source: src/main/java/genius/core/AgentAdapter.java

package genius.core;

import java.util.List;

import java.util.Date;
import java.util.HashMap;
import java.util.Map;

import genius.core.actions.Accept;
import genius.core.actions.Action;
import genius.core.actions.EndNegotiation;
import genius.core.actions.Offer;
import genius.core.actions.OfferForVoting;
import genius.core.parties.NegotiationInfo;
import genius.core.parties.NegotiationParty;
import genius.core.protocol.MultilateralProtocol;
import genius.core.protocol.StackedAlternatingOffersProtocol;
import genius.core.tournament.VariablesAndValues.AgentParamValue;
import genius.core.tournament.VariablesAndValues.AgentParameterVariable;
import genius.core.utility.AbstractUtilitySpace;

/**
 * Adapts {@link Agent} to the {@link NegotiationParty} so that bilateral agents
 * can be run as a multiparty system. Notice that these agents can
 * handle only 1 opponent, and thus may behave weird if presented with more than
 * one opponent.
 * 
 * What is unusual (in the Java sense) is that Agent extends this, not the other
 * way round. This way, all old agents also become a NegotiationParty.
 * 
 */
@SuppressWarnings("serial")
public abstract class AgentAdapter implements NegotiationParty {

        /**
         * 
         * @return the actual agent that is being adapted.
         */
        abstract protected Agent getAgent();

        private Action lastAction = null;
        private AbstractUtilitySpace utilSpace;

        @SuppressWarnings("deprecation")
        @Override
        public final void init(NegotiationInfo info) {
                this.utilSpace = info.getUtilitySpace();
                getAgent().internalInit(0, 1, new Date(),
                                info.getDeadline().getTimeOrDefaultTimeout(),
                                info.getTimeline(), utilSpace,
                                new HashMap<AgentParameterVariable, AgentParamValue>(),
                                info.getAgentID());
                getAgent().setName(info.getAgentID().toString());
                getAgent().init();
        }

        @SuppressWarnings("deprecation")
        @Override
        public final Action chooseAction(
                        List<Class<? extends Action>> possibleActions) {
                lastAction = getAgent().chooseAction();
                return lastAction;
        }

        @SuppressWarnings("deprecation")
        @Override
        public final void receiveMessage(AgentID sender, Action action) {
                if (action instanceof Offer || action instanceof Accept
                                || action instanceof OfferForVoting
                                || action instanceof EndNegotiation) {
                        getAgent().ReceiveMessage(action);
                }
        }

        /**
         * This is a convenience wrapper so that we don't have to fix all old agent
         * descriptions (these used to be in the xml file)
         */
        @Override
        public String getDescription() {
                return "Agent " + getAgent().getClass().getSimpleName();
        }

        @Override
        public final Class<? extends MultilateralProtocol> getProtocol() {
                return StackedAlternatingOffersProtocol.class;
        }

        @SuppressWarnings("deprecation")
        @Override
        public final Map<String, String> negotiationEnded(Bid acceptedBid) {
                double util = 0;
                if (acceptedBid != null) {
                        try {
                                util = getAgent().getUtility(acceptedBid);
                        } catch (Exception e) {
                        }
                }
                getAgent().endSession(
                                new NegotiationResult(util, lastAction, acceptedBid));
                return null;
        }

}