Struct nom8::input::Located

pub struct Located<I> { /* private fields */ }

Allow collecting the span of a parsed token

See Parser::span and Parser::with_span for more details

Implementations

impl<I> Located<I>where
    I: Clone + IntoOutput + Offset,

pub fn new(input: I) -> Self

Wrap another Input with span tracking

Trait Implementations

impl<I> AsBytes for Located<I>where
    I: AsBytes,

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

Casts the input type to a byte slice

impl<I> AsRef<I> for Located<I>

fn as_ref(&self) -> &I

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

impl<I: Clone> Clone for Located<I>

fn clone(&self) -> Located<I>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<I, U> Compare<U> for Located<I>where
    I: Compare<U>,

fn compare(&self, other: U) -> CompareResult

Compares self to another value for equality

fn compare_no_case(&self, other: U) -> CompareResult

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

impl<I: Debug> Debug for Located<I>

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

Formats the value using the given formatter.

impl<I: Default> Default for Located<I>

fn default() -> Located<I>

Returns the “default value” for a type.

impl<I> Deref for Located<I>

type Target = I

The resulting type after dereferencing.

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

Dereferences the value.

impl<I> ExtendInto for Located<I>where
    I: ExtendInto,

type Item = <I as ExtendInto>::Item

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

type Extender = <I as ExtendInto>::Extender

The type that will be produced

fn new_builder(&self) -> Self::Extender

Create a new Extend of the correct type

fn extend_into(&self, extender: &mut Self::Extender)

Accumulate the input into an accumulator

impl<I, T> FindSubstring<T> for Located<I>where
    I: FindSubstring<T>,

fn find_substring(&self, substr: T) -> Option<usize>

Returns the byte position of the substring if it is found

impl<I> HexDisplay for Located<I>where
    I: HexDisplay,

fn to_hex(&self, chunk_size: usize) -> String

Converts the value of self to a hex dump, returning the owned String.

fn to_hex_from(&self, chunk_size: usize, from: usize) -> String

Converts the value of self to a hex dump beginning at from address, returning the owned String.

impl<I> InputIsStreaming<false> for Located<I>where
    I: InputIsStreaming<false>,

type Complete = Located<I>

Complete counterpart

type Streaming = Located<<I as InputIsStreaming<false>>::Streaming>

Streaming counterpart

fn into_complete(self) -> Self::Complete

Convert to complete counterpart

fn into_streaming(self) -> Self::Streaming

Convert to streaming counterpart

impl<I> InputIsStreaming<true> for Located<I>where
    I: InputIsStreaming<true>,

type Complete = Located<<I as InputIsStreaming<true>>::Complete>

Complete counterpart

type Streaming = Located<I>

Streaming counterpart

fn into_complete(self) -> Self::Complete

Convert to complete counterpart

fn into_streaming(self) -> Self::Streaming

Convert to streaming counterpart

impl<I> InputIter for Located<I>where
    I: InputIter,

type Item = <I as InputIter>::Item

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

type Iter = <I 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 = <I 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<I> InputLength for Located<I>where
    I: InputLength,

fn input_len(&self) -> usize

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

impl<I> InputTake for Located<I>where
    I: InputTake + Clone,

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<I> InputTakeAtPosition for Located<I>where
    I: InputTakeAtPosition + Clone,

type Item = <I as InputTakeAtPosition>::Item

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

fn split_at_position_complete<P, E>(
    &self,
    predicate: P
) -> IResult<Self, Self, E>where
    P: Fn(Self::Item) -> bool,
    E: ParseError<Self>,

Looks for the first element of the input type for which the condition returns true, and returns the input up to this position.

fn split_at_position_streaming<P, E>(
    &self,
    predicate: P
) -> IResult<Self, Self, E>where
    P: Fn(Self::Item) -> bool,
    E: ParseError<Self>,

Looks for the first element of the input type for which the condition returns true, and returns the input up to this position.

fn split_at_position1_streaming<P, E>(
    &self,
    predicate: P,
    kind: ErrorKind
) -> IResult<Self, Self, E>where
    P: Fn(Self::Item) -> bool,
    E: ParseError<Self>,

Looks for the first element of the input type for which the condition returns true and returns the input up to this position.

fn split_at_position1_complete<P, E>(
    &self,
    predicate: P,
    kind: ErrorKind
) -> IResult<Self, Self, E>where
    P: Fn(Self::Item) -> bool,
    E: ParseError<Self>,

Looks for the first element of the input type for which the condition returns true and returns the input up to this position.

impl<I> IntoOutput for Located<I>where
    I: IntoOutput,

type Output = <I as IntoOutput>::Output

Output type

fn into_output(self) -> Self::Output

Convert an Input into an appropriate Output type

fn merge_output(self, inner: Self::Output) -> Self

Convert an Output type to be used as Input

impl<I> Location for Located<I>where
    I: Clone + IntoOutput + Offset,

fn location(&self) -> usize

Number of indices input has advanced since start of parsing

impl<I> Offset for Located<I>where
    I: Offset,

fn offset(&self, other: &Self) -> usize

Offset between the first byte of self and the first byte of the argument

impl<I: Ord> Ord for Located<I>

fn cmp(&self, other: &Located<I>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere
    Self: PartialOrd<Self>,

Restrict a value to a certain interval.

impl<I, R> ParseTo<R> for Located<I>where
    I: ParseTo<R>,

fn parse_to(&self) -> Option<R>

Succeeds if parse() succeeded. The byte slice implementation will first convert it to a &str, then apply the parse() function

impl<I: PartialEq> PartialEq<Located<I>> for Located<I>

fn eq(&self, other: &Located<I>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<I: PartialOrd> PartialOrd<Located<I>> for Located<I>

fn partial_cmp(&self, other: &Located<I>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<I, R> Slice<R> for Located<I>where
    I: Slice<R> + Clone,

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

Slices self according to the range argument

impl<I: Copy> Copy for Located<I>

impl<I: Eq> Eq for Located<I>

impl<I> StructuralEq for Located<I>

impl<I> StructuralPartialEq for Located<I>