Enum byte_unit::ByteUnit[−][src]

pub enum ByteUnit {

Show variants    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 (103)

KiB

1 KiB = 1024 bytes (210)

MB

1 MB = 1000000 bytes (106)

MiB

1 MiB = 1048576 bytes (220)

GB

1 GB = 1000000000 bytes (109)

GiB

1 GiB = 1073741824 bytes (230)

TB

1 TB = 1000000000000 bytes (1012)

TiB

1 TiB = 1099511627776 bytes (240)

PB

1 PB = 1000000000000000 bytes (1015)

PiB

1 PiB = 1125899906842624 bytes (250)

EB

1 EB = 1000000000000000000 bytes (1018)

EiB

1 EiB = 1152921504606846976 bytes (260)

ZB

1 ZB = 1000000000000000000000 bytes (1021)

ZiB

1 ZiB = 1180591620717411303424 bytes (270)

Implementations

impl ByteUnit[src]

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

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

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

Use string slice to represent this ByteUnit.

extern crate byte_unit;

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[src]

Get bytes represented by this ByteUnit.

extern crate byte_unit;

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[src]

fn as_ref(&self) -> &str[src]

Performs the conversion.

impl Clone for ByteUnit[src]

fn clone(&self) -> ByteUnit[src]

Returns a copy of the value. Read more

fn clone_from(&mut self, source: &Self)1.0.0[src]

Performs copy-assignment from source. Read more

impl Debug for ByteUnit[src]

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

Formats the value using the given formatter. Read more

impl Display for ByteUnit[src]

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

Formats the value using the given formatter. Read more

impl FromStr for ByteUnit[src]

type Err = UnitIncorrectError

The associated error which can be returned from parsing.

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

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

impl PartialEq<ByteUnit> for ByteUnit[src]

fn eq(&self, other: &ByteUnit) -> bool[src]

This method tests for self and other values to be equal, and is used by ==. Read more

#[must_use]
fn ne(&self, other: &Rhs) -> bool1.0.0[src]

This method tests for !=.

impl TryFrom<&'_ str> for ByteUnit[src]

type Error = UnitIncorrectError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl Copy for ByteUnit[src]

impl Eq for ByteUnit[src]

impl StructuralEq for ByteUnit[src]

impl StructuralPartialEq for ByteUnit[src]

Auto Trait Implementations

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized, [src]

pub fn type_id(&self) -> TypeId[src]

Gets the TypeId of self. Read more

impl<T> Borrow<T> for T where
    T: ?Sized, [src]

pub fn borrow(&self) -> &T[src]

Immutably borrows from an owned value. Read more

impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]

pub fn borrow_mut(&mut self) -> &mut T[src]

Mutably borrows from an owned value. Read more

impl<T> From<T> for T[src]

pub fn from(t: T) -> T[src]

Performs the conversion.

impl<T, U> Into<U> for T where
    U: From<T>, [src]

pub fn into(self) -> U[src]

Performs the conversion.

impl<T> ToOwned for T where
    T: Clone, [src]

type Owned = T

The resulting type after obtaining ownership.

pub fn to_owned(&self) -> T[src]

Creates owned data from borrowed data, usually by cloning. Read more

pub fn clone_into(&self, target: &mut T)[src]

🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

Uses borrowed data to replace owned data, usually by cloning. Read more

impl<T> ToString for T where
    T: Display + ?Sized, [src]

pub default fn to_string(&self) -> String[src]

Converts the given value to a String. Read more

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]

Performs the conversion.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>[src]

Performs the conversion.