Struct UnifiedAsyncClient 

pub struct UnifiedAsyncClient { /* private fields */ }

Unified async OpenIGTLink client

Supports optional TLS encryption and automatic reconnection without combinatorial type explosion.

Examples

use openigtlink_rust::io::unified_async_client::UnifiedAsyncClient;

// Plain TCP client
let client = UnifiedAsyncClient::connect("127.0.0.1:18944").await?;

// With TLS
let tls_config = rustls::ClientConfig::builder()
    .with_root_certificates(rustls::RootCertStore::empty())
    .with_no_client_auth();
let client = UnifiedAsyncClient::connect_with_tls(
    "localhost",
    18944,
    std::sync::Arc::new(tls_config)
).await?;

Implementations

impl UnifiedAsyncClient

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

Connect to a plain TCP server

Arguments

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

pub async fn connect_with_tls( hostname: &str, port: u16, tls_config: Arc<ClientConfig>, ) -> Result<Self>

Connect to a TLS-enabled server

Arguments

• hostname - Server hostname (for SNI)
• port - Server port
• tls_config - TLS client configuration

pub fn with_reconnect(self, config: ReconnectConfig) -> Self

Enable automatic reconnection

Arguments

• config - Reconnection configuration

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

Enable or disable CRC verification

pub fn verify_crc(&self) -> bool

Get current CRC verification setting

pub fn reconnect_count(&self) -> usize

Get reconnection count

pub fn is_connected(&self) -> bool

Check if currently connected

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

Send a message

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

Receive a message

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

Receive any message type dynamically without knowing the type in advance

This method reads the message header first, determines the message type, and then decodes the appropriate message type dynamically.

Returns

An AnyMessage enum containing the decoded message. If the message type is not recognized, it will be returned as AnyMessage::Unknown with the raw header and body bytes.

Examples

use openigtlink_rust::io::builder::ClientBuilder;
use openigtlink_rust::protocol::AnyMessage;

let mut client = ClientBuilder::new()
    .tcp("127.0.0.1:18944")
    .async_mode()
    .build()
    .await?;

loop {
    let msg = client.receive_any().await?;

    match msg {
        AnyMessage::Transform(transform_msg) => {
            println!("Received transform from {}",
                     transform_msg.header.device_name.as_str()?);
        }
        AnyMessage::Status(status_msg) => {
            println!("Status: {}", status_msg.content.status_string);
        }
        AnyMessage::Image(image_msg) => {
            println!("Received image: {}x{}x{}",
                     image_msg.content.size[0],
                     image_msg.content.size[1],
                     image_msg.content.size[2]);
        }
        AnyMessage::Unknown { header, .. } => {
            println!("Unknown message type: {}",
                     header.type_name.as_str()?);
        }
        _ => {}
    }
}