Struct Spanned

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

You can wrap your input in this struct with Spanned::new

Implementations

impl<T> Spanned<T>

pub fn new(data: T, handle_utf8: bool) -> Self

pub fn new_for_ut8(data: T) -> Self

pub fn new_for_ascii(data: T) -> Self

pub fn line(&self) -> usize

Get the current line number

pub fn col(&self) -> usize

Get the current column number

pub fn byte_offset(&self) -> usize

Get the current byte offset

pub fn data(&self) -> &T

Get the current data in the span

Trait Implementations

impl<T> AsBytes for Spanned<T>

where T: AsBytes,

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

Casts the input type to a byte slice

impl<T, U> AsRef<U> for Spanned<&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 Spanned<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T, Comp> Compare<Comp> for Spanned<T>

where T: Compare<Comp>,

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

Compares self to another value for equality

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

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

impl<T: Debug> Debug for Spanned<T>

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

Formats the value using the given formatter.

impl<T> Deref for Spanned<T>

type Target = T

The resulting type after dereferencing.

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

Dereferences the value.

impl<T> ExtendInto for Spanned<T>

where T: ExtendInto,

type Item = <T as ExtendInto>::Item

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

type Extender = <T 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, acc: &mut Self::Extender)

Accumulate the input into an accumulator

impl<T> FindSubstring<T> for Spanned<T>

where T: FindSubstring<T>,

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

Returns the byte position of the substring if it is found

impl<T, Token> FindToken<Token> for Spanned<T>

where T: FindToken<Token>,

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

Returns true if self contains the token

impl<T> InputIter for Spanned<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 for Spanned<T>

where T: InputLength,

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 Spanned<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> InputTakeAtPosition for Spanned<T>

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<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_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_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<T> Offset for Spanned<T>

where T: Offset,

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

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

impl<T, R: FromStr> ParseTo<R> for Spanned<T>

where T: 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<T: PartialEq> PartialEq for Spanned<T>

fn eq(&self, other: &Spanned<T>) -> 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 Spanned<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 Spanned<T>

impl<T: Eq> Eq for Spanned<T>

impl<T> StructuralPartialEq for Spanned<T>