Struct Percentage 

pub struct Percentage<T: Copy + Into<f64>> { /* private fields */ }

A percentage value represented as a number.

This type wraps an underlying numeric type, and ensures that callers are clear whether they want a fraction, or a percentage.

Implementations

impl<T: Copy + Into<f64>> Percentage<T>

pub fn new(value: T) -> Self

Create a new IntPercentage from the underlying percentage.

pub fn as_fraction(self) -> f64

Return this value as a (possibly improper) fraction.

use tor_units::Percentage;
let pct_200 = Percentage::<u8>::new(200);
let pct_100 = Percentage::<u8>::new(100);
let pct_50 = Percentage::<u8>::new(50);

assert_eq!(pct_200.as_fraction(), 2.0);
assert_eq!(pct_100.as_fraction(), 1.0);
assert_eq!(pct_50.as_fraction(), 0.5);
// Note: don't actually compare f64 with ==.

pub fn as_percent(self) -> T

Return this value as a percentage.

use tor_units::Percentage;
let pct_200 = Percentage::<u8>::new(200);
let pct_100 = Percentage::<u8>::new(100);
let pct_50 = Percentage::<u8>::new(50);

assert_eq!(pct_200.as_percent(), 200);
assert_eq!(pct_100.as_percent(), 100);
assert_eq!(pct_50.as_percent(), 50);

Trait Implementations

impl<T: Clone + Copy + Into<f64>> Clone for Percentage<T>

fn clone(&self) -> Percentage<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug + Copy + Into<f64>> Debug for Percentage<T>

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

Formats the value using the given formatter.

impl<T: Hash + Copy + Into<f64>> Hash for Percentage<T>

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<T: PartialEq + Copy + Into<f64>> PartialEq for Percentage<T>

fn eq(&self, other: &Percentage<T>) -> 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<const H: i32, const L: i32> TryFrom<i32> for Percentage<BoundedInt32<H, L>>

type Error = Error

The type returned in the event of a conversion error.

fn try_from(v: i32) -> Result<Self, Error>

Performs the conversion.

impl<T: Copy + Copy + Into<f64>> Copy for Percentage<T>

impl<T: Eq + Copy + Into<f64>> Eq for Percentage<T>

impl<T: Copy + Into<f64>> StructuralPartialEq for Percentage<T>

Layout

Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.