state_client.h

#ifndef STATE_CLIENT_H
#define STATE_CLIENT_H
 
#include <future>
#include "../com/someip/rpc/rpc_client.h"
#include "./execution_error_event.h"
#include "./function_group_state.h"
#include "./exec_exception.h"
 
namespace ara
{
    namespace exec
    {
        class StateClient final
        {
        private:
            static const ExecErrorDomain cErrorDomain;
            const uint16_t cServiceId{3};
            const uint16_t cSetStateId{1};
            const uint16_t cStateTransition{2};
            const uint16_t cClientId{4};
 
            std::function<void(const ExecutionErrorEvent &)> mUndefinedStateCallback;
            com::someip::rpc::RpcClient *const mRpcClient;
            std::promise<void> mSetStatePromise;
            std::shared_future<void> mSetStateFuture;
            std::promise<void> mStateTransitionPromise;
            std::shared_future<void> mStateTransitionFuture;
 
            static void setPromiseException(
                std::promise<void> &promise, ExecErrc executionErrorCode);
 
            static void genericHandler(
                std::promise<void> &promise,
                const com::someip::rpc::SomeIpRpcMessage &message);
 
            void setStateHandler(
                const com::someip::rpc::SomeIpRpcMessage &message);
 
            void stateTransitionHandler(
                const com::someip::rpc::SomeIpRpcMessage &message);
 
            std::shared_future<void> getFuture(
                std::promise<void> &promise,
                uint16_t methodId,
                const std::vector<uint8_t> &rpcPayload);
 
        public:
            StateClient(
                std::function<void(const ExecutionErrorEvent &)> undefinedStateCallback,
                com::someip::rpc::RpcClient *rpcClient);
 
            StateClient() = delete;
            ~StateClient() noexcept = default;
 
            std::shared_future<void> SetState(const FunctionGroupState &state);
 
            std::shared_future<void> GetInitialMachineStateTransitionResult();
 
            core::Result<ExecutionErrorEvent> GetExecutionError(
                const FunctionGroup &functionGroup) noexcept;
        };
    }
}
 
#endif