timer_set_state.h

#ifndef TIMER_SET_STATE_H
#define TIMER_SET_STATE_H
 
#include <stdexcept>
#include "../../../helper/machine_state.h"
 
namespace ara
{
    namespace com
    {
        namespace someip
        {
            namespace sd
            {
                namespace fsm
                {
                    template <typename T>
                    class TimerSetState : virtual public helper::MachineState<T>
                    {
                    private:
                        const T mStoppedState;
                        T mNextState;
                        bool mStopped;
                        bool mInterrupted;
 
                        void setTimerBase()
                        {
                            SetTimer();
                            // Transition to the next state or to the stopped state
                            if (mStopped)
                            {
                                helper::MachineState<T>::Transit(mStoppedState);
                            }
                            else
                            {
                                helper::MachineState<T>::Transit(mNextState);
                            }
                        }
 
                    protected:
                        bool WaitFor(std::chrono::milliseconds duration)
                        {
                            std::this_thread::sleep_for(duration);
                            bool _result = mStopped || mInterrupted;
 
                            return _result;
                        }
 
                        bool WaitFor(int duration)
                        {
                            auto _milliseconds = std::chrono::milliseconds(duration);
                            bool _result = WaitFor(_milliseconds);
 
                            return _result;
                        }
 
                        void Interrupt() noexcept
                        {
                            mInterrupted = true;
                        }
 
                        const std::function<void()> OnTimerExpired;
 
                        virtual void SetTimer() = 0;
 
                        TimerSetState(
                            T nextState,
                            T stoppedState,
                            std::function<void()> onTimerExpired) : mNextState{nextState},
                                                                    mStoppedState{stoppedState},
                                                                    OnTimerExpired{onTimerExpired},
                                                                    mStopped{false},
                                                                    mInterrupted{false}
                        {
                        }
 
                        void Deactivate(T nextState) override
                        {
                            // Reset 'service interrupted' flag
                            mInterrupted = false;
                            // Reset 'service stopped' flag
                            mStopped = false;
                        }
 
                    public:
                        TimerSetState(const TimerSetState &) = delete;
                        TimerSetState &operator=(const TimerSetState &) = delete;
 
                        virtual void Activate(T previousState) override
                        {
                            if (!mStopped)
                            {
                                setTimerBase();
                            }
                        }
 
                        void ServiceStopped() noexcept
                        {
                            mStopped = true;
                        }
 
                        void SetNextState(T nextState) noexcept
                        {
                            mNextState = nextState;
                        }
 
                        virtual ~TimerSetState() override
                        {
                            // Set a fake stop signal, otherwise the timer loop may never end (e.g., in the main phase).
                            ServiceStopped();
                        }
                    };
                }
            }
        }
    }
}
 
#endif