Struct radix_trie::NibbleVec

pub struct NibbleVec<A>
where
    A: Array<Item = u8>,
{ /* private fields */ }

A data-structure for storing a sequence of 4-bit values.

Values are stored in a Vec<u8>, with two values per byte.

Values at even indices are stored in the most-significant half of their byte, while values at odd indices are stored in the least-significant half.

Imagine a vector of MSB first bytes, and you’ll be right.

n = [_ _ | _ _ | _ _]

Implementations

impl<A> NibbleVec<A>

where A: Array<Item = u8>,

pub fn new() -> NibbleVec<A>

Create an empty nibble vector.

pub fn from_byte_vec(vec: Vec<u8>) -> NibbleVec<A>

Create a nibble vector from a vector of bytes.

Each byte is split into two 4-bit entries (MSB, LSB).

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

Returns a byte slice of the nibble vector’s contents.

pub fn into_bytes(self) -> Vec<u8>

Converts a nibble vector into a byte vector.

This consumes the nibble vector, so we do not need to copy its contents.

pub fn len(&self) -> usize

Get the number of elements stored in the vector.

pub fn is_empty(&self) -> bool

Returns true if the nibble vector has a length of 0.

pub fn get(&self, idx: usize) -> u8

Fetch a single entry from the vector.

Guaranteed to be a value in the interval [0, 15].

Panics if idx >= self.len().

pub fn push(&mut self, val: u8)

Add a single nibble to the vector.

Only the 4 least-significant bits of the value are used.

pub fn split(&mut self, idx: usize) -> NibbleVec<A>

Split the vector into two parts.

All elements at or following the given index are returned in a new NibbleVec, with exactly idx elements remaining in this vector.

Panics if idx > self.len().

pub fn join(self, other: &NibbleVec<A>) -> NibbleVec<A>

Append another nibble vector whilst consuming this vector.

Trait Implementations

impl<A> Clone for NibbleVec<A>

where A: Clone + Array<Item = u8>,

fn clone(&self) -> NibbleVec<A>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<A> Debug for NibbleVec<A>

where A: Array<Item = u8>,

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

Formats the value using the given formatter.

impl<A> Default for NibbleVec<A>

where A: Default + Array<Item = u8>,

fn default() -> NibbleVec<A>

Returns the “default value” for a type.

impl<'a, A> From<&'a [u8]> for NibbleVec<A>

where A: Array<Item = u8>,

fn from(v: &[u8]) -> NibbleVec<A>

Converts to this type from the input type.

impl<A> From<Vec<u8>> for NibbleVec<A>

where A: Array<Item = u8>,

fn from(v: Vec<u8>) -> NibbleVec<A>

Converts to this type from the input type.

impl<'a, A> Into<Vec<u8>> for &'a NibbleVec<A>

where A: Array<Item = u8>,

fn into(self) -> Vec<u8>

Converts this type into the (usually inferred) input type.

impl<A> Into<Vec<u8>> for NibbleVec<A>

where A: Array<Item = u8>,

fn into(self) -> Vec<u8>

Converts this type into the (usually inferred) input type.

impl<A> PartialEq<[u8]> for NibbleVec<A>

where A: Array<Item = u8>,

Compare a NibbleVec and a slice of bytes element-by-element. Bytes are not interpreted as two NibbleVec entries.

fn eq(&self, other: &[u8]) -> 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<A> PartialEq for NibbleVec<A>

where A: Array<Item = u8>,

fn eq(&self, other: &NibbleVec<A>) -> 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<A> Eq for NibbleVec<A>

where A: Array<Item = u8>,