Struct JsonLimits 

pub struct JsonLimits {
    pub max_input_bytes: usize,
    pub max_depth: usize,
    pub max_string_bytes: usize,
    pub max_key_bytes: usize,
    pub max_number_bytes: usize,
    pub max_array_items: usize,
    pub max_object_members: usize,
    pub max_total_nodes: usize,
    pub max_total_decoded_string_bytes: usize,
}

Resource limits enforced while parsing.

Limits bound logical decoded data (counts and byte lengths), not exact allocator memory — real heap use also depends on String/Vec capacity and the platform. Parsing untrusted input should always go through limits; crate::parse applies JsonLimits::new by default.

Fields

max_input_bytes: usize

Maximum size of the whole input, in bytes.

max_depth: usize

Maximum nesting depth of arrays and objects.

max_string_bytes: usize

Maximum decoded size of a single string value, in bytes.

max_key_bytes: usize

Maximum decoded size of a single object key, in bytes.

max_number_bytes: usize

Maximum length of a single number token, in bytes.

max_array_items: usize

Maximum number of items in a single array.

max_object_members: usize

Maximum number of members in a single object.

max_total_nodes: usize

Maximum total number of values (nodes) in the document.

max_total_decoded_string_bytes: usize

Maximum total decoded string bytes across the whole document.

Implementations

impl JsonLimits

pub const fn new() -> Self

The default limits: conservative values suitable for untrusted input.

1 MiB input, depth 64, 256 KiB per string, 16 KiB per key, 256 bytes per number, 100_000 array items / object members, 200_000 total nodes, 1 MiB total decoded string bytes.

pub const fn conservative() -> Self

A tighter profile for small, low-trust payloads (e.g. tokens, webhooks).

64 KiB input, depth 32, 16 KiB per string, 1 KiB per key, 64 bytes per number, 4_096 array items / object members, 16_384 total nodes, 64 KiB total decoded string bytes.

Examples found in repository

examples/basic.rs (line 12)

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 const fn permissive() -> Self

A looser profile for larger trusted documents. Still explicit and finite.

64 MiB input, depth 128, 16 MiB per string, 256 KiB per key, 1_024 bytes per number, 5_000_000 array items / object members, 10_000_000 total nodes, 64 MiB total decoded string bytes.

pub const fn with_max_depth(self, value: usize) -> Self

Sets max_depth.

pub const fn with_max_input_bytes(self, value: usize) -> Self

Sets max_input_bytes.

pub const fn with_max_string_bytes(self, value: usize) -> Self

Sets max_string_bytes.

pub const fn with_max_total_nodes(self, value: usize) -> Self

Sets max_total_nodes.

Trait Implementations

impl Clone for JsonLimits

fn clone(&self) -> JsonLimits

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for JsonLimits

impl Debug for JsonLimits

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

Formats the value using the given formatter.

impl Default for JsonLimits

fn default() -> Self

Returns the “default value” for a type.

impl Eq for JsonLimits

impl PartialEq for JsonLimits

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