fn next_state(
        &mut self,
        qcur: &mut SparseSet,
        qnext: &mut SparseSet,
        si: StatePtr,
        b: Byte,
    ) -> Option<StatePtr> {
        if si == STATE_DEAD {
            return Some(STATE_DEAD);
        }
        let cls = self.byte_class(b);
        match self.cache.state(si).next[cls] {
            STATE_UNKNOWN => self.exec_byte(qcur, qnext, si, b),
            STATE_DEAD => return Some(STATE_DEAD),
            nsi => return Some(nsi),
        }
    }
/// Returns the next state given the current state si and current byte
/// b. {qcur,qnext} are used as scratch space for storing ordered NFA
/// states.
///
/// This tries to fetch the next state from the cache, but if that fails,
/// it computes the next state, caches it and returns a pointer to it.
///
/// The pointer can be to a real state, or it can be STATE_DEAD.
/// STATE_UNKNOWN cannot be returned.
///
/// None is returned if a new state could not be allocated (i.e., the DFA
/// ran out of space and thinks it's running too slowly).
Returns the next state given the current state si and current byte
b. {qcur,qnext} are used as scratch space for storing ordered NFA
states.

This tries to fetch the next state from the cache, but if that fails,
it computes the next state, caches it and returns a pointer to it.

The pointer can be to a real state, or it can be STATE_DEAD.
STATE_UNKNOWN cannot be returned.

None is returned if a new state could not be allocated .
Returns the next state given the current state si and current byte b . { qcur qnext } are used as scratch space for storing ordered NFA states . This tries to fetch the next state from the cache but if that fails it computes the next state caches it and returns a pointer to it . The pointer can be to a real state or it can be STATE_DEAD . STATE_UNKNOWN cannot be returned . None is returned if a new state could not be allocated .
fn next_state(
        &mut self,
        qcur: &mut SparseSet,
        qnext: &mut SparseSet,
        si: StatePtr,
        b: Byte,
    ) -> Option<StatePtr> {
        if si == STATE_DEAD {
            return Some(STATE_DEAD);
        }
        let cls = self.byte_class(b);
        match self.cache.state(si).next[cls] {
            STATE_UNKNOWN => self.exec_byte(qcur, qnext, si, b),
            STATE_DEAD => return Some(STATE_DEAD),
            nsi => return Some(nsi),
        }
    }
fn next_state ( & mut self , qcur : & mut SparseSet , qnext : & mut SparseSet , si : StatePtr , b : Byte , ) -> Option < StatePtr > { if si == STATE_DEAD { return Some ( STATE_DEAD ) ; } let cls = self . byte_class ( b ) ; match self . cache . state ( si ) . next [ cls ] { STATE_UNKNOWN => self . exec_byte ( qcur , qnext , si , b ) , STATE_DEAD => return Some ( STATE_DEAD ) , nsi => return Some ( nsi ) , } }
Returns the next state given the current state si and current byte
b.
Returns the next state given the current state si and current byte b .
&mut self
qcur
&mut SparseSet
qnext
&mut SparseSet
si
StatePtr
b
Byte
&mut self
qcur
&mut SparseSet
qnext
&mut SparseSet
si
StatePtr
b
Byte