IntermediateState

Struct IntermediateState 

Source
pub struct IntermediateState<TermClass, NonTerm, StateIndex, RuleIndex> {
    pub shift_goto_map_term: Vec<(TermClass, ShiftTarget<StateIndex>)>,
    pub shift_goto_map_nonterm: Vec<(NonTerm, ShiftTarget<StateIndex>)>,
    pub reduce_map: Vec<(TermClass, Vec<RuleIndex>)>,
    pub ruleset: Vec<ShiftedRuleRef>,
}
Expand description

This intermediate state is a common structure to convert from generated code and grammar builder into various types of parser states (SparseState, DenseState, …).

Fields§

§shift_goto_map_term: Vec<(TermClass, ShiftTarget<StateIndex>)>§shift_goto_map_nonterm: Vec<(NonTerm, ShiftTarget<StateIndex>)>§reduce_map: Vec<(TermClass, Vec<RuleIndex>)>§ruleset: Vec<ShiftedRuleRef>

Trait Implementations§

Source§

impl<TermClass, NonTerm, RuleContainer, StateIndex, RuleIndex> From<IntermediateState<TermClass, NonTerm, StateIndex, RuleIndex>> for DenseState<TermClass, NonTerm, RuleContainer, StateIndex>
where TermClass: TerminalClass + Ord + Copy, NonTerm: NonTerminal + Hash + Eq + Copy, StateIndex: Copy, RuleContainer: Clone + ReduceRules, <RuleContainer as ReduceRules>::RuleIndex: TryFrom<RuleIndex>,

Source§

fn from( builder_state: IntermediateState<TermClass, NonTerm, StateIndex, RuleIndex>, ) -> DenseState<TermClass, NonTerm, RuleContainer, StateIndex>

Converts to this type from the input type.
Source§

impl<TermClass, NonTerm, RuleContainer, StateIndex, RuleIndex> From<IntermediateState<TermClass, NonTerm, StateIndex, RuleIndex>> for SparseState<TermClass, NonTerm, RuleContainer, StateIndex>
where TermClass: TerminalClass + Ord + Hash, NonTerm: NonTerminal + Hash + Eq, RuleContainer: ReduceRules, <RuleContainer as ReduceRules>::RuleIndex: TryFrom<RuleIndex>,

Source§

fn from( builder_state: IntermediateState<TermClass, NonTerm, StateIndex, RuleIndex>, ) -> SparseState<TermClass, NonTerm, RuleContainer, StateIndex>

Converts to this type from the input type.
Source§

impl<Term, NonTerm> From<State<Term, NonTerm>> for IntermediateState<Term, NonTerm, usize, usize>
where Term: Ord,

Source§

fn from( state: State<Term, NonTerm>, ) -> IntermediateState<Term, NonTerm, usize, usize>

Converts to this type from the input type.

Auto Trait Implementations§

§

impl<TermClass, NonTerm, StateIndex, RuleIndex> Freeze for IntermediateState<TermClass, NonTerm, StateIndex, RuleIndex>

§

impl<TermClass, NonTerm, StateIndex, RuleIndex> RefUnwindSafe for IntermediateState<TermClass, NonTerm, StateIndex, RuleIndex>
where TermClass: RefUnwindSafe, NonTerm: RefUnwindSafe, StateIndex: RefUnwindSafe, RuleIndex: RefUnwindSafe,

§

impl<TermClass, NonTerm, StateIndex, RuleIndex> Send for IntermediateState<TermClass, NonTerm, StateIndex, RuleIndex>
where TermClass: Send, NonTerm: Send, StateIndex: Send, RuleIndex: Send,

§

impl<TermClass, NonTerm, StateIndex, RuleIndex> Sync for IntermediateState<TermClass, NonTerm, StateIndex, RuleIndex>
where TermClass: Sync, NonTerm: Sync, StateIndex: Sync, RuleIndex: Sync,

§

impl<TermClass, NonTerm, StateIndex, RuleIndex> Unpin for IntermediateState<TermClass, NonTerm, StateIndex, RuleIndex>
where TermClass: Unpin, NonTerm: Unpin, StateIndex: Unpin, RuleIndex: Unpin,

§

impl<TermClass, NonTerm, StateIndex, RuleIndex> UnwindSafe for IntermediateState<TermClass, NonTerm, StateIndex, RuleIndex>
where TermClass: UnwindSafe, NonTerm: UnwindSafe, StateIndex: UnwindSafe, RuleIndex: UnwindSafe,

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.