Struct ByteReader 

pub struct ByteReader<R, E>
where
    R: Read,
    E: Endianness,
{ /* private fields */ }

For reading aligned bytes from a stream of bytes in a given endianness.

This only reads aligned values and maintains no internal state.

Implementations

impl<R, E> ByteReader<R, E>

where R: Read, E: Endianness,

pub fn new(reader: R) -> ByteReader<R, E>

Wraps a ByteReader around something that implements Read

pub fn endian(reader: R, _endian: E) -> ByteReader<R, E>

Wraps a ByteReader around something that implements Read with the given endianness.

pub fn into_reader(self) -> R

Unwraps internal reader and disposes of ByteReader.

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

Provides mutable reference to internal reader

pub fn into_bitreader(self) -> BitReader<R, E>

Converts ByteReader to BitReader in the same endianness.

pub fn bitreader(&mut self) -> BitReader<&mut R, E>

Provides temporary BitReader in the same endianness.

Warning

Any unread bits left over when BitReader is dropped are lost.

Trait Implementations

impl<R, E> ByteRead for ByteReader<R, E>

where R: Read, E: Endianness,

fn read<V>(&mut self) -> Result<V, Error>

where V: Primitive,

Reads whole numeric value from stream

fn read_as<F, V>(&mut self) -> Result<V, Error>

where F: Endianness, V: Primitive,

Reads whole numeric value from stream in a potentially different endianness

fn read_bytes(&mut self, buf: &mut [u8]) -> Result<(), Error>

Completely fills the given buffer with whole bytes.

fn skip(&mut self, bytes: u32) -> Result<(), Error>

Skips the given number of bytes in the stream.

fn reader_ref(&mut self) -> &mut dyn Read

Returns mutable reference to underlying reader

fn read_to_bytes<const SIZE: usize>(&mut self) -> Result<[u8; SIZE], Error>

👎Deprecated since 1.8.0:

use read() method instead

Completely fills a whole buffer with bytes and returns it.

fn read_to_vec(&mut self, bytes: usize) -> Result<Vec<u8>, Error>

Completely fills a vector of bytes and returns it.

fn parse<F>(&mut self) -> Result<F, <F as FromByteStream>::Error>

where F: FromByteStream,

Parses and returns complex type

fn parse_with<'a, F>( &mut self, context: &<F as FromByteStreamWith<'a>>::Context, ) -> Result<F, <F as FromByteStreamWith<'a>>::Error>

where F: FromByteStreamWith<'a>,

Parses and returns complex type with context

fn parse_using<F>( &mut self, context: <F as FromByteStreamUsing>::Context, ) -> Result<F, <F as FromByteStreamUsing>::Error>

where F: FromByteStreamUsing,

Parses and returns complex type with owned context

impl<R, E> Debug for ByteReader<R, E>

where R: Debug + Read, E: Debug + Endianness,

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<R, E> Seek for ByteReader<R, E>

where R: Read + Seek, E: Endianness,

fn seek(&mut self, pos: SeekFrom) -> Result<u64, Error>

Seek to an offset, in bytes, in a stream.

fn rewind(&mut self) -> Result<(), Error>

Rewind to the beginning of a stream.

fn stream_len(&mut self) -> Result<u64, Error>

🔬This is a nightly-only experimental API. (seek_stream_len)

Returns the length of this stream (in bytes).

fn stream_position(&mut self) -> Result<u64, Error>

Returns the current seek position from the start of the stream.

fn seek_relative(&mut self, offset: i64) -> Result<(), Error>

Seeks relative to the current position.