vyre-std 0.1.0

Vyre standard library: GPU DFA assembly pipeline, Aho-Corasick construction, and compositional arithmetic helpers
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

//! vyre-std example: compile a pattern set to a GPU-ready DFA in 10 lines.
//!
//! Run with `cargo run -p vyre-std --example std_pattern_compile`.

use vyre_std::pattern::{dfa_assemble, dfa_unpack, AssembleOptions, Pattern, INVALID_STATE};

fn main() {
    let patterns = [
        Pattern::Literal(b"GET /api"),
        Pattern::Literal(b"POST /api"),
        Pattern::Regex("PUT /api/v[0-9]+"),
    ];

    let packed =
        dfa_assemble(&patterns, AssembleOptions::default()).expect("patterns compile cleanly");

    println!(
        "Compiled {} patterns into a {}-state DFA ({} bytes, format = {:?}).",
        patterns.len(),
        packed.state_count,
        packed.bytes.len(),
        packed.format,
    );

    let dfa = dfa_unpack(&packed).expect("packed bytes round-trip to Dfa");

    for (label, input) in [
        ("hit literal", &b"GET /api"[..]),
        ("hit regex v1", &b"PUT /api/v1"[..]),
        ("hit regex v42", &b"PUT /api/v42"[..]),
        ("miss", &b"DELETE /api"[..]),
    ] {
        let mut state = dfa.start;
        let mut matched = true;
        for &b in input {
            let next = dfa.go(state, b);
            if next == INVALID_STATE {
                matched = false;
                break;
            }
            state = next;
        }
        let accepted = matched && dfa.accept[state as usize];
        println!(
            "  {label:16} {accepted:>5}  (input `{:?}`)",
            String::from_utf8_lossy(input)
        );
    }
}