Struct ParserConfig 

pub struct ParserConfig {

    pub backend: ParserBackend,
    pub timeout: Duration,
    pub max_expression_depth: u32,
    pub max_collection_size: u32,
    pub max_string_length: u32,
    pub max_parameters: u32,
    pub strict_validation: bool,
    pub allow_experimental: bool,
    pub backend_options: HashMap<String, Value>,
    pub features: Vec<ParserFeature>,
    pub memory_limits: MemoryLimits,
    pub performance: PerformanceSettings,
    pub error_handling: ErrorHandlingSettings,
    pub memory_settings: MemorySettings,
    pub security_settings: SecuritySettings,
}

Parser configuration

Fields

backend: ParserBackend

Backend to use for parsing

timeout: Duration

Timeout for parsing operations

max_expression_depth: u32

Maximum depth for nested expressions

max_collection_size: u32

Maximum number of items in collections

max_string_length: u32

Maximum length for string literals

max_parameters: u32

Maximum number of parameters in a statement

strict_validation: bool

Whether to enable strict validation

allow_experimental: bool

Whether to allow experimental features

backend_options: HashMap<String, Value>

Backend-specific options

features: Vec<ParserFeature>

Features to enable

memory_limits: MemoryLimits

Memory limits

performance: PerformanceSettings

Performance settings

error_handling: ErrorHandlingSettings

Error handling settings

memory_settings: MemorySettings

Memory settings

security_settings: SecuritySettings

Security settings

Implementations

impl ParserConfig

pub fn new() -> Self

Create a new configuration with default values

pub fn fast() -> Self

Create a fast configuration optimized for performance

Parallel parsing requires >=2 worker threads, so the thread count is set to max(num_cpus, 2) to stay valid even on single-core CI runners.

pub fn strict() -> Self

Create a strict configuration with maximum validation

pub fn development() -> Self

Create a development configuration with debugging features

pub fn minimal() -> Self

Create a minimal configuration for embedded use

pub fn with_backend(self, backend: ParserBackend) -> Self

Set the parser backend

pub fn with_timeout(self, timeout: Duration) -> Self

Set the timeout

pub fn with_strict_validation(self, strict: bool) -> Self

Enable strict validation

pub fn with_feature(self, feature: ParserFeature) -> Self

Add a feature (no-op if already present)

pub fn has_feature(&self, feature: &ParserFeature) -> bool

Check if a feature is enabled

pub fn validate(&self) -> Result<(), String>

Validate the configuration

Trait Implementations

impl Clone for ParserConfig

fn clone(&self) -> ParserConfig

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ParserConfig

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

Formats the value using the given formatter.

impl Default for ParserConfig

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for ParserConfig

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for ParserConfig

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

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for ParserConfig