source: src/main/java/onetomany/bargainingchipsgame/OutcomeSpace.java@ 285

package onetomany.bargainingchipsgame;

import java.util.List;

import java.util.ArrayList;

import onetomany.bargainingchipsgame.players.utilityfunction.UtilityFunction;

/**
 * This class generates the complete outcome space and is therefore useful if
 * someone wants to quickly implement an agent. Note that working with a sorted 
 * outcomespace class would be faster during the negotiation.
 */
public class OutcomeSpace 
{
        /** List of all possible bids in the domain */
        protected List<Bundle> allBids = new ArrayList<Bundle>();

        /**
         * Creates an unsorted outcome space. Warning: this call iterates over ALL
         * possible bids.
         * 
         * @param utilSpace
         */
        public OutcomeSpace(Domain domain) 
        {
                generateAllBids();
        }

        /**
         * Generates all the possible bids in the domain
         * 
         * @param utilSpace
         */
        public void generateAllBids() 
        {
        
        }

        /**
         * @return list of all possible bids
         */
        public List<Bundle> getAllOutcomes() 
        {
                return allBids;
        }
        
        /**
         * gets a BidDetails which is closest to the given utility
         * 
         * @param utility
         *            to which the found bid must be closest.
         * @return BidDetails
         */
        public Bundle getBidNearUtility(double utility, UtilityFunction u) 
        {
                return allBids.get(getIndexOfBidNearUtility(utility, u));
        }

        /**
         * @return best bid in the domain.
         */
        public Bundle getMaxBidPossible(UtilityFunction u) 
        {
                Bundle maxBid = allBids.get(0);
                for (Bundle bid : allBids) {
                        if (u.getUtility(bid) > u.getUtility(maxBid)) {
                                maxBid = bid;
                        }
                }
                return maxBid;
        }

        /**
         * @return worst bid in the domain.
         */
        public Bundle getMinBidPossible(UtilityFunction u) {
                Bundle minBid = allBids.get(0);
                for (Bundle bid : allBids) {
                        if (u.getUtility(bid) < u.getUtility(minBid)) {
                                minBid = bid;
                        }
                }
                return minBid;
        }

        /**
         * @param utility
         *            to which the found bid must be closest.
         * @return index of the bid with the utility closest to the given utilty.
         */
        public int getIndexOfBidNearUtility(double utility, UtilityFunction u) 
        {
                double closesDistance = 1;
                int best = 0;
                for (int i = 0; i < allBids.size(); i++) {
                        if (Math.abs(u.getUtility(allBids.get(i)) - utility) < closesDistance) {
                                closesDistance = Math.abs(u.getUtility(allBids.get(i)) - utility);
                                best = i;
                        }
                }
                return best;
        }

        @Override
        public String toString() {
                String all = "";
                for (Bundle b : allBids) {
                        all += b.toString() + "\n,";
                }
                return "OutcomeSpace[" + all + "]";
        }
}