source: src/test/java/boaexample/BoaPartyExample.java@ 169

package boaexample;

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

import negotiator.boaframework.opponentmodel.HardHeadedFrequencyModel;

import genius.core.boaframework.AcceptanceStrategy;
import genius.core.boaframework.BoaParty;
import genius.core.boaframework.OMStrategy;
import genius.core.boaframework.OfferingStrategy;
import genius.core.boaframework.OpponentModel;
import genius.core.utility.AbstractUtilitySpace;

/**
 * This example shows how BOA components can be made into an independent negotiation party.
 * 
 * Note that this is equivalent to adding a BOA party via the GUI by selecting the components and parameters.
 * However, this method gives more control over the implementation, as the agent designer can
 * choose to override behavior (such as handling preference uncertainty).
 */
public class BoaPartyExample extends BoaParty
{
        // The choice for each component is made here
        private static AcceptanceStrategy acceptanceStrategy()  {return new AC_Next();}
        private static OfferingStrategy offeringStrategy()              {return new TimeDependent_Offering();}
        private static OpponentModel opponentModel()                    {return new HardHeadedFrequencyModel();}
        private static OMStrategy opponentModelStrategy()               {return new BestBid();}
        
        // All component parameters can be set below. Static initialization is used purely for convenience as the
        // constructor call to super() needs to be the first statement
        private static Map<String, Double> acParams()                   {return new HashMap<String, Double>();}
        private static Map<String, Double> omParams()                   {return new HashMap<String, Double>();}
        private static Map<String, Double> omsParams()                  {return new HashMap<String, Double>();}

        // Set the concession parameter "e" for the offering strategy to yield Boulware-like behavior
        private static Map<String, Double> osParams()                   
        {
                HashMap<String, Double> osParams = new HashMap<String, Double>();
                osParams.put("e", 0.2);
                return osParams;
        }
        
        public BoaPartyExample() 
        {
                // This initializes all the components of this party to the choices defined above
                super(acceptanceStrategy(), acParams(), 
                                offeringStrategy(), osParams(),
                                opponentModel(), omParams(), 
                                opponentModelStrategy(), omsParams());
        }
        
        // All the rest of the functionality is defined by the BOA framework

        /**
         * Specific functionality, such as the estimate of the utility space in the face of preference uncertainty,
         * can be specified by overriding the default behavior.
         */
        @Override
        public AbstractUtilitySpace estimateUtilitySpace() 
        {
                return super.estimateUtilitySpace();
        }

}