Struct BinarySpan

pub struct BinarySpan<T> { /* private fields */ }

Cloned from the crate nom_locate but with the omission of computing the line & column number since we don’t care about them in binary protocols, and they do make using the LocateSpan slower.

Implementations

impl<T> BinarySpan<T>

pub const fn new(buffer: T) -> Self

pub const unsafe fn new_from_raw_offset(offset: usize, fragment: T) -> Self

Similar to new_extra, but allows overriding offset.

Safety

This is unsafe, because giving an offset too large may result in undefined behavior, as some methods move back along the fragment assuming any negative index within the offset is valid.

pub const fn new_extra(program: T) -> BinarySpan<T>

pub const fn location_offset(&self) -> usize

pub const fn fragment(&self) -> &T

Trait Implementations

impl<T: AsBytes> AsBytes for BinarySpan<T>

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

Casts the input type to a byte slice

impl<T, U> AsRef<U> for BinarySpan<&T>

where T: ?Sized + AsRef<U>, U: ?Sized,

fn as_ref(&self) -> &U

Converts this type into a shared reference of the (usually inferred) input type.

impl<T: Clone> Clone for BinarySpan<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<A: Compare<B>, B: Into<BinarySpan<B>>> Compare<B> for BinarySpan<A>

fn compare(&self, t: B) -> CompareResult

Compares self to another value for equality

fn compare_no_case(&self, t: B) -> CompareResult

Compares self to another value for equality independently of the case.

impl<T: Debug> Debug for BinarySpan<T>

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

Formats the value using the given formatter.

impl<T> Deref for BinarySpan<T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T: AsBytes> From<T> for BinarySpan<T>

fn from(i: T) -> Self

Converts to this type from the input type.

impl<T> InputIter for BinarySpan<T>

where T: InputIter,

type Item = <T as InputIter>::Item

The current input type is a sequence of that Item type.

type Iter = <T as InputIter>::Iter

An iterator over the input type, producing the item and its position for use with Slice. If we’re iterating over &str, the position corresponds to the byte index of the character

type IterElem = <T as InputIter>::IterElem

An iterator over the input type, producing the item

fn iter_indices(&self) -> Self::Iter

Returns an iterator over the elements and their byte offsets

fn iter_elements(&self) -> Self::IterElem

Returns an iterator over the elements

fn position<P>(&self, predicate: P) -> Option<usize>

where P: Fn(Self::Item) -> bool,

Finds the byte position of the element

fn slice_index(&self, count: usize) -> Result<usize, Needed>

Get the byte offset from the element’s position in the stream

impl<T: InputLength> InputLength for BinarySpan<T>

fn input_len(&self) -> usize

Calculates the input length, as indicated by its name, and the name of the trait itself

impl<T> InputTake for BinarySpan<T>

where Self: Slice<RangeFrom<usize>> + Slice<RangeTo<usize>>,

fn take(&self, count: usize) -> Self

Returns a slice of count bytes. panics if count > length

fn take_split(&self, count: usize) -> (Self, Self)

Split the stream at the count byte offset. panics if count > length

impl<T: AsBytes + PartialEq> PartialEq for BinarySpan<T>

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<T, R> Slice<R> for BinarySpan<T>

where T: Slice<R> + Offset + AsBytes + Slice<RangeTo<usize>>,

fn slice(&self, range: R) -> Self

Slices self according to the range argument

impl<T: Copy> Copy for BinarySpan<T>

impl<T: AsBytes + Eq> Eq for BinarySpan<T>