source: src/main/java/onetomany/bargainingchipsgame/Bundle.java@ 271

/**
 * Bundle class
 */
package onetomany.bargainingchipsgame;

import java.util.List;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;

/**
 * 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.  
 * Aggregation of a bundle with the empty stack or empty bundle is itself.  
 * 
 * @author Faria Nassiri-Mofakham
 *
 */
public class Bundle implements Iterable<Stack>
{
        private List<Stack> bundle;

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

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


        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 Iterator<Stack> iterator() 
        {
                return bundle.iterator();   
        }       


        public Double getPrice()
        {
                double sum=0.0;
                for (Stack t: bundle)
                        sum += t.getPrice();
                return sum;
        }

        /**
         * 
         * 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 (without calling aggregate with stack, below !
        {
                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.getColor()==s.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;
        }


        // previous try for calling two methods both with using iterators

        /**
         *      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) //loop over bundle b stacks
                                this.aggregateWith333(s);  //aggregate stacks of b into `this' bundle by calling aggregateWith(stack), below
                }
                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 aggregateWith333(Stack s) 
        {
                Bundle b=new Bundle();

                if (s!=null && this!=null) 
                {
                        Boolean f=Boolean.FALSE; //flag for stack s added
                
                        for (Stack t : bundle) //loop over `this' bundle stacks
                        {                       
                                if (t.hasSameColorAs(s)) //if the stacks t and s are of the same colors
                                {
                                        System.out.println("\n hey it is t "+t+" and it is s "+s);
                                        b.addStack(s.aggregateWith(t)); //aggregate stacks t and s and then add to the new bundle
                                        System.out.println("\n hey1 it is b "+b);
                                        f=true;
                                }
                                else 
                                        {b.addStack(t); // so put the stack of `this' bundle directly into the new bundle
                                        System.out.println("\n hey2 it is b "+b);

                                        }
                        }
                        if (!f) //s not aggregated with any stack in `this' bundle 
                                {b.addStack(s);  // so put stack s directly into the new bundle
                                System.out.println("\n hey3 it is b "+b);
                                }
                        return b;
                }
                return b;       
        }



}