Struct tcp_handler::streams::compress::TcpServerHandlerCompress

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

Available on crate features streams and compression only.

The server side TcpHandler of the compress protocol.

Implementations

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

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

Create and init a new TcpServerHandlerCompress.

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

Deconstruct the TcpServerHandlerCompress into the inner parts.

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

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

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

Send a message to the client.

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

Receive a message from the client.

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

pub fn get_client_version(&self) -> &str

Get the client’s application version.

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

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

Available on crate feature stream_net only.

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

Trait Implementations

impl<R: Debug + AsyncRead + Unpin, W: Debug + AsyncWrite + Unpin> Debug for TcpServerHandlerCompress<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 TcpServerHandlerCompress<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.