Struct RecursionGuard 

pub struct RecursionGuard<K: Hash + Eq> { /* private fields */ }

A reusable guard that tracks recursion depth and detects cycles.

Use this in any recursive parser function to enforce the ADR 0004 recursion depth limit (50 levels) and optionally detect circular references via a visited set keyed by K.

For depth-only tracking (no cycle detection), use RecursionGuard<()> — the unit type implements Hash + Eq as a singleton, so the visited set never grows and enter/leave are cheap no-ops.

Type Parameters

• K — The key type for cycle detection (e.g., usize for package indices, String for dependency names, PathBuf for file paths, or () for depth-only tracking).

Example

use provenant::parsers::utils::RecursionGuard;

fn walk_tree(idx: usize, guard: &mut RecursionGuard<usize>) {
    if guard.exceeded() {
        return;
    }
    if guard.enter(idx) {
        return;
    }
    walk_tree(idx + 1, guard);
    guard.leave(idx);
}

Implementations

impl<K: Hash + Eq> RecursionGuard<K>

pub fn new() -> Self

pub fn exceeded(&self) -> bool

pub fn depth(&self) -> usize

pub fn enter(&mut self, key: K) -> bool

pub fn leave(&mut self, key: K)

impl RecursionGuard<()>

pub fn depth_only() -> Self

pub fn descend(&mut self) -> bool

pub fn ascend(&mut self)

Trait Implementations

impl<K: Hash + Eq> Default for RecursionGuard<K>

fn default() -> Self

Returns the “default value” for a type.