repetition_state.h

#ifndef REPETITION_STATE_H
#define REPETITION_STATE_H
 
#include <thread>
#include <cmath>
#include <chrono>
#include "./timer_set_state.h"
 
namespace ara
{
    namespace com
    {
        namespace someip
        {
            namespace sd
            {
                namespace fsm
                {
                    template <typename T>
                    class RepetitionState : public TimerSetState<T>
                    {
                    protected:
                        const int RepetitionsMax;
 
                        const int RepetitionsBaseDelay;
 
                        virtual void SetTimer() override
                        {
                            for (uint32_t i = 0; i < RepetitionsMax; ++i)
                            {
                                int _doubledDelay = std::pow(2, i) * RepetitionsBaseDelay;
                                auto _delay = std::chrono::milliseconds(_doubledDelay);
                                bool _interrupted = this->WaitFor(_delay);
 
                                if (_interrupted)
                                {
                                    break;
                                }
                                else
                                {
                                    // Invoke the on timer expiration callback
                                    this->OnTimerExpired();
                                }
                            }
                        }
 
                    public:
                        RepetitionState(
                            T currentState,
                            T nextState,
                            T stoppedState,
                            std::function<void()> onTimerExpired,
                            uint32_t repetitionsMax,
                            int repetitionsBaseDelay) : helper::MachineState<T>(currentState),
                                                        TimerSetState<T>(nextState, stoppedState, onTimerExpired),
                                                        RepetitionsMax{static_cast<int>(repetitionsMax)},
                                                        RepetitionsBaseDelay{repetitionsBaseDelay}
                        {
                            if (repetitionsBaseDelay < 0)
                            {
                                throw std::invalid_argument("Invalid repetition base delay.");
                            }
                        }
 
                        RepetitionState() = delete;
                        RepetitionState(const RepetitionState &) = delete;
                        RepetitionState &operator=(const RepetitionState &) = delete;
                    };
                }
            }
        }
    }
}
 
#endif