Trait BitReaderExt 

pub trait BitReaderExt<'de>: BitReader<'de> {
    // Provided methods
    fn is_empty(&self) -> bool { ... }
    fn read_bytes_into(
        &mut self,
        dst: impl AsMut<[u8]>,
    ) -> Result<usize, Self::Error> { ... }
    fn read_bytes_array<const N: usize>(
        &mut self,
    ) -> Result<[u8; N], Self::Error> { ... }
    fn unpack<T>(
        &mut self,
        args: <T as BitUnpack<'de>>::Args,
    ) -> Result<T, Self::Error>
       where T: BitUnpack<'de> { ... }
    fn unpack_iter<'a, T>(
        &'a mut self,
        args: <T as BitUnpack<'de>>::Args,
    ) -> impl Iterator<Item = Result<T, Self::Error>> + 'a
       where T: BitUnpack<'de>,
             <T as BitUnpack<'de>>::Args: Clone + 'a { ... }
    fn unpack_as<T, As>(
        &mut self,
        args: <As as BitUnpackAs<'de, T>>::Args,
    ) -> Result<T, Self::Error>
       where As: BitUnpackAs<'de, T> + ?Sized { ... }
    fn unpack_iter_as<'a, T, As>(
        &'a mut self,
        args: <As as BitUnpackAs<'de, T>>::Args,
    ) -> impl Iterator<Item = Result<T, Self::Error>> + 'a
       where As: BitUnpackAs<'de, T> + ?Sized,
             <As as BitUnpackAs<'de, T>>::Args: Clone + 'a { ... }
    fn as_mut(&mut self) -> &mut Self { ... }
    fn map_err<F>(self, f: F) -> MapErr<Self, F>
       where Self: Sized { ... }
    fn tee<W>(self, writer: W) -> Tee<Self, W>
       where Self: Sized,
             W: BitWriter { ... }
    fn checkpoint(self) -> Checkpoint<Self>
       where Self: Sized { ... }
    fn join<R>(self, next: R) -> Join<Self, R>
       where Self: Sized,
             R: BitReader<'de> { ... }
}

Extension helper for BitReader.

Provided Methods

fn is_empty(&self) -> bool

Returns wheather the reader is empty

fn read_bytes_into( &mut self, dst: impl AsMut<[u8]>, ) -> Result<usize, Self::Error>

Reads dst.len() bytes into given byte slice

fn read_bytes_array<const N: usize>(&mut self) -> Result<[u8; N], Self::Error>

Read N bytes and return array

fn unpack<T>( &mut self, args: <T as BitUnpack<'de>>::Args, ) -> Result<T, Self::Error>

where T: BitUnpack<'de>,

Unpack value witg args using its BitUnpack implementation

fn unpack_iter<'a, T>( &'a mut self, args: <T as BitUnpack<'de>>::Args, ) -> impl Iterator<Item = Result<T, Self::Error>> + 'a

where T: BitUnpack<'de>, <T as BitUnpack<'de>>::Args: Clone + 'a,

Return iterator that unpacks values with args using BitUnpack implementation

fn unpack_as<T, As>( &mut self, args: <As as BitUnpackAs<'de, T>>::Args, ) -> Result<T, Self::Error>

where As: BitUnpackAs<'de, T> + ?Sized,

Unpack value with args using an adapter.

This approach is heavily inspired by serde_with. Please, read their docs for more usage examples.

fn unpack_iter_as<'a, T, As>( &'a mut self, args: <As as BitUnpackAs<'de, T>>::Args, ) -> impl Iterator<Item = Result<T, Self::Error>> + 'a

where As: BitUnpackAs<'de, T> + ?Sized, <As as BitUnpackAs<'de, T>>::Args: Clone + 'a,

Returns iterator that unpacks values with args using an adapter.

This approach is heavily inspired by serde_with. Please, read their docs for more usage examples.

fn as_mut(&mut self) -> &mut Self

Borrows reader, rather than consuming it.

fn map_err<F>(self, f: F) -> MapErr<Self, F>

where Self: Sized,

Map Error by given closure

fn tee<W>(self, writer: W) -> Tee<Self, W>

where Self: Sized, W: BitWriter,

Mirror all read data to given writer as well.

fn checkpoint(self) -> Checkpoint<Self>

where Self: Sized,

fn join<R>(self, next: R) -> Join<Self, R>

where Self: Sized, R: BitReader<'de>,

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors

impl<'de, T> BitReaderExt<'de> for T

where T: BitReader<'de> + ?Sized,