Enum Packed4Cow 

pub enum Packed4Cow<'a, T>
where
    T: Packable4,
{
    Borrowed(Packed4Slice<'a, T>),
    Owned(Packed4Vec<T>),
}

A Clone-on-Write (CoW) container for packed 4-bit elements.

Promotes zero-copy operations by borrowing packed byte buffers as read-only Packed4Slices, only upgrading to an owned Packed4Vec when mutation is requested.

Variants

Borrowed(Packed4Slice<'a, T>)

Borrowed read-only packed slice view.

Owned(Packed4Vec<T>)

Owned packed vector.

Implementations

impl<'a, T> Packed4Cow<'a, T>

where T: Packable4,

pub fn borrowed(view: Packed4Slice<'a, T>) -> Packed4Cow<'a, T>

Creates a borrowed Packed4Cow wrapping a Packed4Slice.

pub fn owned(vec: Packed4Vec<T>) -> Packed4Cow<'a, T>

Creates an owned Packed4Cow wrapping a Packed4Vec.

pub fn is_borrowed(&self) -> bool

Returns true when this container is borrowing caller-owned packed bytes.

pub fn is_owned(&self) -> bool

Returns true when this container owns its packed byte storage.

pub fn from_packed_slice( data: &'a [u8], len: usize, ) -> Option<Packed4Cow<'a, T>>

Creates a borrowed Packed4Cow from a byte slice and logical length. Returns None if the byte slice is too small for the requested length.

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

Obtains a read-only view of the packed slice.

pub fn len(&self) -> usize

Returns the logical length (number of 4-bit elements).

pub fn is_empty(&self) -> bool

Returns true if empty.

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

Get an element at the given logical index.

pub fn to_mut(&mut self) -> &mut Packed4Vec<T>

Upgrades the container to the Owned variant and returns a mutable reference to the underlying Packed4Vec. Subsequent calls are free (no reallocation).

pub fn into_owned(self) -> Packed4Vec<T>

Convert into the owned Packed4Vec type, allocating if borrowed.

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

Sets an element at the given logical index, upgrading to owned if currently borrowed.

pub fn sub_slice(&self, range: Range<usize>) -> Option<Packed4Cow<'_, T>>

Attempts to create a zero-copy sub-slice of the packed Clone-on-Write container.

Returns Some(Packed4Cow::Borrowed) if the sub-slice range starts at an even logical index (aligned to byte boundaries), otherwise returns None.

Trait Implementations

impl<T> Archive for Packed4Cow<'_, T>

where T: Packable4,

type Archived = ArchivedPacked4Cow<T>

The archived representation of this type.

type Resolver = Packed4CowResolver

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

fn resolve( &self, resolver: <Packed4Cow<'_, T> as Archive>::Resolver, out: Place<<Packed4Cow<'_, T> as Archive>::Archived>, )

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

const COPY_OPTIMIZATION: CopyOptimization<Self> = _

An optimization flag that allows the bytes of this type to be copied directly to a writer instead of calling serialize.

impl<'a, T> Clone for Packed4Cow<'a, T>

where T: Clone + Packable4,

fn clone(&self) -> Packed4Cow<'a, T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a, T> Debug for Packed4Cow<'a, T>

where T: Debug + Packable4,

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

Formats the value using the given formatter.

impl<T> Default for Packed4Cow<'static, T>

where T: Packable4,

fn default() -> Packed4Cow<'static, T>

Returns the “default value” for a type.

impl<T, D> Deserialize<Packed4Cow<'static, T>, D> for ArchivedPacked4Cow<T>

where T: Packable4, D: Fallible + ?Sized,

fn deserialize( &self, _deserializer: &mut D, ) -> Result<Packed4Cow<'static, T>, <D as Fallible>::Error>

Deserializes using the given deserializer

impl<'a, T> Eq for Packed4Cow<'a, T>

where T: Eq + Packable4,

impl<'a, T> IntoIterator for &'a Packed4Cow<'a, T>

where T: Packable4,

type Item = T

The type of the elements being iterated over.

type IntoIter = Packed4Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <&'a Packed4Cow<'a, T> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T> IntoIterator for Packed4Cow<'a, T>

where T: Packable4,

type Item = T

The type of the elements being iterated over.

type IntoIter = Packed4CowIntoIter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <Packed4Cow<'a, T> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T: Packable4> Packed4CowExt<'a, T> for Packed4Cow<'a, T>

fn unpack_to_cow<Arch, Align>( &self, ) -> SimdCow<'static, T::Unpacked, Arch, Align>

where Arch: SimdArch, Align: Alignment,

Unpack packed elements directly to a SimdCow of wider precision with zero intermediate allocations.

impl<'a, T> PartialEq for Packed4Cow<'a, T>

where T: PartialEq + Packable4,

fn eq(&self, other: &Packed4Cow<'a, T>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<T, S> Serialize<S> for Packed4Cow<'_, T>

where T: Packable4, S: Fallible + Allocator + Writer + ?Sized,

fn serialize( &self, serializer: &mut S, ) -> Result<<Packed4Cow<'_, 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<'a, T> StructuralPartialEq for Packed4Cow<'a, T>

where T: PartialEq + Packable4,