wp-lang 0.1.8

WPL language crate with AST, parser, evaluator, builtins, and generators.
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
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

use wp_model_core::model::DataType;

use crate::ParserFactory;
use crate::ast::{WplRule, WplSep, WplStatementType};
use crate::generator::{FmtField, FmtFieldVec, GenChannel, NamedFieldGF};
use crate::types::AnyResult;

type FieldGenFn = Box<dyn Fn(&mut GenChannel) -> AnyResult<FmtField> + Send + Sync>;

/// A precompiled generator for a whole rule (sequence of fields).
pub struct CompiledRule {
    fields: Vec<FieldGenFn>,
}

impl CompiledRule {
    pub(crate) fn new(fields: Vec<FieldGenFn>) -> Self {
        Self { fields }
    }
    /// Generate one record (Vec of fields).
    pub fn gen_one(&self) -> AnyResult<FmtFieldVec> {
        let mut ch = GenChannel::new();
        let mut out = FmtFieldVec::new();
        for f in &self.fields {
            out.push(f(&mut ch)?);
        }
        Ok(out)
    }
    /// Generate `count` records; start index is unused but kept for API parity.
    pub fn gen_batch(&self, _idx_begin: usize, count: usize) -> AnyResult<Vec<FmtFieldVec>> {
        let mut v = Vec::with_capacity(count);
        for _ in 0..count {
            v.push(self.gen_one()?);
        }
        Ok(v)
    }
}

/// Compile a WPL rule with optional field generation configs into a precompiled generator.
pub fn compile_rule(
    rule: &WplRule,
    fields: &NamedFieldGF,
) -> crate::parser::error::WplCodeResult<CompiledRule> {
    match &rule.statement {
        WplStatementType::Express(expr) => {
            let mut items: Vec<FieldGenFn> = Vec::new();
            let ups_sep = WplSep::default();
            for group in &expr.group {
                let sep = group.resolve_sep(&ups_sep);
                for f_conf in &group.fields {
                    let gconf = f_conf
                        .name
                        .as_ref()
                        .and_then(|n| fields.get(n.as_str()))
                        .cloned();
                    let f_conf_cloned = f_conf.clone();
                    let sep_cloned = sep.clone();
                    let field_fn: FieldGenFn = Box::new(move |ch: &mut GenChannel| {
                        let meta = DataType::from(f_conf_cloned.meta_name.as_str())?;
                        let parser = ParserFactory::create(&meta)?;
                        let f = parser.generate(ch, &sep_cloned, &f_conf_cloned, gconf.as_ref())?;
                        Ok(f)
                    });
                    items.push(field_fn);
                }
            }
            Ok(CompiledRule::new(items))
        }
    }
}