deterministic_client.h

#ifndef DETERMINISTIC_CLIENT_H
#define DETERMINISTIC_CLIENT_H
 
#include <stdint.h>
#include <future>
#include <chrono>
#include <mutex>
#include <condition_variable>
#include "../core/result.h"
#include "./worker_runnable.h"
#include "./helper/atomic_optional.h"
 
namespace ara
{
    namespace exec
    {
        enum class ActivationReturnType : uint8_t
        {
            kRegisterService = 0,  
            kServiceDiscovery = 1, 
            kInit = 2,             
            kRun = 3,              
            kTerminate = 4         
        };
 
        class DeterministicClient final
        {
        public:
            using TimeStamp = std::chrono::time_point<std::chrono::steady_clock>;
 
            static const uint64_t cCycleDelayMs{10};
 
        private:
            static std::atomic_uint8_t mCounter;
            static std::future<void> mFuture;
            static bool mRunning;
            static std::mutex mCycleMutex;
            static std::condition_variable mCycleConditionVariable;
            static std::default_random_engine mGenerator;
            static std::uniform_int_distribution<uint64_t> mDistribution;
            static helper::AtomicOptional<uint64_t> mSeed;
            static uint64_t mRandomNumber;
            static TimeStamp mActivationTime;
            WorkerThread mWorkerThread;
 
            static void activateCycle();
 
        public:
            DeterministicClient();
            ~DeterministicClient();
 
            core::Result<ActivationReturnType> WaitForActivation();
 
            template <typename ValueType, typename Container>
            ara::core::Result<void> RunWorkerPool(
                WorkerRunnable<ValueType> &runnableObj,
                Container &container) noexcept
            {
                static_assert(
                    std::is_same<ValueType, typename Container::value_type>::value,
                    "Container value type mismatch!");
 
                for (auto element : container)
                {
                    runnableObj.Run(element, mWorkerThread);
                }
 
                ara::core::Result<void> _result;
                return _result;
            }
 
            uint64_t GetRandom() noexcept;
 
            void SetRandomSeed(uint64_t seed) noexcept;
 
            core::Result<TimeStamp> GetActivationTime() noexcept;
 
            core::Result<TimeStamp> GetNextActivationTime();
        };
    }
}
 
#endif