Struct shadow_rs::utility::units::Bytes

pub struct Bytes<T: Prefix> {
    pub value: u64,
    pub prefix: T,
}

A number of bytes.

Fields

value: u64

prefix: T

Implementations

impl<T: Prefix> Bytes<T>

pub fn new(value: u64, prefix: T) -> Self

Trait Implementations

impl<T: Clone + Prefix> Clone for Bytes<T>

fn clone(&self) -> Bytes<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug + Prefix> Debug for Bytes<T>

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

Formats the value using the given formatter.

impl<T: Prefix> Default for Bytes<T>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, T: Prefix> Deserialize<'de> for Bytes<T>

where <T as FromStr>::Err: Debug + Display,

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T: Prefix> Display for Bytes<T>

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

Formats the value using the given formatter.

impl<T: Prefix> FromStr for Bytes<T>

where <T as FromStr>::Err: Debug + Display,

type Err = Box<dyn Error + Sync + Send>

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<T: Prefix> JsonSchema for Bytes<T>

fn is_referenceable() -> bool

Whether JSON Schemas generated for this type should be re-used where possible using the $ref keyword.

fn schema_name() -> String

The name of the generated JSON Schema.

fn json_schema(_: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

impl<T: PartialEq + Prefix> PartialEq for Bytes<T>

fn eq(&self, other: &Bytes<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: Prefix> Serialize for Bytes<T>

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

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<T: Prefix> Unit for Bytes<T>

type U = u64

type T = T

fn value(&self) -> Self::U

The value of the unit in the size of its current prefix.

fn prefix(&self) -> Self::T

The current prefix.

fn suffixes() -> &'static [&'static str]

fn convert(&self, prefix: Self::T) -> Result<Self, String>

Convert value to a different prefix, but return an error if the conversion cannot be done without possibly losing precision.

fn convert_lossy(&self, prefix: Self::T) -> Self

Convert value to a different prefix, even if it loses precision.

impl<T: Copy + Prefix> Copy for Bytes<T>

impl<T: Eq + Prefix> Eq for Bytes<T>

impl<T: Prefix> StructuralPartialEq for Bytes<T>