Struct PathNfa 

pub struct PathNfa { /* private fields */ }

Non-deterministic finite automaton for variable-length path matching.

For a simple VLP pattern [:TYPE*min..max], this is a linear chain:

q0 --TYPE--> q1 --TYPE--> q2 --TYPE--> ... --TYPE--> q(max)
             ^                                        ^
             accepting if >= min_hops                  accepting

For a QPP pattern ((a)-[:T1]->(b:Person)-[:T2]->(c)){2,4}:

q0 --T1--> q1[Person] --T2--> q2 --T1--> q3[Person] --T2--> q4 --T1--> ...
                               ^                              ^
                               accepting (1 iter)             accepting (2 iter)

State constraints are checked during BFS expansion.

Implementations

impl PathNfa

pub fn from_vlp( edge_type_ids: Vec<u32>, direction: Direction, min_hops: usize, max_hops: usize, ) -> Self

Compile a simple VLP pattern into a linear-chain NFA.

Creates states q0..q(max_hops), with transitions from qi to qi+1. Accepting states are q(min_hops)..=q(max_hops).

pub fn transitions_from(&self, state: NfaStateId) -> &[NfaTransition]

Get all transitions from a given NFA state.

pub fn is_accepting(&self, state: NfaStateId) -> bool

Check if a state is an accepting state.

pub fn start_state(&self) -> NfaStateId

Get the start state of the NFA.

pub fn num_states(&self) -> u16

Get the total number of states.

pub fn accepting_states(&self) -> &HashSet<NfaStateId>

Get a reference to the accepting states set.

pub fn state_constraint(&self, state: NfaStateId) -> Option<&VertexConstraint>

Get the state constraint for a given NFA state.

pub fn from_qpp( steps: Vec<QppStep>, min_iterations: usize, max_iterations: usize, ) -> Self

Compile a QPP (Quantified Path Pattern) into an NFA with per-state constraints.

steps: the sub-pattern hops (e.g., 2 steps for (a)-[:T1]->(b:Person)-[:T2]->(c)) min_iterations, max_iterations: quantifier bounds (iterations, NOT hops)

For a 2-step sub-pattern with {2,4}:

• Total hops = 2 * 4 = 8
• States: q0, q1, q2, q3, q4, q5, q6, q7, q8 (9 states)
• Accepting at iteration boundaries: q4, q6, q8 (iterations 2, 3, 4)
• State constraints: step[0].target_constraint at q1, q3, q5, q7; step[1].target_constraint at q2, q4, q6, q8

Trait Implementations

impl Clone for PathNfa

fn clone(&self) -> PathNfa

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PathNfa

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

Formats the value using the given formatter.