Field Detail

• ERR_ILLEGAL_ALLOC

  public static final String ERR_ILLEGAL_ALLOC

  Suffix for error event that are triggered in reaction to invalid data model locations.

  See Also:

  Constant Field Values

Constructor Detail

• SCXMLSemanticsImpl

  public SCXMLSemanticsImpl()

Method Detail

• normalizeStateMachine

  public SCXML normalizeStateMachine(SCXML input,
                            ErrorReporter errRep)

  Optional post processing immediately following SCXMLReader. May be used for removing pseudo-states etc.

  Specified by:

  normalizeStateMachine in interface SCXMLSemantics

  Parameters:

  input - SCXML state machine

  errRep - ErrorReporter callback

  Returns:

  normalized SCXML state machine, pseudo states are removed, etc.

• firstStep

  public void firstStep(SCXMLExecutionContext exctx)
                 throws ModelException

  First step in the execution of an SCXML state machine.

  This will first (re)initialize the state machine instance, destroying any existing state!

  The first step is corresponding to the Algorithm for SCXML processing from the interpret() procedure to the mainLoop() procedure up to the blocking wait for an external event.

  This step will thus complete the SCXML initial execution and a subsequent macroStep to stabilize the state machine again before returning.

  If the state machine no longer is running after all this, first the finalStep(SCXMLExecutionContext) will be called for cleanup before returning.

  Specified by:

  firstStep in interface SCXMLSemantics

  Parameters:

  exctx - The execution context for this step

  Throws:

  ModelException - if the state machine instance failed to initialize or a SCXML model error occurred during the execution.

• nextStep

  public void nextStep(SCXMLExecutionContext exctx,
              TriggerEvent event)
                throws ModelException

  Next step in the execution of an SCXML state machine.

  The next step is corresponding to the Algorithm for SCXML processing mainEventLoop() procedure after receiving an external event, up to the blocking wait for another external event.

  If the state machine isn't SCXMLExecutionContext.isRunning() (any more), invoking this method will simply do nothing.

  If the provided event is a TriggerEvent.CANCEL_EVENT, the state machine will stop running.

  Otherwise, the event is set in the SCXMLSystemContext and processing of the event then is started, and if the event leads to any transitions a microStep for this event will be performed, followed up by a macroStep to stabilize the state machine again before returning.

  If the state machine no longer is running after all this, first the finalStep(SCXMLExecutionContext) will be called for cleanup before returning.

  Specified by:

  nextStep in interface SCXMLSemantics

  Parameters:

  exctx - The execution context for this step

  event - The event to process

  Throws:

  ModelException - if a SCXML model error occurred during the execution.

• finalStep

  public void finalStep(SCXMLExecutionContext exctx)
                 throws ModelException

  The final step in the execution of an SCXML state machine.

  This final step is corresponding to the Algorithm for SCXML processing exitInterpreter() procedure, after the state machine stopped running.

  If the state machine still is SCXMLExecutionContext.isRunning() invoking this method will simply do nothing.

  This final step will exit all remaining active states and cancel any active invokers.

  TODO: the current implementation does not yet provide final donedata handling.

  Specified by:

  finalStep in interface SCXMLSemantics

  Parameters:

  exctx - The execution context for this step

  Throws:

  ModelException - if a SCXML model error occurred during the execution.

• microStep

  public void microStep(SCXMLExecutionContext exctx,
               Step step,
               Set<TransitionalState> statesToInvoke)
                 throws ModelException

  Perform a micro step in the execution of a state machine.

  This micro step is corresponding to the Algorithm for SCXML processing microstep() procedure.

  Parameters:

  exctx - The execution context for this step

  step - The current micro step

  statesToInvoke - the set of activated states which invokes need to be invoked at the end of the current macro step

  Throws:

  ModelException - if a SCXML model error occurred during the execution.

• buildStep

  public void buildStep(SCXMLExecutionContext exctx,
               Step step)
                 throws ModelException

  buildStep builds the exitSet and entrySet for the current configuration given the transitionList on the step.

  Parameters:

  exctx - The SCXML execution context

  step - The step containing the list of transitions to be taken

  Throws:

  ModelException - if the result of taking the transitions would lead to an illegal configuration

• macroStep

  public void macroStep(SCXMLExecutionContext exctx,
               Set<TransitionalState> statesToInvoke)
                 throws ModelException

  Perform a macro step in the execution of a state machine.

  This macro step is corresponding to the Algorithm for SCXML processing mainEventLoop() procedure macro step sub-flow, which are the first 3 steps of the described 4, so everything up to the blocking wait for an external event.

  Parameters:

  exctx - The execution context for this step

  statesToInvoke - the set of activated states which invokes need to be invoked at the end of the current macro step

  Throws:

  ModelException - if a SCXML model error occurred during the execution.

• computeExitSet

  public void computeExitSet(Step step,
                    StateConfiguration stateConfiguration)

  Compute and store the set of states to exit for the current list of transitions in the provided step.

  This method corresponds to the Algorithm for SCXML processing computeExitSet() procedure.

  Parameters:

  step - The step containing the list of transitions to be taken

  stateConfiguration - The current configuration of the state machine (SCInstance.getStateConfiguration()).

• computeExitSet

  public void computeExitSet(SimpleTransition transition,
                    Set<EnterableState> exitSet,
                    Set<EnterableState> activeStates)

  Compute and store the set of states to exit for one specific transition in the provided step.

  This method corresponds to the Algorithm for SCXML processing computeExitSet() procedure.

  Parameters:

  transition - The transition to compute the states to exit from

  exitSet - The set for adding the states to exit to

  activeStates - The current active states of the state machine (StateConfiguration.getActiveStates()).

• recordHistory

  public void recordHistory(Step step,
                   Set<EnterableState> atomicStates,
                   Set<EnterableState> activeStates)

  Record the history configurations for states to exit if applicable and temporarily store this in the step.

  These history configurations must be pre-recorded as they might impact (re)entrance calculation during computeEntrySet(SCXMLExecutionContext, Step).

  Only after the new configuration has been validated (see: isLegalConfiguration(Set, ErrorReporter)), the history configurations will be persisted during the actual exitStates(SCXMLExecutionContext, Step, Set) processing.

  Parameters:

  step - The step containing the list of states to exit, and the map to record the new history configurations

  atomicStates - The current set of active atomic states in the state machine

  activeStates - The current set of all active states in the state machine

• computeEntrySet

  public void computeEntrySet(SCXMLExecutionContext exctx,
                     Step step)

  Compute and store the set of states to enter for the current list of transitions in the provided step.

  This method corresponds to the Algorithm for SCXML processing computeEntrySet() procedure.

  Parameters:

  exctx - The execution context for this step

  step - The step containing the list of transitions to be taken

• addDescendantStatesToEnter

  public void addDescendantStatesToEnter(SCXMLExecutionContext exctx,
                                Step step,
                                TransitionTarget tt)

  This method corresponds to the Algorithm for SCXML processing addDescendantStatesToEnter() procedure.

  Parameters:

  exctx - The execution context for this step

  step - The step

  tt - The TransitionTarget

• addAncestorStatesToEnter

  public void addAncestorStatesToEnter(SCXMLExecutionContext exctx,
                              Step step,
                              TransitionTarget tt,
                              TransitionTarget ancestor)

  This method corresponds to the Algorithm for SCXML processing addAncestorStatesToEnter() procedure.

  Parameters:

  exctx - The execution context for this step

  step - The step

  tt - The TransitionTarget

  ancestor - The ancestor TransitionTarget

• containsDescendant

  public boolean containsDescendant(Set<EnterableState> states,
                           EnterableState state)

  Parameters:

  states - the set of states to check for descendants

  state - the state to check with

  Returns:

  Returns true if a member of the provided states set is a descendant of the provided state.

• selectTransitions

  public void selectTransitions(SCXMLExecutionContext exctx,
                       Step step)
                         throws ModelException

  This method corresponds to the Algorithm for SCXML processing selectTransitions() as well as the selectEventlessTransitions() procedure, depending on the event (or null) in the provided step

  Parameters:

  exctx - The execution context for this step

  step - The step

  Throws:

  ModelException

• removeConflictingTransitions

  public void removeConflictingTransitions(SCXMLExecutionContext exctx,
                                  Step step,
                                  List<Transition> enabledTransitions)

  This method corresponds to the Algorithm for SCXML processing removeConflictingTransitions() procedure.

  Parameters:

  exctx - The execution context for this step

  step - The step

  enabledTransitions - The list of enabled transitions

• matchTransition

  public boolean matchTransition(SCXMLExecutionContext exctx,
                        Transition transition,
                        String eventName)

  Parameters:

  exctx - The execution context for this step

  transition - The transition

  eventName - The (optional) event name to match against

  Returns:

  Returns true if the transition matches against the provided eventName, or is event-less when no eventName is provided, AND its (optional) condition guard evaluates to true.

• isInFinalState

  public boolean isInFinalState(EnterableState es,
                       Set<EnterableState> configuration)

  This method corresponds to the Algorithm for SCXML processing isFinalState() function.

  Parameters:

  es - the enterable state to check

  configuration - the current state machine configuration

  Returns:

  Return true if s is a compound state and one of its children is an active final state (i.e. is a member of the current configuration), or if s is a parallel state and isInFinalState is true of all its children.

• isInvokerEvent

  public boolean isInvokerEvent(String invokerId,
                       TriggerEvent event)

  Checks if an external event was send (back) by an specific Invoker

  Parameters:

  invokerId - the invokerId

  event - received external event

  Returns:

  true if this event was send by the specific Invoker

• isCancelEvent

  public boolean isCancelEvent(TriggerEvent event)

  Check if an external event indicates the state machine execution must be cancelled.

  Parameters:

  event - received external event

  Returns:

  true if this event is of type TriggerEvent.CANCEL_EVENT.

• isLegalConfiguration

  public boolean isLegalConfiguration(Set<EnterableState> states,
                             ErrorReporter errRep)

  Checks whether a given set of states is a legal Harel State Table configuration (with the respect to the definition of the OR and AND states).

  Specified by:

  isLegalConfiguration in interface SCXMLSemantics

  Parameters:

  states - a set of states

  errRep - ErrorReporter to report detailed error info if needed

  Returns:

  true if a given state configuration is legal, false otherwise

• setSystemEventVariable

  public void setSystemEventVariable(SCInstance scInstance,
                            TriggerEvent event,
                            boolean internal)

  Stores the provided event in the system context

  For the event a EventVariable is instantiated and the provided event its type is mapped to the one of the SCXML specification predefined types.

  Parameters:

  scInstance - the state machine instance holding the system context

  event - The event being stored

  internal - Flag indicating the event was received internally or externally

• executeGlobalScript

  public void executeGlobalScript(SCXMLExecutionContext exctx)
                           throws ModelException

  Executes the global SCXML script element

  Parameters:

  exctx - The execution context

  Throws:

  ModelException - if a SCXML model error occurred during the execution.

• exitStates

  public void exitStates(SCXMLExecutionContext exctx,
                Step step,
                Set<TransitionalState> statesToInvoke)
                  throws ModelException

  This method corresponds to the Algorithm for SCXML processing exitStates() procedure, where the states to exit already have been pre-computed in microStep(SCXMLExecutionContext, Step, java.util.Set).

  Parameters:

  exctx - The execution context for this micro step

  step - the step

  statesToInvoke - the set of activated states which invokes need to be invoked at the end of the current macro step

  Throws:

  ModelException - if a SCXML model error occurred during the execution.

• executeTransitionContent

  public void executeTransitionContent(SCXMLExecutionContext exctx,
                              Step step)
                                throws ModelException

  Executes the executable content for all transitions in the micro step

  Parameters:

  exctx - The execution context for this micro step

  step - the step

  Throws:

  ModelException - if a SCXML model error occurred during the execution.

• executeContent

  public void executeContent(SCXMLExecutionContext exctx,
                    Executable exec)
                      throws ModelException

  Executes the executable content for a specific executable in the micro step

  Parameters:

  exctx - The execution context for this micro step

  exec - the executable providing the execution content

  Throws:

  ModelException - if a SCXML model error occurred during the execution.

• notifyOnTransition

  public void notifyOnTransition(SCXMLExecutionContext exctx,
                        Transition t,
                        TransitionTarget target)

  Notifies SCXMLListeners on the transition taken

  Parameters:

  exctx - The execution context for this micro step

  t - The Transition taken

  target - The target of the Transition

• enterStates

  public void enterStates(SCXMLExecutionContext exctx,
                 Step step,
                 Set<TransitionalState> statesToInvoke)
                   throws ModelException

  This method corresponds to the Algorithm for SCXML processing enterStates() procedure, where the states to enter already have been pre-computed in microStep(SCXMLExecutionContext, Step, java.util.Set).

  Parameters:

  exctx - The execution context for this micro step

  step - the step

  statesToInvoke - the set of activated states which invokes need to be invoked at the end of the current macro step

  Throws:

  ModelException - if a SCXML model error occurred during the execution.

• initiateInvokes

  public void initiateInvokes(SCXMLExecutionContext exctx,
                     Set<TransitionalState> statesToInvoke)
                       throws ModelException

  Initiate any new invoked activities.

  Parameters:

  exctx - provides the execution context

  statesToInvoke - the set of activated states which invokes need to be invoked

  Throws:

  ModelException

• processInvokes

  public void processInvokes(SCXMLExecutionContext exctx,
                    TriggerEvent event)
                      throws ModelException

  Forward events to invoked activities, execute finalize handlers.

  Parameters:

  exctx - provides the execution context

  event - The events to be forwarded

  Throws:

  ModelException - in case there is a fatal SCXML object model problem.