fsm.hpp

#ifndef QOS_CPP_FSM
#define QOS_CPP_FSM
 
#include "include/types.hpp"
#include "include/timer.hpp"
#include "include/queue.hpp"
 
namespace qOS {
 

 
    class stateMachine;

    namespace sm {

 
        class state;
 
        using signalIDType = uint32_t;

        enum signalID : signalIDType {
            SIGNAL_START = 0xFFFFFFFFUL,
            SIGNAL_EXIT = 0xFFFFFFFEUL,
            SIGNAL_ENTRY = 0xFFFFFFFDUL,
            SIGNAL_NONE = 0xFFFFFFFCUL,
            TM_MAX = 0xFFFFFFFBUL,
            TM_MIN = TM_MAX - ( Q_FSM_MAX_TIMEOUTS - 1 ),
            #if ( 0 == Q_FSM_MAX_TIMEOUTS )
                #warning "FSM has no defined internal timeouts"
            #elif ( 1 == Q_FSM_MAX_TIMEOUTS )
                SIGNAL_TIMEOUT0 = 0xFFFFFFFBUL,
            #elif ( 2 == Q_FSM_MAX_TIMEOUTS )
                SIGNAL_TIMEOUT0= 0xFFFFFFFBUL,
                SIGNAL_TIMEOUT1 = 0xFFFFFFFAUL,
            #elif ( 3 == Q_FSM_MAX_TIMEOUTS )
                SIGNAL_TIMEOUT0 = 0xFFFFFFFBUL,
                SIGNAL_TIMEOUT1 = 0xFFFFFFFAUL,
                SIGNAL_TIMEOUT2 = 0xFFFFFFF9UL,
            #elif ( 4 == Q_FSM_MAX_TIMEOUTS )
                SIGNAL_TIMEOUT0 = 0xFFFFFFFBUL,
                SIGNAL_TIMEOUT1 = 0xFFFFFFFAUL,
                SIGNAL_TIMEOUT2 = 0xFFFFFFF9UL,
                SIGNAL_TIMEOUT3 = 0xFFFFFFF8UL,
            #elif ( 5 == Q_FSM_MAX_TIMEOUTS )
                SIGNAL_TIMEOUT0 = 0xFFFFFFFBUL,
                SIGNAL_TIMEOUT1 = 0xFFFFFFFAUL,
                SIGNAL_TIMEOUT2 = 0xFFFFFFF9UL,
                SIGNAL_TIMEOUT3 = 0xFFFFFFF8UL,
                SIGNAL_TIMEOUT4 = 0xFFFFFFF7UL,
            #elif ( 6 == Q_FSM_MAX_TIMEOUTS )
                SIGNAL_TIMEOUT0 = 0xFFFFFFFBUL,
                SIGNAL_TIMEOUT1 = 0xFFFFFFFAUL,
                SIGNAL_TIMEOUT2 = 0xFFFFFFF9UL,
                SIGNAL_TIMEOUT3 = 0xFFFFFFF8UL,
                SIGNAL_TIMEOUT4 = 0xFFFFFFF7UL,
                SIGNAL_TIMEOUT5 = 0xFFFFFFF6UL,
            #elif ( 7 == Q_FSM_MAX_TIMEOUTS )
                SIGNAL_TIMEOUT0 = 0xFFFFFFFBUL,
                SIGNAL_TIMEOUT1 = 0xFFFFFFFAUL,
                SIGNAL_TIMEOUT2 = 0xFFFFFFF9UL,
                SIGNAL_TIMEOUT3 = 0xFFFFFFF8UL,
                SIGNAL_TIMEOUT4 = 0xFFFFFFF7UL,
                SIGNAL_TIMEOUT5 = 0xFFFFFFF6UL,
                SIGNAL_TIMEOUT6 = 0xFFFFFFF5UL,
            #elif ( 8 == Q_FSM_MAX_TIMEOUTS )
                SIGNAL_TIMEOUT0 = 0xFFFFFFFBUL,
                SIGNAL_TIMEOUT1 = 0xFFFFFFFAUL,
                SIGNAL_TIMEOUT2 = 0xFFFFFFF9UL,
                SIGNAL_TIMEOUT3 = 0xFFFFFFF8UL,
                SIGNAL_TIMEOUT4 = 0xFFFFFFF7UL,
                SIGNAL_TIMEOUT5 = 0xFFFFFFF6UL,
                SIGNAL_TIMEOUT6 = 0xFFFFFFF5UL,
                SIGNAL_TIMEOUT7 = 0xFFFFFFF4UL,
            #elif ( 9 == Q_FSM_MAX_TIMEOUTS )
                SIGNAL_TIMEOUT0 = 0xFFFFFFFBUL,
                SIGNAL_TIMEOUT1 = 0xFFFFFFFAUL,
                SIGNAL_TIMEOUT2 = 0xFFFFFFF9UL,
                SIGNAL_TIMEOUT3 = 0xFFFFFFF8UL,
                SIGNAL_TIMEOUT4 = 0xFFFFFFF7UL,
                SIGNAL_TIMEOUT5 = 0xFFFFFFF6UL,
                SIGNAL_TIMEOUT6 = 0xFFFFFFF5UL,
                SIGNAL_TIMEOUT7 = 0xFFFFFFF4UL,
                SIGNAL_TIMEOUT8 = 0xFFFFFFF3UL,
            #elif ( 10 == Q_FSM_MAX_TIMEOUTS )
                SIGNAL_TIMEOUT0 = 0xFFFFFFFBUL,
                SIGNAL_TIMEOUT1 = 0xFFFFFFFAUL,
                SIGNAL_TIMEOUT2 = 0xFFFFFFF9UL,
                SIGNAL_TIMEOUT3 = 0xFFFFFFF8UL,
                SIGNAL_TIMEOUT4 = 0xFFFFFFF7UL,
                SIGNAL_TIMEOUT5 = 0xFFFFFFF6UL,
                SIGNAL_TIMEOUT6 = 0xFFFFFFF5UL,
                SIGNAL_TIMEOUT7 = 0xFFFFFFF4UL,
                SIGNAL_TIMEOUT8 = 0xFFFFFFF3UL,
                SIGNAL_TIMEOUT9 = 0xFFFFFFF2UL,
            #elif ( Q_FSM_MAX_TIMEOUTS > 10 )
                #error "Max FSM allowed timeout should not be greater that 10"
            #endif
            MIN_SIGNAL = 0x0UL,
            MAX_SIGNAL = TM_MIN - 1
        };
 
 

        constexpr signalID SIGNAL_TIMEOUT( index_t iTm )
        {
            return static_cast<signalID>( signalID::TM_MAX - static_cast<signalID>( Q_FSM_MAX_TIMEOUTS - 1 ) + static_cast<signalID>( iTm ) );
        }

        constexpr signalID SIGNAL_USER( uint32_t s )
        {
            /*cstat -MISRAC++2008-5-0-3*/
            return ( s < signalID::MAX_SIGNAL ) ? static_cast<signalID>( s ) : signalID::MAX_SIGNAL;
            /*cstat +MISRAC++2008-5-0-3*/
        }

        struct signal_t {
            signalID id{ signalID::SIGNAL_NONE };  
            void *data{ nullptr };                 
        };

        template <size_t numberOfSignals>
        struct signalQueue {
            queue q;
            signal_t qStack[ numberOfSignals ]; // skipcq: CXX-W2066
        };
 

        enum status : int16_t {
            BEFORE_ANY = -32767,
            ABSENT = -32766,
            FAILURE = -32765,
            SUCCESS = -32764,
            SIGNAL_HANDLED = -32763,
        };

        enum historyMode : uint8_t {
            NO_HISTORY = 0U,
            SHALLOW_HISTORY,
            DEEP_HISTORY,
        };
 
        #ifdef DOXYGEN
        class handler_t final {
            protected:
                state *StartState{ nullptr };
                state *NextState{ nullptr };
                stateMachine* Machine{ nullptr };
                state *State{ nullptr };
                historyMode TransitionHistory{ historyMode::NO_HISTORY };
                status Status{ SUCCESS };
                signalID Signal{ signalID::SIGNAL_NONE };
                _Handler( _Handler const& ) = delete;      /* not copyable*/
                void operator=( _Handler const& ) = delete;  /* not assignable*/
            public:
                _Handler() = default;
                void *SignalData{ nullptr };    
                void *Data{ nullptr };          
                void *StateData{ nullptr };     
                inline void nextState( state &s, historyMode m = historyMode::NO_HISTORY ) noexcept
                {
                    NextState = &s;
                    TransitionHistory = m;
                }

                inline void startState( state &s ) noexcept
                {
                    StartState = &s;
                }

                bool timeoutSet( const index_t i, const qOS::duration_t t ) noexcept;
                bool timeoutStop( const index_t i ) noexcept;
                inline state& thisState( void ) noexcept
                {
                    return *State;
                }

                inline stateMachine& thisMachine( void ) noexcept
                {
                    return *Machine;
                }

                inline signalID signal( void ) const noexcept
                {
                    return Signal;
                }

                inline status lastStatus( void ) const noexcept
                {
                    return Status;
                }
            friend class qOS::sm::state;
        };
        #endif

        class stateHandler : private nonCopyable {
            protected:
                state *StartState{ nullptr };
                state *NextState{ nullptr };
                stateMachine* Machine{ nullptr };
                state *State{ nullptr };
                historyMode TransitionHistory{ historyMode::NO_HISTORY };
                status Status{ SUCCESS };
                signalID Signal{ signalID::SIGNAL_NONE };
                stateHandler() = default;
            public:
                virtual ~stateHandler() {}
                void *SignalData{ nullptr };    
                void *Data{ nullptr };          
                void *StateData{ nullptr };     
                inline void nextState( state &s, historyMode m = historyMode::NO_HISTORY ) noexcept
                {
                    NextState = &s;
                    TransitionHistory = m;
                }
                inline void startState( state &s ) noexcept
                {
                    StartState = &s;
                }
                inline state& thisState( void ) noexcept
                {
                    return *State;
                }
                inline stateMachine& thisMachine( void ) noexcept
                {
                    return *Machine;
                }
                inline signalID signal( void ) const noexcept
                {
                    return Signal;
                }
                inline status lastStatus( void ) const noexcept
                {
                    return Status;
                }
            friend class qOS::sm::state;
        };
        using handler_t = stateHandler&;

        using stateCallback_t = status (*)( handler_t );

        using surroundingCallback_t = void (*)( handler_t );

        using signalAction_t = bool (*)( handler_t );

        using timeoutSpecOption_t = uint32_t;

        struct timeoutStateDefinition {
            qOS::duration_t xTimeout;
            timeoutSpecOption_t options;
        };

        struct transition final {
            signalID xSignal{ signalID::SIGNAL_NONE };
            signalAction_t guard{ nullptr };
            state *nextState{ nullptr };
            historyMode history{ historyMode::NO_HISTORY };
            void *signalData{ nullptr };
            transition() = default;
            /*cstat -MISRAC++2008-7-1-2*/
            transition( signalID iSignal, signalAction_t sGuard, state &next, historyMode mHistory = historyMode::NO_HISTORY, void *sigData = nullptr ) :
                        xSignal(iSignal),
                        guard(sGuard),
                        nextState(&next),
                        history(mHistory),
                        signalData(sigData) {}
            transition( signalID iSignal, state &next, historyMode mHistory = historyMode::NO_HISTORY, void *sigData = nullptr ) :
                        xSignal(iSignal),
                        guard(nullptr),
                        nextState(&next),
                        history(mHistory),
                        signalData(sigData) {}
            transition( signalIDType iSignal, signalAction_t sGuard, state &next, uint8_t mHistory = 0U, void *sigData = nullptr ) :
                        xSignal( static_cast<signalID>( iSignal ) ),
                        guard(sGuard),
                        nextState(&next),
                        history( static_cast<historyMode>(mHistory) ),
                        signalData(sigData) {}
            /*cstat +MISRAC++2008-7-1-2*/
            transition( signalIDType iSignal, state &next, uint8_t mHistory = 0U, void *sigData = nullptr ) :
                        xSignal( static_cast<signalID>( iSignal ) ),
                        guard(nullptr),
                        nextState(&next),
                        history( static_cast<historyMode>(mHistory) ),
                        signalData(sigData) {}
        };

        class state {
            private:
                state *parent{ nullptr };
                state *lastRunningChild{ nullptr };
                state *initState{ nullptr };
                stateCallback_t sCallback{ nullptr};
                timeoutStateDefinition *tdef{ nullptr };
                transition *tTable{ nullptr };
                void *sData{ nullptr };
                size_t tEntries{ 0U };
                size_t nTm{ 0U };
                stateHandler *pHandler{ nullptr };
                void sweepTransitionTable( stateHandler &h ) const noexcept;
                state( state const& ) = delete;
                void operator=( state const& ) = delete;
                bool subscribe( sm::state *s, const sm::stateCallback_t &sFcn, sm::state *init ) noexcept;
                void topSelf( const sm::stateCallback_t &topFcn, sm::state *init ) noexcept;
            protected:
                virtual sm::status activities( sm::handler_t h );
            public:
                state() = default;
                virtual ~state() {}
                inline bool add( sm::state &s, const sm::stateCallback_t &sFcn, sm::state &init ) noexcept
                {
                    return subscribe( &s, sFcn, &init );
                }

                inline bool add( sm::state &s, const sm::stateCallback_t &sFcn ) noexcept
                {
                    return subscribe( &s, sFcn, nullptr );
                }

                bool install( transition *table, size_t n ) noexcept;
                template <size_t numberOfTransitions>
                bool install( transition (&table)[ numberOfTransitions ] ) noexcept // skipcq : CXX-W2066
                {
                    return install( table, numberOfTransitions );
                }

                inline bool install( transition *table, size_t nTable, timeoutStateDefinition *def, size_t nDef )
                {
                    int ret = 1;
                    /*cstat -MISRAC++2008-5-0-21  -CERT-EXP46-C */
                    ret &= install( table, nTable ); // skipcq: CXX-W2065
                    ret &= install( def, nDef );    // skipcq: CXX-W2065
                    /*cstat +MISRAC++2008-5-0-21  +CERT-EXP46-C */
                    return ( 0 != ret );
                }

                template <size_t numberOfTransitions, size_t numberOfTimeoutDefs>
                bool install( transition (&table)[ numberOfTransitions ], timeoutStateDefinition (&def)[ numberOfTimeoutDefs ] ) noexcept // skipcq : CXX-W2066
                {
                    return install( table, numberOfTransitions, def, numberOfTimeoutDefs );
                }

                bool install( timeoutStateDefinition *def, size_t n ) noexcept;
                template <size_t numberOfTimeoutDefs>
                bool install( timeoutStateDefinition (&def)[ numberOfTimeoutDefs ] ) noexcept // skipcq : CXX-W2066
                {
                    return install( def, numberOfTimeoutDefs );
                }

                void* getData( void ) noexcept;
                void setData( void *pData ) noexcept;
                transition* getTransitionTable( void ) noexcept;
                void setCallback( const stateCallback_t sFcn ) noexcept;
            friend class qOS::stateMachine;
        };

        class timeoutSpec {
            uint32_t isPeriodic{ 0U };
            timer timeout[ Q_FSM_MAX_TIMEOUTS ]; // skipcq: CXX-W2066
            friend class qOS::stateMachine;
        };

        enum psReqStatus{
            PS_SIGNAL_NOT_FOUND,
            PS_SUBSCRIBER_NOT_FOUND,
            PS_SUBSCRIBER_FOUND,
            PS_SIGNAL_SLOTS_FULL,
            PS_SUBSCRIBER_SLOTS_FULL
        };
 
        struct psIndex_t {
            psReqStatus status;
            size_t sig_slot;
            size_t sub_slot;
        };

        extern const timeoutSpecOption_t TIMEOUT_SET_ENTRY;
        extern const timeoutSpecOption_t TIMEOUT_RST_ENTRY;
        extern const timeoutSpecOption_t TIMEOUT_SET_EXIT;
        extern const timeoutSpecOption_t TIMEOUT_RST_EXIT;
        extern const timeoutSpecOption_t TIMEOUT_KEEP_IF_SET;
        extern const timeoutSpecOption_t TIMEOUT_PERIODIC;
        constexpr timeoutSpecOption_t TIMEOUT_INDEX( index_t i )
        {
            return ( 0x00FFFFFFUL & static_cast<timeoutSpecOption_t>( i ) );
        }

        constexpr timeoutSpecOption_t TIMEOUT_USE_SIGNAL( index_t i )
        {
            return ( 0x00FFFFFFUL & static_cast<timeoutSpecOption_t>( i ) );
        }

    }

    class stateMachine : protected sm::stateHandler {
        private:
            sm::state *current{ nullptr };
            sm::state *next{ nullptr };
            sm::state *source{ nullptr };
            queue *sQueue{ nullptr };
            sm::timeoutSpec *timeSpec{ nullptr };
            sm::surroundingCallback_t surrounding{ nullptr };
            sm::state top;
            sm::signal_t signalNot;
            void *owner{ nullptr };
            void *mData{ nullptr };
            bool internalSignalSend( sm::signalID sig, void *sData, bool isUrgent ) noexcept;
            void timeoutCheckSignals( void ) noexcept;
            void timeoutPerformSpecifiedActions( sm::state * const s, sm::signalID sig ) noexcept;
            void transition( sm::state *target, sm::historyMode mHistory ) noexcept;
            uint8_t levelsToLCA( sm::state *target ) const noexcept;
            void exitUpToLCA( uint8_t lca ) noexcept;
            void prepareHandler( sm::signal_t sig, sm::state *s ) noexcept;
            sm::status invokeStateActivities( sm::state * const s ) noexcept;
            sm::state* stateOnExit( sm::state *s ) noexcept;
            void stateOnEntry( sm::state *s ) noexcept;
            sm::state* stateOnStart( sm::state *s ) noexcept;
            sm::status stateOnSignal( sm::state *s, sm::signal_t sig ) noexcept;
            void tracePathAndRetraceEntry( sm::state **trace ) noexcept;
            void traceOnStart( sm::state **entryPath ) noexcept;
            sm::signal_t checkForSignals( sm::signal_t sig ) noexcept;
            stateMachine( stateMachine const& ) = delete;
            void operator=( stateMachine const& ) = delete;
            bool smSetup( sm::stateCallback_t topFcn, sm::state *init, const sm::surroundingCallback_t sFcn, void* pData ) noexcept;
 
            /*cstat -MISRAC++2008-8-5-2*/
            static sm::signalID psSignals[ Q_FSM_PS_SIGNALS_MAX ]; // skipcq: CXX-W2009, CXX-W2066
            /*cstat +MISRAC++2008-8-5-2*/
            static stateMachine* psSubs[ Q_FSM_PS_SIGNALS_MAX ][ Q_FSM_PS_SUB_PER_SIGNAL_MAX ]; // skipcq: CXX-W2009, CXX-W2066
            static const sm::timeoutSpecOption_t OPT_INDEX_MASK;
        public:
            stateMachine() = default;
            virtual ~stateMachine() {}
            inline bool setup( const sm::stateCallback_t &topFcn, sm::state &init, sm::surroundingCallback_t sFcn = nullptr, void* pData = nullptr)  noexcept
            {
                return smSetup( topFcn, &init, sFcn, pData );
            }

            inline bool add( sm::state &s, const sm::stateCallback_t &sFcn, sm::state &init ) noexcept
            {
                return top.subscribe( &s, sFcn, &init );
            }

            inline bool add( sm::state &s, const sm::stateCallback_t &sFcn ) noexcept
            {
                return top.subscribe( &s, sFcn, nullptr );
            }

            bool install( queue& q ) noexcept;

            template <size_t numberOfSignals>
            bool install( sm::signalQueue<numberOfSignals> &sq ) noexcept
            {
                sq.q.setup( sq.qStack, sizeof(sm::signal_t), numberOfSignals );
                return install( sq.q );
            }

            bool sendSignal( sm::signalID sig, void *sData = nullptr, bool isUrgent = false ) noexcept;
            bool sendSignal( sm::signalIDType sig, void *sData = nullptr, bool isUrgent = false ) noexcept
            {
                return sendSignal( static_cast<sm::signalID>( sig ), sData, isUrgent );
            }

            bool install( sm::timeoutSpec &ts ) noexcept;
            bool timeoutSet( const index_t xTimeout, const qOS::duration_t t ) noexcept;
            bool timeoutStop( const index_t xTimeout ) noexcept;
            const sm::state& getTop( void ) const noexcept;
            sm::state * const & getCurrent( void ) const noexcept;
            queue * const & getQueue( void ) const noexcept;
            sm::timeoutSpec * const & getTimeSpec( void ) const noexcept;
            void * const & getData( void ) const noexcept;
            void setSurrounding( const sm::surroundingCallback_t &sFcn ) noexcept;
            bool run( sm::signal_t sig ) noexcept;
            bool isInitialized( void ) const {
                return ( nullptr != top.initState );
            }

            explicit operator bool() const noexcept {
                return isInitialized();
            }
        friend class core;
    };

    namespace sm {

        class signalPublisher {
            private:
                sm::signalID psSignals[ Q_FSM_PS_SIGNALS_MAX ] = { sm::signalID::SIGNAL_START }; // skipcq: CXX-W2009, CXX-W2066
                stateMachine* psSubs[ Q_FSM_PS_SIGNALS_MAX ][ Q_FSM_PS_SUB_PER_SIGNAL_MAX ]; // skipcq: CXX-W2009, CXX-W2066
                sm::psIndex_t getSubscriptionStatus( stateMachine &m, sm::signalID s ) const noexcept;
                void unsubscribeAll( void ) noexcept;
            public:
                signalPublisher();
                virtual ~signalPublisher() {}
                bool subscribeToSignal( stateMachine &m, sm::signalID s ) noexcept;
                bool subscribeToSignal( stateMachine &m, sm::signalIDType s ) noexcept
                {
                    return subscribeToSignal( m, static_cast<sm::signalID>( s ) );
                }

                bool unsubscribeFromSignal( stateMachine &m, sm::signalID s ) noexcept;
                bool unsubscribeFromSignal( stateMachine &m, sm::signalIDType s ) noexcept
                {
                    return unsubscribeFromSignal( m, static_cast<sm::signalID>( s ) );
                }

                bool sendSignal( sm::signalID sig, void *sData = nullptr, bool isUrgent = false ) noexcept;
                bool sendSignal( sm::signalIDType sig, void *sData = nullptr, bool isUrgent = false ) noexcept
                {
                    return sendSignal( static_cast<sm::signalID>( sig ), sData, isUrgent );
                }
        };

    }
}
 
 
 
#endif /*QOS_CPP_FSM*/