source: protocol/src/main/java/geniusweb/protocol/tournament/allpermutations/AllPermutationsState.java@ 39

package geniusweb.protocol.tournament.allpermutations;

import java.math.BigInteger;
import java.util.ArrayList;
import java.util.List;

import geniusweb.protocol.session.SessionResult;
import geniusweb.protocol.session.SessionSettings;
import geniusweb.protocol.tournament.TournamentState;
import tudelft.utilities.immutablelist.ImmutableList;

/**
 * A non-parallel simple implementation of all-permutations
 */
public class AllPermutationsState implements TournamentState {

        protected final AllPermutationsSettings toursettings; // original settings
        protected final ImmutableList<SessionSettings> sessionsettings;
        // limited to MAX_INT elements. But we need to store results anyway
        protected final List<SessionResult> results;

        public AllPermutationsState(AllPermutationsSettings toursettings,
                        ImmutableList<SessionSettings> settings,
                        List<SessionResult> results) {
                this.toursettings = toursettings;
                this.sessionsettings = settings;
                this.results = results;
        }

        public List<SessionResult> getResults() {
                return results;
        }

        @Override
        public boolean isFinal(long currentTimeMs) {
                return sessionsettings.size().intValue() == results.size();
        }

        /**
         * @return the settings for the next session. Null if no such session.
         */
        public SessionSettings getNextSettings() {
                if (isFinal(0l))
                        return null;
                return sessionsettings.get(BigInteger.valueOf(results.size()));
        }

        /**
         * 
         * @param result the next {@link SessionResult}
         * @return new state
         * @throws IllegalArgumentException if the result participants are not
         *                                  matching the expected participants
         */
        public AllPermutationsState with(SessionResult result) {
                // FIXME do we really need this? Why is this not working?
                // if (!new HashSet<PartyWithProfile>(getNextSettings().getAllParties())
                // .equals(result.getParticipants().values())) {
                // throw new IllegalArgumentException("Inconsistent session result");
                // }
                ArrayList<SessionResult> newresults = new ArrayList<>(results);
                newresults.add(result);
                return new AllPermutationsState(toursettings, sessionsettings,
                                newresults);
        }

        /**
         * 
         * @return number of sessions in this tournament.
         */
        public BigInteger getSize() {
                return sessionsettings.size();
        }

        @Override
        public AllPermutationsSettings getSettings() {
                return toursettings;
        }

}