Struct ByRef

pub struct ByRef<B: SplitByteSlice> { /* private fields */ }

A ParseStrategy that produces [Ref<B, T>].

This strategy is zero-copy, but one consequence is that the parser input and output cannot be retained outside the lexical scope from which the parser input was borrowed. For example, the following will not compile:

fn do_by_ref<'a, T: zerocopy::FromBytes + zerocopy::Unaligned>() -> (
    zerocopy::Ref<&'a [u8], T>, ByRef<&'a [u8]>,
) {
    let bytes: Vec<u8> = // ...
    let parser = ByRef::new(bytes.as_slice());
    parser.parse::<T>().unwrap()
}

The above code induces the following error:

error[E0515]: cannot return value referencing local variable `bytes`

Implementations

impl<B: SplitByteSlice + Clone> ByRef<B>

pub fn new(byte_slice: B) -> Self

Returns a new ByRef that wraps bytes_slice.

Trait Implementations

impl<B: Clone + SplitByteSlice> Clone for ByRef<B>

fn clone(&self) -> ByRef<B>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<B: Debug + SplitByteSlice> Debug for ByRef<B>

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

Formats the value using the given formatter.

impl<B: Debug + SplitByteSlice + PartialEq, T: Clone + Debug + FromBytes + KnownLayout + Immutable + PartialEq + Unaligned> Parse<ByRef<B>> for Ref<B, T>

type Error = Error

The type of error that may be returned from parse(), usually ParseError or anyhow::Error.

fn parse(bytes: ByRef<B>) -> Result<(Self, ByRef<B>), Self::Error>

Parses a Self from bytes, returning the Self and trailing bytes, or an error if bytes corresponding to a Self are malformed.

impl<B: Debug + SplitByteSlice + PartialEq> ParseStrategy for ByRef<B>

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

Returns a [Ref<B, T>] as the parsed output of the next bytes in the underlying [ByteSlice].

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

Returns a Ref<B, [T]> as the parsed output of the next bytes in the underlying [ByteSlice].

type Input = B

Type of input supported by this ParseStrategy.

type Output<T: Debug + FromBytes + KnownLayout + Immutable + PartialEq + Unaligned> = Ref<B, T>

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

type Slice<T: Debug + FromBytes + Immutable + PartialEq + Unaligned> = Ref<B, [T]>

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

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

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

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

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<B: PartialEq + SplitByteSlice> PartialEq for ByRef<B>

fn eq(&self, other: &ByRef<B>) -> 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<B: SplitByteSlice> StructuralPartialEq for ByRef<B>