Struct WireframeClient 

pub struct WireframeClient<S = BincodeSerializer, T = TcpStream>
where
    T: ClientStream,
{ /* private fields */ }

Client runtime for wireframe connections.

Examples

use std::net::SocketAddr;

use wireframe::WireframeClient;

let addr: SocketAddr = "127.0.0.1:9000".parse().expect("valid socket address");
let _client = WireframeClient::builder().connect(addr).await?;

Implementations

impl WireframeClient<BincodeSerializer, TcpStream>

pub fn builder() -> WireframeClientBuilder<BincodeSerializer, ()>

Start building a new client with the default serializer and codec.

Examples

use std::net::SocketAddr;

use wireframe::WireframeClient;

let addr: SocketAddr = "127.0.0.1:9000".parse().expect("valid socket address");
let _client = WireframeClient::builder().connect(addr).await?;

impl<S, T> WireframeClient<S, T>

where S: Serializer + Send + Sync, T: ClientStream,

pub async fn send<M: Message>(&mut self, message: &M) -> Result<(), ClientError>

Send a message to the peer using the configured serializer.

Errors

Returns ClientError if serialization or I/O fails.

Examples

use std::net::SocketAddr;

use wireframe::{ClientError, WireframeClient};

#[derive(bincode::Encode, bincode::BorrowDecode)]
struct Ping(u8);

let addr: SocketAddr = "127.0.0.1:9000".parse().expect("valid socket address");
let mut client = WireframeClient::builder().connect(addr).await?;
client.send(&Ping(1)).await?;

pub async fn receive<M: Message>(&mut self) -> Result<M, ClientError>

Receive the next message from the peer.

Errors

Returns ClientError if the connection closes, decoding fails, or I/O errors occur.

Examples

use std::net::SocketAddr;

use wireframe::{ClientError, WireframeClient};

#[derive(bincode::Encode, bincode::BorrowDecode, Debug, PartialEq)]
struct Pong(u8);

let addr: SocketAddr = "127.0.0.1:9000".parse().expect("valid socket address");
let mut client = WireframeClient::builder().connect(addr).await?;
let _pong: Pong = client.receive().await?;

pub async fn call<Req: Message, Resp: Message>( &mut self, request: &Req, ) -> Result<Resp, ClientError>

Send a message and await the next response.

Errors

Returns ClientError if the request cannot be sent or the response cannot be decoded.

Examples

use std::net::SocketAddr;

use wireframe::{ClientError, WireframeClient};

#[derive(bincode::Encode, bincode::BorrowDecode)]
struct Login {
    username: String,
}

#[derive(bincode::Encode, bincode::BorrowDecode, Debug, PartialEq)]
struct LoginAck {
    ok: bool,
}

let addr: SocketAddr = "127.0.0.1:9000".parse().expect("valid socket address");
let mut client = WireframeClient::builder().connect(addr).await?;
let login = Login {
    username: "guest".to_string(),
};
let _ack: LoginAck = client.call(&login).await?;

pub const fn codec_config(&self) -> &ClientCodecConfig

Inspect the configured codec settings.

Examples

use std::net::SocketAddr;

use wireframe::{ClientError, WireframeClient};

let addr: SocketAddr = "127.0.0.1:9000".parse().expect("valid socket address");
let client = WireframeClient::builder().connect(addr).await?;
let codec = client.codec_config();
assert_eq!(codec.max_frame_length_value(), 1024);

pub fn stream(&self) -> &T

Access the underlying stream.

Examples

use std::net::SocketAddr;

use wireframe::{ClientError, WireframeClient};

let addr: SocketAddr = "127.0.0.1:9000".parse().expect("valid socket address");
let client = WireframeClient::builder().connect(addr).await?;
let _stream = client.stream();

impl<S> WireframeClient<S, RewindStream<TcpStream>>

where S: Serializer + Send + Sync,

pub fn tcp_stream(&self) -> &TcpStream

Access the underlying TcpStream.

Examples

use std::net::SocketAddr;

use wireframe::{ClientError, WireframeClient};

let addr: SocketAddr = "127.0.0.1:9000".parse().expect("valid socket address");
let client = WireframeClient::builder().connect(addr).await?;
let _stream = client.tcp_stream();

pub fn rewind_stream(&self) -> &RewindStream<TcpStream>

Access the rewind stream wrapper.

This provides access to the RewindStream that wraps the TCP stream, which may contain leftover bytes from preamble exchange.

Trait Implementations

impl<S, T> Debug for WireframeClient<S, T>

where T: ClientStream,

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

Formats the value using the given formatter.