redb-bincode 0.4.0

`redb` + `bincode` wrapper around `redb`
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

use std::marker::PhantomData;

use redb::TableError;

use super::{ReadOnlyTable, Table};
use crate::sort;

pub struct ReadTransaction(redb::ReadTransaction);

impl From<redb::ReadTransaction> for ReadTransaction {
    fn from(value: redb::ReadTransaction) -> Self {
        Self(value)
    }
}

impl ReadTransaction {
    pub fn as_raw(&self) -> &redb::ReadTransaction {
        &self.0
    }
    pub fn open_table<K, V>(
        &self,
        table_def: &TableDefinition<'_, K, V>,
    ) -> Result<ReadOnlyTable<K, V, sort::Lexicographical>, TableError>
    where
        K: bincode::Encode + bincode::Decode<()>,
        V: bincode::Encode + bincode::Decode<()>,
    {
        Ok(ReadOnlyTable {
            inner: self
                .0
                .open_table(redb::TableDefinition::new(table_def.name))?,
            _k: PhantomData,
            _v: PhantomData,
        })
    }
}

pub struct WriteTransaction(redb::WriteTransaction);

impl From<redb::WriteTransaction> for WriteTransaction {
    fn from(value: redb::WriteTransaction) -> Self {
        Self(value)
    }
}

pub struct TableDefinition<'a, K, V> {
    name: &'a str,
    _key_type: PhantomData<K>,
    _value_type: PhantomData<V>,
}

impl<'a, K, V> TableDefinition<'a, K, V> {
    pub const fn new(name: &'a str) -> Self {
        Self {
            name,
            _key_type: PhantomData,
            _value_type: PhantomData,
        }
    }

    pub fn as_raw(&self) -> redb::TableDefinition<'_, &'static [u8], &'static [u8]> {
        redb::TableDefinition::new(self.name)
    }
}

impl WriteTransaction {
    pub fn as_raw(&self) -> &redb::WriteTransaction {
        &self.0
    }

    pub fn open_table<K, V>(
        &self,
        table_def: &TableDefinition<'_, K, V>,
    ) -> Result<Table<K, V, sort::Lexicographical>, TableError>
    where
        K: bincode::Encode + bincode::Decode<()>,
        V: bincode::Encode + bincode::Decode<()>,
    {
        Ok(Table {
            inner: self
                .0
                .open_table(redb::TableDefinition::new(table_def.name))?,
            _k: PhantomData,
            _v: PhantomData,
        })
    }

    pub fn commit(self) -> Result<(), redb::CommitError> {
        self.0.commit()
    }
}