Enum byte_unit::ByteUnit

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

The unit of bytes.

Variants

B

1 B = 1 byte

KB

1 KB = 1000 bytes

KiB

1 KiB = 1024 bytes

MB

1 MB = 1000000 bytes

MiB

1 MiB = 1048576 bytes

GB

1 GB = 1000000000 bytes

GiB

1 GiB = 1073741824 bytes

TB

1 TB = 1000000000000 bytes

TiB

1 TiB = 1099511627776 bytes

PB

1 PB = 1000000000000000 bytes

PiB

1 PiB = 1125899906842624 bytes

Methods

impl ByteUnit

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

Get an instance of ByteUnit from a string slice.

extern crate byte_unit;

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());

Trait Implementations

impl Eq for ByteUnit

impl Copy for ByteUnit

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 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 ==.

#[must_use]

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl Hash for ByteUnit

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given [Hasher].

impl Display for ByteUnit

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

Formats the value using the given formatter.

impl Debug for ByteUnit

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

Formats the value using the given formatter.