inet::Macho::_MachineBase Class Reference

#include <Macho.h>

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

_MachineBase()

inet::_MachineBase::_MachineBase ( )

protected

{
}

~_MachineBase()

inet::_MachineBase::~_MachineBase ( )

protected

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

Member Function Documentation

allocate()

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

protected

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

clearHistoryDeep()

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

protected

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

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

currentState()

Alias inet::_MachineBase::currentState

(

)

const

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

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

free()

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;
    }
}

getInstance() [1/2]

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

inlineprotected

    {
        return myInstances[id];
    }

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(), and inet::Macho::MachoLink< C, P >::history().

getInstance() [2/2]

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

inlineprotected

    {
        return myInstances[id];
    }

rattleOn()

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

Referenced by setState().

setPendingEvent()

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

inlineprotected

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

setPendingState()

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

inlineprotected

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

Referenced by inet::Macho::_StateInstance::init(), setState(), and inet::Macho::Alias::setState().

setState() [1/2]

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

protected

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

Referenced by shutdown(), and start().

setState() [2/2]

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

protected

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

shutdown()

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;
}

Referenced by inet::Macho::_StateSpecification::_shutdown().

start() [1/2]

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);
}

start() [2/2]

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);
}

Friends And Related Function Documentation

::inet::TestAccess

friend class ::inet::TestAccess

friend

_AdaptingInitializer

friend class _AdaptingInitializer

friend

_StateInstance

friend class _StateInstance

friend

_StateSpecification

friend class _StateSpecification

friend

Alias

friend class Alias

friend

Referenced by currentState().

MachoLink

template<class C , class P >

friend class MachoLink

friend

TopBase

template<class T >

friend class TopBase

friend

Member Data Documentation

myCurrentState

_StateInstance* inet::Macho::_MachineBase::myCurrentState = nullptr

protected

Referenced by inet::Macho::_StateSpecification::_restore(), currentState(), rattleOn(), shutdown(), and start().

myInstances

_StateInstance** inet::Macho::_MachineBase::myInstances = nullptr

protected

Referenced by allocate(), clearHistoryDeep(), free(), getInstance(), and ~_MachineBase().

myPendingBox

void* inet::Macho::_MachineBase::myPendingBox = nullptr

protected

Referenced by rattleOn().

myPendingEvent

_IEventBase* inet::Macho::_MachineBase::myPendingEvent = nullptr

protected

Referenced by rattleOn(), setPendingEvent(), and ~_MachineBase().

myPendingInit

_Initializer* inet::Macho::_MachineBase::myPendingInit = nullptr

protected

Referenced by rattleOn(), setPendingState(), and ~_MachineBase().

myPendingState

_StateInstance* inet::Macho::_MachineBase::myPendingState = nullptr

protected

Referenced by rattleOn(), setPendingState(), and shutdown().

---

The documentation for this class was generated from the following files:

• Macho.h
• Macho.cc