Struct irox_tools::bits::stdwrappers::BitsWrapper

pub struct BitsWrapper<'a, T>(pub &'a mut T);

Tuple Fields

0: &'a mut T

Trait Implementations

impl<'a, T> Bits for BitsWrapper<'a, T>

where T: Read,

fn next_u8(&mut self) -> Result<Option<u8>, Error>

Optionally returns a single u8

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

Reads a single u8

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

Reads a single u16 in big-endian order, 2 bytes, MSB first.

fn next_be_u16(&mut self) -> Result<Option<u16>, Error>

Optionally reads a single u16 in big-endian order, 2 bytes, MSB first.

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

Reads a single u32 in big-endian order, 4 bytes, MSB first.

fn next_be_u32(&mut self) -> Result<Option<u32>, Error>

Optionally reads a single u32 in big-endian order, 4 bytes, MSB first.

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

Reads a single u64 in big-endian order, 8 bytes, MSB first.

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

Optionally reads a single u64 in big-endian order, 8 bytes, MSB first.

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

Reads a single u128 in big-endian order, 16 bytes, MSB first.

fn next_be_u128(&mut self) -> Result<Option<u128>, Error>

Optionally reads a single u128 in big-endian order, 16 bytes, MSB first.

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

Reads a single f32, 4 bytes. Standard IEEE754 encoding

fn next_f32(&mut self) -> Result<Option<f32>, Error>

Optionally reads a single f32, 4 bytes. Standard IEEE754 encoding

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

Reads a single f64, 8 bytes. Standard IEEE754 encoding

fn next_f64(&mut self) -> Result<Option<f64>, Error>

Optionally reads a single f64, 8 bytes. Standard IEEE754 encoding

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

Reads a single i16 in big-endian order, 2 bytes, MSB first.

fn next_be_i16(&mut self) -> Result<Option<i16>, Error>

Optionally reads a single i16 in big-endian order, 2 bytes, MSB first.

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

Reads a single i32 in big-endian order, 4 bytes, MSB first.

fn next_be_i32(&mut self) -> Result<Option<i32>, Error>

Optionally reads a single i32 in big-endian order, 4 bytes, MSB first.

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

Reads a single i64 in big-endian order, 8 bytes, MSB first.

fn next_be_i64(&mut self) -> Result<Option<i64>, Error>

Optionally reads a single i64 in big-endian order, 8 bytes, MSB first.

fn advance(&mut self, len: usize) -> Result<usize, Error>

Advances the stream by at most ‘len’ bytes. The actual amount of bytes advanced may be less, and is returned in [Ok(usize)]

fn read_u8_blob(&mut self) -> Result<Vec<u8>, Error>

Reads a sized blob, a series of bytes preceded by a u8 declaring the size.

fn read_u16_blob(&mut self) -> Result<Vec<u8>, Error>

Reads a sized blob, a series of bytes preceded by a u16 declaring the size.

fn read_u32_blob(&mut self) -> Result<Vec<u8>, Error>

Reads a sized blob, a series of bytes preceded by a u32 declaring the size.

fn read_u64_blob(&mut self) -> Result<Vec<u8>, Error>

Reads a sized blob, a series of bytes preceded by a u64 declaring the size.

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

Reads the specified amount of bytes into a Vec<u8> and returns it

fn read_exact_into<T: MutBits>( &mut self, size: usize, into: &mut T ) -> Result<(), Error>

Reads the specified amount of bytes into the specified target.

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

Reads the entire stream into a UTF-8 String, dropping all other packets.

fn read_all_vec(&mut self) -> Result<Vec<u8>, Error>

Reads to the end of the stream and returns the data as a Vec<u8>

fn read_all_into<T: MutBits>(&mut self, into: &mut T) -> Result<(), Error>

Reads to the end of the stream, and writes it into the specified target.

fn read_some_into<T: MutBits>(&mut self, buf: &mut T) -> Result<usize, Error>

Reads some subset of the data into the specified target.

fn read_until(&mut self, search: &[u8]) -> Result<Vec<u8>, Error>

Reads from the input stream until:

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

Consumes data from the input stream until:

impl<'a, T> MutBits for BitsWrapper<'a, T>

where T: Write,

fn write_u8(&mut self, val: u8) -> Result<(), Error>

Writes a single u8

fn write_be_u16(&mut self, val: u16) -> Result<(), Error>

Writes a single u16 in big-endian order, 2 bytes, MSB first.

fn write_be_u32(&mut self, val: u32) -> Result<(), Error>

Writes a single u32 in big-endian order, 4 bytes, MSB first.

fn write_be_u64(&mut self, val: u64) -> Result<(), Error>

Writes a single u64 in big-endian order, 8 bytes, MSB first.

fn write_be_u128(&mut self, val: u128) -> Result<(), Error>

Writes a single u128 in big-endian order, 16 bytes, MSB first.

fn write_f32(&mut self, val: f32) -> Result<(), Error>

Writes a single f32 in standard IEEE754 format, 4 bytes

fn write_f64(&mut self, val: f64) -> Result<(), Error>

Writes a single u16 in standard IEEE754 format, 8 bytes

fn write_be_i16(&mut self, val: i16) -> Result<(), Error>

Writes a single i16 in big-endian order, 2 bytes, MSB first.

fn write_be_i32(&mut self, val: i32) -> Result<(), Error>

Writes a single i32 in big-endian order, 4 bytes, MSB first.

fn write_be_i64(&mut self, val: i64) -> Result<(), Error>

Writes a single i64 in big-endian order, 8 bytes, MSB first.

fn write_be_i128(&mut self, val: i128) -> Result<(), Error>

Writes a single i128 in big-endian order, 16 bytes, MSB first.

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

Writes a sized blob, a series of bytes preceded by a u8 declaring the size

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

Writes a sized blob, a series of bytes preceded by a u16 declaring the size

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

Writes a sized blob, a series of bytes preceded by a u32 declaring the size

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

Writes a sized blob, a series of bytes preceded by a u64 declaring the size

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

Writes all the bytes in order

fn write_fmt(&mut self, args: Arguments<'_>) -> Result<(), Error>

fn write_some_bytes(&mut self, val: &[u8]) -> usize