[−][src]Trait libp2prs_traits::ReadEx

pub trait ReadEx: Send {
#[must_use]    pub fn read2<'life0, 'life1, 'async_trait>(
        &'life0 mut self, 
        buf: &'life1 mut [u8]
    ) -> Pin<Box<dyn Future<Output = Result<usize, Error>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        'life1: 'async_trait,
        Self: 'async_trait;

#[must_use]    pub fn read_exact2<'a, 'async_trait>(
        &'a mut self, 
        buf: &'a mut [u8]
    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>
    where
        'a: 'async_trait,
        Self: 'async_trait,
    { ... }

#[must_use]    pub fn read_fixed_u32<'life0, 'async_trait>(
        &'life0 mut self
    ) -> Pin<Box<dyn Future<Output = Result<usize, Error>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: 'async_trait,
    { ... }

#[must_use]    pub fn read_varint<'life0, 'async_trait>(
        &'life0 mut self
    ) -> Pin<Box<dyn Future<Output = Result<usize, Error>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: 'async_trait,
    { ... }

#[must_use]    pub fn read_one_fixed<'life0, 'async_trait>(
        &'life0 mut self, 
        max_size: usize
    ) -> Pin<Box<dyn Future<Output = Result<Vec<u8>, Error>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: 'async_trait,
    { ... }

#[must_use]    pub fn read_one<'life0, 'async_trait>(
        &'life0 mut self, 
        max_size: usize
    ) -> Pin<Box<dyn Future<Output = Result<Vec<u8>, Error>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: 'async_trait,
    { ... }
}

Read Trait for async/await

Required methods

#[must_use]pub fn read2<'life0, 'life1, 'async_trait>(
    &'life0 mut self,
    buf: &'life1 mut [u8]
) -> Pin<Box<dyn Future<Output = Result<usize, Error>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, [src]

Reads some bytes from the byte stream.

On success, returns the total number of bytes read.

If the return value is Ok(n), then it must be guaranteed that 0 <= n <= buf.len(). A nonzero n value indicates that the buffer has been filled with n bytes of data. If n is 0, then it can indicate one of two scenarios:

  1. This reader has reached its "end of file" and will likely no longer be able to produce bytes. Note that this does not mean that the reader will always no longer be able to produce bytes.
  2. The buffer specified was 0 bytes in length.

Attempt to read bytes from underlying stream object.

On success, returns Ok(n). Otherwise, returns Err(io:Error)

Loading content...

Provided methods

#[must_use]pub fn read_exact2<'a, 'async_trait>(
    &'a mut self,
    buf: &'a mut [u8]
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>> where
    'a: 'async_trait,
    Self: 'async_trait, [src]

Reads the exact number of bytes requested.

On success, returns Ok(()). Otherwise, returns Err(io:Error).

#[must_use]pub fn read_fixed_u32<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<usize, Error>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, [src]

Reads a fixed-length integer from the underlying IO.

On success, return Ok(n). Otherwise, returns Err(io:Error).

#[must_use]pub fn read_varint<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<usize, Error>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, [src]

Reads a variable-length integer from the underlying IO.

As a special exception, if the IO is empty and EOFs right at the beginning, then we return Ok(0).

On success, return Ok(n). Otherwise, returns Err(io:Error).

Note: This function reads bytes one by one from the underlying IO. It is therefore encouraged to use some sort of buffering mechanism.

#[must_use]pub fn read_one_fixed<'life0, 'async_trait>(
    &'life0 mut self,
    max_size: usize
) -> Pin<Box<dyn Future<Output = Result<Vec<u8>, Error>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, [src]

Reads a fixed length-prefixed message from the underlying IO.

The max_size parameter is the maximum size in bytes of the message that we accept. This is necessary in order to avoid DoS attacks where the remote sends us a message of several gigabytes.

Note: Assumes that a fixed-length prefix indicates the length of the message. This is compatible with what write_one_fixed does.

#[must_use]pub fn read_one<'life0, 'async_trait>(
    &'life0 mut self,
    max_size: usize
) -> Pin<Box<dyn Future<Output = Result<Vec<u8>, Error>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, [src]

Reads a variable length-prefixed message from the underlying IO.

The max_size parameter is the maximum size in bytes of the message that we accept. This is necessary in order to avoid DoS attacks where the remote sends us a message of several gigabytes.

On success, returns Ok(Vec<u8>). Otherwise, returns Err(io:Error).

Note: Assumes that a variable-length prefix indicates the length of the message. This is compatible with what write_one does.

Loading content...

Implementors

impl<T: AsyncRead + Unpin + Send> ReadEx for T[src]

Loading content...