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);
using opened_account_versions_t = decltype (opened_account_versions_shared)::value_type;
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
opened_account_versions_t opened_account_versions_l (epoch_count);
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;
using unopened_highest_pending_t = decltype (unopened_highest_pending_shared)::value_type;
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
unopened_highest_pending_t unopened_highest_pending_l;
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::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;
}
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;
}
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));
store::iterator<nano::account, nano::wallet_value> end (nullptr);
iterator end{ nullptr };
if (result != end)
{
if (result->first == key)
@ -1787,10 +1787,11 @@ nano::store::iterator<nano::account, nano::wallet_value> nano::wallet_store::fin
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) :
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
{
public:
using iterator = store::iterator<nano::account, nano::wallet_value>;
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 &, std::string const &);
@ -89,10 +92,10 @@ public:
bool fetch (store::transaction const &, nano::account const &, nano::raw_key &);
bool exists (store::transaction const &, nano::account const &);
void destroy (store::transaction const &);
store::iterator<nano::account, nano::wallet_value> find (store::transaction const &, nano::account const &);
store::iterator<nano::account, nano::wallet_value> begin (store::transaction const &, nano::account const &);
store::iterator<nano::account, nano::wallet_value> begin (store::transaction const &);
store::iterator<nano::account, nano::wallet_value> end ();
iterator find (store::transaction const &, nano::account const &);
iterator begin (store::transaction const &, nano::account const &);
iterator begin (store::transaction const &);
iterator end ();
void derive_key (nano::raw_key &, store::transaction const &, std::string const &);
void serialize_json (store::transaction const &, std::string &);
void write_backup (store::transaction const &, std::filesystem::path const &);

10
nano/secure/ledger.cpp
View file

@ -14,7 +14,7 @@
#include <nano/store/block.hpp>
#include <nano/store/component.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/peer.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)
{
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 account_count_l{ 0 };
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 (
[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 };
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)
{
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);
for (; i != n; ++i)
{
@ -1523,4 +1523,4 @@ nano::container_info nano::ledger::container_info () const
info.put ("bootstrap_weights", bootstrap_weights);
info.add ("rep_weights", cache.rep_weights.container_info ());
return info;
}
}

5
nano/store/CMakeLists.txt
View file

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

13
nano/store/account.hpp
View file

@ -19,6 +19,9 @@ namespace nano::store
*/
class account
{
public:
using iterator = store::iterator<nano::account, nano::account_info>;
public:
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;
@ -26,10 +29,10 @@ public:
virtual void del (store::write_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 iterator<nano::account, nano::account_info> begin (store::transaction const &, nano::account const &) const = 0;
virtual iterator<nano::account, nano::account_info> begin (store::transaction const &) const = 0;
virtual iterator<nano::account, nano::account_info> rbegin (store::transaction const &) const = 0;
virtual iterator<nano::account, nano::account_info> 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 iterator begin (store::transaction const &, nano::account const &) const = 0;
virtual iterator begin (store::transaction const &) const = 0;
virtual iterator rbegin (store::transaction const &) const = 0;
virtual iterator end () const = 0;
virtual void for_each_par (std::function<void (store::read_transaction const &, iterator, iterator)> const &) const = 0;
};
} // namespace nano::store

11
nano/store/block.hpp
View file

@ -21,6 +21,9 @@ namespace nano::store
*/
class block
{
public:
using iterator = store::iterator<nano::block_hash, block_w_sideband>;
public:
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;
@ -31,9 +34,9 @@ public:
virtual void del (store::write_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 iterator<nano::block_hash, block_w_sideband> 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<nano::block_hash, block_w_sideband> 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 iterator begin (store::transaction const &, nano::block_hash const &) const = 0;
virtual iterator begin (store::transaction const &) const = 0;
virtual iterator end () const = 0;
virtual void for_each_par (std::function<void (store::read_transaction const &, iterator, iterator)> const & action_a) const = 0;
};
} // namespace nano::store

11
nano/store/confirmation_height.hpp
View file

@ -17,6 +17,9 @@ namespace nano::store
*/
class confirmation_height
{
public:
using iterator = store::iterator<nano::account, nano::confirmation_height_info>;
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;
@ -32,9 +35,9 @@ public:
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 &) = 0;
virtual iterator<nano::account, nano::confirmation_height_info> 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<nano::account, nano::confirmation_height_info> 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 iterator begin (store::transaction const & transaction_a, nano::account const & account_a) const = 0;
virtual iterator begin (store::transaction const & transaction_a) const = 0;
virtual iterator end () const = 0;
virtual void for_each_par (std::function<void (store::read_transaction const &, iterator, iterator)> const &) const = 0;
};
} // 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
{
public:
using iterator = store::iterator<nano::qualified_root, nano::block_hash>;
public:
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;
@ -24,9 +27,9 @@ public:
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 &) = 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 store::iterator<nano::qualified_root, nano::block_hash> begin (store::transaction const & transaction_a) const = 0;
virtual store::iterator<nano::qualified_root, nano::block_hash> 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 iterator begin (store::transaction const & transaction_a, nano::qualified_root const & root_a) const = 0;
virtual iterator begin (store::transaction const & transaction_a) const = 0;
virtual iterator end () const = 0;
virtual void for_each_par (std::function<void (store::read_transaction const &, iterator, iterator)> const & action_a) const = 0;
};
} // namespace nano::store

10
nano/store/iterator_impl.hpp
View file

@ -11,14 +11,14 @@ template <typename T, typename U>
class iterator_impl
{
public:
explicit iterator_impl (nano::store::transaction const & transaction_a) :
transaction{ transaction_a },
explicit iterator_impl (transaction const & transaction_a) :
txn{ transaction_a },
transaction_epoch{ transaction_a.epoch () }
{
}
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;
@ -37,7 +37,7 @@ public:
}
protected:
nano::store::transaction const & transaction;
nano::store::transaction::epoch_t const transaction_epoch;
transaction const & txn;
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);
}
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);
}
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);
}
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);
}
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> (
[&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;
bool exists (store::transaction const & transaction_a, nano::account const & account_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;
store::iterator<nano::account, nano::account_info> begin (store::transaction const & transaction_a) const override;
store::iterator<nano::account, nano::account_info> rbegin (store::transaction const & transaction_a) const override;
store::iterator<nano::account, nano::account_info> 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;
iterator begin (store::transaction const & transaction_a, nano::account const & account_a) const override;
iterator begin (store::transaction const & transaction_a) const override;
iterator rbegin (store::transaction const & transaction_a) const override;
iterator end () 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)

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);
}
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);
}
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);
}
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> (
[&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;
bool exists (store::transaction const & transaction_a, nano::block_hash const & hash_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;
store::iterator<nano::block_hash, nano::store::block_w_sideband> 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;
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;
iterator begin (store::transaction const & transaction_a) const override;
iterator begin (store::transaction const & transaction_a, nano::block_hash const & hash_a) const override;
iterator end () 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)

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);
}
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);
}
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);
}
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> (
[&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;
void clear (store::write_transaction const & transaction_a, nano::account const & account_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;
store::iterator<nano::account, nano::confirmation_height_info> begin (store::transaction const & transaction_a) const override;
store::iterator<nano::account, nano::confirmation_height_info> 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;
iterator begin (store::transaction const & transaction_a, nano::account const & account_a) const override;
iterator begin (store::transaction const & transaction_a) const override;
iterator end () 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

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);
}
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);
}
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);
}
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> (
[&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
#include <nano/store/final.hpp>
#include <nano/store/final_vote.hpp>
#include <lmdb/libraries/liblmdb/lmdb.h>
@ -23,10 +23,10 @@ public:
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) override;
store::iterator<nano::qualified_root, nano::block_hash> 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;
store::iterator<nano::qualified_root, nano::block_hash> 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;
iterator begin (store::transaction const & transaction_a, nano::qualified_root const & root_a) const override;
iterator begin (store::transaction const & transaction_a) const override;
iterator end () 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.

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

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

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

@ -15,9 +15,9 @@ public:
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 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;
store::iterator<uint64_t, nano::amount> rbegin (store::transaction const & transaction_a) const override;
store::iterator<uint64_t, nano::amount> end () const override;
iterator begin (store::transaction const & transaction_a) const override;
iterator rbegin (store::transaction const & transaction_a) const override;
iterator end () const override;
size_t count (store::transaction const & transaction_a) const 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);
}
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);
}
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;
size_t count (store::transaction const &) const override;
void clear (store::write_transaction const &) override;
store::iterator<nano::endpoint_key, nano::millis_t> begin (store::transaction const &) const override;
store::iterator<nano::endpoint_key, nano::millis_t> end () const override;
iterator begin (store::transaction const &) const override;
iterator end () const override;
/*
* 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;
}
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);
}
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);
}
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> (
[&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;
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;
store::iterator<nano::pending_key, nano::pending_info> 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;
store::iterator<nano::pending_key, nano::pending_info> 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;
iterator begin (store::transaction const & transaction_a, nano::pending_key const & key_a) const override;
iterator begin (store::transaction const & transaction_a) const override;
iterator end () 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)

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);
}
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);
}
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);
}
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> (
[&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;
size_t count (store::transaction const & transaction_a) const 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;
store::iterator<nano::block_hash, std::nullptr_t> begin (store::transaction const & transaction_a) const override;
store::iterator<nano::block_hash, std::nullptr_t> 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;
iterator begin (store::transaction const & transaction_a, nano::block_hash const & hash_a) const override;
iterator begin (store::transaction const & transaction_a) const override;
iterator end () const override;
void for_each_par (std::function<void (store::read_transaction const &, iterator, iterator)> const & action_a) const override;
/**
* 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);
}
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);
}
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);
}
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> (
[&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;
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;
store::iterator<nano::account, nano::uint128_union> 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;
store::iterator<nano::account, nano::uint128_union> 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;
iterator begin (store::transaction const & transaction_a, nano::account const & representative_a) const override;
iterator begin (store::transaction const & transaction_a) const override;
iterator end () const override;
void for_each_par (std::function<void (store::read_transaction const &, iterator, iterator)> const & action_a) const override;
/**
* Representative weights

9
nano/store/online_weight.hpp
View file

@ -17,12 +17,15 @@ namespace nano::store
*/
class online_weight
{
public:
using iterator = store::iterator<uint64_t, nano::amount>;
public:
virtual void put (store::write_transaction const &, uint64_t, nano::amount const &) = 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 store::iterator<uint64_t, nano::amount> rbegin (store::transaction const &) const = 0;
virtual store::iterator<uint64_t, nano::amount> end () const = 0;
virtual iterator begin (store::transaction const &) const = 0;
virtual iterator rbegin (store::transaction const &) const = 0;
virtual iterator end () const = 0;
virtual size_t count (store::transaction const &) 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
{
public:
using iterator = store::iterator<nano::endpoint_key, nano::millis_t>;
public:
/// 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;
@ -25,7 +28,7 @@ public:
virtual bool exists (store::transaction const &, nano::endpoint_key const & endpoint) const = 0;
virtual size_t count (store::transaction const &) 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 store::iterator<nano::endpoint_key, nano::millis_t> end () const = 0;
virtual iterator begin (store::transaction const &) const = 0;
virtual iterator end () const = 0;
};
} // 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 bool exists (store::transaction const &, nano::pending_key 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 store::iterator<nano::pending_key, nano::pending_info> begin (store::transaction const &) const = 0;
virtual store::iterator<nano::pending_key, nano::pending_info> 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 iterator begin (store::transaction const &, nano::pending_key const &) const = 0;
virtual iterator begin (store::transaction const &) const = 0;
virtual iterator end () const = 0;
virtual void for_each_par (std::function<void (store::read_transaction const &, iterator, iterator)> const & action_a) const = 0;
};
} // namespace nano::store

11
nano/store/pruned.hpp
View file

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

11
nano/store/rep_weight.hpp
View file

@ -18,15 +18,18 @@ namespace nano::store
*/
class rep_weight
{
public:
using iterator = store::iterator<nano::account, nano::uint128_union>;
public:
virtual ~rep_weight (){};
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 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 store::iterator<nano::account, nano::uint128_union> 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 store::iterator<nano::account, nano::uint128_union> 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 iterator begin (store::transaction const & transaction_a, nano::account const & representative_a) const = 0;
virtual iterator begin (store::transaction const & transaction_a) const = 0;
virtual iterator end () 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);
}
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);
}
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);
}
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);
}
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> (
[&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;
bool exists (store::transaction const & transaction_a, nano::account const & account_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;
store::iterator<nano::account, nano::account_info> begin (store::transaction const & transaction_a) const override;
store::iterator<nano::account, nano::account_info> rbegin (store::transaction const & transaction_a) const override;
store::iterator<nano::account, nano::account_info> 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;
iterator begin (store::transaction const & transaction_a, nano::account const & account_a) const override;
iterator begin (store::transaction const & transaction_a) const override;
iterator rbegin (store::transaction const & transaction_a) const override;
iterator end () const override;
void for_each_par (std::function<void (store::read_transaction const &, iterator, iterator)> const & action_a) const override;
};
} // 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);
}
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);
}
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);
}
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> (
[&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 }
{
}
void nano::block_predecessor_rocksdb_set::fill_value (nano::block const & block_a)
{
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));
block_store.raw_put (transaction, data, block_a.previous ());
}
void nano::block_predecessor_rocksdb_set::send_block (nano::send_block const & block_a)
{
fill_value (block_a);
}
void nano::block_predecessor_rocksdb_set::receive_block (nano::receive_block const & block_a)
{
fill_value (block_a);
}
void nano::block_predecessor_rocksdb_set::open_block (nano::open_block const & block_a)
{
// Open blocks don't have a predecessor
}
void nano::block_predecessor_rocksdb_set::change_block (nano::change_block const & block_a)
{
fill_value (block_a);
}
void nano::block_predecessor_rocksdb_set::state_block (nano::state_block const & block_a)
{
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;
bool exists (store::transaction const & transaction_a, nano::block_hash const & hash_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;
store::iterator<nano::block_hash, nano::store::block_w_sideband> 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;
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;
iterator begin (store::transaction const & transaction_a) const override;
iterator begin (store::transaction const & transaction_a, nano::block_hash const & hash_a) const override;
iterator end () const override;
void for_each_par (std::function<void (store::read_transaction const &, iterator, iterator)> const & action_a) const override;
protected:
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);
}
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);
}
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);
}
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> (
[&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;
void clear (store::write_transaction const & transaction_a, nano::account const & account_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;
store::iterator<nano::account, nano::confirmation_height_info> begin (store::transaction const & transaction_a) const override;
store::iterator<nano::account, nano::confirmation_height_info> 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;
iterator begin (store::transaction const & transaction_a, nano::account const & account_a) const override;
iterator begin (store::transaction const & transaction_a) const override;
iterator end () const override;
void for_each_par (std::function<void (store::read_transaction const &, iterator, iterator)> const & action_a) const override;
};
} // 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);
}
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);
}
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);
}
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> (
[&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
#include <nano/store/final.hpp>
#include <nano/store/final_vote.hpp>
namespace nano::store::rocksdb
{
@ -21,9 +21,9 @@ public:
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) override;
store::iterator<nano::qualified_root, nano::block_hash> 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;
store::iterator<nano::qualified_root, nano::block_hash> 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;
iterator begin (store::transaction const & transaction_a, nano::qualified_root const & root_a) const override;
iterator begin (store::transaction const & transaction_a) const override;
iterator end () const override;
void for_each_par (std::function<void (store::read_transaction const &, iterator, iterator)> const & action_a) const override;
};
} // namespace nano::store::rocksdb

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

@ -33,8 +33,8 @@ class iterator : public iterator_impl<T, U>
public:
iterator () = default;
iterator (::rocksdb::DB * db, store::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 (::rocksdb::DB * db, transaction const & transaction_a, ::rocksdb::ColumnFamilyHandle * handle_a, db_val const * val_a, bool const direction_asc) :
iterator_impl<T, U> (transaction_a)
{
// Don't fill the block cache for any blocks read as a result of an iterator
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;
other_a.cursor = nullptr;
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 ();
if (cursor->Valid ())
@ -109,7 +109,7 @@ public:
return *this;
}
store::iterator_impl<T, U> & operator-- () override
iterator_impl<T, U> & operator-- () override
{
cursor->Prev ();
if (cursor->Valid ())
@ -135,9 +135,9 @@ public:
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 ())
{
@ -187,13 +187,13 @@ public:
current.second = nano::store::rocksdb::db_val{};
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);
current = other_a.current;
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::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);
}
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);
}
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);
}
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

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

@ -17,9 +17,9 @@ public:
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 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;
store::iterator<uint64_t, nano::amount> rbegin (store::transaction const & transaction_a) const override;
store::iterator<uint64_t, nano::amount> end () const override;
iterator begin (store::transaction const & transaction_a) const override;
iterator rbegin (store::transaction const & transaction_a) const override;
iterator end () const override;
size_t count (store::transaction const & transaction_a) const 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);
}
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);
}
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;
size_t count (store::transaction const &) const override;
void clear (store::write_transaction const &) override;
store::iterator<nano::endpoint_key, nano::millis_t> begin (store::transaction const &) const override;
store::iterator<nano::endpoint_key, nano::millis_t> end () const override;
iterator begin (store::transaction const &) const override;
iterator end () const override;
};
} // 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;
}
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);
}
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);
}
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> (
[&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;
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;
store::iterator<nano::pending_key, nano::pending_info> 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;
store::iterator<nano::pending_key, nano::pending_info> 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;
iterator begin (store::transaction const & transaction_a, nano::pending_key const & key_a) const override;
iterator begin (store::transaction const & transaction_a) const override;
iterator end () const override;
void for_each_par (std::function<void (store::read_transaction const &, iterator, iterator)> const & action_a) const override;
};
} // 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);
}
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);
}
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);
}
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> (
[&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;
size_t count (store::transaction const & transaction_a) const 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;
store::iterator<nano::block_hash, std::nullptr_t> begin (store::transaction const & transaction_a) const override;
store::iterator<nano::block_hash, std::nullptr_t> 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;
iterator begin (store::transaction const & transaction_a, nano::block_hash const & hash_a) const override;
iterator begin (store::transaction const & transaction_a) const override;
iterator end () const override;
void for_each_par (std::function<void (store::read_transaction const &, iterator, iterator)> const & action_a) const override;
};
} // namespace nano::store::rocksdb

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

@ -42,26 +42,26 @@ void nano::store::rocksdb::rep_weight::del (store::write_transaction const & txn
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);
}
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);
}
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> (
[&action_a, this] (nano::uint256_t const & start, nano::uint256_t const & end, bool const is_last) {
auto transaction (this->store.tx_begin_read ());
action_a (transaction, this->begin (transaction, start), !is_last ? this->begin (transaction, end) : this->end ());
});
}
}

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;
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;
store::iterator<nano::account, nano::uint128_union> 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;
store::iterator<nano::account, nano::uint128_union> 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;
iterator begin (store::transaction const & txn_a, nano::account const & representative_a) const override;
iterator begin (store::transaction const & txn_a) const override;
iterator end () 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;
random_pool::generate_block (account.bytes.data (), sizeof (account.bytes));
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 ())
{
entry = node_a.store.account.begin (transaction);