Struct distant_net::Client

pub struct Client<T, U> where
    T: Send + Sync + Serialize + 'static,
    U: Send + Sync + DeserializeOwned + 'static, { /* private fields */ }

Represents a client that can be used to send requests & receive responses from a server

Implementations

impl<T, U> Client<T, U> where
    T: Send + Sync + Serialize,
    U: Send + Sync + DeserializeOwned, 

pub fn new<R, W>(writer: W, reader: R) -> Result<Self> where
    R: TypedAsyncRead<Response<U>> + Send + 'static,
    W: TypedAsyncWrite<Request<T>> + Send + 'static, 

Initializes a client using the provided reader and writer

pub fn from_framed_transport<TR, C>(
    transport: FramedTransport<TR, C>
) -> Result<Self> where
    TR: RawTransport + IntoSplit + 'static,
    <TR as IntoSplit>::Read: RawTransportRead,
    <TR as IntoSplit>::Write: RawTransportWrite,
    C: Codec + Send + 'static, 

Initializes a client using the provided framed transport

pub fn into_channel(self) -> Channel<T, U>

Convert into underlying channel

pub fn clone_channel(&self) -> Channel<T, U>

Clones the underlying channel for requests and returns the cloned instance

pub async fn wait(self) -> Result<(), JoinError>

Waits for the client to terminate, which results when the receiving end of the network connection is closed (or the client is shutdown)

pub fn abort(&self)

Abort the client’s current connection by forcing its tasks to abort

pub fn is_finished(&self) -> bool

Returns true if client’s underlying event processing has finished/terminated

Methods from Deref<Target = Channel<T, U>>

pub fn is_closed(&self) -> bool

Returns true if no more requests can be transferred

pub async fn mail(
    &mut self,
    req: impl Into<Request<T>>
) -> Result<Mailbox<Response<U>>>

Sends a request and returns a mailbox that can receive one or more responses, failing if unable to send a request or if the session’s receiving line to the remote server has already been severed

pub async fn mail_timeout(
    &mut self,
    req: impl Into<Request<T>>,
    duration: impl Into<Option<Duration>>
) -> Result<Mailbox<Response<U>>>

Sends a request and returns a mailbox, timing out after duration has passed

pub async fn send(&mut self, req: impl Into<Request<T>>) -> Result<Response<U>>

Sends a request and waits for a response, failing if unable to send a request or if the session’s receiving line to the remote server has already been severed

pub async fn send_timeout(
    &mut self,
    req: impl Into<Request<T>>,
    duration: impl Into<Option<Duration>>
) -> Result<Response<U>>

Sends a request and waits for a response, timing out after duration has passed

pub async fn fire(&mut self, req: impl Into<Request<T>>) -> Result<()>

Sends a request without waiting for a response; this method is able to be used even if the session’s receiving line to the remote server has been severed

pub async fn fire_timeout(
    &mut self,
    req: impl Into<Request<T>>,
    duration: impl Into<Option<Duration>>
) -> Result<()>

Sends a request without waiting for a response, timing out after duration has passed

Trait Implementations

impl<T, U> Deref for Client<T, U> where
    T: Send + Sync + Serialize + 'static,
    U: Send + Sync + DeserializeOwned + 'static, 

type Target = Channel<T, U>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T, U> DerefMut for Client<T, U> where
    T: Send + Sync + Serialize + 'static,
    U: Send + Sync + DeserializeOwned + 'static, 

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl From<Client<Auth, Auth>> for AuthClient

fn from(client: Client<Auth, Auth>) -> Self

Converts to this type from the input type.

impl<T, U> From<Client<T, U>> for Channel<T, U> where
    T: Send + Sync + Serialize + 'static,
    U: Send + Sync + DeserializeOwned + 'static, 

fn from(client: Client<T, U>) -> Self

Converts to this type from the input type.

impl<T, U> TcpClientExt<T, U> for Client<T, U> where
    T: Send + Sync + Serialize + 'static,
    U: Send + Sync + DeserializeOwned + 'static, 

fn connect<'async_trait, C>(
    addr: SocketAddr,
    codec: C
) -> Pin<Box<dyn Future<Output = Result<Client<T, U>>> + Send + 'async_trait>> where
    C: Codec + Send + 'static,
    C: 'async_trait,
    Self: 'async_trait, 

Connect to a remote TCP server using the provided information

fn connect_timeout<'async_trait, C>(
    addr: SocketAddr,
    codec: C,
    duration: Duration
) -> Pin<Box<dyn Future<Output = Result<Client<T, U>>> + Send + 'async_trait>> where
    C: Codec + Send + 'static,
    C: 'async_trait,
    Self: Send + 'async_trait, 

Connect to a remote TCP server, timing out after duration has passed

impl<T, U> UnixSocketClientExt<T, U> for Client<T, U> where
    T: Send + Sync + Serialize + 'static,
    U: Send + Sync + DeserializeOwned + 'static, 

fn connect<'async_trait, P, C>(
    path: P,
    codec: C
) -> Pin<Box<dyn Future<Output = Result<Client<T, U>>> + Send + 'async_trait>> where
    P: AsRef<Path> + Send,
    C: Codec + Send + 'static,
    P: 'async_trait,
    C: 'async_trait, 

Connect to a proxy unix socket

fn connect_timeout<'async_trait, P, C>(
    path: P,
    codec: C,
    duration: Duration
) -> Pin<Box<dyn Future<Output = Result<Client<T, U>>> + Send + 'async_trait>> where
    P: AsRef<Path> + Send,
    C: Codec + Send + 'static,
    P: 'async_trait,
    C: 'async_trait,
    Self: Send + 'async_trait, 

Connect to a proxy unix socket, timing out after duration has passed