Struct AdjustedBit

pub struct AdjustedBit { /* private fields */ }

Available on crate feature bit only.

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

Available on crate feature serde only.

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<'r> FromFormField<'r> for AdjustedBit

Available on crate feature rocket only.

fn from_value(v: ValueField<'r>) -> Result<'r, Self>

Parse a value of T from a form value field.

fn from_data<'life0, 'async_trait>( field: DataField<'v, 'life0>, ) -> Pin<Box<dyn Future<Output = Result<Self, Errors<'v>>> + Send + 'async_trait>>

where 'v: 'async_trait, 'life0: 'async_trait, Self: 'async_trait,

Parse a value of T from a form data field.

fn default() -> Option<Self>

Returns a default value, if any exists, to be used during lenient parsing when the form field is missing.

impl<'r> FromParam<'r> for AdjustedBit

Available on crate feature rocket only.

type Error = ParseError

The associated error to be returned if parsing/validation fails.

fn from_param(v: &'r str) -> Result<Self, Self::Error>

Parses and validates an instance of Self from a path parameter string or returns an Error if parsing or validation fails.

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,

Restrict a value to a certain interval.

impl PartialEq for AdjustedBit

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

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.

impl Serialize for AdjustedBit

Available on crate feature serde only.

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