Struct readable::Percent

pub struct Percent(_, _);

Human readable percentage.

Takes a floating point number as input and returns a ready-to-print!() Percent.

The default From implementation will print 2 decimal numbers.

Anything lower than 0.01 is rounded down to 0.00.

This can be changed by using different functions when initially creating the Percent, or converting an existing Percent, for example:

let f0 = Percent::new_0_point(3.0);
let f2 = Percent::from(3.0);
let f3 = Percent::new_3_point(3.0);
let f4 = Percent::new_4_point(3.0);

assert!(f0 == "3%");
assert!(f2 == "3.00%");
assert!(f3 == "3.000%");
assert!(f4 == "3.0000%");

Performance

The actual string used internally is not a String, but a CompactString so that any string 24 bytes (12 bytes on 32-bit) or less are stack allocated instead of heap allocated.

The documentation will still refer to the inner string as a String. Anything returned will also be a String.

Exceptions

• f64::NAN outputs NAN
• f64::INFINITY outputs INFINITY

To disable checks for these, (you are sure you don’t have NaN’s), enable the ignore_nan_inf feature flag.

Examples

assert!(Percent::zero()    == "0.00%");
assert!(Percent::unknown() == "?.??%");

assert!(Percent::from(0.001)   == "0.00%");
assert!(Percent::from(0.1)     == "0.10%");
assert!(Percent::from(1.0)     == "1.00%");
assert!(Percent::from(100.0)   == "100.00%");
assert!(Percent::from(1_000.0) == "1,000.00%");

assert!(Percent::from(1_u64)      == "1.00%");
assert!(Percent::from(1_000_u64)  == "1,000.00%");
assert!(Percent::from(10_000_u64) == "10,000.00%");

assert!(Percent::from(-1_i64)      == "-1.00%");
assert!(Percent::from(-1_000_i64)  == "-1,000.00%");
assert!(Percent::from(-10_000_i64) == "-10,000.00%");

Implementations

impl Percent

pub fn zero() -> Self

Returns a Self with the f64 value of 0.0.

The String is set to 0.00%.

pub fn unknown() -> Self

Returns a Self with the f64 value of f64::NAN.

The String is set to ?.??%.

pub fn nan() -> Self

Returns a Self with the f64 value of f64::NAN.

The String is set to NaN.

pub fn inf() -> Self

Returns a Self with the f64 value of f64::INFINITY.

The String is set to ∞.

pub fn new_0_point(f: f64) -> Self

Same as Self::from but with no floating point on the inner String.

The inner f64 stays the same as the input.

This does not round up or down, it completely ignores the floating point.

Examples

Input	String Output
0.0	0%
50.123	50%
100.1	100%

pub fn new_1_point(f: f64) -> Self

Same as Self::from but with 1 floating point.

pub fn new_3_point(f: f64) -> Self

Same as Self::from but with 3 floating point.

pub fn new_4_point(f: f64) -> Self

Same as Self::from but with 4 floating point.

pub fn new_5_point(f: f64) -> Self

Same as Self::from but with 5 floating point.

pub fn new_6_point(f: f64) -> Self

Same as Self::from but with 6 floating point.

Trait Implementations

impl AsRef<str> for Percent

fn as_ref(&self) -> &str

Converts this type into a shared reference of the (usually inferred) input type.

impl Borrow<str> for Percent

fn borrow(&self) -> &str

Immutably borrows from an owned value.

impl Clone for Percent

fn clone(&self) -> Percent

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Percent

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Percent

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Percent

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

Formats the value using the given formatter.

impl From<f32> for Percent

fn from(number: f32) -> Self

Converts to this type from the input type.

impl From<f64> for Percent

fn from(number: f64) -> Self

Converts to this type from the input type.

impl From<i16> for Percent

fn from(number: i16) -> Self

Converts to this type from the input type.

impl From<i32> for Percent

fn from(number: i32) -> Self

Converts to this type from the input type.

impl From<i64> for Percent

fn from(number: i64) -> Self

Converts to this type from the input type.

impl From<i8> for Percent

fn from(number: i8) -> Self

Converts to this type from the input type.

impl From<isize> for Percent

fn from(number: isize) -> Self

Converts to this type from the input type.

impl From<u16> for Percent

fn from(number: u16) -> Self

Converts to this type from the input type.

impl From<u32> for Percent

fn from(number: u32) -> Self

Converts to this type from the input type.

impl From<u64> for Percent

fn from(number: u64) -> Self

Converts to this type from the input type.

impl From<u8> for Percent

fn from(number: u8) -> Self

Converts to this type from the input type.

impl From<usize> for Percent

fn from(number: usize) -> Self

Converts to this type from the input type.

impl PartialEq<&Percent> for f64

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<&Percent> for str

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<&str> for Percent

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<Percent> for Percent

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<Percent> for f64

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<Percent> for str

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<f64> for &Percent

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<f64> for Percent

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<str> for Percent

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialOrd<Percent> for Percent

fn partial_cmp(&self, other: &Percent) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for Percent

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Percent