Struct Number

pub struct Number { /* private fields */ }

Represents a JSON number, whether integer or floating point.

Implementations

impl Number

fn is_i64(&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) -> 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) -> 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) -> Option<i64>

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

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

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

fn as_f64(&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) -> Option<i128>

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

fn as_u128(&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());

Trait Implementations

impl Clone for Number

fn clone(&self) -> Self

impl Debug for Number

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

impl Display for Number

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

impl Eq for Number

impl From<i16> for Number

fn from(i: i16) -> Self

impl From<i32> for Number

fn from(i: i32) -> Self

impl From<i64> for Number

fn from(i: i64) -> Self

impl From<i8> for Number

fn from(i: i8) -> Self

impl From<isize> for Number

fn from(i: isize) -> Self

impl From<u16> for Number

fn from(u: u16) -> Self

impl From<u32> for Number

fn from(u: u32) -> Self

impl From<u64> for Number

fn from(u: u64) -> Self

impl From<u8> for Number

fn from(u: u8) -> Self

impl From<usize> for Number

fn from(u: usize) -> Self

impl FromStr for Number

type Err = Error;
fn from_str(s: &str) -> Result<Self, Self::Err>

impl Hash for Number

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

impl PartialEq for Number

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

impl Serialize for Number

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

impl StructuralPartialEq for Number

impl<'de> Deserialize<'de> for Number

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

impl<'de> Deserializer<'de> for Number

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

Auto Trait Implementations

impl Freeze for Number

impl RefUnwindSafe for Number

impl Send for Number

impl Sync for Number

impl Unpin for Number

impl UnsafeUnpin for Number

impl UnwindSafe for Number

Blanket Implementations

impl<T> Any for Number where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for Number where T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for Number where T: ?Sized,

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

impl<T> CloneToUninit for Number where T: Clone,

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

impl<T> DeserializeOwned for Number where T: for<'de> Deserialize<'de>,

impl<T> From<T> for Number

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> ToOwned for Number where T: Clone,

type Owned = T;
fn to_owned(&self) -> T
fn clone_into(&self, target: &mut T)

impl<T> ToString for Number where T: Display + ?Sized,

fn to_string(&self) -> String

impl<T, U> Into<U> for Number where U: From<T>,

fn into(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<U> for Number where U: Into<T>,

type Error = never;
fn try_from(value: U) -> Result<T, never>

impl<T, U> TryInto<U> for Number where U: TryFrom<T>,

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