Struct MidReader

pub struct MidReader<R, D> { /* private fields */ }

Implementations

impl<R, D> MidReader<R, D>

where R: AsyncReadExt + Unpin, D: IDecompressor,

pub async fn read_compressed( &mut self, size: usize, strategy: DecompressionStrategy, ) -> Result<Vec<u8>, CompressedReadError>

Reads compressed pile of bytes from the stream

impl<R, D> MidReader<R, D>

where R: AsyncReadExt + Unpin,

pub async fn skip_n_bytes(&mut self, nbytes: usize) -> Result<()>

Skips nbytes bytes from the underlying stream.

pub async fn read_raw_packet_type(&mut self) -> Result<(u8, u8)>

Reads packet type and decodes it returning pair of u8’s

pub async fn read_string_prefixed(&mut self) -> Result<String>

Reads string of prefixed size with max size of u8::MAX, uses lossy utf8 decoding.

pub async fn read_string(&mut self, bytes_size: usize) -> Result<String>

Reads string of size bytes_size with lossy utf8 decoding.

pub async fn read_bytes_prefixed(&mut self) -> Result<Vec<u8>>

Reads prefixed buffer with max size of u8::MAX.

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

Read u8 from the underlying stream

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

Read u16 from the underlying stream (little endian)

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

Read u32 from the underlying stream (little endian)

pub async fn read_buffer(&mut self, size: usize) -> Result<Vec<u8>>

Read size bytes from the socket without buffer pre-filling.

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

Reads variadic length of payload from the stream

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

Reads variadic client id from the stream

pub async fn read_variadic( &mut self, current_flags: u8, needed: u8, ) -> Result<u16>

Reads u8 or u16 from the stream, depending on flags.

impl<R, D> MidReader<R, D>

where R: AsyncRead,

pub fn make_buffered( self, buffer_size: usize, decompressor: D, ) -> MidReader<BufReader<R>, D>

Create buffered reader (wraps R with BufReader<R> with specified capacity)

impl<R, D> MidReader<BufReader<R>, D>

where R: AsyncRead,

pub fn new_buffered(socket: R, decompressor: D, buffer_size: usize) -> Self

Create buffered version of the reader

pub fn unbuffer(self) -> MidReader<R, D>

Remove underlying buffer.

WARNING: buffered data can be lost!

impl<R, D> MidReader<R, D>

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

Get shared access to the underlying socket

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

Get exclusive access to the underlying socket

pub const fn new(socket: R, decompressor: D) -> Self

Simply create reader from the underlying socket type