source: src/main/java/negotiator/onetomany/domain/Bundle.java@ 233

/**
 * Bundle class
 */
package negotiator.onetomany.domain;

import java.util.ArrayList;
import java.util.List;

/**
 * Offers are exchanged in Bundle formats.
 * A Bundle is a set of several stacks, {s_1, ..., s_n}, where no two stacks are of the same color.
 * A stack can be aggregated into a bundle if at the same color of one of the Bundle's stacks. 
 * Two bundles can also be aggregated into a new bundle, where every two stacks of the same colors from both bundles are aggregated into one stack in the new bundle.  
 * That is, any t_j from the second stack is aggregated with s_i at the same color from stack 1, i.e., {s_1, ...+s_(i-1), s_i + t_j, s_(i+1), ..., s_n}.
 * Aggregation of a bundle with the empty stack or empty bundle is itself.  
 * 
 * @author Faria Nassiri-Mofakham
 *
 */
public class Bundle {
        private List<Stack> bundle;

        public Bundle() 
        {
                this.bundle = new ArrayList<Stack>();
        }

        /**
         * @return the bundle
         */
        public List<Stack> getBundle() {
                return bundle;
        }

        /**
         * @param b the bundle to set
         */
        public void setBundle(List<Stack> b) {
                this.bundle = b;
        }

        public void addStack(Stack s) 
        {
                bundle.add(s);
        }

        @Override
        public String toString() 
        {
                return bundle.toString();
        }

        public int size()
        {
                if (bundle != null)
                {
                        return getBundle().size();
                }
                else return 0;          
        }

        public Stack getStack(int i)
        {
                return getBundle().get(i);
        }

        public Stack iterator()  // stack or List<stack>
        {
                Stack s=null;
                if (this!=null)
                        for (int i=0; i<this.size();i++)
                                s = bundle.get(i);
                return s;   // this just returns the last one, a stack, not a list!
        }       

//      /**
//       * @param s, this method adds stack s to `this' bundle
//       * @return the aggregated bundle
//       * where, stack s is aggregated with a stack of the same color in `this' bundle and the new stack is added into the new bundle;
//       * otherwise, stack s is just added into the new bundle.
//       */
//      public Bundle aggregateWith(Stack s) 
//      {
//              if (s!=null) 
//              {
//                      Bundle b=new Bundle();
//                      Boolean f=false; //stack s not aggregated yet
//                      if (this!=null)
//                      {
//                              Stack t=new Stack(); //stacks of `this' bundle
//                              for (int i=0; i<this.size();i++)
//                              {
//                                      t=this.getStack(i);
//                                      if (f || (t.getChip().getColor()!=s.getChip().getColor()) )                                             
//                                      {       
//                                              b.addStack(t); 
//                                              System.out.println("\nPOINT1-0:BundleClass:aggregateWith(stack), produced bundle "+b);                          
//                                      }
//                                      else
//                                      {
//                                              b.addStack(t.aggregateWith(s)); 
//                                              f=true; // stack s was aggregated with stack t of `this' bundle into new bundle b
//                                              System.out.println("\nPOINT1-00:BundleClass:aggregateWith(stack), produced bundle "+b);                         
//                                      }
//                              }
//                      }
//                      if (!f || (this==null)) 
//                              b.addStack(s); 
//                      System.out.println("\nPOINT1:BundleClass:aggregateWith(stack), produced bundle "+b);                            
//                      return b;
//              }
//              return this;
//      }
//
//      /**
//       * @param b, this method adds bundle b to `this' bundle
//       * @return the aggregated bundle
//       * where, any two stacks of the same colors are aggregated as a new stack into the new bundle, otherwise, they are just added into the new bundle.
//       */
//      public Bundle aggregateWith(Bundle b) 
//      {
//              System.out.println("\nPOINT2:BundleClass:aggregateWith(Bundle)method, `this' is: "+this+"\nand b is: "+b);
//              if (b!=null)
//              {
//                      Bundle l=new Bundle();
//                      Stack s=new Stack(); //stacks of bundle b
//                      for (int i=0; i<b.size();i++) // i over stacks of bundle b
//                      {
//                              s=b.getStack(i);
//                              if (this!=null)
//                              {
//                                      l.aggregateWith(s);
//                                      System.out.println("\nPOINT3-0:BundleClass:aggregateWith(Bundle)method, produced bundle is "+l);
//                              }
//                              else
//                                      l.addStack(s);
//                              System.out.println("\nPOINT3:BundleClass:aggregateWith(Bundle)method, produced bundle is "+l);
//                      }
//                      return l;
//              }
//              return this;
//      }
        
        /**
         * @param s, this method adds stack s to `this' bundle
         * @return the aggregated bundle
         * where, stack s is aggregated with a stack of the same color in `this' bundle and the new stack is added into the new bundle;
         * otherwise, stack s is just added into the new bundle.
         */
        public Bundle aggregateWith(Stack s) 
        {
                if (s!=null) 
                {
                        Bundle b=new Bundle();
                        Boolean f=false; //stack s not aggregated yet
                        if (this!=null) 
                        {
                                Stack t=new Stack(); //stacks of `this' bundle
                                for (int i=0; i<this.size();i++)
                                {
                                        t=this.getStack(i);
                                        if (f || (t.getChip().getColor()!=s.getChip().getColor()) )             // if stack s already aggregated into new bundle (i.e., f=true), next stacks of `this' bundle still would be added to the new bundle                            
                                        {       
                                                b.addStack(t); 
                                                System.out.println("\nPOINT1-0:BundleClass:aggregateWith(stack), produced bundle "+b);                          
                                        }
                                        else
                                                if (t.getChip().getColor()!=s.getChip().getColor())
                                                {
                                                        b.addStack(t.aggregateWith(s)); 
                                                        f=true; // stack s was aggregated with stack t of `this' bundle into new bundle b
                                                        System.out.println("\nPOINT1-00:BundleClass:aggregateWith(stack), produced bundle "+b);                         
                                                }
                                }
                                if (!f) 
                                {
                                        b.addStack(s);
                                        f=true; // stack s was aggregated with stack t of `this' bundle into new bundle b       
                                        System.out.println("\nPOINT1-000:BundleClass:aggregateWith(stack), produced bundle "+b);                                                        
                                }
                                return b;               
                        }
                        this.addStack(s); //`this' bundle will no longer be null; stack s is added 
                        f=true; // stack s was aggregated into `this' bundle    
                        System.out.println("\nPOINT1:BundleClass:aggregateWith(stack), produced bundle "+b);                                                                                                                    
                }
                return this;
        }

        /**
         * @param b, this method adds bundle b to `this' bundle
         * @return the aggregated bundle
         * where, any two stacks of the same colors are aggregated as a new stack into the new bundle, otherwise, they are just added into the new bundle.
         */
        public Bundle aggregateWith(Bundle b) 
        {
                System.out.println("\nPOINT2:BundleClass:aggregateWith(Bundle)method, `this' is: "+this+"\nand b is: "+b);
                if (b!=null)
                {
                        Bundle l=new Bundle();
                        Stack s=new Stack(); //stacks of bundle b
                        for (int i=0; i<b.size();i++) // i over stacks of bundle b
                        {
                                s=b.getStack(i);
                                if (this!=null)
                                {
                                        l.aggregateWith(s);
                                        System.out.println("\nPOINT3-0:BundleClass:aggregateWith(Bundle)method, produced bundle is "+l);
                                }
                                else
                                        l.addStack(s);
                                System.out.println("\nPOINT3:BundleClass:aggregateWith(Bundle)method, produced bundle is "+l);
                        }
                        return l;
                }
                return this;
        }
}