source: protocol/src/main/java/geniusweb/protocol/session/mopac/phase/OptInPhase.java@ 52

package geniusweb.protocol.session.mopac.phase;

import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonProperty;

import geniusweb.actions.Action;
import geniusweb.actions.EndNegotiation;
import geniusweb.actions.PartyId;
import geniusweb.actions.Votes;
import geniusweb.inform.Agreements;
import geniusweb.inform.Inform;
import geniusweb.inform.OptIn;
import geniusweb.protocol.ProtocolException;
import geniusweb.protocol.session.mopac.PartyStates;
import geniusweb.voting.CollectedVotes;
import geniusweb.voting.VotingEvaluator;

public class OptInPhase extends DefaultPhase {

        /**
         * The votes received in the {@link VotingPhase}
         */
        private final List<Votes> votes;

        @JsonCreator
        protected OptInPhase(@JsonProperty("votes") List<Votes> votes,
                        @JsonProperty("partyStates") PartyStates partyStates,
                        @JsonProperty("deadline") Long deadline,
                        @JsonProperty("evaluator") VotingEvaluator evaluator) {
                super(partyStates, deadline, evaluator);
                this.votes = votes;
                if (votes == null)
                        throw new IllegalArgumentException("votes must be not null");
        }

        @Override
        public Inform getInform() {
                return new OptIn(votes);
        }

        @Override
        public Phase with(PartyId actor, Action action, long now) {
                try {
                        checkAction(actor, action, now);
                        if (action instanceof Votes)
                                checkExtends((Votes) action);

                        return new OptInPhase(votes, partyStates.with(action), deadline,
                                        evaluator);

                } catch (ProtocolException e) {
                        return this.with(e);
                }
        }

        /**
         * Check that this action extends previous action.
         * 
         * @param newvotes new {@link Votes} just received
         * @throws ProtocolException if this action does not correctly extend
         *                           previous vote.
         */
        private void checkExtends(Votes newvotes) throws ProtocolException {
                PartyId actor = newvotes.getActor();
                // this actor is active so he must have voted in previous round.
                Votes prevVotes = votes.stream().filter(v -> v.getActor().equals(actor))
                                .findFirst().get();
                if (!(newvotes.isExtending(prevVotes)))
                        throw new ProtocolException("New votes " + newvotes
                                        + " does not extend previous vote " + prevVotes, actor);
        }

        @Override
        public OptInPhase with(ProtocolException e) {
                return new OptInPhase(votes, partyStates.with(e), deadline, evaluator);
        }

        @Override
        public OptInPhase finish() {
                PartyStates states = partyStates.finish();
                Map<PartyId, Votes> votesmap = states.getActions(Votes.class).stream()
                                .collect(Collectors.toMap(votes -> votes.getActor(), v -> v));
                CollectedVotes allvotes = new CollectedVotes(votesmap,
                                states.getPowers());
                Agreements newAgree = evaluator.create(allvotes).getAgreements();
                if (!newAgree.getMap().isEmpty()) {
                        System.out.println("detected new agreements");
                }
                PartyStates finalStates = states.with(newAgree);

                return new OptInPhase(votes, finalStates, deadline, evaluator);
        }

        @Override
        public OfferPhase checkedNext(long newdeadline) {
                return new OfferPhase(partyStates.flush(), newdeadline, evaluator);
        }

        @Override
        public List<Class<? extends Action>> getAllowedActions() {
                return Arrays.asList(Votes.class, EndNegotiation.class);
        }

        public List<Votes> getVotes() {
                return Collections.unmodifiableList(votes);
        }
}