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

use crate::{
    address::segment::segment_page_iterator::SegmentPageIterator,
    id::SegmentId,
    persy::PersyImpl,
    snapshots::SnapshotRef,
    transaction::{iter::TransactionInsertIterator, tx_impl::TransactionImpl},
    PersyId,
};

pub struct SegmentRawIter {
    segment_id: SegmentId,
    iterator: SegmentPageIterator,
}

impl SegmentRawIter {
    pub fn new(segment_id: SegmentId, iterator: SegmentPageIterator) -> SegmentRawIter {
        SegmentRawIter { segment_id, iterator }
    }
    pub fn next(&mut self, persy_impl: &PersyImpl) -> Option<(PersyId, Vec<u8>)> {
        while let Some(id) = self.iterator.next(persy_impl.address()) {
            if let Ok(Some(val)) = persy_impl.read(self.segment_id, &id) {
                return Some((PersyId(id), val));
            }
        }
        None
    }
}

pub struct SegmentSnapshotRawIter {
    segment_id: SegmentId,
    iterator: SegmentPageIterator,
    snapshot_ref: SnapshotRef,
}

impl SegmentSnapshotRawIter {
    pub fn new(
        segment_id: SegmentId,
        iterator: SegmentPageIterator,
        snapshot_ref: &SnapshotRef,
    ) -> SegmentSnapshotRawIter {
        SegmentSnapshotRawIter {
            segment_id,
            iterator,
            snapshot_ref: snapshot_ref.clone(),
        }
    }
    pub fn next(&mut self, persy_impl: &PersyImpl) -> Option<(PersyId, Vec<u8>)> {
        while let Some(id) = self.iterator.next(persy_impl.address()) {
            if let Ok(Some(val)) = persy_impl.read_snap(self.segment_id, &id, &self.snapshot_ref) {
                return Some((PersyId(id), val));
            }
        }
        None
    }
}

pub struct TxSegmentRawIter {
    segment_id: SegmentId,
    tx_iterator: TransactionInsertIterator,
    iterator: SegmentPageIterator,
    snapshot_ref: SnapshotRef,
}

impl TxSegmentRawIter {
    pub fn new(
        tx: &TransactionImpl,
        segment_id: SegmentId,
        iterator: SegmentPageIterator,
        snapshot_ref: SnapshotRef,
    ) -> TxSegmentRawIter {
        let iter = tx.scan_insert(segment_id).into_iter();
        TxSegmentRawIter {
            segment_id,
            tx_iterator: iter,
            iterator,
            snapshot_ref,
        }
    }
    pub fn next(&mut self, persy_impl: &PersyImpl, tx: &TransactionImpl) -> Option<(PersyId, Vec<u8>, u16)> {
        let _one = &self.snapshot_ref;
        while let Some(id) = self
            .iterator
            .next(persy_impl.address())
            .or_else(|| self.tx_iterator.next())
        {
            if let Ok(Some((val, version))) = persy_impl.read_tx_internal(tx, self.segment_id, &id) {
                return Some((PersyId(id), val, version));
            }
        }
        None
    }
}