Struct FormatterBuilder

Source

pub struct FormatterBuilder { /* private fields */ }

Expand description

Formatter safe builder.

The safe and stable builder for fmt::Formatter

Due to unstable Formatter::new, uses this crate to dynamically build a Formatter.

§Examples

use formatter_builder::{FormatterBuilder, Fill, Sign, Alignment};

let mut output = String::new();
let n = 6.23;
formatter_builder::FormatterBuilder::new()
    .width(8)
    .align(Alignment::Right)
    .precision(3)
    .fill(Fill::Zero)
    .with(&mut output, |f| {
        std::fmt::Display::fmt(&n, f)
    })
    .unwrap();
assert_eq!(output, "0006.230")

use std::fmt::{Display, Formatter, Result};
use formatter_builder::FormatterBuilder;

struct Foo(f32);
impl Display for Foo {
    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
        FormatterBuilder::from_formatter_lossy(f)
            .precision(2)
            .with(f, |f| self.0.fmt(f))
    }
}

Implementations§

Source §

impl FormatterBuilder

Source

pub fn with<W, F>(&self, writer: W, f: F) -> Result
where W: Write, F: FnOnce(&mut Formatter<'_>) -> Result,

Source §

impl FormatterBuilder

Source

pub fn new() -> Self

Source

pub fn from_formatter_lossy(f: &Formatter<'_>) -> Self

Rebuild from Formatter, but maybe lose some fields

Incomplete list of loses:

Only support partial fill char (Fill)
About DebugHex (x? X?)

Source

pub fn sign(&mut self, sign: impl Into<Option<Sign>>) -> &mut Self

Format like {:+} and {:-}

§Examples

use std::fmt::Display;
let mut writter = String::new();
FormatterBuilder::new().sign(Sign::Plus).with(&mut writter, |f| {
    2i32.fmt(f);
    Ok(())
}).unwrap();
assert_eq!(writter, "+2");

Source

pub fn sign_aware_zero_pad(&mut self, sign_aware_zero_pad: bool) -> &mut Self

Format like {:0}

§Examples

FormatterBuilder::new().sign_aware_zero_pad(true).with(writter, |f| {
    assert!(f.sign_aware_zero_pad());
    Ok(())
}).unwrap();

Source

pub fn alternate(&mut self, alternate: bool) -> &mut Self

Format like {:#}

§Examples

FormatterBuilder::new().alternate(true).with(writter, |f| {
    assert!(f.alternate());
    Ok(())
}).unwrap();

Source

pub fn fill(&mut self, fill: impl Into<Option<Fill>>) -> &mut Self

Format like {:0>} {: ^} etc

§Panics

panic when align is unset

§Examples

FormatterBuilder::new().align(Left).fill(Fill::Space).with(writter, |f| {
    assert_eq!(f.fill(), ' ');
    Ok(())
}).unwrap();

Source

pub fn align(&mut self, align: impl Into<Option<Alignment>>) -> &mut Self

Format like {:<} and {:^} and {:>}

§Examples

FormatterBuilder::new().align(Center).with(writter, |f| {
    assert_eq!(f.align(), Some(Center));
    Ok(())
}).unwrap();

Source

pub fn width(&mut self, width: impl Into<Option<u16>>) -> &mut Self

Format like {:3}

§Examples

use std::fmt::Display;
let mut writter = String::new();
FormatterBuilder::new().width(3).with(&mut writter, |f| {
    2i32.fmt(f);
    Ok(())
}).unwrap();
assert_eq!(writter, "  2");

Source

pub fn precision(&mut self, precision: impl Into<Option<u16>>) -> &mut Self

Format like {:.3}

§Examples

use std::fmt::Display;
let mut writter = String::new();
FormatterBuilder::new().precision(3).with(&mut writter, |f| {
    2f32.fmt(f);
    Ok(())
}).unwrap();
assert_eq!(writter, "2.000");