source: src/main/java/bargainingchips/protocol/AsynchronousOffersProtocol.java@ 340

package bargainingchips.protocol;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

import bargainingchips.actions.Breakoff;
import bargainingchips.actions.Offer;
import bargainingchips.actions.OfferBy;
import bargainingchips.actions.PreAccept;


public class AsynchronousOffersProtocol extends BilateralProtocol 
{
        public AsynchronousOffersProtocol(BlockingQueue<OfferBy> from, String nameA,
                        BlockingQueue<Offer> toA, String nameB, BlockingQueue<Offer> toB) {
                super(from, nameA, toA, nameB, toB);
        }

        /**
         * An offer is valid iff:
         * 1) An offer or walk-away is sent by anyone at any time: $o_{t+1} \in \Omega \cup \{End\}$; or
     * 2) A bid is accepted by the other: $o_{t+1} = Accept$ and $o_{t}\in\Omega$ and $g_t \neq g_{t+1}$; or
     * 3) An accept is acknowledged, concluding the thread: $o_{t+1} = Accept$ and $o_{t} = Accept$ and $o_{t-1} \in \Omega$ and $g_{t-1} = g_{t+1} \neq g_{t}$.
         */     
        @Override
        protected ValidationResult validate(OfferBy curOfferBy) 
        {
                Offer curOffer = curOfferBy.getOffer();
                String curSender = curOfferBy.getSender();
                
                // 1) Offer or breakoff
                
                if (curOffer.isBid())
                        return new ValidationSuccess();
                
                if (curOffer.isBreakoff())
                        return new ValidationSuccessWithDisagreement(); // we are done
                
                // 2) PreAccept of an offer. TODO: check for equality of the contents of the accepts in 2) and 3)
                
                if (log.size() < 1)             // o_t should exist
                        return new ValidationFailure();
                
                OfferBy prevOfferBy = getLastOffer();
                Offer prevOffer = prevOfferBy.getOffer();
                String prevSender = prevOfferBy.getSender();
                
                if (curOffer.isPreAccept() && prevOffer.isBid() && !curSender.equals(prevSender))
                        return new ValidationSuccess();
                
                // 3) FinalAccept of a PreAccept (of an offer)
                
                if (log.size() < 2)             // o_{t-1} should exist
                        return new ValidationFailure();
                
                OfferBy prevprevBy = log.get(log.size() - 2);
                Offer prevprev = prevprevBy.getOffer();
                String prevprevSender = prevprevBy.getSender();
                
                if (curOffer.isFinalAccept() && prevOffer.isPreAccept() 
                                && prevprev.isBid() && prevprevSender.equals(curSender) 
                                && !curSender.equals(prevSender))
                        return new ValidationSuccessWithAgreement(prevprev.getBundle()); // we are done
                
                return new ValidationFailure();
        }
        
        public static void main(String[] args) throws InterruptedException 
        {
                BlockingQueue<OfferBy> from  = new LinkedBlockingQueue<OfferBy>();
                String nameA = "Buyer";
                BlockingQueue<Offer> toA        = new LinkedBlockingQueue<Offer>();
                String nameB = "Seller";
                BlockingQueue<Offer> toB        = new LinkedBlockingQueue<Offer>();
                
                AsynchronousOffersProtocol aop = new AsynchronousOffersProtocol(from, nameA, toA, nameB, toB);
                
                Thread aopThread = new Thread(aop);
                aopThread.start();
                
                from.put(OfferBy.getSampleOffer("Buyer", "Red", 3));
//              Thread.sleep(1000);
                from.put(OfferBy.getSampleOffer("Buyer", "Red", 6));
//              Thread.sleep(1000);
                from.put(new OfferBy("Seller", new PreAccept(Offer.getSampleOffer(6))));
//              Thread.sleep(1000);
//              from.put(new OfferBy("Buyer", new Accept(Offer.getSampleOffer(6))));
                from.put(new OfferBy("Buyer", new Breakoff()));
                
                Thread.sleep(1000);
                System.out.println("Sent to A:" + toA);
                System.out.println("Sent to B:" + toB);
        }
        
        @Override
        public String toString()
        {
                return "Asynchronous Offers Protocol between " + nameA + " and " + nameB;
        }
        

}