initial_wait_state.h

#ifndef INITIAL_WAIT_STATE_H
#define INITIAL_WAIT_STATE_H
 
#include <random>
#include <thread>
#include <chrono>
#include "./timer_set_state.h"
 
namespace ara
{
    namespace com
    {
        namespace someip
        {
            namespace sd
            {
                namespace fsm
                {
                    template <typename T>
                    class InitialWaitState : public TimerSetState<T>
                    {
                    protected:
                        const int InitialDelayMin;
 
                        const int InitialDelayMax;
 
                        virtual void SetTimer() override
                        {
                            // Generate a random initial delay
                            std::default_random_engine _generator;
                            std::uniform_int_distribution<int> _distribution(
                                InitialDelayMin, InitialDelayMax);
                            int _randomDely = _distribution(_generator);
 
                            // Sleep for the initali random delay and
                            // then transit to the next state
                            auto _delay = std::chrono::milliseconds(_randomDely);
                            bool _interrupted = this->WaitFor(_delay);
 
                            if (!_interrupted)
                            {
                                // Invoke the on timer expiration callback
                                this->OnTimerExpired();
                            }
                        }
 
                    public:
                        InitialWaitState(
                            T currentState,
                            T nextState,
                            T stoppedState,
                            std::function<void()> onTimerExpired,
                            int initialDelayMin,
                            int initialDelayMax) : helper::MachineState<T>(currentState),
                                                   TimerSetState<T>(nextState, stoppedState, onTimerExpired),
                                                   InitialDelayMin{initialDelayMin},
                                                   InitialDelayMax{initialDelayMax}
                        {
                            if ((initialDelayMin < 0) ||
                                (initialDelayMax < 0) ||
                                (initialDelayMin > initialDelayMax))
                            {
                                throw std::invalid_argument("Invalid initial delay minimum and/or maximum.");
                            }
                        }
 
                        InitialWaitState() = delete;
                        InitialWaitState(const InitialWaitState &) = delete;
                        InitialWaitState &operator=(const InitialWaitState &) = delete;
                    };
                }
            }
        }
    }
}
 
#endif