Struct byte_unit::Bit

source ·
pub struct Bit(/* private fields */);
Available on crate features bit and u128 only.
Expand description

Representing the size in bits.

Implementations§

source§

impl Bit

Associated functions for generating AdjustedBit.

source

pub fn get_adjusted_unit(self, unit: Unit) -> AdjustedBit

Adjust the unit and value for this Bit instance.

Examples
use byte_unit::{AdjustedBit, Bit, Unit};

let bit = Bit::parse_str("123Kib").unwrap();

let adjusted_bit = bit.get_adjusted_unit(Unit::Kbit);

assert_eq!("125.952 Kb", adjusted_bit.to_string());
use byte_unit::{AdjustedBit, Bit, Unit};

let bit = Bit::parse_str("50.84 Mb").unwrap();

let adjusted_bit = bit.get_adjusted_unit(Unit::Mibit);

assert_eq!("48.48480224609375 Mib", adjusted_bit.to_string());
source

pub fn get_appropriate_unit(&self, unit_type: UnitType) -> AdjustedBit

Find the appropriate unit and value for this Bit instance.

Examples
use byte_unit::{Bit, UnitType};

let bit = Bit::parse_str("123Kib").unwrap();

let adjusted_bit = bit.get_appropriate_unit(UnitType::Decimal);

assert_eq!("125.952 Kb", adjusted_bit.to_string());
use byte_unit::{Bit, UnitType};

let bit = Bit::parse_str("50.84 Mb").unwrap();

let adjusted_bit = bit.get_appropriate_unit(UnitType::Binary);

assert_eq!("48.48480224609375 Mib", adjusted_bit.to_string());
source§

impl Bit

Constant Bits.

source

pub const BIT: Bit = _

One bit.

source

pub const KILOBIT: Bit = _

1 Kbit = 103 bits.

source

pub const MEGABIT: Bit = _

1 Mbit = 106 bits.

source

pub const GIGABIT: Bit = _

1 Gbit = 109 bits.

source

pub const TERABIT: Bit = _

1 Tbit = 1012 bits.

source

pub const PETABIT: Bit = _

1 Pbit = 1015 bits.

source

pub const EXABIT: Bit = _

1 Ebit = 1018 bits.

source

pub const ZETTABIT: Bit = _

1 Zbit = 1021 bits.

source

pub const YOTTABIT: Bit = _

1 Ybit = 1024 bits.

source

pub const KIBIBIT: Bit = _

1 Kibit = 210 bits.

source

pub const MEBIBIT: Bit = _

1 Mibit = 220 bits.

source

pub const GIBIBIT: Bit = _

1 Gibit = 230 bits.

source

pub const TEBIBIT: Bit = _

1 Tibit = 240 bits.

source

pub const PEBIBIT: Bit = _

1 Pibit = 250 bits.

source

pub const EXBIBIT: Bit = _

1 Eibit = 260 bits.

source

pub const ZEBIBIT: Bit = _

1 Zibit = 270 bits.

source

pub const YOBIBIT: Bit = _

1 Yibit = 280 bits.

source

pub const KILOBYTE: Bit = _

1 KB = 8 * 103 bits.

source

pub const MEGABYTE: Bit = _

1 MB = 8 * 106 bits.

source

pub const GIGABYTE: Bit = _

1 GB = 8 * 109 bits.

source

pub const TERABYTE: Bit = _

1 TB = 8 * 1012 bits.

source

pub const PETABYTE: Bit = _

1 PB = 8 * 1015 bits.

source

pub const EXABYTE: Bit = _

1 EB = 8 * 1018 bits.

source

pub const ZETTABYTE: Bit = _

1 ZB = 8 * 1021 bits.

source

pub const YOTTABYTE: Bit = _

1 YB = 8 * 1024 bits.

source

pub const KIBIBYTE: Bit = _

1 KiB = 213 bits.

source

pub const MEBIBYTE: Bit = _

1 MiB = 223 bits.

source

pub const GIBIBYTE: Bit = _

1 GiB = 233 bits.

source

pub const TEBIBYTE: Bit = _

1 TiB = 243 bits.

source

pub const PEBIBYTE: Bit = _

1 PiB = 253 bits.

source

pub const EXBIBYTE: Bit = _

1 EiB = 263 bits.

source

pub const ZEBIBYTE: Bit = _

1 ZiB = 273 bits.

source

pub const YOBIBYTE: Bit = _

1 YiB = 283 bits.

source

pub const MIN: Bit = _

0 bit.

source

pub const MAX: Bit = _

1027 - 1 bits if the u128 feature is enabled, or 264 - 1 otherwise.

source§

impl Bit

Associated functions for building Bit instances using Decimal.

source

pub fn from_decimal(size: Decimal) -> Option<Self>

Create a new Bit instance from a size in bits.

Examples
use byte_unit::Bit;
use rust_decimal::Decimal;

let bit = Bit::from_decimal(Decimal::from(15000000u64)).unwrap(); // 15 Mb
Points to Note
  • If the input size is too large (the maximum is 1027 - 1 if the u128 feature is enabled, or 264 - 1 otherwise) or not greater than or equal to 0, this function will return None.
  • The fractional part will be rounded up.
source§

impl Bit

Associated functions for building Bit instances using Decimal (with Unit).

source

pub fn from_decimal_with_unit(size: Decimal, unit: Unit) -> Option<Self>

Create a new Bit instance from a size of bits with a unit.

Examples
use byte_unit::{Bit, Unit};
use rust_decimal::Decimal;

let bit = Bit::from_decimal_with_unit(Decimal::from(15u64), Unit::Mbit).unwrap(); // 15 Mb
Points to Note
  • If the calculated bit is too large or not greater than or equal to 0, this function will return None.
  • The calculated bit will be rounded up.
source§

impl Bit

Methods for finding an unit using Decimal.

source

pub fn get_recoverable_unit( self, allow_in_bits: bool, precision: usize ) -> (Decimal, Unit)

Find the appropriate unit and value that can be used to recover back to this Bit precisely.

Examples
use byte_unit::{Bit, Unit};

let bit = Bit::from_u64(3670016);

assert_eq!(
    (3.5f64.try_into().unwrap(), Unit::Mibit),
    bit.get_recoverable_unit(false, 3)
);
use byte_unit::{Bit, Unit};

let bit = Bit::from_u64(28000000);

assert_eq!(
    (3.5f64.try_into().unwrap(), Unit::MB),
    bit.get_recoverable_unit(true, 3)
);
use byte_unit::{Bit, Unit};

let bit = Bit::from_u64(437500);

assert_eq!(
    (437.5f64.try_into().unwrap(), Unit::Kbit),
    bit.get_recoverable_unit(false, 3)
);
Points to Note
  • precision should be smaller or equal to 26 if the u128 feature is enabled, otherwise 19. The typical precision is 3.
source§

impl Bit

Associated functions for parsing strings.

source

pub fn parse_str<S: AsRef<str>>(s: S) -> Result<Self, ParseError>

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

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

Examples
let bit = Bit::parse_str("123Kib").unwrap(); // 123 * 1024 bits
source§

impl Bit

Associated functions for building Bit instances.

source

pub const fn from_u128(size: u128) -> Option<Self>

Create a new Bit instance from a size in bits.

Examples
let bit = Bit::from_u128(15000000).unwrap(); // 15 Mb
Points to Note
  • If the input size is too large (the maximum is 1027 - 1 if the u128 feature is enabled, or 264 - 1 otherwise), this function will return None.
source

pub const unsafe fn from_u128_unsafe(size: u128) -> Self

Create a new Bit instance from a size in bits.

Examples
let bit = unsafe { Bit::from_u128_unsafe(15000000) }; // 15 Mb
Safety

You must ensure the input size is not too large (the maximum is 1027 - 1 if the u128 feature is enabled, or 264 - 1 otherwise) on your own.

source

pub const fn from_u64(size: u64) -> Self

Create a new Bit instance from a size in bits.

Examples
let bit = Bit::from_u64(15000000); // 15 Mb
source

pub fn from_f64(size: f64) -> Option<Self>

Create a new Bit instance from a size im bits.

Examples
let bit = Bit::from_f64(15000000.0).unwrap(); // 15 Mb
Points to Note
  • If the input size is too large (the maximum is 1027 - 1 if the u128 feature is enabled, or 264 - 1 otherwise) or not greater than or equal to 0, this function will return None.
  • The fractional part will be rounded up.
source

pub fn from_f32(size: f32) -> Option<Self>

Create a new Bit instance from a size in bits.

Examples
let bit = Bit::from_f32(15000000.0).unwrap(); // 15 Mb
Points to Note
  • If the input size is too large (the maximum is 1027 - 1 if the u128 feature is enabled, or 264 - 1 otherwise) or not greater than or equal to 0, this function will return None.
  • The fractional part will be rounded up.
source

pub const fn from_i128(size: i128) -> Option<Self>

Create a new Bit instance from a size in bits.

Examples
let bit = Bit::from_i128(15000000).unwrap(); // 15 Mb
Points to Note
  • If the input size is too large (the maximum is 1027 - 1 if the u128 feature is enabled, or 264 - 1 otherwise) or negative, this function will return None.
source

pub const fn from_i64(size: i64) -> Option<Self>

Create a new Bit instance from a size in bits.

Examples
let bit = Bit::from_i64(15000000).unwrap(); // 15 Mb
Points to Note
  • If the input size is negative, this function will return None.
source§

impl Bit

Associated functions for building Bit instances (with Unit).

source

pub const fn from_u128_with_unit(size: u128, unit: Unit) -> Option<Self>

Create a new Bit instance from a size of bits with a unit.

Examples
use byte_unit::{Bit, Unit};

let bit = Bit::from_u128_with_unit(15, Unit::Mbit).unwrap(); // 15 Mb
Points to Note
  • If the calculated bit is too large, this function will return None.
source

pub const fn from_u64_with_unit(size: u64, unit: Unit) -> Option<Self>

Create a new Bit instance from a size of bits with a unit.

Examples
use byte_unit::{Bit, Unit};

let bit = Bit::from_u64_with_unit(15, Unit::Mbit).unwrap(); // 15 Mb
Points to Note
  • If the calculated bit is too large, this function will return None.
  • If the input unit is Bit, the calculated bit will be rounded up.
source

pub fn from_f64_with_unit(size: f64, unit: Unit) -> Option<Self>

Create a new Bit instance from a size of bits with a unit.

Examples
use byte_unit::{Bit, Unit};

let bit = Bit::from_f64_with_unit(15.0, Unit::Mbit).unwrap(); // 15 Mb
Points to Note
  • If the calculated bit is too large or not greater than or equal to 0, this function will return None.
  • The calculated bit will be rounded up.
source

pub fn from_f32_with_unit(size: f32, unit: Unit) -> Option<Self>

Create a new Bit instance from a size of bits with a unit.

Examples
use byte_unit::{Bit, Unit};

let bit = Bit::from_f32_with_unit(15.0, Unit::Mbit).unwrap(); // 15 Mb
Points to Note
  • If the calculated bit is too large or not greater than or equal to 0, this function will return None.
  • The calculated bit will be rounded up.
source

pub const fn from_i128_with_unit(size: i128, unit: Unit) -> Option<Self>

Create a new Bit instance from a size of bits with a unit.

Examples
use byte_unit::{Bit, Unit};

let bit = Bit::from_i128_with_unit(15, Unit::Mibit).unwrap(); // 15 Mb
Points to Note
  • If the calculated bit is too large or negative, this function will return None.
source

pub const fn from_i64_with_unit(size: i64, unit: Unit) -> Option<Self>

Create a new Bit instance from a size of bits with a unit.

Examples
use byte_unit::{Bit, Unit};

let bit = Bit::from_i64_with_unit(15, Unit::Mbit).unwrap(); // 15 Mb
Points to Note
  • If the calculated bit is too large or negative, this function will return None.
source§

impl Bit

Methods for converting a Bit instance into a primitive integer.

source

pub const fn as_u128(self) -> u128

Retrieve the bit represented by this Bit instance.

Examples
use byte_unit::Bit;

let bit = Bit::parse_str("123KiB").unwrap();

let result = bit.as_u128();

assert_eq!(1007616, result);
use byte_unit::Bit;

let bit = Bit::parse_str("123Kib").unwrap();

let result = bit.as_u128();

assert_eq!(125952, result);
source

pub const fn as_u64(self) -> u64

Retrieve the bit represented by this Bit instance. When the u128 feature is enabled, if the bit is actually greater than 264 - 1, it will return 264 - 1.

Examples
use byte_unit::Bit;

let bit = Bit::parse_str("1kb").unwrap();

let result = bit.as_u64();

assert_eq!(1000, result);
use byte_unit::Bit;

let bit = Bit::parse_str("1zb").unwrap();

let result = bit.as_u64();

assert_eq!(u64::MAX, result);
source

pub const fn as_u64_checked(self) -> Option<u64>

Retrieve the bit represented by this Bit instance.

Examples
use byte_unit::Bit;

let bit = Bit::parse_str("1k").unwrap();

let result = bit.as_u64_checked();

assert_eq!(Some(1000), result);
use byte_unit::Bit;

let bit = Bit::parse_str("1zb").unwrap();

let result = bit.as_u64_checked();

assert_eq!(None, result);
source§

impl Bit

Methods for calculation.

source

pub const fn add(self, rhs: Bit) -> Option<Bit>

Add another Bit instance.

Examples
use byte_unit::Bit;

let bit_1 = Bit::from_u64(1024);
let bit_2 = Bit::from_u64(512);

let bit = bit_1.add(bit_2).unwrap();

assert_eq!(1536, bit.as_u64());
Points to Note
  • If the calculated bit is too large, this function will return None.
source

pub const fn subtract(self, rhs: Bit) -> Option<Bit>

Subtract another Bit instance.

Examples
use byte_unit::Bit;

let bit_1 = Bit::from_u64(1024);
let bit_2 = Bit::from_u64(512);

let bit = bit_1.subtract(bit_2).unwrap();

assert_eq!(512, bit.as_u64());
Points to Note
  • If the right-hand side is bigger then this Bit instance, this function will return None.
source

pub const fn multiply(self, rhs: usize) -> Option<Bit>

Multiplied by an unsigned integer.

Examples
use byte_unit::Bit;

let count = 100;
let bit = Bit::from_u64(1024);

let total_bit = bit.multiply(100).unwrap();

assert_eq!(102400, total_bit.as_u64());
Points to Note
  • If the calculated bit is too large, this function will return None.
source

pub const fn divide(self, rhs: usize) -> Option<Bit>

Divided by an unsigned integer.

Examples
use byte_unit::Bit;

let count = 100;
let bit = Bit::from_u64(1024);

let total_bit = bit.divide(100).unwrap();

assert_eq!(10, total_bit.as_u64());
Points to Note
  • If the input right-hand side is zero, this function will return None.
  • The result will be rounded down.
source§

impl Bit

Methods for finding an unit.

source

pub const fn get_exact_unit(self, allow_in_bytes: bool) -> (u128, Unit)

Obtain the largest unit which is the greatest factor of this Bit instance.

Examples
use byte_unit::{Bit, Unit};

let bit = Bit::from_u64(3145728);

let (n, unit) = bit.get_exact_unit(true);

assert_eq!(3, n);
assert_eq!(Unit::Mibit, unit);
use byte_unit::{Bit, Unit};

let bit = Bit::from_u64(24000000);

let (n, unit) = bit.get_exact_unit(true);

assert_eq!(3, n);
assert_eq!(Unit::MB, unit);
use byte_unit::{Bit, Unit};

let bit = Bit::from_u64(24000000);

let (n, unit) = bit.get_exact_unit(false);

assert_eq!(24, n);
assert_eq!(Unit::Mbit, unit);

Trait Implementations§

source§

impl Clone for Bit

source§

fn clone(&self) -> Bit

Returns a copy of the value. Read more
1.0.0 · source§

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

Performs copy-assignment from source. Read more
source§

impl Debug for Bit

source§

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

Formats the value using the given formatter. Read more
source§

impl Default for Bit

source§

fn default() -> Bit

Returns the “default value” for a type. Read more
source§

impl<'de> Deserialize<'de> for Bit

Available on crate feature serde only.
source§

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

Deserialize this value from the given Serde deserializer. Read more
source§

impl Display for Bit

source§

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

Formats the value using the given formatter.

Examples
use byte_unit::{Bit, Unit};

let bit = Bit::from_u64_with_unit(1555, Unit::Kbit).unwrap();

assert_eq!("1555000", bit.to_string());
use byte_unit::{Bit, UnitType};

let bit_based_2 = Bit::from_u64(10240);
let bit_based_10 = Bit::from_u64(10000);

assert_eq!("10240", format!("{bit_based_2}"));
assert_eq!("10000", format!("{bit_based_10}"));

// with an exact unit
assert_eq!("10 Kib", format!("{bit_based_2:#}"));
assert_eq!("10 Kb", format!("{bit_based_10:#}"));

// with an exact unit, no spaces between the value and the unit
assert_eq!("10Kib", format!("{bit_based_2:-#}"));
assert_eq!("10Kb", format!("{bit_based_10:-#}"));

// with a width, left alignment
assert_eq!("10     Kib", format!("{bit_based_2:#10}"));
assert_eq!("10      Kb", format!("{bit_based_10:#10}"));

// with a width, right alignment
assert_eq!("    10 Kib", format!("{bit_based_2:>#10}"));
assert_eq!("     10 Kb", format!("{bit_based_10:>#10}"));

// with a width, right alignment, more spaces between the value and the unit
assert_eq!("    10 Kib", format!("{bit_based_2:>+#10}"));
assert_eq!("    10  Kb", format!("{bit_based_10:>+#10}"));
use byte_unit::{Bit, UnitType};

let bit = Bit::from_u64(3211776);

assert_eq!("3211776", format!("{bit}"));

// with a unit, still precisely
assert_eq!("3136.5 Kib", format!("{bit:#}"));

// with a unit and a larger precision (default is 3), still precisely
assert_eq!("3.211776 Mb", format!("{bit:#.6}"));

// with a unit and a smaller precision (default is 3), still precisely
assert_eq!("3211776 b", format!("{bit:#.0}"));
source§

impl From<AdjustedBit> for Bit

source§

fn from(value: AdjustedBit) -> Self

Converts to this type from the input type.
source§

impl From<Bit> for AdjustedBit

source§

fn from(value: Bit) -> Self

unit_type is set to UnitType::Both. See Bit::get_appropriate_unit.

source§

impl From<Bit> for u128

source§

fn from(bit: Bit) -> Self

Converts to this type from the input type.
source§

impl From<Bit> for u64

source§

fn from(bit: Bit) -> Self

Converts to this type from the input type.
source§

impl From<u16> for Bit

source§

fn from(value: u16) -> Self

Converts to this type from the input type.
source§

impl From<u32> for Bit

source§

fn from(value: u32) -> Self

Converts to this type from the input type.
source§

impl From<u64> for Bit

source§

fn from(value: u64) -> Self

Converts to this type from the input type.
source§

impl From<u8> for Bit

source§

fn from(value: u8) -> Self

Converts to this type from the input type.
source§

impl From<usize> for Bit

source§

fn from(value: usize) -> Self

Converts to this type from the input type.
source§

impl FromStr for Bit

§

type Err = ParseError

The associated error which can be returned from parsing.
source§

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

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

impl Hash for Bit

source§

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

Feeds this value into the given Hasher. Read more
1.3.0 · source§

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

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

impl Ord for Bit

source§

fn cmp(&self, other: &Bit) -> Ordering

This method returns an Ordering between self and other. Read more
1.21.0 · source§

fn max(self, other: Self) -> Self
where Self: Sized,

Compares and returns the maximum of two values. Read more
1.21.0 · source§

fn min(self, other: Self) -> Self
where Self: Sized,

Compares and returns the minimum of two values. Read more
1.50.0 · source§

fn clamp(self, min: Self, max: Self) -> Self
where Self: Sized + PartialOrd,

Restrict a value to a certain interval. Read more
source§

impl PartialEq for Bit

source§

fn eq(&self, other: &Bit) -> bool

This method tests for self and other values to be equal, and is used by ==.
1.0.0 · source§

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.
source§

impl PartialOrd for Bit

source§

fn partial_cmp(&self, other: &Bit) -> Option<Ordering>

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

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

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

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

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

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

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

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

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

impl Serialize for Bit

Available on crate feature serde only.
source§

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

Serialize this value into the given Serde serializer. Read more
source§

impl TryFrom<Bit> for u16

§

type Error = TryFromIntError

The type returned in the event of a conversion error.
source§

fn try_from(bit: Bit) -> Result<Self, Self::Error>

Performs the conversion.
source§

impl TryFrom<Bit> for u32

§

type Error = TryFromIntError

The type returned in the event of a conversion error.
source§

fn try_from(bit: Bit) -> Result<Self, Self::Error>

Performs the conversion.
source§

impl TryFrom<Bit> for u8

§

type Error = TryFromIntError

The type returned in the event of a conversion error.
source§

fn try_from(bit: Bit) -> Result<Self, Self::Error>

Performs the conversion.
source§

impl TryFrom<Bit> for usize

§

type Error = TryFromIntError

The type returned in the event of a conversion error.
source§

fn try_from(bit: Bit) -> Result<Self, Self::Error>

Performs the conversion.
source§

impl TryFrom<f32> for Bit

§

type Error = ExceededBoundsError

The type returned in the event of a conversion error.
source§

fn try_from(value: f32) -> Result<Self, Self::Error>

Performs the conversion.
source§

impl TryFrom<f64> for Bit

§

type Error = ExceededBoundsError

The type returned in the event of a conversion error.
source§

fn try_from(value: f64) -> Result<Self, Self::Error>

Performs the conversion.
source§

impl TryFrom<i128> for Bit

§

type Error = ExceededBoundsError

The type returned in the event of a conversion error.
source§

fn try_from(value: i128) -> Result<Self, Self::Error>

Performs the conversion.
source§

impl TryFrom<i16> for Bit

§

type Error = ExceededBoundsError

The type returned in the event of a conversion error.
source§

fn try_from(value: i16) -> Result<Self, Self::Error>

Performs the conversion.
source§

impl TryFrom<i32> for Bit

§

type Error = ExceededBoundsError

The type returned in the event of a conversion error.
source§

fn try_from(value: i32) -> Result<Self, Self::Error>

Performs the conversion.
source§

impl TryFrom<i64> for Bit

§

type Error = ExceededBoundsError

The type returned in the event of a conversion error.
source§

fn try_from(value: i64) -> Result<Self, Self::Error>

Performs the conversion.
source§

impl TryFrom<i8> for Bit

§

type Error = ExceededBoundsError

The type returned in the event of a conversion error.
source§

fn try_from(value: i8) -> Result<Self, Self::Error>

Performs the conversion.
source§

impl TryFrom<isize> for Bit

§

type Error = ExceededBoundsError

The type returned in the event of a conversion error.
source§

fn try_from(value: isize) -> Result<Self, Self::Error>

Performs the conversion.
source§

impl TryFrom<u128> for Bit

§

type Error = ExceededBoundsError

The type returned in the event of a conversion error.
source§

fn try_from(value: u128) -> Result<Self, Self::Error>

Performs the conversion.
source§

impl Copy for Bit

source§

impl Eq for Bit

source§

impl StructuralEq for Bit

source§

impl StructuralPartialEq for Bit

Auto Trait Implementations§

§

impl RefUnwindSafe for Bit

§

impl Send for Bit

§

impl Sync for Bit

§

impl Unpin for Bit

§

impl UnwindSafe for Bit

Blanket Implementations§

source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for T
where U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T> ToOwned for T
where T: Clone,

§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

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

fn clone_into(&self, target: &mut T)

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

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

source§

default fn to_string(&self) -> String

Converts the given value to a String. Read more
source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

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

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

§

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

The type returned in the event of a conversion error.
source§

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

Performs the conversion.
source§

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