JDAQCHSM.hh

Go to the documentation of this file.

#ifndef chsm_895
#define chsm_895
 
/***** <<CHSM-to-C++ Compiler 4.4>> *****/
 
#include <chsm.h>
namespace CHSM_ns_alias = CHSM_NS;
 
/***** user-declarations *****/
 
#line 1 "JDAQCHSM.chsm"
 
 
#include "chsm.h"
 
#include <string>
#include <sstream>
 
 
/**
 * DAQ state machine interface.
 */
class JDAQCHSM : 
  public CHSM::machine
{
public:
  /**
   * DAQ state class.
   *
   * The member method enter() makes a call to the virtual method JDAQCHSM::enterState(...), 
   * where:
   *  - first  argument is the state entered;
   *  - second argument is the event that caused the transition;
   *
   * This method should be overwritten by the run control client to reply to the run control.
   */
  class JDAQState : 
    public CHSM::state 
  {
  public:
    /**
     * Default CHSM constructor.
     */
    JDAQState(CHSM_STATE_ARGS) :
      CHSM::state(CHSM_STATE_INIT)
    {}
 
 
    /**
     * Enter this state.
     *
     * \param  event     event that triggered transition
     * \param  from      pointer to state from where transition started
     * \return           true if all OK; else false
     */
    bool enter(const CHSM::event& event, CHSM::state* from)
    {
      try {
 
        dynamic_cast<JDAQCHSM&>(this->chsm()).enterState(*this, event);
 
        return CHSM::state::enter(event, from);
      }
      catch(const std::exception& error) {      
        return false;
      }
    }
  };
 
 
  /**
   * Constructor.
   *
   * \param  __name               name of state machine
   */
  JDAQCHSM(CHSM_MACHINE_ARGS, const std::string& __name) :
    CHSM::machine(CHSM_MACHINE_INIT),
    name       (__name), 
    detector_id(-1),
    run_number (-1)
  {}
 
 
  /**
   * Get name of state machine.
   *
   * \return                      name
   */
  const std::string& getName() const
  {
    return name;
  }
 
 
  /**
   * Get detector identifier.
   *
   * \return             detector identifier.
   */
  int getDetectorID() const 
  { 
    return detector_id; 
  }
 
 
  /**
   * Get run number.
   *
   * \return             run number
   */
  int getRunNumber() const 
  { 
    return run_number; 
  }
 
 
  /**
   * Interface methods for actions corresponding to state transitions.
   */
  virtual void actionEnter() {}
  virtual void actionExit()  {}
 
  virtual void actionInit      (int, const char*) {}
  virtual void actionConfigure (int, const char*) {}
  virtual void actionStart     (int, const char*) {}
  virtual void actionPause     (int, const char*) {}
  virtual void actionContinue  (int, const char*) {}
  virtual void actionStop      (int, const char*) {}
  virtual void actionReset     (int, const char*) {}
  virtual void actionQuit      (int, const char*) {}
 
  virtual void actionCheck(int, const char*) {}
  virtual void actionInput(int, const char*) {}
 
  virtual void actionError() {}
  virtual void actionRecover(int, const char*) {}
 
 
protected:
  /**
   * Action when entering state.
   *
   * \param  state       entered state
   * \param  event       event that triggered transition
   */
  virtual void enterState(const CHSM::state& state, const CHSM::event& event) = 0;
 
 
  /**
   * Type definition of action method.
   */
  typedef void (JDAQCHSM::*action)(int, const char*);
 
 
  /**
   * The method to execute the action.
   *
   * This method shall be implemented in the derived class.
   *
   * \param  __action    pointer to action method
   * \param  __event     event that triggered the action
   */
  virtual void execute(action __action, const CHSM::event& __event) = 0;
 
  std::string name;
  int         detector_id;
  int         run_number;
};
 
 
/***** CHSM class declaration *****/
 
class JDAQStateMachine : public JDAQCHSM  {
public:
        JDAQStateMachine( const std ::string );
        ~JDAQStateMachine();
 
        // states
        class state_root : public CHSM_ns_alias::cluster { // -1
        public:
 
                state_root( CHSM_STATE_ARGS, bool chsm_history_ );
        private:
                static int const children_[];
        } root;
        class state_Main : public CHSM_ns_alias::set { // 0
        public:
                class state_RunControl : public CHSM_ns_alias::cluster { // 1
                public:
                        class state_Operational : public CHSM_ns_alias::cluster { // 2
                        public:
                                JDAQState  Idle; // 3
                                JDAQState  Standby; // 4
                                JDAQState  Ready; // 5
                                JDAQState  Paused; // 6
                                JDAQState  Running; // 7
 
                                state_Operational( CHSM_STATE_ARGS, bool chsm_history_ );
                        private:
                                static int const children_[];
                        } Operational;
                        JDAQState  Error; // 8
 
                        state_RunControl( CHSM_STATE_ARGS, bool chsm_history_ );
                private:
                        static int const children_[];
                } RunControl;
                CHSM_ns_alias::state Responder; // 9
 
                state_Main( CHSM_STATE_ARGS );
        private:
                static int const children_[];
        } Main;
 
        // events
        private: static int const ev_daq_transitions[]; public:
        class ev_daq_event : public CHSM_ns_alias::event {
        public:
                typedef CHSM_ns_alias::event::param_block base_param_block;
                struct param_block : CHSM_ns_alias::event::param_block {
#line 172 "JDAQCHSM.chsm"
                        int length;
#line 172 "JDAQCHSM.chsm"
                        const char * buffer;
                        param_block( CHSM_ns_alias::event const &, int , const char * );
                protected:
                        virtual ~param_block();
                };
                param_block* operator->() const {
                        return (param_block*)param_block_;
                }
                void operator()( int , const char * );
        protected:
                ev_daq_event( CHSM_EVENT_ARGS ) : 
                        CHSM_ns_alias::event( CHSM_EVENT_INIT ) { }
                friend class JDAQStateMachine;
        } ev_daq;
        char ev_daq_param_block[ sizeof( ev_daq_event::param_block ) ];
 
        private: static int const ev_init_transitions[]; public:
        class ev_init_event : public JDAQStateMachine::ev_daq_event {
        public:
                typedef JDAQStateMachine::ev_daq_event::param_block base_param_block;
                struct param_block : JDAQStateMachine::ev_daq_event::param_block {
                        param_block( CHSM_ns_alias::event const &, int , const char * );
                protected:
                        virtual ~param_block();
                };
                param_block* operator->() const {
                        return (param_block*)param_block_;
                }
                void operator()( int , const char * );
        protected:
                ev_init_event( CHSM_EVENT_ARGS ) : 
                        JDAQStateMachine::ev_daq_event( CHSM_EVENT_INIT ) { }
                friend class JDAQStateMachine;
        } ev_init;
        char ev_init_param_block[ sizeof( ev_init_event::param_block ) ];
 
        private: static int const ev_configure_transitions[]; public:
        class ev_configure_event : public JDAQStateMachine::ev_daq_event {
        public:
                typedef JDAQStateMachine::ev_daq_event::param_block base_param_block;
                struct param_block : JDAQStateMachine::ev_daq_event::param_block {
                        param_block( CHSM_ns_alias::event const &, int , const char * );
                protected:
                        virtual ~param_block();
                };
                param_block* operator->() const {
                        return (param_block*)param_block_;
                }
                void operator()( int , const char * );
        protected:
                ev_configure_event( CHSM_EVENT_ARGS ) : 
                        JDAQStateMachine::ev_daq_event( CHSM_EVENT_INIT ) { }
                friend class JDAQStateMachine;
        } ev_configure;
        char ev_configure_param_block[ sizeof( ev_configure_event::param_block ) ];
 
        private: static int const ev_start_transitions[]; public:
        class ev_start_event : public JDAQStateMachine::ev_daq_event {
        public:
                typedef JDAQStateMachine::ev_daq_event::param_block base_param_block;
                struct param_block : JDAQStateMachine::ev_daq_event::param_block {
                        param_block( CHSM_ns_alias::event const &, int , const char * );
                protected:
                        virtual ~param_block();
                };
                param_block* operator->() const {
                        return (param_block*)param_block_;
                }
                void operator()( int , const char * );
        protected:
                ev_start_event( CHSM_EVENT_ARGS ) : 
                        JDAQStateMachine::ev_daq_event( CHSM_EVENT_INIT ) { }
                friend class JDAQStateMachine;
        } ev_start;
        char ev_start_param_block[ sizeof( ev_start_event::param_block ) ];
 
        private: static int const ev_pause_transitions[]; public:
        class ev_pause_event : public JDAQStateMachine::ev_daq_event {
        public:
                typedef JDAQStateMachine::ev_daq_event::param_block base_param_block;
                struct param_block : JDAQStateMachine::ev_daq_event::param_block {
                        param_block( CHSM_ns_alias::event const &, int , const char * );
                protected:
                        virtual ~param_block();
                };
                param_block* operator->() const {
                        return (param_block*)param_block_;
                }
                void operator()( int , const char * );
        protected:
                ev_pause_event( CHSM_EVENT_ARGS ) : 
                        JDAQStateMachine::ev_daq_event( CHSM_EVENT_INIT ) { }
                friend class JDAQStateMachine;
        } ev_pause;
        char ev_pause_param_block[ sizeof( ev_pause_event::param_block ) ];
 
        private: static int const ev_continue_transitions[]; public:
        class ev_continue_event : public JDAQStateMachine::ev_daq_event {
        public:
                typedef JDAQStateMachine::ev_daq_event::param_block base_param_block;
                struct param_block : JDAQStateMachine::ev_daq_event::param_block {
                        param_block( CHSM_ns_alias::event const &, int , const char * );
                protected:
                        virtual ~param_block();
                };
                param_block* operator->() const {
                        return (param_block*)param_block_;
                }
                void operator()( int , const char * );
        protected:
                ev_continue_event( CHSM_EVENT_ARGS ) : 
                        JDAQStateMachine::ev_daq_event( CHSM_EVENT_INIT ) { }
                friend class JDAQStateMachine;
        } ev_continue;
        char ev_continue_param_block[ sizeof( ev_continue_event::param_block ) ];
 
        private: static int const ev_stop_transitions[]; public:
        class ev_stop_event : public JDAQStateMachine::ev_daq_event {
        public:
                typedef JDAQStateMachine::ev_daq_event::param_block base_param_block;
                struct param_block : JDAQStateMachine::ev_daq_event::param_block {
                        param_block( CHSM_ns_alias::event const &, int , const char * );
                protected:
                        virtual ~param_block();
                };
                param_block* operator->() const {
                        return (param_block*)param_block_;
                }
                void operator()( int , const char * );
        protected:
                ev_stop_event( CHSM_EVENT_ARGS ) : 
                        JDAQStateMachine::ev_daq_event( CHSM_EVENT_INIT ) { }
                friend class JDAQStateMachine;
        } ev_stop;
        char ev_stop_param_block[ sizeof( ev_stop_event::param_block ) ];
 
        private: static int const ev_reset_transitions[]; public:
        class ev_reset_event : public JDAQStateMachine::ev_daq_event {
        public:
                typedef JDAQStateMachine::ev_daq_event::param_block base_param_block;
                struct param_block : JDAQStateMachine::ev_daq_event::param_block {
                        param_block( CHSM_ns_alias::event const &, int , const char * );
                protected:
                        virtual ~param_block();
                };
                param_block* operator->() const {
                        return (param_block*)param_block_;
                }
                void operator()( int , const char * );
        protected:
                ev_reset_event( CHSM_EVENT_ARGS ) : 
                        JDAQStateMachine::ev_daq_event( CHSM_EVENT_INIT ) { }
                friend class JDAQStateMachine;
        } ev_reset;
        char ev_reset_param_block[ sizeof( ev_reset_event::param_block ) ];
 
        private: static int const ev_quit_transitions[]; public:
        class ev_quit_event : public JDAQStateMachine::ev_daq_event {
        public:
                typedef JDAQStateMachine::ev_daq_event::param_block base_param_block;
                struct param_block : JDAQStateMachine::ev_daq_event::param_block {
                        param_block( CHSM_ns_alias::event const &, int , const char * );
                protected:
                        virtual ~param_block();
                };
                param_block* operator->() const {
                        return (param_block*)param_block_;
                }
                void operator()( int , const char * );
        protected:
                ev_quit_event( CHSM_EVENT_ARGS ) : 
                        JDAQStateMachine::ev_daq_event( CHSM_EVENT_INIT ) { }
                friend class JDAQStateMachine;
        } ev_quit;
        char ev_quit_param_block[ sizeof( ev_quit_event::param_block ) ];
 
        private: static int const ev_off_transitions[]; public:
        class ev_off_event : public JDAQStateMachine::ev_daq_event {
        public:
                typedef JDAQStateMachine::ev_daq_event::param_block base_param_block;
                struct param_block : JDAQStateMachine::ev_daq_event::param_block {
                        param_block( CHSM_ns_alias::event const &, int , const char * );
                protected:
                        virtual ~param_block();
                };
                param_block* operator->() const {
                        return (param_block*)param_block_;
                }
                void operator()( int , const char * );
        protected:
                ev_off_event( CHSM_EVENT_ARGS ) : 
                        JDAQStateMachine::ev_daq_event( CHSM_EVENT_INIT ) { }
                friend class JDAQStateMachine;
        } ev_off;
        char ev_off_param_block[ sizeof( ev_off_event::param_block ) ];
 
        private: static int const ev_check_transitions[]; public:
        class ev_check_event : public JDAQStateMachine::ev_daq_event {
        public:
                typedef JDAQStateMachine::ev_daq_event::param_block base_param_block;
                struct param_block : JDAQStateMachine::ev_daq_event::param_block {
                        param_block( CHSM_ns_alias::event const &, int , const char * );
                protected:
                        virtual ~param_block();
                };
                param_block* operator->() const {
                        return (param_block*)param_block_;
                }
                void operator()( int , const char * );
        protected:
                ev_check_event( CHSM_EVENT_ARGS ) : 
                        JDAQStateMachine::ev_daq_event( CHSM_EVENT_INIT ) { }
                friend class JDAQStateMachine;
        } ev_check;
        char ev_check_param_block[ sizeof( ev_check_event::param_block ) ];
 
        private: static int const ev_input_transitions[]; public:
        class ev_input_event : public JDAQStateMachine::ev_daq_event {
        public:
                typedef JDAQStateMachine::ev_daq_event::param_block base_param_block;
                struct param_block : JDAQStateMachine::ev_daq_event::param_block {
                        param_block( CHSM_ns_alias::event const &, int , const char * );
                protected:
                        virtual ~param_block();
                };
                param_block* operator->() const {
                        return (param_block*)param_block_;
                }
                void operator()( int , const char * );
        protected:
                ev_input_event( CHSM_EVENT_ARGS ) : 
                        JDAQStateMachine::ev_daq_event( CHSM_EVENT_INIT ) { }
                friend class JDAQStateMachine;
        } ev_input;
        char ev_input_param_block[ sizeof( ev_input_event::param_block ) ];
 
        private: static int const ev_recover_transitions[]; public:
        class ev_recover_event : public JDAQStateMachine::ev_daq_event {
        public:
                typedef JDAQStateMachine::ev_daq_event::param_block base_param_block;
                struct param_block : JDAQStateMachine::ev_daq_event::param_block {
                        param_block( CHSM_ns_alias::event const &, int , const char * );
                protected:
                        virtual ~param_block();
                };
                param_block* operator->() const {
                        return (param_block*)param_block_;
                }
                void operator()( int , const char * );
        protected:
                ev_recover_event( CHSM_EVENT_ARGS ) : 
                        JDAQStateMachine::ev_daq_event( CHSM_EVENT_INIT ) { }
                friend class JDAQStateMachine;
        } ev_recover;
        char ev_recover_param_block[ sizeof( ev_recover_event::param_block ) ];
 
        private: static int const ev_error_transitions[]; public:
        class ev_error_event : public CHSM_ns_alias::event {
        public:
                typedef CHSM_ns_alias::event::param_block base_param_block;
                struct param_block : CHSM_ns_alias::event::param_block {
                        param_block( CHSM_ns_alias::event const &event ) : 
                                CHSM_ns_alias::event::param_block( event ) { }
                protected:
                        virtual ~param_block();
                };
        protected:
                ev_error_event( CHSM_EVENT_ARGS ) : 
                        CHSM_ns_alias::event( CHSM_EVENT_INIT ) { }
                friend class JDAQStateMachine;
        } ev_error;
        char ev_error_param_block[ sizeof( ev_error_event::param_block ) ];
 
 
        // transition conditions
 
        // transition targets
 
        // transition actions
        void A1( CHSM_ns_alias::event const& );
        void A2( CHSM_ns_alias::event const& );
        void A3( CHSM_ns_alias::event const& );
        void A4( CHSM_ns_alias::event const& );
        void A5( CHSM_ns_alias::event const& );
        void A6( CHSM_ns_alias::event const& );
        void A7( CHSM_ns_alias::event const& );
        void A8( CHSM_ns_alias::event const& );
        void A9( CHSM_ns_alias::event const& );
        void A10( CHSM_ns_alias::event const& );
        void A11( CHSM_ns_alias::event const& );
        void A12( CHSM_ns_alias::event const& );
        void A13( CHSM_ns_alias::event const& );
        void A14( CHSM_ns_alias::event const& );
 
        // enter/exit actions
        void EAM4root( CHSM_ns_alias::state const&, CHSM_ns_alias::event const& );
        void XAM4root( CHSM_ns_alias::state const&, CHSM_ns_alias::event const& );
private:
        CHSM_ns_alias::state *state_[ 11 ];
        static CHSM_ns_alias::transition const transition_[];
        CHSM_ns_alias::event const *taken_[ 14 ];
        CHSM_ns_alias::state *target_[ 14 ];
};
 
 
/***** THE END *****/
#endif