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<'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.

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>