Trait BufRead 

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

    // Provided methods
    fn remaining(&self) -> &[u8]  { ... }
    fn remaining_len(&self) -> usize { ... }
    fn copy_to_slice(&self, dst: &mut [u8]) -> JResult<()> { ... }
    fn take_array<const N: usize>(&self) -> JResult<[u8; N]> { ... }
    fn take_byteorder_array<const N: usize>(
        &mut self,
        byteorder: ByteOrder,
    ) -> JResult<[u8; N]> { ... }
    fn take_bytes(&self, nbytes: usize) -> JResult<&[u8]> { ... }
    fn take_bytes_starts<V: AsRef<[u8]>>(&self, value: V) -> JResult<()> { ... }
    fn take_bool(&self) -> JResult<bool> { ... }
    fn take_char(&self) -> JResult<char> { ... }
    fn take_u8(&self) -> JResult<u8> { ... }
    fn take_be_u8(&self) -> JResult<u8> { ... }
    fn take_le_u8(&self) -> JResult<u8> { ... }
    fn take_ne_u8(&self) -> JResult<u8> { ... }
    fn take_byteorder_u8(&self, _byteorder: ByteOrder) -> JResult<u8> { ... }
    fn take_i8(&self) -> JResult<i8> { ... }
    fn take_be_i8(&self) -> JResult<i8> { ... }
    fn take_le_i8(&self) -> JResult<i8> { ... }
    fn take_ne_i8(&self) -> JResult<i8> { ... }
    fn take_byteorder_i8(&self, _byteorder: ByteOrder) -> JResult<i8> { ... }
    fn take_u16(&self) -> JResult<u16> { ... }
    fn take_be_u16(&self) -> JResult<u16> { ... }
    fn take_le_u16(&self) -> JResult<u16> { ... }
    fn take_ne_u16(&self) -> JResult<u16> { ... }
    fn take_byteorder_u16(&self, byteorder: ByteOrder) -> JResult<u16> { ... }
    fn take_i16(&self) -> JResult<i16> { ... }
    fn take_be_i16(&self) -> JResult<i16> { ... }
    fn take_le_i16(&self) -> JResult<i16> { ... }
    fn take_ne_i16(&self) -> JResult<i16> { ... }
    fn take_byteorder_i16(&self, byteorder: ByteOrder) -> JResult<i16> { ... }
    fn take_u24(&self) -> JResult<u32> { ... }
    fn take_be_u24(&self) -> JResult<u32> { ... }
    fn take_le_u24(&self) -> JResult<u32> { ... }
    fn take_ne_u24(&self) -> JResult<u32> { ... }
    fn take_byteorder_u24(&self, byteorder: ByteOrder) -> JResult<u32> { ... }
    fn take_u32(&self) -> JResult<u32> { ... }
    fn take_be_u32(&self) -> JResult<u32> { ... }
    fn take_le_u32(&self) -> JResult<u32> { ... }
    fn take_ne_u32(&self) -> JResult<u32> { ... }
    fn take_byteorder_u32(&self, byteorder: ByteOrder) -> JResult<u32> { ... }
    fn take_i32(&self) -> JResult<i32> { ... }
    fn take_be_i32(&self) -> JResult<i32> { ... }
    fn take_le_i32(&self) -> JResult<i32> { ... }
    fn take_ne_i32(&self) -> JResult<i32> { ... }
    fn take_byteorder_i32(&self, byteorder: ByteOrder) -> JResult<i32> { ... }
    fn take_u64(&self) -> JResult<u64> { ... }
    fn take_be_u64(&self) -> JResult<u64> { ... }
    fn take_le_u64(&self) -> JResult<u64> { ... }
    fn take_ne_u64(&self) -> JResult<u64> { ... }
    fn take_byteorder_u64(&self, byteorder: ByteOrder) -> JResult<u64> { ... }
    fn take_i64(&self) -> JResult<i64> { ... }
    fn take_be_i64(&self) -> JResult<i64> { ... }
    fn take_le_i64(&self) -> JResult<i64> { ... }
    fn take_ne_i64(&self) -> JResult<i64> { ... }
    fn take_byteorder_i64(&self, byteorder: ByteOrder) -> JResult<i64> { ... }
    fn take_u128(&self) -> JResult<u128> { ... }
    fn take_be_u128(&self) -> JResult<u128> { ... }
    fn take_le_u128(&self) -> JResult<u128> { ... }
    fn take_ne_u128(&self) -> JResult<u128> { ... }
    fn take_byteorder_u128(&self, byteorder: ByteOrder) -> JResult<u128> { ... }
    fn take_i128(&self) -> JResult<i128> { ... }
    fn take_be_i128(&self) -> JResult<i128> { ... }
    fn take_le_i128(&self) -> JResult<i128> { ... }
    fn take_ne_i128(&self) -> JResult<i128> { ... }
    fn take_byteorder_i128(&self, byteorder: ByteOrder) -> JResult<i128> { ... }
    fn take_usize(&self) -> JResult<usize> { ... }
    fn take_be_usize(&self) -> JResult<usize> { ... }
    fn take_le_usize(&self) -> JResult<usize> { ... }
    fn take_ne_usize(&self) -> JResult<usize> { ... }
    fn take_byteorder_usize(&self, byteorder: ByteOrder) -> JResult<usize> { ... }
    fn take_isize(&self) -> JResult<isize> { ... }
    fn take_be_isize(&self) -> JResult<isize> { ... }
    fn take_le_isize(&self) -> JResult<isize> { ... }
    fn take_ne_isize(&self) -> JResult<isize> { ... }
    fn take_byteorder_isize(&self, byteorder: ByteOrder) -> JResult<isize> { ... }
    fn take_uint(&self, nbytes: usize) -> JResult<u64> { ... }
    fn take_be_uint(&self, nbytes: usize) -> JResult<u64> { ... }
    fn take_le_uint(&self, nbytes: usize) -> JResult<u64> { ... }
    fn take_ne_uint(&self, nbytes: usize) -> JResult<u64> { ... }
    fn take_byteorder_uint(
        &self,
        nbytes: usize,
        byteorder: ByteOrder,
    ) -> JResult<u64> { ... }
    fn take_int(&self, nbytes: usize) -> JResult<i64> { ... }
    fn take_be_int(&self, nbytes: usize) -> JResult<i64> { ... }
    fn take_le_int(&self, nbytes: usize) -> JResult<i64> { ... }
    fn take_ne_int(&self, nbytes: usize) -> JResult<i64> { ... }
    fn take_byteorder_int(
        &self,
        nbytes: usize,
        byteorder: ByteOrder,
    ) -> JResult<i64> { ... }
    fn take_f32(&self) -> JResult<f32> { ... }
    fn take_be_f32(&self) -> JResult<f32> { ... }
    fn take_le_f32(&self) -> JResult<f32> { ... }
    fn take_ne_f32(&self) -> JResult<f32> { ... }
    fn take_byteorder_f32(&self, byteorder: ByteOrder) -> JResult<f32> { ... }
    fn take_f64(&self) -> JResult<f64> { ... }
    fn take_be_f64(&self) -> JResult<f64> { ... }
    fn take_le_f64(&self) -> JResult<f64> { ... }
    fn take_ne_f64(&self) -> JResult<f64> { ... }
    fn take_byteorder_f64(&self, byteorder: ByteOrder) -> JResult<f64> { ... }
    fn find_subsequence<I: AsRef<[u8]>>(&self, needle: I) -> JResult<&[u8]> { ... }
    fn find_subsequence_needle<I: AsRef<[u8]>>(
        &self,
        needle: I,
        include_needle: bool,
    ) -> JResult<&[u8]> { ... }
    fn find_subsequences<I, P>(&self, needle: I) -> JResult<&[u8]>
       where I: IntoIterator<Item = P>,
             P: AsRef<[u8]> { ... }
    fn find_subsequences_needle<I, P>(
        &self,
        needle: I,
        include_needle: bool,
    ) -> JResult<&[u8]>
       where I: IntoIterator<Item = P>,
             P: AsRef<[u8]> { ... }
    fn untake_bytes(&self, nbytes: usize) -> JResult<&[u8]> { ... }
    fn untake_bool(&self) -> JResult<bool> { ... }
    fn untake_char(&self) -> JResult<char> { ... }
    fn untake_u8(&self) -> JResult<u8> { ... }
    fn untake_be_u8(&self) -> JResult<u8> { ... }
    fn untake_le_u8(&self) -> JResult<u8> { ... }
    fn untake_ne_u8(&self) -> JResult<u8> { ... }
    fn untake_byteorder_u8(&self, _byteorder: ByteOrder) -> JResult<u8> { ... }
    fn untake_i8(&self) -> JResult<i8> { ... }
    fn untake_be_i8(&self) -> JResult<i8> { ... }
    fn untake_le_i8(&self) -> JResult<i8> { ... }
    fn untake_ne_i8(&self) -> JResult<i8> { ... }
    fn untake_byteorder_i8(&self, _byteorder: ByteOrder) -> JResult<i8> { ... }
    fn untake_u16(&self) -> JResult<u16> { ... }
    fn untake_be_u16(&self) -> JResult<u16> { ... }
    fn untake_le_u16(&self) -> JResult<u16> { ... }
    fn untake_ne_u16(&self) -> JResult<u16> { ... }
    fn untake_byteorder_u16(&self, byteorder: ByteOrder) -> JResult<u16> { ... }
    fn untake_i16(&self) -> JResult<i16> { ... }
    fn untake_be_i16(&self) -> JResult<i16> { ... }
    fn untake_le_i16(&self) -> JResult<i16> { ... }
    fn untake_ne_i16(&self) -> JResult<i16> { ... }
    fn untake_byteorder_i16(&self, byteorder: ByteOrder) -> JResult<i16> { ... }
    fn untake_u24(&self) -> JResult<u32> { ... }
    fn untake_be_u24(&self) -> JResult<u32> { ... }
    fn untake_le_u24(&self) -> JResult<u32> { ... }
    fn untake_ne_u24(&self) -> JResult<u32> { ... }
    fn untake_byteorder_u24(&self, byteorder: ByteOrder) -> JResult<u32> { ... }
    fn untake_u32(&self) -> JResult<u32> { ... }
    fn untake_be_u32(&self) -> JResult<u32> { ... }
    fn untake_le_u32(&self) -> JResult<u32> { ... }
    fn untake_ne_u32(&self) -> JResult<u32> { ... }
    fn untake_byteorder_u32(&self, byteorder: ByteOrder) -> JResult<u32> { ... }
    fn untake_i32(&self) -> JResult<i32> { ... }
    fn untake_be_i32(&self) -> JResult<i32> { ... }
    fn untake_le_i32(&self) -> JResult<i32> { ... }
    fn untake_ne_i32(&self) -> JResult<i32> { ... }
    fn untake_byteorder_i32(&self, byteorder: ByteOrder) -> JResult<i32> { ... }
    fn untake_u64(&self) -> JResult<u64> { ... }
    fn untake_be_u64(&self) -> JResult<u64> { ... }
    fn untake_le_u64(&self) -> JResult<u64> { ... }
    fn untake_ne_u64(&self) -> JResult<u64> { ... }
    fn untake_byteorder_u64(&self, byteorder: ByteOrder) -> JResult<u64> { ... }
    fn untake_i64(&self) -> JResult<i64> { ... }
    fn untake_be_i64(&self) -> JResult<i64> { ... }
    fn untake_le_i64(&self) -> JResult<i64> { ... }
    fn untake_ne_i64(&self) -> JResult<i64> { ... }
    fn untake_byteorder_i64(&self, byteorder: ByteOrder) -> JResult<i64> { ... }
    fn untake_u128(&self) -> JResult<u128> { ... }
    fn untake_be_u128(&self) -> JResult<u128> { ... }
    fn untake_le_u128(&self) -> JResult<u128> { ... }
    fn untake_ne_u128(&self) -> JResult<u128> { ... }
    fn untake_byteorder_u128(&self, byteorder: ByteOrder) -> JResult<u128> { ... }
    fn untake_i128(&self) -> JResult<i128> { ... }
    fn untake_be_i128(&self) -> JResult<i128> { ... }
    fn untake_le_i128(&self) -> JResult<i128> { ... }
    fn untake_ne_i128(&self) -> JResult<i128> { ... }
    fn untake_byteorder_i128(&self, byteorder: ByteOrder) -> JResult<i128> { ... }
    fn untake_usize(&self) -> JResult<usize> { ... }
    fn untake_be_usize(&self) -> JResult<usize> { ... }
    fn untake_le_usize(&self) -> JResult<usize> { ... }
    fn untake_ne_usize(&self) -> JResult<usize> { ... }
    fn untake_byteorder_usize(&self, byteorder: ByteOrder) -> JResult<usize> { ... }
    fn untake_isize(&self) -> JResult<isize> { ... }
    fn untake_be_isize(&self) -> JResult<isize> { ... }
    fn untake_le_isize(&self) -> JResult<isize> { ... }
    fn untake_ne_isize(&self) -> JResult<isize> { ... }
    fn untake_byteorder_isize(&self, byteorder: ByteOrder) -> JResult<isize> { ... }
    fn untake_uint(&self, nbytes: usize) -> JResult<u64> { ... }
    fn untake_be_uint(&self, nbytes: usize) -> JResult<u64> { ... }
    fn untake_le_uint(&self, nbytes: usize) -> JResult<u64> { ... }
    fn untake_ne_uint(&self, nbytes: usize) -> JResult<u64> { ... }
    fn untake_byteorder_uint(
        &self,
        nbytes: usize,
        byteorder: ByteOrder,
    ) -> JResult<u64> { ... }
    fn untake_int(&self, nbytes: usize) -> JResult<i64> { ... }
    fn untake_be_int(&self, nbytes: usize) -> JResult<i64> { ... }
    fn untake_le_int(&self, nbytes: usize) -> JResult<i64> { ... }
    fn untake_ne_int(&self, nbytes: usize) -> JResult<i64> { ... }
    fn untake_byteorder_int(
        &self,
        nbytes: usize,
        byteorder: ByteOrder,
    ) -> JResult<i64> { ... }
    fn untake_f32(&self) -> JResult<f32> { ... }
    fn untake_be_f32(&self) -> JResult<f32> { ... }
    fn untake_le_f32(&self) -> JResult<f32> { ... }
    fn untake_ne_f32(&self) -> JResult<f32> { ... }
    fn untake_byteorder_f32(&self, byteorder: ByteOrder) -> JResult<f32> { ... }
    fn untake_f64(&self) -> JResult<f64> { ... }
    fn untake_be_f64(&self) -> JResult<f64> { ... }
    fn untake_le_f64(&self) -> JResult<f64> { ... }
    fn untake_ne_f64(&self) -> JResult<f64> { ... }
    fn untake_byteorder_f64(&self, byteorder: ByteOrder) -> JResult<f64> { ... }
}

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 set_position(&self, position: usize)

Set the internal cursor of the self.

fn reset_position(&self)

Reset the internal cursor of the self.

fn advance(&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(&self, dst: &mut [u8]) -> JResult<()>

Reads n-byte data to arrary from self.

fn take_array<const N: usize>(&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(&self, nbytes: usize) -> JResult<&[u8]>

Reads n-byte data from self.

fn take_bytes_starts<V: AsRef<[u8]>>(&self, value: V) -> JResult<()>

Reads n-byte of data according to the prefix from self.

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

Reads a bool from self.

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

Reads a byte from self.

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

Reads an unsigned 8 bit integer from self.

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

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

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

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

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

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

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

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

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

Reads a signed 8 bit integer from self.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Reads an unsigned 16 bit integer from self.

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

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

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

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

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

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

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

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

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

Reads a signed 16 bit integer from self.

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

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

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

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

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

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

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

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

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

Reads an unsigned 24 bit integer from self.

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

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

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

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

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

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

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

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

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

Reads an unsigned 32 bit integer from self.

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

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

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

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

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

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

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

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

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

Reads a signed 32 bit integer from self.

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

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

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

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

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

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

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

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

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

Reads an unsigned 64 bit integer from self.

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

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

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

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

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

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

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

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

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

Reads a signed 64 bit integer from self.

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

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

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

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

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

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

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

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

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

Reads an unsigned 128 bit integer from self.

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

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

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

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

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

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

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

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

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

Reads a signed 128 bit integer from self.

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

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

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

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

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

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

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

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

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

Reads an unsigned size bit integer from self.

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

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

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

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

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

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

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

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

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

Reads a signed size bit integer from self.

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

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

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

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

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

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

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

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

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

Reads an unsigned n-byte integer from self.

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

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

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

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

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

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

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

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

fn take_byteorder_int( &self, nbytes: usize, byteorder: ByteOrder, ) -> JResult<i64>

Reads a signed n-byte integer from self.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Reads n-byte data from self, but don’t move the position.

fn untake_bool(&self) -> JResult<bool>

Reads a bool from self, but don’t move the position.

fn untake_char(&self) -> JResult<char>

Reads a byte from self, but don’t move the position.

fn untake_u8(&self) -> JResult<u8>

Reads an unsigned 8 bit integer from self, but don’t move the position.

fn untake_be_u8(&self) -> JResult<u8>

Reads an unsigned 8 bit integer from self, but don’t move the position, exactly like the [untake_u8] function.

fn untake_le_u8(&self) -> JResult<u8>

Reads an unsigned 8 bit integer from self, but don’t move the position, exactly like the [untake_u8] function.

fn untake_ne_u8(&self) -> JResult<u8>

Reads an unsigned 8 bit integer from self, but don’t move the position, exactly like the [untake_u8] function.

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

Reads an unsigned 8 bit integer from self, but don’t move the position, exactly like the [untake_u8] function.

fn untake_i8(&self) -> JResult<i8>

Reads a signed 8 bit integer from self, but don’t move the position.

fn untake_be_i8(&self) -> JResult<i8>

Reads a signed 8 bit integer from self, but don’t move the position, exactly like the [untake_i8] function.

fn untake_le_i8(&self) -> JResult<i8>

Reads a signed 8 bit integer from self, but don’t move the position, exactly like the [untake_i8] function.

fn untake_ne_i8(&self) -> JResult<i8>

Reads a signed 8 bit integer from self, but don’t move the position, exactly like the [untake_i8] function.

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

Reads a signed 8 bit integer from self, but don’t move the position, exactly like the [untake_i8] function.

fn untake_u16(&self) -> JResult<u16>

Reads an unsigned 16 bit integer from self in big-endian byte order, but don’t move the position.

fn untake_be_u16(&self) -> JResult<u16>

Reads an unsigned 16 bit integer from self in big-endian byte order, but don’t move the position.

fn untake_le_u16(&self) -> JResult<u16>

Reads an unsigned 16 bit integer from self in little-endian byte order, but don’t move the position.

fn untake_ne_u16(&self) -> JResult<u16>

Reads an unsigned 16 bit integer from self in native-endian byte order, but don’t move the position.

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

Reads an unsigned 16 bit integer from self, but don’t move the position.

fn untake_i16(&self) -> JResult<i16>

Reads a signed 16 bit integer from self in big-endian byte order, but don’t move the position.

fn untake_be_i16(&self) -> JResult<i16>

Reads a signed 16 bit integer from self in big-endian byte order, but don’t move the position.

fn untake_le_i16(&self) -> JResult<i16>

Reads a signed 16 bit integer from self in little-endian byte order, but don’t move the position.

fn untake_ne_i16(&self) -> JResult<i16>

Reads a signed 16 bit integer from self in native-endian byte order, but don’t move the position.

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

Reads a signed 16 bit integer from self, but don’t move the position.

fn untake_u24(&self) -> JResult<u32>

Reads an unsigned 24 bit integer from self in big-endian byte order, but don’t move the position.

fn untake_be_u24(&self) -> JResult<u32>

Reads an unsigned 24 bit integer from self in big-endian byte order, but don’t move the position.

fn untake_le_u24(&self) -> JResult<u32>

Reads an unsigned 24 bit integer from self in little-endian byte order, but don’t move the position.

fn untake_ne_u24(&self) -> JResult<u32>

Reads an unsigned 24 bit integer from self in native-endian byte order, but don’t move the position.

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

Reads an unsigned 24 bit integer from self, but don’t move the position.

fn untake_u32(&self) -> JResult<u32>

Reads an unsigned 32 bit integer from self in big-endian byte order, but don’t move the position.

fn untake_be_u32(&self) -> JResult<u32>

Reads an unsigned 32 bit integer from self in big-endian byte order, but don’t move the position.

fn untake_le_u32(&self) -> JResult<u32>

Reads an unsigned 32 bit integer from self in little-endian byte order, but don’t move the position.

fn untake_ne_u32(&self) -> JResult<u32>

Reads an unsigned 32 bit integer from self in native-endian byte order, but don’t move the position.

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

Reads an unsigned 32 bit integer from self, but don’t move the position.

fn untake_i32(&self) -> JResult<i32>

Reads a signed 32 bit integer from self in big-endian byte order, but don’t move the position.

fn untake_be_i32(&self) -> JResult<i32>

Reads a signed 32 bit integer from self in big-endian byte order, but don’t move the position.

fn untake_le_i32(&self) -> JResult<i32>

Reads a signed 32 bit integer from self in little-endian byte order, but don’t move the position.

fn untake_ne_i32(&self) -> JResult<i32>

Reads a signed 32 bit integer from self in native-endian byte order, but don’t move the position.

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

Reads a signed 32 bit integer from self, but don’t move the position.

fn untake_u64(&self) -> JResult<u64>

Reads an unsigned 32 bit integer from self in big-endian byte order, but don’t move the position.

fn untake_be_u64(&self) -> JResult<u64>

Reads an unsigned 64 bit integer from self in big-endian byte order, but don’t move the position.

fn untake_le_u64(&self) -> JResult<u64>

Reads an unsigned 64 bit integer from self in little-endian byte order, but don’t move the position.

fn untake_ne_u64(&self) -> JResult<u64>

Reads an unsigned 64 bit integer from self in native-endian byte order, but don’t move the position.

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

Reads an unsigned 64 bit integer from self, but don’t move the position.

fn untake_i64(&self) -> JResult<i64>

Reads a signed 64 bit integer from self in big-endian byte order, but don’t move the position.

fn untake_be_i64(&self) -> JResult<i64>

Reads a signed 64 bit integer from self in big-endian byte order, but don’t move the position.

fn untake_le_i64(&self) -> JResult<i64>

Reads a signed 64 bit integer from self in little-endian byte order, but don’t move the position.

fn untake_ne_i64(&self) -> JResult<i64>

Reads a signed 64 bit integer from self in native-endian byte order, but don’t move the position.

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

Reads a signed 64 bit integer from self, but don’t move the position.

fn untake_u128(&self) -> JResult<u128>

Reads an unsigned 128 bit integer from self in big-endian byte order, but don’t move the position.

fn untake_be_u128(&self) -> JResult<u128>

Reads an unsigned 128 bit integer from self in big-endian byte order, but don’t move the position.

fn untake_le_u128(&self) -> JResult<u128>

Reads an unsigned 128 bit integer from self in little-endian byte order, but don’t move the position.

fn untake_ne_u128(&self) -> JResult<u128>

Reads an unsigned 128 bit integer from self in native-endian byte order, but don’t move the position.

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

Reads an unsigned 128 bit integer from self, but don’t move the position.

fn untake_i128(&self) -> JResult<i128>

Reads a signed 128 bit integer from self in big-endian byte order, but don’t move the position.

fn untake_be_i128(&self) -> JResult<i128>

Reads a signed 128 bit integer from self in big-endian byte order, but don’t move the position.

fn untake_le_i128(&self) -> JResult<i128>

Reads a signed 128 bit integer from self in little-endian byte order, but don’t move the position.

fn untake_ne_i128(&self) -> JResult<i128>

Reads a signed 128 bit integer from self in native-endian byte order, but don’t move the position.

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

Reads a signed 128 bit integer from self, but don’t move the position.

fn untake_usize(&self) -> JResult<usize>

Reads an unsigned size integer from self in big-endian byte order, but don’t move the position.

fn untake_be_usize(&self) -> JResult<usize>

Reads an unsigned size integer from self in big-endian byte order, but don’t move the position.

fn untake_le_usize(&self) -> JResult<usize>

Reads an unsigned size integer from self in little-endian byte order, but don’t move the position.

fn untake_ne_usize(&self) -> JResult<usize>

Reads an unsigned size integer from self in native-endian byte order, but don’t move the position.

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

Reads an unsigned size bit integer from self, but don’t move the position.

fn untake_isize(&self) -> JResult<isize>

Reads a signed size integer from self in big-endian byte order, but don’t move the position.

fn untake_be_isize(&self) -> JResult<isize>

Reads a signed size integer from self in big-endian byte order, but don’t move the position.

fn untake_le_isize(&self) -> JResult<isize>

Reads a signed size integer from self in little-endian byte order, but don’t move the position.

fn untake_ne_isize(&self) -> JResult<isize>

Reads a signed size integer from self in native-endian byte order, but don’t move the position.

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

Reads a signed size bit integer from self, but don’t move the position.

fn untake_uint(&self, nbytes: usize) -> JResult<u64>

Reads an unsigned n-byte integer from self in big-endian byte order, but don’t move the position.

fn untake_be_uint(&self, nbytes: usize) -> JResult<u64>

Reads an unsigned n-byte integer from self in big-endian byte order, but don’t move the position.

fn untake_le_uint(&self, nbytes: usize) -> JResult<u64>

Reads an unsigned n-byte integer from self in little-endian byte order, but don’t move the position.

fn untake_ne_uint(&self, nbytes: usize) -> JResult<u64>

Reads an unsigned n-byte integer from self in native-endian byte order, but don’t move the position.

fn untake_byteorder_uint( &self, nbytes: usize, byteorder: ByteOrder, ) -> JResult<u64>

Reads an unsigned n-byte integer from self, but don’t move the position.

fn untake_int(&self, nbytes: usize) -> JResult<i64>

Reads a signed n-byte integer from self in big-endian byte order, but don’t move the position.

fn untake_be_int(&self, nbytes: usize) -> JResult<i64>

Reads a signed n-byte integer from self in big-endian byte order, but don’t move the position.

fn untake_le_int(&self, nbytes: usize) -> JResult<i64>

Reads a signed n-byte integer from self in little-endian byte order, but don’t move the position.

fn untake_ne_int(&self, nbytes: usize) -> JResult<i64>

Reads a signed n-byte integer from self in native-endian byte order, but don’t move the position.

fn untake_byteorder_int( &self, nbytes: usize, byteorder: ByteOrder, ) -> JResult<i64>

Reads a signed n-byte integer from self, but don’t move the position.

fn untake_f32(&self) -> JResult<f32>

Reads an IEEE754 single-precision (4 bytes) floating point number from self in big-endian byte order, but don’t move the position.

fn untake_be_f32(&self) -> JResult<f32>

Reads an IEEE754 single-precision (4 bytes) floating point number from self in big-endian byte order, but don’t move the position.

fn untake_le_f32(&self) -> JResult<f32>

Reads an IEEE754 single-precision (4 bytes) floating point number from self in little-endian byte order, but don’t move the position.

fn untake_ne_f32(&self) -> JResult<f32>

Reads an IEEE754 single-precision (4 bytes) floating point number from self in native-endian byte order, but don’t move the position.

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

Reads an IEEE754 single-precision (4 bytes) floating point number from self, but don’t move the position.

fn untake_f64(&self) -> JResult<f64>

Reads an IEEE754 double-precision (8 bytes) floating point number from self in big-endian byte order, but don’t move the position.

fn untake_be_f64(&self) -> JResult<f64>

Reads an IEEE754 double-precision (8 bytes) floating point number from self in big-endian byte order, but don’t move the position.

fn untake_le_f64(&self) -> JResult<f64>

Reads an IEEE754 double-precision (8 bytes) floating point number from self in little-endian byte order, but don’t move the position.

fn untake_ne_f64(&self) -> JResult<f64>

Reads an IEEE754 double-precision (8 bytes) floating point number from self in native-endian byte order, but don’t move the position.

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

Reads an IEEE754 single-precision (8 bytes) floating point number from self, but don’t move the position.

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.

Implementors

impl BufRead for Buffer

impl<T> BufRead for Bytes<T>

where T: AsRef<[u8]>,