Enum byte_unit::ByteUnit

pub enum ByteUnit {
    B,
    KB,
    KiB,
    MB,
    MiB,
    GB,
    GiB,
    TB,
    TiB,
    PB,
    PiB,
    EB,
    EiB,
    ZB,
    ZiB,
}

The unit of bytes.

Variants

B

1 B = 1 byte

KB

1 KB = 1000 bytes (10³)

KiB

1 KiB = 1024 bytes (2¹⁰)

MB

1 MB = 1000000 bytes (10⁶)

MiB

1 MiB = 1048576 bytes (2²⁰)

GB

1 GB = 1000000000 bytes (10⁹)

GiB

1 GiB = 1073741824 bytes (2³⁰)

TB

1 TB = 1000000000000 bytes (10¹²)

TiB

1 TiB = 1099511627776 bytes (2⁴⁰)

PB

1 PB = 1000000000000000 bytes (10¹⁵)

PiB

1 PiB = 1125899906842624 bytes (2⁵⁰)

EB

1 EB = 1000000000000000000 bytes (10¹⁸)

EiB

1 EiB = 1152921504606846976 bytes (2⁶⁰)

ZB

1 ZB = 1000000000000000000000 bytes (10²¹)

ZiB

1 ZiB = 1180591620717411303424 bytes (2⁷⁰)

Implementations

impl ByteUnit

pub fn from_str<S: AsRef<str>>(unit: S) -> Result<ByteUnit, UnitIncorrectError>

Get an instance of ByteUnit from a string slice.

use byte_unit::ByteUnit;

assert_eq!(ByteUnit::B, ByteUnit::from_str("").unwrap());
assert_eq!(ByteUnit::B, ByteUnit::from_str("b").unwrap());
assert_eq!(ByteUnit::B, ByteUnit::from_str("B").unwrap());
assert_eq!(ByteUnit::KB, ByteUnit::from_str("k").unwrap());
assert_eq!(ByteUnit::KB, ByteUnit::from_str("K").unwrap());
assert_eq!(ByteUnit::KiB, ByteUnit::from_str("Kib").unwrap());
assert_eq!(ByteUnit::MB, ByteUnit::from_str("mb").unwrap());
assert_eq!(ByteUnit::MiB, ByteUnit::from_str("mib").unwrap());
assert_eq!(ByteUnit::GB, ByteUnit::from_str("GB").unwrap());
assert_eq!(ByteUnit::GiB, ByteUnit::from_str("GiB").unwrap());
assert_eq!(ByteUnit::TB, ByteUnit::from_str("TB").unwrap());
assert_eq!(ByteUnit::TiB, ByteUnit::from_str("TIB").unwrap());
assert_eq!(ByteUnit::PB, ByteUnit::from_str("PB").unwrap());
assert_eq!(ByteUnit::PiB, ByteUnit::from_str("PiB").unwrap());

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

Use string slice to represent this ByteUnit.

use byte_unit::ByteUnit;

assert_eq!("B", ByteUnit::B.as_str());
assert_eq!("KB", ByteUnit::KB.as_str());
assert_eq!("KiB", ByteUnit::KiB.as_str());
assert_eq!("MB", ByteUnit::MB.as_str());
assert_eq!("MiB", ByteUnit::MiB.as_str());
assert_eq!("GB", ByteUnit::GB.as_str());
assert_eq!("GiB", ByteUnit::GiB.as_str());
assert_eq!("TB", ByteUnit::TB.as_str());
assert_eq!("TiB", ByteUnit::TiB.as_str());
assert_eq!("PB", ByteUnit::PB.as_str());
assert_eq!("PiB", ByteUnit::PiB.as_str());

pub fn get_unit_bytes(self) -> u128

Get bytes represented by this ByteUnit.

use byte_unit::ByteUnit;

assert_eq!(1000000000000000000000, ByteUnit::ZB.get_unit_bytes());
assert_eq!(1152921504606846976, ByteUnit::EiB.get_unit_bytes());

Trait Implementations

impl AsRef<str> for ByteUnit

fn as_ref(&self) -> &str

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

impl Clone for ByteUnit

fn clone(&self) -> ByteUnit

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ByteUnit

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ByteUnit

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>where
    D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for ByteUnit

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

Formats the value using the given formatter.

impl FromStr for ByteUnit

type Err = UnitIncorrectError

The associated error which can be returned from parsing.

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

Parses a string s to return a value of this type.

impl PartialEq<ByteUnit> for ByteUnit

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

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

Serialize this value into the given Serde serializer.

impl TryFrom<&str> for ByteUnit

type Error = UnitIncorrectError

The type returned in the event of a conversion error.

fn try_from(s: &str) -> Result<Self, Self::Error>

Performs the conversion.

impl Copy for ByteUnit

impl Eq for ByteUnit

impl StructuralEq for ByteUnit

impl StructuralPartialEq for ByteUnit