Struct Cursor

pub struct Cursor<'a> {
    ptr: *const Entry,
    scope: *const Entry,
    marker: PhantomData<&'a Entry>,
}

A cheaply copyable cursor into a TokenBuffer.

This cursor holds a shared reference into the immutable data which is used internally to represent a TokenStream, and can be efficiently manipulated and copied around.

An empty Cursor can be created directly, or one may create a TokenBuffer object and get a cursor to its first token with begin().

Fields

ptr: *const Entry

scope: *const Entry

marker: PhantomData<&'a Entry>

Implementations

impl<'a> Cursor<'a>

pub fn empty() -> Self

Creates a cursor referencing a static empty TokenStream.

unsafe fn create(ptr: *const Entry, scope: *const Entry) -> Self

This create method intelligently exits non-explicitly-entered None-delimited scopes when the cursor reaches the end of them, allowing for them to be treated transparently.

fn entry(self) -> &'a Entry

Get the current entry.

unsafe fn bump_ignore_group(self) -> Cursor<'a>

Bump the cursor to point at the next token after the current one. This is undefined behavior if the cursor is currently looking at an Entry::End.

If the cursor is looking at an Entry::Group, the bumped cursor will point at the first token in the group (with the same scope end).

fn ignore_none(&mut self)

While the cursor is looking at a None-delimited group, move it to look at the first token inside instead. If the group is empty, this will move the cursor past the None-delimited group.

WARNING: This mutates its argument.

pub fn eof(self) -> bool

Checks whether the cursor is currently pointing at the end of its valid scope.

pub fn ident(self) -> Option<(Ident, Cursor<'a>)>

If the cursor is pointing at a Ident, returns it along with a cursor pointing at the next TokenTree.

pub fn punct(self) -> Option<(Punct, Cursor<'a>)>

If the cursor is pointing at a Punct, returns it along with a cursor pointing at the next TokenTree.

pub fn literal(self) -> Option<(Literal, Cursor<'a>)>

If the cursor is pointing at a Literal, return it along with a cursor pointing at the next TokenTree.

pub fn lifetime(self) -> Option<(Lifetime, Cursor<'a>)>

If the cursor is pointing at a Lifetime, returns it along with a cursor pointing at the next TokenTree.

pub fn group( self, delim: Delimiter, ) -> Option<(Cursor<'a>, DelimSpan, Cursor<'a>)>

If the cursor is pointing at a Group with the given delimiter, returns a cursor into that group and one pointing to the next TokenTree.

pub fn any_group(self) -> Option<(Cursor<'a>, Delimiter, DelimSpan, Cursor<'a>)>

If the cursor is pointing at a Group, returns a cursor into the group and one pointing to the next TokenTree.

pub(crate) fn any_group_token(self) -> Option<(Group, Cursor<'a>)>

pub fn token_stream(self) -> TokenStream

Copies all remaining tokens visible from this cursor into a TokenStream.

pub fn token_tree(self) -> Option<(TokenTree, Cursor<'a>)>

If the cursor is pointing at a TokenTree, returns it along with a cursor pointing at the next TokenTree.

Returns None if the cursor has reached the end of its stream.

This method does not treat None-delimited groups as transparent, and will return a Group(None, ..) if the cursor is looking at one.

pub fn span(self) -> Span

Returns the Span of the current token, or Span::call_site() if this cursor points to eof.

pub(crate) fn prev_span(self) -> Span

Returns the Span of the token immediately prior to the position of this cursor, or of the current token if there is no previous one.

pub(crate) fn skip(self) -> Option<Cursor<'a>>

Skip over the next token that is not a None-delimited group, without cloning it. Returns None if this cursor points to eof.

This method treats 'lifetimes as a single token.

pub(crate) fn scope_delimiter(self) -> Delimiter

Trait Implementations

impl<'a> Clone for Cursor<'a>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> PartialEq for Cursor<'a>

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<'a> PartialOrd for Cursor<'a>

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

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

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl<'a> Copy for Cursor<'a>

impl<'a> Eq for Cursor<'a>