Struct Packed4Vec 

pub struct Packed4Vec<T>
where
    T: Packable4,
{ /* private fields */ }

A heap-allocated packed vector of 4-bit values, stored 2 per byte.

Implementations

impl<T> Packed4Vec<T>

where T: Packable4,

pub fn new() -> Packed4Vec<T>

Create a new empty Packed4Vec.

pub fn with_capacity(capacity: usize) -> Packed4Vec<T>

Create a new Packed4Vec with the given capacity.

pub fn len(&self) -> usize

Returns the logical length.

pub fn is_empty(&self) -> bool

Returns true if empty.

pub fn clear(&mut self)

Clear the vector.

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

Push an element to the back of the vector.

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

Get an element at index.

pub fn set(&mut self, index: usize, val: T)

Set an element at index.

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

Access the underlying packed bytes.

pub fn as_packed_slice_mut(&mut self) -> &mut [u8]

Access the underlying packed bytes mutably.

pub fn as_view(&self) -> Packed4Slice<'_, T>

Convert to a Packed4Slice view.

pub fn as_view_mut(&mut self) -> Packed4SliceMut<'_, T>

Convert to a Packed4SliceMut view.

Trait Implementations

impl<T> Archive for Packed4Vec<T>

where T: Packable4,

type Archived = ArchivedPacked4Vec<T>

The archived representation of this type.

type Resolver = Packed4VecResolver

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

unsafe fn resolve( &self, pos: usize, resolver: <Packed4Vec<T> as Archive>::Resolver, out: *mut <Packed4Vec<T> as Archive>::Archived, )

Creates the archived version of this value at the given position and writes it to the given output.

impl<T> Clone for Packed4Vec<T>

where T: Clone + Packable4,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for Packed4Vec<T>

where T: Debug + Packable4,

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

Formats the value using the given formatter.

impl<T> Default for Packed4Vec<T>

where T: Packable4,

fn default() -> Packed4Vec<T>

Returns the “default value” for a type.

impl<T> Eq for Packed4Vec<T>

where T: Eq + Packable4,

impl<T> Extend<T> for Packed4Vec<T>

where T: Packable4,

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

where I: IntoIterator<Item = T>,

Extend the vector from any iterator yielding T.

Uses size_hint to pre-allocate the backing byte storage before pushing, avoiding per-element reallocation when the iterator advertises a lower bound.

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<T> FromIterator<T> for Packed4Vec<T>

where T: Packable4,

fn from_iter<I>(iter: I) -> Packed4Vec<T>

where I: IntoIterator<Item = T>,

Collect any iterator of T into a Packed4Vec<T>.

Uses the iterator’s size_hint to reserve byte capacity before collecting, so a tight upper bound eliminates all but one allocation.

impl<T> IntoIterator for Packed4Vec<T>

where T: Packable4,

type Item = T

The type of the elements being iterated over.

type IntoIter = Packed4OwnedIter<T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <Packed4Vec<T> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<T> PartialEq for Packed4Vec<T>

where T: PartialEq + Packable4,

fn eq(&self, other: &Packed4Vec<T>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<T, S> Serialize<S> for Packed4Vec<T>

where T: Packable4, S: Fallible + Serializer + ScratchSpace + ?Sized,

fn serialize( &self, serializer: &mut S, ) -> Result<<Packed4Vec<T> as Archive>::Resolver, <S as Fallible>::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.

impl<T> StructuralPartialEq for Packed4Vec<T>

where T: PartialEq + Packable4,