Struct Formatter 

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

Structure containing options and scales used to format numbers with the right scale preffix, separators and units.

Implementations

impl<'a> Formatter<'a>

pub fn new(scales: Scales<'a>, options: Options<'a>) -> Self

Create a formatter with a given scale set and some options

pub fn set_force_sign(&mut self, force_sign: bool)

Forces the sign to be displayed.

pub fn with_force_sign(self, force_sign: bool) -> Self

Forces the sign to be displayed.

pub fn set_decimals(&mut self, decimals: usize)

Sets the number of decimals to display.

pub fn with_decimals(self, decimals: usize) -> Self

Sets the number of decimals to display.

pub fn set_unit<U: Into<Cow<'a, str>>>(&mut self, unit: U)

Sets the expected unit, like B for bytes or g for grams.

pub fn with_unit<U: Into<Cow<'a, str>>>(self, unit: U) -> Self

Sets the expected unit, like B for bytes or g for grams.

pub fn set_separator<U: Into<Cow<'a, str>>>(&mut self, separator: U)

Sets the separator between the number and the preffix.

pub fn with_separator<U: Into<Cow<'a, str>>>(self, separator: U) -> Self

Sets the separator between the number and the preffix.

pub fn format(&'a self, value: f64) -> ScaledValue<'a>

Formats a number and returns a scaled value that can be displayed.

impl Formatter<'static>

pub fn si() -> Self

Formatter that uses the SI format style

use human_number::Formatter;

let formatter = Formatter::si();
let result = format!("{}", formatter.format(4_234.0));
assert_eq!(result, "4.23 k");
let result = format!("{}", formatter.format(0.012_34));
assert_eq!(result, "12.34 m");

let formatter = Formatter::si().with_unit("g").with_separator("").with_decimals(1);
let result = format!("{}", formatter.format(4_234.0));
assert_eq!(result, "4.2kg");
let result = format!("{}", formatter.format(0.012_34));
assert_eq!(result, "12.3mg");

pub fn binary() -> Self

Formatter that uses the binary format style

use human_number::Formatter;

let formatter = Formatter::binary().with_unit("B");
let result = format!("{}", formatter.format(4_320_133.0));
assert_eq!(result, "4.12 MiB");

pub fn empty() -> Self

Formatter that doesn’t use a scale

use human_number::Formatter;

let formatter = Formatter::empty();
let result = format!("{}", formatter.format(25_000.0));
assert_eq!(result, "25000.00");

let formatter = Formatter::empty().with_unit("%");
let result = format!("{}", formatter.format(25.0));
assert_eq!(result, "25.00 %");

Trait Implementations

impl<'a> Clone for Formatter<'a>

fn clone(&self) -> Formatter<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Formatter<'a>

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

Formats the value using the given formatter.

impl<'a> PartialEq for Formatter<'a>

fn eq(&self, other: &Formatter<'a>) -> 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<'a> StructuralPartialEq for Formatter<'a>