Struct SeqBytes 

pub struct SeqBytes { /* private fields */ }

A sequence of &[u8], stored contiguously

This can be used as a drop-in replacement for Vec<Vec<u8>> in some cases, with better memory locality and fewer memory allocations.

When using SeqBytes instead of Vec<Vec<u8>>, the individual byte strings cannot be resized, but when this isn’t needed there isn’t much downside otherwise.

The container also supports “emplace”-style APIs like in_place_writer, which allow you to write the next element directly into the contiguous buffer with minimal overhead.

Implementations

impl SeqBytes

pub fn new() -> Self

Create a new SeqBytes

pub fn is_empty(&self) -> bool

Check if the sequence is empty

pub fn len(&self) -> usize

Get the number of slices in the sequence

pub fn reserve(&mut self, extra: usize)

Reserve capacity for more slices

pub fn shrink_to_fit(&mut self)

Shrink container to fit the current data

pub fn num_bytes(&self) -> usize

Get the sum of the lengths of the byte strings

pub fn get(&self, idx: usize) -> Option<&[u8]>

Get the i’th element of the sequence in a checked manner

pub fn get_mut(&mut self, idx: usize) -> Option<&mut [u8]>

Get the i’th element of the sequence in a checked manner

pub fn contains(&self, s: impl AsRef<[u8]>) -> bool

Check if the sequence contains a particular element

pub fn push(&mut self, s: impl AsRef<[u8]>)

Push a &u8 onto the sequence

pub fn last(&self) -> Option<&[u8]>

Get the last &u8 of the sequence

pub fn pop(&mut self)

Pop the last element of the container Note that we can’t return it because of lifetimes, so call [last] before popping.

pub fn iter(&self) -> SeqBytesIter<'_>

Iterate over the sequence of &u8

pub fn iter_mut(&mut self) -> SeqBytesIterMut<'_>

Iterate over the sequence of &mut u8

pub fn range(&self, range_bounds: impl RangeBounds<usize>) -> SeqBytesIter<'_>

Iterate over a range of the sequence of &[u8]

This resembles std::collections::BTreeMap::range, and is needed becuase like BTreeMap, we can’t implement Deref or SliceIndex<Range> and produce a slice of our contents. See also [as_vec].

pub fn range_mut( &mut self, range_bounds: impl RangeBounds<usize>, ) -> SeqBytesIterMut<'_>

Iterate over a range of the sequence of &mut [u8]

pub fn truncate(&mut self, new_size: usize)

Truncate to at most the first n slices

pub fn resize(&mut self, new_size: usize)

Resize to contain only the first n &[u8], or pad up to n slices, with empty slices added

pub fn retain(&mut self, pred: impl FnMut(&[u8]) -> bool)

Retain only those slices satisfying a predicate. The slices are always visited in order, similar to std::vec::Vec::retain.

pub fn retain_mut(&mut self, pred: impl FnMut(&mut [u8]) -> bool)

Retain only those slices satisfying a predicate. The slices are always visited in order, similar to std::vec::Vec::retain_mut.

pub fn in_place_writer(&mut self) -> impl Write

Get an impl std::io::Write which can be used to write the next slice directly into the buffer without copying.

pub fn in_place_writer_no_std(&mut self) -> impl FnMut(&[u8])

Version of in_place_writer that doesn’t require std::io::Write trait

Any bytes passed to the result of this function get concatenated to produce the newest byte string in the sequence. The new item is final when the writer is dropped.

pub fn as_vec(&self) -> Vec<&[u8]>

Express as a Vec<&u8>. The main reason that this may be useful is that there are useful methods on slice types &[&[u8]], for example, [core::slice::binary_search], but SeqBytes itself doesn’t implement Deref the way that Vec does and can only produce such a slice by allocating.

Note: The trade-offs are that we would need more memory and in_place_writer would have to be more complicated and slower if we wanted our internal representation of the offsets to be a Vec<&[u8]>, which would allow such a Deref implementation. The direction we’ve taken is to add useful functions from Vec and slice as needed directly to this type instead, if they can’t be obtained in a simpler way.

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

Concatenate the &[u8] in the sequence into one &[u8]

Trait Implementations

impl Clone for SeqBytes

fn clone(&self) -> SeqBytes

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SeqBytes

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

Formats the value using the given formatter.

impl Default for SeqBytes

fn default() -> SeqBytes

Returns the “default value” for a type.

impl<A: AsRef<[u8]>> Extend<A> for SeqBytes

fn extend<T>(&mut self, iter: T)

where T: IntoIterator<Item = A>,

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

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

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

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

Reserves capacity in a collection for the given number of additional elements.

impl<A: AsRef<[u8]>> FromIterator<A> for SeqBytes

fn from_iter<T>(iter: T) -> Self

where T: IntoIterator<Item = A>,

Creates a value from an iterator.

impl Hash for SeqBytes

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

Feeds this value into the given Hasher.

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

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Index<usize> for SeqBytes

type Output = [u8]

The returned type after indexing.

fn index(&self, index: usize) -> &[u8]

Performs the indexing (container[index]) operation.

impl IndexMut<usize> for SeqBytes

fn index_mut(&mut self, index: usize) -> &mut [u8]

Performs the mutable indexing (container[index]) operation.

impl<'a> IntoIterator for &'a SeqBytes

type Item = &'a [u8]

The type of the elements being iterated over.

type IntoIter = SeqBytesIter<'a>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl PartialEq for SeqBytes

fn eq(&self, other: &SeqBytes) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl Eq for SeqBytes

impl StructuralPartialEq for SeqBytes