source: protocol/src/main/java/geniusweb/protocol/tournament/allpermutations/AllPermutationsProtocol.java@ 52

package geniusweb.protocol.tournament.allpermutations;

import java.util.List;
import java.util.logging.Level;

import geniusweb.events.ProtocolEvent;
import geniusweb.events.TournamentStarted;
import geniusweb.protocol.CurrentNegoState;
import geniusweb.protocol.partyconnection.ProtocolToPartyConnFactory;
import geniusweb.protocol.session.SessionProtocol;
import geniusweb.protocol.session.SessionResult;
import geniusweb.protocol.session.SessionSettings;
import geniusweb.protocol.session.SessionState;
import geniusweb.protocol.tournament.TournamentProtocol;
import geniusweb.protocol.tournament.TournamentState;
import geniusweb.references.PartyWithProfile;
import geniusweb.references.ProtocolRef;
import tudelft.utilities.listener.DefaultListenable;
import tudelft.utilities.logging.Reporter;

/**
 * This protocol creates sequentially all permutations of available parties and
 * profiles. Only 1 session is run at a time because managing multiple sessions
 * is more complex to manage in the {@link TournamentState}
 * 
 */
public class AllPermutationsProtocol extends DefaultListenable<ProtocolEvent>
                implements TournamentProtocol {
        private static final ProtocolRef APP = new ProtocolRef("APP");
        private final transient Reporter log;

        private ProtocolToPartyConnFactory connectionFactory; // FINAL
        private AllPermutationsState state; // MUTABLE

        /**
         * 
         * @param state  the {@link AllPermutationsState}
         * @param logger used for all logging, about the tournament, and the created
         *               the session and protocols.
         */
        public AllPermutationsProtocol(AllPermutationsState state,
                        Reporter logger) {
                this.state = state;
                this.log = logger;
        }

        @Override
        public void start(ProtocolToPartyConnFactory connectionfactory) {
                this.connectionFactory = connectionfactory;
                notifyListeners(new TournamentStarted(state.getSize().longValue()));
                startNextSession();
        }

        /**
         * Start the next session in a new thread. Using a new thread ensures that
         * all calls to this return immediately.
         */
        private void startNextSession() {
                new Thread(new Runnable() {

                        @Override
                        public void run() {
                                log.log(Level.INFO,
                                                "Tournament " + this + " starting next session ");
                                SessionSettings settings = state.getNextSettings();
                                SessionProtocol sessionprotocol = settings.getProtocol(log);
                                sessionprotocol.addListener(evt -> sessionEvent(evt));
                                sessionprotocol.start(connectionFactory);
                        }
                }).start();
        }

        /**
         * Called when the session completed.
         * 
         * @param data the ProtocolEvent data,
         */
        private void sessionEvent(ProtocolEvent data) {
                if (data instanceof CurrentNegoState) {
                        SessionState sessionstate = (SessionState) ((CurrentNegoState) data)
                                        .getState();
                        long now = System.currentTimeMillis();
                        if (sessionstate.isFinal(now)) {
                                List<SessionResult> results = sessionstate.getResults();
                                state = state.with(results);
                                notifyListeners(new CurrentNegoState(state));
                                if (!state.isFinal(now)) {
                                        startNextSession();
                                }
                        }
                }
        }

        @Override
        public String getDescription() {
                return "Runs all possible permutations of provided parties and profiles, "
                                + "with the given number of parties per session. Sessions run one at a time. "
                                + "If reuseParties is set, then a party can occur more than 1 time in each session. "
                                + "The sessionSettings determine the baseline settings for each session, eg the deadline "
                                + "and the protocol to be used. The AllPermutationsProtocol supports all basic SessionProtocols. "
                                + "parties and protocols already available in the settings will participate in every session. ";
        }

        @Override
        public TournamentState getState() {
                return state;
        }

        @Override
        public ProtocolRef getRef() {
                return APP;
        }

        @Override
        public void addParticipant(PartyWithProfile party) {
                log.log(Level.INFO, "tournament ignoring join attempt by " + party);
        }

}