persy 1.5.2

Transactional Persistence Engine
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

use crate::{
    id::IndexId,
    index::{
        config::IndexTypeInternal,
        tree::nodes::{PageIter, PageIterBack, Value},
    },
    persy::PersyImpl,
    snapshots::SnapshotRef,
};
use std::{
    cmp::Ordering,
    ops::{Bound, RangeBounds},
};

pub struct IndexRawIter<K, V> {
    index_id: IndexId,
    read_snapshot: SnapshotRef,
    iter: PageIter<K, V>,
    back: PageIterBack<K, V>,
    range: (Bound<K>, Bound<K>),
}

impl<K: IndexTypeInternal, V> IndexRawIter<K, V>
where
    K: IndexTypeInternal,
    V: IndexTypeInternal,
{
    pub fn new(
        index_id: IndexId,
        read_snapshot: &SnapshotRef,
        iter: PageIter<K, V>,
        back: PageIterBack<K, V>,
        range: (Bound<K>, Bound<K>),
    ) -> IndexRawIter<K, V> {
        IndexRawIter {
            index_id,
            read_snapshot: read_snapshot.clone(),
            iter,
            back,
            range,
        }
    }

    pub fn next(&mut self, persy_impl: &PersyImpl) -> Option<(K, Value<V>)> {
        if let Some(front) = self.iter.iter.peek() {
            if let Some(back) = self.back.iter.peek() {
                if front.key.cmp(&back.key) == Ordering::Greater {
                    return None;
                }
            } else {
                match self.range.end_bound() {
                    Bound::Unbounded => {}
                    Bound::Included(x) => {
                        if x.cmp(&front.key) == Ordering::Less {
                            return None;
                        }
                    }
                    Bound::Excluded(x) => {
                        if front.key.cmp(x) == Ordering::Greater {
                            return None;
                        }
                    }
                }
            }
        }
        if let Some(n) = self.iter.iter.next() {
            if self.iter.iter.peek().is_none() {
                if let Ok(iter) = persy_impl.index_next(&self.index_id, &self.read_snapshot, Bound::Excluded(&n.key)) {
                    self.iter = iter;
                }
            }

            Some((n.key, n.value))
        } else {
            None
        }
    }

    pub fn next_back(&mut self, persy_impl: &PersyImpl) -> Option<(K, Value<V>)> {
        if let Some(back) = self.back.iter.peek() {
            if let Some(front) = self.iter.iter.peek() {
                if back.key.cmp(&front.key) == Ordering::Less {
                    return None;
                }
            } else {
                match self.range.start_bound() {
                    Bound::Unbounded => {}
                    Bound::Included(x) => {
                        if x.cmp(&back.key) == Ordering::Greater {
                            return None;
                        }
                    }
                    Bound::Excluded(x) => {
                        if back.key.cmp(x) == Ordering::Less {
                            return None;
                        }
                    }
                }
            }
        }
        if let Some(n) = self.back.iter.next() {
            if self.back.iter.peek().is_none() {
                if let Ok(back) = persy_impl.index_back(&self.index_id, &self.read_snapshot, Bound::Excluded(&n.key)) {
                    self.back = back;
                }
            }
            Some((n.key, n.value))
        } else {
            None
        }
    }
}