Struct VarZeroCow 

pub struct VarZeroCow<'a, V: ?Sized> { /* private fields */ }

Copy-on-write type that efficiently represents VarULE types as their bitstream representation.

The primary use case for VarULE types is the ability to store complex variable-length datastructures inside variable-length collections like crate::VarZeroVec.

Underlying this ability is the fact that VarULE types can be efficiently represented as a flat bytestream.

In zero-copy cases, sometimes one wishes to unconditionally use this bytestream representation, for example to save stack size. A struct with five Cow<'a, str>s is not as stack-efficient as a single Cow containing the bytestream representation of, say, Tuple5VarULE<str, str, str, str, str>.

This type helps in this case: It is logically a Cow<'a, V>, with some optimizations, that is guaranteed to serialize as a byte stream in machine-readable scenarios.

During human-readable serialization, it will fall back to the serde impls on V, which ought to have a human-readable variant.

Implementations

impl<'a, V: VarULE + ?Sized> VarZeroCow<'a, V>

pub fn parse_bytes(bytes: &'a [u8]) -> Result<Self, UleError>

Construct from a slice. Errors if the slice doesn’t represent a valid V

pub fn parse_owned_bytes(bytes: Box<[u8]>) -> Result<Self, UleError>

Construct from an owned slice. Errors if the slice doesn’t represent a valid V

pub const unsafe fn from_bytes_unchecked(bytes: &'a [u8]) -> Self

Construct from a slice that is known to represent a valid V

Safety

bytes must be a valid V, i.e. it must successfully pass through V::parse_bytes() or V::validate_bytes().

pub fn from_encodeable<E: EncodeAsVarULE<V>>(encodeable: &E) -> Self

Construct this from an EncodeAsVarULE version of the contained type

Will always construct an owned version

pub fn new_borrowed(val: &'a V) -> Self

Construct a new borrowed version of this

pub fn new_owned(val: Box<V>) -> Self

Construct a new borrowed version of this

impl<'a, V: ?Sized> VarZeroCow<'a, V>

pub fn is_owned(&self) -> bool

Whether or not this is owned

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

Get the byte representation of this type

Is also always a valid V and can be passed to V::from_bytes_unchecked()

Trait Implementations

impl<'a, V: ?Sized> Clone for VarZeroCow<'a, V>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a, V: VarULE + ?Sized + Debug> Debug for VarZeroCow<'a, V>

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

Formats the value using the given formatter.

impl<'a, V: VarULE + ?Sized> Deref for VarZeroCow<'a, V>

type Target = V

The resulting type after dereferencing.

fn deref(&self) -> &V

Dereferences the value.

impl<'a, V: VarULE + ?Sized> EncodeAsVarULE<V> for VarZeroCow<'a, V>

fn encode_var_ule_as_slices<R>(&self, _: impl FnOnce(&[&[u8]]) -> R) -> R

Calls cb with a piecewise list of byte slices that when concatenated produce the memory pattern of the corresponding instance of T.

fn encode_var_ule_len(&self) -> usize

Return the length, in bytes, of the corresponding VarULE type

fn encode_var_ule_write(&self, dst: &mut [u8])

Write the corresponding VarULE type to the dst buffer. dst should be the size of Self::encode_var_ule_len()

impl<'a, V: VarULE + ?Sized> From<&'a V> for VarZeroCow<'a, V>

fn from(other: &'a V) -> Self

Converts to this type from the input type.

impl<'a, V: VarULE + ?Sized> From<Box<V>> for VarZeroCow<'a, V>

fn from(other: Box<V>) -> Self

Converts to this type from the input type.

impl<'a, V: VarULE + ?Sized + Ord> Ord for VarZeroCow<'a, V>

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<'a, V: VarULE + ?Sized + PartialEq> PartialEq for VarZeroCow<'a, V>

fn eq(&self, other: &Self) -> 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, V: VarULE + ?Sized + PartialOrd> PartialOrd for VarZeroCow<'a, V>

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

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<'a, T: 'static + ?Sized> Yokeable<'a> for VarZeroCow<'static, T>

This impl requires enabling the optional yoke Cargo feature of the zerovec crate

type Output = VarZeroCow<'a, T>

This type MUST be Self with the 'static replaced with 'a, i.e. Self<'a>

fn transform(&'a self) -> &'a Self::Output

This method must cast self between &'a Self<'static> and &'a Self<'a>.

fn transform_owned(self) -> Self::Output

This method must cast self between Self<'static> and Self<'a>.

unsafe fn make(from: Self::Output) -> Self

This method can be used to cast away Self<'a>’s lifetime.

fn transform_mut<F>(&'a mut self, f: F)

where F: 'static + for<'b> FnOnce(&'b mut Self::Output),

This method must cast self between &'a mut Self<'static> and &'a mut Self<'a>, and pass it to f.

impl<'a, V: VarULE + ?Sized> ZeroFrom<'a, V> for VarZeroCow<'a, V>

fn zero_from(other: &'a V) -> Self

Clone the other C into a struct that may retain references into C.

impl<'a, 'b, V: VarULE + ?Sized> ZeroFrom<'a, VarZeroCow<'b, V>> for VarZeroCow<'a, V>

fn zero_from(other: &'a VarZeroCow<'b, V>) -> Self

Clone the other C into a struct that may retain references into C.

impl<'a, V: VarULE + ?Sized + Eq> Eq for VarZeroCow<'a, V>

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 24 bytes