Struct UnlimitedBuffer 

pub struct UnlimitedBuffer<T: Clone> { /* private fields */ }

Available on crate feature alloc only.

Zero re-allocation linked-page buffer. Faster than a Vec for large datasets because it does not require pre-allocation of memory to achieve zero-reallocation. However, wastes memory for very small data sets since the minimum size quanta that allocates is 4k * sizeof(T). IE, a u8 page will be 4k wide, but a u128 page will be 64k wide and a Box<T> page will either be 32k (standard types) or 64k wide (dyn types)

Implementations

impl<T: Clone> UnlimitedBuffer<T>

pub fn new() -> UnlimitedBuffer<T>

pub fn get(&self, index: usize) -> Option<&T>

pub fn get_mut(&mut self, index: usize) -> Option<&mut T>

pub fn capacity(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn len(&self) -> u64

pub fn clear(&mut self)

pub fn front(&self) -> Option<&T>

pub fn front_mut(&mut self) -> Option<&mut T>

pub fn back(&self) -> Option<&T>

pub fn back_mut(&mut self) -> Option<&mut T>

pub fn pop_front(&mut self) -> Option<T>

Retrieves and returns the front value

pub fn pop_back(&mut self) -> Option<T>

Retrieves and returns the last value

pub fn append_slice(&mut self, slice: &[T])

Appends all elements of the slice to the back.

pub fn push_front(&mut self, value: T)

Push a value to the front

pub fn push_back(&mut self, value: T)

Push a value to the end

pub fn iter_blocks<F: FnMut(&[Option<T>])>(&mut self, f: F)

Iterate over each block of data stored

Trait Implementations

impl Bits for UnlimitedBuffer<u8>

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.

impl<T: Clone + Clone> Clone for UnlimitedBuffer<T>

fn clone(&self) -> UnlimitedBuffer<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Default + Clone> Default for UnlimitedBuffer<T>

fn default() -> UnlimitedBuffer<T>

Returns the “default value” for a type.

impl<T: Clone> Iterator for UnlimitedBuffer<T>

type Item = T

The type of the elements being iterated over.

fn next(&mut self) -> Option<Self::Item>

Advances the iterator and returns the next value.

fn next_chunk<const N: usize>( &mut self, ) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>

where Self: Sized,

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

Advances the iterator and returns an array containing the next N values.

fn size_hint(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the iterator.

fn count(self) -> usize

where Self: Sized,

Consumes the iterator, counting the number of iterations and returning it.

fn last(self) -> Option<Self::Item>

where Self: Sized,

Consumes the iterator, returning the last element.

fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

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

Advances the iterator by n elements.

fn nth(&mut self, n: usize) -> Option<Self::Item>

Returns the nth element of the iterator.

fn step_by(self, step: usize) -> StepBy<Self>

where Self: Sized,

Creates an iterator starting at the same point, but stepping by the given amount at each iteration.

fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>

where Self: Sized, U: IntoIterator<Item = Self::Item>,

Takes two iterators and creates a new iterator over both in sequence.

fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>

where Self: Sized, U: IntoIterator,

‘Zips up’ two iterators into a single iterator of pairs.

fn intersperse(self, separator: Self::Item) -> Intersperse<Self>

where Self: Sized, Self::Item: Clone,

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

Creates a new iterator which places a copy of separator between adjacent items of the original iterator.

fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>

where Self: Sized, G: FnMut() -> Self::Item,

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

Creates a new iterator which places an item generated by separator between adjacent items of the original iterator.

fn map<B, F>(self, f: F) -> Map<Self, F>

where Self: Sized, F: FnMut(Self::Item) -> B,

Takes a closure and creates an iterator which calls that closure on each element.

fn for_each<F>(self, f: F)

where Self: Sized, F: FnMut(Self::Item),

Calls a closure on each element of an iterator.

fn filter<P>(self, predicate: P) -> Filter<Self, P>

where Self: Sized, P: FnMut(&Self::Item) -> bool,

Creates an iterator which uses a closure to determine if an element should be yielded.

fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>

where Self: Sized, F: FnMut(Self::Item) -> Option<B>,

Creates an iterator that both filters and maps.

fn enumerate(self) -> Enumerate<Self>

where Self: Sized,

Creates an iterator which gives the current iteration count as well as the next value.

fn peekable(self) -> Peekable<Self>

where Self: Sized,

Creates an iterator which can use the peek and peek_mut methods to look at the next element of the iterator without consuming it. See their documentation for more information.

fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>

where Self: Sized, P: FnMut(&Self::Item) -> bool,

Creates an iterator that skips elements based on a predicate.

fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>

where Self: Sized, P: FnMut(&Self::Item) -> bool,

Creates an iterator that yields elements based on a predicate.

fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>

where Self: Sized, P: FnMut(Self::Item) -> Option<B>,

Creates an iterator that both yields elements based on a predicate and maps.

fn skip(self, n: usize) -> Skip<Self>

where Self: Sized,

Creates an iterator that skips the first n elements.

fn take(self, n: usize) -> Take<Self>

where Self: Sized,

Creates an iterator that yields the first n elements, or fewer if the underlying iterator ends sooner.

fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>

where Self: Sized, F: FnMut(&mut St, Self::Item) -> Option<B>,

An iterator adapter which, like fold, holds internal state, but unlike fold, produces a new iterator.

fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>

where Self: Sized, U: IntoIterator, F: FnMut(Self::Item) -> U,

Creates an iterator that works like map, but flattens nested structure.

fn flatten(self) -> Flatten<Self>

where Self: Sized, Self::Item: IntoIterator,

Creates an iterator that flattens nested structure.

fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>

where Self: Sized, F: FnMut(&[Self::Item; N]) -> R,

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

Calls the given function f for each contiguous window of size N over self and returns an iterator over the outputs of f. Like slice::windows(), the windows during mapping overlap as well.

fn fuse(self) -> Fuse<Self>

where Self: Sized,

Creates an iterator which ends after the first None.

fn inspect<F>(self, f: F) -> Inspect<Self, F>

where Self: Sized, F: FnMut(&Self::Item),

Does something with each element of an iterator, passing the value on.

fn by_ref(&mut self) -> &mut Self

where Self: Sized,

Creates a “by reference” adapter for this instance of Iterator.

fn collect<B>(self) -> B

where B: FromIterator<Self::Item>, Self: Sized,

Transforms an iterator into a collection.

fn try_collect<B>( &mut self, ) -> <<Self::Item as Try>::Residual as Residual<B>>::TryType

where Self: Sized, Self::Item: Try, <Self::Item as Try>::Residual: Residual<B>, B: FromIterator<<Self::Item as Try>::Output>,

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

Fallibly transforms an iterator into a collection, short circuiting if a failure is encountered.

fn collect_into<E>(self, collection: &mut E) -> &mut E

where E: Extend<Self::Item>, Self: Sized,

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

Collects all the items from an iterator into a collection.

fn partition<B, F>(self, f: F) -> (B, B)

where Self: Sized, B: Default + Extend<Self::Item>, F: FnMut(&Self::Item) -> bool,

Consumes an iterator, creating two collections from it.

fn is_partitioned<P>(self, predicate: P) -> bool

where Self: Sized, P: FnMut(Self::Item) -> bool,

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

Checks if the elements of this iterator are partitioned according to the given predicate, such that all those that return true precede all those that return false.

fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R

where Self: Sized, F: FnMut(B, Self::Item) -> R, R: Try<Output = B>,

An iterator method that applies a function as long as it returns successfully, producing a single, final value.

fn try_for_each<F, R>(&mut self, f: F) -> R

where Self: Sized, F: FnMut(Self::Item) -> R, R: Try<Output = ()>,

An iterator method that applies a fallible function to each item in the iterator, stopping at the first error and returning that error.

fn fold<B, F>(self, init: B, f: F) -> B

where Self: Sized, F: FnMut(B, Self::Item) -> B,

Folds every element into an accumulator by applying an operation, returning the final result.

fn reduce<F>(self, f: F) -> Option<Self::Item>

where Self: Sized, F: FnMut(Self::Item, Self::Item) -> Self::Item,

Reduces the elements to a single one, by repeatedly applying a reducing operation.

fn try_reduce<R>( &mut self, f: impl FnMut(Self::Item, Self::Item) -> R, ) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType

where Self: Sized, R: Try<Output = Self::Item>, <R as Try>::Residual: Residual<Option<Self::Item>>,

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

Reduces the elements to a single one by repeatedly applying a reducing operation. If the closure returns a failure, the failure is propagated back to the caller immediately.

fn all<F>(&mut self, f: F) -> bool

where Self: Sized, F: FnMut(Self::Item) -> bool,

Tests if every element of the iterator matches a predicate.

fn any<F>(&mut self, f: F) -> bool

where Self: Sized, F: FnMut(Self::Item) -> bool,

Tests if any element of the iterator matches a predicate.

fn find<P>(&mut self, predicate: P) -> Option<Self::Item>

where Self: Sized, P: FnMut(&Self::Item) -> bool,

Searches for an element of an iterator that satisfies a predicate.

fn find_map<B, F>(&mut self, f: F) -> Option<B>

where Self: Sized, F: FnMut(Self::Item) -> Option<B>,

Applies function to the elements of iterator and returns the first non-none result.

fn try_find<R>( &mut self, f: impl FnMut(&Self::Item) -> R, ) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType

where Self: Sized, R: Try<Output = bool>, <R as Try>::Residual: Residual<Option<Self::Item>>,

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

Applies function to the elements of iterator and returns the first true result or the first error.

fn position<P>(&mut self, predicate: P) -> Option<usize>

where Self: Sized, P: FnMut(Self::Item) -> bool,

Searches for an element in an iterator, returning its index.

fn max(self) -> Option<Self::Item>

where Self: Sized, Self::Item: Ord,

Returns the maximum element of an iterator.

fn min(self) -> Option<Self::Item>

where Self: Sized, Self::Item: Ord,

Returns the minimum element of an iterator.

fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>

where B: Ord, Self: Sized, F: FnMut(&Self::Item) -> B,

Returns the element that gives the maximum value from the specified function.

fn max_by<F>(self, compare: F) -> Option<Self::Item>

where Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> Ordering,

Returns the element that gives the maximum value with respect to the specified comparison function.

fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>

where B: Ord, Self: Sized, F: FnMut(&Self::Item) -> B,

Returns the element that gives the minimum value from the specified function.

fn min_by<F>(self, compare: F) -> Option<Self::Item>

where Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> Ordering,

Returns the element that gives the minimum value with respect to the specified comparison function.

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)

where FromA: Default + Extend<A>, FromB: Default + Extend<B>, Self: Sized + Iterator<Item = (A, B)>,

Converts an iterator of pairs into a pair of containers.

fn copied<'a, T>(self) -> Copied<Self>

where T: Copy + 'a, Self: Sized + Iterator<Item = &'a T>,

Creates an iterator which copies all of its elements.

fn cloned<'a, T>(self) -> Cloned<Self>

where T: Clone + 'a, Self: Sized + Iterator<Item = &'a T>,

Creates an iterator which clones all of its elements.

fn cycle(self) -> Cycle<Self>

where Self: Sized + Clone,

Repeats an iterator endlessly.

fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>

where Self: Sized,

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

Returns an iterator over N elements of the iterator at a time.

fn sum<S>(self) -> S

where Self: Sized, S: Sum<Self::Item>,

Sums the elements of an iterator.

fn product<P>(self) -> P

where Self: Sized, P: Product<Self::Item>,

Iterates over the entire iterator, multiplying all the elements

fn cmp<I>(self, other: I) -> Ordering

where I: IntoIterator<Item = Self::Item>, Self::Item: Ord, Self: Sized,

Lexicographically compares the elements of this Iterator with those of another.

fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering

where Self: Sized, I: IntoIterator, F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

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

Lexicographically compares the elements of this Iterator with those of another with respect to the specified comparison function.

fn partial_cmp<I>(self, other: I) -> Option<Ordering>

where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,

Lexicographically compares the PartialOrd elements of this Iterator with those of another. The comparison works like short-circuit evaluation, returning a result without comparing the remaining elements. As soon as an order can be determined, the evaluation stops and a result is returned.

fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>

where Self: Sized, I: IntoIterator, F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

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

Lexicographically compares the elements of this Iterator with those of another with respect to the specified comparison function.

fn eq<I>(self, other: I) -> bool

where I: IntoIterator, Self::Item: PartialEq<<I as IntoIterator>::Item>, Self: Sized,

Determines if the elements of this Iterator are equal to those of another.

fn eq_by<I, F>(self, other: I, eq: F) -> bool

where Self: Sized, I: IntoIterator, F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

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

Determines if the elements of this Iterator are equal to those of another with respect to the specified equality function.

fn ne<I>(self, other: I) -> bool

where I: IntoIterator, Self::Item: PartialEq<<I as IntoIterator>::Item>, Self: Sized,

Determines if the elements of this Iterator are not equal to those of another.

fn lt<I>(self, other: I) -> bool

where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,

Determines if the elements of this Iterator are lexicographically less than those of another.

fn le<I>(self, other: I) -> bool

where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,

Determines if the elements of this Iterator are lexicographically less or equal to those of another.

fn gt<I>(self, other: I) -> bool

where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,

Determines if the elements of this Iterator are lexicographically greater than those of another.

fn ge<I>(self, other: I) -> bool

where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,

Determines if the elements of this Iterator are lexicographically greater than or equal to those of another.

fn is_sorted(self) -> bool

where Self: Sized, Self::Item: PartialOrd,

Checks if the elements of this iterator are sorted.

fn is_sorted_by<F>(self, compare: F) -> bool

where Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> bool,

Checks if the elements of this iterator are sorted using the given comparator function.

fn is_sorted_by_key<F, K>(self, f: F) -> bool

where Self: Sized, F: FnMut(Self::Item) -> K, K: PartialOrd,

Checks if the elements of this iterator are sorted using the given key extraction function.

impl MutBits for UnlimitedBuffer<u8>

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

Writes a single u8

fn write_i8(&mut self, val: i8) -> Result<(), BitsError>

Writes a single i8

fn write_bool(&mut self, val: bool) -> Result<(), BitsError>

Writes 1u8 if true, 0u8 if false

fn write_be_utf8_char(&mut self, val: char) -> Result<usize, BitsError>

Encodes the character as UTF-8, and writes anywhere from 1-4 bytes. The number of bytes written is returned.

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

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

fn write_le_u16(&mut self, val: u16) -> Result<(), BitsError>

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

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

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

fn write_le_u32(&mut self, val: u32) -> Result<(), BitsError>

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

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

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

fn write_le_u64(&mut self, val: u64) -> Result<(), BitsError>

Writes a single u64 in little-endian order, 8 bytes, LSB first.

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

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

fn write_le_u128(&mut self, val: u128) -> Result<(), BitsError>

Writes a single u128 in little-endian order, 16 bytes, LSB first.

fn write_be_f32(&mut self, val: f32) -> Result<(), BitsError>

Writes a single f32 in standard IEEE754 format, 4 bytes

fn write_le_f32(&mut self, val: f32) -> Result<(), BitsError>

Writes a single f32 in reversed IEEE754 format, 4 bytes

fn write_be_f64(&mut self, val: f64) -> Result<(), BitsError>

Writes a single u16 in standard IEEE754 format, 8 bytes

fn write_le_f64(&mut self, val: f64) -> Result<(), BitsError>

Writes a single u16 in reversed IEEE754 format, 8 bytes

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

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

fn write_le_i16(&mut self, val: i16) -> Result<(), BitsError>

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

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

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

fn write_le_i32(&mut self, val: i32) -> Result<(), BitsError>

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

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

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

fn write_le_i64(&mut self, val: i64) -> Result<(), BitsError>

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

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

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

fn write_le_i128(&mut self, val: i128) -> Result<(), BitsError>

Writes a single i128 in little-endian order, 16 bytes, LSB first.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Writes all the bytes in order

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

Allows the use of core::format_args macro

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

Writes some subset of bytes until either the input is exhausted, or the underlying buffer fills up or errors. Returns the total number of bytes written

fn write_str_u32_blob(&mut self, val: &str) -> Result<usize, BitsError>

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

fn write_exact(&mut self, val: &[u8], len: usize) -> Result<(), BitsError>

Writes the exact amount of bytes from the input buffer to the output stream Returns an error if the buffer doesn’t have enough values or if the output stream errors.

fn write_all_into_self_from<T>( &mut self, other: &mut T, ) -> Result<u64, BitsError>

where T: Bits,

Copies all data from the other stream into this stream.

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

Flush all bytes out of the cache. Most impl’s won’t need this.