routable_uds_service.h

#ifndef ROUTABLE_USD_SERVICE_H
#define ROUTABLE_USD_SERVICE_H
 
#include <future>
#include <vector>
#include "../../core/instance_specifier.h"
#include "../../core/result.h"
#include "../meta_info.h"
#include "../cancellation_handler.h"
 
namespace ara
{
    namespace diag
    {
        struct OperationOutput
        {
            std::vector<uint8_t> responseData;
        };
 
        namespace routing
        {
            class RoutableUdsService
            {
            private:
                const uint8_t mSid;
                bool mOffered;
                const ara::core::InstanceSpecifier &mSpecifier;
 
            protected:
                static const uint8_t cPositiveResponseSidIncrement{0x40};
                const uint8_t cSubFunctionNotSupported{0x12};
                const uint8_t cIncorrectMessageLength{0x13};
                const uint8_t cRequestSequenceError{0x24};
 
                RoutableUdsService(
                    const ara::core::InstanceSpecifier &specifier,
                    uint8_t sid) noexcept;
 
                void GenerateNegativeResponse(
                    OperationOutput &response, uint8_t nrc) const;
 
                template <class T>
                bool TryExtractValue(MetaInfo &metaInfo, std::string key, T &value) const
                {
                    core::Optional<std::string> _optionalValue{metaInfo.GetValue(key)};
 
                    if (_optionalValue.HasValue())
                    {
                        std::string _valueStr{_optionalValue.Value()};
                        int _valueInt{std::stoi(_valueStr)};
                        value = static_cast<T>(_valueInt);
 
                        return true;
                    }
                    else
                    {
                        return false;
                    }
                }
 
            public:
                static const uint8_t cNegativeResponseCodeSid{0x7f};
 
                uint8_t GetSid() const noexcept;
 
                ara::core::Result<void> Offer();
 
                bool IsOffered() const noexcept;
 
                virtual std::future<OperationOutput> HandleMessage(
                    const std::vector<uint8_t> &requestData,
                    MetaInfo &metaInfo,
                    CancellationHandler &&cancellationHandler) = 0;
 
                void StopOffer() noexcept;
 
                virtual ~RoutableUdsService() noexcept = default;
            };
        }
    }
}
 
#endif