Struct NumFmt

pub struct NumFmt { /* private fields */ }

The number formatter configurations. See the module documentation for use.

Formatter has a FromStr implementation that can parse a string into a formatter using a specific grammar. Please consult the parsing section in the module documentation.

Implementations

impl Formatter

pub fn new() -> Formatter

Construct a new formatter.

No scaling is set, so this is only does a single allocation for the buffer.

Example

let mut f = Formatter::new();
assert_eq!(f.fmt(12345.6789), "12345.6789");

pub fn currency(prefix: &str) -> Result<Formatter, Error>

Create a formatter that formats numbers as a currency.

Example

let mut f = Formatter::currency("$").unwrap();
assert_eq!(f.fmt(12345.6789), "$12,345.67");
assert_eq!(f.fmt(1234_f64), "$1,234.0");

pub fn percentage() -> Formatter

Create a formatter that formats numbers as a percentage.

Example

let mut f = Formatter::percentage();
assert_eq!(f.fmt(0.678912), "67.8912%");
assert_eq!(f.fmt(1.23), "123.0%");
assert_eq!(f.fmt(1.2), "120.0%");

f = f.precision(Precision::Decimals(2));
assert_eq!(f.fmt(0.01234), "1.23%");

pub fn convert(self, f: fn(_: f64) -> f64) -> Formatter

Set the value converter.

Use a converter to transform the input number into another number. This is done before all steps and the number follows the same procedure as normal. A good example of a use of a converter is to make a percentage number by always multiplying by 100.

pub fn precision(self, precision: Precision) -> Formatter

Set the precision.

pub fn scales(self, scales: Scales) -> Formatter

Set the scaling.

pub fn build_scales( self, base: u16, units: Vec<&'static str>, ) -> Result<Formatter, Error>

Set the scaling via Scales::new.

pub fn separator<S>(self, sep: S) -> Result<Formatter, Error>

where S: Into<Option<char>>,

Set the thousands separator.

If separator is not a single byte, an error is returned. If the separator is a period ., this signals to use a comma for the decimal marker.

Example

let mut f = Formatter::new().separator(',').unwrap(); // use a comma
assert_eq!(f.fmt(12345.67), "12,345.67");

f = f.separator(' ').unwrap(); // use a space
assert_eq!(f.fmt(12345.67), "12 345.67");

f = f.separator(None).unwrap(); // no separator
assert_eq!(f.fmt(12345.67), "12345.67");

f = f.separator('.').unwrap(); // use a period separator and comma for decimal
assert_eq!(f.fmt(12345.67), "12.345,67");

pub fn comma(self, comma: bool) -> Formatter

Set the comma option.

If set to true it will use a comma instead of a period. If a comma is the separator, a period will be used instead.

Example

let mut f = Formatter::new();
assert_eq!(f.fmt(12345.67), "12345.67");
f = f.comma(true);
assert_eq!(f.fmt(12345.67), "12345,67");

f = f.separator('.').unwrap();
assert_eq!(f.fmt(12345.67), "12.345,67");

pub fn prefix(self, prefix: &str) -> Result<Formatter, Error>

Sets the prefix.

If the prefix is longer than the supported length, an error is returned.

pub fn suffix(self, suffix: &str) -> Result<Formatter, Error>

Set the suffix.

If the suffix is longer than the supported length, an error is returned.

pub fn fmt(&mut self, num: f64) -> &str

👎Deprecated: consider using Formatter::fmt2 instead

Format the number!

pub fn fmt2<N>(&mut self, num: N) -> &str

where N: Numeric,

Format any number implementing Numeric.

Trait Implementations

impl Clone for Formatter

fn clone(&self) -> Formatter

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Formatter

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for Formatter

fn default() -> Formatter

Returns the “default value” for a type.

impl FromStr for Formatter

type Err = ParseError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Formatter, ParseError>

Parses a string s to return a value of this type.

impl Hash for Formatter

fn hash<H>(&self, hasher: &mut H)

where H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Formatter

fn eq(&self, other: &Formatter) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for Formatter