source: logconverter/src/main/java/geniusweb/logconverter/SessionResultWithUtils.java@ 52

package geniusweb.logconverter;

import java.io.IOException;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.logging.Level;

import javax.websocket.DeploymentException;

import com.fasterxml.jackson.annotation.JsonProperty;

import geniusweb.actions.PartyId;
import geniusweb.inform.Agreements;
import geniusweb.issuevalue.Bid;
import geniusweb.profile.PartialOrdering;
import geniusweb.profile.utilityspace.UtilitySpace;
import geniusweb.profileconnection.ProfileConnectionFactory;
import geniusweb.profileconnection.ProfileInterface;
import geniusweb.protocol.session.SessionResult;
import geniusweb.references.PartyWithProfile;
import geniusweb.references.ProfileRef;
import tudelft.utilities.logging.Reporter;

/**
 * Contains SessionResult including the utilities.
 */
public class SessionResultWithUtils extends SessionResult {

        private final Map<PartyId, BigDecimal> utilities;
        private final static transient Map<ProfileRef, UtilitySpace> profilecache = new HashMap<>();;

        /**
         * 
         * @param res   a {@link SessionResult}
         * @param utils a map of the netto utility (including penalty) by each
         *              party. 0 if not known or invalid.
         */
        public SessionResultWithUtils(
                        @JsonProperty("participants") Map<PartyId, PartyWithProfile> participants,
                        @JsonProperty("agreements") Agreements agreements,
                        @JsonProperty("penalties") Map<PartyId, Double> penalties,
                        @JsonProperty("error") Throwable error,
                        @JsonProperty("utilities") Map<PartyId, BigDecimal> utils) {
                super(participants, agreements, penalties, error);
                this.utilities = new HashMap<>(utils);
                List<PartyId> missed = new ArrayList<PartyId>(participants.keySet());
                missed.removeAll(utils.keySet());
                if (!missed.isEmpty())
                        throw new IllegalArgumentException(
                                        "participants " + missed + " must also get a utility");

        }

        /**
         * adds utility values to a standard SessionResult.
         * 
         * @param res the standard {@link SessionResult}
         * @return a {@link SessionResultWithUtils}. The utilities for of the
         *         agreement are computed using the profile available in the given
         *         {@link SessionResult}. The penalty will be subtracted from this.
         *         Notice that the final value thus can be negative.
         *         <p>
         *         If there is no agreement, the utility of the reservation bid will
         *         be used. If there is no reservation bid, utility is 0.
         *         <p>
         *         If a profile is not a {@link UtilitySpace}, eg the profile is a
         *         {@link PartialOrdering} or is unavailable (eg security
         *         restrictions or server down), the utility will be set to 0.
         *         <p>
         *         Any penalty will be subtracted "as is", so if the penalty is 0.2
         */
        public static SessionResultWithUtils create(SessionResult res,
                        Reporter reporter) {
                Map<PartyId, UtilitySpace> profiles = new HashMap<>();
                Map<PartyId, BigDecimal> utils = new HashMap<>();
                Map<PartyId, Bid> agreements = res.getAgreements().getMap();

                for (PartyId party : res.getParticipants().keySet()) {
                        BigDecimal util = BigDecimal.ZERO;
                        UtilitySpace prof = getProfile(
                                        res.getParticipants().get(party).getProfile(), reporter);
                        if (prof != null) {
                                Bid bid = agreements.get(party);
                                if (bid == null) {
                                        if (prof.getReservationBid() != null)
                                                util = prof.getUtility(prof.getReservationBid());
                                } else {
                                        // check we have profile to avoid repeated errors
                                        util = prof.getUtility(bid);
                                        Double penalty = res.getPenalties().get(party);
                                        if (penalty != null) {
                                                util = util
                                                                .subtract(new BigDecimal(penalty.toString()));
                                        }
                                }
                        }
                        utils.put(party, util);
                }
                return new SessionResultWithUtils(res.getParticipants(),
                                res.getAgreements(), res.getPenalties(), res.getError(), utils);
        }

        /**
         * @param profileref
         * @param reporter
         * @return profile {@link UtilitySpace}, or null if profile can't be
         *         fetched. Profiles are cached to avoid repeated fetching.
         */
        private static UtilitySpace getProfile(ProfileRef profileref,
                        Reporter reporter) {
                UtilitySpace us = null;
                if (!profilecache.containsKey(profileref)) {
                        try {
                                ProfileInterface interf = ProfileConnectionFactory
                                                .create(profileref.getURI(), reporter);
                                us = (UtilitySpace) interf.getProfile();
                        } catch (IOException | DeploymentException e) {
                                e.printStackTrace();
                                reporter.log(Level.WARNING,
                                                "Failed to get profile:" + e.getMessage(), e);
                        }
                        profilecache.put(profileref, us);
                }
                return profilecache.get(profileref);
        }

        /**
         * 
         * @return the netto utility achieved by each party.
         */
        public Map<PartyId, BigDecimal> getUtilities() {
                return utilities;
        }

        @Override
        public String toString() {
                // not so important as toString is mainly for debugging.
                return "SessionResultWithUtils[" + super.toString() + "," + utilities
                                + "]";
        }

        @Override
        public int hashCode() {
                final int prime = 31;
                int result = super.hashCode();
                result = prime * result + Objects.hash(utilities);
                return result;
        }

        @Override
        public boolean equals(Object obj) {
                if (this == obj)
                        return true;
                if (!super.equals(obj))
                        return false;
                if (getClass() != obj.getClass())
                        return false;
                SessionResultWithUtils other = (SessionResultWithUtils) obj;
                return Objects.equals(utilities, other.utilities);
        }

}