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: Parse + ToTokens> Cached<T>

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

Sets the value and updates the string representation.

impl<T: Parse> Cached<T>

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: Parse> Cached<T>

pub fn new(s: &str) -> Self

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<Self>

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: Parse> AsRef<T> for Cached<T>

fn as_ref(&self) -> &T

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

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

fn as_ref(&self) -> &str

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

impl<T: Clone> Clone for Cached<T>

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: Parse + Debug> Debug for Cached<T>

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

Formats the value using the given formatter.

impl<T: Parse> Deref for Cached<T>

type Target = T

The resulting type after dereferencing.

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

Dereferences the value.

impl<T: Parse> Eq for Cached<T>

impl From<Cached<Group>> for Group

Convert CachedGroup into a Group`.

fn from(cached: CachedGroup) -> Self

Converts to this type from the input type.

impl From<Cached<Ident>> for Ident

Convert CachedIdent into a Ident`.

fn from(cached: CachedIdent) -> Self

Converts to this type from the input type.

impl From<Cached<Literal>> for Literal

Convert CachedLiteral into a Literal`.

fn from(cached: CachedLiteral) -> Self

Converts to this type from the input type.

impl From<Cached<LiteralInteger>> for LiteralInteger

Convert CachedLiteralInteger into a LiteralInteger`.

fn from(cached: CachedLiteralInteger) -> Self

Converts to this type from the input type.

impl From<Cached<LiteralString>> for LiteralString

Convert CachedLiteralString into a LiteralString`.

fn from(cached: CachedLiteralString) -> Self

Converts to this type from the input type.

impl From<Cached<Punct>> for Punct

Convert CachedPunct into a Punct`.

fn from(cached: CachedPunct) -> Self

Converts to this type from the input type.

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

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

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

Converts to this type from the input type.

impl<T: Parse> Hash for Cached<T>

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

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: Parse + ToTokens> Parser for Cached<T>

fn parser(tokens: &mut TokenIter) -> Result<Self>

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: Parse> PartialEq for Cached<T>

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<T: Parse> PartialEq<&str> for Cached<T>

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: Parse + ToTokens> ToTokens for Cached<T>

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: Parse> TryFrom<&str> for Cached<T>

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<Self>

Performs the conversion.

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

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<Self>

Performs the conversion.