source: protocol/src/main/java/geniusweb/protocol/session/learn/LearnState.java@ 31

package geniusweb.protocol.session.learn;

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

import geniusweb.actions.Action;
import geniusweb.actions.LearningDone;
import geniusweb.actions.PartyId;
import geniusweb.inform.Agreements;
import geniusweb.progress.Progress;
import geniusweb.protocol.ProtocolException;
import geniusweb.protocol.session.DefaultSessionState;
import geniusweb.protocol.session.SessionResult;
import geniusweb.references.PartyWithProfile;

/**
 * Stores the state for Learn protocol. Immutable.
 */
public class LearnState extends DefaultSessionState<LearnState, LearnSettings> {

        /**
         * 
         * @param actions       the actions done by the parties
         * @param conns         the existing party connections. we assume ownership
         *                      of this so it should not be modified although
         *                      connections may of course break. If null, default
         *                      empty list is used. Can be less than 2 parties in
         *                      the first phases of the setup.
         * @param progress      the {@link Progress} line. can be null
         * @param settings      the {@link LearnSettings}
         * @param partyprofiles map with the {@link PartyWithProfile} for connected
         *                      parties. null is equivalent to an empty map.
         * @param e             the {@link ProtocolException}, or null if none
         *                      occurred.
         */
        public LearnState(List<Action> actions, List<PartyId> conns,
                        Progress progress, LearnSettings settings,
                        Map<PartyId, PartyWithProfile> partyprofiles, ProtocolException e) {
                super(actions, conns, progress, settings, partyprofiles, e);
        }

        /**
         * Creates the initial state from the given settings and progress=null
         * 
         * @param settings the {@link LearnSettings}
         */
        public LearnState(LearnSettings settings) {
                this(Collections.emptyList(), Collections.emptyList(), null, settings,
                                null, null);

        }

        @Override
        public LearnState with(List<Action> actions, List<PartyId> conns,
                        Progress progr, LearnSettings settings,
                        Map<PartyId, PartyWithProfile> partyprofiles, ProtocolException e) {
                return new LearnState(actions, conns, progr, settings, partyprofiles,
                                e);
        }

        @Override
        public Agreements getAgreements() {
                return new Agreements();
        }

        @Override
        public SessionResult getResult() {
                return new SessionResult(getPartyProfiles(), getAgreements(),
                                Collections.emptyMap(), null);
        }

        @Override
        public boolean isFinal(long currentTimeMs) {
                Set<PartyId> done = getDoneLearning();
                // if done is empty we're probably still starting up.
                return super.isFinal(currentTimeMs)
                                || (!done.isEmpty() && done.containsAll(getConnections()));
        }

        /**
         * 
         * @param e the error that occured
         * @return a new state with the error set.
         */
        @Override
        public LearnState with(ProtocolException e) {
                return new LearnState(getActions(), getConnections(), getProgress(),
                                getSettings(), getPartyProfiles(), e);
        }

        @Override
        public LearnSettings getSettings() {
                return super.getSettings();
        }

        /**
         * 
         * @param actor  the known real actor that did this action
         * @param action an {@link Action}
         * @return null if action seems ok, or message explaining why not.
         */
        @Override
        public String checkAction(PartyId actor, Action action) {
                String msg = super.checkAction(actor, action);
                if (msg != null)
                        return msg;
                if (getDoneLearning().contains(actor))
                        return "actor already was done learning";
                if (!(action instanceof LearningDone))
                        return "Action " + action + " is not allowed";
                return null;
        }

        /**
         * 
         * @return set of parties that reported they are done with learning.
         */
        private Set<PartyId> getDoneLearning() {
                return getActions().stream().map(party -> party.getActor())
                                .collect(Collectors.toSet());
        }

}