Struct rusty_parser::DictHashMap

pub struct DictHashMap<Output, CharType>
where
    CharType: Hash + Eq,
    Output: Clone + Tuple,
{ /* private fields */ }

Dictionary using trie, implementation uses HashMap; O(1) search.

Output: Output you inserted

Example

use rusty_parser as rp;
use rp::IntoParser;

let mut parser = rp::DictHashMap::new();

parser.insert("hello".chars(), (1,));
parser.insert("hello_world".chars(), (2,));
parser.insert("world".chars(), (3,));

// this will match as long as possible
let res = rp::parse(&parser, "hello_world_abcdefg".chars());
assert_eq!(res.output.unwrap(), (2,));
// 'hello_world' is parsed, so the rest is "_abcdefg"
assert_eq!(res.it.collect::<String>(), "_abcdefg");

// match 'hello' only
let res = rp::parse(&parser, "hello_wo".chars());
assert_eq!(res.output.unwrap(), (1,));

Implementations

impl<Output, CharType> DictHashMapParser<Output, CharType>

where CharType: Hash + Eq, Output: Clone + Tuple,

pub fn new() -> Self

pub fn insert<CharIter>( &mut self, key: CharIter, output: Output ) -> Option<Output>

where CharIter: Iterator<Item = CharType>,

Trait Implementations

impl<Output, CharType> Clone for DictHashMapParser<Output, CharType>

where CharType: Hash + Eq + Clone, Output: Clone + Tuple + Clone,

fn clone(&self) -> DictHashMapParser<Output, CharType>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Output, CharType> Debug for DictHashMapParser<Output, CharType>

where CharType: Hash + Eq + Debug, Output: Clone + Tuple + Debug,

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

Formats the value using the given formatter.

impl<Output, CharType> Default for DictHashMapParser<Output, CharType>

where CharType: Hash + Eq + Default, Output: Clone + Tuple + Default,

fn default() -> DictHashMapParser<Output, CharType>

Returns the “default value” for a type.

impl<CharType, Output> IntoParser for DictHashMapParser<Output, CharType>

where CharType: Hash + Eq, Output: Clone + Tuple,

type Into = DictHashMapParser<Output, CharType>

Target Parser type

fn into_parser(self) -> Self::Into

convert self to Parser

fn seq<RhsParser: IntoParser>( self, rhs: RhsParser ) -> SeqParser<Self::Into, RhsParser::Into>

where Self: Sized,

concatenate two parser

fn repeat<RangeTypeIncludeInteger>( self, range: RangeTypeIncludeInteger ) -> RepeatParser<Self::Into, RangeTypeIncludeInteger::Into>

where Self: Sized, RangeTypeIncludeInteger: ToCopyable, RangeTypeIncludeInteger::Into: RangeBound<usize>,

repeat parser multiple times. This tries to match as long as possible.

fn or<RhsParser: IntoParser>( self, rhs: RhsParser ) -> OrParser<Self::Into, RhsParser::Into>

where Self: Sized,

or combinator for two parsers

fn map<ClosureType, ClosureInput, ClosureOutput>( self, callback: ClosureType ) -> MapParser<Self::Into, ClosureType, ClosureInput, ClosureOutput>

where ClosureInput: Tuple, ClosureType: Fn(ClosureInput) -> ClosureOutput, ClosureOutput: Tuple, Self: Sized,

Map parser’s Output to new value

fn void(self) -> VoidParser<Self::Into>

where Self: Sized,

Change Parser’s Output to (). This internally call match_pattern() instead of parse()

fn optional(self) -> OptionalParser<Self::Into>

where Self: Sized,

This parser always success whether the input is matched or not.

fn optional_or<Output: Clone + Tuple>( self, output: Output ) -> OptionalOrParser<Self::Into, Output>

where Self: Sized,

This parser always success whether the input is matched or not.

fn refcell(self) -> RefCelledParser<Self::Into>

where Self: Sized,

create RefCell<Parser> wrapper.

fn rc(self) -> RcedParser<Self::Into>

where Self: Sized,

Create Rc<Parser> wrapper.

fn box_slice<Output, T>(self) -> DynBoxSlice<Output, T>

where Output: Tuple, T: Clone + Copy, Self: Sized, Self::Into: for<'a> Parser<Cloned<Iter<'a, T>>, Output = Output> + 'static,

create a Box<dyn Parser> wrapper for iterators of std::iter::Cloned<std::slice::Iter>.

fn not<RhsParser: IntoParser>( self, rhs: RhsParser ) -> NotParser<Self::Into, RhsParser::Into>

where Self: Sized,

Match for parser1 parser2, parser1 must success and parser2 must fail.

fn output<Output: Tuple + Clone>( self, output: Output ) -> OutputParser<Self::Into, Output>

where Self: Sized,

Change Parser’s Output to output.

fn vec<T>(self) -> VecParser<Self::Into>

where Self: Sized, Self::Into: for<'a> Parser<Cloned<Iter<'a, T>>>,

Returns Vec\<T\> of parsed input. Only works for parsing with std::iter::Cloned<std::slice::Iter>.

fn not_consume(self) -> NotConsumeParser<Self::Into>

where Self: Sized,

Parser will not consume the input iterator. It still match and return the output.

impl<Output, CharType, It> Parser<It> for DictHashMapParser<Output, CharType>

where It: InputIteratorTrait + Iterator<Item = CharType> + Clone, CharType: Hash + Eq, Output: Clone + Tuple,

type Output = Output

fn parse(&self, it: It) -> ParseResult<Self::Output, It>

fn match_pattern(&self, it: It) -> ParseResult<(), It>