# Enum json::JsonValue [−] [src]

    pub enum JsonValue {
        Null,
        Short(Short),
        String(String),
        Number(Number),
        Boolean(bool),
        Object(Object),
        Array(Vec<JsonValue>),
    }

## Variants

`Null`
`Short(Short)`
`String(String)`
`Number(Number)`
`Boolean(bool)`
`Object(Object)`
`Array(Vec<JsonValue>)`

## Implementations

### `impl JsonValue` [src]

#### `pub fn new_object() -> JsonValue` [src]

Create an empty `JsonValue::Object` instance. When creating an object with data, consider using the `object!` macro.

#### `pub fn new_array() -> JsonValue` [src]

Create an empty `JsonValue::Array` instance. When creating array with data, consider using the `array!` macro.

#### `pub fn dump(&self) -> String` [src]

Prints out the value as JSON string.

#### `pub fn pretty(&self, spaces: u16) -> String` [src]

Pretty prints out the value as JSON string. Takes an argument that’s number of spaces to indent new blocks with.

#### `pub fn to_writer<W: Write>(&self, writer: &mut W)` [src]

👎 Deprecated since 0.10.2:

use `JsonValue::write` instead

Writes the JSON as byte stream into an implementor of `std::io::Write`.

This method is deprecated as it will panic on io errors, use `write` instead.

#### `pub fn write<W: Write>(&self, writer: &mut W) -> Result<()>` [src]

Writes the JSON as byte stream into an implementor of `std::io::Write`.

#### `pub fn write_pretty<W: Write>(&self, writer: &mut W, spaces: u16) -> Result<()>` [src]

Writes the JSON as byte stream into an implementor of `std::io::Write`.

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

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

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

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

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

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

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

Checks whether the value is empty. Returns true for:

- empty string (`""`)
- number `0`
- boolean `false`
- null
- empty array (`array![]`)
- empty object (`object!{}`)

#### `pub fn as_str(&self) -> Option<&str>` [src]

#### `pub fn as_number(&self) -> Option<Number>` [src]

#### `pub fn as_f64(&self) -> Option<f64>` [src]

#### `pub fn as_f32(&self) -> Option<f32>` [src]

#### `pub fn as_u64(&self) -> Option<u64>` [src]

#### `pub fn as_u32(&self) -> Option<u32>` [src]

#### `pub fn as_u16(&self) -> Option<u16>` [src]

#### `pub fn as_u8(&self) -> Option<u8>` [src]

#### `pub fn as_usize(&self) -> Option<usize>` [src]

#### `pub fn as_i64(&self) -> Option<i64>` [src]

#### `pub fn as_i32(&self) -> Option<i32>` [src]

#### `pub fn as_i16(&self) -> Option<i16>` [src]

#### `pub fn as_i8(&self) -> Option<i8>` [src]

#### `pub fn as_isize(&self) -> Option<isize>` [src]

#### `pub fn as_bool(&self) -> Option<bool>` [src]

#### `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` called on a value that’s not a number, or if the number is negative or a NaN.

    let price_a = JsonValue::from(5.99);
    let price_b = JsonValue::from(7);
    let price_c = JsonValue::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 = JsonValue::from(-1.49);
    let balance_b = JsonValue::from(42);

    assert_eq!(balance_a.as_fixed_point_i64(2), Some(-149));
    assert_eq!(balance_b.as_fixed_point_i64(2), Some(4200));

#### `pub fn take(&mut self) -> JsonValue` [src]

Take over the ownership of the value, leaving `Null` in it’s place.

## Example

    let mut data = array!["Foo", 42];

    let first = data[0].take();
    let second = data[1].take();

    assert!(first == "Foo");
    assert!(second == 42);

    assert!(data[0].is_null());
    assert!(data[1].is_null());

#### `pub fn take_string(&mut self) -> Option<String>` [src]

Checks that self is a string, returns an owned Rust `String`, leaving `Null` in it’s place.

- If the contained string is already a heap allocated `String`, then the ownership is moved without any heap allocation.

- If the contained string is a `Short`, this will perform a heap allocation to convert the types for you.

## Example

    let mut data = array!["Hello", "World"];

    let owned = data[0].take_string().expect("Should be a string");

    assert_eq!(owned, "Hello");
    assert!(data[0].is_null());

#### `pub fn push<T>(&mut self, value: T) -> Result<()> where
T: Into<JsonValue>,` [src]

Works on `JsonValue::Array` - pushes a new value to the array.

#### `pub fn pop(&mut self) -> JsonValue` [src]

Works on `JsonValue::Array` - remove and return last element from an array. On failure returns a null.

#### `pub fn contains<T>(&self, item: T) -> bool where
T: PartialEq<JsonValue>,` [src]

Works on `JsonValue::Array` - checks if the array contains a value

#### `pub fn has_key(&self, key: &str) -> bool` [src]

Works on `JsonValue::Object` - checks if the object has a key

#### `pub fn len(&self) -> usize` [src]

Returns length of array or object (number of keys), defaults to `0` for other types.

#### `pub fn members(&self) -> Members<'_>` [src]

Works on `JsonValue::Array` - returns an iterator over members. Will return an empty iterator if called on non-array types.

#### `pub fn members_mut(&mut self) -> MembersMut<'_>` [src]

Works on `JsonValue::Array` - returns a mutable iterator over members. Will return an empty iterator if called on non-array types.

#### `pub fn entries(&self) -> Entries<'_>` [src]

Works on `JsonValue::Object` - returns an iterator over key value pairs. Will return an empty iterator if called on non-object types.

#### `pub fn entries_mut(&mut self) -> EntriesMut<'_>` [src]

Works on `JsonValue::Object` - returns a mutable iterator over key value pairs. Will return an empty iterator if called on non-object types.

#### `pub fn insert<T>(&mut self, key: &str, value: T) -> Result<()> where
T: Into<JsonValue>,` [src]

Works on `JsonValue::Object` - inserts a new entry, or override an existing one into the object. Note that `key` has to be a `&str` slice and not an owned `String`. The internals of `Object` will handle the heap allocation of the key if needed for better performance.

#### `pub fn remove(&mut self, key: &str) -> JsonValue` [src]

Works on `JsonValue::Object` - remove a key and return the value it held. If the key was not present, the method is called on anything but an object, it will return a null.

#### `pub fn array_remove(&mut self, index: usize) -> JsonValue` [src]

Works on `JsonValue::Array` - remove an entry and return the value it held. If the method is called on anything but an object or if the index is out of bounds, it will return `JsonValue::Null`.

#### `pub fn clear(&mut self)` [src]

When called on an array or an object, will wipe them clean. When called on a string will clear the string. Numbers and booleans become null.

## Trait Implementations

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

#### `fn clone(&self) -> JsonValue` [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 Debug for JsonValue` [src]

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

Formats the value using the given formatter. Read more

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

Implements formatting

    let data = json::parse(r#"{"url":"https://github.com/"}"#).unwrap();
    println!("{}", data);
    println!("{:#}", data);

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

Formats the value using the given formatter. Read more

### `impl Eq for JsonValue` [src]

### `impl<'a, T: Into<JsonValue> + Clone> From<&'a [T]> for JsonValue` [src]

#### `fn from(val: &'a [T]) -> JsonValue` [src]

Performs the conversion.

### `impl<'a> From<&'a str> for JsonValue` [src]

#### `fn from(val: &'a str) -> JsonValue` [src]

Performs the conversion.

### `impl<K: AsRef<str>, V: Into<JsonValue>> From<BTreeMap<K, V>> for JsonValue` [src]

#### `fn from(val: BTreeMap<K, V>) -> JsonValue` [src]

Performs the conversion.

### `impl<K: AsRef<str>, V: Into<JsonValue>> From<HashMap<K, V, RandomState>> for JsonValue` [src]

#### `fn from(val: HashMap<K, V>) -> JsonValue` [src]

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

### `impl<T: Into<JsonValue>> From<Option<T>> for JsonValue` [src]

#### `fn from(val: Option<T>) -> JsonValue` [src]

Performs the conversion.

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

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

Performs the conversion.

### `impl<T: Into<JsonValue>> From<Vec<T, Global>> for JsonValue` [src]

#### `fn from(val: Vec<T>) -> JsonValue` [src]

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

### `impl<'a> Index<&'a String> for JsonValue` [src]

#### `type Output = JsonValue`

The returned type after indexing.

#### `fn index(&self, index: &String) -> &JsonValue` [src]

Performs the indexing (`container[index]`) operation.

### `impl<'a> Index<&'a str> for JsonValue` [src]

Implements indexing by `&str` to easily access object members:

## Example

    let object = object!{
        foo: "bar"
    };

    assert!(object["foo"] == "bar");

#### `type Output = JsonValue`

The returned type after indexing.

#### `fn index(&self, index: &str) -> &JsonValue` [src]

Performs the indexing (`container[index]`) operation.

### `impl Index<String> for JsonValue` [src]

#### `type Output = JsonValue`

The returned type after indexing.

#### `fn index(&self, index: String) -> &JsonValue` [src]

Performs the indexing (`container[index]`) operation.

### `impl Index<usize> for JsonValue` [src]

Implements indexing by `usize` to easily access array members:

## Example

    let mut array = JsonValue::new_array();

    array.push("foo");

    assert!(array[0] == "foo");

#### `type Output = JsonValue`

The returned type after indexing.

#### `fn index(&self, index: usize) -> &JsonValue` [src]

Performs the indexing (`container[index]`) operation.

### `impl<'a> IndexMut<&'a String> for JsonValue` [src]

#### `fn index_mut(&mut self, index: &String) -> &mut JsonValue` [src]

Performs the mutable indexing (`container[index]`) operation.

### `impl<'a> IndexMut<&'a str> for JsonValue` [src]

Implements mutable indexing by `&str` to easily modify object members:

## Example

    let mut object = object!{};

    object["foo"] = 42.into();

    assert!(object["foo"] == 42);

#### `fn index_mut(&mut self, index: &str) -> &mut JsonValue` [src]

Performs the mutable indexing (`container[index]`) operation.

### `impl IndexMut<String> for JsonValue` [src]

#### `fn index_mut(&mut self, index: String) -> &mut JsonValue` [src]

Performs the mutable indexing (`container[index]`) operation.

### `impl IndexMut<usize> for JsonValue` [src]

Implements mutable indexing by `usize` to easily modify array members:

## Example

    let mut array = array!["foo", 3.14];

    array[1] = "bar".into();

    assert!(array[1] == "bar");

#### `fn index_mut(&mut self, index: usize) -> &mut JsonValue` [src]

Performs the mutable indexing (`container[index]`) operation.

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

#### `fn eq(&self, other: &&str) -> 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<JsonValue> for &'a str` [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<'a> PartialEq<JsonValue> for str` [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<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<JsonValue> for Object` [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<JsonValue> for JsonValue` [src]

#### `fn eq(&self, other: &Self) -> 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<Object> for JsonValue` [src]

#### `fn eq(&self, other: &Object) -> 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<Object> for &'a JsonValue` [src]

#### `fn eq(&self, other: &Object) -> 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<String> for JsonValue` [src]

#### `fn eq(&self, other: &String) -> 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<String> for &'a JsonValue` [src]

#### `fn eq(&self, other: &String) -> 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<bool> for JsonValue` [src]

#### `fn eq(&self, other: &bool) -> 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<bool> for &'a JsonValue` [src]

#### `fn eq(&self, other: &bool) -> 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 JsonValue` [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<'a> PartialEq<f32> for &'a JsonValue` [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 JsonValue` [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<'a> PartialEq<f64> for &'a JsonValue` [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 JsonValue` [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<'a> PartialEq<i16> for &'a JsonValue` [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 JsonValue` [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<'a> PartialEq<i32> for &'a JsonValue` [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 JsonValue` [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<'a> PartialEq<i64> for &'a JsonValue` [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 JsonValue` [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<'a> PartialEq<i8> for &'a JsonValue` [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 JsonValue` [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<'a> PartialEq<isize> for &'a JsonValue` [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<str> for JsonValue` [src]

#### `fn eq(&self, other: &str) -> 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 JsonValue` [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<'a> PartialEq<u16> for &'a JsonValue` [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 JsonValue` [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<'a> PartialEq<u32> for &'a JsonValue` [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 JsonValue` [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<'a> PartialEq<u64> for &'a JsonValue` [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 JsonValue` [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<'a> PartialEq<u8> for &'a JsonValue` [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 JsonValue` [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 `!=`.

### `impl<'a> PartialEq<usize> for &'a JsonValue` [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 JsonValue`

### `impl Send for JsonValue`

### `impl Sync for JsonValue`

### `impl Unpin for JsonValue`

### `impl UnwindSafe for JsonValue`

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