Struct genco::prelude::Tokens

pub struct Tokens<L = ()> where
    L: Lang,  { /* fields omitted */ }

A set of tokens.

Implementations

impl<L> Tokens<L> where
    L: Lang, 

Generic methods.

pub fn new() -> Tokens<L>

Create a new set of tokens.

pub fn append<T>(&mut self, tokens: T) where
    T: FormatTokens<L>, 

Append the given element.

pub fn extend<I>(&mut self, it: I) where
    I: IntoIterator<Item = Item<L>>, 

Extend with another set of tokens.

pub fn walk_imports(&self) -> WalkImports<L>

Walk over all elements.

pub fn register<T>(&mut self, tokens: T) where
    T: RegisterTokens<L>, 

Add an registered custom element that is not rendered.

Registration can be used to generate imports that do not render a visible result.

Examples

The register functionality is available through the quote! macro by using the register function.

use genco::rust::{imported, Config};
use genco::quote;

let write_bytes_ext = imported("byteorder", "WriteBytesExt").alias("_");

let tokens = quote!(#@(write_bytes_ext));

assert_eq!("use byteorder::WriteBytesExt as _;\n\n", tokens.to_file_string().unwrap());

pub fn is_empty(&self) -> bool

Check if tokens contain no elements.

pub fn spacing(&mut self)

Add a single spacing to the token stream.

pub fn push(&mut self)

Add a single push spacing operation.

pub fn push_line(&mut self)

Assert that there's the necessary elements to create one empty line at the top of the queue.

pub fn indent(&mut self)

Add a single indentation to the token stream.

pub fn unindent(&mut self)

Add a single unindentation to the token stream.

impl<L: Lang> Tokens<L>

pub fn format(
    &self,
    out: &mut Formatter,
    config: &mut L::Config,
    level: usize
) -> Result

Format the tokens.

pub fn to_file_string_with(
    self,
    config: L::Config,
    format_config: FormatterConfig
) -> Result<String, Error>

Format the token stream as a file for the given target language to a string. Using the specified config.

pub fn to_string_with(
    self,
    config: L::Config,
    format_config: FormatterConfig
) -> Result<String, Error>

Format only the current token stream as a string. Using the specified config.

pub fn to_file_vec_with(
    self,
    config: L::Config,
    format_config: FormatterConfig
) -> Result<Vec<String>, Error>

Format tokens into a vector, where each entry equals a line in the resulting file. Using the specified config.

pub fn to_fmt_writer_with<W>(
    self,
    writer: W,
    config: L::Config,
    format_config: FormatterConfig
) -> Result<(), Error> where
    W: Write, 

Format the token stream as a file for the given target language to the given writer. Using the specified config.

pub fn to_io_writer_with<W>(
    self,
    writer: W,
    config: L::Config,
    format_config: FormatterConfig
) -> Result<(), Error> where
    W: Write, 

Format the token stream as a file for the given target language to the given writer. Using the specified config.

impl<C: Default, L: Lang<Config = C>> Tokens<L>

pub fn to_file_string(self) -> Result<String, Error>

Format the token stream as a file for the given target language to a string. Using the default configuration.

pub fn to_string(self) -> Result<String, Error>

Format only the current token stream as a string. Using the default configuration.

pub fn to_file_vec(self) -> Result<Vec<String>, Error>

Format tokens into a vector, where each entry equals a line in the resulting file. Using the default configuration.

pub fn to_fmt_writer<W>(self, writer: W) -> Result<(), Error> where
    W: Write, 

Format the token stream as a file for the given target language to the given writer. Using the default configuration.

pub fn to_io_writer<W>(self, writer: W) -> Result<(), Error> where
    W: Write, 

Format the token stream as a file for the given target language to the given writer. Using the default configuration.

Trait Implementations

impl<L> Clone for Tokens<L> where
    L: Lang, 

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<L> Debug for Tokens<L> where
    L: Lang, 

fn fmt(&self, fmt: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<L: Default> Default for Tokens<L> where
    L: Lang, 

fn default() -> Tokens<L>

Returns the "default value" for a type.

impl<L> FormatTokens<L> for Tokens<L> where
    L: Lang, 

fn format_tokens(self, tokens: &mut Self)

Convert the type into tokens.

fn is_empty(&self) -> bool

Hint to test if we are empty.

fn into_tokens(self) -> Tokens<L> where
    Self: Sized, 

Convert into tokens.

impl<'a, L> FormatTokens<L> for &'a Tokens<L> where
    L: Lang, 

fn format_tokens(self, tokens: &mut Tokens<L>)

Convert the type into tokens.

fn is_empty(&self) -> bool

Hint to test if we are empty.

fn into_tokens(self) -> Tokens<L> where
    Self: Sized, 

Convert into tokens.

impl<'a, L> FromIterator<&'a Item<L>> for Tokens<L> where
    L: Lang, 

fn from_iter<I: IntoIterator<Item = &'a Item<L>>>(iter: I) -> Tokens<L>

Creates a value from an iterator.

impl<L> FromIterator<Item<L>> for Tokens<L> where
    L: Lang, 

fn from_iter<I: IntoIterator<Item = Item<L>>>(iter: I) -> Tokens<L>

Creates a value from an iterator.

impl<L> IntoIterator for Tokens<L> where
    L: Lang, 

type Item = Item<L>

The type of the elements being iterated over.

type IntoIter = IntoIter<Item<L>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.