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

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

import java.awt.Color;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import negotiator.onetomany.Product;

/**
 * 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 s=null;
                if (this!=null)
                        for (int i=0; i<this.size();i++)
                                s = bundle.get(i);
                return s;   
        }       


        /**
         * 
         * bundle "+" bundle 
         * 
         * @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.
         * 
         * This method just calls stack '+' stack aggregation operation (has no need to bundle "+" stack aggregation operation. 
         */
        public Bundle aggregateWith(Bundle b) //This WORKED WELL although it is not in nice programming style!
        {
                if (b!=null && this!=null)
                {
                        Bundle l=new Bundle();          
                        Boolean[] f1 = new Boolean[b.size()]; //flag for b bundle stack added
                        Arrays.fill(f1, Boolean.FALSE);
                        Boolean[] f2 = new Boolean[this.size()]; //flag for `this' bundle stack added
                        Arrays.fill(f2, Boolean.FALSE);


                        for (int i=0;i<b.size();i++) //loop over bundle b stacks
                        {
                                Stack s=b.getStack(i);

                                for (int j=0; j<this.size();j++) //loop over `this' bundle stacks
                                {       
                                        Stack t= this.getStack(j);
                                        if (!f1[i] && !f2[j] && t.getChip().getColor()==s.getChip().getColor())
                                        {
                                                l.addStack(t.aggregateWith(s)); //aggregate these two stacks (b's i-th and this j-th) into the new bundle l
                                                f1[i]=Boolean.TRUE;
                                                f2[j]=Boolean.TRUE;
                                        }
                                }
                                if (!f1[i])
                                        l.addStack(s); // so put i-th stack of bundle b directly into the new bundle
                        }
                        for (int j=0;j<this.size();j++)
                                if (!f2[j])
                                        l.addStack(this.getStack(j)); // so put j-th stack of `this' bundle directly into the new bundle
                        return l;
                }
                return this;
        }

//      /**
//       *      bundle "+" bundle       : second method (nested iterators by the other method), doesn't work correctly.
//       *      
//       * @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.
//       * 
//       * This method calls bundle "+" stack aggregation operation. 
//       */
//      public Bundle aggregateWith333(Bundle b) 
//      {
//              if (b!=null && this!=null)
//              {
//                      Bundle l=new Bundle();          
//
//                      for (Stack s : b.getBundle())
//                      {
//                              l=this.aggregateWith(s);
//                      }
//                      return l;
//              }
//              return this;
//      }
//
//
//
//      /**
//       *      bundle '+' stack
//       *      
//       * @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.
//       * 
//       * This method is called by  
//       */
//      public Bundle aggregateWith(Stack s) 
//      {
//              if (s!=null && this!=null) 
//              {
//                      Bundle b=new Bundle();
//                      Boolean f=false; //flag for s stack added
//
//                      for (Stack t : this.getBundle()) //loop over `this' bundle stacks
//                      {
//                              if (t.getChip().getColor()==s.getChip().getColor())
//                              {
//                                      b.addStack(t.aggregateWith(s));
//                                      f=true;
//                              }
//                              else 
//                                      b.addStack(t); // so put the stack of `this' bundle directly into the new bundle
//                      }
//                      if (!f) //s not aggregated with any stack in `this' bundle 
//                              b.addStack(s);  // so put stack s directly into the new bundle
//                      return b;
//              }
//              return this;    
//      }
}