Enum Value 

pub enum Value<T: Json> {
    Null,
    Boolean(bool),
    Number(T::Number),
    String(T::String),
    Array(T::Array),
    Object(T::Object),
}

Any JSON value.

Variants

Null

JSON null value.

Boolean(bool)

JSON boolean value (true or false).

Number(T::Number)

JSON number, wether integer of floating point.

String(T::String)

JSON string value.

Array(T::Array)

JSON array of values.

Object(T::Object)

JSON object.

Implementations

impl<T: Json> Value<T>

pub fn is_null(&self) -> bool

Returns true if the value is a Null. Returns false otherwise.

pub fn is_bool(&self) -> bool

Returns true if the value is a boolean. Returns false otherwise.

For any value on which is_bool returns true, as_bool is guaranteed to return the boolean value.

pub fn is_number(&self) -> bool

Returns true if the value is a number. Returns false otherwise.

For any value on which is_number returns true, as_number is guaranteed to return the number value.

pub fn is_string(&self) -> bool

Returns true if the value is a string. Returns false otherwise.

For any value on which is_string returns true, as_str is guaranteed to return the string value.

pub fn is_array(&self) -> bool

Returns true if the value is an array. Returns false otherwise.

For any value on which is_array returns true, as_array is guaranteed to return the array value.

pub fn is_object(&self) -> bool

Returns true if the value is an object. Returns false otherwise.

For any value on which is_object returns true, as_object is guaranteed to return the object value.

pub fn as_bool(&self) -> Option<bool>

If the value is a boolean, returns the associated bool. Returns None otherwise.

pub fn as_number(&self) -> Option<&T::Number>

If the value is a number, returns a reference to it. Returns None otherwise.

pub fn as_str(&self) -> Option<&str>

If the value is a string, returns its associated str. Returns None otherwise.

pub fn as_array(&self) -> Option<&T::Array>

If the value is an array, returns a reference to it. Returns None otherwise.

pub fn as_array_mut(&mut self) -> Option<&mut T::Array>

If the value is an array, returns a mutable reference to it. Returns None otherwise.

pub fn as_object(&self) -> Option<&T::Object>

If the value is an object, returns a reference to it. Returns None otherwise.

pub fn as_object_mut(&mut self) -> Option<&mut T::Object>

If the value is an object, returns a mutable reference to it. Returns None otherwise.

pub fn as_value_ref(&self) -> ValueRef<'_, T>

pub fn as_value_mut(&mut self) -> ValueMut<'_, T>

pub fn take(&mut self) -> Self

Takes the value out of the Value, leaving a Null in its place.

impl<T: JsonNew> Value<T>

where T::String: for<'a> From<&'a str>,

pub fn with(self, meta: T::MetaData) -> T

pub fn with_default(self) -> T

where T::MetaData: Default,

Trait Implementations

impl<T: Json> Clone for Value<T>

where T::Number: Clone, T::String: Clone, T::Array: Clone, T::Object: Clone,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Json> Debug for Value<T>

where T::Number: Debug, T::String: Debug, T::Array: Debug, T::Object: Debug,

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

Formats the value using the given formatter.

impl<T: Json> Default for Value<T>

fn default() -> Self

The default value is Value::Null.

impl<'a, T: Json> From<&'a [Value<T>]> for Value<T>

where T::Array: From<&'a [Value<T>]>,

fn from(a: &'a [Value<T>]) -> Self

Converts to this type from the input type.

impl<'a, T: Json> From<&'a str> for Value<T>

where T::String: From<&'a str>,

fn from(s: &'a str) -> Self

Converts to this type from the input type.

impl<T: Json> From<()> for Value<T>

fn from(_: ()) -> Self

Converts to this type from the input type.

impl<'a, T: Json> From<Cow<'a, str>> for Value<T>

where T::String: From<Cow<'a, str>>,

fn from(s: Cow<'a, str>) -> Self

Converts to this type from the input type.

impl<J: Json> From<J> for Value<J>

fn from(j: J) -> Value<J>

Converts to this type from the input type.

impl<T: Json> From<String> for Value<T>

where T::String: From<String>,

fn from(s: String) -> Self

Converts to this type from the input type.

impl<T: Json> From<Vec<Value<T>>> for Value<T>

where T::Array: From<Vec<Value<T>>>,

fn from(a: Vec<Value<T>>) -> Self

Converts to this type from the input type.

impl<T: Json> From<bool> for Value<T>

fn from(b: bool) -> Self

Converts to this type from the input type.

impl<T: Json> From<f32> for Value<T>

where T::Number: From<f32>,

fn from(n: f32) -> Self

Converts to this type from the input type.

impl<T: Json> From<f64> for Value<T>

where T::Number: From<f64>,

fn from(n: f64) -> Self

Converts to this type from the input type.

impl<T: Json> From<i16> for Value<T>

where T::Number: From<i16>,

fn from(n: i16) -> Self

Converts to this type from the input type.

impl<T: Json> From<i32> for Value<T>

where T::Number: From<i32>,

fn from(n: i32) -> Self

Converts to this type from the input type.

impl<T: Json> From<i64> for Value<T>

where T::Number: From<i64>,

fn from(n: i64) -> Self

Converts to this type from the input type.

impl<T: Json> From<i8> for Value<T>

where T::Number: From<i8>,

fn from(n: i8) -> Self

Converts to this type from the input type.

impl<T: Json> From<isize> for Value<T>

where T::Number: From<isize>,

fn from(n: isize) -> Self

Converts to this type from the input type.

impl<T: Json> From<u16> for Value<T>

where T::Number: From<u16>,

fn from(n: u16) -> Self

Converts to this type from the input type.

impl<T: Json> From<u32> for Value<T>

where T::Number: From<u32>,

fn from(n: u32) -> Self

Converts to this type from the input type.

impl<T: Json> From<u64> for Value<T>

where T::Number: From<u64>,

fn from(n: u64) -> Self

Converts to this type from the input type.

impl<T: Json> From<u8> for Value<T>

where T::Number: From<u8>,

fn from(n: u8) -> Self

Converts to this type from the input type.

impl<T: Json> From<usize> for Value<T>

where T::Number: From<usize>,

fn from(n: usize) -> Self

Converts to this type from the input type.

impl<T: Json, V: Into<Self>> FromIterator<V> for Value<T>

where T::Array: FromIterator<Self>,

fn from_iter<I: IntoIterator<Item = V>>(iter: I) -> Self

Creates a value from an iterator.

impl<T: Json> Hash for Value<T>

where T::Number: Hash, T::String: Hash, T::Array: Hash, T::Object: Hash,

fn hash<H: Hasher>(&self, h: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'a, T: Json> PartialEq<&'a str> for Value<T>

fn eq(&self, other: &&'a str) -> 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<'a, T: Json> PartialEq<String> for Value<T>

fn eq(&self, other: &String) -> 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<T: Json> PartialEq<Value<T>> for f32

where f32: PartialEq<T::Number>,

fn eq(&self, other: &Value<T>) -> 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<T: Json> PartialEq<Value<T>> for f64

where f64: PartialEq<T::Number>,

fn eq(&self, other: &Value<T>) -> 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<T: Json> PartialEq<Value<T>> for i16

where i16: PartialEq<T::Number>,

fn eq(&self, other: &Value<T>) -> 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<T: Json> PartialEq<Value<T>> for i32

where i32: PartialEq<T::Number>,

fn eq(&self, other: &Value<T>) -> 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<T: Json> PartialEq<Value<T>> for i64

where i64: PartialEq<T::Number>,

fn eq(&self, other: &Value<T>) -> 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<T: Json> PartialEq<Value<T>> for i8

where i8: PartialEq<T::Number>,

fn eq(&self, other: &Value<T>) -> 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<T: Json> PartialEq<Value<T>> for isize

where isize: PartialEq<T::Number>,

fn eq(&self, other: &Value<T>) -> 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<T: Json> PartialEq<Value<T>> for u16

where u16: PartialEq<T::Number>,

fn eq(&self, other: &Value<T>) -> 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<T: Json> PartialEq<Value<T>> for u32

where u32: PartialEq<T::Number>,

fn eq(&self, other: &Value<T>) -> 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<T: Json> PartialEq<Value<T>> for u64

where u64: PartialEq<T::Number>,

fn eq(&self, other: &Value<T>) -> 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<T: Json> PartialEq<Value<T>> for u8

where u8: PartialEq<T::Number>,

fn eq(&self, other: &Value<T>) -> 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<T: Json> PartialEq<Value<T>> for usize

where usize: PartialEq<T::Number>,

fn eq(&self, other: &Value<T>) -> 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<T: Json, U: Json> PartialEq<Value<U>> for Value<T>

where T::Number: PartialEq<U::Number>, T::String: PartialEq<U::String>, T::Array: PartialEq<U::Array>, T::Object: PartialEq<U::Object>,

fn eq(&self, other: &Value<U>) -> 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<T: Json> PartialEq<bool> for Value<T>

fn eq(&self, other: &bool) -> 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<'a, T: Json> PartialEq<f32> for &'a Value<T>

where T::Number: PartialEq<f32>,

fn eq(&self, other: &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<'a, T: Json> PartialEq<f32> for &'a mut Value<T>

where T::Number: PartialEq<f32>,

fn eq(&self, other: &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<T: Json> PartialEq<f32> for Value<T>

where T::Number: PartialEq<f32>,

fn eq(&self, other: &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<'a, T: Json> PartialEq<f64> for &'a Value<T>

where T::Number: PartialEq<f64>,

fn eq(&self, other: &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<'a, T: Json> PartialEq<f64> for &'a mut Value<T>

where T::Number: PartialEq<f64>,

fn eq(&self, other: &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<T: Json> PartialEq<f64> for Value<T>

where T::Number: PartialEq<f64>,

fn eq(&self, other: &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<'a, T: Json> PartialEq<i16> for &'a Value<T>

where T::Number: PartialEq<i16>,

fn eq(&self, other: &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<'a, T: Json> PartialEq<i16> for &'a mut Value<T>

where T::Number: PartialEq<i16>,

fn eq(&self, other: &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<T: Json> PartialEq<i16> for Value<T>

where T::Number: PartialEq<i16>,

fn eq(&self, other: &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<'a, T: Json> PartialEq<i32> for &'a Value<T>

where T::Number: PartialEq<i32>,

fn eq(&self, other: &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<'a, T: Json> PartialEq<i32> for &'a mut Value<T>

where T::Number: PartialEq<i32>,

fn eq(&self, other: &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<T: Json> PartialEq<i32> for Value<T>

where T::Number: PartialEq<i32>,

fn eq(&self, other: &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<'a, T: Json> PartialEq<i64> for &'a Value<T>

where T::Number: PartialEq<i64>,

fn eq(&self, other: &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<'a, T: Json> PartialEq<i64> for &'a mut Value<T>

where T::Number: PartialEq<i64>,

fn eq(&self, other: &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<T: Json> PartialEq<i64> for Value<T>

where T::Number: PartialEq<i64>,

fn eq(&self, other: &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<'a, T: Json> PartialEq<i8> for &'a Value<T>

where T::Number: PartialEq<i8>,

fn eq(&self, other: &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<'a, T: Json> PartialEq<i8> for &'a mut Value<T>

where T::Number: PartialEq<i8>,

fn eq(&self, other: &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<T: Json> PartialEq<i8> for Value<T>

where T::Number: PartialEq<i8>,

fn eq(&self, other: &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<'a, T: Json> PartialEq<isize> for &'a Value<T>

where T::Number: PartialEq<isize>,

fn eq(&self, other: &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<'a, T: Json> PartialEq<isize> for &'a mut Value<T>

where T::Number: PartialEq<isize>,

fn eq(&self, other: &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<T: Json> PartialEq<isize> for Value<T>

where T::Number: PartialEq<isize>,

fn eq(&self, other: &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<'a, T: Json> PartialEq<u16> for &'a Value<T>

where T::Number: PartialEq<u16>,

fn eq(&self, other: &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<'a, T: Json> PartialEq<u16> for &'a mut Value<T>

where T::Number: PartialEq<u16>,

fn eq(&self, other: &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<T: Json> PartialEq<u16> for Value<T>

where T::Number: PartialEq<u16>,

fn eq(&self, other: &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<'a, T: Json> PartialEq<u32> for &'a Value<T>

where T::Number: PartialEq<u32>,

fn eq(&self, other: &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<'a, T: Json> PartialEq<u32> for &'a mut Value<T>

where T::Number: PartialEq<u32>,

fn eq(&self, other: &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<T: Json> PartialEq<u32> for Value<T>

where T::Number: PartialEq<u32>,

fn eq(&self, other: &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<'a, T: Json> PartialEq<u64> for &'a Value<T>

where T::Number: PartialEq<u64>,

fn eq(&self, other: &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<'a, T: Json> PartialEq<u64> for &'a mut Value<T>

where T::Number: PartialEq<u64>,

fn eq(&self, other: &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<T: Json> PartialEq<u64> for Value<T>

where T::Number: PartialEq<u64>,

fn eq(&self, other: &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<'a, T: Json> PartialEq<u8> for &'a Value<T>

where T::Number: PartialEq<u8>,

fn eq(&self, other: &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<'a, T: Json> PartialEq<u8> for &'a mut Value<T>

where T::Number: PartialEq<u8>,

fn eq(&self, other: &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<T: Json> PartialEq<u8> for Value<T>

where T::Number: PartialEq<u8>,

fn eq(&self, other: &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<'a, T: Json> PartialEq<usize> for &'a Value<T>

where T::Number: PartialEq<usize>,

fn eq(&self, other: &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<'a, T: Json> PartialEq<usize> for &'a mut Value<T>

where T::Number: PartialEq<usize>,

fn eq(&self, other: &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<T: Json> PartialEq<usize> for Value<T>

where T::Number: PartialEq<usize>,

fn eq(&self, other: &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<T: Json, U: Json> PartialOrd<Value<U>> for Value<T>

where T::Number: PartialOrd<U::Number>, T::String: PartialOrd<U::String>, T::Array: PartialOrd<U::Array>, T::Object: PartialOrd<U::Object>,

fn partial_cmp(&self, other: &Value<U>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T: Json> Eq for Value<T>

where T::Number: Eq, T::String: Eq, T::Array: Eq, T::Object: Eq,