logos-derive 0.9.7

Create ridiculously fast Lexers
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 std::rc::Rc;

use crate::tree::{Node, Branch};

#[derive(Debug, Clone)]
pub enum Handler<'a> {
    Eof,
    Error,
    Whitespace,
    Tree(Rc<Node<'a>>),
}

#[derive(Debug)]
pub struct Handlers<'a> {
    handlers: Vec<Handler<'a>>,
}

impl<'a> Handlers<'a> {
    pub fn new() -> Self {
        let mut handlers = vec![Handler::Error; 256];

        handlers[0] = Handler::Eof;
        handlers[1..33].iter_mut().for_each(|slot| *slot = Handler::Whitespace);

        Handlers {
            handlers
        }
    }

    pub fn insert(&mut self, mut branch: Branch<'a>) {
        let bytes = branch.regex
                          .unshift()
                          .expect("Cannot assign tokens to empty patterns")
                          .to_bytes();

        let node = Rc::new(Node::from(branch));

        for byte in bytes {
            match self.handlers[byte as usize] {
                Handler::Tree(ref mut root) => Rc::make_mut(root).insert((*node).clone()),
                ref mut slot => *slot = Handler::Tree(node.clone()),
            }
        }
    }

    pub fn into_iter(self) -> impl Iterator<Item = Handler<'a>> {
        self.handlers.into_iter()
    }
}