gstatemachine.h

Go to the documentation of this file.

//
// Copyright (C) 2001-2013 Graeme Walker <graeme_walker@users.sourceforge.net>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
// ===

#ifndef G_STATE_MACHINE_H
#define G_STATE_MACHINE_H

#include "gdef.h"
#include "gexception.h"
#include <map>

namespace G
{

G_EXCEPTION_CLASS( StateMachine_Error , "invalid state machine transition" ) ;

template <typename T, typename State, typename Event, typename Arg = std::string>
class StateMachine 
{
public:
        typedef void (T::*Action)(const Arg &, bool &) ;
        typedef StateMachine_Error Error ;

        StateMachine( State s_start , State s_end , State s_same , State s_any ) ;

        void addTransition( Event event , State from , State to , Action action ) ;

        void addTransition( Event event , State from , State to , Action action , State alt ) ;

        State apply( T & t , Event event , const Arg & arg ) ;

        State state() const ;

        State reset( State new_state ) ;

private:
        struct Transition 
        { 
                State from ; 
                State to ; 
                State alt ; // alternate "to" state if predicate false
                Action action ; 
                Transition(State s1,State s2,Action a,State s3) :
                        from(s1) , to(s2) , alt(s3) , action(a) {}
        } ;
        typedef std::multimap<Event,Transition> Map ;
        typedef typename Map::value_type Map_value_type ;
        Map m_map ;
        State m_state ;
        State m_end ;
        State m_same ;
        State m_any ;
} ;

template <typename T, typename State, typename Event, typename Arg>
StateMachine<T,State,Event,Arg>::StateMachine( State s_start , State s_end , State s_same , State s_any ) :
        m_state(s_start) ,
        m_end(s_end) ,
        m_same(s_same) ,
        m_any(s_any)
{
}

template <typename T, typename State, typename Event, typename Arg>
void StateMachine<T,State,Event,Arg>::addTransition( Event event , State from , State to , Action action )
{
        addTransition( event , from , to , action , to ) ;
}

template <typename T, typename State, typename Event, typename Arg>
void StateMachine<T,State,Event,Arg>::addTransition( Event event , State from , State to , Action action , State alt )
{
        if( to == m_any || alt == m_any )
                throw Error( "\"to any\" is invalid" ) ;

        if( from == m_same )
                throw Error( "\"from same\" is invalid" ) ;

        if( to == m_end && alt != to )
                throw Error( "predicates on end-state transitions are invalid" ) ;

        if( alt == m_end && to != m_end )
                throw Error( "false predicates cannot take you to the end state" ) ;

        m_map.insert( Map_value_type( event , Transition(from,to,action,alt) ) ) ;
}

template <typename T, typename State, typename Event, typename Arg>
State StateMachine<T,State,Event,Arg>::reset( State new_state )
{
        State old_state = m_state ;
        m_state = new_state ;
        return old_state ;
}

template <typename T, typename State, typename Event, typename Arg>
State StateMachine<T,State,Event,Arg>::state() const
{
        return m_state ;
}

template <typename T, typename State, typename Event, typename Arg>
State StateMachine<T,State,Event,Arg>::apply( T & t , Event event , const Arg & arg )
{
        State state = m_state ;
        typename Map::iterator p = m_map.find(event) ; // look up in the multimap keyed on event + current-state
        for( ; p != m_map.end() && (*p).first == event ; ++p )
        {
                if( (*p).second.from == m_any || (*p).second.from == m_state )
                {
                        State old_state = m_state ; // change state
                        if( (*p).second.to != m_same )
                                state = m_state = (*p).second.to ;

                        State end = m_end ; // (avoid using members after the action method call)

                        bool predicate = true ;
                        (t.*((*p).second.action))( arg , predicate ) ; // perform action

                        if( state != end && !predicate ) // respond to predicate
                        {
                                State alt_state = (*p).second.alt ;
                                state = m_state = alt_state == m_same ? old_state : alt_state ;
                        }
                        return state ;
                }
        }
        return m_any ;
}

}

#endif