Struct Cached 

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

Getting the underlying string expensive as it always allocates a new String. This type caches the string representation of a given entity. Note that this is only reliable for fundamental entities that represent a single token. Spacing between composed tokens is not stable and should be considered informal only.

Example

use unsynn::*;
let mut token_iter = "ident 1234".to_token_iter();

let cached_ident = Cached::<Ident>::parse(&mut token_iter).unwrap();
assert!(cached_ident == "ident");

Implementations

impl<T> Cached<T>

where T: Parse + ToTokens,

pub fn set(&mut self, value: T)

Sets the value and updates the string representation.

impl<T> Cached<T>

where T: Parse,

pub fn into_inner(self) -> T

Deconstructs self and returns the inner value.

pub fn into_string(self) -> String

Deconstructs self and returns the contained String representation.

pub fn as_str(&self) -> &str

Gets the cached string representation

impl<T> Cached<T>

where T: Parse,

pub fn new(s: &str) -> Cached<T>

Creates a new Cached<T> from a &str.

Panics

Panics when s can’t be parsed.

Example

use unsynn::*;
let cached_ident = Cached::<Ident>::new("ident");
assert!(cached_ident == "ident");

pub fn from_string(s: String) -> Result<Cached<T>, Error>

Creates a new Cached<T> from a owned String.

Errors

Returns Err when s can’t be parsed.

Example

use unsynn::*;
let cached_ident = Cached::<Ident>::from_string("ident".into()).unwrap();
assert!(cached_ident == "ident");

Trait Implementations

impl<T> AsRef<T> for Cached<T>

where T: Parse,

fn as_ref(&self) -> &T

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

impl<T> AsRef<str> for Cached<T>

where T: Parse,

fn as_ref(&self) -> &str

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

impl<T> Clone for Cached<T>

where T: Clone,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for Cached<T>

where T: Parse + Debug,

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

Formats the value using the given formatter.

impl<T> Deref for Cached<T>

where T: Parse,

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &<Cached<T> as Deref>::Target

Dereferences the value.

impl From<Cached<Group>> for Group

Convert CachedGroup into a Group`.

fn from(cached: Cached<Group>) -> Group

Converts to this type from the input type.

impl From<Cached<Ident>> for Ident

Convert CachedIdent into a Ident`.

fn from(cached: Cached<Ident>) -> Ident

Converts to this type from the input type.

impl From<Cached<Literal>> for Literal

Convert CachedLiteral into a Literal`.

fn from(cached: Cached<Literal>) -> Literal

Converts to this type from the input type.

impl From<Cached<LiteralInteger>> for LiteralInteger

Convert CachedLiteralInteger into a LiteralInteger`.

fn from(cached: Cached<LiteralInteger>) -> LiteralInteger

Converts to this type from the input type.

impl From<Cached<LiteralString>> for LiteralString

Convert CachedLiteralString into a LiteralString`.

fn from(cached: Cached<LiteralString>) -> LiteralString

Converts to this type from the input type.

impl From<Cached<Punct>> for Punct

Convert CachedPunct into a Punct`.

fn from(cached: Cached<Punct>) -> Punct

Converts to this type from the input type.

impl<T> From<Cached<T>> for TokenTree

where T: Into<TokenTree>,

Convert a Cached<T: Into<TokenTree>> object into a TokenTree.

fn from(cached: Cached<T>) -> TokenTree

Converts to this type from the input type.

impl<T> Hash for Cached<T>

where T: Parse,

fn hash<H>(&self, state: &mut H)

where H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T> Parser for Cached<T>

where T: Parse + ToTokens,

fn parser(tokens: &mut TokenIter) -> Result<Cached<T>, Error>

The actual parsing function that must be implemented. This mutates the tokens iterator directly. It should not be called from user code except for implementing parsers itself and then only when the rules below are followed.

impl<T> PartialEq<&str> for Cached<T>

where T: Parse,

fn eq(&self, other: &&str) -> 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> PartialEq for Cached<T>

where T: Parse,

fn eq(&self, other: &Cached<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> ToTokens for Cached<T>

where T: Parse + ToTokens,

fn to_tokens(&self, tokens: &mut TokenStream)

Write &self to the given TokenStream.

fn to_token_iter(&self) -> TokenIter

Convert &self into a TokenIter object.

fn into_token_iter(self) -> TokenIter

where Self: Sized,

Convert self into a TokenIter object.

fn to_token_stream(&self) -> TokenStream

Convert &self into a TokenStream object.

fn into_token_stream(self) -> TokenStream

where Self: Sized,

Convert self into a TokenStream object.

fn tokens_to_string(&self) -> String

Convert &self into a String object. This is mostly used in the test suite to compare the outputs. When the input is a &str then this parses it and returns a normalized String.

impl<T> TryFrom<&str> for Cached<T>

where T: Parse,

Available on crate feature proc_macro2 only.

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: &str) -> Result<Cached<T>, Error>

Performs the conversion.

impl<T> TryFrom<String> for Cached<T>

where T: Parse,

Available on crate feature proc_macro2 only.

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: String) -> Result<Cached<T>, Error>

Performs the conversion.

impl<T> Eq for Cached<T>

where T: Parse,