Struct AdjustedByte

pub struct AdjustedByte { /* private fields */ }

Available on crate feature byte only.

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

For accuracy representation, utilize the Byte struct.

Implementations

impl AdjustedByte

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_byte(&self) -> Byte

Create a new Byte instance from this AdjustedByte instance.

Examples

use byte_unit::{Byte, Unit};

let byte = Byte::from_u64_with_unit(1555, Unit::KB).unwrap();

let adjusted_byte = byte.get_adjusted_unit(Unit::MB);

let byte_back = adjusted_byte.get_byte();

assert_eq!(byte, byte_back);

Points to Note

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

Trait Implementations

impl Clone for AdjustedByte

fn clone(&self) -> AdjustedByte

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for AdjustedByte

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for AdjustedByte

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 AdjustedByte

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

Formats the value using the given formatter.

Examples

use byte_unit::{Byte, Unit};

let byte = Byte::from_u64_with_unit(1555, Unit::KB).unwrap();

let adjusted_byte = byte.get_adjusted_unit(Unit::MB);

assert_eq!("1.555 MB", adjusted_byte.to_string());

use byte_unit::{Byte, UnitType};

let byte = Byte::from_u64(10000);

let adjusted_byte_based_2 = byte.get_appropriate_unit(UnitType::Binary);
let adjusted_byte_based_10 = byte.get_appropriate_unit(UnitType::Decimal);

assert_eq!("9.765625 KiB", format!("{adjusted_byte_based_2}"));
assert_eq!("10 KB", format!("{adjusted_byte_based_10}"));

// with precision
assert_eq!("9.77 KiB", format!("{adjusted_byte_based_2:.2}"));
assert_eq!("10.00 KB", format!("{adjusted_byte_based_10:.2}"));

// without any unnecessary fractional part
assert_eq!("9.77 KiB", format!("{adjusted_byte_based_2:#.2}"));
assert_eq!("10 KB", format!("{adjusted_byte_based_10:#.2}"));

// with a width, left alignment
assert_eq!("9.77   KiB", format!("{adjusted_byte_based_2:10.2}"));
assert_eq!("10.00   KB", format!("{adjusted_byte_based_10:10.2}"));

// with a width, right alignment
assert_eq!("  9.77 KiB", format!("{adjusted_byte_based_2:>10.2}"));
assert_eq!("  10.00 KB", format!("{adjusted_byte_based_10:>10.2}"));

// with a width, right alignment, more spaces between the value and the unit
assert_eq!("  9.77 KiB", format!("{adjusted_byte_based_2:>+10.2}"));
assert_eq!(" 10.00  KB", format!("{adjusted_byte_based_10:>+10.2}"));

// no spaces between the value and the unit
assert_eq!("9.765625KiB", format!("{adjusted_byte_based_2:-}"));
assert_eq!("10KB", format!("{adjusted_byte_based_10:-}"));

impl From<AdjustedByte> for Byte

fn from(value: AdjustedByte) -> Self

Converts to this type from the input type.

impl From<AdjustedByte> for Unit

fn from(value: AdjustedByte) -> Self

Converts to this type from the input type.

impl From<AdjustedByte> for f64

fn from(value: AdjustedByte) -> Self

Converts to this type from the input type.

impl From<Byte> for AdjustedByte

fn from(value: Byte) -> Self

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

impl<'r> FromFormField<'r> for AdjustedByte

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 AdjustedByte

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 AdjustedByte

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

• ignore_case is set to false. See Byte::parse_str.
• unit_type is set to UnitType::Both. See Byte::get_appropriate_unit.

type Err = ParseError

The associated error which can be returned from parsing.

impl Ord for AdjustedByte

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

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

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

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 AdjustedByte

impl Eq for AdjustedByte