Trait BufReadMut

pub trait BufReadMut {
    // Required methods
    fn get_position(&self) -> usize;
    fn get_data(&self) -> &[u8] ;
    fn advance(&mut self, nbytes: usize);

    // Provided methods
    fn remaining(&self) -> &[u8]  { ... }
    fn remaining_len(&self) -> usize { ... }
    fn copy_to_slice(&mut self, dst: &mut [u8]) -> JResult<()> { ... }
    fn take_array<const N: usize>(&mut self) -> JResult<[u8; N]> { ... }
    fn take_byteorder_array<const N: usize>(
        &mut self,
        byteorder: ByteOrder,
    ) -> JResult<[u8; N]> { ... }
    fn take_bytes(&mut self, nbytes: usize) -> JResult<&[u8]> { ... }
    fn take_bool(&mut self) -> JResult<bool> { ... }
    fn take_char(&mut self) -> JResult<char> { ... }
    fn take_u8(&mut self) -> JResult<u8> { ... }
    fn take_be_u8(&mut self) -> JResult<u8> { ... }
    fn take_le_u8(&mut self) -> JResult<u8> { ... }
    fn take_ne_u8(&mut self) -> JResult<u8> { ... }
    fn take_byteorder_u8(&mut self, _byteorder: ByteOrder) -> JResult<u8> { ... }
    fn take_i8(&mut self) -> JResult<i8> { ... }
    fn take_be_i8(&mut self) -> JResult<i8> { ... }
    fn take_le_i8(&mut self) -> JResult<i8> { ... }
    fn take_ne_i8(&mut self) -> JResult<i8> { ... }
    fn take_byteorder_i8(&mut self, _byteorder: ByteOrder) -> JResult<i8> { ... }
    fn take_u16(&mut self) -> JResult<u16> { ... }
    fn take_be_u16(&mut self) -> JResult<u16> { ... }
    fn take_le_u16(&mut self) -> JResult<u16> { ... }
    fn take_ne_u16(&mut self) -> JResult<u16> { ... }
    fn take_byteorder_u16(&mut self, byteorder: ByteOrder) -> JResult<u16> { ... }
    fn take_i16(&mut self) -> JResult<i16> { ... }
    fn take_be_i16(&mut self) -> JResult<i16> { ... }
    fn take_le_i16(&mut self) -> JResult<i16> { ... }
    fn take_ne_i16(&mut self) -> JResult<i16> { ... }
    fn take_byteorder_i16(&mut self, byteorder: ByteOrder) -> JResult<i16> { ... }
    fn take_u24(&mut self) -> JResult<u32> { ... }
    fn take_be_u24(&mut self) -> JResult<u32> { ... }
    fn take_le_u24(&mut self) -> JResult<u32> { ... }
    fn take_ne_u24(&mut self) -> JResult<u32> { ... }
    fn take_byteorder_u24(&mut self, byteorder: ByteOrder) -> JResult<u32> { ... }
    fn take_u32(&mut self) -> JResult<u32> { ... }
    fn take_be_u32(&mut self) -> JResult<u32> { ... }
    fn take_le_u32(&mut self) -> JResult<u32> { ... }
    fn take_ne_u32(&mut self) -> JResult<u32> { ... }
    fn take_byteorder_u32(&mut self, byteorder: ByteOrder) -> JResult<u32> { ... }
    fn take_i32(&mut self) -> JResult<i32> { ... }
    fn take_be_i32(&mut self) -> JResult<i32> { ... }
    fn take_le_i32(&mut self) -> JResult<i32> { ... }
    fn take_ne_i32(&mut self) -> JResult<i32> { ... }
    fn take_byteorder_i32(&mut self, byteorder: ByteOrder) -> JResult<i32> { ... }
    fn take_u64(&mut self) -> JResult<u64> { ... }
    fn take_be_u64(&mut self) -> JResult<u64> { ... }
    fn take_le_u64(&mut self) -> JResult<u64> { ... }
    fn take_ne_u64(&mut self) -> JResult<u64> { ... }
    fn take_byteorder_u64(&mut self, byteorder: ByteOrder) -> JResult<u64> { ... }
    fn take_i64(&mut self) -> JResult<i64> { ... }
    fn take_be_i64(&mut self) -> JResult<i64> { ... }
    fn take_le_i64(&mut self) -> JResult<i64> { ... }
    fn take_ne_i64(&mut self) -> JResult<i64> { ... }
    fn take_byteorder_i64(&mut self, byteorder: ByteOrder) -> JResult<i64> { ... }
    fn take_u128(&mut self) -> JResult<u128> { ... }
    fn take_be_u128(&mut self) -> JResult<u128> { ... }
    fn take_le_u128(&mut self) -> JResult<u128> { ... }
    fn take_ne_u128(&mut self) -> JResult<u128> { ... }
    fn take_byteorder_u128(&mut self, byteorder: ByteOrder) -> JResult<u128> { ... }
    fn take_i128(&mut self) -> JResult<i128> { ... }
    fn take_be_i128(&mut self) -> JResult<i128> { ... }
    fn take_le_i128(&mut self) -> JResult<i128> { ... }
    fn take_ne_i128(&mut self) -> JResult<i128> { ... }
    fn take_byteorder_i128(&mut self, byteorder: ByteOrder) -> JResult<i128> { ... }
    fn take_usize(&mut self) -> JResult<usize> { ... }
    fn take_be_usize(&mut self) -> JResult<usize> { ... }
    fn take_le_usize(&mut self) -> JResult<usize> { ... }
    fn take_ne_usize(&mut self) -> JResult<usize> { ... }
    fn take_byteorder_usize(&mut self, byteorder: ByteOrder) -> JResult<usize> { ... }
    fn take_isize(&mut self) -> JResult<isize> { ... }
    fn take_be_isize(&mut self) -> JResult<isize> { ... }
    fn take_le_isize(&mut self) -> JResult<isize> { ... }
    fn take_ne_isize(&mut self) -> JResult<isize> { ... }
    fn take_byteorder_isize(&mut self, byteorder: ByteOrder) -> JResult<isize> { ... }
    fn take_uint(&mut self, nbytes: usize) -> JResult<usize> { ... }
    fn take_be_uint(&mut self, nbytes: usize) -> JResult<usize> { ... }
    fn take_le_uint(&mut self, nbytes: usize) -> JResult<usize> { ... }
    fn take_ne_uint(&mut self, nbytes: usize) -> JResult<usize> { ... }
    fn take_byteorder_uint(&mut self, byteorder: ByteOrder) -> JResult<usize> { ... }
    fn take_int(&mut self, nbytes: usize) -> JResult<isize> { ... }
    fn take_be_int(&mut self, nbytes: usize) -> JResult<isize> { ... }
    fn take_le_int(&mut self, nbytes: usize) -> JResult<isize> { ... }
    fn take_ne_int(&mut self, nbytes: usize) -> JResult<isize> { ... }
    fn take_byteorder_int(&mut self, byteorder: ByteOrder) -> JResult<isize> { ... }
    fn take_f32(&mut self) -> JResult<f32> { ... }
    fn take_be_f32(&mut self) -> JResult<f32> { ... }
    fn take_le_f32(&mut self) -> JResult<f32> { ... }
    fn take_ne_f32(&mut self) -> JResult<f32> { ... }
    fn take_byteorder_f32(&mut self, byteorder: ByteOrder) -> JResult<f32> { ... }
    fn take_f64(&mut self) -> JResult<f64> { ... }
    fn take_be_f64(&mut self) -> JResult<f64> { ... }
    fn take_le_f64(&mut self) -> JResult<f64> { ... }
    fn take_ne_f64(&mut self) -> JResult<f64> { ... }
    fn take_byteorder_f64(&mut self, byteorder: ByteOrder) -> JResult<f64> { ... }
    fn find_subsequence<I: AsRef<[u8]>>(&mut self, needle: I) -> JResult<&[u8]> { ... }
    fn find_subsequence_needle<I: AsRef<[u8]>>(
        &mut self,
        needle: I,
        include_needle: bool,
    ) -> JResult<&[u8]> { ... }
    fn find_subsequences<I, P>(&mut self, needle: I) -> JResult<&[u8]>
       where I: IntoIterator<Item = P>,
             P: AsRef<[u8]> { ... }
    fn find_subsequences_needle<P, I>(
        &mut self,
        needle: I,
        include_needle: bool,
    ) -> JResult<&[u8]>
       where I: IntoIterator<Item = P>,
             P: AsRef<[u8]> { ... }
}

Required Methods

fn get_position(&self) -> usize

Get the internal cursor of the self.

fn get_data(&self) -> &[u8]

Get the internal data of the self.

fn advance(&mut self, nbytes: usize)

Advance the internal cursor of the self.

Provided Methods

fn remaining(&self) -> &[u8]

Returns the n-bytes between the current position and the end of the buffer.

fn remaining_len(&self) -> usize

Returns the number of bytes between the current position and the end of the buffer.

fn copy_to_slice(&mut self, dst: &mut [u8]) -> JResult<()>

Reads n-byte data to arrary from self.

fn take_array<const N: usize>(&mut self) -> JResult<[u8; N]>

Reads n-byte data from self.

fn take_byteorder_array<const N: usize>( &mut self, byteorder: ByteOrder, ) -> JResult<[u8; N]>

Reads n-byte data from self.

fn take_bytes(&mut self, nbytes: usize) -> JResult<&[u8]>

Reads n-byte data from self.

fn take_bool(&mut self) -> JResult<bool>

Reads a bool from self.

fn take_char(&mut self) -> JResult<char>

Reads a byte from self.

fn take_u8(&mut self) -> JResult<u8>

Reads an unsigned 8 bit integer from self.

fn take_be_u8(&mut self) -> JResult<u8>

Reads an unsigned 8 bit integer from self, exactly like the [take_u8] function.

fn take_le_u8(&mut self) -> JResult<u8>

Reads an unsigned 8 bit integer from self, exactly like the [take_u8] function.

fn take_ne_u8(&mut self) -> JResult<u8>

Reads an unsigned 8 bit integer from self, exactly like the [take_u8] function.

fn take_byteorder_u8(&mut self, _byteorder: ByteOrder) -> JResult<u8>

Reads an unsigned 8 bit integer from self, exactly like the [take_u8] function.

fn take_i8(&mut self) -> JResult<i8>

Reads a signed 8 bit integer from self.

fn take_be_i8(&mut self) -> JResult<i8>

Reads a signed 8 bit integer from self, exactly like the [take_i8] function.

fn take_le_i8(&mut self) -> JResult<i8>

Reads a signed 8 bit integer from self, exactly like the [take_i8] function.

fn take_ne_i8(&mut self) -> JResult<i8>

Reads a signed 8 bit integer from self, exactly like the [take_i8] function.

fn take_byteorder_i8(&mut self, _byteorder: ByteOrder) -> JResult<i8>

Reads a signed 8 bit integer from self, exactly like the [take_i8] function.

fn take_u16(&mut self) -> JResult<u16>

Reads an unsigned 16 bit integer from self in big-endian byte order.

fn take_be_u16(&mut self) -> JResult<u16>

Reads an unsigned 16 bit integer from self in big-endian byte order.

fn take_le_u16(&mut self) -> JResult<u16>

Reads an unsigned 16 bit integer from self in little-endian byte order.

fn take_ne_u16(&mut self) -> JResult<u16>

Reads an unsigned 16 bit integer from self in native-endian byte order.

fn take_byteorder_u16(&mut self, byteorder: ByteOrder) -> JResult<u16>

Reads an unsigned 16 bit integer from self.

fn take_i16(&mut self) -> JResult<i16>

Reads a signed 16 bit integer from self in big-endian byte order.

fn take_be_i16(&mut self) -> JResult<i16>

Reads a signed 16 bit integer from self in big-endian byte order.

fn take_le_i16(&mut self) -> JResult<i16>

Reads a signed 16 bit integer from self in little-endian byte order.

fn take_ne_i16(&mut self) -> JResult<i16>

Reads a signed 16 bit integer from self in native-endian byte order.

fn take_byteorder_i16(&mut self, byteorder: ByteOrder) -> JResult<i16>

Reads a signed 16 bit integer from self.

fn take_u24(&mut self) -> JResult<u32>

Reads an unsigned 24 bit integer from self in big-endian byte order.

fn take_be_u24(&mut self) -> JResult<u32>

Reads an unsigned 24 bit integer from self in big-endian byte order.

fn take_le_u24(&mut self) -> JResult<u32>

Reads an unsigned 24 bit integer from self in little-endian byte order.

fn take_ne_u24(&mut self) -> JResult<u32>

Reads an unsigned 24 bit integer from self in native-endian byte order.

fn take_byteorder_u24(&mut self, byteorder: ByteOrder) -> JResult<u32>

Reads an unsigned 24 bit integer from self.

fn take_u32(&mut self) -> JResult<u32>

Reads an unsigned 32 bit integer from self in big-endian byte order.

fn take_be_u32(&mut self) -> JResult<u32>

Reads an unsigned 32 bit integer from self in big-endian byte order.

fn take_le_u32(&mut self) -> JResult<u32>

Reads an unsigned 32 bit integer from self in little-endian byte order.

fn take_ne_u32(&mut self) -> JResult<u32>

Reads an unsigned 32 bit integer from self in native-endian byte order.

fn take_byteorder_u32(&mut self, byteorder: ByteOrder) -> JResult<u32>

Reads an unsigned 32 bit integer from self.

fn take_i32(&mut self) -> JResult<i32>

Reads a signed 32 bit integer from self in big-endian byte order.

fn take_be_i32(&mut self) -> JResult<i32>

Reads a signed 32 bit integer from self in big-endian byte order.

fn take_le_i32(&mut self) -> JResult<i32>

Reads a signed 32 bit integer from self in little-endian byte order.

fn take_ne_i32(&mut self) -> JResult<i32>

Reads a signed 32 bit integer from self in native-endian byte order.

fn take_byteorder_i32(&mut self, byteorder: ByteOrder) -> JResult<i32>

Reads a signed 32 bit integer from self.

fn take_u64(&mut self) -> JResult<u64>

Reads an unsigned 32 bit integer from self in big-endian byte order.

fn take_be_u64(&mut self) -> JResult<u64>

Reads an unsigned 64 bit integer from self in big-endian byte order.

fn take_le_u64(&mut self) -> JResult<u64>

Reads an unsigned 64 bit integer from self in little-endian byte order.

fn take_ne_u64(&mut self) -> JResult<u64>

Reads an unsigned 64 bit integer from self in native-endian byte order.

fn take_byteorder_u64(&mut self, byteorder: ByteOrder) -> JResult<u64>

Reads an unsigned 64 bit integer from self.

fn take_i64(&mut self) -> JResult<i64>

Reads a signed 64 bit integer from self in big-endian byte order.

fn take_be_i64(&mut self) -> JResult<i64>

Reads a signed 64 bit integer from self in big-endian byte order.

fn take_le_i64(&mut self) -> JResult<i64>

Reads a signed 64 bit integer from self in little-endian byte order.

fn take_ne_i64(&mut self) -> JResult<i64>

Reads a signed 64 bit integer from self in native-endian byte order.

fn take_byteorder_i64(&mut self, byteorder: ByteOrder) -> JResult<i64>

Reads a signed 64 bit integer from self.

fn take_u128(&mut self) -> JResult<u128>

Reads an unsigned 128 bit integer from self in big-endian byte order.

fn take_be_u128(&mut self) -> JResult<u128>

Reads an unsigned 128 bit integer from self in big-endian byte order.

fn take_le_u128(&mut self) -> JResult<u128>

Reads an unsigned 128 bit integer from self in little-endian byte order.

fn take_ne_u128(&mut self) -> JResult<u128>

Reads an unsigned 128 bit integer from self in native-endian byte order.

fn take_byteorder_u128(&mut self, byteorder: ByteOrder) -> JResult<u128>

Reads an unsigned 128 bit integer from self.

fn take_i128(&mut self) -> JResult<i128>

Reads a signed 128 bit integer from self in big-endian byte order.

fn take_be_i128(&mut self) -> JResult<i128>

Reads a signed 128 bit integer from self in big-endian byte order.

fn take_le_i128(&mut self) -> JResult<i128>

Reads a signed 128 bit integer from self in little-endian byte order.

fn take_ne_i128(&mut self) -> JResult<i128>

Reads a signed 128 bit integer from self in native-endian byte order.

fn take_byteorder_i128(&mut self, byteorder: ByteOrder) -> JResult<i128>

Reads a signed 128 bit integer from self.

fn take_usize(&mut self) -> JResult<usize>

Reads an unsigned size integer from self in big-endian byte order.

fn take_be_usize(&mut self) -> JResult<usize>

Reads an unsigned size integer from self in big-endian byte order.

fn take_le_usize(&mut self) -> JResult<usize>

Reads an unsigned size integer from self in little-endian byte order.

fn take_ne_usize(&mut self) -> JResult<usize>

Reads an unsigned size integer from self in native-endian byte order.

fn take_byteorder_usize(&mut self, byteorder: ByteOrder) -> JResult<usize>

Reads an unsigned size bit integer from self.

fn take_isize(&mut self) -> JResult<isize>

Reads a signed size integer from self in big-endian byte order.

fn take_be_isize(&mut self) -> JResult<isize>

Reads a signed size integer from self in big-endian byte order.

fn take_le_isize(&mut self) -> JResult<isize>

Reads a signed size integer from self in little-endian byte order.

fn take_ne_isize(&mut self) -> JResult<isize>

Reads a signed size integer from self in native-endian byte order.

fn take_byteorder_isize(&mut self, byteorder: ByteOrder) -> JResult<isize>

Reads a signed size bit integer from self.

fn take_uint(&mut self, nbytes: usize) -> JResult<usize>

Reads an unsigned n-byte integer from self in big-endian byte order.

fn take_be_uint(&mut self, nbytes: usize) -> JResult<usize>

Reads an unsigned n-byte integer from self in big-endian byte order.

fn take_le_uint(&mut self, nbytes: usize) -> JResult<usize>

Reads an unsigned n-byte integer from self in little-endian byte order.

fn take_ne_uint(&mut self, nbytes: usize) -> JResult<usize>

Reads an unsigned n-byte integer from self in native-endian byte order.

fn take_byteorder_uint(&mut self, byteorder: ByteOrder) -> JResult<usize>

Reads an unsigned n-byte integer from self.

fn take_int(&mut self, nbytes: usize) -> JResult<isize>

Reads a signed n-byte integer from self in big-endian byte order.

fn take_be_int(&mut self, nbytes: usize) -> JResult<isize>

Reads a signed n-byte integer from self in big-endian byte order.

fn take_le_int(&mut self, nbytes: usize) -> JResult<isize>

Reads a signed n-byte integer from self in little-endian byte order.

fn take_ne_int(&mut self, nbytes: usize) -> JResult<isize>

Reads a signed n-byte integer from self in native-endian byte order.

fn take_byteorder_int(&mut self, byteorder: ByteOrder) -> JResult<isize>

Reads a signed n-byte integer from self.

fn take_f32(&mut self) -> JResult<f32>

Reads an IEEE754 single-precision (4 bytes) floating point number from self in big-endian byte order.

fn take_be_f32(&mut self) -> JResult<f32>

Reads an IEEE754 single-precision (4 bytes) floating point number from self in big-endian byte order.

fn take_le_f32(&mut self) -> JResult<f32>

Reads an IEEE754 single-precision (4 bytes) floating point number from self in little-endian byte order.

fn take_ne_f32(&mut self) -> JResult<f32>

Reads an IEEE754 single-precision (4 bytes) floating point number from self in native-endian byte order.

fn take_byteorder_f32(&mut self, byteorder: ByteOrder) -> JResult<f32>

Reads an IEEE754 single-precision (4 bytes) floating point number from self.

fn take_f64(&mut self) -> JResult<f64>

Reads an IEEE754 double-precision (8 bytes) floating point number from self in big-endian byte order.

fn take_be_f64(&mut self) -> JResult<f64>

Reads an IEEE754 double-precision (8 bytes) floating point number from self in big-endian byte order.

fn take_le_f64(&mut self) -> JResult<f64>

Reads an IEEE754 double-precision (8 bytes) floating point number from self in little-endian byte order.

fn take_ne_f64(&mut self) -> JResult<f64>

Reads an IEEE754 double-precision (8 bytes) floating point number from self in native-endian byte order.

fn take_byteorder_f64(&mut self, byteorder: ByteOrder) -> JResult<f64>

Reads an IEEE754 single-precision (8 bytes) floating point number from self.

fn find_subsequence<I: AsRef<[u8]>>(&mut self, needle: I) -> JResult<&[u8]>

fn find_subsequence_needle<I: AsRef<[u8]>>( &mut self, needle: I, include_needle: bool, ) -> JResult<&[u8]>

fn find_subsequences<I, P>(&mut self, needle: I) -> JResult<&[u8]>

where I: IntoIterator<Item = P>, P: AsRef<[u8]>,

fn find_subsequences_needle<P, I>( &mut self, needle: I, include_needle: bool, ) -> JResult<&[u8]>

where I: IntoIterator<Item = P>, P: AsRef<[u8]>,

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl BufReadMut for &[u8]

fn get_position(&self) -> usize

fn get_data(&self) -> &[u8]

fn advance(&mut self, nbytes: usize)

fn remaining(&self) -> &[u8]

fn take_bytes(&mut self, nbytes: usize) -> JResult<&[u8]>

impl<T: AsRef<[u8]>> BufReadMut for Cursor<T>

fn get_position(&self) -> usize

fn get_data(&self) -> &[u8]

fn advance(&mut self, nbytes: usize)

Implementors