Struct JsonObject 

pub struct JsonObject { /* private fields */ }

A JSON object: members in insertion order with unique keys.

Keys are guaranteed unique — the parser rejects duplicates, and insert replaces an existing key in place rather than adding a second entry. Lookup is linear; object size is bounded by JsonLimits when parsing untrusted input.

Implementations

impl JsonObject

pub fn new() -> Self

Creates an empty object.

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

Returns the value for key, if present.

Examples found in repository

examples/basic.rs (line 23)

fn main() {
    // Treat this as untrusted input: parse under a conservative limit profile.
    let input = r#"{ "service": "api", "port": 8080, "tags": ["a", "b"], "enabled": true }"#;
    let limits = JsonLimits::conservative();

    let value = match parse_with_limits(input.as_bytes(), limits) {
        Ok(value) => value,
        Err(err) => {
            eprintln!("rejected: {err}");
            return;
        }
    };

    if let JsonValue::Object(object) = &value {
        if let Some(port) = object.get("port").and_then(JsonValue::as_number) {
            println!("port = {}", port.to_u64().unwrap());
        }
        if let Some(tags) = object.get("tags").and_then(JsonValue::as_array) {
            println!("tags = {}", tags.len());
        }
    }

    // Deterministic, member-order-preserving serialization.
    println!("compact = {}", to_compact_string(&value));

    // Strict by default: these are all rejected.
    for bad in [r#"{"a":1,"a":2}"#, "{ /* c */ }", "[1,]", "NaN"] {
        match parse_with_limits(bad.as_bytes(), limits) {
            Ok(_) => println!("accepted (unexpected): {bad}"),
            Err(err) => println!("rejected {bad:?}: {}", err.kind_str()),
        }
    }
}

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

Returns true if key is present.

pub fn insert(&mut self, key: String, value: JsonValue) -> Option<JsonValue>

Inserts or replaces key. If the key already exists its value is replaced in place (preserving position) and the old value is returned; otherwise the member is appended.

pub fn len(&self) -> usize

The number of members.

pub fn is_empty(&self) -> bool

Returns true if the object has no members.

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

Iterates over members in insertion order.

Trait Implementations

impl Clone for JsonObject

fn clone(&self) -> JsonObject

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for JsonObject

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

Formats the value using the given formatter.

impl Default for JsonObject

fn default() -> JsonObject

Returns the “default value” for a type.

impl PartialEq for JsonObject

fn eq(&self, other: &JsonObject) -> 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 StructuralPartialEq for JsonObject