persy 1.3.0

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

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

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

impl SegmentRawIter {
    pub fn new(segment_id: SegmentId, iterator: SegmentPageIterator, snapshot_id: SnapshotId) -> SegmentRawIter {
        SegmentRawIter {
            segment_id,
            iterator,
            snapshot_id,
        }
    }
    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 fn release(&self, persy_impl: &PersyImpl) -> PERes<()> {
        persy_impl.release_snapshot(self.snapshot_id)?;
        Ok(())
    }
}

pub struct SegmentSnapshotRawIter {
    segment_id: SegmentId,
    iterator: SegmentPageIterator,
    snapshot_id: SnapshotId,
}

impl SegmentSnapshotRawIter {
    pub fn new(
        segment_id: SegmentId,
        iterator: SegmentPageIterator,
        snapshot_id: SnapshotId,
    ) -> SegmentSnapshotRawIter {
        SegmentSnapshotRawIter {
            segment_id,
            iterator,
            snapshot_id,
        }
    }
    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_id) {
                return Some((PersyId(id), val));
            }
        }
        None
    }
}

pub struct TxSegmentRawIter {
    segment_id: SegmentId,
    tx_iterator: TransactionInsertIterator,
    iterator: SegmentPageIterator,
    snapshot_id: SnapshotId,
}

impl TxSegmentRawIter {
    pub fn new(
        tx: &TransactionImpl,
        segment_id: SegmentId,
        iterator: SegmentPageIterator,
        snapshot_id: SnapshotId,
    ) -> TxSegmentRawIter {
        let iter = tx.scan_insert(segment_id).into_iter();
        TxSegmentRawIter {
            segment_id,
            tx_iterator: iter,
            iterator,
            snapshot_id,
        }
    }
    pub fn next(&mut self, persy_impl: &PersyImpl, tx: &TransactionImpl) -> Option<(PersyId, Vec<u8>, u16)> {
        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
    }
    pub fn release(&self, persy_impl: &PersyImpl) -> PERes<()> {
        persy_impl.release_snapshot(self.snapshot_id)?;
        Ok(())
    }
}