elyze 1.5.5

Elyze is an extensible general purpose framework parser allowing to parser any type of data without allocation.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

use elyze::errors::ParseResult;
use elyze::matcher::Match;
use elyze::recognizer::Recognizer;
use elyze::scanner::Scanner;

#[derive(Debug)]
enum Operator {
    Add,
    Sub,
}

fn match_char(c: char, data: &[u8]) -> (bool, usize) {
    match data.first() {
        Some(&d) => (d == c as u8, 1),
        None => (false, 0),
    }
}

impl Match<u8> for Operator {
    fn is_matching(&self, data: &[u8]) -> (bool, usize) {
        match self {
            Operator::Add => match_char('+', data),
            Operator::Sub => match_char('-', data),
        }
    }

    fn size(&self) -> usize {
        match self {
            Operator::Add => 1,
            Operator::Sub => 1,
        }
    }
}

fn main() -> ParseResult<()> {
    let data = b"+";
    let mut scanner = Scanner::new(data);
    // Initialize the recognizer
    let recognizer = Recognizer::new(&mut scanner);
    // Try to apply the recognizer on the operator add, if it fails, return an error
    let recognizer_add = recognizer.try_or(Operator::Add)?;
    // Try to apply the recognizer on the operator sub, if it fails, return an error
    let recognizer_add_and_sub = recognizer_add.try_or(Operator::Sub)?;
    // Finish the recognizer
    let result = recognizer_add_and_sub.finish();
    dbg!(result);

    Ok(())
}