Struct AsyncIgtlClient 

pub struct AsyncIgtlClient { /* private fields */ }

👎Deprecated since 0.2.0: Use ClientBuilder instead: ClientBuilder::new().tcp(addr).async_mode().build().await

Asynchronous OpenIGTLink client

Uses non-blocking I/O with Tokio for high-concurrency scenarios.

Examples

use openigtlink_rust::io::AsyncIgtlClient;
use openigtlink_rust::protocol::types::StatusMessage;
use openigtlink_rust::protocol::message::IgtlMessage;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut client = AsyncIgtlClient::connect("127.0.0.1:18944").await?;

    let status = StatusMessage::ok("Hello");
    let msg = IgtlMessage::new(status, "AsyncClient")?;
    client.send(&msg).await?;

    Ok(())
}

Implementations

impl AsyncIgtlClient

pub async fn connect(addr: &str) -> Result<Self>

Connect to an OpenIGTLink server asynchronously

Arguments

• addr - Server address (e.g., “127.0.0.1:18944”)

Errors

• IgtlError::Io - Failed to connect

Examples

use openigtlink_rust::io::AsyncIgtlClient;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = AsyncIgtlClient::connect("127.0.0.1:18944").await?;
    Ok(())
}

pub fn set_verify_crc(&mut self, verify: bool)

Enable or disable CRC verification for received messages

Arguments

• verify - true to enable CRC verification (default), false to disable

Safety

Disabling CRC verification should only be done in trusted environments where data corruption is unlikely (e.g., loopback, local network).

pub fn verify_crc(&self) -> bool

Get current CRC verification setting

pub async fn send<T: Message>(&mut self, msg: &IgtlMessage<T>) -> Result<()>

Send a message to the server asynchronously

Arguments

• msg - Message to send

Errors

• IgtlError::Io - Network write failed
• IgtlError::BodyTooLarge - Message exceeds maximum size

Examples

use openigtlink_rust::io::AsyncIgtlClient;
use openigtlink_rust::protocol::types::StatusMessage;
use openigtlink_rust::protocol::message::IgtlMessage;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut client = AsyncIgtlClient::connect("127.0.0.1:18944").await?;

    let status = StatusMessage::ok("Ready");
    let msg = IgtlMessage::new(status, "Client")?;
    client.send(&msg).await?;

    Ok(())
}

pub async fn receive<T: Message>(&mut self) -> Result<IgtlMessage<T>>

Receive a message from the server asynchronously

Errors

• IgtlError::Io - Network read failed
• IgtlError::InvalidHeader - Received malformed header
• IgtlError::CrcMismatch - Data corruption detected
• IgtlError::UnknownMessageType - Unsupported message type

Examples

use openigtlink_rust::io::AsyncIgtlClient;
use openigtlink_rust::protocol::types::TransformMessage;
use openigtlink_rust::protocol::message::IgtlMessage;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut client = AsyncIgtlClient::connect("127.0.0.1:18944").await?;
    let msg: IgtlMessage<TransformMessage> = client.receive().await?;
    Ok(())
}

pub async fn set_read_timeout( &mut self, timeout: Option<Duration>, ) -> Result<()>

Set read timeout for the underlying TCP stream

pub async fn set_write_timeout( &mut self, timeout: Option<Duration>, ) -> Result<()>

Set write timeout for the underlying TCP stream

pub async fn set_nodelay(&self, nodelay: bool) -> Result<()>

Enable or disable TCP_NODELAY (Nagle’s algorithm)

pub async fn nodelay(&self) -> Result<bool>

Get the current TCP_NODELAY setting

pub fn local_addr(&self) -> Result<SocketAddr>

Get the local address

pub fn peer_addr(&self) -> Result<SocketAddr>

Get the remote peer address

pub fn into_split(self) -> (AsyncIgtlReader, AsyncIgtlWriter)

Split the client into read and write halves

This allows concurrent reading and writing on separate tasks.

Examples

use openigtlink_rust::io::AsyncIgtlClient;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = AsyncIgtlClient::connect("127.0.0.1:18944").await?;
    let (reader, writer) = client.into_split();

    // Use reader and writer in separate tasks
    Ok(())
}