Struct Object

pub struct Object { /* private fields */ }

A binary tree implementation of a string -> JsonValue map. You normally don’t have to interact with instances of Object, much more likely you will be using the JsonValue::Object variant, which wraps around this struct.

Implementations

impl Object

pub fn new() -> Object

Create a new, empty instance of Object. Empty Object performs no allocation until a value is inserted into it.

pub fn with_capacity(capacity: usize) -> Object

Create a new Object with memory preallocated for capacity number of entries.

pub fn insert(&mut self, key: &str, value: JsonValue)

Insert a new entry, or override an existing one. 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 override_last(&mut self, value: JsonValue)

👎Deprecated since 0.11.11: Was only meant for internal use

pub fn get(&self, key: &str) -> Option<&JsonValue>

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

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

Attempts to remove the value behind key, if successful will return the JsonValue stored behind the key.

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn clear(&mut self)

Wipe the Object clear. The capacity will remain untouched.

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

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

pub fn dump(&self) -> String

Prints out the value as JSON string.

pub fn pretty(&self, spaces: u16) -> String

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

Trait Implementations

impl Clone for Object

fn clone(&self) -> Object

Returns a duplicate 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<(), Error>

Formats the value using the given formatter.

impl From<Object> for JsonValue

fn from(val: Object) -> JsonValue

Converts to this type from the input type.

impl<'a> Index<&'a String> for Object

type Output = JsonValue

The returned type after indexing.

fn index(&self, index: &String) -> &JsonValue

Performs the indexing (container[index]) operation.

impl<'a> Index<&'a str> for Object

Implements indexing by &str to easily access object members:

Example

let value = object!{
    "foo" => "bar"
};

if let JsonValue::Object(object) = value {
  assert!(object["foo"] == "bar");
}

type Output = JsonValue

The returned type after indexing.

fn index(&self, index: &str) -> &JsonValue

Performs the indexing (container[index]) operation.

impl Index<String> for Object

type Output = JsonValue

The returned type after indexing.

fn index(&self, index: String) -> &JsonValue

Performs the indexing (container[index]) operation.

impl<'a> IndexMut<&'a String> for Object

fn index_mut(&mut self, index: &String) -> &mut JsonValue

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

impl<'a> IndexMut<&'a str> for Object

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

Example

let value = object!{};

if let JsonValue::Object(mut object) = value {
  object["foo"] = 42.into();

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

fn index_mut(&mut self, index: &str) -> &mut JsonValue

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

impl IndexMut<String> for Object

fn index_mut(&mut self, index: String) -> &mut JsonValue

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

impl PartialEq<JsonValue> for Object

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

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 JsonValue

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 for Object

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.