Struct byte_unit::AdjustedBit

pub struct AdjustedBit { /* private fields */ }

Generated from the Bit::get_adjusted_unit method or the the Bit::get_appropriate_unit method.

For accuracy representation, utilize the Bit struct.

Implementations

impl AdjustedBit

Methods for getting values.

pub const fn get_value(&self) -> f64

Get the value.

pub const fn get_unit(&self) -> Unit

Get the unit.

pub fn get_bit(&self) -> Bit

Create a new Bit instance from this AdjustedBit instance.

Examples

use byte_unit::{Bit, Unit};

let bit = Bit::from_u64_with_unit(1555, Unit::Kbit).unwrap();

let adjusted_bit = bit.get_adjusted_unit(Unit::Mbit);

let bit_back = adjusted_bit.get_bit();

assert_eq!(bit, bit_back);

Points to Note

• The result may not be logically equal to the original Bit instance due to the accuracy of floating-point numbers.

Trait Implementations

impl Clone for AdjustedBit

fn clone(&self) -> AdjustedBit

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for AdjustedBit

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for AdjustedBit

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for AdjustedBit

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

Formats the value using the given formatter.

Examples

use byte_unit::{Bit, Unit};

let bit = Bit::from_u64_with_unit(1555, Unit::Kbit).unwrap();

let adjusted_bit = bit.get_adjusted_unit(Unit::Mbit);

assert_eq!("1.555 Mb", adjusted_bit.to_string());

use byte_unit::{Bit, UnitType};

let bit = Bit::from_u64(10000);

let adjusted_bit_based_2 = bit.get_appropriate_unit(UnitType::Binary);
let adjusted_bit_based_10 = bit.get_appropriate_unit(UnitType::Decimal);

assert_eq!("9.765625 Kib", format!("{adjusted_bit_based_2}"));
assert_eq!("10 Kb", format!("{adjusted_bit_based_10}"));

// with precision
assert_eq!("9.77 Kib", format!("{adjusted_bit_based_2:.2}"));
assert_eq!("10.00 Kb", format!("{adjusted_bit_based_10:.2}"));

// without any unnecessary fractional part
assert_eq!("9.77 Kib", format!("{adjusted_bit_based_2:#.2}"));
assert_eq!("10 Kb", format!("{adjusted_bit_based_10:#.2}"));

// with a width, left alignment
assert_eq!("9.77   Kib", format!("{adjusted_bit_based_2:10.2}"));
assert_eq!("10.00   Kb", format!("{adjusted_bit_based_10:10.2}"));

// with a width, right alignment
assert_eq!("  9.77 Kib", format!("{adjusted_bit_based_2:>10.2}"));
assert_eq!("  10.00 Kb", format!("{adjusted_bit_based_10:>10.2}"));

// with a width, right alignment, more spaces between the value and the unit
assert_eq!("  9.77 Kib", format!("{adjusted_bit_based_2:>+10.2}"));
assert_eq!(" 10.00  Kb", format!("{adjusted_bit_based_10:>+10.2}"));

// no spaces between the value and the unit
assert_eq!("9.765625Kib", format!("{adjusted_bit_based_2:-}"));
assert_eq!("10Kb", format!("{adjusted_bit_based_10:-}"));

impl From<AdjustedBit> for Bit

fn from(value: AdjustedBit) -> Self

Converts to this type from the input type.

impl From<AdjustedBit> for Unit

fn from(value: AdjustedBit) -> Self

Converts to this type from the input type.

impl From<AdjustedBit> for f64

fn from(value: AdjustedBit) -> Self

Converts to this type from the input type.

impl From<Bit> for AdjustedBit

fn from(value: Bit) -> Self

unit_type is set to UnitType::Both. See Bit::get_appropriate_unit.

impl FromStr for AdjustedBit

fn from_str(s: &str) -> Result<Self, Self::Err>

• unit_type is set to UnitType::Both. See Bit::get_appropriate_unit.

type Err = ParseError

The associated error which can be returned from parsing.

impl Ord for AdjustedBit

fn cmp(&self, other: &AdjustedBit) -> 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 + PartialOrd,

Restrict a value to a certain interval.

impl PartialEq for AdjustedBit

fn eq(&self, other: &AdjustedBit) -> 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 for AdjustedBit

fn partial_cmp(&self, other: &AdjustedBit) -> 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 AdjustedBit

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for AdjustedBit

impl Eq for AdjustedBit