source: src/main/java/genius/core/Bid.java@ 126

package genius.core;

import java.util.List;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

import java.io.Serializable;

import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlElementRef;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.adapters.XmlAdapter;
import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter;

import genius.core.analysis.pareto.IssueValue;
import genius.core.issue.Issue;
import genius.core.issue.Value;

/**
 * A bid is a set of tuples [idnumber,value], where idnumber is the unique
 * number of the issue, and value is the picked alternative.
 * <p>
 * Bid is a immutable. But you can create modified copies using
 * {@link #putValue(int, Value)}.
 * 
 * Bid should be considered final so do not extend this.
 * 
 * @author Dmytro Tykhonov, Koen Hindriks
 */
@XmlRootElement
public class Bid implements Serializable {

        /**
         * 
         */
        private static final long serialVersionUID = -7723017380013100614L;

        private final Domain fDomain;

        /**
         * the bid values for each IssueID
         */
        @XmlElement(name = "values")
        @XmlJavaTypeAdapter(MyMapAdapter.class)
        private HashMap<Integer, Value> fValues;

        /**
         * Only for (de)serialization
         */
        private Bid() {
                fDomain = null; // keep Java happy. Serializer shall overwrite anyway
        }

        /**
         * Create a new empty bid of which the values still must be set.
         * 
         * @param domain
         *            the domain for this bid
         */
        public Bid(Domain domain) {
                fDomain = domain;
                fValues = new HashMap<Integer, Value>();
        }

        /**
         * createFrom a new bid in a domain. There is only this constructor because we require that ALL
         * values in the domain get assigned a value.
         * 
         * @param domainP
         *            the domain in which the bid is done
         * @param bidP
         *            HashMap, which is a set of pairs [issueID,value]
         */
        public Bid(Domain domainP, HashMap<Integer, Value> bidP) {
                this.fDomain = domainP; 
                fValues = bidP;
        }

        /**
         * create bid from set of {@link IssueValue}s
         * 
         * @param domain
         *            the {@link Domain}
         * @param values
         *            a {@link Collection} of {@link IssueValue}s
         */
        public Bid(Domain domain, Collection<IssueValue> values) {
                if (domain == null)
                        throw new NullPointerException("null domain");
                if (values == null)
                        throw new NullPointerException("null values");

                this.fDomain = domain;
                fValues = new HashMap<>();
                for (IssueValue iv : values) {
                        fValues.put(iv.getIssue().getNumber(), iv.getValue());
                }
        }

        /**
         * This method clones the given bid.
         * 
         * @param bid
         *            the bid to clone
         */
        public Bid(Bid bid) {

                fDomain = bid.fDomain;
                fValues = (HashMap<Integer, Value>) bid.fValues.clone();
        }

        /**
         * @param issueNr
         *            number of an issue.
         * @return the picked value for given issue idnumber
         * @throws IllegalArgumentException
         *             if there exist no issue with the given number.
         */
        public Value getValue(int issueNr) {
                Value v = fValues.get(issueNr);
                if (v == null) {
                        if (fDomain.getIssues().get(issueNr) == null)
                                throw new IllegalArgumentException("Bid.getValue: issue " + issueNr + " does not exist at all");
                        throw new IllegalStateException("There is no evaluator for issue " + issueNr);
                }
                return v;
        }

        /**
         * @param issueId
         *            unique ID of an issue.
         * @param pValue
         *            value of the issue.
         * @return new Bid as the current bid but with the value of the issue with
         *         the given issueID to the given value
         * @throws IllegalArgumentException
         *             if there exist no issue with the given number.
         */
        public Bid putValue(int issueId, Value pValue) {
                if (fValues.get(issueId).getType() != pValue.getType()) {
                        // FIXME
                        // if (fDomain.getIssue(issueId).getType() != pValue.getType()) {
                        throw new IllegalArgumentException("expected value of type " + fDomain.getIssues().get(issueId).getType()
                                        + " but got " + pValue + " of type " + pValue.getType());
                }
                HashMap<Integer, Value> newValues = new HashMap<Integer, Value>(fValues);
                newValues.put(issueId, pValue);
                return new Bid(fDomain, newValues);
        }

        public String toString() {
                String s = "Bid[";
                Set<Entry<Integer, Value>> value_set = fValues.entrySet();
                Iterator<Entry<Integer, Value>> value_it = value_set.iterator();
                int i = 0;
                while (value_it.hasNext()) {
                        int ind = ((Entry<Integer, Value>) value_it.next()).getKey();
                        Object tmpobj = fDomain.getObjectivesRoot().getObjective(ind);
                        if (tmpobj != null) {
                                String issueName = fDomain.getObjectivesRoot().getObjective(ind).getName();
                                s += (i++ > 0 ? ", " : "") + issueName + ": " + fValues.get(ind);
                        } else {
                                System.out.println("objective with index " + ind + " does not exist");
                        }
                }
                s = s + "]";
                return s;
        }

        /**
         * @param pBid
         *            to which this bid must be compared.
         * @return true if the values of this and the given bid are equal.
         */
        public boolean equals(Bid pBid) {
                if (pBid == null)
                        return false;
                return fValues.equals(pBid.fValues);
        }

        /*
         * (non-Javadoc)
         * 
         * @see java.lang.Object#equals(java.lang.Object)
         */
        @Override
        public boolean equals(Object obj) {
                if (obj instanceof Bid)
                        return equals((Bid) obj);
                return false;
        }

        /**
         * @return a (copy of ) the list of all values in this bid. FIXME we really
         *         should return an immutable {@link Map} here but that may break
         *         many agents.
         */

        public HashMap<Integer, Value> getValues() {
                return new HashMap<Integer, Value>(fValues);
        }

        // Reyhan: add this method
        public List<Issue> getIssues() {
                return fDomain.getIssues();
        }

        public Domain getDomain() {
                return fDomain;
        }
        
        /**
         * Counts the number of equal values with another bid (assuming they are defined on the same domain)
         */
        public int countEqualValues(Bid b)
        {
                int count = 0;
                for (Integer v : fValues.keySet())
                {
                        if (this.fValues.get(v).equals(b.fValues.get(v)))
                                count++;
                }
                return count;
        }

        @Override
        public int hashCode() {
                int code = 0;
                for (Entry<Integer, Value> lEntry : fValues.entrySet()) {
                        code = code + lEntry.getValue().hashCode();
                }
                return code;// fValues.hashCode();
        }

}

class MyMapAdapter extends XmlAdapter<Temp, Map<Integer, Value>> {

        @Override
        public Temp marshal(Map<Integer, Value> arg0) throws Exception {
                Temp temp = new Temp();
                for (Entry<Integer, Value> entry : arg0.entrySet()) {
                        temp.entry.add(new Item(entry.getKey(), entry.getValue()));
                }
                return temp;
        }

        @Override
        public Map<Integer, Value> unmarshal(Temp arg0) throws Exception {
                Map<Integer, Value> map = new HashMap<Integer, Value>();
                for (Item item : arg0.entry) {
                        map.put(item.key, item.value);
                }
                return map;
        }

}

class Temp {
        @XmlElement(name = "issue")
        public List<Item> entry;

        public Temp() {
                entry = new ArrayList<Item>();
        }

}

@XmlRootElement
class Item {
        @XmlAttribute(name = "index")
        public Integer key;

        @XmlElementRef
        public Value value;

        public Item() {
        }

        public Item(Integer key, Value val) {
                this.key = key;
                this.value = val;
        }
}