Struct TcpClientHandlerCompress

pub struct TcpClientHandlerCompress<R: AsyncRead + Unpin, W: AsyncWrite + Unpin> { /* private fields */ }

Available on crate features streams and compression only.

The client side TcpHandler of the compress protocol.

Implementations

impl<R: AsyncRead + Unpin, W: AsyncWrite + Unpin> TcpClientHandlerCompress<R, W>

pub async fn new( reader: R, writer: W, identifier: &str, version: &str, ) -> Result<Self, StarterError>

Create and init a new TcpClientHandlerCompress.

pub fn into_inner(self) -> (R, W)

Deconstruct the TcpClientHandlerCompress into the inner parts.

pub fn from_inner(reader: R, writer: W) -> Self

Unsafe!!! Construct the TcpClientHandlerCompress from the inner parts.

pub async fn send<B: Buf>(&mut self, message: &mut B) -> Result<(), PacketError>

Send a message to the server.

pub async fn recv(&mut self) -> Result<BytesMut, PacketError>

Receive a message from the server.

impl TcpClientHandlerCompress<BufReader<OwnedReadHalf>, BufWriter<OwnedWriteHalf>>

pub async fn connect<A: ToSocketAddrs>( addr: A, identifier: &str, version: &str, ) -> Result<Self, StarterError>

Available on crate feature stream_net only.

Connection to addr, and construct the TcpClientHandlerCompress using TcpClientHandlerCompress::new.

impl TcpClientHandlerCompress<BufReader<OwnedReadHalf>, BufWriter<OwnedWriteHalf>>

pub async fn from_stream( stream: TcpStream, identifier: &str, version: &str, ) -> Result<Self, StarterError>

Available on crate feature stream_net only.

Construct the TcpClientHandlerCompress from tokio::net::TcpStream.

Trait Implementations

impl<R: Debug + AsyncRead + Unpin, W: Debug + AsyncWrite + Unpin> Debug for TcpClientHandlerCompress<R, W>

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

Formats the value using the given formatter.

impl<R: AsyncRead + Unpin + Send, W: AsyncWrite + Unpin + Send> TcpHandler for TcpClientHandlerCompress<R, W>

fn handler_send<'life0, 'life1, 'async_trait, B>( &'life0 mut self, message: &'life1 mut B, ) -> Pin<Box<dyn Future<Output = Result<(), PacketError>> + Send + 'async_trait>>

where B: 'async_trait + Buf + Send, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Send a message to the remote.

fn handler_recv<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<BytesMut, PacketError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Receive a message from the remote.

fn handler_send_recv<'life0, 'life1, 'async_trait, B>( &'life0 mut self, message: &'life1 mut B, ) -> Pin<Box<dyn Future<Output = Result<BytesMut, PacketError>> + Send + 'async_trait>>

where B: 'async_trait + Buf + Send, Self: Send + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Send and receive a message.