dn724/dncurrency
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages 1 Wiki Activity Actions

Merge pull request #4760 from clemahieu/store_cleanup

Browse source
This commit is contained in:
clemahieu 2024-10-21 08:29:19 +01:00 • committed by GitHub
commit e11ffcfb3d
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
56 changed files with 293 additions and 256 deletions
Download patch file Download diff file Expand all files Collapse all files

4
nano/nano_node/entry.cpp
View file

@ -1942,7 +1942,7 @@ int main (int argc, char * const * argv)
nano::locked<std::vector<boost::unordered_set<nano::account>>> opened_account_versions_shared (epoch_count); nano::locked<std::vector<boost::unordered_set<nano::account>>> opened_account_versions_shared (epoch_count);
using opened_account_versions_t = decltype (opened_account_versions_shared)::value_type; using opened_account_versions_t = decltype (opened_account_versions_shared)::value_type;
node->store.account.for_each_par ( node->store.account.for_each_par (
[&opened_account_versions_shared, epoch_count] (nano::store::read_transaction const & /*unused*/, nano::store::iterator<nano::account, nano::account_info> i, nano::store::iterator<nano::account, nano::account_info> n) { [&opened_account_versions_shared, epoch_count] (nano::store::read_transaction const & /*unused*/, auto i, auto n) {
// First cache locally // First cache locally
opened_account_versions_t opened_account_versions_l (epoch_count); opened_account_versions_t opened_account_versions_l (epoch_count);
for (; i != n; ++i) for (; i != n; ++i)
@ -1979,7 +1979,7 @@ int main (int argc, char * const * argv)
nano::locked<boost::unordered_map<nano::account, std::underlying_type_t<nano::epoch>>> unopened_highest_pending_shared; nano::locked<boost::unordered_map<nano::account, std::underlying_type_t<nano::epoch>>> unopened_highest_pending_shared;
using unopened_highest_pending_t = decltype (unopened_highest_pending_shared)::value_type; using unopened_highest_pending_t = decltype (unopened_highest_pending_shared)::value_type;
node->store.pending.for_each_par ( node->store.pending.for_each_par (
[&unopened_highest_pending_shared, &opened_accounts] (nano::store::read_transaction const & /*unused*/, nano::store::iterator<nano::pending_key, nano::pending_info> i, nano::store::iterator<nano::pending_key, nano::pending_info> n) { [&unopened_highest_pending_shared, &opened_accounts] (nano::store::read_transaction const & /*unused*/, auto i, auto n) {
// First cache locally // First cache locally
unopened_highest_pending_t unopened_highest_pending_l; unopened_highest_pending_t unopened_highest_pending_l;
for (; i != n; ++i) for (; i != n; ++i)

17
nano/node/wallet.cpp
View file

@ -1753,22 +1753,22 @@ std::unordered_map<nano::wallet_id, std::shared_ptr<nano::wallet>> nano::wallets
nano::uint128_t const nano::wallets::generate_priority = std::numeric_limits<nano::uint128_t>::max (); nano::uint128_t const nano::wallets::generate_priority = std::numeric_limits<nano::uint128_t>::max ();
nano::uint128_t const nano::wallets::high_priority = std::numeric_limits<nano::uint128_t>::max () - 1; nano::uint128_t const nano::wallets::high_priority = std::numeric_limits<nano::uint128_t>::max () - 1;
nano::store::iterator<nano::account, nano::wallet_value> nano::wallet_store::begin (store::transaction const & transaction_a) auto nano::wallet_store::begin (store::transaction const & transaction_a) -> iterator
{ {
store::iterator<nano::account, nano::wallet_value> result (std::make_unique<nano::store::lmdb::iterator<nano::account, nano::wallet_value>> (transaction_a, env, handle, nano::store::lmdb::db_val (nano::account (special_count)))); iterator result (std::make_unique<nano::store::lmdb::iterator<nano::account, nano::wallet_value>> (transaction_a, env, handle, nano::store::lmdb::db_val (nano::account (special_count))));
return result; return result;
} }
nano::store::iterator<nano::account, nano::wallet_value> nano::wallet_store::begin (store::transaction const & transaction_a, nano::account const & key) auto nano::wallet_store::begin (store::transaction const & transaction_a, nano::account const & key) -> iterator
{ {
store::iterator<nano::account, nano::wallet_value> result (std::make_unique<nano::store::lmdb::iterator<nano::account, nano::wallet_value>> (transaction_a, env, handle, nano::store::lmdb::db_val (key))); iterator result (std::make_unique<nano::store::lmdb::iterator<nano::account, nano::wallet_value>> (transaction_a, env, handle, nano::store::lmdb::db_val (key)));
return result; return result;
} }
nano::store::iterator<nano::account, nano::wallet_value> nano::wallet_store::find (store::transaction const & transaction_a, nano::account const & key) auto nano::wallet_store::find (store::transaction const & transaction_a, nano::account const & key) -> iterator
{ {
auto result (begin (transaction_a, key)); auto result (begin (transaction_a, key));
store::iterator<nano::account, nano::wallet_value> end (nullptr); iterator end{ nullptr };
if (result != end) if (result != end)
{ {
if (result->first == key) if (result->first == key)
@ -1787,10 +1787,11 @@ nano::store::iterator<nano::account, nano::wallet_value> nano::wallet_store::fin
return result; return result;
} }
nano::store::iterator<nano::account, nano::wallet_value> nano::wallet_store::end () auto nano::wallet_store::end () -> iterator
{ {
return store::iterator<nano::account, nano::wallet_value> (nullptr); return iterator{ nullptr };
} }
nano::mdb_wallets_store::mdb_wallets_store (std::filesystem::path const & path_a, nano::lmdb_config const & lmdb_config_a) : nano::mdb_wallets_store::mdb_wallets_store (std::filesystem::path const & path_a, nano::lmdb_config const & lmdb_config_a) :
environment (error, path_a, nano::store::lmdb::env::options::make ().set_config (lmdb_config_a).override_config_sync (nano::lmdb_config::sync_strategy::always).override_config_map_size (1ULL * 1024 * 1024 * 1024)) environment (error, path_a, nano::store::lmdb::env::options::make ().set_config (lmdb_config_a).override_config_sync (nano::lmdb_config::sync_strategy::always).override_config_map_size (1ULL * 1024 * 1024 * 1024))
{ {

11
nano/node/wallet.hpp
View file

@ -57,6 +57,9 @@ enum class key_type
class wallet_store final class wallet_store final
{ {
public:
using iterator = store::iterator<nano::account, nano::wallet_value>;
public: public:
wallet_store (bool &, nano::kdf &, store::transaction &, store::lmdb::env &, nano::account, unsigned, std::string const &); wallet_store (bool &, nano::kdf &, store::transaction &, store::lmdb::env &, nano::account, unsigned, std::string const &);
wallet_store (bool &, nano::kdf &, store::transaction &, store::lmdb::env &, nano::account, unsigned, std::string const &, std::string const &); wallet_store (bool &, nano::kdf &, store::transaction &, store::lmdb::env &, nano::account, unsigned, std::string const &, std::string const &);
@ -89,10 +92,10 @@ public:
bool fetch (store::transaction const &, nano::account const &, nano::raw_key &); bool fetch (store::transaction const &, nano::account const &, nano::raw_key &);
bool exists (store::transaction const &, nano::account const &); bool exists (store::transaction const &, nano::account const &);
void destroy (store::transaction const &); void destroy (store::transaction const &);
store::iterator<nano::account, nano::wallet_value> find (store::transaction const &, nano::account const &); iterator find (store::transaction const &, nano::account const &);
store::iterator<nano::account, nano::wallet_value> begin (store::transaction const &, nano::account const &); iterator begin (store::transaction const &, nano::account const &);
store::iterator<nano::account, nano::wallet_value> begin (store::transaction const &); iterator begin (store::transaction const &);
store::iterator<nano::account, nano::wallet_value> end (); iterator end ();
void derive_key (nano::raw_key &, store::transaction const &, std::string const &); void derive_key (nano::raw_key &, store::transaction const &, std::string const &);
void serialize_json (store::transaction const &, std::string &); void serialize_json (store::transaction const &, std::string &);
void write_backup (store::transaction const &, std::filesystem::path const &); void write_backup (store::transaction const &, std::filesystem::path const &);

8
nano/secure/ledger.cpp
View file

@ -14,7 +14,7 @@
#include <nano/store/block.hpp> #include <nano/store/block.hpp>
#include <nano/store/component.hpp> #include <nano/store/component.hpp>
#include <nano/store/confirmation_height.hpp> #include <nano/store/confirmation_height.hpp>
#include <nano/store/final.hpp> #include <nano/store/final_vote.hpp>
#include <nano/store/online_weight.hpp> #include <nano/store/online_weight.hpp>
#include <nano/store/peer.hpp> #include <nano/store/peer.hpp>
#include <nano/store/pending.hpp> #include <nano/store/pending.hpp>
@ -749,7 +749,7 @@ void nano::ledger::initialize (nano::generate_cache_flags const & generate_cache
if (generate_cache_flags_a.reps || generate_cache_flags_a.account_count || generate_cache_flags_a.block_count) if (generate_cache_flags_a.reps || generate_cache_flags_a.account_count || generate_cache_flags_a.block_count)
{ {
store.account.for_each_par ( store.account.for_each_par (
[this] (store::read_transaction const & /*unused*/, store::iterator<nano::account, nano::account_info> i, store::iterator<nano::account, nano::account_info> n) { [this] (store::read_transaction const & /*unused*/, auto i, auto n) {
uint64_t block_count_l{ 0 }; uint64_t block_count_l{ 0 };
uint64_t account_count_l{ 0 }; uint64_t account_count_l{ 0 };
for (; i != n; ++i) for (; i != n; ++i)
@ -763,7 +763,7 @@ void nano::ledger::initialize (nano::generate_cache_flags const & generate_cache
}); });
store.rep_weight.for_each_par ( store.rep_weight.for_each_par (
[this] (store::read_transaction const & /*unused*/, store::iterator<nano::account, nano::uint128_union> i, store::iterator<nano::account, nano::uint128_union> n) { [this] (store::read_transaction const & /*unused*/, auto i, auto n) {
nano::rep_weights rep_weights_l{ this->store.rep_weight }; nano::rep_weights rep_weights_l{ this->store.rep_weight };
for (; i != n; ++i) for (; i != n; ++i)
{ {
@ -776,7 +776,7 @@ void nano::ledger::initialize (nano::generate_cache_flags const & generate_cache
if (generate_cache_flags_a.cemented_count) if (generate_cache_flags_a.cemented_count)
{ {
store.confirmation_height.for_each_par ( store.confirmation_height.for_each_par (
[this] (store::read_transaction const & /*unused*/, store::iterator<nano::account, nano::confirmation_height_info> i, store::iterator<nano::account, nano::confirmation_height_info> n) { [this] (store::read_transaction const & /*unused*/, auto i, auto n) {
uint64_t cemented_count_l (0); uint64_t cemented_count_l (0);
for (; i != n; ++i) for (; i != n; ++i)
{ {

5
nano/store/CMakeLists.txt
View file

@ -9,7 +9,7 @@ add_library(
db_val_impl.hpp db_val_impl.hpp
iterator.hpp iterator.hpp
iterator_impl.hpp iterator_impl.hpp
final.hpp final_vote.hpp
lmdb/account.hpp lmdb/account.hpp
lmdb/block.hpp lmdb/block.hpp
lmdb/confirmation_height.hpp lmdb/confirmation_height.hpp
@ -32,6 +32,7 @@ add_library(
peer.hpp peer.hpp
pending.hpp pending.hpp
pruned.hpp pruned.hpp
rep_weight.hpp
rocksdb/account.hpp rocksdb/account.hpp
rocksdb/block.hpp rocksdb/block.hpp
rocksdb/confirmation_height.hpp rocksdb/confirmation_height.hpp
@ -58,7 +59,7 @@ add_library(
db_val.cpp db_val.cpp
iterator.cpp iterator.cpp
iterator_impl.cpp iterator_impl.cpp
final.cpp final_vote.cpp
lmdb/account.cpp lmdb/account.cpp
lmdb/block.cpp lmdb/block.cpp
lmdb/confirmation_height.cpp lmdb/confirmation_height.cpp

13
nano/store/account.hpp
View file

@ -19,6 +19,9 @@ namespace nano::store
*/ */
class account class account
{ {
public:
using iterator = store::iterator<nano::account, nano::account_info>;
public: public:
virtual void put (store::write_transaction const &, nano::account const &, nano::account_info const &) = 0; virtual void put (store::write_transaction const &, nano::account const &, nano::account_info const &) = 0;
virtual bool get (store::transaction const &, nano::account const &, nano::account_info &) = 0; virtual bool get (store::transaction const &, nano::account const &, nano::account_info &) = 0;
@ -26,10 +29,10 @@ public:
virtual void del (store::write_transaction const &, nano::account const &) = 0; virtual void del (store::write_transaction const &, nano::account const &) = 0;
virtual bool exists (store::transaction const &, nano::account const &) = 0; virtual bool exists (store::transaction const &, nano::account const &) = 0;
virtual size_t count (store::transaction const &) = 0; virtual size_t count (store::transaction const &) = 0;
virtual iterator<nano::account, nano::account_info> begin (store::transaction const &, nano::account const &) const = 0; virtual iterator begin (store::transaction const &, nano::account const &) const = 0;
virtual iterator<nano::account, nano::account_info> begin (store::transaction const &) const = 0; virtual iterator begin (store::transaction const &) const = 0;
virtual iterator<nano::account, nano::account_info> rbegin (store::transaction const &) const = 0; virtual iterator rbegin (store::transaction const &) const = 0;
virtual iterator<nano::account, nano::account_info> end () const = 0; virtual iterator end () const = 0;
virtual void for_each_par (std::function<void (store::read_transaction const &, iterator<nano::account, nano::account_info>, iterator<nano::account, nano::account_info>)> const &) const = 0; virtual void for_each_par (std::function<void (store::read_transaction const &, iterator, iterator)> const &) const = 0;
}; };
} // namespace nano::store } // namespace nano::store

11
nano/store/block.hpp
View file

@ -21,6 +21,9 @@ namespace nano::store
*/ */
class block class block
{ {
public:
using iterator = store::iterator<nano::block_hash, block_w_sideband>;
public: public:
virtual void put (store::write_transaction const &, nano::block_hash const &, nano::block const &) = 0; virtual void put (store::write_transaction const &, nano::block_hash const &, nano::block const &) = 0;
virtual void raw_put (store::write_transaction const &, std::vector<uint8_t> const &, nano::block_hash const &) = 0; virtual void raw_put (store::write_transaction const &, std::vector<uint8_t> const &, nano::block_hash const &) = 0;
@ -31,9 +34,9 @@ public:
virtual void del (store::write_transaction const &, nano::block_hash const &) = 0; virtual void del (store::write_transaction const &, nano::block_hash const &) = 0;
virtual bool exists (store::transaction const &, nano::block_hash const &) = 0; virtual bool exists (store::transaction const &, nano::block_hash const &) = 0;
virtual uint64_t count (store::transaction const &) = 0; virtual uint64_t count (store::transaction const &) = 0;
virtual iterator<nano::block_hash, block_w_sideband> begin (store::transaction const &, nano::block_hash const &) const = 0; virtual iterator begin (store::transaction const &, nano::block_hash const &) const = 0;
virtual iterator<nano::block_hash, block_w_sideband> begin (store::transaction const &) const = 0; virtual iterator begin (store::transaction const &) const = 0;
virtual iterator<nano::block_hash, block_w_sideband> end () const = 0; virtual iterator end () const = 0;
virtual void for_each_par (std::function<void (store::read_transaction const &, iterator<nano::block_hash, block_w_sideband>, iterator<nano::block_hash, block_w_sideband>)> const & action_a) const = 0; virtual void for_each_par (std::function<void (store::read_transaction const &, iterator, iterator)> const & action_a) const = 0;
}; };
} // namespace nano::store } // namespace nano::store

11
nano/store/confirmation_height.hpp
View file

@ -17,6 +17,9 @@ namespace nano::store
*/ */
class confirmation_height class confirmation_height
{ {
public:
using iterator = store::iterator<nano::account, nano::confirmation_height_info>;
public: public:
virtual void put (store::write_transaction const & transaction_a, nano::account const & account_a, nano::confirmation_height_info const & confirmation_height_info_a) = 0; virtual void put (store::write_transaction const & transaction_a, nano::account const & account_a, nano::confirmation_height_info const & confirmation_height_info_a) = 0;
@ -32,9 +35,9 @@ public:
virtual uint64_t count (store::transaction const & transaction_a) = 0; virtual uint64_t count (store::transaction const & transaction_a) = 0;
virtual void clear (store::write_transaction const &, nano::account const &) = 0; virtual void clear (store::write_transaction const &, nano::account const &) = 0;
virtual void clear (store::write_transaction const &) = 0; virtual void clear (store::write_transaction const &) = 0;
virtual iterator<nano::account, nano::confirmation_height_info> begin (store::transaction const & transaction_a, nano::account const & account_a) const = 0; virtual iterator begin (store::transaction const & transaction_a, nano::account const & account_a) const = 0;
virtual iterator<nano::account, nano::confirmation_height_info> begin (store::transaction const & transaction_a) const = 0; virtual iterator begin (store::transaction const & transaction_a) const = 0;
virtual iterator<nano::account, nano::confirmation_height_info> end () const = 0; virtual iterator end () const = 0;
virtual void for_each_par (std::function<void (store::read_transaction const &, iterator<nano::account, nano::confirmation_height_info>, iterator<nano::account, nano::confirmation_height_info>)> const &) const = 0; virtual void for_each_par (std::function<void (store::read_transaction const &, iterator, iterator)> const &) const = 0;
}; };
} // namespace nano::store } // namespace nano::store

1
nano/store/final.cpp
View file

@ -1 +0,0 @@
#include <nano/store/final.hpp>

1
nano/store/final_vote.cpp Normal file
View file

@ -0,0 +1 @@
#include <nano/store/final_vote.hpp>

11
nano/store/final.hpp → nano/store/final_vote.hpp
View file

@ -17,6 +17,9 @@ namespace nano::store
*/ */
class final_vote class final_vote
{ {
public:
using iterator = store::iterator<nano::qualified_root, nano::block_hash>;
public: public:
virtual bool put (store::write_transaction const & transaction_a, nano::qualified_root const & root_a, nano::block_hash const & hash_a) = 0; virtual bool put (store::write_transaction const & transaction_a, nano::qualified_root const & root_a, nano::block_hash const & hash_a) = 0;
virtual std::vector<nano::block_hash> get (store::transaction const & transaction_a, nano::root const & root_a) = 0; virtual std::vector<nano::block_hash> get (store::transaction const & transaction_a, nano::root const & root_a) = 0;
@ -24,9 +27,9 @@ public:
virtual size_t count (store::transaction const & transaction_a) const = 0; virtual size_t count (store::transaction const & transaction_a) const = 0;
virtual void clear (store::write_transaction const &, nano::root const &) = 0; virtual void clear (store::write_transaction const &, nano::root const &) = 0;
virtual void clear (store::write_transaction const &) = 0; virtual void clear (store::write_transaction const &) = 0;
virtual store::iterator<nano::qualified_root, nano::block_hash> begin (store::transaction const & transaction_a, nano::qualified_root const & root_a) const = 0; virtual iterator begin (store::transaction const & transaction_a, nano::qualified_root const & root_a) const = 0;
virtual store::iterator<nano::qualified_root, nano::block_hash> begin (store::transaction const & transaction_a) const = 0; virtual iterator begin (store::transaction const & transaction_a) const = 0;
virtual store::iterator<nano::qualified_root, nano::block_hash> end () const = 0; virtual iterator end () const = 0;
virtual void for_each_par (std::function<void (store::read_transaction const &, store::iterator<nano::qualified_root, nano::block_hash>, store::iterator<nano::qualified_root, nano::block_hash>)> const & action_a) const = 0; virtual void for_each_par (std::function<void (store::read_transaction const &, iterator, iterator)> const & action_a) const = 0;
}; };
} // namespace nano::store } // namespace nano::store

10
nano/store/iterator_impl.hpp
View file

@ -11,14 +11,14 @@ template <typename T, typename U>
class iterator_impl class iterator_impl
{ {
public: public:
explicit iterator_impl (nano::store::transaction const & transaction_a) : explicit iterator_impl (transaction const & transaction_a) :
transaction{ transaction_a }, txn{ transaction_a },
transaction_epoch{ transaction_a.epoch () } transaction_epoch{ transaction_a.epoch () }
{ {
} }
virtual ~iterator_impl () virtual ~iterator_impl ()
{ {
debug_assert (transaction_epoch == transaction.epoch (), "invalid iterator-transaction lifetime detected"); debug_assert (transaction_epoch == txn.epoch (), "invalid iterator-transaction lifetime detected");
} }
virtual iterator_impl<T, U> & operator++ () = 0; virtual iterator_impl<T, U> & operator++ () = 0;
@ -37,7 +37,7 @@ public:
} }
protected: protected:
nano::store::transaction const & transaction; transaction const & txn;
nano::store::transaction::epoch_t const transaction_epoch; transaction::epoch_t const transaction_epoch;
}; };
} }

12
nano/store/lmdb/account.cpp
View file

@ -43,27 +43,27 @@ size_t nano::store::lmdb::account::count (store::transaction const & transaction
return store.count (transaction_a, tables::accounts); return store.count (transaction_a, tables::accounts);
} }
nano::store::iterator<nano::account, nano::account_info> nano::store::lmdb::account::begin (store::transaction const & transaction, nano::account const & account) const auto nano::store::lmdb::account::begin (store::transaction const & transaction, nano::account const & account) const -> iterator
{ {
return store.make_iterator<nano::account, nano::account_info> (transaction, tables::accounts, account); return store.make_iterator<nano::account, nano::account_info> (transaction, tables::accounts, account);
} }
nano::store::iterator<nano::account, nano::account_info> nano::store::lmdb::account::begin (store::transaction const & transaction) const auto nano::store::lmdb::account::begin (store::transaction const & transaction) const -> iterator
{ {
return store.make_iterator<nano::account, nano::account_info> (transaction, tables::accounts); return store.make_iterator<nano::account, nano::account_info> (transaction, tables::accounts);
} }
nano::store::iterator<nano::account, nano::account_info> nano::store::lmdb::account::rbegin (store::transaction const & transaction_a) const auto nano::store::lmdb::account::rbegin (store::transaction const & transaction_a) const -> iterator
{ {
return store.make_iterator<nano::account, nano::account_info> (transaction_a, tables::accounts, false); return store.make_iterator<nano::account, nano::account_info> (transaction_a, tables::accounts, false);
} }
nano::store::iterator<nano::account, nano::account_info> nano::store::lmdb::account::end () const auto nano::store::lmdb::account::end () const -> iterator
{ {
return store::iterator<nano::account, nano::account_info> (nullptr); return iterator{ nullptr };
} }
void nano::store::lmdb::account::for_each_par (std::function<void (store::read_transaction const &, store::iterator<nano::account, nano::account_info>, store::iterator<nano::account, nano::account_info>)> const & action_a) const void nano::store::lmdb::account::for_each_par (std::function<void (store::read_transaction const &, iterator, iterator)> const & action_a) const
{ {
parallel_traversal<nano::uint256_t> ( parallel_traversal<nano::uint256_t> (
[&action_a, this] (nano::uint256_t const & start, nano::uint256_t const & end, bool const is_last) { [&action_a, this] (nano::uint256_t const & start, nano::uint256_t const & end, bool const is_last) {

10
nano/store/lmdb/account.hpp
View file

@ -22,11 +22,11 @@ public:
void del (store::write_transaction const & transaction_a, nano::account const & account_a) override; void del (store::write_transaction const & transaction_a, nano::account const & account_a) override;
bool exists (store::transaction const & transaction_a, nano::account const & account_a) override; bool exists (store::transaction const & transaction_a, nano::account const & account_a) override;
size_t count (store::transaction const & transaction_a) override; size_t count (store::transaction const & transaction_a) override;
store::iterator<nano::account, nano::account_info> begin (store::transaction const & transaction_a, nano::account const & account_a) const override; iterator begin (store::transaction const & transaction_a, nano::account const & account_a) const override;
store::iterator<nano::account, nano::account_info> begin (store::transaction const & transaction_a) const override; iterator begin (store::transaction const & transaction_a) const override;
store::iterator<nano::account, nano::account_info> rbegin (store::transaction const & transaction_a) const override; iterator rbegin (store::transaction const & transaction_a) const override;
store::iterator<nano::account, nano::account_info> end () const override; iterator end () const override;
void for_each_par (std::function<void (store::read_transaction const &, store::iterator<nano::account, nano::account_info>, store::iterator<nano::account, nano::account_info>)> const & action_a) const override; void for_each_par (std::function<void (store::read_transaction const &, iterator, iterator)> const & action_a) const override;
/** /**
* Maps account v1 to account information, head, rep, open, balance, timestamp and block count. (Removed) * Maps account v1 to account information, head, rep, open, balance, timestamp and block count. (Removed)

11
nano/store/lmdb/block.cpp
View file

@ -134,22 +134,23 @@ uint64_t nano::store::lmdb::block::count (store::transaction const & transaction
{ {
return store.count (transaction_a, tables::blocks); return store.count (transaction_a, tables::blocks);
} }
nano::store::iterator<nano::block_hash, nano::store::block_w_sideband> nano::store::lmdb::block::begin (store::transaction const & transaction) const
auto nano::store::lmdb::block::begin (store::transaction const & transaction) const -> iterator
{ {
return store.make_iterator<nano::block_hash, nano::store::block_w_sideband> (transaction, tables::blocks); return store.make_iterator<nano::block_hash, nano::store::block_w_sideband> (transaction, tables::blocks);
} }
nano::store::iterator<nano::block_hash, nano::store::block_w_sideband> nano::store::lmdb::block::begin (store::transaction const & transaction, nano::block_hash const & hash) const auto nano::store::lmdb::block::begin (store::transaction const & transaction, nano::block_hash const & hash) const -> iterator
{ {
return store.make_iterator<nano::block_hash, nano::store::block_w_sideband> (transaction, tables::blocks, hash); return store.make_iterator<nano::block_hash, nano::store::block_w_sideband> (transaction, tables::blocks, hash);
} }
nano::store::iterator<nano::block_hash, nano::store::block_w_sideband> nano::store::lmdb::block::end () const auto nano::store::lmdb::block::end () const -> iterator
{ {
return store::iterator<nano::block_hash, nano::store::block_w_sideband> (nullptr); return iterator{ nullptr };
} }
void nano::store::lmdb::block::for_each_par (std::function<void (store::read_transaction const &, store::iterator<nano::block_hash, block_w_sideband>, store::iterator<nano::block_hash, block_w_sideband>)> const & action_a) const void nano::store::lmdb::block::for_each_par (std::function<void (store::read_transaction const &, iterator, iterator)> const & action_a) const
{ {
parallel_traversal<nano::uint256_t> ( parallel_traversal<nano::uint256_t> (
[&action_a, this] (nano::uint256_t const & start, nano::uint256_t const & end, bool const is_last) { [&action_a, this] (nano::uint256_t const & start, nano::uint256_t const & end, bool const is_last) {

8
nano/store/lmdb/block.hpp
View file

@ -31,10 +31,10 @@ public:
void del (store::write_transaction const & transaction_a, nano::block_hash const & hash_a) override; void del (store::write_transaction const & transaction_a, nano::block_hash const & hash_a) override;
bool exists (store::transaction const & transaction_a, nano::block_hash const & hash_a) override; bool exists (store::transaction const & transaction_a, nano::block_hash const & hash_a) override;
uint64_t count (store::transaction const & transaction_a) override; uint64_t count (store::transaction const & transaction_a) override;
store::iterator<nano::block_hash, nano::store::block_w_sideband> begin (store::transaction const & transaction_a) const override; iterator begin (store::transaction const & transaction_a) const override;
store::iterator<nano::block_hash, nano::store::block_w_sideband> begin (store::transaction const & transaction_a, nano::block_hash const & hash_a) const override; iterator begin (store::transaction const & transaction_a, nano::block_hash const & hash_a) const override;
store::iterator<nano::block_hash, nano::store::block_w_sideband> end () const override; iterator end () const override;
void for_each_par (std::function<void (store::read_transaction const &, store::iterator<nano::block_hash, block_w_sideband>, store::iterator<nano::block_hash, block_w_sideband>)> const & action_a) const override; void for_each_par (std::function<void (store::read_transaction const &, iterator, iterator)> const & action_a) const override;
/** /**
* Contains block_sideband and block for all block types (legacy send/change/open/receive & state blocks) * Contains block_sideband and block for all block types (legacy send/change/open/receive & state blocks)

10
nano/store/lmdb/confirmation_height.cpp
View file

@ -59,22 +59,22 @@ void nano::store::lmdb::confirmation_height::clear (store::write_transaction con
store.drop (transaction_a, nano::tables::confirmation_height); store.drop (transaction_a, nano::tables::confirmation_height);
} }
nano::store::iterator<nano::account, nano::confirmation_height_info> nano::store::lmdb::confirmation_height::begin (store::transaction const & transaction, nano::account const & account) const auto nano::store::lmdb::confirmation_height::begin (store::transaction const & transaction, nano::account const & account) const -> iterator
{ {
return store.make_iterator<nano::account, nano::confirmation_height_info> (transaction, tables::confirmation_height, account); return store.make_iterator<nano::account, nano::confirmation_height_info> (transaction, tables::confirmation_height, account);
} }
nano::store::iterator<nano::account, nano::confirmation_height_info> nano::store::lmdb::confirmation_height::begin (store::transaction const & transaction) const auto nano::store::lmdb::confirmation_height::begin (store::transaction const & transaction) const -> iterator
{ {
return store.make_iterator<nano::account, nano::confirmation_height_info> (transaction, tables::confirmation_height); return store.make_iterator<nano::account, nano::confirmation_height_info> (transaction, tables::confirmation_height);
} }
nano::store::iterator<nano::account, nano::confirmation_height_info> nano::store::lmdb::confirmation_height::end () const auto nano::store::lmdb::confirmation_height::end () const -> iterator
{ {
return store::iterator<nano::account, nano::confirmation_height_info> (nullptr); return iterator{ nullptr };
} }
void nano::store::lmdb::confirmation_height::for_each_par (std::function<void (store::read_transaction const &, store::iterator<nano::account, nano::confirmation_height_info>, store::iterator<nano::account, nano::confirmation_height_info>)> const & action_a) const void nano::store::lmdb::confirmation_height::for_each_par (std::function<void (store::read_transaction const &, iterator, iterator)> const & action_a) const
{ {
parallel_traversal<nano::uint256_t> ( parallel_traversal<nano::uint256_t> (
[&action_a, this] (nano::uint256_t const & start, nano::uint256_t const & end, bool const is_last) { [&action_a, this] (nano::uint256_t const & start, nano::uint256_t const & end, bool const is_last) {

8
nano/store/lmdb/confirmation_height.hpp
View file

@ -23,10 +23,10 @@ public:
uint64_t count (store::transaction const & transaction_a) override; uint64_t count (store::transaction const & transaction_a) override;
void clear (store::write_transaction const & transaction_a, nano::account const & account_a) override; void clear (store::write_transaction const & transaction_a, nano::account const & account_a) override;
void clear (store::write_transaction const & transaction_a) override; void clear (store::write_transaction const & transaction_a) override;
store::iterator<nano::account, nano::confirmation_height_info> begin (store::transaction const & transaction_a, nano::account const & account_a) const override; iterator begin (store::transaction const & transaction_a, nano::account const & account_a) const override;
store::iterator<nano::account, nano::confirmation_height_info> begin (store::transaction const & transaction_a) const override; iterator begin (store::transaction const & transaction_a) const override;
store::iterator<nano::account, nano::confirmation_height_info> end () const override; iterator end () const override;
void for_each_par (std::function<void (store::read_transaction const &, store::iterator<nano::account, nano::confirmation_height_info>, store::iterator<nano::account, nano::confirmation_height_info>)> const & action_a) const override; void for_each_par (std::function<void (store::read_transaction const &, iterator, iterator)> const & action_a) const override;
/* /*
* Confirmation height of an account, and the hash for the block at that height * Confirmation height of an account, and the hash for the block at that height

10
nano/store/lmdb/final_vote.cpp
View file

@ -64,22 +64,22 @@ void nano::store::lmdb::final_vote::clear (store::write_transaction const & tran
store.drop (transaction_a, nano::tables::final_votes); store.drop (transaction_a, nano::tables::final_votes);
} }
nano::store::iterator<nano::qualified_root, nano::block_hash> nano::store::lmdb::final_vote::begin (store::transaction const & transaction, nano::qualified_root const & root) const auto nano::store::lmdb::final_vote::begin (store::transaction const & transaction, nano::qualified_root const & root) const -> iterator
{ {
return store.make_iterator<nano::qualified_root, nano::block_hash> (transaction, tables::final_votes, root); return store.make_iterator<nano::qualified_root, nano::block_hash> (transaction, tables::final_votes, root);
} }
nano::store::iterator<nano::qualified_root, nano::block_hash> nano::store::lmdb::final_vote::begin (store::transaction const & transaction) const auto nano::store::lmdb::final_vote::begin (store::transaction const & transaction) const -> iterator
{ {
return store.make_iterator<nano::qualified_root, nano::block_hash> (transaction, tables::final_votes); return store.make_iterator<nano::qualified_root, nano::block_hash> (transaction, tables::final_votes);
} }
nano::store::iterator<nano::qualified_root, nano::block_hash> nano::store::lmdb::final_vote::end () const auto nano::store::lmdb::final_vote::end () const -> iterator
{ {
return store::iterator<nano::qualified_root, nano::block_hash> (nullptr); return iterator{ nullptr };
} }
void nano::store::lmdb::final_vote::for_each_par (std::function<void (store::read_transaction const &, store::iterator<nano::qualified_root, nano::block_hash>, store::iterator<nano::qualified_root, nano::block_hash>)> const & action_a) const void nano::store::lmdb::final_vote::for_each_par (std::function<void (store::read_transaction const &, iterator, iterator)> const & action_a) const
{ {
parallel_traversal<nano::uint512_t> ( parallel_traversal<nano::uint512_t> (
[&action_a, this] (nano::uint512_t const & start, nano::uint512_t const & end, bool const is_last) { [&action_a, this] (nano::uint512_t const & start, nano::uint512_t const & end, bool const is_last) {

10
nano/store/lmdb/final_vote.hpp
View file

@ -1,6 +1,6 @@
#pragma once #pragma once
#include <nano/store/final.hpp> #include <nano/store/final_vote.hpp>
#include <lmdb/libraries/liblmdb/lmdb.h> #include <lmdb/libraries/liblmdb/lmdb.h>
@ -23,10 +23,10 @@ public:
size_t count (store::transaction const & transaction_a) const override; size_t count (store::transaction const & transaction_a) const override;
void clear (store::write_transaction const & transaction_a, nano::root const & root_a) override; void clear (store::write_transaction const & transaction_a, nano::root const & root_a) override;
void clear (store::write_transaction const & transaction_a) override; void clear (store::write_transaction const & transaction_a) override;
store::iterator<nano::qualified_root, nano::block_hash> begin (store::transaction const & transaction_a, nano::qualified_root const & root_a) const override; iterator begin (store::transaction const & transaction_a, nano::qualified_root const & root_a) const override;
store::iterator<nano::qualified_root, nano::block_hash> begin (store::transaction const & transaction_a) const override; iterator begin (store::transaction const & transaction_a) const override;
store::iterator<nano::qualified_root, nano::block_hash> end () const override; iterator end () const override;
void for_each_par (std::function<void (store::read_transaction const &, store::iterator<nano::qualified_root, nano::block_hash>, store::iterator<nano::qualified_root, nano::block_hash>)> const & action_a) const override; void for_each_par (std::function<void (store::read_transaction const &, iterator, iterator)> const & action_a) const override;
/** /**
* Maps root to block hash for generated final votes. * Maps root to block hash for generated final votes.

54
nano/store/lmdb/iterator.hpp
View file

@ -14,8 +14,8 @@ template <typename T, typename U>
class iterator : public iterator_impl<T, U> class iterator : public iterator_impl<T, U>
{ {
public: public:
iterator (store::transaction const & transaction_a, env const & env_a, MDB_dbi db_a, MDB_val const & val_a = MDB_val{}, bool const direction_asc = true) : iterator (transaction const & transaction_a, env const & env_a, MDB_dbi db_a, MDB_val const & val_a = MDB_val{}, bool const direction_asc = true) :
nano::store::iterator_impl<T, U> (transaction_a) iterator_impl<T, U> (transaction_a)
{ {
auto status (mdb_cursor_open (env_a.tx (transaction_a), db_a, &cursor)); auto status (mdb_cursor_open (env_a.tx (transaction_a), db_a, &cursor));
release_assert (status == 0); release_assert (status == 0);
@ -47,14 +47,14 @@ public:
iterator () = default; iterator () = default;
iterator (nano::store::lmdb::iterator<T, U> && other_a) iterator (iterator<T, U> && other_a)
{ {
cursor = other_a.cursor; cursor = other_a.cursor;
other_a.cursor = nullptr; other_a.cursor = nullptr;
current = other_a.current; current = other_a.current;
} }
iterator (nano::store::lmdb::iterator<T, U> const &) = delete; iterator (iterator<T, U> const &) = delete;
~iterator () ~iterator ()
{ {
@ -64,7 +64,7 @@ public:
} }
} }
store::iterator_impl<T, U> & operator++ () override iterator_impl<T, U> & operator++ () override
{ {
debug_assert (cursor != nullptr); debug_assert (cursor != nullptr);
auto status (mdb_cursor_get (cursor, &current.first.value, &current.second.value, MDB_NEXT)); auto status (mdb_cursor_get (cursor, &current.first.value, &current.second.value, MDB_NEXT));
@ -80,7 +80,7 @@ public:
return *this; return *this;
} }
store::iterator_impl<T, U> & operator-- () override iterator_impl<T, U> & operator-- () override
{ {
debug_assert (cursor != nullptr); debug_assert (cursor != nullptr);
auto status (mdb_cursor_get (cursor, &current.first.value, &current.second.value, MDB_PREV)); auto status (mdb_cursor_get (cursor, &current.first.value, &current.second.value, MDB_PREV));
@ -101,9 +101,9 @@ public:
return &current; return &current;
} }
bool operator== (nano::store::lmdb::iterator<T, U> const & base_a) const bool operator== (iterator<T, U> const & base_a) const
{ {
auto const other_a (boost::polymorphic_downcast<nano::store::lmdb::iterator<T, U> const *> (&base_a)); auto const other_a (boost::polymorphic_downcast<iterator<T, U> const *> (&base_a));
auto result (current.first.data () == other_a->current.first.data ()); auto result (current.first.data () == other_a->current.first.data ());
debug_assert (!result || (current.first.size () == other_a->current.first.size ())); debug_assert (!result || (current.first.size () == other_a->current.first.size ()));
debug_assert (!result || (current.second.data () == other_a->current.second.data ())); debug_assert (!result || (current.second.data () == other_a->current.second.data ()));
@ -111,9 +111,9 @@ public:
return result; return result;
} }
bool operator== (store::iterator_impl<T, U> const & base_a) const override bool operator== (iterator_impl<T, U> const & base_a) const override
{ {
auto const other_a (boost::polymorphic_downcast<nano::store::lmdb::iterator<T, U> const *> (&base_a)); auto const other_a (boost::polymorphic_downcast<iterator<T, U> const *> (&base_a));
auto result (current.first.data () == other_a->current.first.data ()); auto result (current.first.data () == other_a->current.first.data ());
debug_assert (!result || (current.first.size () == other_a->current.first.size ())); debug_assert (!result || (current.first.size () == other_a->current.first.size ()));
debug_assert (!result || (current.second.data () == other_a->current.second.data ())); debug_assert (!result || (current.second.data () == other_a->current.second.data ()));
@ -151,7 +151,7 @@ public:
debug_assert (is_end_sentinal ()); debug_assert (is_end_sentinal ());
} }
nano::store::lmdb::iterator<T, U> & operator= (nano::store::lmdb::iterator<T, U> && other_a) iterator<T, U> & operator= (iterator<T, U> && other_a)
{ {
if (cursor != nullptr) if (cursor != nullptr)
{ {
@ -164,7 +164,7 @@ public:
return *this; return *this;
} }
store::iterator_impl<T, U> & operator= (store::iterator_impl<T, U> const &) = delete; iterator_impl<T, U> & operator= (iterator_impl<T, U> const &) = delete;
MDB_cursor * cursor{ nullptr }; MDB_cursor * cursor{ nullptr };
std::pair<store::db_val<MDB_val>, store::db_val<MDB_val>> current; std::pair<store::db_val<MDB_val>, store::db_val<MDB_val>> current;
}; };
@ -176,21 +176,21 @@ template <typename T, typename U>
class merge_iterator : public iterator_impl<T, U> class merge_iterator : public iterator_impl<T, U>
{ {
public: public:
merge_iterator (store::transaction const & transaction_a, MDB_dbi db1_a, MDB_dbi db2_a) : merge_iterator (transaction const & transaction_a, MDB_dbi db1_a, MDB_dbi db2_a) :
impl1 (std::make_unique<nano::store::lmdb::iterator<T, U>> (transaction_a, db1_a)), impl1 (std::make_unique<iterator<T, U>> (transaction_a, db1_a)),
impl2 (std::make_unique<nano::store::lmdb::iterator<T, U>> (transaction_a, db2_a)) impl2 (std::make_unique<iterator<T, U>> (transaction_a, db2_a))
{ {
} }
merge_iterator () : merge_iterator () :
impl1 (std::make_unique<nano::store::lmdb::iterator<T, U>> ()), impl1 (std::make_unique<iterator<T, U>> ()),
impl2 (std::make_unique<nano::store::lmdb::iterator<T, U>> ()) impl2 (std::make_unique<iterator<T, U>> ())
{ {
} }
merge_iterator (store::transaction const & transaction_a, MDB_dbi db1_a, MDB_dbi db2_a, MDB_val const & val_a) : merge_iterator (transaction const & transaction_a, MDB_dbi db1_a, MDB_dbi db2_a, MDB_val const & val_a) :
impl1 (std::make_unique<nano::store::lmdb::iterator<T, U>> (transaction_a, db1_a, val_a)), impl1 (std::make_unique<iterator<T, U>> (transaction_a, db1_a, val_a)),
impl2 (std::make_unique<nano::store::lmdb::iterator<T, U>> (transaction_a, db2_a, val_a)) impl2 (std::make_unique<iterator<T, U>> (transaction_a, db2_a, val_a))
{ {
} }
@ -202,13 +202,13 @@ public:
merge_iterator (merge_iterator<T, U> const &) = delete; merge_iterator (merge_iterator<T, U> const &) = delete;
store::iterator_impl<T, U> & operator++ () override iterator_impl<T, U> & operator++ () override
{ {
++least_iterator (); ++least_iterator ();
return *this; return *this;
} }
store::iterator_impl<T, U> & operator-- () override iterator_impl<T, U> & operator-- () override
{ {
--least_iterator (); --least_iterator ();
return *this; return *this;
@ -229,7 +229,7 @@ public:
return !(*this == base_a); return !(*this == base_a);
} }
bool operator== (store::iterator_impl<T, U> const & base_a) const override bool operator== (iterator_impl<T, U> const & base_a) const override
{ {
debug_assert ((dynamic_cast<merge_iterator<T, U> const *> (&base_a) != nullptr) && "Incompatible iterator comparison"); debug_assert ((dynamic_cast<merge_iterator<T, U> const *> (&base_a) != nullptr) && "Incompatible iterator comparison");
auto & other (static_cast<merge_iterator<T, U> const &> (base_a)); auto & other (static_cast<merge_iterator<T, U> const &> (base_a));
@ -267,9 +267,9 @@ public:
mutable bool from_first_database{ false }; mutable bool from_first_database{ false };
private: private:
nano::store::lmdb::iterator<T, U> & least_iterator () const iterator<T, U> & least_iterator () const
{ {
nano::store::lmdb::iterator<T, U> * result; iterator<T, U> * result;
if (impl1->is_end_sentinal ()) if (impl1->is_end_sentinal ())
{ {
result = impl2.get (); result = impl2.get ();
@ -304,7 +304,7 @@ private:
return *result; return *result;
} }
std::unique_ptr<nano::store::lmdb::iterator<T, U>> impl1; std::unique_ptr<iterator<T, U>> impl1;
std::unique_ptr<nano::store::lmdb::iterator<T, U>> impl2; std::unique_ptr<iterator<T, U>> impl2;
}; };
} }

8
nano/store/lmdb/online_weight.cpp
View file

@ -18,19 +18,19 @@ void nano::store::lmdb::online_weight::del (store::write_transaction const & tra
store.release_assert_success (status); store.release_assert_success (status);
} }
nano::store::iterator<uint64_t, nano::amount> nano::store::lmdb::online_weight::begin (store::transaction const & transaction) const auto nano::store::lmdb::online_weight::begin (store::transaction const & transaction) const -> iterator
{ {
return store.make_iterator<uint64_t, nano::amount> (transaction, tables::online_weight); return store.make_iterator<uint64_t, nano::amount> (transaction, tables::online_weight);
} }
nano::store::iterator<uint64_t, nano::amount> nano::store::lmdb::online_weight::rbegin (store::transaction const & transaction) const auto nano::store::lmdb::online_weight::rbegin (store::transaction const & transaction) const -> iterator
{ {
return store.make_iterator<uint64_t, nano::amount> (transaction, tables::online_weight, false); return store.make_iterator<uint64_t, nano::amount> (transaction, tables::online_weight, false);
} }
nano::store::iterator<uint64_t, nano::amount> nano::store::lmdb::online_weight::end () const auto nano::store::lmdb::online_weight::end () const -> iterator
{ {
return store::iterator<uint64_t, nano::amount> (nullptr); return iterator{ nullptr };
} }
size_t nano::store::lmdb::online_weight::count (store::transaction const & transaction) const size_t nano::store::lmdb::online_weight::count (store::transaction const & transaction) const

6
nano/store/lmdb/online_weight.hpp
View file

@ -15,9 +15,9 @@ public:
explicit online_weight (nano::store::lmdb::component & store_a); explicit online_weight (nano::store::lmdb::component & store_a);
void put (store::write_transaction const & transaction_a, uint64_t time_a, nano::amount const & amount_a) override; void put (store::write_transaction const & transaction_a, uint64_t time_a, nano::amount const & amount_a) override;
void del (store::write_transaction const & transaction_a, uint64_t time_a) override; void del (store::write_transaction const & transaction_a, uint64_t time_a) override;
store::iterator<uint64_t, nano::amount> begin (store::transaction const & transaction_a) const override; iterator begin (store::transaction const & transaction_a) const override;
store::iterator<uint64_t, nano::amount> rbegin (store::transaction const & transaction_a) const override; iterator rbegin (store::transaction const & transaction_a) const override;
store::iterator<uint64_t, nano::amount> end () const override; iterator end () const override;
size_t count (store::transaction const & transaction_a) const override; size_t count (store::transaction const & transaction_a) const override;
void clear (store::write_transaction const & transaction_a) override; void clear (store::write_transaction const & transaction_a) override;

6
nano/store/lmdb/peer.cpp
View file

@ -45,12 +45,12 @@ void nano::store::lmdb::peer::clear (store::write_transaction const & transactio
store.release_assert_success (status); store.release_assert_success (status);
} }
nano::store::iterator<nano::endpoint_key, nano::millis_t> nano::store::lmdb::peer::begin (store::transaction const & transaction) const auto nano::store::lmdb::peer::begin (store::transaction const & transaction) const -> iterator
{ {
return store.make_iterator<nano::endpoint_key, nano::millis_t> (transaction, tables::peers); return store.make_iterator<nano::endpoint_key, nano::millis_t> (transaction, tables::peers);
} }
nano::store::iterator<nano::endpoint_key, nano::millis_t> nano::store::lmdb::peer::end () const auto nano::store::lmdb::peer::end () const -> iterator
{ {
return store::iterator<nano::endpoint_key, nano::millis_t> (nullptr); return iterator{ nullptr };
} }

4
nano/store/lmdb/peer.hpp
View file

@ -19,8 +19,8 @@ public:
bool exists (store::transaction const &, nano::endpoint_key const & endpoint) const override; bool exists (store::transaction const &, nano::endpoint_key const & endpoint) const override;
size_t count (store::transaction const &) const override; size_t count (store::transaction const &) const override;
void clear (store::write_transaction const &) override; void clear (store::write_transaction const &) override;
store::iterator<nano::endpoint_key, nano::millis_t> begin (store::transaction const &) const override; iterator begin (store::transaction const &) const override;
store::iterator<nano::endpoint_key, nano::millis_t> end () const override; iterator end () const override;
/* /*
* Endpoints for peers * Endpoints for peers

10
nano/store/lmdb/pending.cpp
View file

@ -45,22 +45,22 @@ bool nano::store::lmdb::pending::any (store::transaction const & transaction_a,
return iterator != end () && nano::pending_key (iterator->first).account == account_a; return iterator != end () && nano::pending_key (iterator->first).account == account_a;
} }
nano::store::iterator<nano::pending_key, nano::pending_info> nano::store::lmdb::pending::begin (store::transaction const & transaction_a, nano::pending_key const & key_a) const auto nano::store::lmdb::pending::begin (store::transaction const & transaction_a, nano::pending_key const & key_a) const -> iterator
{ {
return store.make_iterator<nano::pending_key, nano::pending_info> (transaction_a, tables::pending, key_a); return store.make_iterator<nano::pending_key, nano::pending_info> (transaction_a, tables::pending, key_a);
} }
nano::store::iterator<nano::pending_key, nano::pending_info> nano::store::lmdb::pending::begin (store::transaction const & transaction_a) const auto nano::store::lmdb::pending::begin (store::transaction const & transaction_a) const -> iterator
{ {
return store.make_iterator<nano::pending_key, nano::pending_info> (transaction_a, tables::pending); return store.make_iterator<nano::pending_key, nano::pending_info> (transaction_a, tables::pending);
} }
nano::store::iterator<nano::pending_key, nano::pending_info> nano::store::lmdb::pending::end () const auto nano::store::lmdb::pending::end () const -> iterator
{ {
return store::iterator<nano::pending_key, nano::pending_info> (nullptr); return iterator{ nullptr };
} }
void nano::store::lmdb::pending::for_each_par (std::function<void (store::read_transaction const &, store::iterator<nano::pending_key, nano::pending_info>, store::iterator<nano::pending_key, nano::pending_info>)> const & action_a) const void nano::store::lmdb::pending::for_each_par (std::function<void (store::read_transaction const &, iterator, iterator)> const & action_a) const
{ {
parallel_traversal<nano::uint512_t> ( parallel_traversal<nano::uint512_t> (
[&action_a, this] (nano::uint512_t const & start, nano::uint512_t const & end, bool const is_last) { [&action_a, this] (nano::uint512_t const & start, nano::uint512_t const & end, bool const is_last) {

8
nano/store/lmdb/pending.hpp
View file

@ -22,10 +22,10 @@ public:
std::optional<nano::pending_info> get (store::transaction const & transaction_a, nano::pending_key const & key_a) override; std::optional<nano::pending_info> get (store::transaction const & transaction_a, nano::pending_key const & key_a) override;
bool exists (store::transaction const & transaction_a, nano::pending_key const & key_a) override; bool exists (store::transaction const & transaction_a, nano::pending_key const & key_a) override;
bool any (store::transaction const & transaction_a, nano::account const & account_a) override; bool any (store::transaction const & transaction_a, nano::account const & account_a) override;
store::iterator<nano::pending_key, nano::pending_info> begin (store::transaction const & transaction_a, nano::pending_key const & key_a) const override; iterator begin (store::transaction const & transaction_a, nano::pending_key const & key_a) const override;
store::iterator<nano::pending_key, nano::pending_info> begin (store::transaction const & transaction_a) const override; iterator begin (store::transaction const & transaction_a) const override;
store::iterator<nano::pending_key, nano::pending_info> end () const override; iterator end () const override;
void for_each_par (std::function<void (store::read_transaction const &, store::iterator<nano::pending_key, nano::pending_info>, store::iterator<nano::pending_key, nano::pending_info>)> const & action_a) const override; void for_each_par (std::function<void (store::read_transaction const &, iterator, iterator)> const & action_a) const override;
/** /**
* Maps min_version 0 (destination account, pending block) to (source account, amount). (Removed) * Maps min_version 0 (destination account, pending block) to (source account, amount). (Removed)

10
nano/store/lmdb/pruned.cpp
View file

@ -45,22 +45,22 @@ void nano::store::lmdb::pruned::clear (store::write_transaction const & transact
store.release_assert_success (status); store.release_assert_success (status);
} }
nano::store::iterator<nano::block_hash, std::nullptr_t> nano::store::lmdb::pruned::begin (store::transaction const & transaction, nano::block_hash const & hash) const auto nano::store::lmdb::pruned::begin (store::transaction const & transaction, nano::block_hash const & hash) const -> iterator
{ {
return store.make_iterator<nano::block_hash, std::nullptr_t> (transaction, tables::pruned, hash); return store.make_iterator<nano::block_hash, std::nullptr_t> (transaction, tables::pruned, hash);
} }
nano::store::iterator<nano::block_hash, std::nullptr_t> nano::store::lmdb::pruned::begin (store::transaction const & transaction) const auto nano::store::lmdb::pruned::begin (store::transaction const & transaction) const -> iterator
{ {
return store.make_iterator<nano::block_hash, std::nullptr_t> (transaction, tables::pruned); return store.make_iterator<nano::block_hash, std::nullptr_t> (transaction, tables::pruned);
} }
nano::store::iterator<nano::block_hash, std::nullptr_t> nano::store::lmdb::pruned::end () const auto nano::store::lmdb::pruned::end () const -> iterator
{ {
return store::iterator<nano::block_hash, std::nullptr_t> (nullptr); return iterator{ nullptr };
} }
void nano::store::lmdb::pruned::for_each_par (std::function<void (store::read_transaction const &, store::iterator<nano::block_hash, std::nullptr_t>, store::iterator<nano::block_hash, std::nullptr_t>)> const & action_a) const void nano::store::lmdb::pruned::for_each_par (std::function<void (store::read_transaction const &, iterator, iterator)> const & action_a) const
{ {
parallel_traversal<nano::uint256_t> ( parallel_traversal<nano::uint256_t> (
[&action_a, this] (nano::uint256_t const & start, nano::uint256_t const & end, bool const is_last) { [&action_a, this] (nano::uint256_t const & start, nano::uint256_t const & end, bool const is_last) {

8
nano/store/lmdb/pruned.hpp
View file

@ -19,10 +19,10 @@ public:
nano::block_hash random (store::transaction const & transaction_a) override; nano::block_hash random (store::transaction const & transaction_a) override;
size_t count (store::transaction const & transaction_a) const override; size_t count (store::transaction const & transaction_a) const override;
void clear (store::write_transaction const & transaction_a) override; void clear (store::write_transaction const & transaction_a) override;
store::iterator<nano::block_hash, std::nullptr_t> begin (store::transaction const & transaction_a, nano::block_hash const & hash_a) const override; iterator begin (store::transaction const & transaction_a, nano::block_hash const & hash_a) const override;
store::iterator<nano::block_hash, std::nullptr_t> begin (store::transaction const & transaction_a) const override; iterator begin (store::transaction const & transaction_a) const override;
store::iterator<nano::block_hash, std::nullptr_t> end () const override; iterator end () const override;
void for_each_par (std::function<void (store::read_transaction const &, store::iterator<nano::block_hash, std::nullptr_t>, store::iterator<nano::block_hash, std::nullptr_t>)> const & action_a) const override; void for_each_par (std::function<void (store::read_transaction const &, iterator, iterator)> const & action_a) const override;
/** /**
* Pruned blocks hashes * Pruned blocks hashes

10
nano/store/lmdb/rep_weight.cpp
View file

@ -43,22 +43,22 @@ void nano::store::lmdb::rep_weight::del (store::write_transaction const & txn_a,
store.release_assert_success (status); store.release_assert_success (status);
} }
nano::store::iterator<nano::account, nano::uint128_union> nano::store::lmdb::rep_weight::begin (store::transaction const & transaction_a, nano::account const & representative_a) const auto nano::store::lmdb::rep_weight::begin (store::transaction const & transaction_a, nano::account const & representative_a) const -> iterator
{ {
return store.make_iterator<nano::account, nano::uint128_union> (transaction_a, tables::rep_weights, representative_a); return store.make_iterator<nano::account, nano::uint128_union> (transaction_a, tables::rep_weights, representative_a);
} }
nano::store::iterator<nano::account, nano::uint128_union> nano::store::lmdb::rep_weight::begin (store::transaction const & transaction_a) const auto nano::store::lmdb::rep_weight::begin (store::transaction const & transaction_a) const -> iterator
{ {
return store.make_iterator<nano::account, nano::uint128_union> (transaction_a, tables::rep_weights); return store.make_iterator<nano::account, nano::uint128_union> (transaction_a, tables::rep_weights);
} }
nano::store::iterator<nano::account, nano::uint128_union> nano::store::lmdb::rep_weight::end () const auto nano::store::lmdb::rep_weight::end () const -> iterator
{ {
return nano::store::iterator<nano::account, nano::uint128_union> (nullptr); return iterator{ nullptr };
} }
void nano::store::lmdb::rep_weight::for_each_par (std::function<void (store::read_transaction const &, store::iterator<nano::account, nano::uint128_union>, store::iterator<nano::account, nano::uint128_union>)> const & action_a) const void nano::store::lmdb::rep_weight::for_each_par (std::function<void (store::read_transaction const &, iterator, iterator)> const & action_a) const
{ {
parallel_traversal<nano::uint256_t> ( parallel_traversal<nano::uint256_t> (
[&action_a, this] (nano::uint256_t const & start, nano::uint256_t const & end, bool const is_last) { [&action_a, this] (nano::uint256_t const & start, nano::uint256_t const & end, bool const is_last) {

8
nano/store/lmdb/rep_weight.hpp
View file

@ -20,10 +20,10 @@ public:
nano::uint128_t get (store::transaction const & txn_a, nano::account const & representative_a) override; nano::uint128_t get (store::transaction const & txn_a, nano::account const & representative_a) override;
void put (store::write_transaction const & txn_a, nano::account const & representative_a, nano::uint128_t const & weight_a) override; void put (store::write_transaction const & txn_a, nano::account const & representative_a, nano::uint128_t const & weight_a) override;
void del (store::write_transaction const &, nano::account const & representative_a) override; void del (store::write_transaction const &, nano::account const & representative_a) override;
store::iterator<nano::account, nano::uint128_union> begin (store::transaction const & transaction_a, nano::account const & representative_a) const override; iterator begin (store::transaction const & transaction_a, nano::account const & representative_a) const override;
store::iterator<nano::account, nano::uint128_union> begin (store::transaction const & transaction_a) const override; iterator begin (store::transaction const & transaction_a) const override;
store::iterator<nano::account, nano::uint128_union> end () const override; iterator end () const override;
void for_each_par (std::function<void (store::read_transaction const &, store::iterator<nano::account, nano::uint128_union>, store::iterator<nano::account, nano::uint128_union>)> const & action_a) const override; void for_each_par (std::function<void (store::read_transaction const &, iterator, iterator)> const & action_a) const override;
/** /**
* Representative weights * Representative weights

9
nano/store/online_weight.hpp
View file

@ -17,12 +17,15 @@ namespace nano::store
*/ */
class online_weight class online_weight
{ {
public:
using iterator = store::iterator<uint64_t, nano::amount>;
public: public:
virtual void put (store::write_transaction const &, uint64_t, nano::amount const &) = 0; virtual void put (store::write_transaction const &, uint64_t, nano::amount const &) = 0;
virtual void del (store::write_transaction const &, uint64_t) = 0; virtual void del (store::write_transaction const &, uint64_t) = 0;
virtual store::iterator<uint64_t, nano::amount> begin (store::transaction const &) const = 0; virtual iterator begin (store::transaction const &) const = 0;
virtual store::iterator<uint64_t, nano::amount> rbegin (store::transaction const &) const = 0; virtual iterator rbegin (store::transaction const &) const = 0;
virtual store::iterator<uint64_t, nano::amount> end () const = 0; virtual iterator end () const = 0;
virtual size_t count (store::transaction const &) const = 0; virtual size_t count (store::transaction const &) const = 0;
virtual void clear (store::write_transaction const &) = 0; virtual void clear (store::write_transaction const &) = 0;
}; };

7
nano/store/peer.hpp
View file

@ -17,6 +17,9 @@ namespace nano::store
*/ */
class peer class peer
{ {
public:
using iterator = store::iterator<nano::endpoint_key, nano::millis_t>;
public: public:
/// Returns true if the peer was inserted, false if it was already in the container /// Returns true if the peer was inserted, false if it was already in the container
virtual void put (store::write_transaction const &, nano::endpoint_key const & endpoint, nano::millis_t timestamp) = 0; virtual void put (store::write_transaction const &, nano::endpoint_key const & endpoint, nano::millis_t timestamp) = 0;
@ -25,7 +28,7 @@ public:
virtual bool exists (store::transaction const &, nano::endpoint_key const & endpoint) const = 0; virtual bool exists (store::transaction const &, nano::endpoint_key const & endpoint) const = 0;
virtual size_t count (store::transaction const &) const = 0; virtual size_t count (store::transaction const &) const = 0;
virtual void clear (store::write_transaction const &) = 0; virtual void clear (store::write_transaction const &) = 0;
virtual store::iterator<nano::endpoint_key, nano::millis_t> begin (store::transaction const &) const = 0; virtual iterator begin (store::transaction const &) const = 0;
virtual store::iterator<nano::endpoint_key, nano::millis_t> end () const = 0; virtual iterator end () const = 0;
}; };
} // namespace nano::store } // namespace nano::store

8
nano/store/pending.hpp
View file

@ -29,9 +29,9 @@ public:
virtual std::optional<nano::pending_info> get (store::transaction const &, nano::pending_key const &) = 0; virtual std::optional<nano::pending_info> get (store::transaction const &, nano::pending_key const &) = 0;
virtual bool exists (store::transaction const &, nano::pending_key const &) = 0; virtual bool exists (store::transaction const &, nano::pending_key const &) = 0;
virtual bool any (store::transaction const &, nano::account const &) = 0; virtual bool any (store::transaction const &, nano::account const &) = 0;
virtual store::iterator<nano::pending_key, nano::pending_info> begin (store::transaction const &, nano::pending_key const &) const = 0; virtual iterator begin (store::transaction const &, nano::pending_key const &) const = 0;
virtual store::iterator<nano::pending_key, nano::pending_info> begin (store::transaction const &) const = 0; virtual iterator begin (store::transaction const &) const = 0;
virtual store::iterator<nano::pending_key, nano::pending_info> end () const = 0; virtual iterator end () const = 0;
virtual void for_each_par (std::function<void (store::read_transaction const &, store::iterator<nano::pending_key, nano::pending_info>, store::iterator<nano::pending_key, nano::pending_info>)> const & action_a) const = 0; virtual void for_each_par (std::function<void (store::read_transaction const &, iterator, iterator)> const & action_a) const = 0;
}; };
} // namespace nano::store } // namespace nano::store

11
nano/store/pruned.hpp
View file

@ -17,6 +17,9 @@ namespace nano::store
*/ */
class pruned class pruned
{ {
public:
using iterator = store::iterator<nano::block_hash, std::nullptr_t>;
public: public:
virtual void put (store::write_transaction const & transaction_a, nano::block_hash const & hash_a) = 0; virtual void put (store::write_transaction const & transaction_a, nano::block_hash const & hash_a) = 0;
virtual void del (store::write_transaction const & transaction_a, nano::block_hash const & hash_a) = 0; virtual void del (store::write_transaction const & transaction_a, nano::block_hash const & hash_a) = 0;
@ -24,9 +27,9 @@ public:
virtual nano::block_hash random (store::transaction const & transaction_a) = 0; virtual nano::block_hash random (store::transaction const & transaction_a) = 0;
virtual size_t count (store::transaction const & transaction_a) const = 0; virtual size_t count (store::transaction const & transaction_a) const = 0;
virtual void clear (store::write_transaction const &) = 0; virtual void clear (store::write_transaction const &) = 0;
virtual store::iterator<nano::block_hash, std::nullptr_t> begin (store::transaction const & transaction_a, nano::block_hash const & hash_a) const = 0; virtual iterator begin (store::transaction const & transaction_a, nano::block_hash const & hash_a) const = 0;
virtual store::iterator<nano::block_hash, std::nullptr_t> begin (store::transaction const & transaction_a) const = 0; virtual iterator begin (store::transaction const & transaction_a) const = 0;
virtual store::iterator<nano::block_hash, std::nullptr_t> end () const = 0; virtual iterator end () const = 0;
virtual void for_each_par (std::function<void (store::read_transaction const &, store::iterator<nano::block_hash, std::nullptr_t>, store::iterator<nano::block_hash, std::nullptr_t>)> const & action_a) const = 0; virtual void for_each_par (std::function<void (store::read_transaction const &, iterator, iterator)> const & action_a) const = 0;
}; };
} // namespace nano::store } // namespace nano::store

11
nano/store/rep_weight.hpp
View file

@ -18,15 +18,18 @@ namespace nano::store
*/ */
class rep_weight class rep_weight
{ {
public:
using iterator = store::iterator<nano::account, nano::uint128_union>;
public: public:
virtual ~rep_weight (){}; virtual ~rep_weight (){};
virtual uint64_t count (store::transaction const & txn_a) = 0; virtual uint64_t count (store::transaction const & txn_a) = 0;
virtual nano::uint128_t get (store::transaction const & txn_a, nano::account const & representative_a) = 0; virtual nano::uint128_t get (store::transaction const & txn_a, nano::account const & representative_a) = 0;
virtual void put (store::write_transaction const & txn_a, nano::account const & representative_a, nano::uint128_t const & weight_a) = 0; virtual void put (store::write_transaction const & txn_a, nano::account const & representative_a, nano::uint128_t const & weight_a) = 0;
virtual void del (store::write_transaction const &, nano::account const & representative_a) = 0; virtual void del (store::write_transaction const &, nano::account const & representative_a) = 0;
virtual store::iterator<nano::account, nano::uint128_union> begin (store::transaction const & transaction_a, nano::account const & representative_a) const = 0; virtual iterator begin (store::transaction const & transaction_a, nano::account const & representative_a) const = 0;
virtual store::iterator<nano::account, nano::uint128_union> begin (store::transaction const & transaction_a) const = 0; virtual iterator begin (store::transaction const & transaction_a) const = 0;
virtual store::iterator<nano::account, nano::uint128_union> end () const = 0; virtual iterator end () const = 0;
virtual void for_each_par (std::function<void (store::read_transaction const &, store::iterator<nano::account, nano::uint128_union>, store::iterator<nano::account, nano::uint128_union>)> const & action_a) const = 0; virtual void for_each_par (std::function<void (store::read_transaction const &, iterator, iterator)> const & action_a) const = 0;
}; };
} }

12
nano/store/rocksdb/account.cpp
View file

@ -42,27 +42,27 @@ size_t nano::store::rocksdb::account::count (store::transaction const & transact
return store.count (transaction_a, tables::accounts); return store.count (transaction_a, tables::accounts);
} }
nano::store::iterator<nano::account, nano::account_info> nano::store::rocksdb::account::begin (store::transaction const & transaction, nano::account const & account) const auto nano::store::rocksdb::account::begin (store::transaction const & transaction, nano::account const & account) const -> iterator
{ {
return store.make_iterator<nano::account, nano::account_info> (transaction, tables::accounts, account); return store.make_iterator<nano::account, nano::account_info> (transaction, tables::accounts, account);
} }
nano::store::iterator<nano::account, nano::account_info> nano::store::rocksdb::account::begin (store::transaction const & transaction) const auto nano::store::rocksdb::account::begin (store::transaction const & transaction) const -> iterator
{ {
return store.make_iterator<nano::account, nano::account_info> (transaction, tables::accounts); return store.make_iterator<nano::account, nano::account_info> (transaction, tables::accounts);
} }
nano::store::iterator<nano::account, nano::account_info> nano::store::rocksdb::account::rbegin (store::transaction const & transaction_a) const auto nano::store::rocksdb::account::rbegin (store::transaction const & transaction_a) const -> iterator
{ {
return store.make_iterator<nano::account, nano::account_info> (transaction_a, tables::accounts, false); return store.make_iterator<nano::account, nano::account_info> (transaction_a, tables::accounts, false);
} }
nano::store::iterator<nano::account, nano::account_info> nano::store::rocksdb::account::end () const auto nano::store::rocksdb::account::end () const -> iterator
{ {
return store::iterator<nano::account, nano::account_info> (nullptr); return iterator{ nullptr };
} }
void nano::store::rocksdb::account::for_each_par (std::function<void (store::read_transaction const &, store::iterator<nano::account, nano::account_info>, store::iterator<nano::account, nano::account_info>)> const & action_a) const void nano::store::rocksdb::account::for_each_par (std::function<void (store::read_transaction const &, iterator, iterator)> const & action_a) const
{ {
parallel_traversal<nano::uint256_t> ( parallel_traversal<nano::uint256_t> (
[&action_a, this] (nano::uint256_t const & start, nano::uint256_t const & end, bool const is_last) { [&action_a, this] (nano::uint256_t const & start, nano::uint256_t const & end, bool const is_last) {

10
nano/store/rocksdb/account.hpp
View file

@ -20,10 +20,10 @@ public:
void del (store::write_transaction const & transaction_a, nano::account const & account_a) override; void del (store::write_transaction const & transaction_a, nano::account const & account_a) override;
bool exists (store::transaction const & transaction_a, nano::account const & account_a) override; bool exists (store::transaction const & transaction_a, nano::account const & account_a) override;
size_t count (store::transaction const & transaction_a) override; size_t count (store::transaction const & transaction_a) override;
store::iterator<nano::account, nano::account_info> begin (store::transaction const & transaction_a, nano::account const & account_a) const override; iterator begin (store::transaction const & transaction_a, nano::account const & account_a) const override;
store::iterator<nano::account, nano::account_info> begin (store::transaction const & transaction_a) const override; iterator begin (store::transaction const & transaction_a) const override;
store::iterator<nano::account, nano::account_info> rbegin (store::transaction const & transaction_a) const override; iterator rbegin (store::transaction const & transaction_a) const override;
store::iterator<nano::account, nano::account_info> end () const override; iterator end () const override;
void for_each_par (std::function<void (store::read_transaction const &, store::iterator<nano::account, nano::account_info>, store::iterator<nano::account, nano::account_info>)> const & action_a) const override; void for_each_par (std::function<void (store::read_transaction const &, iterator, iterator)> const & action_a) const override;
}; };
} // namespace nano::store::rocksdb } // namespace nano::store::rocksdb

17
nano/store/rocksdb/block.cpp
View file

@ -133,22 +133,23 @@ uint64_t nano::store::rocksdb::block::count (store::transaction const & transact
{ {
return store.count (transaction_a, tables::blocks); return store.count (transaction_a, tables::blocks);
} }
nano::store::iterator<nano::block_hash, nano::store::block_w_sideband> nano::store::rocksdb::block::begin (store::transaction const & transaction) const
auto nano::store::rocksdb::block::begin (store::transaction const & transaction) const -> iterator
{ {
return store.make_iterator<nano::block_hash, nano::store::block_w_sideband> (transaction, tables::blocks); return store.make_iterator<nano::block_hash, nano::store::block_w_sideband> (transaction, tables::blocks);
} }
nano::store::iterator<nano::block_hash, nano::store::block_w_sideband> nano::store::rocksdb::block::begin (store::transaction const & transaction, nano::block_hash const & hash) const auto nano::store::rocksdb::block::begin (store::transaction const & transaction, nano::block_hash const & hash) const -> iterator
{ {
return store.make_iterator<nano::block_hash, nano::store::block_w_sideband> (transaction, tables::blocks, hash); return store.make_iterator<nano::block_hash, nano::store::block_w_sideband> (transaction, tables::blocks, hash);
} }
nano::store::iterator<nano::block_hash, nano::store::block_w_sideband> nano::store::rocksdb::block::end () const auto nano::store::rocksdb::block::end () const -> iterator
{ {
return store::iterator<nano::block_hash, nano::store::block_w_sideband> (nullptr); return iterator{ nullptr };
} }
void nano::store::rocksdb::block::for_each_par (std::function<void (store::read_transaction const &, store::iterator<nano::block_hash, block_w_sideband>, store::iterator<nano::block_hash, block_w_sideband>)> const & action_a) const void nano::store::rocksdb::block::for_each_par (std::function<void (store::read_transaction const &, iterator, iterator)> const & action_a) const
{ {
parallel_traversal<nano::uint256_t> ( parallel_traversal<nano::uint256_t> (
[&action_a, this] (nano::uint256_t const & start, nano::uint256_t const & end, bool const is_last) { [&action_a, this] (nano::uint256_t const & start, nano::uint256_t const & end, bool const is_last) {
@ -179,6 +180,7 @@ nano::block_predecessor_rocksdb_set::block_predecessor_rocksdb_set (store::write
block_store{ block_store_a } block_store{ block_store_a }
{ {
} }
void nano::block_predecessor_rocksdb_set::fill_value (nano::block const & block_a) void nano::block_predecessor_rocksdb_set::fill_value (nano::block const & block_a)
{ {
auto hash = block_a.hash (); auto hash = block_a.hash ();
@ -190,22 +192,27 @@ void nano::block_predecessor_rocksdb_set::fill_value (nano::block const & block_
std::copy (hash.bytes.begin (), hash.bytes.end (), data.begin () + block_store.block_successor_offset (transaction, value.size (), type)); std::copy (hash.bytes.begin (), hash.bytes.end (), data.begin () + block_store.block_successor_offset (transaction, value.size (), type));
block_store.raw_put (transaction, data, block_a.previous ()); block_store.raw_put (transaction, data, block_a.previous ());
} }
void nano::block_predecessor_rocksdb_set::send_block (nano::send_block const & block_a) void nano::block_predecessor_rocksdb_set::send_block (nano::send_block const & block_a)
{ {
fill_value (block_a); fill_value (block_a);
} }
void nano::block_predecessor_rocksdb_set::receive_block (nano::receive_block const & block_a) void nano::block_predecessor_rocksdb_set::receive_block (nano::receive_block const & block_a)
{ {
fill_value (block_a); fill_value (block_a);
} }
void nano::block_predecessor_rocksdb_set::open_block (nano::open_block const & block_a) void nano::block_predecessor_rocksdb_set::open_block (nano::open_block const & block_a)
{ {
// Open blocks don't have a predecessor // Open blocks don't have a predecessor
} }
void nano::block_predecessor_rocksdb_set::change_block (nano::change_block const & block_a) void nano::block_predecessor_rocksdb_set::change_block (nano::change_block const & block_a)
{ {
fill_value (block_a); fill_value (block_a);
} }
void nano::block_predecessor_rocksdb_set::state_block (nano::state_block const & block_a) void nano::block_predecessor_rocksdb_set::state_block (nano::state_block const & block_a)
{ {
if (!block_a.previous ().is_zero ()) if (!block_a.previous ().is_zero ())

8
nano/store/rocksdb/block.hpp
View file

@ -29,10 +29,10 @@ public:
void del (store::write_transaction const & transaction_a, nano::block_hash const & hash_a) override; void del (store::write_transaction const & transaction_a, nano::block_hash const & hash_a) override;
bool exists (store::transaction const & transaction_a, nano::block_hash const & hash_a) override; bool exists (store::transaction const & transaction_a, nano::block_hash const & hash_a) override;
uint64_t count (store::transaction const & transaction_a) override; uint64_t count (store::transaction const & transaction_a) override;
store::iterator<nano::block_hash, nano::store::block_w_sideband> begin (store::transaction const & transaction_a) const override; iterator begin (store::transaction const & transaction_a) const override;
store::iterator<nano::block_hash, nano::store::block_w_sideband> begin (store::transaction const & transaction_a, nano::block_hash const & hash_a) const override; iterator begin (store::transaction const & transaction_a, nano::block_hash const & hash_a) const override;
store::iterator<nano::block_hash, nano::store::block_w_sideband> end () const override; iterator end () const override;
void for_each_par (std::function<void (store::read_transaction const &, store::iterator<nano::block_hash, block_w_sideband>, store::iterator<nano::block_hash, block_w_sideband>)> const & action_a) const override; void for_each_par (std::function<void (store::read_transaction const &, iterator, iterator)> const & action_a) const override;
protected: protected:
void block_raw_get (store::transaction const & transaction_a, nano::block_hash const & hash_a, nano::store::rocksdb::db_val & value) const; void block_raw_get (store::transaction const & transaction_a, nano::block_hash const & hash_a, nano::store::rocksdb::db_val & value) const;

10
nano/store/rocksdb/confirmation_height.cpp
View file

@ -59,22 +59,22 @@ void nano::store::rocksdb::confirmation_height::clear (store::write_transaction
store.drop (transaction, nano::tables::confirmation_height); store.drop (transaction, nano::tables::confirmation_height);
} }
nano::store::iterator<nano::account, nano::confirmation_height_info> nano::store::rocksdb::confirmation_height::begin (store::transaction const & transaction, nano::account const & account) const auto nano::store::rocksdb::confirmation_height::begin (store::transaction const & transaction, nano::account const & account) const -> iterator
{ {
return store.make_iterator<nano::account, nano::confirmation_height_info> (transaction, tables::confirmation_height, account); return store.make_iterator<nano::account, nano::confirmation_height_info> (transaction, tables::confirmation_height, account);
} }
nano::store::iterator<nano::account, nano::confirmation_height_info> nano::store::rocksdb::confirmation_height::begin (store::transaction const & transaction) const auto nano::store::rocksdb::confirmation_height::begin (store::transaction const & transaction) const -> iterator
{ {
return store.make_iterator<nano::account, nano::confirmation_height_info> (transaction, tables::confirmation_height); return store.make_iterator<nano::account, nano::confirmation_height_info> (transaction, tables::confirmation_height);
} }
nano::store::iterator<nano::account, nano::confirmation_height_info> nano::store::rocksdb::confirmation_height::end () const auto nano::store::rocksdb::confirmation_height::end () const -> iterator
{ {
return store::iterator<nano::account, nano::confirmation_height_info> (nullptr); return iterator{ nullptr };
} }
void nano::store::rocksdb::confirmation_height::for_each_par (std::function<void (store::read_transaction const &, store::iterator<nano::account, nano::confirmation_height_info>, store::iterator<nano::account, nano::confirmation_height_info>)> const & action_a) const void nano::store::rocksdb::confirmation_height::for_each_par (std::function<void (store::read_transaction const &, iterator, iterator)> const & action_a) const
{ {
parallel_traversal<nano::uint256_t> ( parallel_traversal<nano::uint256_t> (
[&action_a, this] (nano::uint256_t const & start, nano::uint256_t const & end, bool const is_last) { [&action_a, this] (nano::uint256_t const & start, nano::uint256_t const & end, bool const is_last) {

8
nano/store/rocksdb/confirmation_height.hpp
View file

@ -21,9 +21,9 @@ public:
uint64_t count (store::transaction const & transaction_a) override; uint64_t count (store::transaction const & transaction_a) override;
void clear (store::write_transaction const & transaction_a, nano::account const & account_a) override; void clear (store::write_transaction const & transaction_a, nano::account const & account_a) override;
void clear (store::write_transaction const & transaction_a) override; void clear (store::write_transaction const & transaction_a) override;
store::iterator<nano::account, nano::confirmation_height_info> begin (store::transaction const & transaction_a, nano::account const & account_a) const override; iterator begin (store::transaction const & transaction_a, nano::account const & account_a) const override;
store::iterator<nano::account, nano::confirmation_height_info> begin (store::transaction const & transaction_a) const override; iterator begin (store::transaction const & transaction_a) const override;
store::iterator<nano::account, nano::confirmation_height_info> end () const override; iterator end () const override;
void for_each_par (std::function<void (store::read_transaction const &, store::iterator<nano::account, nano::confirmation_height_info>, store::iterator<nano::account, nano::confirmation_height_info>)> const & action_a) const override; void for_each_par (std::function<void (store::read_transaction const &, iterator, iterator)> const & action_a) const override;
}; };
} // namespace nano::store::rocksdb } // namespace nano::store::rocksdb

10
nano/store/rocksdb/final_vote.cpp
View file

@ -64,22 +64,22 @@ void nano::store::rocksdb::final_vote::clear (store::write_transaction const & t
store.drop (transaction_a, nano::tables::final_votes); store.drop (transaction_a, nano::tables::final_votes);
} }
nano::store::iterator<nano::qualified_root, nano::block_hash> nano::store::rocksdb::final_vote::begin (store::transaction const & transaction, nano::qualified_root const & root) const auto nano::store::rocksdb::final_vote::begin (store::transaction const & transaction, nano::qualified_root const & root) const -> iterator
{ {
return store.make_iterator<nano::qualified_root, nano::block_hash> (transaction, tables::final_votes, root); return store.make_iterator<nano::qualified_root, nano::block_hash> (transaction, tables::final_votes, root);
} }
nano::store::iterator<nano::qualified_root, nano::block_hash> nano::store::rocksdb::final_vote::begin (store::transaction const & transaction) const auto nano::store::rocksdb::final_vote::begin (store::transaction const & transaction) const -> iterator
{ {
return store.make_iterator<nano::qualified_root, nano::block_hash> (transaction, tables::final_votes); return store.make_iterator<nano::qualified_root, nano::block_hash> (transaction, tables::final_votes);
} }
nano::store::iterator<nano::qualified_root, nano::block_hash> nano::store::rocksdb::final_vote::end () const auto nano::store::rocksdb::final_vote::end () const -> iterator
{ {
return store::iterator<nano::qualified_root, nano::block_hash> (nullptr); return iterator{ nullptr };
} }
void nano::store::rocksdb::final_vote::for_each_par (std::function<void (store::read_transaction const &, store::iterator<nano::qualified_root, nano::block_hash>, store::iterator<nano::qualified_root, nano::block_hash>)> const & action_a) const void nano::store::rocksdb::final_vote::for_each_par (std::function<void (store::read_transaction const &, iterator, iterator)> const & action_a) const
{ {
parallel_traversal<nano::uint512_t> ( parallel_traversal<nano::uint512_t> (
[&action_a, this] (nano::uint512_t const & start, nano::uint512_t const & end, bool const is_last) { [&action_a, this] (nano::uint512_t const & start, nano::uint512_t const & end, bool const is_last) {

10
nano/store/rocksdb/final_vote.hpp
View file

@ -1,6 +1,6 @@
#pragma once #pragma once
#include <nano/store/final.hpp> #include <nano/store/final_vote.hpp>
namespace nano::store::rocksdb namespace nano::store::rocksdb
{ {
@ -21,9 +21,9 @@ public:
size_t count (store::transaction const & transaction_a) const override; size_t count (store::transaction const & transaction_a) const override;
void clear (store::write_transaction const & transaction_a, nano::root const & root_a) override; void clear (store::write_transaction const & transaction_a, nano::root const & root_a) override;
void clear (store::write_transaction const & transaction_a) override; void clear (store::write_transaction const & transaction_a) override;
store::iterator<nano::qualified_root, nano::block_hash> begin (store::transaction const & transaction_a, nano::qualified_root const & root_a) const override; iterator begin (store::transaction const & transaction_a, nano::qualified_root const & root_a) const override;
store::iterator<nano::qualified_root, nano::block_hash> begin (store::transaction const & transaction_a) const override; iterator begin (store::transaction const & transaction_a) const override;
store::iterator<nano::qualified_root, nano::block_hash> end () const override; iterator end () const override;
void for_each_par (std::function<void (store::read_transaction const &, store::iterator<nano::qualified_root, nano::block_hash>, store::iterator<nano::qualified_root, nano::block_hash>)> const & action_a) const override; void for_each_par (std::function<void (store::read_transaction const &, iterator, iterator)> const & action_a) const override;
}; };
} // namespace nano::store::rocksdb } // namespace nano::store::rocksdb

20
nano/store/rocksdb/iterator.hpp
View file

@ -33,8 +33,8 @@ class iterator : public iterator_impl<T, U>
public: public:
iterator () = default; iterator () = default;
iterator (::rocksdb::DB * db, store::transaction const & transaction_a, ::rocksdb::ColumnFamilyHandle * handle_a, db_val const * val_a, bool const direction_asc) : iterator (::rocksdb::DB * db, transaction const & transaction_a, ::rocksdb::ColumnFamilyHandle * handle_a, db_val const * val_a, bool const direction_asc) :
nano::store::iterator_impl<T, U> (transaction_a) iterator_impl<T, U> (transaction_a)
{ {
// Don't fill the block cache for any blocks read as a result of an iterator // Don't fill the block cache for any blocks read as a result of an iterator
if (is_read (transaction_a)) if (is_read (transaction_a))
@ -79,16 +79,16 @@ public:
{ {
} }
iterator (nano::store::rocksdb::iterator<T, U> && other_a) iterator (iterator<T, U> && other_a)
{ {
cursor = other_a.cursor; cursor = other_a.cursor;
other_a.cursor = nullptr; other_a.cursor = nullptr;
current = other_a.current; current = other_a.current;
} }
iterator (nano::store::rocksdb::iterator<T, U> const &) = delete; iterator (iterator<T, U> const &) = delete;
store::iterator_impl<T, U> & operator++ () override iterator_impl<T, U> & operator++ () override
{ {
cursor->Next (); cursor->Next ();
if (cursor->Valid ()) if (cursor->Valid ())
@ -109,7 +109,7 @@ public:
return *this; return *this;
} }
store::iterator_impl<T, U> & operator-- () override iterator_impl<T, U> & operator-- () override
{ {
cursor->Prev (); cursor->Prev ();
if (cursor->Valid ()) if (cursor->Valid ())
@ -135,9 +135,9 @@ public:
return &current; return &current;
} }
bool operator== (store::iterator_impl<T, U> const & base_a) const override bool operator== (iterator_impl<T, U> const & base_a) const override
{ {
auto const other_a (boost::polymorphic_downcast<nano::store::rocksdb::iterator<T, U> const *> (&base_a)); auto const other_a (boost::polymorphic_downcast<iterator<T, U> const *> (&base_a));
if (!current.first.data () && !other_a->current.first.data ()) if (!current.first.data () && !other_a->current.first.data ())
{ {
@ -187,13 +187,13 @@ public:
current.second = nano::store::rocksdb::db_val{}; current.second = nano::store::rocksdb::db_val{};
debug_assert (is_end_sentinal ()); debug_assert (is_end_sentinal ());
} }
nano::store::rocksdb::iterator<T, U> & operator= (nano::store::rocksdb::iterator<T, U> && other_a) iterator<T, U> & operator= (iterator<T, U> && other_a)
{ {
cursor = std::move (other_a.cursor); cursor = std::move (other_a.cursor);
current = other_a.current; current = other_a.current;
return *this; return *this;
} }
store::iterator_impl<T, U> & operator= (store::iterator_impl<T, U> const &) = delete; iterator_impl<T, U> & operator= (iterator_impl<T, U> const &) = delete;
std::unique_ptr<::rocksdb::Iterator> cursor; std::unique_ptr<::rocksdb::Iterator> cursor;
std::pair<nano::store::rocksdb::db_val, nano::store::rocksdb::db_val> current; std::pair<nano::store::rocksdb::db_val, nano::store::rocksdb::db_val> current;

8
nano/store/rocksdb/online_weight.cpp
View file

@ -18,19 +18,19 @@ void nano::store::rocksdb::online_weight::del (store::write_transaction const &
store.release_assert_success (status); store.release_assert_success (status);
} }
nano::store::iterator<uint64_t, nano::amount> nano::store::rocksdb::online_weight::begin (store::transaction const & transaction) const auto nano::store::rocksdb::online_weight::begin (store::transaction const & transaction) const -> iterator
{ {
return store.make_iterator<uint64_t, nano::amount> (transaction, tables::online_weight); return store.make_iterator<uint64_t, nano::amount> (transaction, tables::online_weight);
} }
nano::store::iterator<uint64_t, nano::amount> nano::store::rocksdb::online_weight::rbegin (store::transaction const & transaction) const auto nano::store::rocksdb::online_weight::rbegin (store::transaction const & transaction) const -> iterator
{ {
return store.make_iterator<uint64_t, nano::amount> (transaction, tables::online_weight, false); return store.make_iterator<uint64_t, nano::amount> (transaction, tables::online_weight, false);
} }
nano::store::iterator<uint64_t, nano::amount> nano::store::rocksdb::online_weight::end () const auto nano::store::rocksdb::online_weight::end () const -> iterator
{ {
return store::iterator<uint64_t, nano::amount> (nullptr); return iterator{ nullptr };
} }
size_t nano::store::rocksdb::online_weight::count (store::transaction const & transaction) const size_t nano::store::rocksdb::online_weight::count (store::transaction const & transaction) const

6
nano/store/rocksdb/online_weight.hpp
View file

@ -17,9 +17,9 @@ public:
explicit online_weight (nano::store::rocksdb::component & store_a); explicit online_weight (nano::store::rocksdb::component & store_a);
void put (store::write_transaction const & transaction_a, uint64_t time_a, nano::amount const & amount_a) override; void put (store::write_transaction const & transaction_a, uint64_t time_a, nano::amount const & amount_a) override;
void del (store::write_transaction const & transaction_a, uint64_t time_a) override; void del (store::write_transaction const & transaction_a, uint64_t time_a) override;
store::iterator<uint64_t, nano::amount> begin (store::transaction const & transaction_a) const override; iterator begin (store::transaction const & transaction_a) const override;
store::iterator<uint64_t, nano::amount> rbegin (store::transaction const & transaction_a) const override; iterator rbegin (store::transaction const & transaction_a) const override;
store::iterator<uint64_t, nano::amount> end () const override; iterator end () const override;
size_t count (store::transaction const & transaction_a) const override; size_t count (store::transaction const & transaction_a) const override;
void clear (store::write_transaction const & transaction_a) override; void clear (store::write_transaction const & transaction_a) override;
}; };

6
nano/store/rocksdb/peer.cpp
View file

@ -45,12 +45,12 @@ void nano::store::rocksdb::peer::clear (store::write_transaction const & transac
store.release_assert_success (status); store.release_assert_success (status);
} }
nano::store::iterator<nano::endpoint_key, nano::millis_t> nano::store::rocksdb::peer::begin (store::transaction const & transaction) const auto nano::store::rocksdb::peer::begin (store::transaction const & transaction) const -> iterator
{ {
return store.make_iterator<nano::endpoint_key, nano::millis_t> (transaction, tables::peers); return store.make_iterator<nano::endpoint_key, nano::millis_t> (transaction, tables::peers);
} }
nano::store::iterator<nano::endpoint_key, nano::millis_t> nano::store::rocksdb::peer::end () const auto nano::store::rocksdb::peer::end () const -> iterator
{ {
return store::iterator<nano::endpoint_key, nano::millis_t> (nullptr); return iterator{ nullptr };
} }

4
nano/store/rocksdb/peer.hpp
View file

@ -21,7 +21,7 @@ public:
bool exists (store::transaction const &, nano::endpoint_key const & endpoint) const override; bool exists (store::transaction const &, nano::endpoint_key const & endpoint) const override;
size_t count (store::transaction const &) const override; size_t count (store::transaction const &) const override;
void clear (store::write_transaction const &) override; void clear (store::write_transaction const &) override;
store::iterator<nano::endpoint_key, nano::millis_t> begin (store::transaction const &) const override; iterator begin (store::transaction const &) const override;
store::iterator<nano::endpoint_key, nano::millis_t> end () const override; iterator end () const override;
}; };
} // namespace nano::store::rocksdb } // namespace nano::store::rocksdb

10
nano/store/rocksdb/pending.cpp
View file

@ -45,22 +45,22 @@ bool nano::store::rocksdb::pending::any (store::transaction const & transaction_
return iterator != end () && nano::pending_key (iterator->first).account == account_a; return iterator != end () && nano::pending_key (iterator->first).account == account_a;
} }
nano::store::iterator<nano::pending_key, nano::pending_info> nano::store::rocksdb::pending::begin (store::transaction const & transaction_a, nano::pending_key const & key_a) const auto nano::store::rocksdb::pending::begin (store::transaction const & transaction_a, nano::pending_key const & key_a) const -> iterator
{ {
return store.template make_iterator<nano::pending_key, nano::pending_info> (transaction_a, tables::pending, key_a); return store.template make_iterator<nano::pending_key, nano::pending_info> (transaction_a, tables::pending, key_a);
} }
nano::store::iterator<nano::pending_key, nano::pending_info> nano::store::rocksdb::pending::begin (store::transaction const & transaction_a) const auto nano::store::rocksdb::pending::begin (store::transaction const & transaction_a) const -> iterator
{ {
return store.template make_iterator<nano::pending_key, nano::pending_info> (transaction_a, tables::pending); return store.template make_iterator<nano::pending_key, nano::pending_info> (transaction_a, tables::pending);
} }
nano::store::iterator<nano::pending_key, nano::pending_info> nano::store::rocksdb::pending::end () const auto nano::store::rocksdb::pending::end () const -> iterator
{ {
return store::iterator<nano::pending_key, nano::pending_info> (nullptr); return iterator{ nullptr };
} }
void nano::store::rocksdb::pending::for_each_par (std::function<void (store::read_transaction const &, store::iterator<nano::pending_key, nano::pending_info>, store::iterator<nano::pending_key, nano::pending_info>)> const & action_a) const void nano::store::rocksdb::pending::for_each_par (std::function<void (store::read_transaction const &, iterator, iterator)> const & action_a) const
{ {
parallel_traversal<nano::uint512_t> ( parallel_traversal<nano::uint512_t> (
[&action_a, this] (nano::uint512_t const & start, nano::uint512_t const & end, bool const is_last) { [&action_a, this] (nano::uint512_t const & start, nano::uint512_t const & end, bool const is_last) {

8
nano/store/rocksdb/pending.hpp
View file

@ -16,9 +16,9 @@ public:
std::optional<nano::pending_info> get (store::transaction const & transaction_a, nano::pending_key const & key_a) override; std::optional<nano::pending_info> get (store::transaction const & transaction_a, nano::pending_key const & key_a) override;
bool exists (store::transaction const & transaction_a, nano::pending_key const & key_a) override; bool exists (store::transaction const & transaction_a, nano::pending_key const & key_a) override;
bool any (store::transaction const & transaction_a, nano::account const & account_a) override; bool any (store::transaction const & transaction_a, nano::account const & account_a) override;
store::iterator<nano::pending_key, nano::pending_info> begin (store::transaction const & transaction_a, nano::pending_key const & key_a) const override; iterator begin (store::transaction const & transaction_a, nano::pending_key const & key_a) const override;
store::iterator<nano::pending_key, nano::pending_info> begin (store::transaction const & transaction_a) const override; iterator begin (store::transaction const & transaction_a) const override;
store::iterator<nano::pending_key, nano::pending_info> end () const override; iterator end () const override;
void for_each_par (std::function<void (store::read_transaction const &, store::iterator<nano::pending_key, nano::pending_info>, store::iterator<nano::pending_key, nano::pending_info>)> const & action_a) const override; void for_each_par (std::function<void (store::read_transaction const &, iterator, iterator)> const & action_a) const override;
}; };
} // namespace nano::store::rocksdb } // namespace nano::store::rocksdb

10
nano/store/rocksdb/pruned.cpp
View file

@ -45,22 +45,22 @@ void nano::store::rocksdb::pruned::clear (store::write_transaction const & trans
store.release_assert_success (status); store.release_assert_success (status);
} }
nano::store::iterator<nano::block_hash, std::nullptr_t> nano::store::rocksdb::pruned::begin (store::transaction const & transaction_a, nano::block_hash const & hash_a) const auto nano::store::rocksdb::pruned::begin (store::transaction const & transaction_a, nano::block_hash const & hash_a) const -> iterator
{ {
return store.make_iterator<nano::block_hash, std::nullptr_t> (transaction_a, tables::pruned, hash_a); return store.make_iterator<nano::block_hash, std::nullptr_t> (transaction_a, tables::pruned, hash_a);
} }
nano::store::iterator<nano::block_hash, std::nullptr_t> nano::store::rocksdb::pruned::begin (store::transaction const & transaction_a) const auto nano::store::rocksdb::pruned::begin (store::transaction const & transaction_a) const -> iterator
{ {
return store.make_iterator<nano::block_hash, std::nullptr_t> (transaction_a, tables::pruned); return store.make_iterator<nano::block_hash, std::nullptr_t> (transaction_a, tables::pruned);
} }
nano::store::iterator<nano::block_hash, std::nullptr_t> nano::store::rocksdb::pruned::end () const auto nano::store::rocksdb::pruned::end () const -> iterator
{ {
return store::iterator<nano::block_hash, std::nullptr_t> (nullptr); return iterator{ nullptr };
} }
void nano::store::rocksdb::pruned::for_each_par (std::function<void (store::read_transaction const &, store::iterator<nano::block_hash, std::nullptr_t>, store::iterator<nano::block_hash, std::nullptr_t>)> const & action_a) const void nano::store::rocksdb::pruned::for_each_par (std::function<void (store::read_transaction const &, iterator, iterator)> const & action_a) const
{ {
parallel_traversal<nano::uint256_t> ( parallel_traversal<nano::uint256_t> (
[&action_a, this] (nano::uint256_t const & start, nano::uint256_t const & end, bool const is_last) { [&action_a, this] (nano::uint256_t const & start, nano::uint256_t const & end, bool const is_last) {

8
nano/store/rocksdb/pruned.hpp
View file

@ -21,9 +21,9 @@ public:
nano::block_hash random (store::transaction const & transaction_a) override; nano::block_hash random (store::transaction const & transaction_a) override;
size_t count (store::transaction const & transaction_a) const override; size_t count (store::transaction const & transaction_a) const override;
void clear (store::write_transaction const & transaction_a) override; void clear (store::write_transaction const & transaction_a) override;
store::iterator<nano::block_hash, std::nullptr_t> begin (store::transaction const & transaction_a, nano::block_hash const & hash_a) const override; iterator begin (store::transaction const & transaction_a, nano::block_hash const & hash_a) const override;
store::iterator<nano::block_hash, std::nullptr_t> begin (store::transaction const & transaction_a) const override; iterator begin (store::transaction const & transaction_a) const override;
store::iterator<nano::block_hash, std::nullptr_t> end () const override; iterator end () const override;
void for_each_par (std::function<void (store::read_transaction const &, store::iterator<nano::block_hash, std::nullptr_t>, store::iterator<nano::block_hash, std::nullptr_t>)> const & action_a) const override; void for_each_par (std::function<void (store::read_transaction const &, iterator, iterator)> const & action_a) const override;
}; };
} // namespace nano::store::rocksdb } // namespace nano::store::rocksdb

10
nano/store/rocksdb/rep_weight.cpp
View file

@ -42,22 +42,22 @@ void nano::store::rocksdb::rep_weight::del (store::write_transaction const & txn
store.release_assert_success (status); store.release_assert_success (status);
} }
nano::store::iterator<nano::account, nano::uint128_union> nano::store::rocksdb::rep_weight::begin (store::transaction const & txn_a, nano::account const & representative_a) const auto nano::store::rocksdb::rep_weight::begin (store::transaction const & txn_a, nano::account const & representative_a) const -> iterator
{ {
return store.make_iterator<nano::account, nano::uint128_union> (txn_a, tables::rep_weights, representative_a); return store.make_iterator<nano::account, nano::uint128_union> (txn_a, tables::rep_weights, representative_a);
} }
nano::store::iterator<nano::account, nano::uint128_union> nano::store::rocksdb::rep_weight::begin (store::transaction const & txn_a) const auto nano::store::rocksdb::rep_weight::begin (store::transaction const & txn_a) const -> iterator
{ {
return store.make_iterator<nano::account, nano::uint128_union> (txn_a, tables::rep_weights); return store.make_iterator<nano::account, nano::uint128_union> (txn_a, tables::rep_weights);
} }
nano::store::iterator<nano::account, nano::uint128_union> nano::store::rocksdb::rep_weight::end () const auto nano::store::rocksdb::rep_weight::end () const -> iterator
{ {
return store::iterator<nano::account, nano::uint128_union> (nullptr); return iterator{ nullptr };
} }
void nano::store::rocksdb::rep_weight::for_each_par (std::function<void (store::read_transaction const &, store::iterator<nano::account, nano::uint128_union>, store::iterator<nano::account, nano::uint128_union>)> const & action_a) const void nano::store::rocksdb::rep_weight::for_each_par (std::function<void (store::read_transaction const &, iterator, iterator)> const & action_a) const
{ {
parallel_traversal<nano::uint256_t> ( parallel_traversal<nano::uint256_t> (
[&action_a, this] (nano::uint256_t const & start, nano::uint256_t const & end, bool const is_last) { [&action_a, this] (nano::uint256_t const & start, nano::uint256_t const & end, bool const is_last) {

8
nano/store/rocksdb/rep_weight.hpp
View file

@ -19,9 +19,9 @@ public:
nano::uint128_t get (store::transaction const & txn_a, nano::account const & representative_a) override; nano::uint128_t get (store::transaction const & txn_a, nano::account const & representative_a) override;
void put (store::write_transaction const & txn_a, nano::account const & representative_a, nano::uint128_t const & weight_a) override; void put (store::write_transaction const & txn_a, nano::account const & representative_a, nano::uint128_t const & weight_a) override;
void del (store::write_transaction const &, nano::account const & representative_a) override; void del (store::write_transaction const &, nano::account const & representative_a) override;
store::iterator<nano::account, nano::uint128_union> begin (store::transaction const & txn_a, nano::account const & representative_a) const override; iterator begin (store::transaction const & txn_a, nano::account const & representative_a) const override;
store::iterator<nano::account, nano::uint128_union> begin (store::transaction const & txn_a) const override; iterator begin (store::transaction const & txn_a) const override;
store::iterator<nano::account, nano::uint128_union> end () const override; iterator end () const override;
void for_each_par (std::function<void (store::read_transaction const &, store::iterator<nano::account, nano::uint128_union>, store::iterator<nano::account, nano::uint128_union>)> const & action_a) const override; void for_each_par (std::function<void (store::read_transaction const &, iterator, iterator)> const & action_a) const override;
}; };
} }

2
nano/test_common/system.cpp
View file

@ -532,7 +532,7 @@ void nano::test::system::generate_send_existing (nano::node & node_a, std::vecto
nano::account account; nano::account account;
random_pool::generate_block (account.bytes.data (), sizeof (account.bytes)); random_pool::generate_block (account.bytes.data (), sizeof (account.bytes));
auto transaction = node_a.ledger.tx_begin_read (); auto transaction = node_a.ledger.tx_begin_read ();
store::iterator<nano::account, nano::account_info> entry (node_a.store.account.begin (transaction, account)); auto entry = node_a.store.account.begin (transaction, account);
if (entry == node_a.store.account.end ()) if (entry == node_a.store.account.end ())
{ {
entry = node_a.store.account.begin (transaction); entry = node_a.store.account.begin (transaction);