moogle 0.4.4

data structures for relational code
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

// NOTE: These test modules are written in a way that's intended to make use of rustc
// Specifically, if you see "unused import", you can probably bet that the property listed here
// is not provided (or at least not tested for)
// This lets you spot-check what each bimap has
mod fixture;
mod properties;
use crate::Pom as T;
use crate::Id;

use fixture::*;

use std::collections::VecDeque;

impl crate::Pom<String> {
    fn prepare(fun: &Routine) -> Self {
        let mut pom = Self::new();
        let mut ids = VecDeque::new();
        for phase in &fun.phases {
            pom.prepare_phase(phase, &mut ids);
        }
        pom
    }

    fn prepare_phase(&mut self, phase: &Phase, ids: &mut VecDeque<Id<String>>) {
        self.prepare_unshared(&phase.0, ids);
        self.prepare_shared(&phase.1, ids);
    }

    fn prepare_unshared(&mut self, ops: &[UnsharedOp], ids: &mut VecDeque<Id<String>>) {
        for op in ops {
            match op {
                UnsharedOp::Insert(s) => { ids.push_back(self.insert(s.clone())); }
                UnsharedOp::Remove => {
                    let id = ids.pop_front();
                    match id {
                        None => {}
                        Some(x) => { self.remove(x); }
                    }
                }
                UnsharedOp::Append(c) => {
                    let id = ids.pop_front();
                    match id {
                        None => {}
                        Some(x) => { 
                            (*self.get_mut(x).unwrap()).push_str(&c);
                            ids.push_back(x)
                        }
                    }
                }
                UnsharedOp::Shuffle(n) => {
                    if !ids.is_empty() {
                        for _ in 0..*n {
                            let x = ids.pop_front().unwrap();
                            ids.push_back(x)
                        }
                    }
                }
            }
        }
    }

    fn prepare_shared(&mut self, ops: &[SharedOp], ids: &mut VecDeque<Id<String>>) {
        let (index, mut elements) = self.share();
        let mut iterator = index.keys();

        // TODO: Crash if index's ids != ids
        for op in ops {
            match op {
                SharedOp::Append(c) => {
                    let id = ids.pop_front();
                    match id {
                        None => {}
                        Some(x) => {
                            (*elements.get_mut(x).unwrap()).push_str(&c);
                            ids.push_back(x);
                        }
                    }
                }
                SharedOp::Shuffle(n) => {
                    if !ids.is_empty() {
                        for _ in 0..*n {
                            let x = ids.pop_front().unwrap();
                            ids.push_back(x)
                        }
                    }
                }
                SharedOp::IterateKeys => {
                    let mut sorted_known_ids: Vec<Id<String>> = ids.iter().cloned().collect();
                    sorted_known_ids.sort();
                    // assert index agrees on ids we have
                    let index_ids: Vec<Id<String>> = iterator.collect();
                    assert_eq!(index_ids, sorted_known_ids);

                    let elements_ids: Vec<Id<String>> = elements.keys().collect();
                    assert_eq!(index_ids, elements_ids);
                    
                    // build a new iterator
                    iterator = index.keys();
                }
            }
        }
    }
}

#[quickcheck]
fn test_dont_panic(f: Routine) -> bool {
    let _= T::prepare(&f);
    true
}