Struct ruby_parser::TrackedLocation

pub struct TrackedLocation<T, X> {
    pub metadata: X,
    // some fields omitted
}

Tracks location information and user-defined metadata for nom's source input.

Fields

metadata: X

Any user-defined metadata that should be tracked in addition to the location

Implementations

impl<T: AsBytes, X> TrackedLocation<T, X>

pub fn new_with_metadata(program: T, metadata: X) -> Self

pub fn offset(&self) -> usize

pub fn line(&self) -> usize

pub fn char(&self) -> usize

pub fn input(&self) -> &T

pub fn metadata(&self) -> &X

pub fn beginning_of_line(&self) -> bool

impl<T: AsBytes, X: Default> TrackedLocation<T, X>

pub fn new(program: T) -> Self

pub fn new_with_pos(program: T, offset: usize, line: usize, char: usize) -> Self

impl<T: AsBytes, X> TrackedLocation<T, X>

pub fn new_with_pos_and_meta(
    program: T,
    offset: usize,
    line: usize,
    char: usize,
    metadata: X
) -> Self

Trait Implementations

impl<T: AsBytes, X> AsBytes for TrackedLocation<T, X>

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

casts the input type to a byte slice

impl<T: Clone, X: Clone> Clone for TrackedLocation<T, X>

fn clone(&self) -> TrackedLocation<T, X>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a, A: Compare<B>, B: Into<TrackedLocation<B, X>>, X> Compare<B> for TrackedLocation<A, X>

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

compares self to another value for equality

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

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

impl<T: Debug, X: Debug> Debug for TrackedLocation<T, X>

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

Formats the value using the given formatter.

impl<T, X> Deref for TrackedLocation<T, X>

type Target = T

The resulting type after dereferencing.

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

Dereferences the value.

impl<T: ToString, X> Display for TrackedLocation<T, X>

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

Formats the value using the given formatter.

impl<T: Eq, X> Eq for TrackedLocation<T, X>

impl<'a, I, E, T, X> ExtendInto for TrackedLocation<T, X> where
    E: Default + Extend<I>,
    T: ExtendInto<Item = I, Extender = E>,
    Self: Clone + IntoIterator<Item = I>, 

type Item = I

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

type Extender = E

the type that will be produced

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

create a new Extend of the correct type

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

accumulate the input into an accumulator

impl<'a, T: FindSubstring<&'a str>, X> FindSubstring<&'a str> for TrackedLocation<T, X>

fn find_substring(&self, substr: &'a str) -> Option<usize>

returns the byte position of the substring if it is found

impl<T: FindToken<Token>, Token, X> FindToken<Token> for TrackedLocation<T, X>

fn find_token(&self, token: Token) -> bool

returns true if self contains the token

impl<T: AsBytes, X: Default> From<T> for TrackedLocation<T, X>

fn from(program: T) -> Self

Performs the conversion.

impl<'a, X> InputIter for TrackedLocation<&'a str, X>

type Item = char

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

type Iter = CharIndices<'a>

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 = Chars<'a>

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) -> Option<usize>

get the byte offset from the element's position in the stream

impl<T: InputLength, X> InputLength for TrackedLocation<T, X>

fn input_len(&self) -> usize

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

impl<T, X> InputTake for TrackedLocation<T, X> 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, X> InputTakeAtPosition for TrackedLocation<T, X> where
    T: InputTakeAtPosition + InputLength + InputIter,
    Self: Slice<RangeFrom<usize>> + Slice<RangeTo<usize>> + Clone, 

type Item = <T as InputIter>::Item

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

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

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<P, E: ParseError<Self>>(
    &self,
    predicate: P
) -> IResult<Self, Self, E> where
    P: Fn(Self::Item) -> bool, 

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<P, E: ParseError<Self>>(
    &self,
    predicate: P,
    e: ErrorKind
) -> IResult<Self, Self, E> where
    P: Fn(Self::Item) -> bool, 

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: ParseError<Self>>(
    &self,
    predicate: P,
    e: ErrorKind
) -> IResult<Self, Self, E> where
    P: Fn(Self::Item) -> bool, 

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

impl<'a, X> IntoIterator for TrackedLocation<&'a str, X>

type Item = char

The type of the elements being iterated over.

type IntoIter = Chars<'a>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T, X> Offset for TrackedLocation<T, X>

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

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

impl<R: FromStr, T: ParseTo<R>, X> ParseTo<R> for TrackedLocation<T, X>

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<T: PartialEq, X> PartialEq<TrackedLocation<T, X>> for TrackedLocation<T, X>

fn eq(&self, other: &Self) -> bool

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

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, X: Clone> Slice<Range<usize>> for TrackedLocation<&'a str, X>

fn slice(&self, range: Range<usize>) -> Self

slices self according to the range argument

impl<'a, X: Clone> Slice<RangeFrom<usize>> for TrackedLocation<&'a str, X>

fn slice(&self, range: RangeFrom<usize>) -> Self

slices self according to the range argument

impl<'a, T: Clone, X: Clone> Slice<RangeFull> for TrackedLocation<T, X>

fn slice(&self, _range: RangeFull) -> Self

slices self according to the range argument

impl<'a, X: Clone> Slice<RangeTo<usize>> for TrackedLocation<&'a str, X>

fn slice(&self, range: RangeTo<usize>) -> Self

slices self according to the range argument