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

use std::collections::{btree_map, BTreeMap, btree_set};

use crate::internal_structures::{ToMany, ToManyMetadata};
use crate::id::IdLike;

#[inline]
pub(crate) fn make_to_many_key_range<K: IdLike, V: IdLike>(
    vs: &ToMany<K, V>, front_cursor: Option<K>, back_cursor: Option<K>,
) -> btree_map::Range<'_, K, ToManyMetadata> {
    match (front_cursor, back_cursor) {
        (Some(f), Some(b)) => {
            let mut l = vs.key_subrange(f..=b);
            l.next();
            l.next_back();
            l
        },
        (Some(f), None) => {
            let mut l = vs.key_subrange(f..);
            l.next();
            l
        }
        (None, Some(b)) => {
            let mut l = vs.key_subrange(..=b);
            l.next_back();
            l
        }
        (None, None) => vs.key_subrange(..)
    }
}

#[inline]
pub(crate) fn make_to_many_key_value_range<K: IdLike, V: IdLike>(
    vs: &ToMany<K, V>, 
    front_cursor: Option<(K, V)>, back_cursor: Option<(K, V)>,

    // nyeo note: these are like cursors but don't need to be advanced past
    front_element: Option<(K, V)>, back_element: Option<(K, V)>,  
) -> btree_set::Range<'_, (K, V)> {
    let mut l = match (front_cursor.or(front_element), back_cursor.or(back_element) ) {
        (Some(f), Some(b)) => { vs.element_subrange(f..=b) }
        (Some(f), None) => { vs.element_subrange(f..) }
        (None, Some(b)) => { vs.element_subrange(..=b) }
        (None, None) => { vs.element_subrange(..) }
    };

    match (front_cursor, back_cursor) {
        (Some(_), Some(_)) => { l.next(); l.next_back(); },
        (Some(_), None) => { l.next(); }
        (None, Some(_)) => { l.next_back(); }
        (None, None) => {}
    };

    l
}

#[inline]
pub fn make_map_range<K: Copy+Ord, V>(
    vs: &BTreeMap<K, V>, front_cursor: Option<K>, back_cursor: Option<K>,
) -> btree_map::Range<'_, K, V> {
    match (front_cursor, back_cursor) {
        (Some(f), Some(b)) => {
            let mut l = vs.range(f..=b);
            l.next();
            l.next_back();
            l
        },
        (Some(f), None) => {
            let mut l = vs.range(f..);
            l.next();
            l
        }
        (None, Some(b)) => {
            let mut l = vs.range(..=b);
            l.next_back();
            l
        }
        (None, None) => vs.range(..)
    }
}