Struct justjson::parser::ParseConfig

#[non_exhaustive]
pub struct ParseConfig {
    pub allow_trailing_commas: bool,
    pub recursion_limit: Option<usize>,
    pub allow_all_types_at_root: bool,
}

A JSON Value parsing configuration.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

allow_trailing_commas: bool

If true, allows trailing commas when parsing arrays and objects. If false, trailing commas will cause an ErrorKind::IllegalTrailingComma to be returned.

recursion_limit: Option<usize>

If present, nested arrays and objects will be limited to recursion_limit levels of nesting. If not present, no checks will be performed which can cause a stack overflow with very deeply nested payloads.

allow_all_types_at_root: bool

If true, only arrays or objects will be allowed to parse at the root of the JSON payload.

Implementations

impl ParseConfig

pub const fn new() -> Self

Returns the default configuration:

let config = justjson::parser::ParseConfig::new();
assert_eq!(config.allow_trailing_commas, false);
assert_eq!(config.recursion_limit, Some(128));
assert_eq!(config.allow_all_types_at_root, true);

pub const fn strict() -> Self

Returns a strict configuration, which differs from the default configuration by only allowing objects and arrays at the root:

let config = justjson::parser::ParseConfig::strict();
assert_eq!(config.allow_trailing_commas, false);
assert_eq!(config.recursion_limit, Some(128));
assert_eq!(config.allow_all_types_at_root, false);

pub const fn without_recursion_limit(self) -> Self

Disables recursuion limit testing.

Note: Malicious payloads may be able to cause stack overflows to occur if this is disabled.

pub const fn with_recursion_limit(self, limit: usize) -> Self

Sets the maximum recursion limit to limit.

pub const fn allowing_all_types_at_root(self, allow_all: bool) -> Self

Sets whether to allow all types at the root of the JSON payload. If false, only arrays and objects will be allowed at the root of the JSON payload.

pub const fn allowing_trailing_commas(self) -> Self

Allows trailing commas when parsing objects and arrays.

use justjson::parser::ParseConfig;
use justjson::Value;

let source = r#"{"a":[true,],}"#;
Value::from_json(source).expect_err("not enabled by default");
let config = ParseConfig::new().allowing_trailing_commas();
Value::from_json_with_config(source, config).expect("now parses");

Trait Implementations

impl Clone for ParseConfig

fn clone(&self) -> ParseConfig

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ParseConfig

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

Formats the value using the given formatter.

impl Default for ParseConfig

fn default() -> Self

Returns the “default value” for a type.

impl PartialEq for ParseConfig

fn eq(&self, other: &ParseConfig) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for ParseConfig

impl Eq for ParseConfig

impl StructuralEq for ParseConfig

impl StructuralPartialEq for ParseConfig