nimiq-database 1.5.0

A LMDB database wrapper with support for volatile storage
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

use std::ops::Deref;

use super::MdbxReadTransaction;
use crate::{
    mdbx::CursorProxy,
    traits::{DupTable, ReadTransaction, RegularTable, Table},
};

/// A proxy object that can be either a read or a write transaction.
/// This can be used to hide the transaction kind generic.
pub enum TransactionProxy<'db, 'txn>
where
    'db: 'txn,
{
    Read(&'txn MdbxReadTransaction<'db>),
    OwnedRead(MdbxReadTransaction<'db>),
}

impl<'db, 'inner> ReadTransaction<'db> for TransactionProxy<'db, 'inner>
where
    'db: 'inner,
{
    type Cursor<'txn, T: Table>
        = CursorProxy<'txn, T>
    where
        'inner: 'txn;

    type DupCursor<'txn, T: DupTable>
        = CursorProxy<'txn, T>
    where
        'inner: 'txn;

    fn get<T: Table>(&self, table: &T, key: &T::Key) -> Option<T::Value> {
        match self {
            TransactionProxy::Read(txn) => txn.get(table, key),
            TransactionProxy::OwnedRead(txn) => txn.get(table, key),
        }
    }

    fn cursor<'txn, T: RegularTable>(&'txn self, table: &T) -> Self::Cursor<'txn, T> {
        match self {
            TransactionProxy::Read(txn) => txn.cursor(table),
            TransactionProxy::OwnedRead(txn) => txn.cursor(table),
        }
    }

    fn dup_cursor<'txn, T: DupTable>(&'txn self, table: &T) -> Self::DupCursor<'txn, T> {
        match self {
            TransactionProxy::Read(txn) => txn.dup_cursor(table),
            TransactionProxy::OwnedRead(txn) => txn.dup_cursor(table),
        }
    }
}

impl<'db, 'inner> Deref for TransactionProxy<'db, 'inner>
where
    'db: 'inner,
{
    type Target = MdbxReadTransaction<'db>;

    fn deref(&self) -> &Self::Target {
        match self {
            TransactionProxy::Read(txn) => txn,
            TransactionProxy::OwnedRead(txn) => txn,
        }
    }
}

impl<'db, 'inner> AsRef<MdbxReadTransaction<'db>> for TransactionProxy<'db, 'inner>
where
    'db: 'inner,
{
    fn as_ref(&self) -> &MdbxReadTransaction<'db> {
        match self {
            TransactionProxy::Read(txn) => txn,
            TransactionProxy::OwnedRead(txn) => txn,
        }
    }
}