Struct Records

pub struct Records<B, R: RecordsImplLayout> { /* private fields */ }

A parsed sequence of records.

Records represents a pre-parsed sequence of records whose structure is enforced by the impl in R.

Implementations

impl<B, R> Records<B, R>

where B: SplitByteSlice, R: RecordsImpl,

pub fn parse_with_context( bytes: B, context: R::Context, ) -> Result<Records<B, R>, R::Error>

Parses a sequence of records with a context.

See parse_with_mut_context for details on bytes, context, and return value. parse_with_context just calls parse_with_mut_context with a mutable reference to the context which is passed by value to this function.

pub fn parse_with_mut_context( bytes: B, context: &mut R::Context, ) -> Result<Records<B, R>, R::Error>

Parses a sequence of records with a mutable context.

context may be used by implementers to maintain state while parsing multiple records.

parse_with_mut_context performs a single pass over all of the records to verify that they are well-formed. Once parse_with_context returns successfully, the resulting Records can be used to construct infallible iterators.

impl<B, R> Records<B, R>

where B: SplitByteSlice, R: RecordsImpl<Context = ()>,

pub fn parse(bytes: B) -> Result<Records<B, R>, R::Error>

Parses a sequence of records.

Equivalent to calling parse_with_context with context = ().

impl<B: Deref<Target = [u8]>, R> Records<B, R>

where R: RecordsImpl,

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

Gets the underlying bytes.

bytes returns a reference to the byte slice backing this Records.

impl<B, R> Records<B, R>

where B: ByteSlice, R: RecordsImpl,

pub fn as_ref(&self) -> Records<&[u8], R>

Returns the same records but coerces the backing B type to &[u8].

impl<'a, B, R> Records<B, R>

where B: 'a + SplitByteSlice, R: RecordsImpl,

pub fn iter(&'a self) -> RecordsIter<'a, &'a [u8], R>

Iterates over options.

Since the records were validated in parse, then so long as R::parse_with_context is deterministic, the iterator is infallible.

pub fn iter_bytes(&'a self) -> RecordsBytesIter<'a, &'a [u8], R>

Iterates over byte slices corresponding to options.

Since the records were validated in parse, then so long as R::parse_with_context is deterministic, the iterator is infallible. Unrecognized record types will still be included as long as they don’t fail length validation, even if they would be skipped by the RecordsIter returned by Records::iter.

impl<'a, B, R> Records<B, R>

where B: SplitByteSlice + IntoByteSlice<'a>, R: RecordsImpl,

pub fn into_iter(self) -> RecordsIter<'a, B, R>

Iterates over options.

Since the records were validated in parse, then so long as R::parse_with_context is deterministic, the iterator is infallible.

Trait Implementations

impl<B: Debug, R: Debug + RecordsImplLayout> Debug for Records<B, R>

where R::Context: Debug,

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

Formats the value using the given formatter.

impl<B, R> FromRaw<RecordsRaw<B, R>, ()> for Records<B, R>

where R: RecordsImpl, B: SplitByteSlice,

type Error = <R as RecordsImplLayout>::Error

The type of error that may happen during validation.

fn try_from_raw_with(raw: RecordsRaw<B, R>, _args: ()) -> Result<Self, R::Error>

Attempts to create Self from the raw form in raw with args.

fn try_from_raw(raw: R) -> Result<Self, <Self as FromRaw<R, A>>::Error>

where Self: FromRaw<R, (), Error = <Self as FromRaw<R, A>>::Error>,

Attempts to create Self from the raw form in raw.

impl<B: PartialEq, R: PartialEq + RecordsImplLayout> PartialEq for Records<B, R>

where R::Context: PartialEq,

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