froql_macro 0.1.0

proc_macro crate for froql
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
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166

use super::{
    GeneratorNode,
    relation_helper::{
        RelationHelperInfo, UnrelationHelperInfo, relation_helpers_init_and_set_col,
        relation_helpers_set_rows,
    },
    relation_join::{insert_checks, insert_optional_comps},
    types::{RelationConstraint, UnrelationConstraint},
};
use std::{fmt::Write, ops::Range};

#[derive(Debug)]
pub struct InvarInfo {
    pub var_index: isize,
    pub component_range: Range<usize>,
    /// type, index part of context variable name
    pub opt_components: Vec<(String, usize)>,
    pub relation_helpers: Vec<RelationHelperInfo>,
    pub unrelation_helpers: Vec<UnrelationHelperInfo>,
}

#[derive(Debug)]
pub struct InvarStart {
    pub unequalities: Vec<(isize, isize)>,
    pub rel_constraints: Vec<RelationConstraint>,
    pub unrel_constraints: Vec<UnrelationConstraint>,
    pub invars: Vec<InvarInfo>,
}

impl GeneratorNode for InvarStart {
    fn generate(&self, step: usize, prepend: &mut String, append: &mut String) -> usize {
        write!(
            append,
            r#"
{step} => {{
"#
        )
        .unwrap();
        self.generate_invar_archetype_fill(prepend, append);

        if self.unequalities.is_empty()
            && self.rel_constraints.is_empty()
            && self.unrel_constraints.is_empty()
        {
            append.push_str(
                "
    current_step += 2;
}",
            );
        } else {
            insert_checks(
                append,
                &self.unequalities,
                &self.rel_constraints,
                &self.unrel_constraints,
            );
            append.push_str(
                "
    {
        return None;
    } else {
        current_step += 2;
    }
}",
            );
        }
        let next_step = step + 1;
        // end state
        write!(
            append,
            r#"
{next_step} => {{
    return None;
}}
"#
        )
        .unwrap();
        return step + 2;
    }
}

impl InvarStart {
    fn generate_invar_archetype_fill(&self, prepend: &mut String, append: &mut String) {
        // another string is needed because we prepend optional components before this block
        for invar in &self.invars {
            let var_index = invar.var_index;
            let Range { start, end } = &invar.component_range;
            write!(
                append,
                "
{{
    let (aid, arow) = bk.entities.get_archetype(invar_{var_index});
    let a_ref = &mut a_refs[{var_index}];
    *a_ref = &bk.archetypes[aid.as_index()];
    if !a_ref.find_multiple_columns_fallible(&components_{var_index}, &mut col_indexes[{start}..{end}]) {{
        return None;
    }}
    a_rows[{var_index}] = arow;"
            )
            .unwrap();

            insert_optional_comps(prepend, append, &invar.opt_components);
            relation_helpers_init_and_set_col(
                prepend,
                append,
                &invar.relation_helpers,
                &invar.unrelation_helpers,
            );
            relation_helpers_set_rows(append, &invar.relation_helpers, &invar.unrelation_helpers);

            write!(
                append,
                "
}}
"
            )
            .unwrap();
        }
    }
}

#[cfg(test)]
mod test {
    use super::*;

    #[test]
    fn invar_trivial() {
        let generator = InvarStart {
            unequalities: vec![],
            rel_constraints: vec![],
            unrel_constraints: vec![],
            invars: vec![InvarInfo {
                var_index: 0,
                component_range: 0..2,
                opt_components: vec![],
                relation_helpers: vec![],
                unrelation_helpers: vec![],
            }],
        };

        let mut prepend = String::new();
        let mut append = String::new();
        let r = generator.generate(0, &mut prepend, &mut append);
        assert_eq!(2, r);
        insta::assert_snapshot!(prepend, @"");
        insta::assert_snapshot!(append, @r#"
        0 => {

        {
            let (aid, arow) = bk.entities.get_archetype(invar_0);
            let a_ref = &mut a_refs[0];
            *a_ref = &bk.archetypes[aid.as_index()];
            if !a_ref.find_multiple_columns_fallible(&components_0, &mut col_indexes[0..2]) {
                return None;
            }
            a_rows[0] = arow;
        }

            current_step += 2;
        }
        1 => {
            return None;
        }
        "#);
    }
}