# Struct json::number::Number [−] [src]

    pub struct Number { /* fields omitted */ }

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

### `impl Number` [src]

#### `pub unsafe fn from_parts_unchecked(
positive: bool,
mantissa: u64,
exponent: i16
) -> Self` [src]

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.

#### `pub fn from_parts(positive: bool, mantissa: u64, exponent: i16) -> Self` [src]

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);

#### `pub fn as_parts(&self) -> (bool, u64, i16)` [src]

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` [src]

#### `pub fn is_zero(&self) -> bool` [src]

#### `pub fn is_nan(&self) -> bool` [src]

#### `pub fn is_empty(&self) -> bool` [src]

Test if the number is NaN or has a zero value.

#### `pub fn as_fixed_point_u64(&self, point: u16) -> Option<u64>` [src]

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));

#### `pub fn as_fixed_point_i64(&self, point: u16) -> Option<i64>` [src]

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));

## Trait Implementations

### `impl Clone for Number` [src]

#### `fn clone(&self) -> Number` [src]

Returns a copy of the value. Read more

#### `pub fn clone_from(&mut self, source: &Self)`1.0.0 [src]

Performs copy-assignment from `source`. Read more

### `impl Copy for Number` [src]

### `impl Debug for Number` [src]

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

Formats the value using the given formatter. Read more

### `impl Display for Number` [src]

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

Formats the value using the given formatter. Read more

### `impl From<Number> for JsonValue` [src]

#### `fn from(val: Number) -> JsonValue` [src]

Performs the conversion.

### `impl From<f32> for Number` [src]

#### `fn from(float: f32) -> Number` [src]

Performs the conversion.

### `impl From<f64> for Number` [src]

#### `fn from(float: f64) -> Number` [src]

Performs the conversion.

### `impl From<i16> for Number` [src]

#### `fn from(num: i16) -> Number` [src]

Performs the conversion.

### `impl From<i32> for Number` [src]

#### `fn from(num: i32) -> Number` [src]

Performs the conversion.

### `impl From<i64> for Number` [src]

#### `fn from(num: i64) -> Number` [src]

Performs the conversion.

### `impl From<i8> for Number` [src]

#### `fn from(num: i8) -> Number` [src]

Performs the conversion.

### `impl From<isize> for Number` [src]

#### `fn from(num: isize) -> Number` [src]

Performs the conversion.

### `impl From<u16> for Number` [src]

#### `fn from(num: u16) -> Number` [src]

Performs the conversion.

### `impl From<u32> for Number` [src]

#### `fn from(num: u32) -> Number` [src]

Performs the conversion.

### `impl From<u64> for Number` [src]

#### `fn from(num: u64) -> Number` [src]

Performs the conversion.

### `impl From<u8> for Number` [src]

#### `fn from(num: u8) -> Number` [src]

Performs the conversion.

### `impl From<usize> for Number` [src]

#### `fn from(num: usize) -> Number` [src]

Performs the conversion.

### `impl Neg for Number` [src]

#### `type Output = Number`

The resulting type after applying the `-` operator.

#### `fn neg(self) -> Number` [src]

Performs the unary `-` operation. Read more

### `impl PartialEq<JsonValue> for Number` [src]

#### `fn eq(&self, other: &JsonValue) -> bool` [src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

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

This method tests for `!=`.

### `impl PartialEq<Number> for JsonValue` [src]

#### `fn eq(&self, other: &Number) -> bool` [src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

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

This method tests for `!=`.

### `impl<'a> PartialEq<Number> for &'a JsonValue` [src]

#### `fn eq(&self, other: &Number) -> bool` [src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

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

This method tests for `!=`.

### `impl PartialEq<Number> for Number` [src]

#### `fn eq(&self, other: &Number) -> bool` [src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

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

This method tests for `!=`.

### `impl PartialEq<f32> for Number` [src]

#### `fn eq(&self, other: &f32) -> bool` [src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

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

This method tests for `!=`.

### `impl PartialEq<f64> for Number` [src]

#### `fn eq(&self, other: &f64) -> bool` [src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

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

This method tests for `!=`.

### `impl PartialEq<i16> for Number` [src]

#### `fn eq(&self, other: &i16) -> bool` [src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

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

This method tests for `!=`.

### `impl PartialEq<i32> for Number` [src]

#### `fn eq(&self, other: &i32) -> bool` [src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

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

This method tests for `!=`.

### `impl PartialEq<i64> for Number` [src]

#### `fn eq(&self, other: &i64) -> bool` [src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

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

This method tests for `!=`.

### `impl PartialEq<i8> for Number` [src]

#### `fn eq(&self, other: &i8) -> bool` [src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

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

This method tests for `!=`.

### `impl PartialEq<isize> for Number` [src]

#### `fn eq(&self, other: &isize) -> bool` [src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

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

This method tests for `!=`.

### `impl PartialEq<u16> for Number` [src]

#### `fn eq(&self, other: &u16) -> bool` [src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

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

This method tests for `!=`.

### `impl PartialEq<u32> for Number` [src]

#### `fn eq(&self, other: &u32) -> bool` [src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

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

This method tests for `!=`.

### `impl PartialEq<u64> for Number` [src]

#### `fn eq(&self, other: &u64) -> bool` [src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

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

This method tests for `!=`.

### `impl PartialEq<u8> for Number` [src]

#### `fn eq(&self, other: &u8) -> bool` [src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

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

This method tests for `!=`.

### `impl PartialEq<usize> for Number` [src]

#### `fn eq(&self, other: &usize) -> bool` [src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

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

This method tests for `!=`.

## Auto Trait Implementations

### `impl RefUnwindSafe for Number`

### `impl Send for Number`

### `impl Sync for Number`

### `impl Unpin for Number`

### `impl UnwindSafe for Number`

## 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<T> From<T> for T` [src]

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

Performs the conversion.

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

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

Performs the conversion.

### `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.