Struct ParseOptions 

pub struct ParseOptions {
    pub limits: Limits,
    pub reference_mode: ReferenceMode,
}

Parsing options for configuring HEDL document parsing behavior.

ParseOptions provides both direct field access and a fluent builder API for convenient configuration. All parsing functions accept ParseOptions to customize limits, security settings, and error handling behavior.

Creating ParseOptions

Using the builder pattern (recommended)

use hedl_core::ParseOptions;

// Typical strict parsing with custom depth limit
let opts = ParseOptions::builder()
    .max_depth(100)
    .strict(true)
    .build();

// Lenient parsing for large datasets
let opts = ParseOptions::builder()
    .max_array_length(50_000)
    .strict(false)
    .max_block_string_size(50 * 1024 * 1024)
    .build();

// Restrictive parsing for security
let opts = ParseOptions::builder()
    .max_file_size(10 * 1024 * 1024)
    .max_line_length(64 * 1024)
    .max_depth(20)
    .max_array_length(1000)
    .strict(true)
    .build();

Using defaults

use hedl_core::{ParseOptions, parse_with_limits};

// Default options: strict refs, normal limits
let opts = ParseOptions::default();

// Parse with defaults
let doc = parse_with_limits(input, opts)?;

Direct field access

use hedl_core::{ParseOptions, Limits};

let mut opts = ParseOptions::default();
opts.reference_mode = false;
opts.limits.max_nodes = 5000;

Security Considerations

ParseOptions includes multiple security limits to prevent denial-of-service attacks:

• max_file_size: Prevents loading extremely large files
• max_line_length: Prevents regex DOS via extremely long lines
• max_indent_depth: Prevents stack overflow via deep nesting
• max_nodes: Prevents memory exhaustion via large matrix lists
• max_object_keys and max_total_keys: Prevent memory exhaustion via many objects
• max_nest_depth: Prevents stack overflow via deeply nested NEST hierarchies
• max_block_string_size: Prevents memory exhaustion via large block strings

Fields

• limits: Security limits for parser resources
• reference_mode: Reference resolution mode (strict or lenient)

Fields

limits: Limits

Security limits.

reference_mode: ReferenceMode

Reference resolution mode (strict or lenient).

Controls how unresolved references are handled:

• ReferenceMode::Strict: Errors on unresolved references (default)
• ReferenceMode::Lenient: Ignores unresolved references

Note: Ambiguous references always error regardless of mode.

Implementations

impl ParseOptions

pub fn builder() -> ParseOptionsBuilder

Create a new builder for ParseOptions.

Examples

let opts = ParseOptions::builder()
    .max_depth(100)
    .strict(true)
    .build();

Trait Implementations

impl Clone for ParseOptions

fn clone(&self) -> ParseOptions

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ParseOptions

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

Formats the value using the given formatter.

impl Default for ParseOptions

fn default() -> Self

Returns the “default value” for a type.