Struct MessageBuilder 

pub struct MessageBuilder { /* private fields */ }

Builder for constructing SOME/IP messages.

Implementations

impl MessageBuilder

pub fn new( service_id: ServiceId, method_id: MethodId, message_type: MessageType, ) -> Self

Create a new message builder.

pub fn client_id(self, client_id: ClientId) -> Self

Set the client ID.

Examples found in repository

examples/message_basics.rs (line 19)

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 session_id(self, session_id: SessionId) -> Self

Set the session ID.

Examples found in repository

examples/message_basics.rs (line 20)

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 interface_version(self, version: u8) -> Self

Set the interface version.

Examples found in repository

examples/message_basics.rs (line 21)

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 return_code(self, code: ReturnCode) -> Self

Set the return code.

pub fn payload(self, payload: impl Into<Bytes>) -> Self

Set the payload from bytes.

Examples found in repository

examples/udp_client.rs (line 29)

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 30)

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/tcp_server.rs (line 56)

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 22)

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 payload_vec(self, payload: Vec<u8>) -> Self

Set the payload from a Vec.

pub fn build(self) -> SomeIpMessage

Build the message.

Examples found in repository

examples/udp_client.rs (line 30)

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 31)

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/tcp_server.rs (line 46)

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 23)

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! ===");
}

Trait Implementations

impl Clone for MessageBuilder

fn clone(&self) -> MessageBuilder

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MessageBuilder

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

Formats the value using the given formatter.