Struct Repr 

pub struct Repr<'a> {
    pub flags: u8,
    pub reserved: u32,
    pub entries: &'a [u8],
    pub options: &'a [u8],
}

A high-level representation of a SOME/IP-SD message.

Creating a Repr

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

Fields

flags: u8

Flags (1 byte) - typically used for reboot/unicast flags

reserved: u32

Reserved field (3 bytes) - should be 0x000000

entries: &'a [u8]

Entries array (variable length)

options: &'a [u8]

Options array (variable length)

Implementations

impl<'a> Repr<'a>

pub fn new(flags: u8, entries: &'a [u8], options: &'a [u8]) -> Self

Create a new SOME/IP-SD message representation. The length fields are automatically calculated.

Arguments

• flags - Flags byte (reboot, unicast flags)
• entries - Raw entries array data
• options - Raw options array data

Returns

A new Repr instance with reserved field set to 0.

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

where T: AsRef<[u8]>,

Parse a SOME/IP-SD packet into a high-level representation

Arguments

• packet - The packet to parse

Returns

• Result<Repr> - The parsed representation or an error

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-SD packet into the provided packet/buffer.

Arguments

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

pub fn buffer_len(&self) -> usize

Get the total wire format size needed for this representation

Returns

• usize - The total size in bytes

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>