source: src/main/java/bargainingchips/players/Agent.java@ 341

package bargainingchips.players;

import java.util.List;

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

import bargainingchips.NegotiationContext;
import bargainingchips.actions.Offer;
import bargainingchips.actions.OfferBy;
import bargainingchips.messaging.coordination.CoordinationMessage;
import bargainingchips.messaging.status.StatusMessage;
import bargainingchips.outcomes.Outcome;
import bargainingchips.utilityfunctions.UtilityFunction;
/**
 * An agent typically has a buyer or seller role and can send an receive offers.
 * An agent has a utility function for evaluating any proposal in a given negotiation context. 
 */
public abstract class Agent implements Runnable         // no comma here
{
        protected final String name;
        protected UtilityFunction u;
        protected NegotiationContext negotiationContext; 
        
        protected int k;
        
        public Agent(String name, UtilityFunction u, NegotiationContext negotiationContext,
                        BlockingQueue<Offer> in, BlockingQueue<OfferBy> out,
                        BlockingQueue<CoordinationMessage> cin, BlockingQueue<StatusMessage> cout) 
        {
                this.name = name;
                this.u = u;
                this.negotiationContext = negotiationContext;
                this.in = in;
                this.out = out;
                this.cin  = cin;
                this.cout = cout;
                k = 0;
        }
        
        // Messaging from and to the opponent
        protected BlockingQueue<Offer> in;
        protected BlockingQueue<OfferBy> out;
        // Messaging from and to the coordinator
        protected BlockingQueue<CoordinationMessage> cin;
        protected BlockingQueue<StatusMessage> cout;
        
        protected abstract void  receiveOffer(Offer bundle);
        
        protected abstract void  receiveOutcome(Outcome outcome);
        
        protected abstract Offer sendOffer();
        
        protected abstract Offer sendOpeningOffer();
        
        protected abstract void  receiveCoordinationMessage(CoordinationMessage cpoll); 
        
        protected abstract StatusMessage sendStatusMessage();
        
        @Override
        public void run() 
        {
                // A buyer may send an opening offer
                Offer opening = do_sendOpeningOffer();
                if (opening != null)
                        try {
                                out.put(new OfferBy(name, opening));
                        } catch (InterruptedException e1) {
                                e1.printStackTrace();
                        }
                
                while (true)
                {
                        try 
                        {
                                /* Wait for the messages from coordinator or an incoming offer from seller.
                                 * There may be multiple messages waiting. The agent should process them all.
                                 * The agent can choose itself how to handle multiple messages (e.g. only
                                 * use the last one).
                                 */
                                while (true)
                                {
                                        List<CoordinationMessage> coordinationMessages = new ArrayList<CoordinationMessage>();
                                        int messageNo = cin.drainTo(coordinationMessages);
                                        
                                        if (messageNo > 0)
                                        {
                                                for (CoordinationMessage cm: coordinationMessages)
                                                        do_receiveCoordinationMessage(cm);
                                                break;
                                        }
                                        
                                        List<Offer> offers = new ArrayList<Offer>();
                                        int offersNo = in.drainTo(offers);
                                        
                                        if (offersNo > 0)
                                        {
                                                for (Offer o: offers)
                                                        if (o.isEnd())
                                                        {
                                                                do_receiveOutcome((Outcome) o);         // the offer codes that the negotiation ended in an outcome
                                                                return;
                                                        }
                                                        else
                                                                do_receiveOffer(o);
                                                break;
                                        }
                                }
                                
                                // A sync happened, so we can send out a new offer, given the new information
                                Offer sendOffer = do_sendOffer();
                                out.put(new OfferBy(name, sendOffer));
                                
                                // Pause
                                Thread.sleep(500);
//                              Thread.sleep(500 + (int)(Math.random() * 1000));
                        } 
                        catch (InterruptedException e) {
                                e.printStackTrace();
                        }
                }
        }

        private void do_receiveOutcome(Outcome o) 
        {
                System.out.println(this + " received a message that an outcome was reached: " + o);
                receiveOutcome(o);              
        }

        private void do_receiveCoordinationMessage(CoordinationMessage cpoll) 
        {
                System.out.println(this + " received coordination msg " + cpoll);
                receiveCoordinationMessage(cpoll);
        }

        protected void do_receiveOffer(Offer o) 
        {
                System.out.println(this + " received " + o 
                                + (o.isBid() ? (", with util = " + u.getUtility(o.getBundle())) : "") 
                                );
                receiveOffer(o);                
        }

        protected Offer do_sendOffer()
        {
                Offer o = sendOffer();
                System.out.println(this + " sends " + o);
                k++;            
                return o;
        }
        
        protected Offer do_sendOpeningOffer() 
        {
                Offer o = sendOpeningOffer();
                if (o != null)
                {
                        System.out.println(this + " sends opening offer " + o);
                        k++;
                }
                return o;
        }

        @Override
        public String toString() 
        {
                return "#" + k + ": " + name;
        }
        
        public String toDescription() 
        {
                return name + " with u = " + u;
        }
        
        public String getAgentName()
        {
                return name;
        }
}