RunControlStateMachine.h

#ifndef _ots_RunControlStateMachine_h_
#define _ots_RunControlStateMachine_h_
 
#include "otsdaq/FiniteStateMachine/FiniteStateMachine.h"
#include "otsdaq/FiniteStateMachine/VStateMachine.h"
#include "otsdaq/ProgressBar/ProgressBar.h"
 
#include <atomic>
#include <string>
#include "toolbox/lang/Class.h"
 
namespace ots
{
class RunControlStateMachine : public virtual toolbox::lang::Class
{
  public:
    RunControlStateMachine(const std::string& name = "Undefined Name");
    virtual ~RunControlStateMachine(void);
 
    void reset(void);
    void setStateMachineName(const std::string& name)
    {
        theStateMachine_.setStateMachineName(name);
    }
    const std::string& getErrorMessage(void) const
    {
        return theStateMachine_.getErrorMessage();
    }
    void setAsyncPauseExceptionMessage(const std::string& error)
    {
        asyncPauseExceptionReceived_ = true;
        theStateMachine_.setErrorMessage(error);
    }
    void setAsyncStopExceptionMessage(const std::string& error)
    {
        asyncStopExceptionReceived_ = true;
        theStateMachine_.setErrorMessage(error);
    }
 
    template<class OBJECT>
    void addStateTransition(toolbox::fsm::State from,
                            toolbox::fsm::State to,
                            const std::string&  input,
                            const std::string&  transitionName,
                            OBJECT*             obj,
                            void (OBJECT::*func)(toolbox::Event::Reference))
 
    {
        stateTransitionFunctionTable_[from][input] = func;
        theStateMachine_.addStateTransition(from, to, input, transitionName, obj, func);
    }
 
    template<class OBJECT>
    void addStateTransition(toolbox::fsm::State from,
                            toolbox::fsm::State to,
                            const std::string&  input,
                            const std::string&  transitionName,
                            const std::string&  transitionParameter,
                            OBJECT*             obj,
                            void (OBJECT::*func)(toolbox::Event::Reference))
 
    {
        stateTransitionFunctionTable_[from][input] = func;
        theStateMachine_.addStateTransition(
            from, to, input, transitionName, transitionParameter, obj, func);
    }
 
    virtual void stateInitial(toolbox::fsm::FiniteStateMachine& /*fsm*/) { ; }
 
    virtual void statePaused(toolbox::fsm::FiniteStateMachine& /*fsm*/) { ; }
 
    virtual void stateRunning(toolbox::fsm::FiniteStateMachine& /*fsm*/) { ; }
 
    virtual void stateHalted(toolbox::fsm::FiniteStateMachine& /*fsm*/) { ; }
 
    virtual void stateShutdown(toolbox::fsm::FiniteStateMachine& /*fsm*/) { ; }
 
    virtual void stateConfigured(toolbox::fsm::FiniteStateMachine& /*fsm*/) { ; }
 
    virtual void inError(toolbox::fsm::FiniteStateMachine& /*fsm*/) { ; }
 
    virtual void transitionConfiguring(toolbox::Event::Reference /*e*/) { ; }
    virtual void transitionHalting(toolbox::Event::Reference /*e*/) { ; }
    virtual void transitionShuttingDown(toolbox::Event::Reference /*e*/) { ; }
    virtual void transitionStartingUp(toolbox::Event::Reference /*e*/) { ; }
    virtual void transitionInitializing(toolbox::Event::Reference /*e*/) { ; }
    virtual void transitionPausing(toolbox::Event::Reference /*e*/) { ; }
    virtual void transitionResuming(toolbox::Event::Reference /*e*/) { ; }
    virtual void transitionStarting(toolbox::Event::Reference /*e*/) { ; }
    virtual void transitionStopping(toolbox::Event::Reference /*e*/) { ; }
    virtual void enteringError(toolbox::Event::Reference /*e*/) { ; }
 
    xoap::MessageReference runControlMessageHandler(xoap::MessageReference message);
 
    static const std::string FAILED_STATE_NAME;
    static const std::string INITIAL_STATE_NAME;
    static const std::string HALTED_STATE_NAME;
    static const std::string PAUSED_STATE_NAME;
    static const std::string RUNNING_STATE_NAME;
    static const std::string SHUTDOWN_STATE_NAME;
    static const std::string CONFIGURED_STATE_NAME;
 
    static const std::string SHUTDOWN_TRANSITION_NAME;
    static const std::string STARTUP_TRANSITION_NAME;
    static const std::string INIT_TRANSITION_NAME;
    static const std::string ERROR_TRANSITION_NAME;
    static const std::string FAIL_TRANSITION_NAME;
    static const std::string CONFIGURE_TRANSITION_NAME;
    static const std::string HALT_TRANSITION_NAME;
    static const std::string ABORT_TRANSITION_NAME;
    static const std::string PAUSE_TRANSITION_NAME;
    static const std::string RESUME_TRANSITION_NAME;
    static const std::string START_TRANSITION_NAME;
    static const std::string STOP_TRANSITION_NAME;
 
    // Subsystem-iteration accessors (outermost tier — synchronized across subsystems)
    unsigned int getSubsystemIterationIndex(void) const { return subsystemIterationIndex_; }
    bool         isStandaloneSubsystem(void) const { return subsystemIterationIndex_ == VStateMachine::SUBSYSTEM_ITERATION_STANDALONE; }
    bool isFirstIteration(void) const
    {
        return (subsystemIterationIndex_ == 0 || isStandaloneSubsystem()) &&
               iterationIndex_ == 0 && subIterationIndex_ == 0;
    }
    unsigned int getSubsystemSyncStepIndex(void) const
    {
        return isStandaloneSubsystem() ? iterationIndex_ : subsystemIterationIndex_;
    }
    void indicateSubsystemSyncStepWork(void)
    {
        if(isStandaloneSubsystem())
            iterationWorkFlag_ = true;
        else
            subsystemIterationWorkFlag_ = true;
    }
    void indicateSubsystemIterationWork(void) { subsystemIterationWorkFlag_ = true; }
    void clearSubsystemIterationWork(void) { subsystemIterationWorkFlag_ = false; }
    bool getSubsystemIterationWork(void) { return subsystemIterationWorkFlag_; }
 
    // Iteration accessors (middle tier — synchronized within one subsystem)
    unsigned int getIterationIndex(void) { return iterationIndex_; }
    unsigned int getSubIterationIndex(void) { return subIterationIndex_; }
    unsigned int getMinReadyForEventGenerationStartIteration(void) { return minReadyForEventGenerationStartIteration_; }
    void         indicateIterationWork(void) { iterationWorkFlag_ = true; }
    void         clearIterationWork(void) { iterationWorkFlag_ = false; }
    bool         getIterationWork(void) { return iterationWorkFlag_; }
 
    // Sub-iteration accessors (innermost tier — internal to one application)
    void indicateSubIterationWork(void) { subIterationWorkFlag_ = true; }
    void clearSubIterationWork(void) { subIterationWorkFlag_ = false; }
    bool getSubIterationWork(void) { return subIterationWorkFlag_; }
 
    const std::string& getLastCommand(void) { return lastIterationCommand_; }
    const std::string& getLastAttemptedConfigureGroup(void)
    {
        return lastAttemptedConfigureGroup_;
    }
 
  protected:
    FiniteStateMachine theStateMachine_;
    ProgressBar        theProgressBar_;
 
    std::atomic<bool> asyncFailureReceived_{false};
    std::atomic<bool> asyncPauseExceptionReceived_{false};
    std::atomic<bool> asyncStopExceptionReceived_{false};
 
    unsigned int subsystemIterationIndex_ = 0;
    unsigned int iterationIndex_ = 0, subIterationIndex_ = 0;
    bool         subsystemIterationWorkFlag_, iterationWorkFlag_, subIterationWorkFlag_;
    unsigned int minReadyForEventGenerationStartIteration_ = 0;
 
    toolbox::fsm::State lastIterationState_;
    std::string         lastIterationCommand_;
    std::string         lastAttemptedConfigureGroup_;
    std::string         lastIterationResult_;
    unsigned int        lastSubsystemIterationIndex_, lastIterationIndex_, lastSubIterationIndex_;
 
    std::map<toolbox::fsm::State,
             std::map<std::string,
                      void (RunControlStateMachine::*)(toolbox::Event::Reference),
                      std::less<std::string> > >
        stateTransitionFunctionTable_;
};
 
}  // namespace ots
 
#endif