sm::StateMachine Class Reference

#include <StateMachine.h>

Inheritance diagram for sm::StateMachine:

Public Member Functions
	StateMachine (unsigned int initialStateId)
virtual	~StateMachine ()
bool	update ()
	process events and update current state More...
virtual std::string	getPrintableState (unsigned int state)=0
Public Member Functions inherited from sm::EventHandler
void	addEvent (Event *e)

Protected Member Functions
template<class SM , class Data , void(SM::*)(const Data *, const bool, const bool) Func>
void	registerState (unsigned int stateId)
	register state processing functions from deriving class More...

Private Attributes
unsigned int	_currentStateId = 0
std::map< unsigned int, sm::StateBase * >	_stateActions

Additional Inherited Members
Protected Attributes inherited from sm::EventHandler
std::queue< Event * >	_events

Detailed Description

• Transfer id of initial state in constructor of StateMachine
• Define state functions like: void <name>(const sm::EventData* data);
• call registerState in constructor which maps a state function to an state id

Definition at line 78 of file StateMachine.h.

Constructor & Destructor Documentation

StateMachine()

sm::StateMachine::StateMachine ( unsigned int  initialStateId )

explicit

Definition at line 20 of file StateMachine.cpp.

  : _currentStateId(initialStateId)
{
}

~StateMachine()

sm::StateMachine::~StateMachine ( )

virtual

Definition at line 25 of file StateMachine.cpp.

{
    for (auto it : _stateActions)
    {
        delete it.second;
    }
};

Member Function Documentation

getPrintableState()

virtual std::string sm::StateMachine::getPrintableState ( unsigned int  state )

pure virtual

registerState()

template<class SM , class Data , void(SM::*)(const Data *, const bool, const bool) Func>

void sm::StateMachine::registerState ( unsigned int  stateId )

inlineprotected

register state processing functions from deriving class

Definition at line 96 of file StateMachine.h.

    {
        assert(_stateActions.find(stateId) == _stateActions.end());
        _stateActions[stateId] = new StateAction<SM, Data, Func>();
    }

update()

bool sm::StateMachine::update

(

)

process events and update current state

Definition at line 33 of file StateMachine.cpp.

{
    sm::EventData* data            = nullptr;
    bool           stateEntry      = false;
    bool           stateWasUpdated = false;
    // invoke state action for every valid event, but at least once
    while (!_events.empty())
    {
        Event* e = _events.front();
        _events.pop();
 
        unsigned int newState = e->getNewState(_currentStateId);
        data                  = e->getEventData();
 
        LOG_STATEMACHINE_DEBUG("Event %s received sent by %s",
                               e->name(),
                               e->senderInfo());
 
        if (newState != Event::EVENT_IGNORED)
        {
            if (_currentStateId != newState)
            {
                stateEntry = true;
                LOG_STATEMACHINE_DEBUG("State change: %s -> %s",
                                       getPrintableState(_currentStateId).c_str(),
                                       getPrintableState(newState).c_str());
 
                // inform old state that we will leave it soon
                auto itStateAction = _stateActions.find(_currentStateId);
                if (itStateAction != _stateActions.end())
                {
                    itStateAction->second->invokeStateAction(this,
                                                             data,
                                                             false,
                                                             true);
                }
                else
                {
                    std::stringstream ss;
                    ss << "You forgot to register state "
                       << getPrintableState(_currentStateId)
                       << "!";
                    Utils::exitMsg("StateMachine",
                                   ss.str().c_str(),
                                   __LINE__,
                                   __FILE__);
                }
 
                // update state
                _currentStateId = newState;
            }
            auto itStateAction = _stateActions.find(_currentStateId);
            if (itStateAction != _stateActions.end())
            {
                itStateAction->second->invokeStateAction(this,
                                                         data,
                                                         stateEntry,
                                                         false);
            }
            else
            {
                std::stringstream ss;
                ss << "You forgot to register state "
                   << getPrintableState(_currentStateId)
                   << "!";
                Utils::exitMsg("StateMachine",
                               ss.str().c_str(),
                               __LINE__,
                               __FILE__);
            }
            stateWasUpdated = true;
        }
        else
        {
            LOG_STATEMACHINE_DEBUG("Event %s ignored in state %s",
                                   e->name(),
                                   getPrintableState(_currentStateId).c_str());
        }
 
        delete e;
    }
 
    if (!stateWasUpdated)
        _stateActions[_currentStateId]->invokeStateAction(this, data, stateEntry, false);
 
    // ATTENTION: data ownership is not transferred to state
    delete data;
 
    return true;
}

Member Data Documentation

_currentStateId

unsigned int sm::StateMachine::_currentStateId = 0

private

Definition at line 103 of file StateMachine.h.

_stateActions

std::map<unsigned int, sm::StateBase*> sm::StateMachine::_stateActions

private

Definition at line 105 of file StateMachine.h.

---

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

• StateMachine.h
• StateMachine.cpp