machine_state.h

#ifndef MACHINE_STATE_H
#define MACHINE_STATE_H
 
#include <functional>
#include "./abstract_state_machine.h"
 
namespace ara
{
    namespace com
    {
        namespace helper
        {
            enum class SdServerState
            {
                NotReady,         
                InitialWaitPhase, 
                RepetitionPhase,  
                MainPhase         
            };
 
            enum class SdClientState
            {
                ServiceNotSeen,   
                ServiceSeen,      
                ServiceReady,     
                Stopped,          
                InitialWaitPhase, 
                RepetitionPhase   
            };
 
            enum class PubSubState
            {
                ServiceDown,    
                NotSubscribed,  
                Subscribed      
            };
 
            template <typename T>
            class MachineState
            {
            private:
                const T mState;
                std::function<void(T, T)> mTransitionCallback;
                AbstractStateMachine<T> *mFiniteStateMachine;
 
            protected:
                virtual void Deactivate(T nextState) = 0;
 
                void Transit(T nextState)
                {
                    Deactivate(nextState);
                    if (mFiniteStateMachine)
                    {
                        mFiniteStateMachine->Transit(mState, nextState);
                    }
                }
 
                MachineState(T state) noexcept : mState{state},
                                                 mFiniteStateMachine{nullptr}
                {
                }
 
            public:
                virtual ~MachineState() = default;
                MachineState(const MachineState &) = delete;
                MachineState &operator=(const MachineState &) = delete;
 
                T GetState() const noexcept
                {
                    return mState;
                }
 
                virtual void Activate(T previousState) = 0;
 
                void Register(AbstractStateMachine<T> *finiteStateMachine) noexcept
                {
                    mFiniteStateMachine = finiteStateMachine;
                }
            };
        }
    }
}
 
#endif