Struct rocket::data::ByteUnit[][src]

#[repr(transparent)]
pub struct ByteUnit(_);
Expand description

A unit of bytes with saturating const constructors and arithmetic.

Overview

A ByteUnit represents a unit, a count, a number, of bytes. All operations on a ByteUnit – constructors, arithmetic, conversions – saturate. Overflow, underflow, and divide-by-zero are impossible. See the top-level documentation for more.

ToByteUnit provides human-friendly methods on all integer types for converting into a ByteUnit: 512.megabytes().

Parsing

ByteUnit implements FromStr for parsing byte unit strings into a ByteUnit. The grammar accepted by the parser is:

byte_unit := uint+ ('.' uint+)? WHITESPACE* suffix

uint := '0'..'9'
suffix := case insensitive SI byte unit suffix ('b' to 'eib')
WHITESPACE := the ' ' character
use ubyte::{ByteUnit, ToByteUnit};

let one_gib: ByteUnit = "1GiB".parse().unwrap();
assert_eq!(one_gib, 1.gibibytes());

let quarter_mb: ByteUnit = "256 kB".parse().unwrap();
assert_eq!(quarter_mb, 256.kilobytes());

let half_mb: ByteUnit = "0.5MB".parse().unwrap();
assert_eq!(half_mb, 500.kilobytes());

let half_mib: ByteUnit = "0.500 mib".parse().unwrap();
assert_eq!(half_mib, 512.kibibytes());

let some_mb: ByteUnit = "20.5MB".parse().unwrap();
assert_eq!(some_mb, 20.megabytes() + 500.kilobytes());

(De)serialization

With the serde feaure enabled (disabled by default), ByteUnit implements Deserialize from strings, using the same grammar as the FromStr implementation, defined above, as well as all integer types. The Serialize implementation serializes into a u64.

Example

use ubyte::{ByteUnit, ToByteUnit};

// Construct with unit-valued associated constants, `const` constructors, or
// human-friendly methods from the `ToByteUnit` integer extension trait.
const HALF_GB: ByteUnit = ByteUnit::Megabyte(500);
const HALF_GIB: ByteUnit = ByteUnit::Mebibyte(512);
let half_gb = 500 * ByteUnit::MB;
let half_gib = 512 * ByteUnit::MiB;
let half_gb = 500.megabytes();
let half_gib = 512.mebibytes();

// All arithmetic operations and conversions saturate.
let exbibyte = ByteUnit::Exbibyte(1);
let exbibyte_too_large_a = 1024 * ByteUnit::EiB;
let exbibyte_too_large_b = ByteUnit::Exbibyte(1024);
let exbibyte_too_large_c = 1024.exbibytes();
let div_by_zero = 1024.exbibytes() / 0;
let too_small = 1000.megabytes() - 1.gibibytes();
assert_eq!(exbibyte << 4, ByteUnit::max_value());
assert_eq!(exbibyte << 10, ByteUnit::max_value());
assert_eq!(exbibyte_too_large_a, ByteUnit::max_value());
assert_eq!(exbibyte_too_large_b, ByteUnit::max_value());
assert_eq!(exbibyte_too_large_c, ByteUnit::max_value());
assert_eq!(div_by_zero, ByteUnit::max_value());
assert_eq!(too_small, 0);

Implementations

impl ByteUnit[src]

pub const B: ByteUnit[src]

Number of bytes in 1 B (1).

pub const kB: ByteUnit[src]

Number of bytes in 1 kB (1_000).

pub const KiB: ByteUnit[src]

Number of bytes in 1 KiB (1 << 10).

pub const MB: ByteUnit[src]

Number of bytes in 1 MB (1_000_000).

pub const MiB: ByteUnit[src]

Number of bytes in 1 MiB (1 << 20).

pub const GB: ByteUnit[src]

Number of bytes in 1 GB (1_000_000_000).

pub const GiB: ByteUnit[src]

Number of bytes in 1 GiB (1 << 30).

pub const TB: ByteUnit[src]

Number of bytes in 1 TB (1_000_000_000_000).

pub const TiB: ByteUnit[src]

Number of bytes in 1 TiB (1 << 40).

pub const PB: ByteUnit[src]

Number of bytes in 1 PB (1_000_000_000_000_000).

pub const PiB: ByteUnit[src]

Number of bytes in 1 PiB (1 << 50).

pub const EB: ByteUnit[src]

Number of bytes in 1 EB (1_000_000_000_000_000_000).

pub const EiB: ByteUnit[src]

Number of bytes in 1 EiB (1 << 60).

pub const fn Byte(n: u64) -> ByteUnit[src]

Constructs a ByteUnit representing n B .

Example

assert_eq!(ByteUnit::Byte(10), 10 * ByteUnit::B);

pub const fn Kilobyte(n: u64) -> ByteUnit[src]

Constructs a ByteUnit representing n kB .

Example

assert_eq!(ByteUnit::Kilobyte(10), 10 * ByteUnit::kB);

pub const fn Kibibyte(n: u64) -> ByteUnit[src]

Constructs a ByteUnit representing n KiB .

Example

assert_eq!(ByteUnit::Kibibyte(10), 10 * ByteUnit::KiB);

pub const fn Megabyte(n: u64) -> ByteUnit[src]

Constructs a ByteUnit representing n MB .

Example

assert_eq!(ByteUnit::Megabyte(10), 10 * ByteUnit::MB);

pub const fn Mebibyte(n: u64) -> ByteUnit[src]

Constructs a ByteUnit representing n MiB .

Example

assert_eq!(ByteUnit::Mebibyte(10), 10 * ByteUnit::MiB);

pub const fn Gigabyte(n: u64) -> ByteUnit[src]

Constructs a ByteUnit representing n GB .

Example

assert_eq!(ByteUnit::Gigabyte(10), 10 * ByteUnit::GB);

pub const fn Gibibyte(n: u64) -> ByteUnit[src]

Constructs a ByteUnit representing n GiB .

Example

assert_eq!(ByteUnit::Gibibyte(10), 10 * ByteUnit::GiB);

pub const fn Terabyte(n: u64) -> ByteUnit[src]

Constructs a ByteUnit representing n TB .

Example

assert_eq!(ByteUnit::Terabyte(10), 10 * ByteUnit::TB);

pub const fn Tebibyte(n: u64) -> ByteUnit[src]

Constructs a ByteUnit representing n TiB .

Example

assert_eq!(ByteUnit::Tebibyte(10), 10 * ByteUnit::TiB);

pub const fn Petabyte(n: u64) -> ByteUnit[src]

Constructs a ByteUnit representing n PB .

Example

assert_eq!(ByteUnit::Petabyte(10), 10 * ByteUnit::PB);

pub const fn Pebibyte(n: u64) -> ByteUnit[src]

Constructs a ByteUnit representing n PiB .

Example

assert_eq!(ByteUnit::Pebibyte(10), 10 * ByteUnit::PiB);

pub const fn Exabyte(n: u64) -> ByteUnit[src]

Constructs a ByteUnit representing n EB .

Example

assert_eq!(ByteUnit::Exabyte(10), 10 * ByteUnit::EB);

pub const fn Exbibyte(n: u64) -> ByteUnit[src]

Constructs a ByteUnit representing n EiB .

Example

assert_eq!(ByteUnit::Exbibyte(10), 10 * ByteUnit::EiB);

pub const fn max_value() -> ByteUnit[src]

The maximum value of bytes representable by ByteUnit.

Example

assert_eq!(ByteUnit::max_value(), u64::max_value());

pub const fn as_u64(self) -> u64[src]

Returns the value of bytes represented by self as a u64.

Example

let int: u64 = ByteUnit::Gigabyte(4).as_u64();
assert_eq!(int, 4 * ByteUnit::GB);

assert_eq!(ByteUnit::Megabyte(42).as_u64(), 42 * 1_000_000);
assert_eq!(ByteUnit::Exbibyte(7).as_u64(), 7 * 1 << 60);

pub const fn as_u128(self) -> u128[src]

Returns the value of bytes represented by self as a u128.

Example

let int: u128 = ByteUnit::Gigabyte(4).as_u128();
assert_eq!(int, 4 * ByteUnit::GB);

assert_eq!(ByteUnit::Megabyte(42).as_u64(), 42 * 1_000_000);
assert_eq!(ByteUnit::Exbibyte(7).as_u64(), 7 * 1 << 60);

pub fn repr(self) -> (u64, f64, &'static str, ByteUnit)[src]

Returns the components of the minimal unit representation of self.

The “minimal unit representation” is the representation that maximizes the SI-unit while minimizing the whole part of the value. For example, 1024.bytes() is minimally represented by 1KiB, while 1023.bytes() is minimally represented by 1.023kB.

The four components returned, in tuple-order, are:

  • whole - the whole part of the minimal representation.
  • frac - the fractional part of the minimal representation.
  • suffix - the suffix of the minimal representation.
  • unit - the 1-unit of the minimal representation.

Succinctly, this is: (whole, frac, suffix, unit). Observe that (whole + frac) * unit reconstructs the original value.

Example

use ubyte::{ByteUnit, ToByteUnit};

let value = 2.mebibytes() + 512.kibibytes();
assert_eq!(value.to_string(), "2.50MiB");

let (whole, frac, suffix, unit) = value.repr();
assert_eq!(whole, 2);
assert_eq!(frac, 0.5);
assert_eq!(suffix, "MiB");
assert_eq!(unit, ByteUnit::MiB);

let reconstructed = (whole as f64 + frac) * unit.as_u64() as f64;
assert_eq!(reconstructed as u64, value);

Trait Implementations

impl Add<ByteUnit> for u64[src]

type Output = ByteUnit

The resulting type after applying the + operator.

pub fn add(self, rhs: ByteUnit) -> <u64 as Add<ByteUnit>>::Output[src]

Performs the + operation. Read more

impl<T> Add<T> for ByteUnit where
    T: Into<ByteUnit>, 
[src]

type Output = ByteUnit

The resulting type after applying the + operator.

pub fn add(self, rhs: T) -> <ByteUnit as Add<T>>::Output[src]

Performs the + operation. Read more

impl Clone for ByteUnit[src]

pub 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]

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

Formats the value using the given formatter. Read more

impl<'de> Deserialize<'de> for ByteUnit[src]

pub fn deserialize<D>(
    deserializer: D
) -> Result<ByteUnit, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 
[src]

Deserialize this value from the given Serde deserializer. Read more

impl Display for ByteUnit[src]

Display self as best as possible. For perfectly custom display output, consider using ByteUnit::repr().

Example

use ubyte::{ByteUnit, ToByteUnit};

assert_eq!(323.kilobytes().to_string(), "323kB");
assert_eq!(3.megabytes().to_string(), "3MB");
assert_eq!(3.mebibytes().to_string(), "3MiB");

assert_eq!((3.mebibytes() + 140.kilobytes()).to_string(), "3.13MiB");
assert_eq!((3.mebibytes() + 2.mebibytes()).to_string(), "5MiB");
assert_eq!((7.gigabytes() + 58.mebibytes() + 3.kilobytes()).to_string(), "7.06GB");
assert_eq!((7.gibibytes() + 920.mebibytes()).to_string(), "7.90GiB");
assert_eq!(7231.kilobytes().to_string(), "6.90MiB");

assert_eq!(format!("{:.0}", 7.gibibytes() + 920.mebibytes()), "8GiB");
assert_eq!(format!("{:.1}", 7.gibibytes() + 920.mebibytes()), "7.9GiB");
assert_eq!(format!("{:.2}", 7.gibibytes() + 920.mebibytes()), "7.90GiB");
assert_eq!(format!("{:.3}", 7.gibibytes() + 920.mebibytes()), "7.898GiB");
assert_eq!(format!("{:.4}", 7.gibibytes() + 920.mebibytes()), "7.8984GiB");
assert_eq!(format!("{:.4}", 7231.kilobytes()), "6.8960MiB");
assert_eq!(format!("{:.0}", 7231.kilobytes()), "7MiB");
assert_eq!(format!("{:.2}", 999.kilobytes() + 990.bytes()), "976.55KiB");
assert_eq!(format!("{:.0}", 999.kilobytes() + 990.bytes()), "1MB");

assert_eq!(format!("{:04.2}", 999.kilobytes() + 990.bytes()), "0976.55KiB");
assert_eq!(format!("{:02.0}", 999.kilobytes() + 990.bytes()), "01MB");
assert_eq!(format!("{:04.0}", 999.kilobytes() + 990.bytes()), "0001MB");

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

Formats the value using the given formatter. Read more

impl Div<ByteUnit> for u64[src]

type Output = ByteUnit

The resulting type after applying the / operator.

pub fn div(self, rhs: ByteUnit) -> <u64 as Div<ByteUnit>>::Output[src]

Performs the / operation. Read more

impl<T> Div<T> for ByteUnit where
    T: Into<ByteUnit>, 
[src]

type Output = ByteUnit

The resulting type after applying the / operator.

pub fn div(self, rhs: T) -> <ByteUnit as Div<T>>::Output[src]

Performs the / operation. Read more

impl From<ByteUnit> for u64[src]

pub fn from(v: ByteUnit) -> u64[src]

Performs the conversion.

impl From<i128> for ByteUnit[src]

pub fn from(value: i128) -> ByteUnit[src]

Performs the conversion.

impl From<i16> for ByteUnit[src]

pub fn from(v: i16) -> ByteUnit[src]

Performs the conversion.

impl From<i32> for ByteUnit[src]

pub fn from(v: i32) -> ByteUnit[src]

Performs the conversion.

impl From<i64> for ByteUnit[src]

pub fn from(v: i64) -> ByteUnit[src]

Performs the conversion.

impl From<i8> for ByteUnit[src]

pub fn from(v: i8) -> ByteUnit[src]

Performs the conversion.

impl From<isize> for ByteUnit[src]

pub fn from(value: isize) -> ByteUnit[src]

Performs the conversion.

impl From<u128> for ByteUnit[src]

pub fn from(value: u128) -> ByteUnit[src]

Performs the conversion.

impl From<u16> for ByteUnit[src]

pub fn from(v: u16) -> ByteUnit[src]

Performs the conversion.

impl From<u32> for ByteUnit[src]

pub fn from(v: u32) -> ByteUnit[src]

Performs the conversion.

impl From<u64> for ByteUnit[src]

pub fn from(v: u64) -> ByteUnit[src]

Performs the conversion.

impl From<u8> for ByteUnit[src]

pub fn from(v: u8) -> ByteUnit[src]

Performs the conversion.

impl From<usize> for ByteUnit[src]

pub fn from(value: usize) -> ByteUnit[src]

Performs the conversion.

impl FromStr for ByteUnit[src]

type Err = Error

The associated error which can be returned from parsing.

pub fn from_str(s: &str) -> Result<ByteUnit, <ByteUnit as FromStr>::Err>[src]

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

impl Hash for ByteUnit[src]

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher
[src]

Feeds this value into the given Hasher. Read more

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

Feeds a slice of this type into the given Hasher. Read more

impl Len<ByteUnit> for TempFile<'_>[src]

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

The length of the value.

fn len_into_u64(len: ByteUnit) -> u64[src]

Convert len into u64.

fn zero_len() -> ByteUnit[src]

The zero value for L.

impl Mul<ByteUnit> for u64[src]

type Output = ByteUnit

The resulting type after applying the * operator.

pub fn mul(self, rhs: ByteUnit) -> <u64 as Mul<ByteUnit>>::Output[src]

Performs the * operation. Read more

impl<T> Mul<T> for ByteUnit where
    T: Into<ByteUnit>, 
[src]

type Output = ByteUnit

The resulting type after applying the * operator.

pub fn mul(self, rhs: T) -> <ByteUnit as Mul<T>>::Output[src]

Performs the * operation. Read more

impl Ord for ByteUnit[src]

pub fn cmp(&self, other: &ByteUnit) -> Ordering[src]

This method returns an Ordering between self and other. Read more

#[must_use]
fn max(self, other: Self) -> Self
1.21.0[src]

Compares and returns the maximum of two values. Read more

#[must_use]
fn min(self, other: Self) -> Self
1.21.0[src]

Compares and returns the minimum of two values. Read more

#[must_use]
fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]

Restrict a value to a certain interval. Read more

impl PartialEq<ByteUnit> for u64[src]

pub 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) -> bool
1.0.0[src]

This method tests for !=.

impl<T> PartialEq<T> for ByteUnit where
    T: Into<ByteUnit> + Copy
[src]

pub fn eq(&self, other: &T) -> 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) -> bool
1.0.0[src]

This method tests for !=.

impl PartialOrd<ByteUnit> for u64[src]

pub fn partial_cmp(&self, other: &ByteUnit) -> Option<Ordering>[src]

This method returns an ordering between self and other values if one exists. Read more

#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]

This method tests less than (for self and other) and is used by the < operator. Read more

#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]

This method tests less than or equal to (for self and other) and is used by the <= operator. Read more

#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]

This method tests greater than (for self and other) and is used by the > operator. Read more

#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]

This method tests greater than or equal to (for self and other) and is used by the >= operator. Read more

impl<T> PartialOrd<T> for ByteUnit where
    T: Into<ByteUnit> + Copy
[src]

pub fn partial_cmp(&self, other: &T) -> Option<Ordering>[src]

This method returns an ordering between self and other values if one exists. Read more

#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]

This method tests less than (for self and other) and is used by the < operator. Read more

#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]

This method tests less than or equal to (for self and other) and is used by the <= operator. Read more

#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]

This method tests greater than (for self and other) and is used by the > operator. Read more

#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]

This method tests greater than or equal to (for self and other) and is used by the >= operator. Read more

impl Rem<ByteUnit> for u64[src]

type Output = ByteUnit

The resulting type after applying the % operator.

pub fn rem(self, rhs: ByteUnit) -> <u64 as Rem<ByteUnit>>::Output[src]

Performs the % operation. Read more

impl<T> Rem<T> for ByteUnit where
    T: Into<ByteUnit>, 
[src]

type Output = ByteUnit

The resulting type after applying the % operator.

pub fn rem(self, rhs: T) -> <ByteUnit as Rem<T>>::Output[src]

Performs the % operation. Read more

impl Serialize for ByteUnit[src]

pub fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer
[src]

Serialize this value into the given Serde serializer. Read more

impl Shl<ByteUnit> for u64[src]

type Output = ByteUnit

The resulting type after applying the << operator.

pub fn shl(self, rhs: ByteUnit) -> <u64 as Shl<ByteUnit>>::Output[src]

Performs the << operation. Read more

impl<T> Shl<T> for ByteUnit where
    T: Into<ByteUnit>, 
[src]

type Output = ByteUnit

The resulting type after applying the << operator.

pub fn shl(self, rhs: T) -> <ByteUnit as Shl<T>>::Output[src]

Performs the << operation. Read more

impl Shr<ByteUnit> for u64[src]

type Output = ByteUnit

The resulting type after applying the >> operator.

pub fn shr(self, rhs: ByteUnit) -> <u64 as Shr<ByteUnit>>::Output[src]

Performs the >> operation. Read more

impl<T> Shr<T> for ByteUnit where
    T: Into<ByteUnit>, 
[src]

type Output = ByteUnit

The resulting type after applying the >> operator.

pub fn shr(self, rhs: T) -> <ByteUnit as Shr<T>>::Output[src]

Performs the >> operation. Read more

impl Sub<ByteUnit> for u64[src]

type Output = ByteUnit

The resulting type after applying the - operator.

pub fn sub(self, rhs: ByteUnit) -> <u64 as Sub<ByteUnit>>::Output[src]

Performs the - operation. Read more

impl<T> Sub<T> for ByteUnit where
    T: Into<ByteUnit>, 
[src]

type Output = ByteUnit

The resulting type after applying the - operator.

pub fn sub(self, rhs: T) -> <ByteUnit as Sub<T>>::Output[src]

Performs the - operation. Read more

impl Copy for ByteUnit[src]

impl Eq for ByteUnit[src]

impl StructuralEq for ByteUnit[src]

Auto Trait Implementations

impl RefUnwindSafe for ByteUnit

impl Send for ByteUnit

impl Sync for ByteUnit

impl Unpin for ByteUnit

impl UnwindSafe for ByteUnit

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<Q, K> Equivalent<K> for Q where
    K: Borrow<Q> + ?Sized,
    Q: Eq + ?Sized
[src]

pub fn equivalent(&self, key: &K) -> bool[src]

Compare self to key and return true if they are equal.

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

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

Performs the conversion.

impl<T> Instrument for T[src]

fn instrument(self, span: Span) -> Instrumented<Self>[src]

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

fn in_current_span(self) -> Instrumented<Self>[src]

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

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

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

Performs the conversion.

impl<T> IntoCollection<T> for T

pub fn into_collection<A>(self) -> SmallVec<A> where
    A: Array<Item = T>, 

Converts self into a collection.

pub fn mapped<U, F, A>(self, f: F) -> SmallVec<A> where
    F: FnMut(T) -> U,
    A: Array<Item = U>, 

impl<T> Same<T> for T

type Output = T

Should always be Self

impl<T> ToByteUnit for T where
    T: Into<ByteUnit> + Copy
[src]

fn bytes(self) -> ByteUnit[src]

Converts self to a ByteUnit representing self bytes.

fn kilobytes(self) -> ByteUnit[src]

Converts self to a ByteUnit representing self Read more

fn kibibytes(self) -> ByteUnit[src]

Converts self to a ByteUnit representing self Read more

fn megabytes(self) -> ByteUnit[src]

Converts self to a ByteUnit representing self Read more

fn mebibytes(self) -> ByteUnit[src]

Converts self to a ByteUnit representing self Read more

fn gigabytes(self) -> ByteUnit[src]

Converts self to a ByteUnit representing self Read more

fn gibibytes(self) -> ByteUnit[src]

Converts self to a ByteUnit representing self Read more

fn terabytes(self) -> ByteUnit[src]

Converts self to a ByteUnit representing self Read more

fn tibibytes(self) -> ByteUnit[src]

Converts self to a ByteUnit representing self Read more

fn petabytes(self) -> ByteUnit[src]

Converts self to a ByteUnit representing self Read more

fn pebibytes(self) -> ByteUnit[src]

Converts self to a ByteUnit representing self Read more

fn exabytes(self) -> ByteUnit[src]

Converts self to a ByteUnit representing self Read more

fn exbibytes(self) -> ByteUnit[src]

Converts self to a ByteUnit representing self Read more

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.

impl<V, T> VZip<V> for T where
    V: MultiLane<T>, 

pub fn vzip(self) -> V

impl<T> DeserializeOwned for T where
    T: for<'de> Deserialize<'de>, 
[src]

impl<T, Rhs, Output> NumOps<Rhs, Output> for T where
    T: Sub<Rhs, Output = Output> + Mul<Rhs, Output = Output> + Div<Rhs, Output = Output> + Add<Rhs, Output = Output> + Rem<Rhs, Output = Output>, 
[src]