Struct Cached 

pub struct Cached<T>
where
    T: Parse,
{ /* 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 new(s: &str) -> Cached<T>

Creates a new Cached<T> from a (literal) string.

Panics

Panics when s can’t be parsed.

Example

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

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

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 + Parse,

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<T> From<Cached<T>> for TokenTree

where T: Parse + 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 ShadowCountedIter<'_, <TokenStream as IntoIterator>::IntoIter>, ) -> 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, ) -> ShadowCountedIter<'_, <TokenStream as IntoIterator>::IntoIter>

Convert &self into a TokenIter object.

fn into_token_iter<'a>( self, ) -> ShadowCountedIter<'a, <TokenStream as IntoIterator>::IntoIter>

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,

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,

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,