1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150
use super::ToTokens; use std::fmt::{self, Display}; use std::str::FromStr; /// Tokens produced by a `quote!(...)` invocation. #[derive(Debug, Clone, Eq, PartialEq)] pub struct Tokens(String); impl Tokens { /// Empty tokens. pub fn new() -> Self { Tokens(String::new()) } /// For use by `ToTokens` implementations. /// /// ``` /// # #[macro_use] extern crate quote; /// # use quote::{Tokens, ToTokens}; /// # fn main() { /// struct X; /// /// impl ToTokens for X { /// fn to_tokens(&self, tokens: &mut Tokens) { /// tokens.append("a"); /// tokens.append("b"); /// tokens.append("c"); /// } /// } /// /// let x = X; /// let tokens = quote!(#x); /// assert_eq!(tokens.as_str(), "a b c"); /// # } /// ``` pub fn append(&mut self, token: &str) { if !self.0.is_empty() && !token.is_empty() { self.0.push(' '); } self.0.push_str(token); } /// For use by `ToTokens` implementations. /// /// ``` /// # #[macro_use] extern crate quote; /// # use quote::{Tokens, ToTokens}; /// # fn main() { /// struct X; /// /// impl ToTokens for X { /// fn to_tokens(&self, tokens: &mut Tokens) { /// tokens.append_all(&[true, false]); /// } /// } /// /// let x = X; /// let tokens = quote!(#x); /// assert_eq!(tokens.as_str(), "true false"); /// # } /// ``` pub fn append_all<T, I>(&mut self, iter: I) where T: ToTokens, I: IntoIterator<Item = T> { for token in iter { token.to_tokens(self); } } /// For use by `ToTokens` implementations. /// /// ``` /// # #[macro_use] extern crate quote; /// # use quote::{Tokens, ToTokens}; /// # fn main() { /// struct X; /// /// impl ToTokens for X { /// fn to_tokens(&self, tokens: &mut Tokens) { /// tokens.append_separated(&[true, false], ","); /// } /// } /// /// let x = X; /// let tokens = quote!(#x); /// assert_eq!(tokens.as_str(), "true , false"); /// # } /// ``` pub fn append_separated<T, I>(&mut self, iter: I, sep: &str) where T: ToTokens, I: IntoIterator<Item = T> { for (i, token) in iter.into_iter().enumerate() { if i > 0 { self.append(sep); } token.to_tokens(self); } } /// For use by `ToTokens` implementations. /// /// ``` /// # #[macro_use] extern crate quote; /// # use quote::{Tokens, ToTokens}; /// # fn main() { /// struct X; /// /// impl ToTokens for X { /// fn to_tokens(&self, tokens: &mut Tokens) { /// tokens.append_terminated(&[true, false], ","); /// } /// } /// /// let x = X; /// let tokens = quote!(#x); /// assert_eq!(tokens.as_str(), "true , false ,"); /// # } /// ``` pub fn append_terminated<T, I>(&mut self, iter: I, term: &str) where T: ToTokens, I: IntoIterator<Item = T> { for token in iter { token.to_tokens(self); self.append(term); } } pub fn as_str(&self) -> &str { &self.0 } pub fn parse<T: FromStr>(&self) -> Result<T, T::Err> { FromStr::from_str(&self.0) } } impl Default for Tokens { fn default() -> Self { Tokens::new() } } impl Display for Tokens { fn fmt(&self, formatter: &mut fmt::Formatter) -> Result<(), fmt::Error> { self.0.fmt(formatter) } }