Struct Connection

pub struct Connection<S: Socket> { /* private fields */ }

A connection.

The low-level API to send and receive messages.

Each connection gets a unique identifier when created that can be queried using Connection::id. This ID is shared betwen the read and write halves of the connection. It can be used to associate the read and write halves of the same connection.

Cancel safety

All async methods of this type are cancel safe unless explicitly stated otherwise in its documentation.

Implementations

impl<S> Connection<S>

where S: Socket,

pub fn new(socket: S) -> Self

Create a new connection.

pub fn read(&self) -> &ReadConnection<S::ReadHalf>

The reference to the read half of the connection.

pub fn read_mut(&mut self) -> &mut ReadConnection<S::ReadHalf>

The mutable reference to the read half of the connection.

pub fn write(&self) -> &WriteConnection<S::WriteHalf>

The reference to the write half of the connection.

pub fn write_mut(&mut self) -> &mut WriteConnection<S::WriteHalf>

The mutable reference to the write half of the connection.

pub fn split( self, ) -> (ReadConnection<S::ReadHalf>, WriteConnection<S::WriteHalf>)

Split the connection into read and write halves.

pub fn join( read: ReadConnection<S::ReadHalf>, write: WriteConnection<S::WriteHalf>, ) -> Self

Join the read and write halves into a connection (the opposite of Connection::split).

pub fn id(&self) -> usize

The unique identifier of the connection.

pub async fn send_call<Method>(&mut self, call: &Call<Method>) -> Result<()>

where Method: Serialize + Debug,

Sends a method call.

Convenience wrapper around WriteConnection::send_call.

pub async fn receive_reply<'r, Params, ReplyError>( &'r mut self, ) -> Result<Result<Reply<Params>, ReplyError>>

where Params: Deserialize<'r> + Debug, ReplyError: Deserialize<'r> + Debug,

Receives a method call reply.

Convenience wrapper around ReadConnection::receive_reply.

pub async fn call_method<'r, Method, ReplyError, Params>( &'r mut self, call: &Call<Method>, ) -> Result<Result<Reply<Params>, ReplyError>>

where Method: Serialize + Debug, Params: Deserialize<'r> + Debug, ReplyError: Deserialize<'r> + Debug,

Call a method and receive a reply.

This is a convenience method that combines Connection::send_call and Connection::receive_reply.

pub async fn receive_call<'m, Method>(&'m mut self) -> Result<Call<Method>>

where Method: Deserialize<'m> + Debug,

Receive a method call over the socket.

Convenience wrapper around ReadConnection::receive_call.

pub async fn send_reply<Params>(&mut self, reply: &Reply<Params>) -> Result<()>

where Params: Serialize + Debug,

Send a reply over the socket.

Convenience wrapper around WriteConnection::send_reply.

pub async fn send_error<ReplyError>(&mut self, error: &ReplyError) -> Result<()>

where ReplyError: Serialize + Debug,

Send an error reply over the socket.

Convenience wrapper around WriteConnection::send_error.

Trait Implementations

impl<S: Debug + Socket> Debug for Connection<S>

where S::ReadHalf: Debug, S::WriteHalf: Debug,

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

Formats the value using the given formatter.

impl<S> From<S> for Connection<S>

where S: Socket,

fn from(socket: S) -> Self

Converts to this type from the input type.