Crate erpc_rust 

eRPC Rust Implementation

A pure Rust implementation of the eRPC (Embedded RPC) protocol, providing client and server functionality with multiple transport options.

Features

• Transport Layer: TCP, Serial, and in-memory transports
• Codec: Binary protocol with little-endian encoding
• Client/Server: Async client manager and server implementations
• Message Types: Support for invocation, oneway, reply, and notification messages

Example

use erpc_rust::{
    client::ClientManager,
    codec::BasicCodecFactory,
    transport::memory::MemoryTransport,
};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create paired memory transports for testing
    let (client_transport, _server_transport) = MemoryTransport::pair();
    let codec_factory = BasicCodecFactory::new();
    let _client = ClientManager::new(client_transport, codec_factory);
     
    // Use client for RPC calls
    Ok(())
}

Re-exports

pub use auxiliary::MessageInfo;

pub use auxiliary::MessageType;

pub use auxiliary::RequestContext;

pub use client::ClientManager;

pub use codec::BasicCodec;

pub use codec::BasicCodecFactory;

pub use codec::Codec;

pub use error::ErpcError;

pub use error::ErpcResult;

pub use server::MultiTransportServer;

pub use server::MultiTransportServerBuilder;

pub use server::Server;

pub use server::Service;

pub use server::SimpleServer;

pub use transport::FramedTransport;

pub use transport::Transport;

pub use transport::TcpTransport;

pub use transport::SerialTransport;

Modules

auxiliary

Auxiliary types and utilities for eRPC

client

Client implementation for eRPC

codec

Codec implementation for eRPC message serialization/deserialization

error

Error types for the eRPC Rust implementation

server

Server implementation for eRPC

transport

Transport layer abstraction for eRPC