source: boa/src/main/java/geniusweb/boa/DefaultBoa.java@ 52

package geniusweb.boa;

import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.logging.Level;

import geniusweb.actions.Action;
import geniusweb.boa.acceptancestrategy.AcceptanceStrategy;
import geniusweb.boa.biddingstrategy.BiddingStrategy;
import geniusweb.inform.ActionDone;
import geniusweb.inform.Finished;
import geniusweb.inform.Inform;
import geniusweb.inform.Settings;
import geniusweb.inform.YourTurn;
import geniusweb.opponentmodel.OpponentModel;
import geniusweb.party.Capabilities;
import geniusweb.party.DefaultParty;
import geniusweb.profile.utilityspace.LinearAdditive;
import geniusweb.profileconnection.ProfileConnectionFactory;
import geniusweb.profileconnection.ProfileInterface;
import tudelft.utilities.logging.Reporter;

/**
 * Default behaviour for Boa-style parties
 */
public abstract class DefaultBoa extends DefaultParty {

        private BoaState boaState;
        private ProfileInterface profileint = null;
        private BiddingStrategy biddingStrat = null;
        private AcceptanceStrategy acceptanceStrat = null;

        public DefaultBoa() {
                super();
                boaState = initialState();
        }

        public DefaultBoa(Reporter reporter) {
                super(reporter); // for debugging
                boaState = initialState();
        }

        /**
         * This only supports SAOP protocol because it is not clear how the
         * BiddingStrategy could be made more general without basically becoming a
         * full Party.
         * 
         */
        @Override
        public Capabilities getCapabilities() {
                /*
                 * At this moment only SAOP is supported by BOA. To support others, the
                 * components also need to get capabilities. FIXME limiting this to
                 * linearadditive may be overly restrictive #1871
                 */
                return new Capabilities(new HashSet<>(Arrays.asList("SAOP")),
                                Collections.singleton(LinearAdditive.class));
        }

        /**
         * Impementation of generic BOA behaviour.
         */
        @Override
        public void notifyChange(Inform info) {
                try {
                        if (info instanceof Settings) {
                                /*
                                 * this should be first call. We can not yet create the state
                                 * because we need to wait for the profile fetch.
                                 */
                                Settings settings = (Settings) info;
                                Class<? extends OpponentModel> omClass = getOpponentModel(
                                                settings);
                                biddingStrat = getBiddingStrategy(settings);
                                acceptanceStrat = getAccceptanceStrategy(settings);
                                boaState = boaState.with(settings, omClass);
                                this.profileint = ProfileConnectionFactory
                                                .create(settings.getProfile().getURI(), getReporter());
                                return;
                        }

                        // Beyond this point we should have a profile
                        if (boaState.getProfile() == null) {
                                boaState = boaState.with(this.profileint.getProfile());
                        }

                        if (info instanceof ActionDone) {
                                boaState = boaState.with(((ActionDone) info).getAction());
                        } else if (info instanceof YourTurn) {
                                getConnection().send(getAction());
                                // we will receive ActionDone and update state then
                        } else if (info instanceof Finished) {
                                getReporter().log(Level.INFO, "Final ourcome:" + info);
                                terminate();
                        }
                } catch (Exception e) {
                        getReporter().log(Level.SEVERE, "Failed to handle info " + info, e);
                        // keep running, still hoping to get Finished callback at the end
                }

        }

        /**
         * 
         * @return current {@link BoaState}
         */
        public BoaState getState() {
                return boaState;
        }

        /**
         * Overridable getter for the acceptance strategy. Override if you want to
         * hard code a {@link BoaParty} behaviour
         * 
         * @param settings the {@link Settings}
         * @return the {@link OpponentModel} class to use for modeling opponents
         * @throws InstantiationFailedException if the requested opponent model can
         *                                      not be loaded
         */
        abstract protected Class<? extends OpponentModel> getOpponentModel(
                        Settings settings) throws InstantiationFailedException;

        /**
         * Overridable getter for the acceptance strategy. Override if you want to
         * hard code a {@link BoaParty} behaviour
         * 
         * @param settings the {@link Settings}
         * @return the {@link BiddingStrategy} to use for determining the next
         *         {@link Action}
         * @throws InstantiationFailedException if the requested opponent model can
         *                                      not be loaded
         */
        abstract protected BiddingStrategy getBiddingStrategy(Settings settings)
                        throws InstantiationFailedException;

        /**
         * Overridable getter for the acceptance strategy. Override if you want to
         * hard code a {@link BoaParty} behaviour
         * 
         * @param settings the {@link Settings}
         * @return the {@link AcceptanceStrategy} to use for determining if a bid is
         *         acceptable
         * @throws InstantiationFailedException if the requested opponent model can
         *                                      not be loaded
         */
        abstract protected AcceptanceStrategy getAccceptanceStrategy(
                        Settings settings) throws InstantiationFailedException;

        /**
         * Factory method to create initial state. Override to insert mock
         * 
         * @return initial BoaState
         */
        protected BoaState initialState() {
                return new BoaState(getReporter());
        }

        private Action getAction() {
                Action proposedAction = biddingStrat.getAction(boaState);
                return acceptanceStrat.filter(proposedAction, boaState);
        }

}