W3cubDocs

/Rust

Struct std::fmt::Formatter

pub struct Formatter<'a> { /* fields omitted */ }

Configuration for formatting.

A Formatter represents various options related to formatting. Users do not construct Formatters directly; a mutable reference to one is passed to the fmt method of all formatting traits, like Debug and Display.

To interact with a Formatter, you'll call various methods to change the various options related to formatting. For examples, please see the documentation of the methods defined on Formatter below.

Implementations

`impl<'a> Formatter<'a>`[src]

`pub fn pad_integral( &mut self, is_nonnegative: bool, prefix: &str, buf: &str ) -> Result<(), Error>`[src]

Performs the correct padding for an integer which has already been emitted into a str. The str should not contain the sign for the integer, that will be added by this method.

Arguments

is_nonnegative - whether the original integer was either positive or zero.
prefix - if the '#' character (Alternate) is provided, this is the prefix to put in front of the number.
buf - the byte array that the number has been formatted into

This function will correctly account for the flags provided as well as the minimum width. It will not take precision into account.

Examples

use std::fmt;

struct Foo { nb: i32 };

impl Foo {
    fn new(nb: i32) -> Foo {
        Foo {
            nb,
        }
    }
}

impl fmt::Display for Foo {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        // We need to remove "-" from the number output.
        let tmp = self.nb.abs().to_string();

        formatter.pad_integral(self.nb > 0, "Foo ", &tmp)
    }
}

assert_eq!(&format!("{}", Foo::new(2)), "2");
assert_eq!(&format!("{}", Foo::new(-1)), "-1");
assert_eq!(&format!("{:#}", Foo::new(-1)), "-Foo 1");
assert_eq!(&format!("{:0>#8}", Foo::new(-1)), "00-Foo 1");

`pub fn pad(&mut self, s: &str) -> Result<(), Error>`[src]

This function takes a string slice and emits it to the internal buffer after applying the relevant formatting flags specified. The flags recognized for generic strings are:

width - the minimum width of what to emit
fill/align - what to emit and where to emit it if the string provided needs to be padded
precision - the maximum length to emit, the string is truncated if it is longer than this length

Notably this function ignores the flag parameters.

Examples

use std::fmt;

struct Foo;

impl fmt::Display for Foo {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.pad("Foo")
    }
}

assert_eq!(&format!("{:<4}", Foo), "Foo ");
assert_eq!(&format!("{:0>4}", Foo), "0Foo");

`pub fn write_str(&mut self, data: &str) -> Result<(), Error>`[src]

Writes some data to the underlying buffer contained within this formatter.

Examples

use std::fmt;

struct Foo;

impl fmt::Display for Foo {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("Foo")
        // This is equivalent to:
        // write!(formatter, "Foo")
    }
}

assert_eq!(&format!("{}", Foo), "Foo");
assert_eq!(&format!("{:0>8}", Foo), "Foo");

`pub fn write_fmt(&mut self, fmt: Arguments<'_>) -> Result<(), Error>`[src]

Writes some formatted information into this instance.

Examples

use std::fmt;

struct Foo(i32);

impl fmt::Display for Foo {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_fmt(format_args!("Foo {}", self.0))
    }
}

assert_eq!(&format!("{}", Foo(-1)), "Foo -1");
assert_eq!(&format!("{:0>8}", Foo(2)), "Foo 2");

`pub fn flags(&self) -> u32`[src]

👎 Deprecated since 1.24.0: use the sign_plus, sign_minus, alternate, or sign_aware_zero_pad methods instead

Flags for formatting

`pub fn fill(&self) -> char`[src]1.5.0

Character used as 'fill' whenever there is alignment.

Examples

use std::fmt;

struct Foo;

impl fmt::Display for Foo {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let c = formatter.fill();
        if let Some(width) = formatter.width() {
            for _ in 0..width {
                write!(formatter, "{}", c)?;
            }
            Ok(())
        } else {
            write!(formatter, "{}", c)
        }
    }
}

// We set alignment to the left with ">".
assert_eq!(&format!("{:G>3}", Foo), "GGG");
assert_eq!(&format!("{:t>6}", Foo), "tttttt");

`pub fn align(&self) -> Option<Alignment>`[src]1.28.0

Flag indicating what form of alignment was requested.

Examples

extern crate core;

use std::fmt::{self, Alignment};

struct Foo;

impl fmt::Display for Foo {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let s = if let Some(s) = formatter.align() {
            match s {
                Alignment::Left    => "left",
                Alignment::Right   => "right",
                Alignment::Center  => "center",
            }
        } else {
            "into the void"
        };
        write!(formatter, "{}", s)
    }
}

assert_eq!(&format!("{:<}", Foo), "left");
assert_eq!(&format!("{:>}", Foo), "right");
assert_eq!(&format!("{:^}", Foo), "center");
assert_eq!(&format!("{}", Foo), "into the void");

`pub fn width(&self) -> Option<usize>`[src]1.5.0

Optionally specified integer width that the output should be.

Examples

use std::fmt;

struct Foo(i32);

impl fmt::Display for Foo {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        if let Some(width) = formatter.width() {
            // If we received a width, we use it
            write!(formatter, "{:width$}", &format!("Foo({})", self.0), width = width)
        } else {
            // Otherwise we do nothing special
            write!(formatter, "Foo({})", self.0)
        }
    }
}

assert_eq!(&format!("{:10}", Foo(23)), "Foo(23)   ");
assert_eq!(&format!("{}", Foo(23)), "Foo(23)");

`pub fn precision(&self) -> Option<usize>`[src]1.5.0

Optionally specified precision for numeric types. Alternatively, the maximum width for string types.

Examples

use std::fmt;

struct Foo(f32);

impl fmt::Display for Foo {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        if let Some(precision) = formatter.precision() {
            // If we received a precision, we use it.
            write!(formatter, "Foo({1:.*})", precision, self.0)
        } else {
            // Otherwise we default to 2.
            write!(formatter, "Foo({:.2})", self.0)
        }
    }
}

assert_eq!(&format!("{:.4}", Foo(23.2)), "Foo(23.2000)");
assert_eq!(&format!("{}", Foo(23.2)), "Foo(23.20)");

`pub fn sign_plus(&self) -> bool`[src]1.5.0

Determines if the + flag was specified.

Examples

use std::fmt;

struct Foo(i32);

impl fmt::Display for Foo {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        if formatter.sign_plus() {
            write!(formatter,
                   "Foo({}{})",
                   if self.0 < 0 { '-' } else { '+' },
                   self.0)
        } else {
            write!(formatter, "Foo({})", self.0)
        }
    }
}

assert_eq!(&format!("{:+}", Foo(23)), "Foo(+23)");
assert_eq!(&format!("{}", Foo(23)), "Foo(23)");

`pub fn sign_minus(&self) -> bool`[src]1.5.0

Determines if the - flag was specified.

Examples

use std::fmt;

struct Foo(i32);

impl fmt::Display for Foo {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        if formatter.sign_minus() {
            // You want a minus sign? Have one!
            write!(formatter, "-Foo({})", self.0)
        } else {
            write!(formatter, "Foo({})", self.0)
        }
    }
}

assert_eq!(&format!("{:-}", Foo(23)), "-Foo(23)");
assert_eq!(&format!("{}", Foo(23)), "Foo(23)");

`pub fn alternate(&self) -> bool`[src]1.5.0

Determines if the # flag was specified.

Examples

use std::fmt;

struct Foo(i32);

impl fmt::Display for Foo {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        if formatter.alternate() {
            write!(formatter, "Foo({})", self.0)
        } else {
            write!(formatter, "{}", self.0)
        }
    }
}

assert_eq!(&format!("{:#}", Foo(23)), "Foo(23)");
assert_eq!(&format!("{}", Foo(23)), "23");

`pub fn sign_aware_zero_pad(&self) -> bool`[src]1.5.0

Determines if the 0 flag was specified.

Examples

use std::fmt;

struct Foo(i32);

impl fmt::Display for Foo {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        assert!(formatter.sign_aware_zero_pad());
        assert_eq!(formatter.width(), Some(4));
        // We ignore the formatter's options.
        write!(formatter, "{}", self.0)
    }
}

assert_eq!(&format!("{:04}", Foo(23)), "23");

`pub fn debug_struct(&'b mut self, name: &str) -> DebugStruct<'b, 'a>`[src]1.2.0

Creates a DebugStruct builder designed to assist with creation of fmt::Debug implementations for structs.

Examples

use std::fmt;
use std::net::Ipv4Addr;

struct Foo {
    bar: i32,
    baz: String,
    addr: Ipv4Addr,
}

impl fmt::Debug for Foo {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        fmt.debug_struct("Foo")
            .field("bar", &self.bar)
            .field("baz", &self.baz)
            .field("addr", &format_args!("{}", self.addr))
            .finish()
    }
}

assert_eq!(
    "Foo { bar: 10, baz: \"Hello World\", addr: 127.0.0.1 }",
    format!("{:?}", Foo {
        bar: 10,
        baz: "Hello World".to_string(),
        addr: Ipv4Addr::new(127, 0, 0, 1),
    })
);

`pub fn debug_tuple(&'b mut self, name: &str) -> DebugTuple<'b, 'a>`[src]1.2.0

Creates a DebugTuple builder designed to assist with creation of fmt::Debug implementations for tuple structs.

Examples

use std::fmt;
use std::marker::PhantomData;

struct Foo<T>(i32, String, PhantomData<T>);

impl<T> fmt::Debug for Foo<T> {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        fmt.debug_tuple("Foo")
            .field(&self.0)
            .field(&self.1)
            .field(&format_args!("_"))
            .finish()
    }
}

assert_eq!(
    "Foo(10, \"Hello\", _)",
    format!("{:?}", Foo(10, "Hello".to_string(), PhantomData::<u8>))
);

`pub fn debug_list(&'b mut self) -> DebugList<'b, 'a>`[src]1.2.0

Creates a DebugList builder designed to assist with creation of fmt::Debug implementations for list-like structures.

Examples

use std::fmt;

struct Foo(Vec<i32>);

impl fmt::Debug for Foo {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        fmt.debug_list().entries(self.0.iter()).finish()
    }
}

assert_eq!(format!("{:?}", Foo(vec![10, 11])), "[10, 11]");

`pub fn debug_set(&'b mut self) -> DebugSet<'b, 'a>`[src]1.2.0

Creates a DebugSet builder designed to assist with creation of fmt::Debug implementations for set-like structures.

Examples

use std::fmt;

struct Foo(Vec<i32>);

impl fmt::Debug for Foo {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        fmt.debug_set().entries(self.0.iter()).finish()
    }
}

assert_eq!(format!("{:?}", Foo(vec![10, 11])), "{10, 11}");

In this more complex example, we use format_args! and .debug_set() to build a list of match arms:

use std::fmt;

struct Arm<'a, L: 'a, R: 'a>(&'a (L, R));
struct Table<'a, K: 'a, V: 'a>(&'a [(K, V)], V);

impl<'a, L, R> fmt::Debug for Arm<'a, L, R>
where
    L: 'a + fmt::Debug, R: 'a + fmt::Debug
{
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        L::fmt(&(self.0).0, fmt)?;
        fmt.write_str(" => ")?;
        R::fmt(&(self.0).1, fmt)
    }
}

impl<'a, K, V> fmt::Debug for Table<'a, K, V>
where
    K: 'a + fmt::Debug, V: 'a + fmt::Debug
{
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        fmt.debug_set()
        .entries(self.0.iter().map(Arm))
        .entry(&Arm(&(format_args!("_"), &self.1)))
        .finish()
    }
}

`pub fn debug_map(&'b mut self) -> DebugMap<'b, 'a>`[src]1.2.0

Creates a DebugMap builder designed to assist with creation of fmt::Debug implementations for map-like structures.

Examples

use std::fmt;

struct Foo(Vec<(String, i32)>);

impl fmt::Debug for Foo {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        fmt.debug_map().entries(self.0.iter().map(|&(ref k, ref v)| (k, v))).finish()
    }
}

assert_eq!(
    format!("{:?}",  Foo(vec![("A".to_string(), 10), ("B".to_string(), 11)])),
    r#"{"A": 10, "B": 11}"#
 );

Trait Implementations

`impl<'_> Write for Formatter<'_>`[src]1.2.0

`fn write_str(&mut self, s: &str) -> Result<(), Error>`[src]

`fn write_char(&mut self, c: char) -> Result<(), Error>`[src]

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

Auto Trait Implementations

`impl<'a> !RefUnwindSafe for Formatter<'a>`

`impl<'a> !Send for Formatter<'a>`

`impl<'a> !Sync for Formatter<'a>`

`impl<'a> Unpin for Formatter<'a>`

`impl<'a> !UnwindSafe for Formatter<'a>`

Blanket Implementations

`impl<T> Any for T where T: 'static + ?Sized,` [src]

`fn type_id(&self) -> TypeId`[src]

`impl<T> Borrow<T> for T where T: ?Sized,` [src]

fn borrow(&self) -> &TⓘNotable traits for &'_ mut F
impl<'_, F> Future for &'_ mut F where
    F: Unpin + Future + ?Sized, 
    type Output = <F as Future>::Output;
impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized, 
    type Item = <I as Iterator>::Item;
impl<R: Read + ?Sized, '_> Read for &'_ mut R
impl<W: Write + ?Sized, '_> Write for &'_ mut W

[src]

`impl<T> BorrowMut<T> for T where T: ?Sized,` [src]

fn borrow_mut(&mut self) -> &mut TⓘNotable traits for &'_ mut F
impl<'_, F> Future for &'_ mut F where
    F: Unpin + Future + ?Sized, 
    type Output = <F as Future>::Output;
impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized, 
    type Item = <I as Iterator>::Item;
impl<R: Read + ?Sized, '_> Read for &'_ mut R
impl<W: Write + ?Sized, '_> Write for &'_ mut W

[src]

`impl<T> From<T> for T`[src]

`fn from(t: T) -> T`[src]

`impl<T, U> Into for T where U: From<T>,` [src]

`fn into(self) -> U`[src]

`impl<T, U> TryFrom for T where U: Into<T>,` [src]

`type Error = Infallible`

The type returned in the event of a conversion error.

`fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>`[src]

`impl<T, U> TryInto for T where U: TryFrom<T>,` [src]

`type Error = >::Error`

The type returned in the event of a conversion error.

`fn try_into(self) -> Result<U, >::Error>`[src]

© 2010 The Rust Project Developers
Licensed under the Apache License, Version 2.0 or the MIT license, at your option.
https://doc.rust-lang.org/std/fmt/struct.Formatter.html

Struct std::fmt::Formatter

Implementations

impl<'a> Formatter<'a>[src]

pub fn pad_integral( &mut self, is_nonnegative: bool, prefix: &str, buf: &str) -> Result<(), Error>[src]

Arguments

Examples

pub fn pad(&mut self, s: &str) -> Result<(), Error>[src]

Examples

pub fn write_str(&mut self, data: &str) -> Result<(), Error>[src]

Examples

pub fn write_fmt(&mut self, fmt: Arguments<'_>) -> Result<(), Error>[src]

Examples

pub fn flags(&self) -> u32[src]

pub fn fill(&self) -> char[src]1.5.0

Examples

pub fn align(&self) -> Option<Alignment>[src]1.28.0

Examples

pub fn width(&self) -> Option<usize>[src]1.5.0

Examples

pub fn precision(&self) -> Option<usize>[src]1.5.0

Examples

pub fn sign_plus(&self) -> bool[src]1.5.0

Examples

pub fn sign_minus(&self) -> bool[src]1.5.0

Examples

pub fn alternate(&self) -> bool[src]1.5.0

Examples

pub fn sign_aware_zero_pad(&self) -> bool[src]1.5.0

Examples

pub fn debug_struct(&'b mut self, name: &str) -> DebugStruct<'b, 'a>[src]1.2.0

Examples

pub fn debug_tuple(&'b mut self, name: &str) -> DebugTuple<'b, 'a>[src]1.2.0

Examples

pub fn debug_list(&'b mut self) -> DebugList<'b, 'a>[src]1.2.0

Examples

pub fn debug_set(&'b mut self) -> DebugSet<'b, 'a>[src]1.2.0

Examples

pub fn debug_map(&'b mut self) -> DebugMap<'b, 'a>[src]1.2.0

Examples

Trait Implementations

impl<'_> Write for Formatter<'_>[src]1.2.0

fn write_str(&mut self, s: &str) -> Result<(), Error>[src]

fn write_char(&mut self, c: char) -> Result<(), Error>[src]

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

Auto Trait Implementations

impl<'a> !RefUnwindSafe for Formatter<'a>

impl<'a> !Send for Formatter<'a>

impl<'a> !Sync for Formatter<'a>

impl<'a> Unpin for Formatter<'a>

impl<'a> !UnwindSafe for Formatter<'a>

Blanket Implementations

impl<T> Any for T where T: 'static + ?Sized, [src]

fn type_id(&self) -> TypeId[src]

impl<T> Borrow<T> for T where T: ?Sized, [src]

Notable traits for &'_ mut F

impl<T> BorrowMut<T> for T where T: ?Sized, [src]

Notable traits for &'_ mut F

impl<T> From<T> for T[src]

fn from(t: T) -> T[src]

impl<T, U> Into<U> for T where U: From<T>, [src]

fn into(self) -> U[src]

impl<T, U> TryFrom<U> for T where U: Into<T>, [src]

type Error = Infallible

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]

impl<T, U> TryInto<U> for T where U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>[src]

`impl<'a> Formatter<'a>`[src]

`pub fn pad_integral( &mut self, is_nonnegative: bool, prefix: &str, buf: &str ) -> Result<(), Error>`[src]

`pub fn pad(&mut self, s: &str) -> Result<(), Error>`[src]

`pub fn write_str(&mut self, data: &str) -> Result<(), Error>`[src]

`pub fn write_fmt(&mut self, fmt: Arguments<'_>) -> Result<(), Error>`[src]

`pub fn flags(&self) -> u32`[src]

`pub fn fill(&self) -> char`[src]1.5.0

`pub fn align(&self) -> Option<Alignment>`[src]1.28.0

`pub fn width(&self) -> Option<usize>`[src]1.5.0

`pub fn precision(&self) -> Option<usize>`[src]1.5.0

`pub fn sign_plus(&self) -> bool`[src]1.5.0

`pub fn sign_minus(&self) -> bool`[src]1.5.0

`pub fn alternate(&self) -> bool`[src]1.5.0

`pub fn sign_aware_zero_pad(&self) -> bool`[src]1.5.0

`pub fn debug_struct(&'b mut self, name: &str) -> DebugStruct<'b, 'a>`[src]1.2.0

`pub fn debug_tuple(&'b mut self, name: &str) -> DebugTuple<'b, 'a>`[src]1.2.0

`pub fn debug_list(&'b mut self) -> DebugList<'b, 'a>`[src]1.2.0

`pub fn debug_set(&'b mut self) -> DebugSet<'b, 'a>`[src]1.2.0

`pub fn debug_map(&'b mut self) -> DebugMap<'b, 'a>`[src]1.2.0

`impl<'_> Write for Formatter<'_>`[src]1.2.0

`fn write_str(&mut self, s: &str) -> Result<(), Error>`[src]

`fn write_char(&mut self, c: char) -> Result<(), Error>`[src]

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

`impl<'a> !RefUnwindSafe for Formatter<'a>`

`impl<'a> !Send for Formatter<'a>`

`impl<'a> !Sync for Formatter<'a>`

`impl<'a> Unpin for Formatter<'a>`

`impl<'a> !UnwindSafe for Formatter<'a>`

`impl<T> Any for T where T: 'static + ?Sized,` [src]

`fn type_id(&self) -> TypeId`[src]

`impl<T> Borrow<T> for T where T: ?Sized,` [src]

`impl<T> BorrowMut<T> for T where T: ?Sized,` [src]

`impl<T> From<T> for T`[src]

`fn from(t: T) -> T`[src]

`impl<T, U> Into<U> for T where U: From<T>,` [src]

`fn into(self) -> U`[src]

`impl<T, U> TryFrom<U> for T where U: Into<T>,` [src]

`type Error = Infallible`

`fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>`[src]

`impl<T, U> TryInto<U> for T where U: TryFrom<T>,` [src]

`type Error = <U as TryFrom<T>>::Error`

`fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>`[src]