source: src/main/java/bargainingchips/protocol/BilateralProtocol.java@ 320

package bargainingchips.protocol;

import java.util.List;

import java.util.ArrayList;
import java.util.concurrent.BlockingQueue;

import bargainingchips.actions.Offer;
import bargainingchips.actions.OfferBy;

/**
 * A (possibly asynchronous) protocol between two agents A and B.
 * The protocol acts as the postman of delivering messages between the agents and validates their messages.
 * The protocol keeps the one official (synchronized) log of what has happened.
 */
public abstract class BilateralProtocol implements Runnable
{
        // Messaging to and from A and B
        protected BlockingQueue<Offer> fromA;
        protected BlockingQueue<Offer> toA;
        protected BlockingQueue<Offer> fromB;
        protected BlockingQueue<Offer> toB;
                
        protected List<OfferBy> log;
        
        public BilateralProtocol(BlockingQueue<Offer> fromA,
                        BlockingQueue<Offer> toA, BlockingQueue<Offer> fromB,
                        BlockingQueue<Offer> toB) {
                super();
                this.fromA = fromA;
                this.toA = toA;
                this.fromB = fromB;
                this.toB = toB;
                this.log = new ArrayList<OfferBy>();
        }

        protected abstract ValidationResult validate(OfferBy o);
        
        @Override
        public void run() 
        {
                String sender = "A";
                
                // Wait for a message from A or B
                try {
                        while (true)
                        {
                                BlockingQueue<Offer> from = from(sender);       // starts with A
                                BlockingQueue<Offer> to   = to(sender);         // starts with B
                                
                                Offer o = from.poll();
                                
                                if (o != null)
                                {
                                        OfferBy ob = new OfferBy(sender, o);
                                        ValidationResult validationResult = validate(ob);
                                        if (validationResult.isValid())         // if the offer was valid
                                        {
                                                log(ob);
                                                to.put(o);
                                        }
                                        else // drop!
                                                System.err.println("Warning: " + ob + " was not a valid offer and was dropped. Log: " + log.toString());
                                        
                                        // The validation could result in a state where the negotiation ended. 
                                        // We have an outcome, we let the agents know and clean up
                                        if (validationResult.hasEnded())
                                        {
                                                Offer finalOutcome = validationResult.getOutcome();
                                                toA.put(finalOutcome);
                                                toB.put(finalOutcome);
                                                System.out.println("Protocol detected final outcome: " + finalOutcome + 
                                                                ". Notified agents and quitting.");
                                                return;
                                        }
                                }

                                // Swap the queue to check: A <-> B
                                sender = swapRole(sender, "A", "B");
                        }
                } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                }
        }

        private String swapRole(String x, String y, String z) 
        {
                return x.equals(y) ? z : y;
        }
        
        private BlockingQueue<Offer> from(String sender) 
        {
                return "A".equals(sender) ? fromA : fromB;
        }
        
        private BlockingQueue<Offer> to(String sender) 
        {
                return "A".equals(sender) ? toB : toA;
        }

        private void log(OfferBy ob) 
        {
                log.add(ob);
                System.out.println("Logged: " + ob);
        }
        
        protected OfferBy getLastOffer()
        {
                return log.get(log.size() - 1);
        }       

}