Struct bytebuffer::ByteReader

pub struct ByteReader<'a> { /* private fields */ }

A byte buffer object specifically turned to easily read and write binary values

Implementations

impl<'a> ByteReader<'a>

pub fn from_bytes(bytes: &[u8]) -> ByteReader<'_>

Construct a new ByteReader filled with the data array.

pub fn len(&self) -> usize

Return the buffer size

pub fn is_empty(&self) -> bool

pub fn reset_cursors(&mut self)

Reinitialize the reading cursor

pub fn reset_bits_cursors(&mut self)

Reinitialize the bit reading cursor

pub fn set_endian(&mut self, endian: Endian)

Set the byte order of the buffer

Note: By default the buffer uses big endian order

pub fn endian(&self) -> Endian

Returns the current byte order of the buffer

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

Read a defined amount of raw bytes, or return an IO error if not enough bytes are available. Note: This method resets the read and write cursor for bitwise reading.

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

Read one byte, or return an IO error if not enough bytes are available. Note: This method resets the read and write cursor for bitwise reading.

#Example

let data = vec![0x1];
let mut buffer = ByteReader::from_bytes(&data);
let value = buffer.read_u8().unwrap(); //Value contains 1

pub fn read_i8(&mut self) -> Result<i8>

Same as read_u8() but for signed values

pub fn read_u16(&mut self) -> Result<u16>

Read a 2-bytes long value, or return an IO error if not enough bytes are available. Note: This method resets the read and write cursor for bitwise reading.

#Example

let data = vec![0x0, 0x1];
let mut buffer = ByteReader::from_bytes(&data);
let value = buffer.read_u16().unwrap(); //Value contains 1

pub fn read_i16(&mut self) -> Result<i16>

Same as read_u16() but for signed values Note: This method resets the read and write cursor for bitwise reading.

pub fn read_u32(&mut self) -> Result<u32>

Read a four-bytes long value, or return an IO error if not enough bytes are available. Note: This method resets the read and write cursor for bitwise reading.

#Example

let data = vec![0x0, 0x0, 0x0, 0x1];
let mut buffer = ByteReader::from_bytes(&data);
let value = buffer.read_u32().unwrap(); // Value contains 1

pub fn read_i32(&mut self) -> Result<i32>

Same as read_u32() but for signed values Note: This method resets the read and write cursor for bitwise reading.

pub fn read_u64(&mut self) -> Result<u64>

Read an eight bytes long value, or return an IO error if not enough bytes are available. Note: This method resets the read and write cursor for bitwise reading.

#Example

let data = vec![0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1];
let mut buffer = ByteReader::from_bytes(&data);
let value = buffer.read_u64().unwrap(); //Value contains 1

pub fn read_i64(&mut self) -> Result<i64>

Same as read_u64() but for signed values Note: This method resets the read and write cursor for bitwise reading.

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

Read a 32 bits floating point value, or return an IO error if not enough bytes are available. Note: This method resets the read and write cursor for bitwise reading.

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

Read a 64 bits floating point value, or return an IO error if not enough bytes are available. Note: This method resets the read and write cursor for bitwise reading.

pub fn read_string(&mut self) -> Result<String>

Read a string.

Note: First it reads a 32 bits value representing the size, then ‘size’ raw bytes that must be encoded as UTF8. Note: This method resets the read and write cursor for bitwise reading.

pub fn to_hex_dump(&self) -> String

Dump the byte buffer to a string.

pub fn get_rpos(&self) -> usize

Return the position of the reading cursor

pub fn set_rpos(&mut self, rpos: usize)

Set the reading cursor position. Note: Sets the reading cursor to min(newPosition, self.len()) to prevent overflow

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

Return the raw byte buffer bytes.

pub fn read_bit(&mut self) -> Result<bool>

Read 1 bit. Return true if the bit is set to 1, otherwhise, return false.

Note: Bits are read from left to right

#Example

let data = vec![128];
let mut buffer = ByteReader::from_bytes(&data); // 10000000b
let value1 = buffer.read_bit().unwrap(); //value1 contains true (eg: bit is 1)
let value2 = buffer.read_bit().unwrap(); //value2 contains false (eg: bit is 0)

pub fn read_bits(&mut self, n: u8) -> Result<u64>

Read n bits. an return the corresponding value an u64.

Note: We cannot read more than 64 bits

Note: Bits are read from left to right

#Example

let data = vec![128];
let mut buffer = ByteReader::from_bytes(&data); // 10000000b
let value = buffer.read_bits(3).unwrap(); // value contains 4 (eg: 100b)

pub fn flush_bits(&mut self)

Discard all the pending bits available for reading and place the corresponding cursor to the next byte.

Note: If no bits are currently read, this function does nothing.

#Example

10010010 | 00000001
^
10010010 | 00000001 // read_bit called
 ^
10010010 | 00000001 // flush_bit() called
           ^

Trait Implementations

impl<'a> Clone for ByteReader<'a>

fn clone(&self) -> ByteReader<'a>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Debug for ByteReader<'a>

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

Formats the value using the given formatter.

impl<'a> From<&'a [u8]> for ByteReader<'a>

fn from(val: &'a [u8]) -> Self

Converts to this type from the input type.

impl<'a> Hash for ByteReader<'a>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'a> PartialEq for ByteReader<'a>

fn eq(&self, other: &ByteReader<'a>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> Read for ByteReader<'a>

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

Pull some bytes from this source into the specified buffer, returning how many bytes were read.

fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> Result<usize, Error>

Like read, except that it reads into a slice of buffers.

fn is_read_vectored(&self) -> bool

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

Determines if this Reader has an efficient read_vectored implementation.

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

Read all bytes until EOF in this source, placing them into buf.

fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>

Read all bytes until EOF in this source, appending them to buf.

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

Read the exact number of bytes required to fill buf.

fn read_buf(&mut self, buf: BorrowedCursor<'_>) -> Result<(), Error>

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

Pull some bytes from this source into the specified buffer.

fn read_buf_exact(&mut self, cursor: BorrowedCursor<'_>) -> Result<(), Error>

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

Read the exact number of bytes required to fill cursor.

fn by_ref(&mut self) -> &mut Selfwhere Self: Sized,

Creates a “by reference” adaptor for this instance of Read.

fn bytes(self) -> Bytes<Self>where Self: Sized,

Transforms this Read instance to an Iterator over its bytes.

fn chain<R>(self, next: R) -> Chain<Self, R>where R: Read, Self: Sized,

Creates an adapter which will chain this stream with another.

fn take(self, limit: u64) -> Take<Self>where Self: Sized,

Creates an adapter which will read at most limit bytes from it.

impl<'a> Eq for ByteReader<'a>

impl<'a> StructuralEq for ByteReader<'a>

impl<'a> StructuralPartialEq for ByteReader<'a>