Struct FmtWriter

pub struct FmtWriter<W>
where
    W: Write,
{ /* private fields */ }

Helper struct to format a token stream to an underlying writer implementing fmt::Write.

Examples

use genco::prelude::*;
use genco::fmt;

let map = rust::import("std::collections", "HashMap");

let tokens: rust::Tokens = quote! {
    let mut m = $map::new();
    m.insert(1u32, 2u32);
};

// Note: String implements std::fmt::Write
let mut w = fmt::FmtWriter::new(String::new());

let fmt = fmt::Config::from_lang::<Rust>();

let config = rust::Config::default();
// Default format state for Rust.
let format = rust::Format::default();

tokens.format(&mut w.as_formatter(&fmt), &config, &format)?;

let string = w.into_inner();

assert_eq!("let mut m = HashMap::new();\nm.insert(1u32, 2u32);", string);

Implementations

impl<W> FmtWriter<W>

where W: Write,

pub fn new(writer: W) -> Self

Construct a new line writer from the underlying writer.

pub fn as_formatter<'a>(&'a mut self, config: &'a Config) -> Formatter<'a>

Convert into a formatter.

pub fn into_inner(self) -> W

Convert into underlying writer.

Trait Implementations

impl<W> Write for FmtWriter<W>

where W: Write,

fn write_char(&mut self, c: char) -> Result

Writes a char into this writer, returning whether the write succeeded.

fn write_str(&mut self, s: &str) -> Result

Writes a string slice into this writer, returning whether the write succeeded.

fn write_fmt(&mut self, args: Arguments<'_>) -> Result<(), Error>

Glue for usage of the write! macro with implementors of this trait.