source: geniuswebcore/geniusweb/protocol/session/mopac/phase/DefaultPhase.py@ 100

from abc import abstractmethod

from geniusweb.actions.Action import Action
from geniusweb.actions.PartyId import PartyId
from geniusweb.protocol.ProtocolException import ProtocolException
from geniusweb.protocol.session.mopac.PartyStates import PartyStates
from geniusweb.protocol.session.mopac.phase.Phase import Phase, PHASE_MINTIME, \
        PHASE_MAXTIME
from geniusweb.voting.VotingEvaluator import VotingEvaluator


class DefaultPhase(Phase):
        # deadline for this phase, ms since 1970
        
        def __init__(self,  partyStates:PartyStates, deadline:int,
                        evaluator:VotingEvaluator ): 
                '''
                @param partyStates the {@link PartyStates}
                @param deadline    deadline for this phase, ms since 1970
                @param evaluator   the {@link VotingEvaluator} to be used
                '''
                self._partyStates = partyStates
                self._deadline = deadline
                self._evaluator = evaluator

        def isFinal(self, now:int)->bool:
                return now >= self._deadline or len(self._partyStates.getNotYetActed())==0

        def getDeadline(self)->int:
                return self._deadline

        def _checkAction(self, actor:PartyId ,action: Action , now:int):
                '''
                Check if actor can do given action. Basic checks:
                <ul>
                <li>real actor does not match action's actor
                <li>deadline for this phase has passed
                <li>action is not allowed in this phase
                <li>actor already acted in this phase
                </ul>
                @param actor  the actor that really acted
                @param action the action that was done
                @param now    current time
                @throws ProtocolException if the action violates the protocol
                '''
                if action == None:
                        raise ProtocolException("Action=null", actor)
                if actor != action.getActor():
                        raise ProtocolException(
                                        "Incorrect actor info in action:" + str(action.getActor()),
                                        actor)
                if self.isFinal(now):
                        raise ProtocolException("passed deadline", actor)
                if not type(action) in self.getAllowedActions():
                        raise ProtocolException("Action not allowed in "
                                        + type(self).__name__ + ": " + str(action), actor)
                if not actor in self._partyStates.getNotYetActed():
                        raise ProtocolException("Actor can not act anymore", actor)
                return

        def getPartyStates(self)->PartyStates :
                '''
                @return current PartyStates
                '''
                return self._partyStates

        def getEvaluator(self)->VotingEvaluator :
                return self._evaluator

        def next(self, now:int, duration:int)->Phase : 
                if duration < PHASE_MINTIME or duration > PHASE_MAXTIME:
                        raise ValueError("Bug, illegal duration")
                if not self.isFinal(now):
                        raise ValueError("phase is not final")
                return self._checkedNext(now + duration)

        @abstractmethod
        def  _checkedNext(self, dl:int)-> Phase:
                '''
                As {@link #next(long, long)} but DefaultPhase already checked that 1.
                there is enough time for a next phase 2. current state is final 3.
                
                @param dl the deadline for the next phase (ms since 1970).
                @return the next phase
                '''

        def __repr__(self):
                return type(self).__name__ + "[" + str(self._partyStates) + "," + \
                        str(self._deadline) + "," + str(self._evaluator) + "]"

        def __hash__(self):
                return hash((self._deadline, self._evaluator, self._partyStates))


        def __eq__(self, other):
                return isinstance(other, self.__class__) \
                        and self._partyStates==other._partyStates \
                        and self._deadline==other._deadline\
                        and self._evaluator==other._evaluator