Struct MidWriter

pub struct MidWriter<W, C> { /* private fields */ }

Write side of the Middleware protocol

Implementations

impl<W, C> MidWriter<W, C>

where W: AsyncWriteExt + Unpin, C: ICompressor,

pub async fn write_forward( &mut self, client_id: u16, buffer: &[u8], compression: ForwardCompression, ) -> Result<CompressionStatus>

Write forward packet to the destination socket.

impl<W, C> MidWriter<W, C>

where W: AsyncWriteExt + Unpin,

pub fn write_disconnected( &mut self, id: u16, ) -> impl Future<Output = Result<()>> + '_

Write disconnect packet to the destination socket

pub async fn write_two_bufs( &mut self, before: &[u8], after: &[u8], ) -> Result<bool>

Write two buffers to the socket in vectored mode.

Returns

• Ok(true) if buffer was wrote using efficient implementation (without allocating buffer with size before.len() + after.len())
• Ok(false) if buffer was wrote using the fallback way (allocating buffer with size before.len() + after.len() and copying data to it)

pub fn write_all<'a>( &'a mut self, buf: &'a [u8], ) -> impl Future<Output = Result<()>> + 'a

Writes entire buffer into the socket

pub fn write_u32(&mut self, v: u32) -> impl Future<Output = Result<()>> + '_

Same as MidWriter::write_u32 but writes u32 (little endian)

pub fn write_u16(&mut self, v: u16) -> impl Future<Output = Result<()>> + '_

Same as MidWriter::write_u8 but writes u16 (little endian)

pub fn write_u8(&mut self, v: u8) -> impl Future<Output = Result<()>> + '_

Write u8 to the destination socket (or possibly to buffer)

impl<W, C> MidWriter<BufWriter<W>, C>

where W: AsyncWrite + Unpin,

pub fn flush(&mut self) -> impl Future<Output = Result<()>> + '_

Flush underlying write buffer, so remote side will receive buffered bytes immediately

impl<W, C> MidWriter<BufWriter<W>, C>

where W: AsyncWrite,

pub fn new_buffered(socket: W, compressor: C, buffer_size: usize) -> Self

Create buffered writer.

pub fn unbuffer(self) -> MidWriter<W, C>

Remove bufferization from the writer.

WARNING: it is neccessary to call MidWriter::flush before the unbuffering so you’re sure that previously buffered data was wrote

impl<W, C> MidWriter<W, C>

where W: AsyncWrite,

pub fn make_buffered(self, buffer_size: usize) -> MidWriter<BufWriter<W>, C>

Make writer buffered

impl<W, C> MidWriter<W, C>

pub fn client(&mut self) -> MidClientWriter<'_, W, C>

Create client packets writer. Used mainly to incapsulate client and server packets

pub fn server(&mut self) -> MidServerWriter<'_, W, C>

Same as MidWriter::client but for server packets

pub const fn socket(&self) -> &W

Get shared access to the underlying socket.

pub fn socket_mut(&mut self) -> &mut W

Get exclusive access to the underlying socket.

pub const fn new(socket: W, compressor: C) -> Self

Simply create writer from the underlying socket