Struct SomeIpMessage 

pub struct SomeIpMessage {
    pub header: SomeIpHeader,
    pub payload: Bytes,
}

A complete SOME/IP message (header + payload).

Fields

header: SomeIpHeader

Message header.

payload: Bytes

Message payload.

Implementations

impl SomeIpMessage

pub fn new(header: SomeIpHeader, payload: impl Into<Bytes>) -> Self

Create a new message with the given header and payload.

pub fn with_header(header: SomeIpHeader) -> Self

Create a new message with an empty payload.

pub fn request(service_id: ServiceId, method_id: MethodId) -> MessageBuilder

Create a request message builder.

Examples found in repository

examples/udp_client.rs (line 28)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("Creating SOME/IP UDP client...");

    let mut client = UdpClient::new()?;
    client.set_client_id(ClientId(0x0200));
    client.set_read_timeout(Some(Duration::from_secs(5)))?;

    println!("Client bound to {}", client.local_addr()?);

    // Example 1: Request with call_to (specify address per-request)
    println!("\n--- Example 1: Request/Response ---");
    let request = SomeIpMessage::request(ServiceId(SERVICE_ID), MethodId(METHOD_REVERSE))
        .payload(b"Hello UDP!".as_slice())
        .build();

    println!(
        "Sending: {:?}",
        String::from_utf8_lossy(&request.payload)
    );

    let response = client.call_to(SERVER_ADDR, request)?;
    println!(
        "Received: {:?} (reversed)",
        String::from_utf8_lossy(&response.payload)
    );

    // Example 2: Connect and use call()
    println!("\n--- Example 2: Connected Mode ---");
    client.connect(SERVER_ADDR)?;
    println!("Connected to {SERVER_ADDR}");

    for word in ["Rust", "SOME/IP", "Automotive"] {
        let request = SomeIpMessage::request(ServiceId(SERVICE_ID), MethodId(METHOD_REVERSE))
            .payload(word.as_bytes().to_vec())
            .build();

        let response = client.call(request)?;
        println!(
            "{} -> {}",
            word,
            String::from_utf8_lossy(&response.payload)
        );
    }

    // Example 3: Send notification (fire-and-forget)
    println!("\n--- Example 3: Notification ---");
    let notification = SomeIpMessage::notification(ServiceId(SERVICE_ID), MethodId(0x8001))
        .payload(b"Event occurred!".as_slice())
        .build();

    client.send(notification)?;
    println!("Notification sent!");

    println!("\nDone!");
    Ok(())
}

examples/tcp_client.rs (line 29)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("Connecting to SOME/IP server at {SERVER_ADDR}...");

    let mut client = TcpClient::connect(SERVER_ADDR)?;
    client.set_client_id(ClientId(0x0100));
    client.set_read_timeout(Some(Duration::from_secs(5)))?;

    println!("Connected!");

    // Example 1: Simple echo request
    println!("\n--- Example 1: Echo Request ---");
    let request = SomeIpMessage::request(ServiceId(SERVICE_ID), MethodId(METHOD_ECHO))
        .payload(b"Hello, SOME/IP!".as_slice())
        .build();

    println!(
        "Sending request: service={}, method={}, payload={:?}",
        request.header.service_id,
        request.header.method_id,
        String::from_utf8_lossy(&request.payload)
    );

    let response = client.call(request)?;
    println!(
        "Received response: return_code={:?}, payload={:?}",
        response.header.return_code,
        String::from_utf8_lossy(&response.payload)
    );

    // Example 2: Multiple requests
    println!("\n--- Example 2: Multiple Requests ---");
    for i in 1..=3 {
        let payload = format!("Message #{i}");
        let request = SomeIpMessage::request(ServiceId(SERVICE_ID), MethodId(METHOD_GREET))
            .payload(payload.as_bytes().to_vec())
            .build();

        println!("Request {i}: session_id={}", request.header.session_id);
        let response = client.call(request)?;
        println!(
            "Response {i}: session_id={}, payload={:?}",
            response.header.session_id,
            String::from_utf8_lossy(&response.payload)
        );
    }

    // Example 3: Fire-and-forget (notification)
    println!("\n--- Example 3: Fire-and-Forget ---");
    let notification =
        SomeIpMessage::request_no_return(ServiceId(SERVICE_ID), MethodId(METHOD_ECHO))
            .payload(b"This is a notification".as_slice())
            .build();

    println!("Sending notification (no response expected)...");
    client.send(notification)?;
    println!("Notification sent!");

    println!("\nDone!");
    Ok(())
}

examples/message_basics.rs (line 18)

fn main() {
    println!("=== SOME/IP Message Basics ===\n");

    // Example 1: Create a request message using the builder
    println!("--- Example 1: Building Messages ---");
    let request = SomeIpMessage::request(ServiceId(0x1234), MethodId(0x0001))
        .client_id(ClientId(0x0100))
        .session_id(SessionId(0x0001))
        .interface_version(2)
        .payload(b"Hello, World!".as_slice())
        .build();

    println!("Request message:");
    print_message(&request);

    // Example 2: Create a response from the request
    println!("\n--- Example 2: Creating Responses ---");
    let response = request
        .create_response()
        .payload(b"Response data".as_slice())
        .build();

    println!("Response message:");
    print_message(&response);

    // Example 3: Create an error response
    println!("\n--- Example 3: Error Response ---");
    let error = request
        .create_error_response(ReturnCode::UnknownMethod)
        .build();

    println!("Error response:");
    print_message(&error);

    // Example 4: Serialize and deserialize
    println!("\n--- Example 4: Serialization ---");
    let bytes = request.to_bytes();
    println!("Serialized to {} bytes", bytes.len());
    println!("Header bytes: {:02X?}", &bytes[..HEADER_SIZE]);
    println!("Payload bytes: {:02X?}", &bytes[HEADER_SIZE..]);

    let parsed = SomeIpMessage::from_bytes(&bytes).expect("Failed to parse");
    println!("\nParsed message matches original: {}", parsed == request);

    // Example 5: Working with headers directly
    println!("\n--- Example 5: Header Details ---");
    let header = SomeIpHeader::new(ServiceId(0xFFFF), MethodId(0x8001));
    println!("Service ID: {}", header.service_id);
    println!("Method ID: {} (is_event: {})", header.method_id, header.method_id.is_event());
    println!("Message ID: 0x{:08X}", header.message_id());
    println!("Request ID: 0x{:08X}", header.request_id());

    // Example 6: Different message types
    println!("\n--- Example 6: Message Types ---");

    let notification = SomeIpMessage::notification(ServiceId(0x1234), MethodId::event(0x0001))
        .payload(b"Event data".as_slice())
        .build();
    println!("Notification: type={:?}, method_id={} (is_event: {})",
        notification.header.message_type,
        notification.header.method_id,
        notification.header.method_id.is_event()
    );

    let fire_and_forget = SomeIpMessage::request_no_return(ServiceId(0x1234), MethodId(0x0002))
        .payload(b"Fire and forget".as_slice())
        .build();
    println!("Fire-and-forget: type={:?}, expects_response: {}",
        fire_and_forget.header.message_type,
        fire_and_forget.expects_response()
    );

    // Example 7: Return codes
    println!("\n--- Example 7: Return Codes ---");
    for code in [
        ReturnCode::Ok,
        ReturnCode::NotOk,
        ReturnCode::UnknownService,
        ReturnCode::UnknownMethod,
        ReturnCode::Timeout,
    ] {
        println!("  {:?}: is_ok={}, value=0x{:02X}", code, code.is_ok(), code as u8);
    }

    println!("\n=== Done! ===");
}

pub fn request_no_return( service_id: ServiceId, method_id: MethodId, ) -> MessageBuilder

Create a request-no-return message builder.

Examples found in repository

examples/tcp_client.rs (line 67)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("Connecting to SOME/IP server at {SERVER_ADDR}...");

    let mut client = TcpClient::connect(SERVER_ADDR)?;
    client.set_client_id(ClientId(0x0100));
    client.set_read_timeout(Some(Duration::from_secs(5)))?;

    println!("Connected!");

    // Example 1: Simple echo request
    println!("\n--- Example 1: Echo Request ---");
    let request = SomeIpMessage::request(ServiceId(SERVICE_ID), MethodId(METHOD_ECHO))
        .payload(b"Hello, SOME/IP!".as_slice())
        .build();

    println!(
        "Sending request: service={}, method={}, payload={:?}",
        request.header.service_id,
        request.header.method_id,
        String::from_utf8_lossy(&request.payload)
    );

    let response = client.call(request)?;
    println!(
        "Received response: return_code={:?}, payload={:?}",
        response.header.return_code,
        String::from_utf8_lossy(&response.payload)
    );

    // Example 2: Multiple requests
    println!("\n--- Example 2: Multiple Requests ---");
    for i in 1..=3 {
        let payload = format!("Message #{i}");
        let request = SomeIpMessage::request(ServiceId(SERVICE_ID), MethodId(METHOD_GREET))
            .payload(payload.as_bytes().to_vec())
            .build();

        println!("Request {i}: session_id={}", request.header.session_id);
        let response = client.call(request)?;
        println!(
            "Response {i}: session_id={}, payload={:?}",
            response.header.session_id,
            String::from_utf8_lossy(&response.payload)
        );
    }

    // Example 3: Fire-and-forget (notification)
    println!("\n--- Example 3: Fire-and-Forget ---");
    let notification =
        SomeIpMessage::request_no_return(ServiceId(SERVICE_ID), MethodId(METHOD_ECHO))
            .payload(b"This is a notification".as_slice())
            .build();

    println!("Sending notification (no response expected)...");
    client.send(notification)?;
    println!("Notification sent!");

    println!("\nDone!");
    Ok(())
}

examples/message_basics.rs (line 77)

fn main() {
    println!("=== SOME/IP Message Basics ===\n");

    // Example 1: Create a request message using the builder
    println!("--- Example 1: Building Messages ---");
    let request = SomeIpMessage::request(ServiceId(0x1234), MethodId(0x0001))
        .client_id(ClientId(0x0100))
        .session_id(SessionId(0x0001))
        .interface_version(2)
        .payload(b"Hello, World!".as_slice())
        .build();

    println!("Request message:");
    print_message(&request);

    // Example 2: Create a response from the request
    println!("\n--- Example 2: Creating Responses ---");
    let response = request
        .create_response()
        .payload(b"Response data".as_slice())
        .build();

    println!("Response message:");
    print_message(&response);

    // Example 3: Create an error response
    println!("\n--- Example 3: Error Response ---");
    let error = request
        .create_error_response(ReturnCode::UnknownMethod)
        .build();

    println!("Error response:");
    print_message(&error);

    // Example 4: Serialize and deserialize
    println!("\n--- Example 4: Serialization ---");
    let bytes = request.to_bytes();
    println!("Serialized to {} bytes", bytes.len());
    println!("Header bytes: {:02X?}", &bytes[..HEADER_SIZE]);
    println!("Payload bytes: {:02X?}", &bytes[HEADER_SIZE..]);

    let parsed = SomeIpMessage::from_bytes(&bytes).expect("Failed to parse");
    println!("\nParsed message matches original: {}", parsed == request);

    // Example 5: Working with headers directly
    println!("\n--- Example 5: Header Details ---");
    let header = SomeIpHeader::new(ServiceId(0xFFFF), MethodId(0x8001));
    println!("Service ID: {}", header.service_id);
    println!("Method ID: {} (is_event: {})", header.method_id, header.method_id.is_event());
    println!("Message ID: 0x{:08X}", header.message_id());
    println!("Request ID: 0x{:08X}", header.request_id());

    // Example 6: Different message types
    println!("\n--- Example 6: Message Types ---");

    let notification = SomeIpMessage::notification(ServiceId(0x1234), MethodId::event(0x0001))
        .payload(b"Event data".as_slice())
        .build();
    println!("Notification: type={:?}, method_id={} (is_event: {})",
        notification.header.message_type,
        notification.header.method_id,
        notification.header.method_id.is_event()
    );

    let fire_and_forget = SomeIpMessage::request_no_return(ServiceId(0x1234), MethodId(0x0002))
        .payload(b"Fire and forget".as_slice())
        .build();
    println!("Fire-and-forget: type={:?}, expects_response: {}",
        fire_and_forget.header.message_type,
        fire_and_forget.expects_response()
    );

    // Example 7: Return codes
    println!("\n--- Example 7: Return Codes ---");
    for code in [
        ReturnCode::Ok,
        ReturnCode::NotOk,
        ReturnCode::UnknownService,
        ReturnCode::UnknownMethod,
        ReturnCode::Timeout,
    ] {
        println!("  {:?}: is_ok={}, value=0x{:02X}", code, code.is_ok(), code as u8);
    }

    println!("\n=== Done! ===");
}

pub fn notification( service_id: ServiceId, method_id: MethodId, ) -> MessageBuilder

Create a notification message builder.

Examples found in repository

examples/udp_client.rs (line 63)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("Creating SOME/IP UDP client...");

    let mut client = UdpClient::new()?;
    client.set_client_id(ClientId(0x0200));
    client.set_read_timeout(Some(Duration::from_secs(5)))?;

    println!("Client bound to {}", client.local_addr()?);

    // Example 1: Request with call_to (specify address per-request)
    println!("\n--- Example 1: Request/Response ---");
    let request = SomeIpMessage::request(ServiceId(SERVICE_ID), MethodId(METHOD_REVERSE))
        .payload(b"Hello UDP!".as_slice())
        .build();

    println!(
        "Sending: {:?}",
        String::from_utf8_lossy(&request.payload)
    );

    let response = client.call_to(SERVER_ADDR, request)?;
    println!(
        "Received: {:?} (reversed)",
        String::from_utf8_lossy(&response.payload)
    );

    // Example 2: Connect and use call()
    println!("\n--- Example 2: Connected Mode ---");
    client.connect(SERVER_ADDR)?;
    println!("Connected to {SERVER_ADDR}");

    for word in ["Rust", "SOME/IP", "Automotive"] {
        let request = SomeIpMessage::request(ServiceId(SERVICE_ID), MethodId(METHOD_REVERSE))
            .payload(word.as_bytes().to_vec())
            .build();

        let response = client.call(request)?;
        println!(
            "{} -> {}",
            word,
            String::from_utf8_lossy(&response.payload)
        );
    }

    // Example 3: Send notification (fire-and-forget)
    println!("\n--- Example 3: Notification ---");
    let notification = SomeIpMessage::notification(ServiceId(SERVICE_ID), MethodId(0x8001))
        .payload(b"Event occurred!".as_slice())
        .build();

    client.send(notification)?;
    println!("Notification sent!");

    println!("\nDone!");
    Ok(())
}

examples/message_basics.rs (line 68)

fn main() {
    println!("=== SOME/IP Message Basics ===\n");

    // Example 1: Create a request message using the builder
    println!("--- Example 1: Building Messages ---");
    let request = SomeIpMessage::request(ServiceId(0x1234), MethodId(0x0001))
        .client_id(ClientId(0x0100))
        .session_id(SessionId(0x0001))
        .interface_version(2)
        .payload(b"Hello, World!".as_slice())
        .build();

    println!("Request message:");
    print_message(&request);

    // Example 2: Create a response from the request
    println!("\n--- Example 2: Creating Responses ---");
    let response = request
        .create_response()
        .payload(b"Response data".as_slice())
        .build();

    println!("Response message:");
    print_message(&response);

    // Example 3: Create an error response
    println!("\n--- Example 3: Error Response ---");
    let error = request
        .create_error_response(ReturnCode::UnknownMethod)
        .build();

    println!("Error response:");
    print_message(&error);

    // Example 4: Serialize and deserialize
    println!("\n--- Example 4: Serialization ---");
    let bytes = request.to_bytes();
    println!("Serialized to {} bytes", bytes.len());
    println!("Header bytes: {:02X?}", &bytes[..HEADER_SIZE]);
    println!("Payload bytes: {:02X?}", &bytes[HEADER_SIZE..]);

    let parsed = SomeIpMessage::from_bytes(&bytes).expect("Failed to parse");
    println!("\nParsed message matches original: {}", parsed == request);

    // Example 5: Working with headers directly
    println!("\n--- Example 5: Header Details ---");
    let header = SomeIpHeader::new(ServiceId(0xFFFF), MethodId(0x8001));
    println!("Service ID: {}", header.service_id);
    println!("Method ID: {} (is_event: {})", header.method_id, header.method_id.is_event());
    println!("Message ID: 0x{:08X}", header.message_id());
    println!("Request ID: 0x{:08X}", header.request_id());

    // Example 6: Different message types
    println!("\n--- Example 6: Message Types ---");

    let notification = SomeIpMessage::notification(ServiceId(0x1234), MethodId::event(0x0001))
        .payload(b"Event data".as_slice())
        .build();
    println!("Notification: type={:?}, method_id={} (is_event: {})",
        notification.header.message_type,
        notification.header.method_id,
        notification.header.method_id.is_event()
    );

    let fire_and_forget = SomeIpMessage::request_no_return(ServiceId(0x1234), MethodId(0x0002))
        .payload(b"Fire and forget".as_slice())
        .build();
    println!("Fire-and-forget: type={:?}, expects_response: {}",
        fire_and_forget.header.message_type,
        fire_and_forget.expects_response()
    );

    // Example 7: Return codes
    println!("\n--- Example 7: Return Codes ---");
    for code in [
        ReturnCode::Ok,
        ReturnCode::NotOk,
        ReturnCode::UnknownService,
        ReturnCode::UnknownMethod,
        ReturnCode::Timeout,
    ] {
        println!("  {:?}: is_ok={}, value=0x{:02X}", code, code.is_ok(), code as u8);
    }

    println!("\n=== Done! ===");
}

pub fn create_response(&self) -> MessageBuilder

Create a response to this message.

Examples found in repository

examples/tcp_server.rs (line 55)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("Starting SOME/IP TCP server on {BIND_ADDR}...");

    let server = TcpServer::bind(BIND_ADDR)?;
    println!("Server listening on {}", server.local_addr());

    for connection in server.incoming() {
        match connection {
            Ok(mut conn) => {
                let peer = conn.peer_addr();
                println!("New connection from {peer}");

                // Handle each connection in a separate thread
                thread::spawn(move || {
                    loop {
                        match conn.read_message() {
                            Ok(request) => {
                                println!(
                                    "Received: service={}, method={}, type={:?}, payload={} bytes",
                                    request.header.service_id,
                                    request.header.method_id,
                                    request.header.message_type,
                                    request.payload.len()
                                );

                                // Check if it's our service
                                if request.header.service_id != ServiceId(SERVICE_ID) {
                                    println!("Unknown service, sending error response");
                                    let error = request
                                        .create_error_response(ReturnCode::UnknownService)
                                        .build();
                                    let _ = conn.write_message(&error);
                                    continue;
                                }

                                // Only respond to requests (not notifications)
                                if request.header.message_type == MessageType::Request {
                                    // Echo back the payload
                                    let response = request
                                        .create_response()
                                        .payload(request.payload.clone())
                                        .build();

                                    if let Err(e) = conn.write_message(&response) {
                                        eprintln!("Failed to send response: {e}");
                                        break;
                                    }
                                    println!("Sent response");
                                }
                            }
                            Err(e) => {
                                eprintln!("Connection error: {e}");
                                break;
                            }
                        }
                    }
                    println!("Connection closed: {peer}");
                });
            }
            Err(e) => {
                eprintln!("Accept error: {e}");
            }
        }
    }

    Ok(())
}

examples/message_basics.rs (line 31)

fn main() {
    println!("=== SOME/IP Message Basics ===\n");

    // Example 1: Create a request message using the builder
    println!("--- Example 1: Building Messages ---");
    let request = SomeIpMessage::request(ServiceId(0x1234), MethodId(0x0001))
        .client_id(ClientId(0x0100))
        .session_id(SessionId(0x0001))
        .interface_version(2)
        .payload(b"Hello, World!".as_slice())
        .build();

    println!("Request message:");
    print_message(&request);

    // Example 2: Create a response from the request
    println!("\n--- Example 2: Creating Responses ---");
    let response = request
        .create_response()
        .payload(b"Response data".as_slice())
        .build();

    println!("Response message:");
    print_message(&response);

    // Example 3: Create an error response
    println!("\n--- Example 3: Error Response ---");
    let error = request
        .create_error_response(ReturnCode::UnknownMethod)
        .build();

    println!("Error response:");
    print_message(&error);

    // Example 4: Serialize and deserialize
    println!("\n--- Example 4: Serialization ---");
    let bytes = request.to_bytes();
    println!("Serialized to {} bytes", bytes.len());
    println!("Header bytes: {:02X?}", &bytes[..HEADER_SIZE]);
    println!("Payload bytes: {:02X?}", &bytes[HEADER_SIZE..]);

    let parsed = SomeIpMessage::from_bytes(&bytes).expect("Failed to parse");
    println!("\nParsed message matches original: {}", parsed == request);

    // Example 5: Working with headers directly
    println!("\n--- Example 5: Header Details ---");
    let header = SomeIpHeader::new(ServiceId(0xFFFF), MethodId(0x8001));
    println!("Service ID: {}", header.service_id);
    println!("Method ID: {} (is_event: {})", header.method_id, header.method_id.is_event());
    println!("Message ID: 0x{:08X}", header.message_id());
    println!("Request ID: 0x{:08X}", header.request_id());

    // Example 6: Different message types
    println!("\n--- Example 6: Message Types ---");

    let notification = SomeIpMessage::notification(ServiceId(0x1234), MethodId::event(0x0001))
        .payload(b"Event data".as_slice())
        .build();
    println!("Notification: type={:?}, method_id={} (is_event: {})",
        notification.header.message_type,
        notification.header.method_id,
        notification.header.method_id.is_event()
    );

    let fire_and_forget = SomeIpMessage::request_no_return(ServiceId(0x1234), MethodId(0x0002))
        .payload(b"Fire and forget".as_slice())
        .build();
    println!("Fire-and-forget: type={:?}, expects_response: {}",
        fire_and_forget.header.message_type,
        fire_and_forget.expects_response()
    );

    // Example 7: Return codes
    println!("\n--- Example 7: Return Codes ---");
    for code in [
        ReturnCode::Ok,
        ReturnCode::NotOk,
        ReturnCode::UnknownService,
        ReturnCode::UnknownMethod,
        ReturnCode::Timeout,
    ] {
        println!("  {:?}: is_ok={}, value=0x{:02X}", code, code.is_ok(), code as u8);
    }

    println!("\n=== Done! ===");
}

pub fn create_error_response(&self, return_code: ReturnCode) -> MessageBuilder

Create an error response to this message.

Examples found in repository

examples/tcp_server.rs (line 45)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("Starting SOME/IP TCP server on {BIND_ADDR}...");

    let server = TcpServer::bind(BIND_ADDR)?;
    println!("Server listening on {}", server.local_addr());

    for connection in server.incoming() {
        match connection {
            Ok(mut conn) => {
                let peer = conn.peer_addr();
                println!("New connection from {peer}");

                // Handle each connection in a separate thread
                thread::spawn(move || {
                    loop {
                        match conn.read_message() {
                            Ok(request) => {
                                println!(
                                    "Received: service={}, method={}, type={:?}, payload={} bytes",
                                    request.header.service_id,
                                    request.header.method_id,
                                    request.header.message_type,
                                    request.payload.len()
                                );

                                // Check if it's our service
                                if request.header.service_id != ServiceId(SERVICE_ID) {
                                    println!("Unknown service, sending error response");
                                    let error = request
                                        .create_error_response(ReturnCode::UnknownService)
                                        .build();
                                    let _ = conn.write_message(&error);
                                    continue;
                                }

                                // Only respond to requests (not notifications)
                                if request.header.message_type == MessageType::Request {
                                    // Echo back the payload
                                    let response = request
                                        .create_response()
                                        .payload(request.payload.clone())
                                        .build();

                                    if let Err(e) = conn.write_message(&response) {
                                        eprintln!("Failed to send response: {e}");
                                        break;
                                    }
                                    println!("Sent response");
                                }
                            }
                            Err(e) => {
                                eprintln!("Connection error: {e}");
                                break;
                            }
                        }
                    }
                    println!("Connection closed: {peer}");
                });
            }
            Err(e) => {
                eprintln!("Accept error: {e}");
            }
        }
    }

    Ok(())
}

examples/message_basics.rs (line 41)

fn main() {
    println!("=== SOME/IP Message Basics ===\n");

    // Example 1: Create a request message using the builder
    println!("--- Example 1: Building Messages ---");
    let request = SomeIpMessage::request(ServiceId(0x1234), MethodId(0x0001))
        .client_id(ClientId(0x0100))
        .session_id(SessionId(0x0001))
        .interface_version(2)
        .payload(b"Hello, World!".as_slice())
        .build();

    println!("Request message:");
    print_message(&request);

    // Example 2: Create a response from the request
    println!("\n--- Example 2: Creating Responses ---");
    let response = request
        .create_response()
        .payload(b"Response data".as_slice())
        .build();

    println!("Response message:");
    print_message(&response);

    // Example 3: Create an error response
    println!("\n--- Example 3: Error Response ---");
    let error = request
        .create_error_response(ReturnCode::UnknownMethod)
        .build();

    println!("Error response:");
    print_message(&error);

    // Example 4: Serialize and deserialize
    println!("\n--- Example 4: Serialization ---");
    let bytes = request.to_bytes();
    println!("Serialized to {} bytes", bytes.len());
    println!("Header bytes: {:02X?}", &bytes[..HEADER_SIZE]);
    println!("Payload bytes: {:02X?}", &bytes[HEADER_SIZE..]);

    let parsed = SomeIpMessage::from_bytes(&bytes).expect("Failed to parse");
    println!("\nParsed message matches original: {}", parsed == request);

    // Example 5: Working with headers directly
    println!("\n--- Example 5: Header Details ---");
    let header = SomeIpHeader::new(ServiceId(0xFFFF), MethodId(0x8001));
    println!("Service ID: {}", header.service_id);
    println!("Method ID: {} (is_event: {})", header.method_id, header.method_id.is_event());
    println!("Message ID: 0x{:08X}", header.message_id());
    println!("Request ID: 0x{:08X}", header.request_id());

    // Example 6: Different message types
    println!("\n--- Example 6: Message Types ---");

    let notification = SomeIpMessage::notification(ServiceId(0x1234), MethodId::event(0x0001))
        .payload(b"Event data".as_slice())
        .build();
    println!("Notification: type={:?}, method_id={} (is_event: {})",
        notification.header.message_type,
        notification.header.method_id,
        notification.header.method_id.is_event()
    );

    let fire_and_forget = SomeIpMessage::request_no_return(ServiceId(0x1234), MethodId(0x0002))
        .payload(b"Fire and forget".as_slice())
        .build();
    println!("Fire-and-forget: type={:?}, expects_response: {}",
        fire_and_forget.header.message_type,
        fire_and_forget.expects_response()
    );

    // Example 7: Return codes
    println!("\n--- Example 7: Return Codes ---");
    for code in [
        ReturnCode::Ok,
        ReturnCode::NotOk,
        ReturnCode::UnknownService,
        ReturnCode::UnknownMethod,
        ReturnCode::Timeout,
    ] {
        println!("  {:?}: is_ok={}, value=0x{:02X}", code, code.is_ok(), code as u8);
    }

    println!("\n=== Done! ===");
}

pub fn from_bytes(data: &[u8]) -> Result<Self>

Parse a message from bytes.

Examples found in repository

examples/message_basics.rs (line 54)

fn main() {
    println!("=== SOME/IP Message Basics ===\n");

    // Example 1: Create a request message using the builder
    println!("--- Example 1: Building Messages ---");
    let request = SomeIpMessage::request(ServiceId(0x1234), MethodId(0x0001))
        .client_id(ClientId(0x0100))
        .session_id(SessionId(0x0001))
        .interface_version(2)
        .payload(b"Hello, World!".as_slice())
        .build();

    println!("Request message:");
    print_message(&request);

    // Example 2: Create a response from the request
    println!("\n--- Example 2: Creating Responses ---");
    let response = request
        .create_response()
        .payload(b"Response data".as_slice())
        .build();

    println!("Response message:");
    print_message(&response);

    // Example 3: Create an error response
    println!("\n--- Example 3: Error Response ---");
    let error = request
        .create_error_response(ReturnCode::UnknownMethod)
        .build();

    println!("Error response:");
    print_message(&error);

    // Example 4: Serialize and deserialize
    println!("\n--- Example 4: Serialization ---");
    let bytes = request.to_bytes();
    println!("Serialized to {} bytes", bytes.len());
    println!("Header bytes: {:02X?}", &bytes[..HEADER_SIZE]);
    println!("Payload bytes: {:02X?}", &bytes[HEADER_SIZE..]);

    let parsed = SomeIpMessage::from_bytes(&bytes).expect("Failed to parse");
    println!("\nParsed message matches original: {}", parsed == request);

    // Example 5: Working with headers directly
    println!("\n--- Example 5: Header Details ---");
    let header = SomeIpHeader::new(ServiceId(0xFFFF), MethodId(0x8001));
    println!("Service ID: {}", header.service_id);
    println!("Method ID: {} (is_event: {})", header.method_id, header.method_id.is_event());
    println!("Message ID: 0x{:08X}", header.message_id());
    println!("Request ID: 0x{:08X}", header.request_id());

    // Example 6: Different message types
    println!("\n--- Example 6: Message Types ---");

    let notification = SomeIpMessage::notification(ServiceId(0x1234), MethodId::event(0x0001))
        .payload(b"Event data".as_slice())
        .build();
    println!("Notification: type={:?}, method_id={} (is_event: {})",
        notification.header.message_type,
        notification.header.method_id,
        notification.header.method_id.is_event()
    );

    let fire_and_forget = SomeIpMessage::request_no_return(ServiceId(0x1234), MethodId(0x0002))
        .payload(b"Fire and forget".as_slice())
        .build();
    println!("Fire-and-forget: type={:?}, expects_response: {}",
        fire_and_forget.header.message_type,
        fire_and_forget.expects_response()
    );

    // Example 7: Return codes
    println!("\n--- Example 7: Return Codes ---");
    for code in [
        ReturnCode::Ok,
        ReturnCode::NotOk,
        ReturnCode::UnknownService,
        ReturnCode::UnknownMethod,
        ReturnCode::Timeout,
    ] {
        println!("  {:?}: is_ok={}, value=0x{:02X}", code, code.is_ok(), code as u8);
    }

    println!("\n=== Done! ===");
}

pub fn to_bytes(&self) -> Vec<u8>

Serialize the message to bytes.

Examples found in repository

examples/message_basics.rs (line 49)

fn main() {
    println!("=== SOME/IP Message Basics ===\n");

    // Example 1: Create a request message using the builder
    println!("--- Example 1: Building Messages ---");
    let request = SomeIpMessage::request(ServiceId(0x1234), MethodId(0x0001))
        .client_id(ClientId(0x0100))
        .session_id(SessionId(0x0001))
        .interface_version(2)
        .payload(b"Hello, World!".as_slice())
        .build();

    println!("Request message:");
    print_message(&request);

    // Example 2: Create a response from the request
    println!("\n--- Example 2: Creating Responses ---");
    let response = request
        .create_response()
        .payload(b"Response data".as_slice())
        .build();

    println!("Response message:");
    print_message(&response);

    // Example 3: Create an error response
    println!("\n--- Example 3: Error Response ---");
    let error = request
        .create_error_response(ReturnCode::UnknownMethod)
        .build();

    println!("Error response:");
    print_message(&error);

    // Example 4: Serialize and deserialize
    println!("\n--- Example 4: Serialization ---");
    let bytes = request.to_bytes();
    println!("Serialized to {} bytes", bytes.len());
    println!("Header bytes: {:02X?}", &bytes[..HEADER_SIZE]);
    println!("Payload bytes: {:02X?}", &bytes[HEADER_SIZE..]);

    let parsed = SomeIpMessage::from_bytes(&bytes).expect("Failed to parse");
    println!("\nParsed message matches original: {}", parsed == request);

    // Example 5: Working with headers directly
    println!("\n--- Example 5: Header Details ---");
    let header = SomeIpHeader::new(ServiceId(0xFFFF), MethodId(0x8001));
    println!("Service ID: {}", header.service_id);
    println!("Method ID: {} (is_event: {})", header.method_id, header.method_id.is_event());
    println!("Message ID: 0x{:08X}", header.message_id());
    println!("Request ID: 0x{:08X}", header.request_id());

    // Example 6: Different message types
    println!("\n--- Example 6: Message Types ---");

    let notification = SomeIpMessage::notification(ServiceId(0x1234), MethodId::event(0x0001))
        .payload(b"Event data".as_slice())
        .build();
    println!("Notification: type={:?}, method_id={} (is_event: {})",
        notification.header.message_type,
        notification.header.method_id,
        notification.header.method_id.is_event()
    );

    let fire_and_forget = SomeIpMessage::request_no_return(ServiceId(0x1234), MethodId(0x0002))
        .payload(b"Fire and forget".as_slice())
        .build();
    println!("Fire-and-forget: type={:?}, expects_response: {}",
        fire_and_forget.header.message_type,
        fire_and_forget.expects_response()
    );

    // Example 7: Return codes
    println!("\n--- Example 7: Return Codes ---");
    for code in [
        ReturnCode::Ok,
        ReturnCode::NotOk,
        ReturnCode::UnknownService,
        ReturnCode::UnknownMethod,
        ReturnCode::Timeout,
    ] {
        println!("  {:?}: is_ok={}, value=0x{:02X}", code, code.is_ok(), code as u8);
    }

    println!("\n=== Done! ===");
}

pub fn total_size(&self) -> usize

Get the total message size (header + payload).

pub fn is_request(&self) -> bool

Check if this message is a request.

pub fn is_response(&self) -> bool

Check if this message is a response.

pub fn expects_response(&self) -> bool

Check if this message expects a response.

Examples found in repository

examples/message_basics.rs (line 82)

fn main() {
    println!("=== SOME/IP Message Basics ===\n");

    // Example 1: Create a request message using the builder
    println!("--- Example 1: Building Messages ---");
    let request = SomeIpMessage::request(ServiceId(0x1234), MethodId(0x0001))
        .client_id(ClientId(0x0100))
        .session_id(SessionId(0x0001))
        .interface_version(2)
        .payload(b"Hello, World!".as_slice())
        .build();

    println!("Request message:");
    print_message(&request);

    // Example 2: Create a response from the request
    println!("\n--- Example 2: Creating Responses ---");
    let response = request
        .create_response()
        .payload(b"Response data".as_slice())
        .build();

    println!("Response message:");
    print_message(&response);

    // Example 3: Create an error response
    println!("\n--- Example 3: Error Response ---");
    let error = request
        .create_error_response(ReturnCode::UnknownMethod)
        .build();

    println!("Error response:");
    print_message(&error);

    // Example 4: Serialize and deserialize
    println!("\n--- Example 4: Serialization ---");
    let bytes = request.to_bytes();
    println!("Serialized to {} bytes", bytes.len());
    println!("Header bytes: {:02X?}", &bytes[..HEADER_SIZE]);
    println!("Payload bytes: {:02X?}", &bytes[HEADER_SIZE..]);

    let parsed = SomeIpMessage::from_bytes(&bytes).expect("Failed to parse");
    println!("\nParsed message matches original: {}", parsed == request);

    // Example 5: Working with headers directly
    println!("\n--- Example 5: Header Details ---");
    let header = SomeIpHeader::new(ServiceId(0xFFFF), MethodId(0x8001));
    println!("Service ID: {}", header.service_id);
    println!("Method ID: {} (is_event: {})", header.method_id, header.method_id.is_event());
    println!("Message ID: 0x{:08X}", header.message_id());
    println!("Request ID: 0x{:08X}", header.request_id());

    // Example 6: Different message types
    println!("\n--- Example 6: Message Types ---");

    let notification = SomeIpMessage::notification(ServiceId(0x1234), MethodId::event(0x0001))
        .payload(b"Event data".as_slice())
        .build();
    println!("Notification: type={:?}, method_id={} (is_event: {})",
        notification.header.message_type,
        notification.header.method_id,
        notification.header.method_id.is_event()
    );

    let fire_and_forget = SomeIpMessage::request_no_return(ServiceId(0x1234), MethodId(0x0002))
        .payload(b"Fire and forget".as_slice())
        .build();
    println!("Fire-and-forget: type={:?}, expects_response: {}",
        fire_and_forget.header.message_type,
        fire_and_forget.expects_response()
    );

    // Example 7: Return codes
    println!("\n--- Example 7: Return Codes ---");
    for code in [
        ReturnCode::Ok,
        ReturnCode::NotOk,
        ReturnCode::UnknownService,
        ReturnCode::UnknownMethod,
        ReturnCode::Timeout,
    ] {
        println!("  {:?}: is_ok={}, value=0x{:02X}", code, code.is_ok(), code as u8);
    }

    println!("\n=== Done! ===");
}

pub fn service_id(&self) -> ServiceId

Get the service ID.

pub fn method_id(&self) -> MethodId

Get the method ID.

pub fn client_id(&self) -> ClientId

Get the client ID.

pub fn session_id(&self) -> SessionId

Get the session ID.

pub fn return_code(&self) -> ReturnCode

Get the return code.

pub fn is_ok(&self) -> bool

Check if the return code indicates success.

Trait Implementations

impl Clone for SomeIpMessage

fn clone(&self) -> SomeIpMessage

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SomeIpMessage

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

Formats the value using the given formatter.

impl PartialEq for SomeIpMessage

fn eq(&self, other: &SomeIpMessage) -> 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 Eq for SomeIpMessage

impl StructuralPartialEq for SomeIpMessage