Struct RecursionGuard 

pub struct RecursionGuard { /* private fields */ }

Recursion depth guard for AST traversal and file operations

Tracks the current recursion depth and enforces a maximum limit to prevent stack overflow from pathological inputs like deeply nested function definitions.

Thread Safety

RecursionGuard is NOT thread-safe and should not be shared between threads. Each thread should have its own guard instance.

Example

use sqry_core::query::security::RecursionGuard;

fn process_node(node: &str, guard: &mut RecursionGuard) -> Result<(), Box<dyn std::error::Error>> {
    guard.enter()?;
    // Process the node...
    guard.exit();
    Ok(())
}

let mut guard = RecursionGuard::new(100)?;
process_node("example", &mut guard)?;

Implementations

impl RecursionGuard

pub fn new(max_depth: usize) -> Result<Self>

Create a new recursion guard with the specified maximum depth

Errors

Returns an error if max_depth is 0.

pub fn enter(&mut self) -> Result<(), RecursionError>

Enter a new recursion level

This must be called at the beginning of each recursive function. Must be paired with a corresponding exit call.

Errors

Returns RecursionError::DepthLimitExceeded if entering would exceed the max depth.

pub fn exit(&mut self)

Exit the current recursion level

This must be called when leaving a recursive function, typically in a defer-like pattern or before returning.

pub fn current_depth(&self) -> usize

Get the current recursion depth

pub fn max_depth_reached(&self) -> usize

Get the maximum depth reached during execution

Useful for telemetry and understanding actual depth requirements.

pub fn max_depth(&self) -> usize

Get the configured maximum depth limit

Trait Implementations

impl Debug for RecursionGuard

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

Formats the value using the given formatter.