Enum Num

pub enum Num {
    F32(f32),
    F64(f64),
    Signed(i64),
    Unsigned(u64),
}

A number type that encapsulates what integers and floats can be represented in MessagePack Rust

Variants

F32(f32)

Num is backed by f32 storage.

F64(f64)

Num is backed by f64 storage.

Signed(i64)

Num is backed by i64 storage.

Unsigned(u64)

Num is backed by u64 storage.

Implementations

impl Num

pub fn fits<T>(&self) -> bool

where Num: NumTo<T>,

Will this Num instance fit in the target type? Fits is defined as lossless conversion. E.g. an f64 value of 42.0 will fit in all rust data types, but a u16 value of 256 will not fit in a u8

pub fn to<T>(&self) -> T

where Num: NumTo<T>,

Convert this Num instance into the destination type. If this instance is outside the bounds of the target type, it will be clamped to fit. Check fits() first if this is not desireable

Trait Implementations

impl Clone for Num

fn clone(&self) -> Num

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Num

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

Formats the value using the given formatter.

impl Display for Num

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

Formats the value using the given formatter.

impl From<f32> for Num

fn from(t: f32) -> Num

Converts to this type from the input type.

impl From<f64> for Num

fn from(t: f64) -> Num

Converts to this type from the input type.

impl From<i16> for Num

fn from(t: i16) -> Num

Converts to this type from the input type.

impl From<i32> for Num

fn from(t: i32) -> Num

Converts to this type from the input type.

impl From<i64> for Num

fn from(t: i64) -> Num

Converts to this type from the input type.

impl From<i8> for Num

fn from(t: i8) -> Num

Converts to this type from the input type.

impl From<isize> for Num

fn from(t: isize) -> Num

Converts to this type from the input type.

impl From<u16> for Num

fn from(t: u16) -> Num

Converts to this type from the input type.

impl From<u32> for Num

fn from(t: u32) -> Num

Converts to this type from the input type.

impl From<u64> for Num

fn from(t: u64) -> Num

Converts to this type from the input type.

impl From<u8> for Num

fn from(t: u8) -> Num

Converts to this type from the input type.

impl From<usize> for Num

fn from(t: usize) -> Num

Converts to this type from the input type.

impl NumTo<f32> for Num

fn fits(&self) -> bool

Will this Num instance fit in the target type? Fits is defined as lossless conversion. E.g. an f64 value of 42.0 will fit in all rust data types, but a u16 value of 256 will not fit in a u8

fn to(&self) -> f32

Convert this Num instance into the destination type. If this instance is outside the bounds of the target type, it will be clamped to fit. Check fits() first if this is not desireable

impl NumTo<f64> for Num

fn fits(&self) -> bool

Will this Num instance fit in the target type? Fits is defined as lossless conversion. E.g. an f64 value of 42.0 will fit in all rust data types, but a u16 value of 256 will not fit in a u8

fn to(&self) -> f64

Convert this Num instance into the destination type. If this instance is outside the bounds of the target type, it will be clamped to fit. Check fits() first if this is not desireable

impl NumTo<i128> for Num

fn fits(&self) -> bool

Will this Num instance fit in the target type? Fits is defined as lossless conversion. E.g. an f64 value of 42.0 will fit in all rust data types, but a u16 value of 256 will not fit in a u8

fn to(&self) -> i128

Convert this Num instance into the destination type. If this instance is outside the bounds of the target type, it will be clamped to fit. Check fits() first if this is not desireable

impl NumTo<i16> for Num

fn fits(&self) -> bool

Will this Num instance fit in the target type? Fits is defined as lossless conversion. E.g. an f64 value of 42.0 will fit in all rust data types, but a u16 value of 256 will not fit in a u8

fn to(&self) -> i16

Convert this Num instance into the destination type. If this instance is outside the bounds of the target type, it will be clamped to fit. Check fits() first if this is not desireable

impl NumTo<i32> for Num

fn fits(&self) -> bool

Will this Num instance fit in the target type? Fits is defined as lossless conversion. E.g. an f64 value of 42.0 will fit in all rust data types, but a u16 value of 256 will not fit in a u8

fn to(&self) -> i32

Convert this Num instance into the destination type. If this instance is outside the bounds of the target type, it will be clamped to fit. Check fits() first if this is not desireable

impl NumTo<i64> for Num

fn fits(&self) -> bool

Will this Num instance fit in the target type? Fits is defined as lossless conversion. E.g. an f64 value of 42.0 will fit in all rust data types, but a u16 value of 256 will not fit in a u8

fn to(&self) -> i64

Convert this Num instance into the destination type. If this instance is outside the bounds of the target type, it will be clamped to fit. Check fits() first if this is not desireable

impl NumTo<i8> for Num

fn fits(&self) -> bool

Will this Num instance fit in the target type? Fits is defined as lossless conversion. E.g. an f64 value of 42.0 will fit in all rust data types, but a u16 value of 256 will not fit in a u8

fn to(&self) -> i8

Convert this Num instance into the destination type. If this instance is outside the bounds of the target type, it will be clamped to fit. Check fits() first if this is not desireable

impl NumTo<isize> for Num

fn fits(&self) -> bool

Will this Num instance fit in the target type? Fits is defined as lossless conversion. E.g. an f64 value of 42.0 will fit in all rust data types, but a u16 value of 256 will not fit in a u8

fn to(&self) -> isize

Convert this Num instance into the destination type. If this instance is outside the bounds of the target type, it will be clamped to fit. Check fits() first if this is not desireable

impl NumTo<u128> for Num

fn fits(&self) -> bool

Will this Num instance fit in the target type? Fits is defined as lossless conversion. E.g. an f64 value of 42.0 will fit in all rust data types, but a u16 value of 256 will not fit in a u8

fn to(&self) -> u128

Convert this Num instance into the destination type. If this instance is outside the bounds of the target type, it will be clamped to fit. Check fits() first if this is not desireable

impl NumTo<u16> for Num

fn fits(&self) -> bool

Will this Num instance fit in the target type? Fits is defined as lossless conversion. E.g. an f64 value of 42.0 will fit in all rust data types, but a u16 value of 256 will not fit in a u8

fn to(&self) -> u16

Convert this Num instance into the destination type. If this instance is outside the bounds of the target type, it will be clamped to fit. Check fits() first if this is not desireable

impl NumTo<u32> for Num

fn fits(&self) -> bool

Will this Num instance fit in the target type? Fits is defined as lossless conversion. E.g. an f64 value of 42.0 will fit in all rust data types, but a u16 value of 256 will not fit in a u8

fn to(&self) -> u32

Convert this Num instance into the destination type. If this instance is outside the bounds of the target type, it will be clamped to fit. Check fits() first if this is not desireable

impl NumTo<u64> for Num

fn fits(&self) -> bool

Will this Num instance fit in the target type? Fits is defined as lossless conversion. E.g. an f64 value of 42.0 will fit in all rust data types, but a u16 value of 256 will not fit in a u8

fn to(&self) -> u64

Convert this Num instance into the destination type. If this instance is outside the bounds of the target type, it will be clamped to fit. Check fits() first if this is not desireable

impl NumTo<u8> for Num

fn fits(&self) -> bool

Will this Num instance fit in the target type? Fits is defined as lossless conversion. E.g. an f64 value of 42.0 will fit in all rust data types, but a u16 value of 256 will not fit in a u8

fn to(&self) -> u8

Convert this Num instance into the destination type. If this instance is outside the bounds of the target type, it will be clamped to fit. Check fits() first if this is not desireable

impl NumTo<usize> for Num

fn fits(&self) -> bool

Will this Num instance fit in the target type? Fits is defined as lossless conversion. E.g. an f64 value of 42.0 will fit in all rust data types, but a u16 value of 256 will not fit in a u8

fn to(&self) -> usize

Convert this Num instance into the destination type. If this instance is outside the bounds of the target type, it will be clamped to fit. Check fits() first if this is not desireable

impl PartialEq<f32> for Num

fn eq(&self, oth: &f32) -> 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 PartialEq<f64> for Num

fn eq(&self, oth: &f64) -> 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 PartialEq<i128> for Num

fn eq(&self, oth: &i128) -> 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 PartialEq<i16> for Num

fn eq(&self, oth: &i16) -> 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 PartialEq<i32> for Num

fn eq(&self, oth: &i32) -> 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 PartialEq<i64> for Num

fn eq(&self, oth: &i64) -> 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 PartialEq<i8> for Num

fn eq(&self, oth: &i8) -> 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 PartialEq<isize> for Num

fn eq(&self, oth: &isize) -> 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 PartialEq<u128> for Num

fn eq(&self, oth: &u128) -> 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 PartialEq<u16> for Num

fn eq(&self, oth: &u16) -> 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 PartialEq<u32> for Num

fn eq(&self, oth: &u32) -> 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 PartialEq<u64> for Num

fn eq(&self, oth: &u64) -> 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 PartialEq<u8> for Num

fn eq(&self, oth: &u8) -> 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 PartialEq<usize> for Num

fn eq(&self, oth: &usize) -> 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 PartialEq for Num

fn eq(&self, oth: &Num) -> 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 Copy for Num