lmdb Namespace Reference

Namespaces
namespace	stream

Classes
struct	close_env
	Closes LMDB environment handle. More...
struct	context
	Context given to LMDB. More...
class	database
	Manages a LMDB environment for safe memory-map resizing. Thread-safe. More...
class	key_iterator
class	key_stream
struct	table
	Helper for grouping typical LMDB DBI options. More...
struct	basic_table
	Helper for grouping typical LMDB DBI options when key and value are fixed types. More...
struct	abort_txn
struct	release_read_txn
struct	abort_write_txn
struct	close_cursor
struct	identity
	Prevent instantiation of std::underlying_type<T> when T is not enum. More...
class	value_iterator
class	value_stream

Typedefs
using	environment = std::unique_ptr<MDB_env, close_env>
using	suspended_txn = std::unique_ptr<MDB_txn, abort_txn>
using	read_txn = std::unique_ptr<MDB_txn, release_read_txn>
using	write_txn = std::unique_ptr<MDB_txn, abort_write_txn>
template<typename T>
using	native_type

Enumerations
enum class	error : int
	Tracks LMDB error codes. More...

Functions
expect< environment >	open_environment (const char *path, MDB_dbi max_dbs) noexcept
std::error_category const &	error_category () noexcept
std::error_code	make_error_code (error value) noexcept
template<typename K, typename V>
bool	operator== (key_iterator< K, V > const &lhs, key_iterator< K, V > const &rhs) noexcept
template<typename K, typename V>
bool	operator!= (key_iterator< K, V > const &lhs, key_iterator< K, V > const &rhs) noexcept
template<typename D>
expect< std::unique_ptr< MDB_cursor, D > >	open_cursor (MDB_txn &txn, MDB_dbi tbl) noexcept
template<typename T, typename U = typename std::underlying_type<T>::type>
constexpr U	to_native (T value) noexcept
template<typename T>
MDB_val	to_val (T &&value) noexcept
constexpr epee::span< const std::uint8_t >	to_byte_span (MDB_val value) noexcept
template<typename T, std::size_t offset = 0>
int	less (MDB_val const *left, MDB_val const *right) noexcept
template<typename T, std::size_t offset = 0>
int	compare (MDB_val const *left, MDB_val const *right) noexcept
template<typename T, typename F, std::size_t offset>
bool	operator== (value_iterator< T, F, offset > const &lhs, value_iterator< T, F, offset > const &rhs) noexcept
template<typename T, typename F, std::size_t offset>
bool	operator!= (value_iterator< T, F, offset > const &lhs, value_iterator< T, F, offset > const &rhs) noexcept

Typedef Documentation

environment

using lmdb::environment = std::unique_ptr<MDB_env, close_env>

Definition at line 51 of file database.h.

native_type

template<typename T>

using lmdb::native_type

Initial value:

typename std::conditional<
       std::is_enum<T>::value, std::underlying_type<T>, identity<T>
   >::type::type

Get the native type for enums, or return T unchanged. Useful for merging generated machine code for templated functions that use enums with identical size-widths without relying on aggressive identical comdat folding (ICF) support in linker. So with enum defintion enum class enum_foo : unsigned long {}; will always yield assert(&func_foo<unsigned long> == &func_foo<native_type<enum_foo>>).

Definition at line 75 of file util.h.

read_txn

using lmdb::read_txn = std::unique_ptr<MDB_txn, release_read_txn>

Definition at line 93 of file transaction.h.

suspended_txn

using lmdb::suspended_txn = std::unique_ptr<MDB_txn, abort_txn>

Definition at line 92 of file transaction.h.

write_txn

using lmdb::write_txn = std::unique_ptr<MDB_txn, abort_write_txn>

Definition at line 94 of file transaction.h.

Enumeration Type Documentation

error

enum class lmdb::error : int

strong

Tracks LMDB error codes.

Definition at line 44 of file error.h.

    {
        // 0 is reserved for no error, as per expect<T>
        // All other errors are the values reported by LMDB
    };

Function Documentation

compare()

template<typename T, std::size_t offset = 0>

int lmdb::compare ( MDB_val const * left, MDB_val const * right )

inlinenoexcept

A LMDB comparison function that uses std::memcmp.

\toaram T is !epee::has_padding

Template Parameters

offset

to T within the value.

Returns

The result of std::memcmp over the value.

Definition at line 135 of file util.h.

    {
        static_assert(!epee::has_padding<T>(), "memcmp will not work");
        if (!left || !right || left->mv_size < sizeof(T) + offset || right->mv_size < sizeof(T) + offset)
        {
            assert("invalid use of custom comparison" == 0);
            return -1;
        }
        return std::memcmp(
            static_cast<char*>(left->mv_data) + offset,
            static_cast<char*>(right->mv_data) + offset,
            sizeof(T)
        );
    }

Here is the call graph for this function:

Here is the caller graph for this function:

error_category()

std::error_category const & lmdb::error_category ( )

noexcept

Definition at line 92 of file error.cpp.

    {
        static const category instance{};
        return instance;
    }

Here is the caller graph for this function:

less()

template<typename T, std::size_t offset = 0>

int lmdb::less ( MDB_val const * left, MDB_val const * right )

inlinenoexcept

A LMDB comparison function that uses operator<.

Template Parameters

T	has a defined operator< .
offset	to T within the value.

Returns

-1 if left < right, 1 if right < left, and 0 otherwise.

Definition at line 111 of file util.h.

    {
        if (!left || !right || left->mv_size < sizeof(T) + offset || right->mv_size < sizeof(T) + offset)
        {
            assert("invalid use of custom comparison" == 0);
            return -1;
        }
 
        T left_val;
        T right_val;
        std::memcpy(std::addressof(left_val), static_cast<char*>(left->mv_data) + offset, sizeof(T));
        std::memcpy(std::addressof(right_val), static_cast<char*>(right->mv_data) + offset, sizeof(T));
        return left_val < right_val ? -1 : bool(right_val < left_val);
    }

Here is the caller graph for this function:

make_error_code()

std::error_code lmdb::make_error_code ( error value )

inlinenoexcept

Definition at line 52 of file error.h.

    {
        return std::error_code{int(value), error_category()};
    }

Here is the call graph for this function:

Here is the caller graph for this function:

open_cursor()

template<typename D>

expect< std::unique_ptr< MDB_cursor, D > > lmdb::open_cursor ( MDB_txn & txn, MDB_dbi tbl )

inlinenoexcept

Definition at line 83 of file transaction.h.

    {
        MDB_cursor* cur = nullptr;
        ELECTRONEUM_LMDB_CHECK(mdb_cursor_open(&txn, tbl, &cur));
        return std::unique_ptr<MDB_cursor, D>{cur};
    }

Here is the call graph for this function:

open_environment()

expect< environment > lmdb::open_environment ( const char * path, MDB_dbi max_dbs )

noexcept

Returns

LMDB environment at path with a max of max_dbs tables.

Definition at line 78 of file database.cpp.

    {
        ELECTRONEUM_PRECOND(path != nullptr);
 
        MDB_env* obj = nullptr;
        ELECTRONEUM_LMDB_CHECK(mdb_env_create(std::addressof(obj)));
        environment out{obj};
 
        ELECTRONEUM_LMDB_CHECK(mdb_env_set_maxdbs(out.get(), max_dbs));
        ELECTRONEUM_LMDB_CHECK(mdb_env_open(out.get(), path, 0, open_flags));
        return {std::move(out)};
    }

Here is the call graph for this function:

operator!=() [1/2]

template<typename K, typename V>

bool lmdb::operator!= ( key_iterator< K, V > const & lhs, key_iterator< K, V > const & rhs )

inlinenoexcept

Definition at line 259 of file key_stream.h.

    {
        return !lhs.equal(rhs);
    }

operator!=() [2/2]

template<typename T, typename F, std::size_t offset>

bool lmdb::operator!= ( value_iterator< T, F, offset > const & lhs, value_iterator< T, F, offset > const & rhs )

inlinenoexcept

Definition at line 282 of file value_stream.h.

    {
        return !lhs.equal(rhs);
    }

operator==() [1/2]

template<typename K, typename V>

bool lmdb::operator== ( key_iterator< K, V > const & lhs, key_iterator< K, V > const & rhs )

inlinenoexcept

Definition at line 252 of file key_stream.h.

    {
        return lhs.equal(rhs);
    }

operator==() [2/2]

template<typename T, typename F, std::size_t offset>

bool lmdb::operator== ( value_iterator< T, F, offset > const & lhs, value_iterator< T, F, offset > const & rhs )

inlinenoexcept

Definition at line 275 of file value_stream.h.

    {
        return lhs.equal(rhs);
    }

to_byte_span()

epee::span< const std::uint8_t > lmdb::to_byte_span ( MDB_val value )

inlineconstexprnoexcept

Returns

A span over the same chunk of memory as value.

Definition at line 97 of file util.h.

    {
        return {static_cast<const std::uint8_t*>(value.mv_data), value.mv_size};
    }

Here is the caller graph for this function:

to_native()

template<typename T, typename U = typename std::underlying_type<T>::type>

U lmdb::to_native ( T value )

inlineconstexprnoexcept

Returns

value as its native type.

Definition at line 81 of file util.h.

    {
        return U(value);
    }

Here is the caller graph for this function:

to_val()

template<typename T>

MDB_val lmdb::to_val ( T && value )

inlinenoexcept

Returns

value bytes in a LMDB MDB_val object.

Definition at line 88 of file util.h.

    {
        // lmdb does not touch user data, so const_cast is acceptable
        static_assert(!std::is_rvalue_reference<T&&>(), "cannot use temporary value");
        void const* const temp = reinterpret_cast<void const*>(std::addressof(value));
        return MDB_val{sizeof(value), const_cast<void*>(temp)};
    }

Here is the caller graph for this function: