Struct ParseConfig 

pub struct ParseConfig {
    pub max_recursion_depth: usize,
    pub max_tokens: usize,
}

Configuration for parser behavior and resource limits.

Controls limits on recursion depth, token count, and other resources to prevent denial-of-service attacks via malformed input.

Default Values

Setting	Default	Rationale
max_recursion_depth	128	Matches serde_json default
max_tokens	usize::MAX	No limit by default

Security Considerations

Without recursion limits, deeply nested input like [[[[[[...]]]]]] can cause stack overflow. The default limit of 128 prevents most attacks while allowing reasonable nesting for typical use cases.

Example

let config = ParseConfig::default();
let mut parser = TokenStream::with_config(tokens, config);

// In recursive parse implementation:
fn parse_nested(stream: &mut TokenStream) -> Result<Nested, Error> {
    stream.enter_nested()?; // Increments depth, checks limit
    let inner = stream.parse()?;
    stream.exit_nested(); // Decrements depth
    Ok(Nested { inner })
}

Fields

max_recursion_depth: usize

Maximum allowed recursion depth.

When parsing nested structures, each level of nesting increments a depth counter. If the counter exceeds this limit, parsing fails with Error::RecursionLimitExceeded.

Default: 128 (matching serde_json)

max_tokens: usize

Maximum number of tokens to process.

If the parser consumes more than this many tokens, parsing fails. This can prevent resource exhaustion from extremely long inputs.

Default: usize::MAX (no limit)

Implementations

impl ParseConfig

pub const DEFAULT: Self

Default configuration, usable in const contexts.

Equivalent to ParseConfig::default() but available at compile time.

pub const fn new() -> Self

Creates a new configuration with default values.

pub const fn with_max_recursion_depth(self, depth: usize) -> Self

Sets the maximum recursion depth.

Arguments

• depth - Maximum nesting level. Use usize::MAX to disable the limit.

Example

let config = ParseConfig::new()
    .with_max_recursion_depth(256);

pub const fn with_max_tokens(self, count: usize) -> Self

Sets the maximum token count.

Arguments

• count - Maximum tokens to process. Use usize::MAX to disable.

pub const fn disable_recursion_limit(self) -> Self

Disables the recursion limit.

Warning

Only use this when parsing trusted input! Untrusted deeply-nested input can cause stack overflow.

Trait Implementations

impl Clone for ParseConfig

fn clone(&self) -> ParseConfig

Returns a duplicate 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 configuration.

• max_recursion_depth: 128
• max_tokens: usize::MAX

impl PartialEq for ParseConfig

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

impl Eq for ParseConfig

impl StructuralPartialEq for ParseConfig