Struct nom_locate::LocatedSpan [−][src]
pub struct LocatedSpan<T, X = ()> {
pub extra: X,
// some fields omitted
}
Expand description
A LocatedSpan is a set of meta information about the location of a token, including extra information.
The LocatedSpan
structure can be used as an input of the nom parsers.
It implements all the necessary traits for LocatedSpan<&str,X>
and LocatedSpan<&[u8],X>
Fields
extra: X
Extra information that can be embedded by the user. Example: the parsed file name
Implementations
Create a span for a particular input with default offset
and
line
values and empty extra data.
You can compute the column through the get_column
or get_utf8_column
methods.
offset
starts at 0, line
starts at 1, and column
starts at 1.
Do not use this constructor in parser functions; nom
and
nom_locate
assume span offsets are relative to the beginning of the
same input. In these cases, you probably want to use the
nom::traits::Slice
trait instead.
Example of use
use nom_locate::LocatedSpan;
let span = LocatedSpan::new(b"foobar");
assert_eq!(span.location_offset(), 0);
assert_eq!(span.location_line(), 1);
assert_eq!(span.get_column(), 1);
assert_eq!(span.fragment(), &&b"foobar"[..]);
Create a span for a particular input with default offset
and
line
values. You can compute the column through the get_column
or get_utf8_column
methods.
offset
starts at 0, line
starts at 1, and column
starts at 1.
Do not use this constructor in parser functions; nom
and
nom_locate
assume span offsets are relative to the beginning of the
same input. In these cases, you probably want to use the
nom::traits::Slice
trait instead.
Example of use
use nom_locate::LocatedSpan;
let span = LocatedSpan::new_extra(b"foobar", "extra");
assert_eq!(span.location_offset(), 0);
assert_eq!(span.location_line(), 1);
assert_eq!(span.get_column(), 1);
assert_eq!(span.fragment(), &&b"foobar"[..]);
assert_eq!(span.extra, "extra");
pub unsafe fn new_from_raw_offset(
offset: usize,
line: u32,
fragment: T,
extra: X
) -> LocatedSpan<T, X>
pub unsafe fn new_from_raw_offset(
offset: usize,
line: u32,
fragment: T,
extra: X
) -> LocatedSpan<T, X>
Similar to new_extra
, but allows overriding offset and line.
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.
The offset represents the position of the fragment relatively to the input of the parser. It starts at offset 0.
The line number of the fragment relatively to the input of the parser. It starts at line 1.
The fragment that is spanned. The fragment represents a part of the input of the parser.
Return the line that contains this LocatedSpan.
The get_column
and get_utf8_column
functions returns
indexes that corresponds to the line returned by this function.
Note that if this LocatedSpan ends before the end of the
original data, the result of calling get_line_beginning()
will not include any data from after the LocatedSpan.
let program = LocatedSpan::new(
"Hello World!\
\nThis is a multi-line input\
\nthat ends after this line.\n");
let multi = program.find_substring("multi").unwrap();
assert_eq!(
program.slice(multi..).get_line_beginning(),
"This is a multi-line input".as_bytes(),
);
Return the column index, assuming 1 byte = 1 column.
Use it for ascii text, or use get_utf8_column for UTF8.
Example of use
let span = LocatedSpan::new("foobar");
assert_eq!(span.slice(3..).get_column(), 4);
Return the column index for UTF8 text. Return value is unspecified for non-utf8 text.
This version uses bytecount’s hyper algorithm to count characters. This is much faster
for long lines, but is non-negligibly slower for short slices (below around 100 bytes).
This is also sped up significantly more depending on architecture and enabling the simd
feature gates. If you expect primarily short lines, you may get a noticeable speedup in
parsing by using naive_get_utf8_column
instead. Benchmark your specific use case!
Example of use
let span = LocatedSpan::new("メカジキ");
let indexOf3dKanji = span.find_substring("ジ").unwrap();
assert_eq!(span.slice(indexOf3dKanji..).get_column(), 7);
assert_eq!(span.slice(indexOf3dKanji..).get_utf8_column(), 3);
Return the column index for UTF8 text. Return value is unspecified for non-utf8 text.
A simpler implementation of get_utf8_column
that may be faster on shorter lines.
If benchmarking shows that this is faster, you can use it instead of get_utf8_column
.
Prefer defaulting to get_utf8_column
unless this legitimately is a performance bottleneck.
Example of use
let span = LocatedSpan::new("メカジキ");
let indexOf3dKanji = span.find_substring("ジ").unwrap();
assert_eq!(span.slice(indexOf3dKanji..).get_column(), 7);
assert_eq!(span.slice(indexOf3dKanji..).naive_get_utf8_column(), 3);
Trait Implementations
Compares self to another value for equality
Compares self to another value for equality independently of the case. Read more
Create a new Extend
of the correct type
Accumulate the input into an accumulator
Returns the byte position of the substring if it is found
Returns true if self contains the token
Returns an iterator over the elements and their byte offsets
Returns an iterator over the elements
Finds the byte position of the element
impl<T, X> InputTakeAtPosition for LocatedSpan<T, X> where
T: InputTakeAtPosition + InputLength + InputIter,
Self: Slice<RangeFrom<usize>> + Slice<RangeTo<usize>> + Clone,
impl<T, X> InputTakeAtPosition for LocatedSpan<T, X> where
T: InputTakeAtPosition + InputLength + InputIter,
Self: Slice<RangeFrom<usize>> + Slice<RangeTo<usize>> + Clone,
fn split_at_position_complete<P, E: ParseError<Self>>(
&self,
predicate: P
) -> IResult<Self, Self, E> where
P: Fn(Self::Item) -> bool,
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. Read more
fn split_at_position<P, E: ParseError<Self>>(
&self,
predicate: P
) -> IResult<Self, Self, E> where
P: Fn(Self::Item) -> bool,
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. Read more
fn split_at_position1<P, E: ParseError<Self>>(
&self,
predicate: P,
e: ErrorKind
) -> IResult<Self, Self, E> where
P: Fn(Self::Item) -> bool,
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. Read more
fn split_at_position1_complete<P, E: ParseError<Self>>(
&self,
predicate: P,
e: ErrorKind
) -> IResult<Self, Self, E> where
P: Fn(Self::Item) -> bool,
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. Read more
Auto Trait Implementations
impl<T, X> RefUnwindSafe for LocatedSpan<T, X> where
T: RefUnwindSafe,
X: RefUnwindSafe,
impl<T, X> Send for LocatedSpan<T, X> where
T: Send,
X: Send,
impl<T, X> Sync for LocatedSpan<T, X> where
T: Sync,
X: Sync,
impl<T, X> Unpin for LocatedSpan<T, X> where
T: Unpin,
X: Unpin,
impl<T, X> UnwindSafe for LocatedSpan<T, X> where
T: UnwindSafe,
X: UnwindSafe,
Blanket Implementations
Mutably borrows from an owned value. Read more