#include <Macho.h>

Inheritance diagram for inet::Macho::_MachineBase:

Public Member Functions
class Alias	currentState () const

Protected Member Functions
	_MachineBase ()

	~_MachineBase ()

void	setState (_StateInstance &instance, _Initializer *init)

void	setState (const Alias &state)

void	setPendingState (_StateInstance &instance, _Initializer *init)

void	setPendingEvent (_IEventBase *event)

void	rattleOn ()

_StateInstance *&	getInstance (ID id)

const _StateInstance *	getInstance (ID id) const

void	start (_StateInstance &instance)

void	start (const Alias &state)

void	shutdown ()

void	allocate (unsigned int count)

void	free (unsigned int count)

void	clearHistoryDeep (unsigned int count, const _StateInstance &instance)

Protected Attributes
_StateInstance *	myCurrentState = nullptr

_StateInstance *	myPendingState = nullptr

_Initializer *	myPendingInit = nullptr

void *	myPendingBox = nullptr

_IEventBase *	myPendingEvent = nullptr

_StateInstance **	myInstances = nullptr

Friends
template<class C , class P >
class	MachoLink

template<class T >
class	TopBase

class	_StateSpecification

class	Alias

class	_AdaptingInitializer

class	_StateInstance

class	::inet::TestAccess

Constructor & Destructor Documentation

inet::_MachineBase::_MachineBase ( )

protected

220 {

221 }

inet::_MachineBase::~_MachineBase ( )

protected

 {
     assert(!myPendingInit);
 
     delete[] myInstances;
     delete myPendingEvent;
 }

Member Function Documentation

void inet::_MachineBase::allocate ( unsigned int count )

protected

 {
     myInstances = new _StateInstance *[count];
     for (unsigned int i = 0; i < count; ++i)
         myInstances[i] = nullptr;
 }

void inet::_MachineBase::clearHistoryDeep	(	unsigned int	count,
		const _StateInstance &	instance
	)

protected

Referenced by inet::Macho::MachoLink< C, P >::clearHistoryDeep().

 {
     for (unsigned int i = 0; i < count; ++i) {
         _StateInstance *s = myInstances[i];
         if (s && s->isChild(instance))
             s->setHistory(nullptr);
     }
 }

Alias inet::_MachineBase::currentState ( ) const

Referenced by inet::Macho::MachoLink< C, P >::isCurrent(), and inet::Macho::MachoLink< C, P >::isCurrentDirect().

 {
     return Alias(myCurrentState->key());
 }

void inet::_MachineBase::free ( unsigned int count )

protected

 {
     // Free from end of list, so that child states are freed first
     unsigned int i = count;
     while (i > 0) {
         --i;
         delete myInstances[i];
         myInstances[i] = nullptr;
     }
 }

_StateInstance*& inet::Macho::_MachineBase::getInstance ( ID id )

inlineprotected

Referenced by inet::Macho::_StateSpecification::_getInstance(), inet::Macho::MachoLink< C, P >::_getInstance(), inet::Macho::_AdaptingInitializer::adapt(), inet::Macho::MachoLink< C, P >::clearHistory(), inet::Macho::MachoLink< C, P >::clearHistoryDeep(), inet::Macho::MachoLink< C, P >::history(), and inet::Macho::_StateInstance::init().

     {
         return myInstances[id];
     }

const _StateInstance* inet::Macho::_MachineBase::getInstance ( ID id ) const

inlineprotected

     {
         return myInstances[id];
     }

void inet::_MachineBase::rattleOn ( )

protected

 {
     assert(myCurrentState);
 
     while (myPendingState || myPendingEvent) {
         // Loop here because init actions might change state again.
         while (myPendingState) {
             MACHO_TRC3(myCurrentState->name(), "Transition to", myPendingState->name());
 
 #ifndef NDEBUG
             // Entry/Exit actions may not dispatch events: set dummy event.
             if (!myPendingEvent)
                 myPendingEvent = (_IEventBase *)&myPendingEvent;
 #endif // ifndef NDEBUG
 
             // Perform exit actions (which exactly depends on new state).
             myCurrentState->exit(*myPendingState);
 
             // Store history information for previous state now.
             // Previous state will be used for deep history.
             myCurrentState->setHistorySuper(*myCurrentState);
 
             _StateInstance *previous = myCurrentState;
             myCurrentState = myPendingState;
 
             // Deprecated!
             if (myPendingBox) {
                 myCurrentState->setBox(myPendingBox);
                 myPendingBox = nullptr;
             }
 
             // Perform entry actions on next state's parents (which exactly depends on previous state).
             myCurrentState->entry(*previous);
 
             // State transition complete.
             // Clear 'pending' information just now so that setState would assert in exits and entries, but not in init.
             myPendingState = nullptr;
 
             // Use initializer to call proper "init" action.
             _Initializer *init = myPendingInit;
             myPendingInit = nullptr;
 
             init->execute(*myCurrentState);
             init->destroy();
 
             assert("Init may only transition to proper substates" &&
                     (!myPendingState ||
                      (myPendingState->isChild(*myCurrentState) && (myCurrentState != myPendingState)))
                     );
 
 #ifndef NDEBUG
             // Clear dummy event if need be
             if (myPendingEvent == (_IEventBase *)&myPendingEvent)
                 myPendingEvent = nullptr;
 #endif // ifndef NDEBUG
         }    // while (myPendingState)
 
         if (myPendingEvent) {
             _IEventBase *event = myPendingEvent;
             myPendingEvent = nullptr;
             event->dispatch(*myCurrentState);
             delete event;
         }
     }    // while (myPendingState || myPendingEvent)
 }    // rattleOn

void inet::Macho::_MachineBase::setPendingEvent ( _IEventBase * event )

inlineprotected

     {
         assert(event);
         assert(!myPendingEvent && "There is already an event pending!");
 
         myPendingEvent = event;
     }

void inet::Macho::_MachineBase::setPendingState	(	_StateInstance &	instance,
		_Initializer *	init
	)

inlineprotected

Referenced by inet::Macho::_StateInstance::init(), inet::Macho::_StateSpecification::setState(), inet::Macho::Alias::setState(), inet::Macho::_StateSpecification::setStateBox(), inet::Macho::_StateSpecification::setStateDirect(), and inet::Macho::_StateSpecification::setStateHistory().

     {
         assert((!myPendingState || (myPendingState == &instance && myPendingInit == init)) &&
                 "There is already a state transition pending!");
 
         myPendingState = &instance;
         myPendingInit = init;
     }

void inet::_MachineBase::setState	(	_StateInstance &	instance,
		_Initializer *	init
	)

protected

 {
     setPendingState(instance, init);
     rattleOn();
 }

void inet::_MachineBase::setState ( const Alias & state )

protected

 {
     state.setState(*this);
     rattleOn();
 }

void inet::_MachineBase::shutdown ( )

protected

 {
     assert(!myPendingState);
 
     MACHO_TRC1("Shutting down Machine");
 
     // Performs exit actions by going to Root (=StateSpecification) state.
     setState(_StateSpecification::_getInstance(*this), &_theDefaultInitializer);
 
     myCurrentState = nullptr;
 }

void inet::_MachineBase::start ( _StateInstance & instance )

protected

 {
     MACHO_TRC1("Starting Machine");
 
     // Start with Root state
     myCurrentState = &_StateSpecification::_getInstance(*this);
     // Then go to state
     setState(instance, &_theDefaultInitializer);
 }

void inet::_MachineBase::start ( const Alias & state )

protected

 {
     MACHO_TRC1("Starting Machine");
 
     // Start with Root state
     myCurrentState = &_StateSpecification::_getInstance(*this);
     // Then go to state
     setState(state);
 }