Struct Number

struct Number { ... }

Represents a JSON number, whether integer or floating point.

Implementations

impl Number

fn is_i64(self: &Self) -> bool

Returns true if the Number is an integer between i64::MIN and i64::MAX.

For any Number on which is_i64 returns true, as_i64 is guaranteed to return the integer value.

fn is_u64(self: &Self) -> bool

Returns true if the Number is an integer between zero and u64::MAX.

For any Number on which is_u64 returns true, as_u64 is guaranteed to return the integer value.

fn is_f64(self: &Self) -> bool

Returns true if the Number can be represented by f64.

For any Number on which is_f64 returns true, as_f64 is guaranteed to return the floating point value.

Currently this function returns true if and only if both is_i64 and is_u64 return false but this is not a guarantee in the future.

fn as_i64(self: &Self) -> Option<i64>

If the Number is an integer, represent it as i64 if possible. Returns None otherwise.

fn as_u64(self: &Self) -> Option<u64>

If the Number is an integer, represent it as u64 if possible. Returns None otherwise.

fn as_f64(self: &Self) -> Option<f64>

Represents the number as f64 if possible. Returns None otherwise.

fn from_f64(f: f64) -> Option<Number>

Converts a finite f64 to a Number. Infinite or NaN values are not JSON numbers.

# use serde_json::Number;
#
assert!(Number::from_f64(256.0).is_some());

assert!(Number::from_f64(f64::NAN).is_none());

fn as_i128(self: &Self) -> Option<i128>

If the Number is an integer, represent it as i128 if possible. Returns None otherwise.

fn as_u128(self: &Self) -> Option<u128>

If the Number is an integer, represent it as u128 if possible. Returns None otherwise.

fn from_i128(i: i128) -> Option<Number>

Converts an i128 to a Number. Numbers smaller than i64::MIN or larger than u64::MAX can only be represented in Number if serde_json's "arbitrary_precision" feature is enabled.

# use serde_json::Number;
#
assert!(Number::from_i128(256).is_some());

fn from_u128(i: u128) -> Option<Number>

Converts a u128 to a Number. Numbers greater than u64::MAX can only be represented in Number if serde_json's "arbitrary_precision" feature is enabled.

# use serde_json::Number;
#
assert!(Number::from_u128(256).is_some());

impl Clone for Number

fn clone(self: &Self) -> Number

impl Debug for Number

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

impl Display for Number

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

impl Eq for Number

impl Freeze for Number

impl From for Number

fn from(u: u16) -> Self

impl From for Number

fn from(i: i32) -> Self

impl From for Number

fn from(u: u8) -> Self

impl From for Number

fn from(i: i16) -> Self

impl From for Number

fn from(i: i8) -> Self

impl From for Number

fn from(u: usize) -> Self

impl From for Number

fn from(u: u64) -> Self

impl From for Number

fn from(i: isize) -> Self

impl From for Number

fn from(u: u32) -> Self

impl From for Number

fn from(i: i64) -> Self

impl FromStr for Number

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

impl Hash for Number

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

impl PartialEq for Number

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

impl RefUnwindSafe for Number

impl Send for Number

impl Serialize for Number

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

impl StructuralPartialEq for Number

impl Sync for Number

impl Unpin for Number

impl UnsafeUnpin for Number

impl UnwindSafe for Number

impl<'de> Deserialize for Number

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

impl<'de> Deserializer for Number

fn deserialize_any<V>(self: Self, visitor: V) -> Result<<V as >::Value, Error>
where
    V: Visitor<'de>
fn deserialize_i8<V>(self: Self, visitor: V) -> Result<<V as >::Value, Error>
where
    V: Visitor<'de>
fn deserialize_i16<V>(self: Self, visitor: V) -> Result<<V as >::Value, Error>
where
    V: Visitor<'de>
fn deserialize_i32<V>(self: Self, visitor: V) -> Result<<V as >::Value, Error>
where
    V: Visitor<'de>
fn deserialize_i64<V>(self: Self, visitor: V) -> Result<<V as >::Value, Error>
where
    V: Visitor<'de>
fn deserialize_i128<V>(self: Self, visitor: V) -> Result<<V as >::Value, Error>
where
    V: Visitor<'de>
fn deserialize_u8<V>(self: Self, visitor: V) -> Result<<V as >::Value, Error>
where
    V: Visitor<'de>
fn deserialize_u16<V>(self: Self, visitor: V) -> Result<<V as >::Value, Error>
where
    V: Visitor<'de>
fn deserialize_u32<V>(self: Self, visitor: V) -> Result<<V as >::Value, Error>
where
    V: Visitor<'de>
fn deserialize_u64<V>(self: Self, visitor: V) -> Result<<V as >::Value, Error>
where
    V: Visitor<'de>
fn deserialize_u128<V>(self: Self, visitor: V) -> Result<<V as >::Value, Error>
where
    V: Visitor<'de>
fn deserialize_f32<V>(self: Self, visitor: V) -> Result<<V as >::Value, Error>
where
    V: Visitor<'de>
fn deserialize_f64<V>(self: Self, visitor: V) -> Result<<V as >::Value, Error>
where
    V: Visitor<'de>
fn deserialize_bool<V>(self: Self, visitor: V) -> Result<<V as >::Value, <Self as Deserializer<'de>>::Error>
where
    V: Visitor<'de>
fn deserialize_char<V>(self: Self, visitor: V) -> Result<<V as >::Value, <Self as Deserializer<'de>>::Error>
where
    V: Visitor<'de>
fn deserialize_str<V>(self: Self, visitor: V) -> Result<<V as >::Value, <Self as Deserializer<'de>>::Error>
where
    V: Visitor<'de>
fn deserialize_string<V>(self: Self, visitor: V) -> Result<<V as >::Value, <Self as Deserializer<'de>>::Error>
where
    V: Visitor<'de>
fn deserialize_bytes<V>(self: Self, visitor: V) -> Result<<V as >::Value, <Self as Deserializer<'de>>::Error>
where
    V: Visitor<'de>
fn deserialize_byte_buf<V>(self: Self, visitor: V) -> Result<<V as >::Value, <Self as Deserializer<'de>>::Error>
where
    V: Visitor<'de>
fn deserialize_option<V>(self: Self, visitor: V) -> Result<<V as >::Value, <Self as Deserializer<'de>>::Error>
where
    V: Visitor<'de>
fn deserialize_unit<V>(self: Self, visitor: V) -> Result<<V as >::Value, <Self as Deserializer<'de>>::Error>
where
    V: Visitor<'de>
fn deserialize_unit_struct<V>(self: Self, name: &'static str, visitor: V) -> Result<<V as >::Value, <Self as Deserializer<'de>>::Error>
where
    V: Visitor<'de>
fn deserialize_newtype_struct<V>(self: Self, name: &'static str, visitor: V) -> Result<<V as >::Value, <Self as Deserializer<'de>>::Error>
where
    V: Visitor<'de>
fn deserialize_seq<V>(self: Self, visitor: V) -> Result<<V as >::Value, <Self as Deserializer<'de>>::Error>
where
    V: Visitor<'de>
fn deserialize_tuple<V>(self: Self, len: usize, visitor: V) -> Result<<V as >::Value, <Self as Deserializer<'de>>::Error>
where
    V: Visitor<'de>
fn deserialize_tuple_struct<V>(self: Self, name: &'static str, len: usize, visitor: V) -> Result<<V as >::Value, <Self as Deserializer<'de>>::Error>
where
    V: Visitor<'de>
fn deserialize_map<V>(self: Self, visitor: V) -> Result<<V as >::Value, <Self as Deserializer<'de>>::Error>
where
    V: Visitor<'de>
fn deserialize_struct<V>(self: Self, name: &'static str, fields: &'static [&'static str], visitor: V) -> Result<<V as >::Value, <Self as Deserializer<'de>>::Error>
where
    V: Visitor<'de>
fn deserialize_enum<V>(self: Self, name: &'static str, variants: &'static [&'static str], visitor: V) -> Result<<V as >::Value, <Self as Deserializer<'de>>::Error>
where
    V: Visitor<'de>
fn deserialize_identifier<V>(self: Self, visitor: V) -> Result<<V as >::Value, <Self as Deserializer<'de>>::Error>
where
    V: Visitor<'de>
fn deserialize_ignored_any<V>(self: Self, visitor: V) -> Result<<V as >::Value, <Self as Deserializer<'de>>::Error>
where
    V: Visitor<'de>

impl<T> Any for Number

fn type_id(self: &Self) -> TypeId

impl<T> Borrow for Number

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

impl<T> BorrowMut for Number

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

impl<T> CloneToUninit for Number

unsafe fn clone_to_uninit(self: &Self, dest: *mut u8)

impl<T> DeserializeOwned for Number

impl<T> From for Number

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> ToOwned for Number

fn to_owned(self: &Self) -> T
fn clone_into(self: &Self, target: &mut T)

impl<T> ToString for Number

fn to_string(self: &Self) -> String

impl<T, U> Into for Number

fn into(self: Self) -> U

Calls U::from(self).

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

impl<T, U> TryFrom for Number

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

impl<T, U> TryInto for Number

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