someip_message.h

#ifndef SOMEIP_MESSAGE_H
#define SOMEIP_MESSAGE_H
 
#include <stdint.h>
#include <stdexcept>
#include <vector>
#include <limits>
#include "../helper/payload_helper.h"
 
namespace ara
{
    namespace com
    {
        namespace someip
        {
            enum class SomeIpMessageType : uint8_t
            {
                Request = 0x00,           
                RequestNoReturn = 0x01,   
                Notification = 0x02,      
                Response = 0x80,          
                Error = 0x81,             
                TpRequest = 0x20,         
                TpRequestNoReturn = 0x21, 
                TpNotification = 0x22,    
                TpResponse = 0xa0,        
                TpError = 0xa1            
            };
 
            enum class SomeIpReturnCode : uint8_t
            {
                eOK,                    
                eNotOk,                 
                eUnknownService,        
                eUnknownMethod,         
                eNotReady,              
                eNotReachable,          
                eTimeout,               
                eWrongProtocolVersion,  
                eWrongInterfaceVersion, 
                eMalformedMessage,      
                eWrongMessageType,      
                eE2eRepeated,           
                eE2eWrongSequnece,      
                eE2e,                   
                eE2eNotAvailable,       
                eE2eNoNewData           
            };
 
            class SomeIpMessage
            {
            private:
                uint32_t mMessageId;
                uint16_t mClientId;
                uint16_t mSessionId;
                uint8_t mProtocolVersion;
                uint8_t mInterfaceVersion;
                SomeIpMessageType mMessageType;
                SomeIpReturnCode mReturnCode;
 
                SomeIpMessage(uint32_t messageId,
                              uint16_t clientId,
                              uint16_t sessionId,
                              uint8_t protocolVersion,
                              uint8_t interfaceVersion,
                              SomeIpMessageType messageType,
                              SomeIpReturnCode returnCode) noexcept;
 
            protected:
                SomeIpMessage(uint32_t messageId,
                              uint16_t clientId,
                              uint8_t protocolVersion,
                              uint8_t interfaceVersion,
                              SomeIpMessageType messageType,
                              uint16_t sessionId = 1);
 
                SomeIpMessage(uint32_t messageId,
                              uint16_t clientId,
                              uint8_t protocolVersion,
                              uint8_t interfaceVersion,
                              SomeIpMessageType messageType,
                              SomeIpReturnCode returnCode,
                              uint16_t sessionId = 1);
 
                static void Deserialize(
                    SomeIpMessage *message,
                    const std::vector<uint8_t> &payload);
 
            public:
                SomeIpMessage(SomeIpMessage&& other) noexcept;
                virtual ~SomeIpMessage() noexcept = default;
 
                SomeIpMessage& operator=(SomeIpMessage&& other);
 
                uint32_t MessageId() const noexcept;
 
                virtual uint32_t Length() const noexcept = 0;
 
                uint16_t ClientId() const noexcept;
 
                uint16_t SessionId() const noexcept;
 
                virtual void SetSessionId(uint16_t sessionId);
 
                virtual bool IncrementSessionId() noexcept;
 
                uint8_t ProtocolVersion() const noexcept;
 
                uint8_t InterfaceVersion() const noexcept;
 
                SomeIpMessageType MessageType() const noexcept;
 
                SomeIpReturnCode ReturnCode() const noexcept;
 
                virtual std::vector<uint8_t> Payload() const;
            };
        }
    }
}
 
#endif