Struct Object

pub struct Object(/* private fields */);

Represents the JSON object. The inner implement is a key-value array. Its order is as same as origin JSON.

Examples

use sonic_rs::{from_str, Object};

let mut obj: Object = from_str(r#"{"a": 1, "b": true, "c": null}"#).unwrap();

assert_eq!(obj["a"], 1);
assert_eq!(obj.insert(&"d", "e"), None);
assert_eq!(obj["d"], "e");
assert_eq!(obj.len(), 4);

Warning

The key in Object is not sorted and the get operation is O(n). And Object is allowed to have duplicated keys.

Examples

use sonic_rs::{from_str, Object};

let obj: Object = from_str(r#"{"a": 1, "a": true, "a": null}"#).unwrap();

assert_eq!(obj["a"], 1);
assert_eq!(obj.len(), 3); // allow duplicated keys

If you care about that, recommend to use HashMap or BTreeMap instead. The parse performance is slower than Object.

Implementations

impl Object

pub fn into_value(self) -> Value

Returns the inner Value.

pub fn new() -> Object

Create a new empty object.

Example

use sonic_rs::{from_str, json, object, prelude::*, Object};

let mut obj: Object = from_str("{}").unwrap();
obj.insert(&"arr", object! {});
obj.insert(&"a", 1);
obj.insert(&"arr2", Object::new());
obj["a"] = json!(123);
obj["arr2"] = json!("hello world");

assert_eq!(obj["a"], 123);
assert_eq!(obj["arr2"], "hello world");

pub fn with_capacity(capacity: usize) -> Self

Create a new empty object with capacity.

pub fn clear(&mut self)

Clear the object, make it as empty but keep the allocated memory.

Examples

use sonic_rs::{json, object};

let mut obj = object! {"a": 1, "b": true, "c": null};
obj.clear();
assert!(obj.is_empty());
assert!(obj.capacity() >= 3);

pub fn capacity(&self) -> usize

Returns the capacity of the object.

pub fn get<Q: AsRef<str>>(&self, key: &Q) -> Option<&Value>

Returns a reference to the value corresponding to the key.

The key may be AsRef<str>.

Examples

use sonic_rs::{json, object};

let mut obj = object! {"a": 1, "b": true, "c": null};
obj.insert(&"d", "e");
assert_eq!(obj.get(&"d").unwrap(), "e");
assert_eq!(obj.get(&"f"), None);
assert_eq!(obj.get(&"a").unwrap(), 1);

pub fn contains_key<Q: AsRef<str>>(&self, key: &Q) -> bool

Returns true if the map contains a value for the specified key.

The key may be AsRef<str>.

Examples

use sonic_rs::object;

let mut obj = object! {"a": 1, "b": true, "c": null};
obj.insert(&"d", "e");
assert_eq!(obj.contains_key(&"d"), true);
assert_eq!(obj.contains_key(&"a"), true);
assert_eq!(obj.contains_key(&"e"), false);

pub fn get_mut<Q: AsRef<str>>(&mut self, key: &Q) -> Option<&mut Value>

Returns a mutable reference to the value corresponding to the key.

The key may be AsRef<str>.

Examples

use sonic_rs::object;

let mut obj = object! {"a": 1, "b": true, "c": null};
obj.insert(&"d", "e");

*(obj.get_mut(&"d").unwrap()) = "f".into();
assert_eq!(obj.contains_key(&"d"), true);
assert_eq!(obj["d"], "f");

pub fn get_key_value<Q: AsRef<str>>(&self, key: &Q) -> Option<(&str, &Value)>

Returns the key-value pair corresponding to the supplied key.

The key may be AsRef<str>.

Examples

use sonic_rs::{object, Value};

let mut obj = object! {"a": 1, "b": true, "c": null};
obj.insert(&"d", "e");

assert_eq!(obj.get_key_value(&"d").unwrap(), ("d", &Value::from("e")));
assert_eq!(obj.get_key_value(&"a").unwrap(), ("a", &Value::from(1)));
assert_eq!(obj.get_key_value(&"e"), None);

pub fn insert<K: AsRef<str> + ?Sized, V: Into<Value>>( &mut self, key: &K, value: V, ) -> Option<Value>

Inserts a key-value pair into the object. The Value is converted from V.

The key may be AsRef<str>.

If the object did not have this key present, None is returned.

If the object did have this key present, the value is updated, and the old value is returned. The key is not updated, though; this matters for types that can be == without being identical. See the [module-level documentation] for more.

Examples

use sonic_rs::{json, object, Value};

let mut obj = object! {"a": 1, "b": true, "c": null};
assert_eq!(obj.len(), 3);
assert_eq!(obj.insert(&"d", "e"), None);
assert_eq!(obj.len(), 4);
assert_eq!(obj["d"], "e");
assert_eq!(obj.insert(&"d", "f").unwrap(), "e");
assert_eq!(obj["d"], "f");
assert_eq!(obj.len(), 4);
assert_eq!(obj.insert(&"d", json!("h")).unwrap(), "f");
assert_eq!(obj["d"], "h");
assert_eq!(obj.insert(&"i", Value::from("j")), None);
assert_eq!(obj.len(), 5);

pub fn remove<Q: AsRef<str>>(&mut self, key: &Q) -> Option<Value>

Removes a key from the object, returning the value at the key if the key was previously in the object.

The key may be AsRef<str>.

Examples

use sonic_rs::object;

let mut obj = object! {"a": 1, "b": true, "c": null};
assert_eq!(obj.remove(&"d"), None);
assert_eq!(obj.remove(&"a").unwrap(), 1);

pub fn remove_entry<'k, Q: AsRef<str>>( &mut self, key: &'k Q, ) -> Option<(&'k str, Value)>

Removes a key from the object, returning the stored key and value if the key was previously in the obj.

The key may be AsRef<str>.

Examples

use sonic_rs::object;

let mut obj = object! {"a": 1, "b": true, "c": null};
assert_eq!(obj.remove_entry(&"d"), None);
let (key, val) = obj.remove_entry(&"a").unwrap();
assert_eq!(key, "a");
assert_eq!(val, 1);

pub fn len(&self) -> usize

Returns the number of key-value paris in the object.

pub fn is_empty(&self) -> bool

Returns true if the object contains no key-value pairs.

pub fn iter(&self) -> Iter<'_>

Returns an immutable iterator over the key-value pairs of the object.

Examples

use sonic_rs::object;

let obj = object! {"a": 1, "b": true, "c": null};

for (key, value) in obj.iter() {
    println!("{}: {}", key, value);
}

pub fn iter_mut(&mut self) -> IterMut<'_>

Returns an mutable iterator over the key-value pairs of the object.

Examples

use sonic_rs::{object, Value};

let mut obj = object! {"a": 1, "b": true, "c": null};

for (key, value) in obj.iter_mut() {
    *value = Value::from(key);
}

assert_eq!(obj["a"], "a");
assert_eq!(obj["b"], "b");
assert_eq!(obj["c"], "c");

pub fn entry<'a, Q: AsRef<str> + ?Sized>(&'a mut self, key: &Q) -> Entry<'a>

Gets the given key’s corresponding entry in the object for in-place manipulation.

Examples

use sonic_rs::{object, Value};

let mut obj = object! {};

for i in 0..10 {
    obj.entry(&i.to_string()).or_insert(1);
}

for i in 0..10 {
    obj.entry(&i.to_string())
        .and_modify(|v| *v = Value::from(i + 1));
}

assert_eq!(obj[&"1"], 2);
assert_eq!(obj[&"2"], 3);
assert_eq!(obj[&"3"], 4);
assert_eq!(obj.get(&"10"), None);

pub fn retain<F>(&mut self, f: F)

where F: FnMut(&str, &mut Value) -> bool,

Retains only the elements specified by the predicate.

In other words, remove all pairs (k, v) for which f(&k, &mut v) returns false. The elements are visited in unsorted (and unspecified) order.

Examples

use sonic_rs::object;

let mut obj = object! {"a": 1, "b": true, "c": null};
obj.retain(|key, _| key == "a");
assert_eq!(obj.len(), 1);
assert_eq!(obj["a"], 1);

pub fn append(&mut self, other: &mut Self)

Moves all elements from other into self, leaving other empty.

Examples

use sonic_rs::{json, object};

let mut a = object! {};
let mut b = object! {"a": null, "b": 1};
a.append(&mut b);

assert_eq!(a, object! {"a": null, "b": 1});
assert!(b.is_empty());

pub fn reserve(&mut self, additional: usize)

Reserves capacity for at least additional more elements to be inserted in the given.

Examples

use sonic_rs::object;
let mut obj = object! {};
obj.reserve(1);
assert!(obj.capacity() >= 1);

obj.reserve(10);
assert!(obj.capacity() >= 10);

Trait Implementations

impl Clone for Object

fn clone(&self) -> Object

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Object

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

Formats the value using the given formatter.

impl Default for Object

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Object

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'a, K: AsRef<str> + ?Sized, V: Clone + Debug + Into<Value> + 'a> Extend<(&'a K, &'a V)> for Object

fn extend<I: IntoIterator<Item = (&'a K, &'a V)>>(&mut self, iter: I)

Extend a Object with the contents of an iterator.

Examples

use std::collections::HashMap;

use sonic_rs::{json, object, Object, Value};

let mut obj = object![];
let mut map: HashMap<&str, Value> = {
    let mut map = HashMap::new();
    map.insert("sonic", json!(40));
    map.insert("rs", json!(null));
    map
};

obj.extend(&map);
assert_eq!(obj, object! {"sonic": 40, "rs": null});

obj.extend(&object! {"object": [1, 2, 3]});
assert_eq!(obj, object! {"sonic": 40, "rs": null, "object": [1, 2, 3]});

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl From<Object> for Value

fn from(val: Object) -> Self

Converts to this type from the input type.

impl<'a, K: AsRef<str>, V: Clone + Into<Value> + 'a> FromIterator<(K, &'a V)> for Object

fn from_iter<T: IntoIterator<Item = (K, &'a V)>>(iter: T) -> Self

Create a Object by collecting an iterator of key-value pairs.

Examples

use std::collections::HashMap;

use sonic_rs::{object, Object, Value};

let mut map = HashMap::new();
map.insert("sonic_rs", 40);
map.insert("json", 2);

let x: Object = map.iter().collect();
assert_eq!(x, object! {"sonic_rs": 40, "json": 2});

let x = Object::from_iter(&object! {"sonic_rs": 40, "json": 2});
assert_eq!(x, object! {"sonic_rs": 40, "json": 2});

impl<'a, Q: AsRef<str> + ?Sized> Index<&'a Q> for Object

type Output = Value

The returned type after indexing.

fn index(&self, index: &'a Q) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<'a, Q: AsRef<str> + ?Sized> IndexMut<&'a Q> for Object

fn index_mut(&mut self, index: &'a Q) -> &mut Self::Output

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

impl<'a> IntoIterator for &'a Object

type Item = (&'a str, &'a Value)

The type of the elements being iterated over.

type IntoIter = Iter<'a>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a> IntoIterator for &'a mut Object

type Item = (&'a str, &'a mut Value)

The type of the elements being iterated over.

type IntoIter = IterMut<'a>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl PartialEq<Object> for &Value

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

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

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

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

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

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

fn eq(&self, other: &Self) -> 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 Serialize for Object

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

where S: Serializer,

Serialize this value into the given Serde serializer.