Struct num_runtime_fmt::Builder [−][src]
Builder for a numeric formatter.
Implementations
impl Builder
[src]
pub fn new() -> Builder
[src]
Construct a new Builder
.
pub fn build(self) -> NumFmt
[src]
Build a NumFmt
instance, consuming this builder.
pub fn fill(self, param: char) -> Self
[src]
When width
is greater than the actual rendered width of the number, the excess is padded
with this character.
Note
Wide characters are counted according to their quantity, not their bit width.
let heart = '🖤'; assert_eq!(heart.len_utf8(), 4); let fmt = NumFmt::builder().fill(heart).width(3).build(); let formatted = fmt.fmt(1).unwrap(); assert_eq!(formatted, "🖤🖤1"); // Note that even though we requested a width of 3, the binary length is 9. assert_eq!(formatted.len(), 9);
pub fn align(self, param: Align) -> Self
[src]
Set the alignment of rendering within allotted width
. See Align
.
pub fn sign(self, param: Sign) -> Self
[src]
Set the rendering of the sign. See Sign
.
pub fn hash(self, set: bool) -> Self
[src]
If a set
, print a base specification before the number
according to its format.
See Builder::format
.
- binary:
0b
- octal:
0o
- decimal:
0d
- hex:
0x
Corresponds to the #
format specifier.
pub fn zero(self, set: bool) -> Self
[src]
If set
, engage the zero handler.
The zero handler overrides the padding specification to 0
, and
treats pad characters as part of the number, in contrast
to the default behavior which treats them as arbitrary spacing.
Only valid with Align::Right
and Align::Decimal
.
Examples
// sign handling assert_eq!(NumFmt::from_str("03").unwrap().fmt(-1).unwrap(), "-01"); assert_eq!(NumFmt::from_str("0>3").unwrap().fmt(-1).unwrap(), "0-1");
// separator handling assert_eq!(NumFmt::from_str("0>7,").unwrap().fmt(1).unwrap(), "0000001"); assert_eq!(NumFmt::from_str("07,").unwrap().fmt(1).unwrap(), "000,001");
pub fn width(self, param: usize) -> Self
[src]
Set the width
parameter.
This is a parameter for the “minimum width” that the format should take up. If
the value’s string does not fill up this many characters, then the padding
specified by fill/alignment will be used to take up the required space (see
Builder::fill
).
The width can be set dynamically:
assert_eq!(NumFmt::from_str("-^").unwrap().fmt_with(1, Dynamic::width(5)).unwrap(), "--1--");
Note: with Align::Right
, this is the minimum width of the entire rendered field,
not just the portion before the decimal. To set the width before the decimal,
use Align::Decimal
.
assert_eq!(NumFmt::from_str( "05").unwrap().fmt(1.1).unwrap(), "001.1"); assert_eq!(NumFmt::from_str(">05").unwrap().fmt(1.1).unwrap(), "001.1"); assert_eq!(NumFmt::from_str("v05").unwrap().fmt(1.1).unwrap(), "00001.1");
pub fn precision(self, param: Option<usize>) -> Self
[src]
Set the precision
parameter.
How many digits after the decimal point are printed. Note that integers can be forced to emit decimal places with this modifier.
Precision will pad or truncate as required if set. If unset, passes through as many digits past the decimal as the underlying type naturally returns.
assert_eq!(NumFmt::from_str(".2").unwrap().fmt(3.14159).unwrap(), "3.14"); assert_eq!(NumFmt::from_str(".7").unwrap().fmt(3.14159).unwrap(), "3.1415900");
If the requested precision exceeds the native precision available to this number,
the remainder is always filled with '0'
, even if fill
is specified:
assert_eq!(NumFmt::from_str("-<6.2").unwrap().fmt(1.0_f32).unwrap(), "1.00--");
pub fn base(self, param: Base) -> Self
[src]
Set the output format.
See Base
.
pub fn separator(self, param: Option<char>) -> Self
[src]
Set the separator.
A separator is a (typically non-numeric) character inserted between groups of digits to make it easier for humans to parse the number when reading. Different separators may be desirable in different contexts.
pub fn spacing(self, param: usize) -> Self
[src]
Set the spacing.
Spacing determines the number of characters in each character group. It is only of interest when the separator is set. The default spacing is 3.
pub fn decimal_separator(self, param: char) -> Self
[src]
Set the decimal separator.
This can be desirable to i.e. support German number formats, which use a .
to separate
numeric groups and a ,
as a decimal separator.
Trait Implementations
impl Clone for Builder
[src]
impl Debug for Builder
[src]
impl Default for Builder
[src]
impl Eq for Builder
[src]
impl From<NumFmt> for Builder
[src]
fn from(
NumFmt { fill: fill, align: align, sign: sign, hash: hash, zero: zero, width: width, precision: precision, base: format, separator: separator, spacing: spacing, decimal_separator: decimal_separator }: NumFmt
) -> Self
[src]
NumFmt { fill: fill, align: align, sign: sign, hash: hash, zero: zero, width: width, precision: precision, base: format, separator: separator, spacing: spacing, decimal_separator: decimal_separator }: NumFmt
) -> Self
impl PartialEq<Builder> for Builder
[src]
impl StructuralEq for Builder
[src]
impl StructuralPartialEq for Builder
[src]
Auto Trait Implementations
impl RefUnwindSafe for Builder
impl Send for Builder
impl Sync for Builder
impl Unpin for Builder
impl UnwindSafe for Builder
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
pub fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
pub fn to_owned(&self) -> T
[src]
pub fn clone_into(&self, target: &mut T)
[src]
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
pub 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]
U: TryFrom<T>,