pub struct Number { /* private fields */ }Expand description
Number representation used inside JsonValue. You can easily convert
the Number type into native Rust number types and back, or use the
equality operator with another number type.
let foo: Number = 3.14.into();
let bar: f64 = foo.into();
assert_eq!(foo, 3.14);
assert_eq!(bar, 3.14);More often than not you will deal with JsonValue::Number variant that
wraps around this type, instead of using the methods here directly.
Implementations§
Source§impl Number
impl Number
Sourcepub unsafe fn from_parts_unchecked(
positive: bool,
mantissa: u64,
exponent: i16,
) -> Self
pub unsafe fn from_parts_unchecked( positive: bool, mantissa: u64, exponent: i16, ) -> Self
Construct a new Number from parts. This can’t create a NaN value.
let pi = unsafe { Number::from_parts_unchecked(true, 3141592653589793, -15) };
assert_eq!(pi, 3.141592653589793);While this method is marked unsafe, it doesn’t actually perform any unsafe operations.
THe goal of the ‘unsafe’ is to deter from using this method in favor of its safe equivalent
from_parts, at least in context when the associated performance cost is negligible.
Sourcepub fn from_parts(positive: bool, mantissa: u64, exponent: i16) -> Self
pub fn from_parts(positive: bool, mantissa: u64, exponent: i16) -> Self
Construct a new Number from parts, stripping unnecessary trailing zeroes.
This can’t create a NaN value.
let one = Number::from_parts(true, 1000, -3);
let (positive, mantissa, exponent) = one.as_parts();
assert_eq!(true, positive);
assert_eq!(1, mantissa);
assert_eq!(0, exponent);Sourcepub fn as_parts(&self) -> (bool, u64, i16)
pub fn as_parts(&self) -> (bool, u64, i16)
Reverse to from_parts - obtain parts from an existing Number.
let pi = Number::from(3.141592653589793);
let (positive, mantissa, exponent) = pi.as_parts();
assert_eq!(positive, true);
assert_eq!(mantissa, 3141592653589793);
assert_eq!(exponent, -15);pub fn is_sign_positive(&self) -> bool
pub fn is_zero(&self) -> bool
pub fn is_nan(&self) -> bool
Sourcepub fn as_fixed_point_u64(&self, point: u16) -> Option<u64>
pub fn as_fixed_point_u64(&self, point: u16) -> Option<u64>
Obtain an integer at a fixed decimal point. This is useful for converting monetary values and doing arithmetic on them without rounding errors introduced by floating point operations.
Will return None if Number is negative or a NaN.
let price_a = Number::from(5.99);
let price_b = Number::from(7);
let price_c = Number::from(10.2);
assert_eq!(price_a.as_fixed_point_u64(2), Some(599));
assert_eq!(price_b.as_fixed_point_u64(2), Some(700));
assert_eq!(price_c.as_fixed_point_u64(2), Some(1020));Sourcepub fn as_fixed_point_i64(&self, point: u16) -> Option<i64>
pub fn as_fixed_point_i64(&self, point: u16) -> Option<i64>
Analog to as_fixed_point_u64, except returning a signed
i64, properly handling negative numbers.
let balance_a = Number::from(-1.49);
let balance_b = Number::from(42);
assert_eq!(balance_a.as_fixed_point_i64(2), Some(-149));
assert_eq!(balance_b.as_fixed_point_i64(2), Some(4200));