Enum byte_unit::Unit

pub enum Unit {
    Bit,
    B,
    Kbit,
    Kibit,
    KB,
    KiB,
    Mbit,
    Mibit,
    MB,
    MiB,
    Gbit,
    Gibit,
    GB,
    GiB,
    Tbit,
    Tibit,
    TB,
    TiB,
    Pbit,
    Pibit,
    PB,
    PiB,
    Ebit,
    Eibit,
    EB,
    EiB,
    Zbit,
    Zibit,
    ZB,
    ZiB,
    Ybit,
    Yibit,
    YB,
    YiB,
}

The unit of bits/bytes.

Variants

Bit

8 Bit = 1 byte.

B

1 B = 1 byte.

Kbit

1 Kbit = 125 bytes.

Kibit

1 Kibit = 2⁷ bytes.

KB

1 KB = 10³ bytes.

KiB

1 KiB = 2¹⁰ bytes.

Mbit

1 Mbit = 125 * 10³ bytes.

Mibit

1 Mibit = 2¹⁷ bytes.

MB

1 MB = 10⁶ bytes.

MiB

1 MiB = 2²⁰ bytes.

Gbit

1 Gbit = 125 * 10⁶ bytes.

Gibit

1 Gibit = 2²⁷ bytes.

GB

1 GB = 10⁹ bytes.

GiB

1 GiB = 2³⁰ bytes.

Tbit

1 Tbit = 125 * 10⁹ bytes.

Tibit

1 Tibit = 2³⁷ bytes.

TB

1 TB = 10¹² bytes.

TiB

1 TiB = 2⁴⁰ bytes.

Pbit

1 Pbit = 125 * 10¹² bytes.

Pibit

1 Pibit = 2⁴⁷ bytes.

PB

1 PB = 10¹⁵ bytes.

PiB

1 PiB = 2⁵⁰ bytes.

Ebit

1 Ebit = 125 * 10¹⁵ bytes.

Eibit

1 Eibit = 2⁵⁷ bytes.

EB

1 EB = 10¹⁸ bytes.

EiB

1 EiB = 2⁶⁰ bytes.

Zbit

1 Zbit = 125 * 10¹⁸ bytes.

Zibit

1 Zibit = 2⁶⁷ bytes.

ZB

1 ZB = 10²¹ bytes.

ZiB

1 ZiB = 2⁷⁰ bytes.

Ybit

1 Ybit = 125 * 10²¹ bytes.

Yibit

1 Yibit = 2⁷⁷ bytes.

YB

1 YB = 10²⁴ bytes.

YiB

1 YiB = 2⁸⁰ bytes.

Implementations

impl Unit

Associated functions for parsing strings.

pub fn parse_str<S: AsRef<str>>( s: S, ignore_case: bool, prefer_byte: bool ) -> Result<Self, UnitParseError>

Create a new Unit instance from a string. The string may be "", "B", "M", "MB", "MiB", "b", "Mb", "Mbit".

You can ignore the case of “B” (byte), which means b will still be treated as bytes instead of bits.

If the input string is empty, it will return B if prefer_byte is true; otherwise, it will return b. Similarly, if the string is not empty but it does not explicitly contains "B", "b", or "bit", it will imply the base is "B" if prefer_byte is true; otherwise, imply the base is "b".

Examples

let unit = Unit::parse_str("Kib", true, true).unwrap(); // KiB

let unit = Unit::parse_str("Kib", false, true).unwrap(); // Kibit

impl Unit

Methods for converting a Unit instance into a primitive integer.

pub const fn as_bits_u128(self) -> u128

Retrieve the bit represented by this Unit instance.

Examples

use byte_unit::Unit;

assert_eq!(1, Unit::Bit.as_bits_u128());
assert_eq!(8, Unit::B.as_bits_u128());
assert_eq!(8000, Unit::KB.as_bits_u128());
assert_eq!(1024, Unit::Kibit.as_bits_u128());

impl Unit

Methods for converting a Unit instance into a string.

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

Retrieve the string represented by this Unit instance.

Examples

use byte_unit::Unit;

assert_eq!("B", Unit::B.as_str());
assert_eq!("KB", Unit::KB.as_str());
assert_eq!("MiB", Unit::MiB.as_str());
assert_eq!("Gb", Unit::Gbit.as_str());
assert_eq!("Tib", Unit::Tibit.as_str());

impl Unit

Methods for categorizing variants.

pub const fn is_bit(self) -> bool

Check whether the unit is based on bits.

Examples

use byte_unit::Unit;

assert_eq!(false, Unit::KB.is_bit());
assert_eq!(true, Unit::Kbit.is_bit());

pub const fn is_binary_multiples(self) -> bool

Check whether the unit is based on powers of 2.

Examples

use byte_unit::Unit;

assert_eq!(false, Unit::KB.is_binary_multiples());
assert_eq!(true, Unit::KiB.is_binary_multiples());

Trait Implementations

impl AsRef<str> for Unit

fn as_ref(&self) -> &str

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

impl Clone for Unit

fn clone(&self) -> Unit

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Unit

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Unit

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

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Unit

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

Formats the value using the given formatter.

impl From<AdjustedBit> for Unit

fn from(value: AdjustedBit) -> 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<Unit> for u128

fn from(unit: Unit) -> Self

See Unit::as_bits_u128.

impl FromStr for Unit

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

ignore_case is set to false; prefer_byte is set to true. See Unit::parse_str.

type Err = UnitParseError

The associated error which can be returned from parsing.

impl PartialEq for Unit

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

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 Unit

impl Eq for Unit

impl StructuralEq for Unit

impl StructuralPartialEq for Unit