Struct nix_compat::wire::de::reader::NixReader

pub struct NixReader<R> {
    inner: R,
    buf: BytesMut,
    reserved_buf_size: usize,
    max_buf_size: usize,
    version: ProtocolVersion,
}

Fields

inner: R

buf: BytesMut

reserved_buf_size: usize

max_buf_size: usize

version: ProtocolVersion

Implementations

impl NixReader<Cursor<Vec<u8>>>

pub fn builder() -> NixReaderBuilder

impl<R> NixReader<R>

where R: AsyncReadExt,

pub fn new(reader: R) -> NixReader<R>

pub fn buffer(&self) -> &[u8]

pub fn remaining_mut(&self) -> usize

Remaining capacity in internal buffer

fn poll_force_fill_buf( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Result<usize>>

impl<R> NixReader<R>

where R: AsyncReadExt + Unpin,

async fn force_fill(&mut self) -> Result<usize>

Trait Implementations

impl<R: AsyncRead> AsyncBufRead for NixReader<R>

fn poll_fill_buf( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Result<&[u8]>>

Attempts to return the contents of the internal buffer, filling it with more data from the inner reader if it is empty.

fn consume(self: Pin<&mut Self>, amt: usize)

Tells this buffer that amt bytes have been consumed from the buffer, so they should no longer be returned in calls to poll_read.

impl<R: AsyncRead> AsyncRead for NixReader<R>

fn poll_read( self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &mut ReadBuf<'_>, ) -> Poll<Result<()>>

Attempts to read from the AsyncRead into buf.

impl<R> NixRead for NixReader<R>

where R: AsyncReadExt + Send + Unpin,

type Error = Error

fn version(&self) -> ProtocolVersion

Some types are serialized differently depending on the version of the protocol and so this can be used for implementing that.

async fn try_read_number(&mut self) -> Result<Option<u64>, Self::Error>

Read a single u64 from the protocol. This returns an Option to support graceful shutdown.

async fn try_read_bytes_limited( &mut self, limit: RangeInclusive<usize>, ) -> Result<Option<Bytes>, Self::Error>

Read bytes from the protocol. A size limit on the returned bytes has to be specified. This returns an Option to support graceful shutdown.

fn try_read_bytes( &mut self, ) -> impl Future<Output = Result<Option<Bytes>, Self::Error>> + Send + '_

Read bytes from the protocol without a limit. The default implementation just calls try_read_bytes_limited with a limit of 0..=usize::MAX but other implementations are free to have a reader wide limit. This returns an Option to support graceful shutdown.

fn read_bytes( &mut self, ) -> impl Future<Output = Result<Bytes, Self::Error>> + Send + '_

Read bytes from the protocol. The default implementation just calls read_bytes_limited with a limit of 0..=usize::MAX but other implementations are free to have a reader wide limit. This will return an error if the bytes could not be read.

fn read_number( &mut self, ) -> impl Future<Output = Result<u64, Self::Error>> + Send + '_

Read a single u64 from the protocol. This will return an error if the number could not be read.

fn read_bytes_limited( &mut self, limit: RangeInclusive<usize>, ) -> impl Future<Output = Result<Bytes, Self::Error>> + Send + '_

Read bytes from the protocol. A size limit on the returned bytes has to be specified. This will return an error if the number could not be read.

fn read_value<V: NixDeserialize>( &mut self, ) -> impl Future<Output = Result<V, Self::Error>> + Send + '_

Read a value from the protocol. Uses NixDeserialize::deserialize to read a value.

fn try_read_value<V: NixDeserialize>( &mut self, ) -> impl Future<Output = Result<Option<V>, Self::Error>> + Send + '_

Read a value from the protocol. Uses NixDeserialize::try_deserialize to read a value. This returns an Option to support graceful shutdown.

impl<'__pin, R> Unpin for NixReader<R>

where __Origin<'__pin, R>: Unpin,