/workdir/bitcoin/src/dbwrapper.h

Source (jump to first uncovered line)
// Copyright (c) 2012-2022 The Bitcoin Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.

#ifndef BITCOIN_DBWRAPPER_H
#define BITCOIN_DBWRAPPER_H

#include <attributes.h>
#include <serialize.h>
#include <span.h>
#include <streams.h>
#include <util/check.h>
#include <util/fs.h>

#include <cstddef>
#include <exception>
#include <memory>
#include <optional>
#include <stdexcept>
#include <string>
#include <vector>

static const size_t DBWRAPPER_PREALLOC_KEY_SIZE = 64;
static const size_t DBWRAPPER_PREALLOC_VALUE_SIZE = 1024;

//! User-controlled performance and debug options.
struct DBOptions {
    //! Compact database on startup.
    bool force_compact = false;
};

//! Application-specific storage settings.
struct DBParams {
    //! Location in the filesystem where leveldb data will be stored.
    fs::path path;
    //! Configures various leveldb cache settings.
    size_t cache_bytes;
    //! If true, use leveldb's memory environment.
    bool memory_only = false;
    //! If true, remove all existing data.
    bool wipe_data = false;
    //! If true, store data obfuscated via simple XOR. If false, XOR with a
    //! zero'd byte array.
    bool obfuscate = false;
    //! Passed-through options.
    DBOptions options{};
};

class dbwrapper_error : public std::runtime_error
{
public:
    explicit dbwrapper_error(const std::string& msg) : std::runtime_error(msg) {}
};

class CDBWrapper;

/** These should be considered an implementation detail of the specific database.
 */
namespace dbwrapper_private {

/** Work around circular dependency, as well as for testing in dbwrapper_tests.
 * Database obfuscation should be considered an implementation detail of the
 * specific database.
 */
const std::vector<unsigned char>& GetObfuscateKey(const CDBWrapper &w);

}; // namespace dbwrapper_private

bool DestroyDB(const std::string& path_str);

/** Batch of changes queued to be written to a CDBWrapper */
class CDBBatch
{
    friend class CDBWrapper;

private:
    const CDBWrapper &parent;

    struct WriteBatchImpl;
    const std::unique_ptr<WriteBatchImpl> m_impl_batch;

    DataStream ssKey{};
    DataStream ssValue{};

    size_t size_estimate{0};

    void WriteImpl(Span<const std::byte> key, DataStream& ssValue);
    void EraseImpl(Span<const std::byte> key);

public:
    /**
     * @param[in] _parent   CDBWrapper that this batch is to be submitted to
     */
    explicit CDBBatch(const CDBWrapper& _parent);
    ~CDBBatch();
    void Clear();

    template <typename K, typename V>
    void Write(const K& key, const V& value)
    {
        ssKey.reserve(DBWRAPPER_PREALLOC_KEY_SIZE);
        ssValue.reserve(DBWRAPPER_PREALLOC_VALUE_SIZE);
        ssKey << key;
        ssValue << value;
        WriteImpl(ssKey, ssValue);
        ssKey.clear();
        ssValue.clear();
    }

    template <typename K>
    void Erase(const K& key)
    {
        ssKey.reserve(DBWRAPPER_PREALLOC_KEY_SIZE);
        ssKey << key;
        EraseImpl(ssKey);
        ssKey.clear();
    }

    size_t SizeEstimate() const { return size_estimate; }
};

class CDBIterator
{
public:
    struct IteratorImpl;

private:
    const CDBWrapper &parent;
    const std::unique_ptr<IteratorImpl> m_impl_iter;

    void SeekImpl(Span<const std::byte> key);
    Span<const std::byte> GetKeyImpl() const;
    Span<const std::byte> GetValueImpl() const;

public:

    /**
     * @param[in] _parent          Parent CDBWrapper instance.
     * @param[in] _piter           The original leveldb iterator.
     */
    CDBIterator(const CDBWrapper& _parent, std::unique_ptr<IteratorImpl> _piter);
    ~CDBIterator();

    bool Valid() const;

    void SeekToFirst();

    template<typename K> void Seek(const K& key) {
        DataStream ssKey{};
        ssKey.reserve(DBWRAPPER_PREALLOC_KEY_SIZE);
        ssKey << key;
        SeekImpl(ssKey);
    }

    void Next();

    template<typename K> bool GetKey(K& key) {
        try {
            DataStream ssKey{GetKeyImpl()};
            ssKey >> key;
        } catch (const std::exception&) {
            return false;
        }
        return true;
    }

    template<typename V> bool GetValue(V& value) {
        try {
            DataStream ssValue{GetValueImpl()};
            ssValue.Xor(dbwrapper_private::GetObfuscateKey(parent));
            ssValue >> value;
        } catch (const std::exception&) {
            return false;
        }
        return true;
    }
};

struct LevelDBContext;

class CDBWrapper
{
    friend const std::vector<unsigned char>& dbwrapper_private::GetObfuscateKey(const CDBWrapper &w);
private:
    //! holds all leveldb-specific fields of this class
    std::unique_ptr<LevelDBContext> m_db_context;

    //! the name of this database
    std::string m_name;

    //! a key used for optional XOR-obfuscation of the database
    std::vector<unsigned char> obfuscate_key;

    //! the key under which the obfuscation key is stored
    static const std::string OBFUSCATE_KEY_KEY;

    //! the length of the obfuscate key in number of bytes
    static const unsigned int OBFUSCATE_KEY_NUM_BYTES;

    std::vector<unsigned char> CreateObfuscateKey() const;

    //! path to filesystem storage
    const fs::path m_path;

    //! whether or not the database resides in memory
    bool m_is_memory;

    std::optional<std::string> ReadImpl(Span<const std::byte> key) const;
    bool ExistsImpl(Span<const std::byte> key) const;
    size_t EstimateSizeImpl(Span<const std::byte> key1, Span<const std::byte> key2) const;
    auto& DBContext() const LIFETIMEBOUND { return *Assert(m_db_context); }

public:
    CDBWrapper(const DBParams& params);
    ~CDBWrapper();

    CDBWrapper(const CDBWrapper&) = delete;
    CDBWrapper& operator=(const CDBWrapper&) = delete;

    template <typename K, typename V>
    bool Read(const K& key, V& value) const
    {
        DataStream ssKey{};
        ssKey.reserve(DBWRAPPER_PREALLOC_KEY_SIZE);
        ssKey << key;
        std::optional<std::string> strValue{ReadImpl(ssKey)};
        if (!strValue) {
            return false;
        }
        try {
            DataStream ssValue{MakeByteSpan(*strValue)};
            ssValue.Xor(obfuscate_key);
            ssValue >> value;
        } catch (const std::exception&) {
            return false;
        }
        return true;
    }

    template <typename K, typename V>
    bool Write(const K& key, const V& value, bool fSync = false)
    {
        CDBBatch batch(*this);
        batch.Write(key, value);
        return WriteBatch(batch, fSync);
    }

    //! @returns filesystem path to the on-disk data.
    std::optional<fs::path> StoragePath() {
        if (m_is_memory) {
            return {};
        }
        return m_path;
    }

    template <typename K>
    bool Exists(const K& key) const
    {
        DataStream ssKey{};
        ssKey.reserve(DBWRAPPER_PREALLOC_KEY_SIZE);
        ssKey << key;
        return ExistsImpl(ssKey);
    }

    template <typename K>
    bool Erase(const K& key, bool fSync = false)
    {
        CDBBatch batch(*this);
        batch.Erase(key);
        return WriteBatch(batch, fSync);
    }

    bool WriteBatch(CDBBatch& batch, bool fSync = false);

    // Get an estimate of LevelDB memory usage (in bytes).
    size_t DynamicMemoryUsage() const;

    CDBIterator* NewIterator();

    /**
     * Return true if the database managed by this class contains no entries.
     */
    bool IsEmpty();

    template<typename K>
    size_t EstimateSize(const K& key_begin, const K& key_end) const
    {
        DataStream ssKey1{}, ssKey2{};
        ssKey1.reserve(DBWRAPPER_PREALLOC_KEY_SIZE);
        ssKey2.reserve(DBWRAPPER_PREALLOC_KEY_SIZE);
        ssKey1 << key_begin;
        ssKey2 << key_end;
        return EstimateSizeImpl(ssKey1, ssKey2);
    }
};

#endif // BITCOIN_DBWRAPPER_H

Coverage Report

Created: 2024-08-21 05:08

Line	Count	Source (jump to first uncovered line)
1		// Copyright (c) 2012-2022 The Bitcoin Core developers
2		// Distributed under the MIT software license, see the accompanying
3		// file COPYING or http://www.opensource.org/licenses/mit-license.php.
4
5		#ifndef BITCOIN_DBWRAPPER_H
6		#define BITCOIN_DBWRAPPER_H
7
8		#include <attributes.h>
9		#include <serialize.h>
10		#include <span.h>
11		#include <streams.h>
12		#include <util/check.h>
13		#include <util/fs.h>
14
15		#include <cstddef>
16		#include <exception>
17		#include <memory>
18		#include <optional>
19		#include <stdexcept>
20		#include <string>
21		#include <vector>
22
23		static const size_t DBWRAPPER_PREALLOC_KEY_SIZE = 64;
24		static const size_t DBWRAPPER_PREALLOC_VALUE_SIZE = 1024;
25
26		//! User-controlled performance and debug options.
27		struct DBOptions {
28		//! Compact database on startup.
29		bool force_compact = false;
30		};
31
32		//! Application-specific storage settings.
33		struct DBParams {
34		//! Location in the filesystem where leveldb data will be stored.
35		fs::path path;
36		//! Configures various leveldb cache settings.
37		size_t cache_bytes;
38		//! If true, use leveldb's memory environment.
39		bool memory_only = false;
40		//! If true, remove all existing data.
41		bool wipe_data = false;
42		//! If true, store data obfuscated via simple XOR. If false, XOR with a
43		//! zero'd byte array.
44		bool obfuscate = false;
45		//! Passed-through options.
46		DBOptions options{};
47		};
48
49		class dbwrapper_error : public std::runtime_error
50		{
51		public:
52	0	explicit dbwrapper_error(const std::string& msg) : std::runtime_error(msg) {}
53		};
54
55		class CDBWrapper;
56
57		/** These should be considered an implementation detail of the specific database.
58		*/
59		namespace dbwrapper_private {
60
61		/** Work around circular dependency, as well as for testing in dbwrapper_tests.
62		* Database obfuscation should be considered an implementation detail of the
63		* specific database.
64		*/
65		const std::vector<unsigned char>& GetObfuscateKey(const CDBWrapper &w);
66
67		}; // namespace dbwrapper_private
68
69		bool DestroyDB(const std::string& path_str);
70
71		/** Batch of changes queued to be written to a CDBWrapper */
72		class CDBBatch
73		{
74		friend class CDBWrapper;
75
76		private:
77		const CDBWrapper &parent;
78
79		struct WriteBatchImpl;
80		const std::unique_ptr<WriteBatchImpl> m_impl_batch;
81
82		DataStream ssKey{};
83		DataStream ssValue{};
84
85		size_t size_estimate{0};
86
87		void WriteImpl(Span<const std::byte> key, DataStream& ssValue);
88		void EraseImpl(Span<const std::byte> key);
89
90		public:
91		/**
92		* @param[in] _parent CDBWrapper that this batch is to be submitted to
93		*/
94		explicit CDBBatch(const CDBWrapper& _parent);
95		~CDBBatch();
96		void Clear();
97
98		template <typename K, typename V>
99		void Write(const K& key, const V& value)
100	0	{
101	0	ssKey.reserve(DBWRAPPER_PREALLOC_KEY_SIZE);
102	0	ssValue.reserve(DBWRAPPER_PREALLOC_VALUE_SIZE);
103	0	ssKey << key;
104	0	ssValue << value;
105	0	WriteImpl(ssKey, ssValue);
106	0	ssKey.clear();
107	0	ssValue.clear();
108	0	} Unexecuted instantiation: void CDBBatch::Write<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<unsigned char, std::allocator<unsigned char> > >(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, std::vector<unsigned char, std::allocator<unsigned char> > const&) Unexecuted instantiation: void CDBBatch::Write<unsigned char, CBlockLocator>(unsigned char const&, CBlockLocator const&) Unexecuted instantiation: void CDBBatch::Write<std::pair<unsigned char, uint256>, CDiskTxPos>(std::pair<unsigned char, uint256> const&, CDiskTxPos const&) Unexecuted instantiation: coinstatsindex.cpp:void CDBBatch::Write<(anonymous namespace)::DBHashKey, (anonymous namespace)::DBVal>((anonymous namespace)::DBHashKey const&, (anonymous namespace)::DBVal const&) Unexecuted instantiation: coinstatsindex.cpp:void CDBBatch::Write<(anonymous namespace)::DBHeightKey, std::pair<uint256, (anonymous namespace)::DBVal> >((anonymous namespace)::DBHeightKey const&, std::pair<uint256, (anonymous namespace)::DBVal> const&) Unexecuted instantiation: void CDBBatch::Write<unsigned char, MuHash3072>(unsigned char const&, MuHash3072 const&) Unexecuted instantiation: blockfilterindex.cpp:void CDBBatch::Write<(anonymous namespace)::DBHashKey, (anonymous namespace)::DBVal>((anonymous namespace)::DBHashKey const&, (anonymous namespace)::DBVal const&) Unexecuted instantiation: void CDBBatch::Write<unsigned char, FlatFilePos>(unsigned char const&, FlatFilePos const&) Unexecuted instantiation: blockfilterindex.cpp:void CDBBatch::Write<(anonymous namespace)::DBHeightKey, std::pair<uint256, (anonymous namespace)::DBVal> >((anonymous namespace)::DBHeightKey const&, std::pair<uint256, (anonymous namespace)::DBVal> const&) Unexecuted instantiation: void CDBBatch::Write<unsigned char, unsigned char>(unsigned char const&, unsigned char const&) Unexecuted instantiation: void CDBBatch::Write<std::pair<unsigned char, int>, CBlockFileInfo>(std::pair<unsigned char, int> const&, CBlockFileInfo const&) Unexecuted instantiation: void CDBBatch::Write<unsigned char, int>(unsigned char const&, int const&) Unexecuted instantiation: void CDBBatch::Write<std::pair<unsigned char, uint256>, CDiskBlockIndex>(std::pair<unsigned char, uint256> const&, CDiskBlockIndex const&) Unexecuted instantiation: void CDBBatch::Write<std::pair<unsigned char, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >, unsigned char>(std::pair<unsigned char, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > const&, unsigned char const&) Unexecuted instantiation: void CDBBatch::Write<unsigned char, std::vector<uint256, std::allocator<uint256> > >(unsigned char const&, std::vector<uint256, std::allocator<uint256> > const&) Unexecuted instantiation: txdb.cpp:void CDBBatch::Write<(anonymous namespace)::CoinEntry, Coin>((anonymous namespace)::CoinEntry const&, Coin const&) Unexecuted instantiation: void CDBBatch::Write<unsigned char, uint256>(unsigned char const&, uint256 const&)
109
110		template <typename K>
111		void Erase(const K& key)
112	0	{
113	0	ssKey.reserve(DBWRAPPER_PREALLOC_KEY_SIZE);
114	0	ssKey << key;
115	0	EraseImpl(ssKey);
116	0	ssKey.clear();
117	0	} Unexecuted instantiation: void CDBBatch::Erase<unsigned char>(unsigned char const&) Unexecuted instantiation: txdb.cpp:void CDBBatch::Erase<(anonymous namespace)::CoinEntry>((anonymous namespace)::CoinEntry const&)
118
119	0	size_t SizeEstimate() const { return size_estimate; }
120		};
121
122		class CDBIterator
123		{
124		public:
125		struct IteratorImpl;
126
127		private:
128		const CDBWrapper &parent;
129		const std::unique_ptr<IteratorImpl> m_impl_iter;
130
131		void SeekImpl(Span<const std::byte> key);
132		Span<const std::byte> GetKeyImpl() const;
133		Span<const std::byte> GetValueImpl() const;
134
135		public:
136
137		/**
138		* @param[in] _parent Parent CDBWrapper instance.
139		* @param[in] _piter The original leveldb iterator.
140		*/
141		CDBIterator(const CDBWrapper& _parent, std::unique_ptr<IteratorImpl> _piter);
142		~CDBIterator();
143
144		bool Valid() const;
145
146		void SeekToFirst();
147
148	0	template<typename K> void Seek(const K& key) {
149	0	DataStream ssKey{};
150	0	ssKey.reserve(DBWRAPPER_PREALLOC_KEY_SIZE);
151	0	ssKey << key;
152	0	SeekImpl(ssKey);
153	0	} Unexecuted instantiation: coinstatsindex.cpp:void CDBIterator::Seek<(anonymous namespace)::DBHeightKey>((anonymous namespace)::DBHeightKey const&) Unexecuted instantiation: blockfilterindex.cpp:void CDBIterator::Seek<(anonymous namespace)::DBHeightKey>((anonymous namespace)::DBHeightKey const&) Unexecuted instantiation: void CDBIterator::Seek<std::pair<unsigned char, uint256> >(std::pair<unsigned char, uint256> const&) Unexecuted instantiation: void CDBIterator::Seek<unsigned char>(unsigned char const&)
154
155		void Next();
156
157	0	template<typename K> bool GetKey(K& key) {
158	0	try {
159	0	DataStream ssKey{GetKeyImpl()};
160	0	ssKey >> key;
161	0	} catch (const std::exception&) {
162	0	return false;
163	0	}
164	0	return true;
165	0	} Unexecuted instantiation: coinstatsindex.cpp:bool CDBIterator::GetKey<(anonymous namespace)::DBHeightKey>((anonymous namespace)::DBHeightKey&) Unexecuted instantiation: blockfilterindex.cpp:bool CDBIterator::GetKey<(anonymous namespace)::DBHeightKey>((anonymous namespace)::DBHeightKey&) Unexecuted instantiation: bool CDBIterator::GetKey<std::pair<unsigned char, uint256> >(std::pair<unsigned char, uint256>&) Unexecuted instantiation: txdb.cpp:bool CDBIterator::GetKey<(anonymous namespace)::CoinEntry>((anonymous namespace)::CoinEntry&)
166
167	0	template<typename V> bool GetValue(V& value) {
168	0	try {
169	0	DataStream ssValue{GetValueImpl()};
170	0	ssValue.Xor(dbwrapper_private::GetObfuscateKey(parent));
171	0	ssValue >> value;
172	0	} catch (const std::exception&) {
173	0	return false;
174	0	}
175	0	return true;
176	0	} Unexecuted instantiation: coinstatsindex.cpp:bool CDBIterator::GetValue<std::pair<uint256, (anonymous namespace)::DBVal> >(std::pair<uint256, (anonymous namespace)::DBVal>&) Unexecuted instantiation: blockfilterindex.cpp:bool CDBIterator::GetValue<std::pair<uint256, (anonymous namespace)::DBVal> >(std::pair<uint256, (anonymous namespace)::DBVal>&) Unexecuted instantiation: bool CDBIterator::GetValue<CDiskBlockIndex>(CDiskBlockIndex&) Unexecuted instantiation: bool CDBIterator::GetValue<Coin>(Coin&)
177		};
178
179		struct LevelDBContext;
180
181		class CDBWrapper
182		{
183		friend const std::vector<unsigned char>& dbwrapper_private::GetObfuscateKey(const CDBWrapper &w);
184		private:
185		//! holds all leveldb-specific fields of this class
186		std::unique_ptr<LevelDBContext> m_db_context;
187
188		//! the name of this database
189		std::string m_name;
190
191		//! a key used for optional XOR-obfuscation of the database
192		std::vector<unsigned char> obfuscate_key;
193
194		//! the key under which the obfuscation key is stored
195		static const std::string OBFUSCATE_KEY_KEY;
196
197		//! the length of the obfuscate key in number of bytes
198		static const unsigned int OBFUSCATE_KEY_NUM_BYTES;
199
200		std::vector<unsigned char> CreateObfuscateKey() const;
201
202		//! path to filesystem storage
203		const fs::path m_path;
204
205		//! whether or not the database resides in memory
206		bool m_is_memory;
207
208		std::optional<std::string> ReadImpl(Span<const std::byte> key) const;
209		bool ExistsImpl(Span<const std::byte> key) const;
210		size_t EstimateSizeImpl(Span<const std::byte> key1, Span<const std::byte> key2) const;
211	20	auto& DBContext() const LIFETIMEBOUND { return *Assert(m_db_context); }
212
213		public:
214		CDBWrapper(const DBParams& params);
215		~CDBWrapper();
216
217		CDBWrapper(const CDBWrapper&) = delete;
218		CDBWrapper& operator=(const CDBWrapper&) = delete;
219
220		template <typename K, typename V>
221		bool Read(const K& key, V& value) const
222	0	{
223	0	DataStream ssKey{};
224	0	ssKey.reserve(DBWRAPPER_PREALLOC_KEY_SIZE);
225	0	ssKey << key;
226	0	std::optional<std::string> strValue{ReadImpl(ssKey)};
227	0	if (!strValue) { Branch (227:13): [True: 0, False: 0] Branch (227:13): [True: 0, False: 0] Branch (227:13): [True: 0, False: 0] Branch (227:13): [True: 0, False: 0] Branch (227:13): [True: 0, False: 0] Branch (227:13): [True: 0, False: 0] Branch (227:13): [True: 0, False: 0] Branch (227:13): [True: 0, False: 0] Branch (227:13): [True: 0, False: 0] Branch (227:13): [True: 0, False: 0] Branch (227:13): [True: 0, False: 0] Branch (227:13): [True: 0, False: 0] Branch (227:13): [True: 0, False: 0] Branch (227:13): [True: 0, False: 0] Branch (227:13): [True: 0, False: 0] Branch (227:13): [True: 0, False: 0]
228	0	return false;
229	0	}
230	0	try {
231	0	DataStream ssValue{MakeByteSpan(*strValue)};
232	0	ssValue.Xor(obfuscate_key);
233	0	ssValue >> value;
234	0	} catch (const std::exception&) {
235	0	return false;
236	0	}
237	0	return true;
238	0	} Unexecuted instantiation: bool CDBWrapper::Read<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<unsigned char, std::allocator<unsigned char> > >(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, std::vector<unsigned char, std::allocator<unsigned char> >&) const Unexecuted instantiation: bool CDBWrapper::Read<unsigned char, CBlockLocator>(unsigned char const&, CBlockLocator&) const Unexecuted instantiation: bool CDBWrapper::Read<std::pair<unsigned char, uint256>, CDiskTxPos>(std::pair<unsigned char, uint256> const&, CDiskTxPos&) const Unexecuted instantiation: coinstatsindex.cpp:bool CDBWrapper::Read<(anonymous namespace)::DBHashKey, (anonymous namespace)::DBVal>((anonymous namespace)::DBHashKey const&, (anonymous namespace)::DBVal&) const Unexecuted instantiation: coinstatsindex.cpp:bool CDBWrapper::Read<(anonymous namespace)::DBHeightKey, std::pair<uint256, (anonymous namespace)::DBVal> >((anonymous namespace)::DBHeightKey const&, std::pair<uint256, (anonymous namespace)::DBVal>&) const Unexecuted instantiation: coinstatsindex.cpp:bool CDBWrapper::Read<(anonymous namespace)::DBHashKey, std::pair<uint256, (anonymous namespace)::DBVal> >((anonymous namespace)::DBHashKey const&, std::pair<uint256, (anonymous namespace)::DBVal>&) const Unexecuted instantiation: bool CDBWrapper::Read<unsigned char, MuHash3072>(unsigned char const&, MuHash3072&) const Unexecuted instantiation: blockfilterindex.cpp:bool CDBWrapper::Read<(anonymous namespace)::DBHashKey, (anonymous namespace)::DBVal>((anonymous namespace)::DBHashKey const&, (anonymous namespace)::DBVal&) const Unexecuted instantiation: bool CDBWrapper::Read<unsigned char, FlatFilePos>(unsigned char const&, FlatFilePos&) const Unexecuted instantiation: blockfilterindex.cpp:bool CDBWrapper::Read<(anonymous namespace)::DBHeightKey, std::pair<uint256, (anonymous namespace)::DBVal> >((anonymous namespace)::DBHeightKey const&, std::pair<uint256, (anonymous namespace)::DBVal>&) const Unexecuted instantiation: bool CDBWrapper::Read<std::pair<unsigned char, int>, CBlockFileInfo>(std::pair<unsigned char, int> const&, CBlockFileInfo&) const Unexecuted instantiation: bool CDBWrapper::Read<unsigned char, int>(unsigned char const&, int&) const Unexecuted instantiation: bool CDBWrapper::Read<std::pair<unsigned char, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >, unsigned char>(std::pair<unsigned char, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > const&, unsigned char&) const Unexecuted instantiation: txdb.cpp:bool CDBWrapper::Read<(anonymous namespace)::CoinEntry, Coin>((anonymous namespace)::CoinEntry const&, Coin&) const Unexecuted instantiation: bool CDBWrapper::Read<unsigned char, uint256>(unsigned char const&, uint256&) const Unexecuted instantiation: bool CDBWrapper::Read<unsigned char, std::vector<uint256, std::allocator<uint256> > >(unsigned char const&, std::vector<uint256, std::allocator<uint256> >&) const
239
240		template <typename K, typename V>
241		bool Write(const K& key, const V& value, bool fSync = false)
242	0	{
243	0	CDBBatch batch(*this);
244	0	batch.Write(key, value);
245	0	return WriteBatch(batch, fSync);
246	0	} Unexecuted instantiation: bool CDBWrapper::Write<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<unsigned char, std::allocator<unsigned char> > >(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, std::vector<unsigned char, std::allocator<unsigned char> > const&, bool) Unexecuted instantiation: coinstatsindex.cpp:bool CDBWrapper::Write<(anonymous namespace)::DBHeightKey, std::pair<uint256, (anonymous namespace)::DBVal> >((anonymous namespace)::DBHeightKey const&, std::pair<uint256, (anonymous namespace)::DBVal> const&, bool) Unexecuted instantiation: blockfilterindex.cpp:bool CDBWrapper::Write<(anonymous namespace)::DBHeightKey, std::pair<uint256, (anonymous namespace)::DBVal> >((anonymous namespace)::DBHeightKey const&, std::pair<uint256, (anonymous namespace)::DBVal> const&, bool) Unexecuted instantiation: bool CDBWrapper::Write<unsigned char, unsigned char>(unsigned char const&, unsigned char const&, bool) Unexecuted instantiation: bool CDBWrapper::Write<std::pair<unsigned char, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >, unsigned char>(std::pair<unsigned char, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > const&, unsigned char const&, bool)
247
248		//! @returns filesystem path to the on-disk data.
249	0	std::optional<fs::path> StoragePath() {
250	0	if (m_is_memory) { Branch (250:13): [True: 0, False: 0]
251	0	return {};
252	0	}
253	0	return m_path;
254	0	}
255
256		template <typename K>
257		bool Exists(const K& key) const
258	0	{
259	0	DataStream ssKey{};
260	0	ssKey.reserve(DBWRAPPER_PREALLOC_KEY_SIZE);
261	0	ssKey << key;
262	0	return ExistsImpl(ssKey);
263	0	} Unexecuted instantiation: bool CDBWrapper::Exists<unsigned char>(unsigned char const&) const Unexecuted instantiation: txdb.cpp:bool CDBWrapper::Exists<(anonymous namespace)::CoinEntry>((anonymous namespace)::CoinEntry const&) const
264
265		template <typename K>
266		bool Erase(const K& key, bool fSync = false)
267	0	{
268	0	CDBBatch batch(*this);
269	0	batch.Erase(key);
270	0	return WriteBatch(batch, fSync);
271	0	}
272
273		bool WriteBatch(CDBBatch& batch, bool fSync = false);
274
275		// Get an estimate of LevelDB memory usage (in bytes).
276		size_t DynamicMemoryUsage() const;
277
278		CDBIterator* NewIterator();
279
280		/**
281		* Return true if the database managed by this class contains no entries.
282		*/
283		bool IsEmpty();
284
285		template<typename K>
286		size_t EstimateSize(const K& key_begin, const K& key_end) const
287	0	{
288	0	DataStream ssKey1{}, ssKey2{};
289	0	ssKey1.reserve(DBWRAPPER_PREALLOC_KEY_SIZE);
290	0	ssKey2.reserve(DBWRAPPER_PREALLOC_KEY_SIZE);
291	0	ssKey1 << key_begin;
292	0	ssKey2 << key_end;
293	0	return EstimateSizeImpl(ssKey1, ssKey2);
294	0	}
295		};
296
297		#endif // BITCOIN_DBWRAPPER_H