Struct InflateStream

pub struct InflateStream<'a, B: BufBits> { /* private fields */ }

Available on crate feature miniz only.

Implementations

impl<'a, B: BufBits> InflateStream<'a, B>

pub fn new(reader: BitsWrapper<'a, B>) -> Self

pub fn has_more(&mut self) -> Result<bool, Error>

Trait Implementations

impl<'a, B: BufBits> Bits for InflateStream<'a, B>

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

Optionally returns a single u8

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

Reads a single u8

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

Reads a single i8

fn next_i8(&mut self) -> Result<Option<i8>, BitsError>

Optionally returns a single i8

fn read_bool(&mut self) -> Result<bool, BitsError>

Reads a single bool (u8), returning true if 1, false if 0, or InvalidInput if anything else.

fn next_bool(&mut self) -> Result<Option<bool>, BitsError>

Reads a single bool (u8), returning true if 1, false if 0, or InvalidInput if anything else.

fn read_be_utf8_char(&mut self) -> Result<char, BitsError>

Reads 1, 2, 3, or 4 bytes to construct a UTF-8 charpoint.

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

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

fn read_le_u16(&mut self) -> Result<u16, BitsError>

Reads a single u16 in little-endian order, 2 bytes, LSB first.

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

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

fn next_le_u16(&mut self) -> Result<Option<u16>, BitsError>

Optionally reads a single u16 in little-endian order, 2 bytes, LSB first.

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

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

fn read_le_u32(&mut self) -> Result<u32, BitsError>

Reads a single u32 in little-endian order, 4 bytes, LSB first.

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

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

fn next_le_u32(&mut self) -> Result<Option<u32>, BitsError>

Optionally reads a single u32 in little-endian order, 4 bytes, LSB first.

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

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

fn read_le_u64(&mut self) -> Result<u64, BitsError>

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

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

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

fn next_le_u64(&mut self) -> Result<Option<u64>, BitsError>

Optionally reads a single u64 in little-endian order, 4 bytes, LSB first.

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

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

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

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

fn read_be_i128(&mut self) -> Result<i128, BitsError>

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

fn next_be_i128(&mut self) -> Result<Option<i128>, BitsError>

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

fn read_be_f32(&mut self) -> Result<f32, BitsError>

Reads a single f32, 4 bytes. Standard IEEE754 encoding

fn read_le_f32(&mut self) -> Result<f32, BitsError>

Reads a single f32, 4 bytes. Reversed IEEE754 encoding

fn read_f32(&mut self, order: ByteOrder) -> Result<f32, BitsError>

Reads a single f32, 4 bytes. Specified byte ordering.

fn next_be_f32(&mut self) -> Result<Option<f32>, BitsError>

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

fn next_le_f32(&mut self) -> Result<Option<f32>, BitsError>

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

fn read_be_f64(&mut self) -> Result<f64, BitsError>

Reads a single f64, 8 bytes. Standard IEEE754 encoding

fn read_le_f64(&mut self) -> Result<f64, BitsError>

Reads a single f64, 8 bytes. Reversed IEEE754 encoding

fn next_be_f64(&mut self) -> Result<Option<f64>, BitsError>

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

fn next_le_f64(&mut self) -> Result<Option<f64>, BitsError>

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

fn read_f64(&mut self, order: ByteOrder) -> Result<f64, BitsError>

Reads a single f64, 8 bytes. Specified byte ordering.

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

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

fn read_le_i16(&mut self) -> Result<i16, BitsError>

Reads a single i16 in little-endian order, 2 bytes, LSB first.

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

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

fn next_le_i16(&mut self) -> Result<Option<i16>, BitsError>

Optionally reads a single i16 in little-endian order, 2 bytes, LSB first.

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

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

fn read_le_i32(&mut self) -> Result<i32, BitsError>

Reads a single i32 in little-endian order, 4 bytes, LSB first.

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

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

fn next_le_i32(&mut self) -> Result<Option<i32>, BitsError>

Optionally reads a single i32 in little-endian order, 4 bytes,LSB first.

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

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

fn read_le_i64(&mut self) -> Result<i64, BitsError>

Reads a single i64 in little-endian order, 8 bytes, LSB first.

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

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

fn next_le_i64(&mut self) -> Result<Option<i64>, BitsError>

Optionally reads a single i64 in little-endian order, 8 bytes, LSB first.

fn read_le_i128(&mut self) -> Result<i128, BitsError>

Reads a single i128 in little-endian order, 8 bytes, LSB first.

fn next_le_i128(&mut self) -> Result<Option<i128>, BitsError>

Optionally reads a single i64 in little-endian order, 8 bytes, LSB first.

fn read_le_u128(&mut self) -> Result<u128, BitsError>

Reads a single u128 in little-endian order, 8 bytes, LSB first.

fn next_le_u128(&mut self) -> Result<Option<u128>, BitsError>

Optionally reads a single i64 in little-endian order, 8 bytes, LSB first.

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

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_into<T>(&mut self, into: &mut T) -> Result<(), BitsError>

where T: MutBits,

fn read_u16_blob_into<T>(&mut self, into: &mut T) -> Result<(), BitsError>

where T: MutBits,

fn read_u32_blob_into<T>(&mut self, into: &mut T) -> Result<(), BitsError>

where T: MutBits,

fn read_u64_blob_into<T>(&mut self, into: &mut T) -> Result<(), BitsError>

where T: MutBits,

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

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

fn read_be_u16_blob(&mut self) -> Result<Vec<u8>, BitsError>

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

fn read_le_u16_blob(&mut self) -> Result<Vec<u8>, BitsError>

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

fn read_be_u32_blob(&mut self) -> Result<Vec<u8>, BitsError>

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

fn read_le_u32_blob(&mut self) -> Result<Vec<u8>, BitsError>

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

fn read_be_u64_blob(&mut self) -> Result<Vec<u8>, BitsError>

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

fn read_le_u64_blob(&mut self) -> Result<Vec<u8>, BitsError>

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>, BitsError>

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

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

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

fn read_str_sized_lossy(&mut self, len: usize) -> Result<String, BitsError>

Reads the specified amount of bytes into a UTF-8 String, dropping all other bytes.

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

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

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

Reads from the input stream until:

fn read_line_vec(&mut self) -> Result<Option<Vec<u8>>, BitsError>

Reads until the next \n character, ignoring any \r characters along the way.

fn read_line_str_lossy(&mut self) -> Result<Option<String>, BitsError>

Reads until the next \n character, then calls String::from_utf8_lossy.

fn read_line_str(&mut self) -> Result<Option<String>, BitsError>

Reads until the next \n character, then calls String::from_utf8

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

Consumes data from the input stream until:

fn read_str_u32_blob(&mut self) -> Result<String, BitsError>

Reads a specific sized string from the stream, a string prefixed by a 4-byte big-endian length.

fn read_exact<const N: usize>(&mut self) -> Result<[u8; N], BitsError>

Reads the specified amount of bytes into a stack-allocated array.

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

where T: MutBits,

Reads the specified amount of bytes into the specified target.

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

where T: MutBits,

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

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

where T: MutBits,

Reads some subset of the data into the specified target.

fn read_u16(&mut self, order: ByteOrder) -> Result<u16, BitsError>

Reads a single u16 in the specified order order, 2 bytes.

fn read_u32(&mut self, order: ByteOrder) -> Result<u32, BitsError>

Reads a single u32 in the specified order order, 4 bytes.

fn read_u64(&mut self, order: ByteOrder) -> Result<u64, BitsError>

Reads a single u64 in the specified order order, 8 bytes.

fn read_u128(&mut self, order: ByteOrder) -> Result<u128, BitsError>

Reads a single u128 in the specified order order, 16 bytes.

fn read_i16(&mut self, order: ByteOrder) -> Result<i16, BitsError>

Reads a single i16 in the specified order order, 2 bytes.

fn read_i32(&mut self, order: ByteOrder) -> Result<i32, BitsError>

Reads a single i32 in the specified order order, 4 bytes.

fn read_i64(&mut self, order: ByteOrder) -> Result<i64, BitsError>

Reads a single i64 in the specified order order, 4 bytes.

fn read_i128(&mut self, order: ByteOrder) -> Result<i128, BitsError>

Reads a single i128 in the specified order order, 16 bytes.