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

Adding type aliases to store classes.

Browse source
This commit is contained in:
Colin LeMahieu 2024-10-10 14:28:29 +02:00
commit 635740a512
No known key found for this signature in database
GPG key ID: 43708520C8DFB938
48 changed files with 238 additions and 201 deletions
Download patch file Download diff file Expand all files Collapse all files

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 &);

1
nano/store/CMakeLists.txt
View file

@ -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

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

11
nano/store/final.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

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) {

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

@ -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.

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) {

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

@ -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

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;
};
}