Enum ActiveStates 

pub enum ActiveStates {
    Simple(HashSet<StateId>),
    Counted {
        configs: HashSet<ActiveConfig>,
        num_counters: usize,
    },
    RangedSingle {
        state_ranges: HashMap<StateId, CounterRange>,
        counter_def: CounterDef,
    },
    Hybrid {
        configs: HashMap<HybridKey, CounterRange>,
        ranged_counter_idx: usize,
        num_counters: usize,
    },
}

Quad-path active state set for NFA simulation.

Invariant: values are always closure-closed (epsilon closure has been applied). All constructors and advance methods enforce this.

• Simple: counter-free NFA — delegates to existing HashSet<StateId> functions.
• Counted: NFA with multiple counters — tracks HashSet<ActiveConfig> (scalar).
• RangedSingle: single counter with nullable body — stores one CounterRange per reachable state, converging epsilon closure in O(states) instead of O(N).
• Hybrid: multiple counters, one ranged (fast-forward) + others scalar. Collapses the ranged counter’s dimension; cost proportional to remaining scalar dims.

Variants

Simple(HashSet<StateId>)

Fast path: no counters in this NFA (bit-identical to old code)

Counted

Scalar counted path: configurations carry individual counter values

Fields

configs: HashSet<ActiveConfig>

num_counters: usize

RangedSingle

Optimized path for single-counter NFAs with nullable loop body. Each reachable state maps to one CounterRange (contiguity invariant).

Fields

state_ranges: HashMap<StateId, CounterRange>

counter_def: CounterDef

Hybrid

Hybrid path: one counter ranged (fast-forward), others scalar. The ranged counter’s slot in every HybridKey is always 0 (sentinel); the actual ranged value lives in the CounterRange map value.

Fields

configs: HashMap<HybridKey, CounterRange>

ranged_counter_idx: usize

num_counters: usize

Implementations

impl ActiveStates

pub fn from_nfa(nfa: &NfaTable) -> Self

Create initial active states from an NFA, picking the right variant.

pub fn is_empty(&self) -> bool

Check if the active set is empty (no reachable states).

pub fn contains_accept(&self, nfa: &NfaTable) -> bool

Check if any active state is the NFA accept state.

pub fn epsilon_closure(self, nfa: &NfaTable) -> Self

Compute epsilon closure (including counter transitions for Counted path).

pub fn advance( self, nfa: &NfaTable, element_name: NameId, element_namespace: Option<NameId>, target_namespace: Option<NameId>, substitution_groups: Option<&SubstitutionGroupMap>, xsd_version: XsdVersion, ) -> Self

Advance NFA states by matching an element (XSD 1.0 — no priority).

pub fn advance_with_priority( self, nfa: &NfaTable, element_name: NameId, element_namespace: Option<NameId>, target_namespace: Option<NameId>, substitution_groups: Option<&SubstitutionGroupMap>, xsd_version: XsdVersion, ) -> Self

Advance NFA states with element-over-wildcard priority (XSD 1.1).

pub fn find_match_info( &self, nfa: &NfaTable, name: NameId, namespace: Option<NameId>, target_ns: Option<NameId>, subst_groups: Option<&SubstitutionGroupMap>, xsd_version: XsdVersion, ) -> MatchInfo

Find the matching term info from active states (for content validation).

Returns the element key and resolved type of the first matching term. Since ActiveStates is closure-closed, all reachable term states are already present — no additional epsilon closure needed for Counted path.

pub fn expected_element_terms( &self, nfa: &NfaTable, ) -> Vec<(NameId, Option<NameId>, Option<ElementKey>)>

Collect expected element terms from reachable states (for error messages).

Returns (local_name, namespace, element_key) for each reachable Element term.

Trait Implementations

impl Clone for ActiveStates

fn clone(&self) -> ActiveStates

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ActiveStates

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

Formats the value using the given formatter.