source: events/src/main/java/geniusweb/inform/Agreements.java@ 22

package geniusweb.inform;

import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.JsonAutoDetect.Visibility;
import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonValue;

import geniusweb.actions.PartyId;
import geniusweb.issuevalue.Bid;

/**
 * There can be multiple agreements from a single negotiation. This object
 * contains the agreements. Each party can agree only on 1 bid and there are
 * always at least 2 parties agreeing on a bid.
 */
@JsonAutoDetect(fieldVisibility = Visibility.ANY, getterVisibility = Visibility.NONE, setterVisibility = Visibility.NONE)
public class Agreements {
        @JsonValue
        private final Map<PartyId, Bid> agreements;

        public Agreements() {
                this.agreements = Collections.emptyMap();
        }

        @JsonCreator
        private Agreements(Map<PartyId, Bid> agrees) {
                this.agreements = agrees;
        }

        /**
         * @param other {@link Agreements}
         * @return a new Agreement containing this plus other agreements
         * @throws IllegalArgumentException if parties in other are already in this
         *                                  agreement.
         */
        public Agreements with(Agreements other) {
                Map<PartyId, Bid> newagrees = new HashMap<>(agreements);
                for (PartyId pid : other.agreements.keySet()) {
                        if (newagrees.containsKey(pid))
                                throw new IllegalArgumentException(
                                                "party " + pid + " already has agreement");
                        newagrees.put(pid, other.agreements.get(pid));
                }
                return new Agreements(newagrees);
        }

        /**
         * @param bid
         * @param parties
         * @return new Agreements, with the new bid/parties added.
         */
        public Agreements with(Bid bid, Set<PartyId> parties) {
                if (parties.size() < 2) {
                        throw new IllegalArgumentException(
                                        "Agreement must contain at least 2 parties");
                }
                Map<PartyId, Bid> newagreements = new HashMap<>(agreements);
                for (PartyId party : parties) {
                        if (agreements.containsKey(party)) {
                                throw new IllegalArgumentException(
                                                "A party can agree only on 1 bid");
                        }
                        newagreements.put(party, bid);
                }
                return new Agreements(newagreements);
        }

        /**
         * @return actual agreemenets contained here
         */
        public Map<PartyId, Bid> getMap() {
                return Collections.unmodifiableMap(agreements);
        }

        @Override
        public String toString() {
                return "Agreements" + agreements;
        }

        @Override
        public int hashCode() {
                final int prime = 31;
                int result = 1;
                result = prime * result
                                + ((agreements == null) ? 0 : agreements.hashCode());
                return result;
        }

        @Override
        public boolean equals(Object obj) {
                if (this == obj)
                        return true;
                if (obj == null)
                        return false;
                if (getClass() != obj.getClass())
                        return false;
                Agreements other = (Agreements) obj;
                if (agreements == null) {
                        if (other.agreements != null)
                                return false;
                } else if (!agreements.equals(other.agreements))
                        return false;
                return true;
        }

}