Struct GenericMessage 

pub struct GenericMessage<H, B> {
    pub service: ServiceId,
    pub method: MethodId,
    pub header: H,
    pub body: B,
}

Message addressed to a service instance.

This is used to identify the contents of the payload so that it can be correctly serialized.

Has room for a header to include additional information about the body of the message.

Notes

This is the generic implementation. You probably want to use Message<T> instead.

Fields

service: ServiceId

Identifier of the service interface.

method: MethodId

Identifier of the method or event.

header: H

Additional information about the message.

body: B

Contents of the message.

Implementations

impl<H, B> GenericMessage<H, B>

pub const fn new(header: H, body: B) -> Self

Creates a new GenericMessage<H, B>.

Examples

use rsomeip_proto::GenericMessage;

let message = GenericMessage::new("header", "body");
assert_eq!(message.header, "header");
assert_eq!(message.body, "body");

pub const fn id(&self) -> MessageId

Returns the MessageId portion of this message.

Examples

use rsomeip_proto::{GenericMessage, ServiceId, MethodId};

let message = GenericMessage::new("header", "body")
    .with_service(ServiceId::new(0x1234))
    .with_method(MethodId::new(0x5678));
assert_eq!(message.id().as_u32(), 0x1234_5678);

pub const fn with_id(self, id: MessageId) -> Self

Returns self with the given MessageId.

Examples

use rsomeip_proto::{GenericMessage, MessageId};

let message = GenericMessage::new("header", "body").with_id(MessageId::from(0x1234_5678));
assert_eq!(message.service.as_u16(), 0x1234);
assert_eq!(message.method.as_u16(), 0x5678);

pub const fn with_service(self, service: ServiceId) -> Self

Returns self with the given ServiceId.

Examples

use rsomeip_proto::{GenericMessage, ServiceId};

let message = GenericMessage::new("header", "body").with_service(ServiceId::new(0x1234));
assert_eq!(message.service.as_u16(), 0x1234);

Examples found in repository

examples/request-sample.rs (line 33)

fn send_requests(socket: &UdpSocket, endpoint: &Endpoint) {
    // Create a request to send to the service provider.
    let mut session_id = SessionId::ENABLED;
    let request = Message::default()
        .with_service(SAMPLE_SERVICE_ID)
        .with_method(SAMPLE_METHOD_ID)
        .with_client(ClientId::new(0x0001))
        .with_body((0..10).collect::<Vec<u8>>());

    // Continuously send requests to the service provider.
    loop {
        // Clone the request and increment the session id.
        let request = request.clone().with_session(session_id.increment());
        println!("> {request} {:02x?}", request.body);

        // Process the request into bytes.
        let mut buffer = BytesMut::with_capacity(request.size_hint());
        endpoint
            .process(request, &mut buffer)
            .expect("should process the request");

        // Send the data through the socket.
        socket
            .send_to(&buffer.freeze(), stub_address())
            .expect("should send the data.");

        // Wait for a response.
        let mut buffer = BytesMut::zeroed(64);
        let (size, _) = socket
            .recv_from(&mut buffer[..])
            .expect("should receive the data");

        // Process the response.
        let response: Message = endpoint
            .poll(&mut buffer.split_to(size).freeze())
            .expect("should process the response");
        println!("< {response} {:02x?}", response.body);

        // Wait before sending another request.
        std::thread::sleep(std::time::Duration::from_secs(1));
    }
}

pub const fn with_method(self, method: MethodId) -> Self

Returns self with the given MethodId.

Examples

use rsomeip_proto::{GenericMessage, MethodId};

let message = GenericMessage::new("header", "body").with_method(MethodId::new(0x1234));
assert_eq!(message.method.as_u16(), 0x1234);

Examples found in repository

examples/request-sample.rs (line 34)

fn send_requests(socket: &UdpSocket, endpoint: &Endpoint) {
    // Create a request to send to the service provider.
    let mut session_id = SessionId::ENABLED;
    let request = Message::default()
        .with_service(SAMPLE_SERVICE_ID)
        .with_method(SAMPLE_METHOD_ID)
        .with_client(ClientId::new(0x0001))
        .with_body((0..10).collect::<Vec<u8>>());

    // Continuously send requests to the service provider.
    loop {
        // Clone the request and increment the session id.
        let request = request.clone().with_session(session_id.increment());
        println!("> {request} {:02x?}", request.body);

        // Process the request into bytes.
        let mut buffer = BytesMut::with_capacity(request.size_hint());
        endpoint
            .process(request, &mut buffer)
            .expect("should process the request");

        // Send the data through the socket.
        socket
            .send_to(&buffer.freeze(), stub_address())
            .expect("should send the data.");

        // Wait for a response.
        let mut buffer = BytesMut::zeroed(64);
        let (size, _) = socket
            .recv_from(&mut buffer[..])
            .expect("should receive the data");

        // Process the response.
        let response: Message = endpoint
            .poll(&mut buffer.split_to(size).freeze())
            .expect("should process the response");
        println!("< {response} {:02x?}", response.body);

        // Wait before sending another request.
        std::thread::sleep(std::time::Duration::from_secs(1));
    }
}

pub fn with_header<T>(self, header: T) -> GenericMessage<T, B>

Maps a GenericMessage<H, B> to a GenericMessage<T, B> by replacing the header of the message with the given value.

Examples

use rsomeip_proto::GenericMessage;

let message = GenericMessage::new("header", "body").with_header(0x1234_u16);
assert_eq!(message.header, 0x1234_u16);

pub fn with_body<T>(self, body: T) -> GenericMessage<H, T>

Maps a GenericMessage<H, B> to a GenericMessage<H, T> by replacing the body of the message with the given value.

Examples

use rsomeip_proto::GenericMessage;

let message = GenericMessage::new("header", "body").with_body(0x1234_u16);
assert_eq!(message.body, 0x1234_u16);

Examples found in repository

examples/request-sample.rs (line 36)

fn send_requests(socket: &UdpSocket, endpoint: &Endpoint) {
    // Create a request to send to the service provider.
    let mut session_id = SessionId::ENABLED;
    let request = Message::default()
        .with_service(SAMPLE_SERVICE_ID)
        .with_method(SAMPLE_METHOD_ID)
        .with_client(ClientId::new(0x0001))
        .with_body((0..10).collect::<Vec<u8>>());

    // Continuously send requests to the service provider.
    loop {
        // Clone the request and increment the session id.
        let request = request.clone().with_session(session_id.increment());
        println!("> {request} {:02x?}", request.body);

        // Process the request into bytes.
        let mut buffer = BytesMut::with_capacity(request.size_hint());
        endpoint
            .process(request, &mut buffer)
            .expect("should process the request");

        // Send the data through the socket.
        socket
            .send_to(&buffer.freeze(), stub_address())
            .expect("should send the data.");

        // Wait for a response.
        let mut buffer = BytesMut::zeroed(64);
        let (size, _) = socket
            .recv_from(&mut buffer[..])
            .expect("should receive the data");

        // Process the response.
        let response: Message = endpoint
            .poll(&mut buffer.split_to(size).freeze())
            .expect("should process the response");
        println!("< {response} {:02x?}", response.body);

        // Wait before sending another request.
        std::thread::sleep(std::time::Duration::from_secs(1));
    }
}

pub fn map<T, U, F>(self, f: F) -> GenericMessage<T, U>

where F: FnOnce(H, B) -> (T, U),

Maps a GenericMessage<H, B> to a GenericMessage<T, U> by applying a function to the header and body of the message.

Examples

use rsomeip_proto::GenericMessage;

let message = GenericMessage::new(1u8, 2u8)
    .map(|header, body| (header + 1, body + 1));
assert_eq!(message.header, 2);
assert_eq!(message.body, 3);

pub fn map_header<T, F>(self, f: F) -> GenericMessage<T, B>

where F: FnOnce(H) -> T,

Maps a GenericMessage<H, B> to a GenericMessage<T, B> by applying a function to the header of the message.

Examples

use rsomeip_proto::GenericMessage;

let message = GenericMessage::new(1u8, "body").map_header(|header| header + 1);
assert_eq!(message.header, 2);

pub fn map_body<T, F>(self, f: F) -> GenericMessage<H, T>

where F: FnOnce(B) -> T,

Maps a GenericMessage<H, B> to a GenericMessage<H, T> by applying a function to the body of the message.

Examples

use rsomeip_proto::GenericMessage;

let message = GenericMessage::new("header", 2u8).map_body(|body| body + 1);
assert_eq!(message.body, 3);

pub const fn replace_header(&mut self, value: H) -> H

Replaces the header of the message with the given value.

Returns the old value.

Examples

use rsomeip_proto::GenericMessage;

let mut message = GenericMessage::new("header", "body");
assert_eq!(message.replace_header("new_header"), "header");
assert_eq!(message.header, "new_header");

pub const fn replace_body(&mut self, value: B) -> B

Replaces the body of the message with the given value.

Returns the old value.

Examples

use rsomeip_proto::GenericMessage;

let mut message = GenericMessage::new("header", "body");
assert_eq!(message.replace_body("new_body"), "body");
assert_eq!(message.body, "new_body");

impl<B> GenericMessage<Header, B>

Specialization for the Header type.

pub fn into_response(self, return_code: ReturnCode) -> Self

Returns self as a response message with the given return_code.

Examples

use rsomeip_proto::{GenericMessage, Header, MessageType, ReturnCode};

let message = GenericMessage::new(Header::new(), "body")
    .into_response(ReturnCode::NotOk);
assert_eq!(message.header.message_type.as_type(), MessageType::Response);
assert_eq!(message.header.return_code, ReturnCode::NotOk);
assert_eq!(message.body, "body");

pub fn into_error(self, return_code: ReturnCode) -> Self

Returns self as an error message with the given return_code.

Examples

use rsomeip_proto::{GenericMessage, Header, MessageType, ReturnCode};

let message = GenericMessage::new(Header::new(), "body")
    .into_error(ReturnCode::NotOk);
assert_eq!(message.header.message_type.as_type(), MessageType::Error);
assert_eq!(message.header.return_code, ReturnCode::NotOk);
assert_eq!(message.body, "body");

pub const fn client(&self) -> ClientId

Returns the ClientId portion of the Header.

Examples

use rsomeip_proto::{GenericMessage, Header, ClientId};

let message = GenericMessage::new(Header::new(), "body")
    .with_client(ClientId::new(0x1234));
assert_eq!(message.client().as_u16(), 0x1234);

pub const fn with_client(self, client: ClientId) -> Self

Returns self with the given ClientId.

Examples

use rsomeip_proto::{GenericMessage, Header, ClientId};

let message = GenericMessage::new(Header::new(), "body")
    .with_client(ClientId::new(0x1234));
assert_eq!(message.client().as_u16(), 0x1234);

Examples found in repository

examples/request-sample.rs (line 35)

fn send_requests(socket: &UdpSocket, endpoint: &Endpoint) {
    // Create a request to send to the service provider.
    let mut session_id = SessionId::ENABLED;
    let request = Message::default()
        .with_service(SAMPLE_SERVICE_ID)
        .with_method(SAMPLE_METHOD_ID)
        .with_client(ClientId::new(0x0001))
        .with_body((0..10).collect::<Vec<u8>>());

    // Continuously send requests to the service provider.
    loop {
        // Clone the request and increment the session id.
        let request = request.clone().with_session(session_id.increment());
        println!("> {request} {:02x?}", request.body);

        // Process the request into bytes.
        let mut buffer = BytesMut::with_capacity(request.size_hint());
        endpoint
            .process(request, &mut buffer)
            .expect("should process the request");

        // Send the data through the socket.
        socket
            .send_to(&buffer.freeze(), stub_address())
            .expect("should send the data.");

        // Wait for a response.
        let mut buffer = BytesMut::zeroed(64);
        let (size, _) = socket
            .recv_from(&mut buffer[..])
            .expect("should receive the data");

        // Process the response.
        let response: Message = endpoint
            .poll(&mut buffer.split_to(size).freeze())
            .expect("should process the response");
        println!("< {response} {:02x?}", response.body);

        // Wait before sending another request.
        std::thread::sleep(std::time::Duration::from_secs(1));
    }
}

pub const fn session(&self) -> SessionId

Returns the SessionId portion of the Header.

Examples

use rsomeip_proto::{GenericMessage, Header, SessionId};

let message = GenericMessage::new(Header::new(), "body")
    .with_session(SessionId::new(0x1234));
assert_eq!(message.session().as_u16(), 0x1234);

pub const fn with_session(self, session: SessionId) -> Self

Returns self with the given SessionId.

Examples

use rsomeip_proto::{GenericMessage, Header, SessionId};

let message = GenericMessage::new(Header::new(), "body")
    .with_session(SessionId::new(0x1234));
assert_eq!(message.session().as_u16(), 0x1234);

Examples found in repository

examples/request-sample.rs (line 41)

fn send_requests(socket: &UdpSocket, endpoint: &Endpoint) {
    // Create a request to send to the service provider.
    let mut session_id = SessionId::ENABLED;
    let request = Message::default()
        .with_service(SAMPLE_SERVICE_ID)
        .with_method(SAMPLE_METHOD_ID)
        .with_client(ClientId::new(0x0001))
        .with_body((0..10).collect::<Vec<u8>>());

    // Continuously send requests to the service provider.
    loop {
        // Clone the request and increment the session id.
        let request = request.clone().with_session(session_id.increment());
        println!("> {request} {:02x?}", request.body);

        // Process the request into bytes.
        let mut buffer = BytesMut::with_capacity(request.size_hint());
        endpoint
            .process(request, &mut buffer)
            .expect("should process the request");

        // Send the data through the socket.
        socket
            .send_to(&buffer.freeze(), stub_address())
            .expect("should send the data.");

        // Wait for a response.
        let mut buffer = BytesMut::zeroed(64);
        let (size, _) = socket
            .recv_from(&mut buffer[..])
            .expect("should receive the data");

        // Process the response.
        let response: Message = endpoint
            .poll(&mut buffer.split_to(size).freeze())
            .expect("should process the response");
        println!("< {response} {:02x?}", response.body);

        // Wait before sending another request.
        std::thread::sleep(std::time::Duration::from_secs(1));
    }
}

pub const fn protocol(&self) -> ProtocolVersion

Returns the ProtocolVersion portion of the Header.

Examples

use rsomeip_proto::{GenericMessage, Header, ProtocolVersion};

let message = GenericMessage::new(Header::new(), "body")
    .with_protocol(ProtocolVersion::new(0x12));
assert_eq!(message.protocol().as_u8(), 0x12);

pub const fn with_protocol(self, protocol: ProtocolVersion) -> Self

Returns self with the given ProtocolVersion.

Examples

use rsomeip_proto::{GenericMessage, Header, ProtocolVersion};

let message = GenericMessage::new(Header::new(), "body")
    .with_protocol(ProtocolVersion::new(0x12));
assert_eq!(message.protocol().as_u8(), 0x12);

pub const fn interface(&self) -> InterfaceVersion

Returns the InterfaceVersion portion of the Header.

Examples

use rsomeip_proto::{GenericMessage, Header, InterfaceVersion};

let message = GenericMessage::new(Header::new(), "body")
    .with_interface(InterfaceVersion::new(0x12));
assert_eq!(message.interface().as_u8(), 0x12);

pub const fn with_interface(self, interface: InterfaceVersion) -> Self

Returns self with the given InterfaceVersion.

Examples

use rsomeip_proto::{GenericMessage, Header, InterfaceVersion};

let message = GenericMessage::new(Header::new(), "body")
    .with_interface(InterfaceVersion::new(0x12));
assert_eq!(message.interface().as_u8(), 0x12);

pub const fn message_type(&self) -> MessageType

Returns the MessageType of this GenericMessage<Header, B>.

Examples

use rsomeip_proto::{GenericMessage, Header, MessageType};

let message = GenericMessage::new(Header::new(), "body")
    .with_message_type(MessageType::Notification);
assert_eq!(message.message_type(), MessageType::Notification);

pub const fn with_message_type(self, message_type: MessageType) -> Self

Returns self with the given MessageType.

Examples

use rsomeip_proto::{GenericMessage, Header, MessageType};

let message = GenericMessage::new(Header::new(), "body")
    .with_message_type(MessageType::Notification);
assert_eq!(message.message_type(), MessageType::Notification);

Examples found in repository

examples/response-sample.rs (line 45)

fn send_responses(socket: &UdpSocket, endpoint: &Endpoint) {
    // Continuously process requests from service consumers.
    loop {
        // Wait for a request.
        let mut buffer = BytesMut::zeroed(64);
        let (size, remote_address) = socket
            .recv_from(&mut buffer[..])
            .expect("should receive the data");

        // Process the request.
        let request: Message = endpoint
            .poll(&mut buffer.split_to(size).freeze())
            .expect("should process the request");
        println!("< {request} {:02x?}", request.body);

        // Create a response.
        let response = request.clone().with_message_type(MessageType::Response);
        println!("> {response} {:02x?}", response.body);

        // Process the response into bytes.
        let mut buffer = BytesMut::with_capacity(request.size_hint());
        endpoint
            .process(response, &mut buffer)
            .expect("should process the response");

        // Send the data through the socket.
        socket
            .send_to(&buffer.freeze(), remote_address)
            .expect("should send the data.");
    }
}

pub const fn return_code(&self) -> ReturnCode

Returns the ReturnCode portion of the Header.

Examples

use rsomeip_proto::{GenericMessage, Header, ReturnCode};

let message = GenericMessage::new(Header::new(), "body")
    .with_return_code(ReturnCode::E2e);
assert_eq!(message.return_code(), ReturnCode::E2e);

pub const fn with_return_code(self, return_code: ReturnCode) -> Self

Returns self with the given ReturnCode.

Examples

use rsomeip_proto::{GenericMessage, Header, ReturnCode};

let message = GenericMessage::new(Header::new(), "body")
    .with_return_code(ReturnCode::E2e);
assert_eq!(message.return_code(), ReturnCode::E2e);

impl<H, B> GenericMessage<H, B>

where H: Serialize + Deserialize<Output = H>, B: Serialize + Deserialize<Output = B>,

pub fn to_bytes(&self) -> Result<Bytes, SerializeError>

Returns a buffer containing the serialized message.

Errors

Returns a SerializeError if the message could not be serialized.

pub fn from_bytes(buffer: &mut impl Buf) -> Result<Self, DeserializeError>

Returns a GenericMessage<H, B> deserialized from the buffer.

Errors

Returns a DeserializeError if the message could not be deserialized.

Trait Implementations

impl<H: Clone, B: Clone> Clone for GenericMessage<H, B>

fn clone(&self) -> GenericMessage<H, B>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<H: Debug, B: Debug> Debug for GenericMessage<H, B>

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

Formats the value using the given formatter.

impl<H, B> Default for GenericMessage<H, B>

where H: Default, B: Default,

fn default() -> Self

Returns the “default value” for a type.

impl<H, B> Deserialize for GenericMessage<H, B>

where H: Deserialize<Output = H>, B: Deserialize<Output = B>,

type Output = GenericMessage<H, B>

Type of the data that will be deserialized.

fn deserialize(buffer: &mut impl Buf) -> Result<Self::Output, DeserializeError>

Deserializes an instance of Deserialize::Output from the buffer.

fn deserialize_len( length: LengthField, buffer: &mut impl Buf, ) -> Result<Self::Output, DeserializeError>

Deserializes an instance of Deserialize::Output from the buffer.

impl<H, B> Display for GenericMessage<H, B>

where H: Display,

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

Formats self into a string.

Examples

use rsomeip_proto::{GenericMessage, ServiceId, MethodId};

let message = GenericMessage::new("header", "body")
    .with_service(ServiceId::new(0x1234))
    .with_method(MethodId::new(0x5678));
assert_eq!(message.to_string(), "1234.5678.header")

impl<H: PartialEq, B: PartialEq> PartialEq for GenericMessage<H, B>

fn eq(&self, other: &GenericMessage<H, B>) -> 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<H, B> Serialize for GenericMessage<H, B>

where H: Serialize, B: Serialize,

fn serialize(&self, buffer: &mut impl BufMut) -> Result<usize, SerializeError>

Serializes the implementing type into the buffer.

fn size_hint(&self) -> usize

Returns the expected length of the serialized data.

fn serialize_len( &self, length: LengthField, buffer: &mut impl BufMut, ) -> Result<usize, SerializeError>

Serializes the implementing type into the buffer.

impl<H: Eq, B: Eq> Eq for GenericMessage<H, B>

impl<H, B> StructuralPartialEq for GenericMessage<H, B>