Struct Repr 

pub struct Repr<'a> {
    pub message_id: MessageId,
    pub length: u32,
    pub request_id: RequestId,
    pub protocol_version: u8,
    pub interface_version: u8,
    pub message_type: MessageType,
    pub return_code: ReturnCode,
    pub data: &'a [u8],
}

A high-level representation of a Some/IP message.

Creating a Repr

The preferred way to create a Repr is using Repr::new(), which automatically calculates the correct length field. However, you can also construct it manually using struct initialization if needed.

Fields

message_id: MessageId

Message ID (32 bits)

length: u32

Length field (32 bits) - automatically calculated as 8 + data.len() when using new()

request_id: RequestId

Request ID (32 bits)

protocol_version: u8

Protocol version (8 bits)

interface_version: u8

Interface version (8 bits)

message_type: MessageType

Message type (8 bits)

return_code: ReturnCode

Return code (8 bits)

data: &'a [u8]

Payload data (variable length)

Implementations

impl<'a> Repr<'a>

pub fn new( message_id: MessageId, request_id: RequestId, protocol_version: u8, interface_version: u8, message_type: MessageType, return_code: ReturnCode, data: &'a [u8], ) -> Self

Create a new SOME/IP message representation. The length field is automatically calculated as 8 (header bytes) + data.len().

Arguments

• message_id - The message ID
• request_id - The request ID
• protocol_version - Protocol version (typically 0x01)
• interface_version - Interface version
• message_type - The message type
• return_code - The return code
• data - The payload data

Returns

A new Repr instance with the length field automatically calculated.

pub fn length(&self) -> u32

Get the length field value (8 header bytes + payload length)

pub fn parse<T>(packet: &'a Packet<T>) -> Result<Repr<'a>, Error>

where T: AsRef<[u8]>,

pub fn emit<T>(&self, packet: &mut Packet<&mut T>)

where T: AsRef<[u8]> + AsMut<[u8]> + ?Sized,

Emits the high-level representation of the Some/IP packet into the provided packet/buffer.

Arguments

• packet - A mutable reference to the packet where the high-level representation will be written.

Trait Implementations

impl<'a> Clone for Repr<'a>

fn clone(&self) -> Repr<'a>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Debug for Repr<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a> Display for Repr<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the high-level representation as a string.

impl<'a> PartialEq for Repr<'a>

fn eq(&self, other: &Repr<'a>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> Copy for Repr<'a>

impl<'a> Eq for Repr<'a>

impl<'a> StructuralPartialEq for Repr<'a>