Gaudi::StateMachine Namespace Reference

Enumerations
enum	State { OFFLINE, CONFIGURED, INITIALIZED, RUNNING }
	Allowed states for classes implementing the state machine (ApplicationMgr, Algorithm, Service, AlgTool). More...
enum	Transition {   CONFIGURE, INITIALIZE, START, STOP,   FINALIZE, TERMINATE }
	Allowed transitions between states. More...

Functions
State GAUDI_API	ChangeState (const Transition transition, const State state)
	Function to get the new state according to the required transition, checking if the transition is allowed. More...
std::ostream &	operator<< (std::ostream &s, const Gaudi::StateMachine::State &st)
	Pretty print of states. More...
std::ostream &	operator<< (std::ostream &s, const Gaudi::StateMachine::Transition &t)
	Pretty print of transitions. More...

Enumeration Type Documentation

State

enum Gaudi::StateMachine::State

Allowed states for classes implementing the state machine (ApplicationMgr, Algorithm, Service, AlgTool).

Enumerator
OFFLINE
CONFIGURED
INITIALIZED
RUNNING

Definition at line 21 of file StateMachine.h.

               {
      OFFLINE,
      CONFIGURED,
      INITIALIZED,
      RUNNING //,
      // FINALIZED = CONFIGURED
    };

Transition

enum Gaudi::StateMachine::Transition

Allowed transitions between states.

Enumerator
CONFIGURE
INITIALIZE
START
STOP
FINALIZE
TERMINATE

Definition at line 32 of file StateMachine.h.

                    {
      CONFIGURE,  // OFFLINE     -> CONFIGURED
      INITIALIZE, // CONFIGURED  -> INITIALIZED
      START,      // INITIALIZED -> RUNNING
      STOP,       // RUNNING     -> INITIALIZED
      FINALIZE,   // INITIALIZED -> CONFIGURED
      TERMINATE   // CONFIGURED  -> OFFLINE
    };

Function Documentation

ChangeState()

State Gaudi::StateMachine::ChangeState	(	const Transition	transition,
		const State	state
	)

Function to get the new state according to the required transition, checking if the transition is allowed.

Definition at line 19 of file StateMachine.cpp.

                                                                        {
      switch ( transition ) {
      case CONFIGURE:
        if ( OFFLINE == state ) { return CONFIGURED; }
        break;
      case INITIALIZE:
        if ( CONFIGURED == state ) { return INITIALIZED; }
        break;
      case START:
        if ( INITIALIZED == state ) { return RUNNING; }
        break;
      case STOP:
        if ( RUNNING == state ) { return INITIALIZED; }
        break;
      case FINALIZE:
        if ( INITIALIZED == state ) { return CONFIGURED; }
        break;
      case TERMINATE:
        if ( CONFIGURED == state ) { return OFFLINE; }
        break;
      default:
        break;
      }
      std::stringstream msg;
      msg << "Invalid transition '" << transition << "' from state '" << state << "'";
      throw GaudiException( msg.str(), "Gaudi::StateMachine::ChangeState", StatusCode::FAILURE );
      return OFFLINE; // never reached, but maked the compiler happy
    }

operator<<() [1/2]

std::ostream& Gaudi::StateMachine::operator<< ( std::ostream &  s, const Gaudi::StateMachine::State &  st  )

inline

Pretty print of states.

Definition at line 48 of file StateMachine.h.

                                                                                     {
      switch ( st ) {
      case Gaudi::StateMachine::OFFLINE:
        return s << "OFFLINE";
      case Gaudi::StateMachine::CONFIGURED:
        return s << "CONFIGURED";
      case Gaudi::StateMachine::INITIALIZED:
        return s << "INITIALIZED";
      case Gaudi::StateMachine::RUNNING:
        return s << "RUNNING";
      default:
        return s;
      }
    }

operator<<() [2/2]

std::ostream& Gaudi::StateMachine::operator<< ( std::ostream &  s, const Gaudi::StateMachine::Transition &  t  )

inline

Pretty print of transitions.

Definition at line 64 of file StateMachine.h.

                                                                                         {
      switch ( t ) {
      case Gaudi::StateMachine::CONFIGURE:
        return s << "CONFIGURE";
      case Gaudi::StateMachine::INITIALIZE:
        return s << "INITIALIZE";
      case Gaudi::StateMachine::START:
        return s << "START";
      case Gaudi::StateMachine::STOP:
        return s << "STOP";
      case Gaudi::StateMachine::FINALIZE:
        return s << "FINALIZE";
      case Gaudi::StateMachine::TERMINATE:
        return s << "TERMINATE";
      default:
        return s;
      }
    }