Struct NicePercent 

pub struct NicePercent { /* private fields */ }

Nice Percent.

This struct can be used to quickly and efficiently stringify a “percent” — a float between 0.0..=1.0 — to a fixed precision of hundredths.

Values outside that range are “clamped” to make them make sense, percentage-wise. (NaN and negative values are treated like zero; large positives like one.)

Examples

use dactyl::NicePercent;

// From a ready-made float:
assert_eq!(
    NicePercent::from(0.55012345_f32).as_str(),
    "55.01%",
);

// From separate "done" and "total" integers.
assert_eq!(
    NicePercent::from((20_usize, 800_usize)).as_str(),
    "2.50%",
);

// From weird shit.
assert_eq!(
    NicePercent::from(-0.55012345_f32).as_str(), // Negative.
    "0.00%",
);
assert_eq!(
    NicePercent::from(f64::NAN).as_str(), // Not even a number!
    "0.00%",
);
assert_eq!(
    NicePercent::from(f64::NEG_INFINITY).as_str(), // Negative.
    "0.00%",
);
assert_eq!(
    NicePercent::from(55.012345_f32).as_str(), // Wrong scale.
    "100.00%",
);
assert_eq!(
    NicePercent::from(f64::INFINITY).as_str(), // So much more than one.
    "100.00%",
);

Implementations

impl NicePercent

pub const MIN: Self

Minimum Value.

The nice equivalent of 0.0.

Examples

use dactyl::NicePercent;

assert_eq!(
    NicePercent::MIN.as_str(),
    "0.00%",
);

pub const MAX: Self

Maximum Value.

The nice equivalent of 1.0.

Examples

use dactyl::NicePercent;

assert_eq!(
    NicePercent::MAX.as_str(),
    "100.00%",
);

impl NicePercent

pub const fn as_bytes(&self) -> &[u8]

As Byte Slice.

Return the value as a byte slice.

Examples

use dactyl::NicePercent;

assert_eq!(
    NicePercent::from(1.0_f32).as_bytes(),
    b"100.00%",
);

pub const fn as_str(&self) -> &str

As String Slice.

Return the value as a string slice.

Examples

use dactyl::NicePercent;

assert_eq!(
    NicePercent::from(1.0_f32).as_str(),
    "100.00%",
);

pub const fn is_empty(&self) -> bool

Is Empty?

No! Haha. But for consistency, this method exists.

pub const fn len(&self) -> usize

Length.

Return the length of the nice byte/string representation.

Note this will never be zero.

Examples

use dactyl::NicePercent;

let nice = NicePercent::MAX;
assert_eq!(
    nice.len(),
    nice.as_str().len(),
);

impl NicePercent

pub fn replace(&mut self, num: f32)

Replace.

Reuse the backing storage behind self to hold a new nice percent.

Examples.

use dactyl::NicePercent;

let mut num = NicePercent::from(0.85);
assert_eq!(num.as_str(), "85.00%");

num.replace(0.334);
assert_eq!(num.as_str(), "33.40%");

Trait Implementations

impl AsRef<[u8]> for NicePercent

fn as_ref(&self) -> &[u8]

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

impl AsRef<str> for NicePercent

fn as_ref(&self) -> &str

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

impl Borrow<str> for NicePercent

fn borrow(&self) -> &str

Immutably borrows from an owned value.

impl Clone for NicePercent

fn clone(&self) -> NicePercent

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for NicePercent

impl Debug for NicePercent

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

Formats the value using the given formatter.

impl Default for NicePercent

fn default() -> Self

Returns the “default value” for a type.

impl Display for NicePercent

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

Formats the value using the given formatter.

impl Eq for NicePercent

impl From<(i8, i8)> for NicePercent

fn from((e, d): (i8, i8)) -> Self

Percent From i8/i8.

Create a NicePercent from the division of two integers — e.g. a “done” and a “total” — leveraging NiceFloat::div_i8 for the nitty-gritty.

impl From<(i16, i16)> for NicePercent

fn from((e, d): (i16, i16)) -> Self

Percent From i16/i16.

Create a NicePercent from the division of two integers — e.g. a “done” and a “total” — leveraging NiceFloat::div_i16 for the nitty-gritty.

impl From<(i32, i32)> for NicePercent

fn from((e, d): (i32, i32)) -> Self

Percent From i32/i32.

Create a NicePercent from the division of two integers — e.g. a “done” and a “total” — leveraging NiceFloat::div_i32 for the nitty-gritty.

impl From<(i64, i64)> for NicePercent

fn from((e, d): (i64, i64)) -> Self

Percent From i64/i64.

Create a NicePercent from the division of two integers — e.g. a “done” and a “total” — leveraging NiceFloat::div_i64 for the nitty-gritty.

impl From<(i128, i128)> for NicePercent

fn from((e, d): (i128, i128)) -> Self

Percent From i128/i128.

Create a NicePercent from the division of two integers — e.g. a “done” and a “total” — leveraging NiceFloat::div_i128 for the nitty-gritty.

impl From<(isize, isize)> for NicePercent

fn from((e, d): (isize, isize)) -> Self

Percent From isize/isize.

Create a NicePercent from the division of two integers — e.g. a “done” and a “total” — leveraging NiceFloat::div_isize for the nitty-gritty.

impl From<(u8, u8)> for NicePercent

fn from((e, d): (u8, u8)) -> Self

Percent From u8/u8.

Create a NicePercent from the division of two integers — e.g. a “done” and a “total” — leveraging NiceFloat::div_u8 for the nitty-gritty.

impl From<(u16, u16)> for NicePercent

fn from((e, d): (u16, u16)) -> Self

Percent From u16/u16.

Create a NicePercent from the division of two integers — e.g. a “done” and a “total” — leveraging NiceFloat::div_u16 for the nitty-gritty.

impl From<(u32, u32)> for NicePercent

fn from((e, d): (u32, u32)) -> Self

Percent From u32/u32.

Create a NicePercent from the division of two integers — e.g. a “done” and a “total” — leveraging NiceFloat::div_u32 for the nitty-gritty.

impl From<(u64, u64)> for NicePercent

fn from((e, d): (u64, u64)) -> Self

Percent From u64/u64.

Create a NicePercent from the division of two integers — e.g. a “done” and a “total” — leveraging NiceFloat::div_u64 for the nitty-gritty.

impl From<(u128, u128)> for NicePercent

fn from((e, d): (u128, u128)) -> Self

Percent From u128/u128.

Create a NicePercent from the division of two integers — e.g. a “done” and a “total” — leveraging NiceFloat::div_u128 for the nitty-gritty.

impl From<(usize, usize)> for NicePercent

fn from((e, d): (usize, usize)) -> Self

Percent From usize/usize.

Create a NicePercent from the division of two integers — e.g. a “done” and a “total” — leveraging NiceFloat::div_usize for the nitty-gritty.

impl From<NicePercent> for String

fn from(src: NicePercent) -> Self

Converts to this type from the input type.

impl From<f32> for NicePercent

fn from(num: f32) -> Self

Percent From f32.

impl From<f64> for NicePercent

fn from(num: f64) -> Self

Percent From f64.

impl Hash for NicePercent

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

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 Ord for NicePercent

fn cmp(&self, rhs: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for NicePercent

fn eq(&self, rhs: &Self) -> 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 PartialOrd for NicePercent

fn partial_cmp(&self, rhs: &Self) -> Option<Ordering>

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

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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