Struct ByValue

pub struct ByValue<T: AsRef<[u8]>>(/* private fields */);

A ParseStrategy that produces (copied/cloned) T.

This strategy makes up to one copy of the parser input (in addition to parser output data structures). It is intended to support use cases where the parser input and parser output must be retained outside the lexical from which parsing is invoked. For example:

fn do_by_value<
    D: AsRef<[u8]> + Debug + PartialEq,
    T: zerocopy::FromBytes + zerocopy::Unaligned,
>(
    data: D,
) -> (T, ByValue<D>) {
    let parser = ByValue::new(data);
    parser.parse::<T>().unwrap()
}

Implementations

impl<T: AsRef<[u8]>> ByValue<T>

pub fn new(data: T) -> Self

Returns a new ByValue that wraps data in a Cursor for parsing.

Trait Implementations

impl<T: Clone + AsRef<[u8]>> Clone for ByValue<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug + AsRef<[u8]>> Debug for ByValue<T>

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

Formats the value using the given formatter.

impl<T: AsRef<[u8]> + Debug + PartialEq> ParseStrategy for ByValue<T>

where Cursor<T>: Debug + ParseCursor + PartialEq,

fn parse<P: Clone + Debug + FromBytes + KnownLayout + Immutable + PartialEq + Unaligned>( self, ) -> Option<(Self::Output<P>, Self)>

Returns an P as the parsed output of the next bytes in the underlying Cursor data.

fn parse_slice<PS: Clone + Debug + FromBytes + Immutable + PartialEq + Unaligned>( self, count: usize, ) -> Option<(Self::Slice<PS>, Self)>

Returns a Vec<T> of count items as the parsed output of the next bytes in the underlying Cursor data.

type Input = T

Type of input supported by this ParseStrategy.

type Output<O: Debug + FromBytes + KnownLayout + Immutable + PartialEq + Unaligned> = O

Type of successfully parsed output from Self::parse().

type Slice<S: Debug + FromBytes + Immutable + PartialEq + Unaligned> = Vec<S>

Type of successfully parsed output from Self::parse_slice().

fn deref<'a, D: Debug + FromBytes + KnownLayout + Immutable + PartialEq + Unaligned>( output: &'a Self::Output<D>, ) -> &'a D

Dereferences borrow of Self::Output<T> as borrow of T.

fn deref_slice<'a, DS: Debug + FromBytes + Immutable + PartialEq + Unaligned>( slice: &'a Self::Slice<DS>, ) -> &'a [DS]

Dereferences borrow of Self::Slice<T> as borrow of [T].

fn len(&self) -> usize

Returns the number of bytes remaining to be parsed by this ParseStrategy.

fn into_inner(self) -> Self::Input

Returns the complete parse input being consumed by this strategy.

impl<T: PartialEq + AsRef<[u8]>> PartialEq for ByValue<T>

fn eq(&self, other: &ByValue<T>) -> 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<T: AsRef<[u8]>> StructuralPartialEq for ByValue<T>