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
113
114
115
116
117
118
119
120
|
#pragma once
#include <utility>
#include "common/expect.h"
#include "lmdb/error.h"
#include "lmdb/key_stream.h"
#include "lmdb/util.h"
#include "lmdb/value_stream.h"
namespace lmdb
{
//! Helper for grouping typical LMDB DBI options.
struct table
{
char const* const name;
const unsigned flags;
MDB_cmp_func* const key_cmp;
MDB_cmp_func* const value_cmp;
//! \pre `name != nullptr` \return Open table.
expect<MDB_dbi> open(MDB_txn& write_txn) const noexcept;
};
//! Helper for grouping typical LMDB DBI options when key and value are fixed types.
template<typename K, typename V>
struct basic_table : table
{
using key_type = K;
using value_type = V;
//! \return Additional LMDB flags based on `flags` value.
static constexpr unsigned compute_flags(const unsigned flags) noexcept
{
return flags | ((flags & MDB_DUPSORT) ? MDB_DUPFIXED : 0);
}
constexpr explicit basic_table(const char* name, unsigned flags = 0, MDB_cmp_func value_cmp = nullptr) noexcept
: table{name, compute_flags(flags), &lmdb::less<lmdb::native_type<K>>, value_cmp}
{}
/*!
\tparam U must be same as `V`; used for sanity checking.
\tparam F is the type within `U` that is being extracted.
\tparam offset to `F` within `U`.
\note If using `F` and `offset` to retrieve a specific field, use
`MONERO_FIELD` macro in `src/lmdb/util.h` which calculates the
offset automatically.
\return Value of type `F` at `offset` within `value` which has
type `U`.
*/
template<typename U, typename F = U, std::size_t offset = 0>
static expect<F> get_value(MDB_val value) noexcept
{
static_assert(std::is_same<U, V>(), "bad MONERO_FIELD?");
static_assert(std::is_pod<F>(), "F must be POD");
static_assert(sizeof(F) + offset <= sizeof(U), "bad field type and/or offset");
if (value.mv_size != sizeof(U))
return {lmdb::error(MDB_BAD_VALSIZE)};
F out;
std::memcpy(std::addressof(out), static_cast<char*>(value.mv_data) + offset, sizeof(out));
return out;
}
/*!
\pre `cur != nullptr`.
\param cur Active cursor on table. Returned in object on success,
otherwise destroyed.
\return A handle to the first key/value in the table linked
to `cur` or an empty `key_stream`.
*/
template<typename D>
expect<key_stream<K, V, D>>
static get_key_stream(std::unique_ptr<MDB_cursor, D> cur) noexcept
{
MONERO_PRECOND(cur != nullptr);
MDB_val key;
MDB_val value;
const int err = mdb_cursor_get(cur.get(), &key, &value, MDB_FIRST);
if (err)
{
if (err != MDB_NOTFOUND)
return {lmdb::error(err)};
cur.reset(); // return empty set
}
return key_stream<K, V, D>{std::move(cur)};
}
/*!
\pre `cur != nullptr`.
\param cur Active cursor on table. Returned in object on success,
otherwise destroyed.
\return A handle to the first value at `key` in the table linked
to `cur` or an empty `value_stream`.
*/
template<typename D>
expect<value_stream<V, D>>
static get_value_stream(K const& key, std::unique_ptr<MDB_cursor, D> cur) noexcept
{
MONERO_PRECOND(cur != nullptr);
MDB_val key_bytes = lmdb::to_val(key);
MDB_val value;
const int err = mdb_cursor_get(cur.get(), &key_bytes, &value, MDB_SET);
if (err)
{
if (err != MDB_NOTFOUND)
return {lmdb::error(err)};
cur.reset(); // return empty set
}
return value_stream<V, D>{std::move(cur)};
}
};
} // lmdb
|
