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

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

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;
        }

        /**
         * @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 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
                                l.aggregateWith333(s);  //aggregate stacks of b into `this' bundle by calling aggregateWith(stack), below
                        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 aggregateWith333(Stack s) 
        {
                if (s!=null && this!=null) 
                {
                        Bundle b=new Bundle();
                        Boolean f=Boolean.FALSE; //flag for stack s added

                        for (Stack t : this.getBundle()) //loop over `this' bundle stacks
                        {
                                if (t.getColor()==s.getColor()) //if the stacks t and s are of the same colors
                                {
                                        b.addStack(t.aggregateWith(s)); //aggregate stacks t and s and then add to the new bundle
                                        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;    
        }



}