fsm.h

Go to the documentation of this file.

//
// Date:      23 January  2003
// Modified:  29 November 2003
//            01 December 2003
//            31 July     2004
//            01 August   2004
//            07 August   2004   Doxygen remarks
//            20 August   2005   exception safety changes
//
// Copyright (c) Sergey Satskiy 2003 - 2005
//               <sergesatsky@yahoo.com>
//
// Permission to copy, use, modify, sell and distribute this software 
// is granted provided this copyright notice appears in all copies. 
// This software is provided "as is" without express or implied
// warranty, and with no claim as to its suitability for any purpose.
//


#ifndef FSMTEMPLATE_H
#define FSMTEMPLATE_H

#include <vector>
#include <algorithm>
#include <stdexcept>
#include <deque>
#include <string>
#include <functional>
#include <iterator>
#include <iostream>
#include <boost/function.hpp>




#define FSM_BEGIN( StartFSMState ) (StartFSMState),                         \
                                   FSM::SStateMachineProxy<FSMStateType,    \
                                                           FSMEventType>    \
                                       () << (                              \
                                   FSM::SStatesListProxy<FSMStateType>() <<


#define FSM_STATES


#define FSM_EVENT( Arg )           )                                        \
                                   << (FSM::STransitionsProxy<FSMStateType, \
                                                              FSMEventType> \
                                      ( Arg ) <<


#define FSM_END                    )


#define FSM_RESET                   FSM::ResetMachine




#define FUNCFSM_BEGIN( StartFSMState ) (StartFSMState),                         \
                                   FSM::SFuncStateMachineProxy<FSMStateType,    \
                                                               FSMEventType>    \
                                       () << (                                  \
                                   FSM::SStatesListProxy<FSMStateType>() <<


#define FUNCFSM_STATES


#define FUNCFSM_EVENT( Arg )           )                                        \
                                   << (FSM::SFuncTransitionsProxy<FSMStateType, \
                                                                  FSMEventType> \
                                      ( Arg ) <<


#define FUNCFSM_END                    )


#define FUNCFSM_RESET                   FSM::ResetMachine
                                      



namespace FSM
{

    enum SMachineManipulator 
    { 
        ResetMachine = 0        
    };


    enum STransitionManipulator 
    { 
        NONE = 0,               
        EXCEPTION = 1           
    };
    

    class SStateMachineException : public std::exception
    {
        private:
            const std::string      Message;

        public:
            SStateMachineException( const std::string &  Msg ) : Message( Msg ) 
            {}

            SStateMachineException( const char *         Msg ) : Message( Msg ) 
            {}

            virtual const char * what( void ) const throw() 
            { return Message.c_str(); }

            virtual ~SStateMachineException() throw () {}

        private:
            SStateMachineException();
    };


    template < typename SState, typename SEvent >
    class SEmptyFunctor
    {
        public:
            void operator() ( const SState &, 
                              const SEvent &, 
                              const SState &  ) 
            { return; }
    };


    template < typename SState, typename SEvent >
    class SOnEnterFunctor
    {
        public:
            void operator() ( SState &        From, 
                              const SEvent &  Event, 
                              SState &        To )
            { To.OnEnter( From, Event ); }
    };


    template < typename SState, typename SEvent >
    class SOnExitFunctor
    {
        public:
            void operator() ( SState &        From, 
                              const SEvent &  Event, 
                              SState &        To )
            { From.OnExit( Event, To ); }
    };


    template < typename SState, typename SEvent >
    class SOnMoveFunctor
    {
        public:
            void operator() ( SState &        From, 
                              const SEvent &  Event, 
                              SState &        To )
            { 
              const SState &  FromConst( From );
              const SState &  ToConst( To );
  
              From.OnExit( Event, ToConst ); 
              To.OnEnter( FromConst, Event ); 
            }
    };
        

    template < typename SEvent >
    class SThrowStrategy
    {
        public:
            void operator() ( const SEvent & ) const 
            { throw SStateMachineException( "Unknown event." ); }
    };


    template < typename SEvent >
    class SIgnoreStrategy
    {
        public:
            void operator() ( const SEvent & ) const 
            { return; }
    };




        //
        // Temporary class to collect all the registered states
        //
    template < typename SState >
    class SStatesListProxy
    {
        private:
            std::vector<SState>    StatesProxy;

        public:
            SStatesListProxy() { return; }

            SStatesListProxy &  operator << ( const SState &  TheState )
            { 
                    // Check whether the state is unique
                if ( std::find( StatesProxy.begin(), 
                                StatesProxy.end(), 
                                TheState ) != StatesProxy.end() )
                {
                    throw SStateMachineException( "States must be unique." );
                }
                StatesProxy.push_back( TheState ); 
                return *this; 
            }

            const std::vector<SState> &  GetStates( void ) const 
            { return StatesProxy; }
    };

    



        //
        // Temporary class to collect transitions for a single event
        //
    template < typename SState, typename SEvent >
    class STransitionsProxy
    {
        private:
            SEvent                  Event;
            std::vector<SState>     NewStates;
            std::vector< int >      Manipulators;

        public:
            explicit STransitionsProxy( const SEvent &  TheEvent ) : 
                Event( TheEvent ) 
            { return; }

            STransitionsProxy & operator << ( const SState &  TheState ) 
            { 
                NewStates.push_back( TheState ); 
                Manipulators.push_back( -1 );
                return *this; 
            }

            STransitionsProxy & operator << ( const STransitionManipulator &  Manipulator )
            {
                NewStates.push_back( SState() );
                Manipulators.push_back( Manipulator );
                return *this;
            }

            const std::vector<SState> &  GetStates( void ) const 
            { return NewStates; }

            const std::vector<int> &  GetManipulators( void ) const
            { return Manipulators; }

            const SEvent &  GetEvent( void ) const 
            { return Event; }

        private:
            STransitionsProxy();
    };





        //
        // Temporary class to collect all the transitions
        //
    template < typename SState, typename SEvent >
    class SStateMachineProxy
    {
            typedef SState                   StateType;
            typedef SEvent                   EventType;
            typedef std::vector<StateType>   SStatesList;
            typedef std::vector<EventType>   SEventsList;

            typedef std::vector< int >       SManipulatorsList;

        private:
            SStatesList                     MachineStatesProxy;
            bool                            HaveStates;
            SEventsList                     MachineEventsProxy;
            std::vector<SStatesList>        Transitions;
            std::vector<SManipulatorsList>  TransitionsManipulators;
    
        public:
            SStateMachineProxy() : HaveStates( false ) 
            { return; }

            SStateMachineProxy & operator << 
                ( const SStatesListProxy<SState> &   TheStates )
            { 
                if ( HaveStates ) 
                {
                    throw SStateMachineException( "Too much state lists." );
                }
                HaveStates = true;
                MachineStatesProxy = TheStates.GetStates();
                return *this; 
            }

            SStateMachineProxy & operator << 
                ( const STransitionsProxy<SState,SEvent> &  TheTransitions )
            { 
                if ( !HaveStates ) 
                {
                    throw SStateMachineException( "States must be defined "
                                                  "before the transitions." );
                }
            
                if ( MachineStatesProxy.size() != 
                         TheTransitions.GetStates().size() ) 
                {
                    throw SStateMachineException( "Transition states do not "
                                                  "coincide to the states list." );
                }

                    // Check that the event is unique
                if ( std::find( MachineEventsProxy.begin(), 
                                MachineEventsProxy.end(), 
                                TheTransitions.GetEvent() ) 
                         != MachineEventsProxy.end() ) 
                {
                    throw SStateMachineException( "Events must be unique." );
                }
                    
                    // Check the transition validity
                CheckTransitionValidity( TheTransitions.GetStates().begin(), 
                                         TheTransitions.GetStates().end(),
                                         TheTransitions.GetManipulators().begin(),
                                         TheTransitions.GetManipulators().begin() );

                MachineEventsProxy.push_back( TheTransitions.GetEvent() );
                Transitions.push_back( TheTransitions.GetStates() );
                TransitionsManipulators.push_back( TheTransitions.GetManipulators() );
                return *this; 
            }
                
                
                //
                // Check that the transitions lead to a registered state
                //
            void CheckTransitionValidity( 
                    typename SStatesList::const_iterator  First, 
                    typename SStatesList::const_iterator  Last,
                    std::vector<int>::const_iterator      ManipulatorFirst,
                    std::vector<int>::const_iterator      ManipulatorLast )
            {
                for ( ; First != Last; ++First, ++ManipulatorFirst )
                {
                    if ( *ManipulatorFirst == -1 )  // It's not a manipulator
                    {
                        if ( std::find( MachineStatesProxy.begin(), 
                                        MachineStatesProxy.end(), *First ) 
                                 == MachineStatesProxy.end() ) 
                        {
                            throw SStateMachineException( "Transition state "
                                                          "is not valid." );
                        }
                    }
                }
            }       

            const SStatesList &  GetStates( void ) const
            { return MachineStatesProxy; }

            const std::vector<SStatesList> & GetTransitions( void ) const
            { return Transitions; }

            const std::vector<SManipulatorsList> &  GetManipulators( void ) const
            { return TransitionsManipulators; }

            const SEventsList &  GetEvents( void ) const
            { return MachineEventsProxy; }
    };



            
    template < typename SState, 
               typename SEvent, 
               typename SFunctor = SEmptyFunctor<SState,SEvent>, 
               typename SUnknownEventStrategy = SThrowStrategy<SEvent> > 
    class SStateMachine
    {
        public:
            typedef SState                          StateType;
            typedef SEvent                          EventType;
            typedef std::vector<StateType>          SStatesList;
            typedef std::vector<EventType>          SEventsList;
            typedef std::vector<SStatesList>        TransitionsType;
            typedef std::deque<EventType>           EventsQueueType;
            typedef std::vector<int>                ManipulatorsList;
            typedef std::vector<ManipulatorsList>   ManipulatorsType;

        private:
            StateType              CurrentState;          // Current machine state
            SStatesList            States;                // A list of the registered states
            SEventsList            Events;                // A list of the registered events
            TransitionsType        Transitions;           // A table of transitions between states
            ManipulatorsType       Manipulators;          // A table of manipulators
            SFunctor               Functor;               // Transition function
            SUnknownEventStrategy  UnknownEventStrategy;  // Unknown event strategy
            EventsQueueType        EventsQueue;           // Internal events queue to support events 
                                                          //   that were generated in the transition 
                                                          //   functions
            bool                   InProcess;             // To be sure that we are processing the events
            int                    CurrentStateIndex;     // Index of column in a transition table 
                                                          //   (0 - based)
            StateType              InitialState;          // Start machine state

        public:
            SStateMachine( const StateType &  StartState, 
                           const SStateMachineProxy<StateType,
                                                    EventType> &  ProxyMachine ) :
                CurrentState( StartState ), 
                States( ProxyMachine.GetStates() ),
                Events( ProxyMachine.GetEvents() ), 
                Transitions( ProxyMachine.GetTransitions() ), 
                Manipulators( ProxyMachine.GetManipulators() ),
                InProcess( false ),
                CurrentStateIndex( -1 ), 
                InitialState( StartState )
            {
                    // Check that the start state is valid
                typename SStatesList::iterator  k( std::find( States.begin(), 
                                                              States.end(), 
                                                              StartState ) );
                if ( k == States.end() ) 
                {
                    throw SStateMachineException( "Start state is invalid." );
                }
                CurrentStateIndex = std::distance( States.begin(), k );
            }


            SStateMachine & Reset( void ) 
            {
                CurrentState = InitialState; 
                CurrentStateIndex = GetStateIndex( CurrentState );
                InProcess = false;
                EventsQueue.clear();
                return *this;
            }


            StateType GetCurrentState( void ) const 
            { return CurrentState; }



            SStateMachine &  AcceptEvent( const EventType &  Event )
            {
                EventsQueue.push_back( Event );
                if ( InProcess ) return *this;
                InProcess = true;
                while ( !EventsQueue.empty() )
                {
                    ProcessEvent( EventsQueue.front() );
                    EventsQueue.pop_front();
                }
                InProcess = false;
                return *this;
            }


            SStateMachine & operator << ( const EventType &  Event )
            { return AcceptEvent( Event ); }


            SStateMachine & operator << ( SMachineManipulator Manipulator )
            { 
                if ( Manipulator != ResetMachine ) 
                {
                    Reset();
                    throw SStateMachineException( "Unknown manipulator. Machine is reset." );
                }
                return Reset();
            } 
        
        private:
            void ProcessEvent( const EventType &  Event )
            {   
                try
                {
                    int  EventIndex( GetEventIndex( Event ) );
                    if ( EventIndex == -1 ) return;

                    StateType      OldState( CurrentState );
            
                    if ( (Manipulators[EventIndex])[CurrentStateIndex] == EXCEPTION )
                    {
                        throw SStateMachineException( "Transition is forbidden. Machine is reset." );
                    }
                
                    if ( (Manipulators[EventIndex])[CurrentStateIndex] == NONE )
                    {
                        return;
                    }

                    CurrentState = (Transitions[EventIndex])[CurrentStateIndex];
                    CurrentStateIndex = GetStateIndex( CurrentState );

                    Functor( OldState, Event, CurrentState );
                }
                catch ( ... )
                {
                    Reset();
                    throw;
                }
            }
        
            int GetEventIndex( const EventType &  Event ) const
            {   
                typename SEventsList::const_iterator   k( std::find( Events.begin(), 
                                                                     Events.end(), 
                                                                     Event ) );
                if ( k == Events.end() ) 
                { 
                    UnknownEventStrategy( Event ); 
                    return -1; 
                }
                return std::distance( Events.begin(), k );
            }

            int GetStateIndex( const StateType &  State ) const
            {
                return std::distance( States.begin(), 
                                      std::find( States.begin(), 
                                                 States.end(), 
                                                 State ) );
            }

        private:
                //
                // Prevent the illegal usage
                //
            SStateMachine();
            SStateMachine & operator= ( const SStateMachine & );
            SStateMachine( const SStateMachine & );
    };
    


    template < typename SState, 
               typename SEvent, 
               typename SFunctor, 
               typename SUnknownEventStrategy > 
        std::ostream & operator << (std::ostream &  Stream, 
                                    const SStateMachine<SState,
                                                        SEvent,
                                                        SFunctor,
                                                        SUnknownEventStrategy> &  Machine )
    { return Stream << Machine.GetCurrentState(); }
    



        //
        // Second vertion of the finite state machine where functions are
        // linked to transitions but not to the states
        //
    

    template < typename  Child,
               typename  Event >
    class StateBase
    {
            // Should all of them be const? - No. It is easy to imagine that
            // some fields in the states and events should be changed
        typedef boost::function< void ( Child &,
                                        Event &,
                                        Child & ) >   CallbackType;

        private:
            CallbackType    Callback;

        protected:
            StateBase() : Callback( 0 ) {}

        public:
            Child & operator [] ( const CallbackType &  NewCallback )
            {
                Callback = NewCallback;
                return static_cast< Child & >( *this );
            }
            
            CallbackType  GetCallback( void )
            {
                CallbackType        Temporary( Callback );

                Callback = 0;
                return Temporary;
            }
    };



        // A bundle of the state related information
    template < typename SState, typename SEvent >
    struct SFuncBundle
    {
        SState                                  NewState;
        int                                     Manipulator;
        boost::function< void ( SState &,
                                SEvent &,
                                SState & ) >    Callback;

        SFuncBundle() {}
    };



        // Start state spec is the same as in the first version
        // States list is the same as in the first version

        // Transition accepting class is different.
        // Let's define it.



        //
        // Temporary class to collect transitions for a single event
        //
    template < typename SState, typename SEvent >
    class SFuncTransitionsProxy
    {
        typedef SFuncBundle< SState, SEvent >   Bundle;
        
        private:
            SEvent                  Event;
            std::vector<Bundle>     NewStates;

        public:
            explicit SFuncTransitionsProxy( const SEvent &  TheEvent ) : 
                Event( TheEvent ) 
            { return; }

            SFuncTransitionsProxy & operator << ( SState &  TheState ) 
            { 
                Bundle      NewBundle;

                NewBundle.NewState = TheState;
                NewBundle.Manipulator = -1;
                NewBundle.Callback = TheState.GetCallback();

                NewStates.push_back( NewBundle );
                return *this; 
            }

            SFuncTransitionsProxy & operator << ( const STransitionManipulator &  Manipulator )
            {
                Bundle      NewBundle;

                NewBundle.NewState = SState();
                NewBundle.Manipulator = Manipulator;
                NewBundle.Callback = 0;
                
                NewStates.push_back( NewBundle );
                return *this;
            }

            const std::vector<Bundle> &  GetStates( void ) const 
            { return NewStates; }

            const SEvent &  GetEvent( void ) const 
            { return Event; }

        private:
            SFuncTransitionsProxy();
    };



               

        //
        // Temporary class to collect all the transitions
        //
    template < typename SState, typename SEvent >
    class SFuncStateMachineProxy
    {
        typedef SFuncBundle< SState, SEvent >   Bundle;
        
        typedef SState                   StateType;
        typedef SEvent                   EventType;
        typedef std::vector<StateType>   SStatesList;
        typedef std::vector<EventType>   SEventsList;
        typedef std::vector< Bundle >    SBundlesList;

        private:
            SStatesList                     MachineStatesProxy;
            bool                            HaveStates;
            SEventsList                     MachineEventsProxy;
            std::vector<SBundlesList>       Transitions;
    
        public:
            SFuncStateMachineProxy() : HaveStates( false ) 
            { return; }

            SFuncStateMachineProxy & operator << 
                ( const SStatesListProxy<SState> &   TheStates )
            { 
                if ( HaveStates ) 
                {
                    throw SStateMachineException( "Too much state lists." );
                }
                HaveStates = true;
                MachineStatesProxy = TheStates.GetStates();
                return *this; 
            }

            SFuncStateMachineProxy & operator << 
                ( const SFuncTransitionsProxy<SState,SEvent> &  TheTransitions )
            { 
                if ( !HaveStates ) 
                {
                    throw SStateMachineException( "States must be defined "
                                                  "before the transitions." );
                }
            
                if ( MachineStatesProxy.size() != 
                         TheTransitions.GetStates().size() ) 
                {
                    throw SStateMachineException( "Transition states do not "
                                                  "coincide to the states list." );
                }

                    // Check that the event is unique
                if ( std::find( MachineEventsProxy.begin(), 
                                MachineEventsProxy.end(), 
                                TheTransitions.GetEvent() ) 
                         != MachineEventsProxy.end() ) 
                {
                    throw SStateMachineException( "Events must be unique." );
                }
                    
                    // Check the transition validity
                CheckTransitionValidity( TheTransitions.GetStates().begin(), 
                                         TheTransitions.GetStates().end()      );

                MachineEventsProxy.push_back( TheTransitions.GetEvent() );
                Transitions.push_back( TheTransitions.GetStates() );
                return *this; 
            }
                
                
                //
                // Check that the transitions lead to a registered state
                //
            void CheckTransitionValidity( 
                    typename std::vector<Bundle>::const_iterator  First, 
                    typename std::vector<Bundle>::const_iterator  Last )
            {
                for ( ; First != Last; ++First )
                {
                    if ( First->Manipulator == -1 )  // It's not a manipulator
                    {
                        if ( std::find( MachineStatesProxy.begin(), 
                                        MachineStatesProxy.end(), First->NewState ) 
                                 == MachineStatesProxy.end() ) 
                        {
                            throw SStateMachineException( "Transition state "
                                                          "is not valid." );
                        }
                    }
                }
            }       

            const SStatesList &  GetStates( void ) const
            { return MachineStatesProxy; }

            const std::vector<SBundlesList> & GetTransitions( void ) const
            { return Transitions; }

            const SEventsList &  GetEvents( void ) const
            { return MachineEventsProxy; }
    };




    template < typename SState, 
               typename SEvent, 
               typename SUnknownEventStrategy = SThrowStrategy<SEvent> > 
    class SFuncStateMachine
    {
        public:
        typedef SFuncBundle< SState, SEvent >   Bundle;

        typedef SState                          StateType;
        typedef SEvent                          EventType;
        typedef std::vector<StateType>          SStatesList;
        typedef std::vector<EventType>          SEventsList;
        typedef std::vector<SStatesList>        TransitionsType;
        typedef std::deque<EventType>           EventsQueueType;
        typedef std::vector< Bundle >           SBundlesList;

        private:
            StateType                   CurrentState;          // Current machine state
            SStatesList                 States;                // A list of the registered states
            SEventsList                 Events;                // A list of the registered events
            std::vector<SBundlesList>   Transitions;           // A table of transitions between states
            SUnknownEventStrategy       UnknownEventStrategy;  // Unknown event strategy
            EventsQueueType             EventsQueue;           // Internal events queue to support events 
                                                               //   that were generated in the 
                                                               //   transition functions
            bool                        InProcess;             // To be sure that we are processing 
                                                               //   the events
            int                         CurrentStateIndex;     // Index of column in a transition 
                                                               //   table (0 - based)
            StateType                   InitialState;          // Start machine state

        public:
            SFuncStateMachine( const StateType &  StartState, 
                               const SFuncStateMachineProxy<StateType,
                                                            EventType> &  ProxyMachine ) :
                CurrentState( StartState ), 
                States( ProxyMachine.GetStates() ),
                Events( ProxyMachine.GetEvents() ), 
                Transitions( ProxyMachine.GetTransitions() ), 
                InProcess( false ),
                CurrentStateIndex( -1 ), 
                InitialState( StartState )
            {
                    // Check that the start state is valid
                typename SStatesList::iterator  k( std::find( States.begin(), 
                                                              States.end(), 
                                                              StartState ) );
                if ( k == States.end() ) 
                {
                    throw SStateMachineException( "Start state is invalid." );
                }
                CurrentStateIndex = std::distance( States.begin(), k );
            }


            SFuncStateMachine & Reset( void ) 
            {
                CurrentState = InitialState; 
                CurrentStateIndex = GetStateIndex( CurrentState );
                InProcess = false;
                EventsQueue.clear();
                return *this;
            }


            StateType GetCurrentState( void ) const 
            { return CurrentState; }


            SFuncStateMachine &  AcceptEvent( EventType &  Event )
            {
                EventsQueue.push_back( Event );
                if ( InProcess ) return *this;
                InProcess = true;
                while ( !EventsQueue.empty() )
                {
                    ProcessEvent( EventsQueue.front() );
                    EventsQueue.pop_front();
                }
                InProcess = false;
                return *this;
            }

            SFuncStateMachine & operator << ( EventType &  Event )
            { return AcceptEvent( Event ); }


            SFuncStateMachine & operator << ( SMachineManipulator Manipulator ) 
            { 
                if ( Manipulator != ResetMachine ) 
                {
                    Reset();
                    throw SStateMachineException( "Unknown manipulator. Machine is reset." );
                }
                return Reset();
            } 
        
        private:
            void ProcessEvent( EventType &  Event )
            {   
                try
                {
                    int  EventIndex( GetEventIndex( Event ) );
                    if ( EventIndex == -1 ) return;

                    StateType      OldState( CurrentState );
            
                    if ( Transitions[EventIndex][CurrentStateIndex].Manipulator == EXCEPTION )
                    {
                        throw SStateMachineException( "Transition is forbidden. Machine is reset." );
                    }

                    if ( Transitions[EventIndex][CurrentStateIndex].Manipulator == NONE )
                    {
                        return;
                    }

                    boost::function< void ( SState &, SEvent &, SState & ) >    
                            Functor( Transitions[EventIndex][CurrentStateIndex].Callback );
                
                    CurrentState = Transitions[EventIndex][CurrentStateIndex].NewState;
                    CurrentStateIndex = GetStateIndex( CurrentState );

                    if ( Functor != 0 )     Functor( OldState, Event, CurrentState );
                }
                catch ( ... )
                {
                    Reset();
                    throw;
                }
            }
        

            int GetEventIndex( const EventType &  Event ) const
            {   
                typename SEventsList::const_iterator   k( std::find( Events.begin(), 
                                                                     Events.end(), 
                                                                     Event ) );
                if ( k == Events.end() ) 
                { 
                    UnknownEventStrategy( Event ); 
                    return -1; 
                }
                return std::distance( Events.begin(), k );
            }

            int GetStateIndex( const StateType &  State ) const
            {
                return std::distance( States.begin(), 
                                      std::find( States.begin(), 
                                                 States.end(), 
                                                 State ) );
            }

        private:
                //
                // Prevent the illegal usage
                //
            SFuncStateMachine();
            SFuncStateMachine & operator= ( const SFuncStateMachine & );
            SFuncStateMachine( const SFuncStateMachine & );
    };
    

    template < typename SState, 
               typename SEvent, 
               typename SUnknownEventStrategy > 
        std::ostream & operator << (std::ostream &  Stream, 
                                    const SFuncStateMachine<SState,
                                                            SEvent,
                                                            SUnknownEventStrategy> &  Machine )
    { return Stream << Machine.GetCurrentState(); }
    
    
               
}   // End of the FSM namespace

#endif

---