Struct AsyncIgtlConnection 

pub struct AsyncIgtlConnection { /* private fields */ }

Represents an accepted client connection (async)

Provides methods to send and receive OpenIGTLink messages asynchronously.

Implementations

impl AsyncIgtlConnection

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 connected client asynchronously

Arguments

• msg - Message to send

Errors

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

Examples

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

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let server = AsyncIgtlServer::bind("127.0.0.1:18944").await?;
    let mut conn = server.accept().await?;

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

    Ok(())
}

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

Receive a message from the connected client 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::AsyncIgtlServer;
use openigtlink_rust::protocol::types::TransformMessage;
use openigtlink_rust::protocol::message::IgtlMessage;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let server = AsyncIgtlServer::bind("127.0.0.1:18944").await?;
    let mut conn = server.accept().await?;

    let msg: IgtlMessage<TransformMessage> = conn.receive().await?;
    Ok(())
}

pub async fn receive_any(&mut self) -> Result<AnyMessage>

Receive any message type dynamically (async)

This method receives a message without knowing its type in advance, returning it as an AnyMessage enum that can be pattern matched.

Errors

• IgtlError::Io - Network read failed
• IgtlError::InvalidHeader - Malformed header
• IgtlError::CrcMismatch - Data corruption detected

Examples

use openigtlink_rust::io::AsyncIgtlServer;
use openigtlink_rust::protocol::AnyMessage;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let server = AsyncIgtlServer::bind("127.0.0.1:18944").await?;
    let mut conn = server.accept().await?;

    let msg = conn.receive_any().await?;
    match msg {
        AnyMessage::Transform(_) => println!("Received transform"),
        AnyMessage::Status(_) => println!("Received status"),
        _ => println!("Received other message"),
    }

    Ok(())
}

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 peer_addr(&self) -> Result<SocketAddr>

Get the remote peer address

pub fn into_split( self, ) -> (AsyncIgtlConnectionReader, AsyncIgtlConnectionWriter)

Split the connection into read and write halves

This allows concurrent reading and writing on separate tasks.