mirror of
https://github.com/bitcoin/bitcoin.git
synced 2025-02-08 10:31:50 -05:00
Delete limitedmap as it is unused now
This commit is contained in:
Pieter Wuille
parent
cc16fff3e4
commit
86f50ed10f
5 changed files with 0 additions and 204 deletions
|
|
@ -151,7 +151,6 @@ BITCOIN_CORE_H = \
|
|||
interfaces/wallet.h \
|
||||
key.h \
|
||||
key_io.h \
|
||||
limitedmap.h \
|
||||
logging.h \
|
||||
logging/timer.h \
|
||||
memusage.h \
|
||||
|
|
|
|||
|
|
@ -236,7 +236,6 @@ BITCOIN_TESTS =\
|
|||
test/interfaces_tests.cpp \
|
||||
test/key_io_tests.cpp \
|
||||
test/key_tests.cpp \
|
||||
test/limitedmap_tests.cpp \
|
||||
test/logging_tests.cpp \
|
||||
test/dbwrapper_tests.cpp \
|
||||
test/validation_tests.cpp \
|
||||
|
|
|
|||
100
src/limitedmap.h
100
src/limitedmap.h
|
|
@ -1,100 +0,0 @@
|
|||
// Copyright (c) 2012-2018 The Bitcoin Core developers
|
||||
// Distributed under the MIT software license, see the accompanying
|
||||
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
|
||||
#ifndef BITCOIN_LIMITEDMAP_H
|
||||
#define BITCOIN_LIMITEDMAP_H
|
||||
|
||||
#include <assert.h>
|
||||
#include <map>
|
||||
|
||||
/** STL-like map container that only keeps the N elements with the highest value. */
|
||||
template <typename K, typename V>
|
||||
class limitedmap
|
||||
{
|
||||
public:
|
||||
typedef K key_type;
|
||||
typedef V mapped_type;
|
||||
typedef std::pair<const key_type, mapped_type> value_type;
|
||||
typedef typename std::map<K, V>::const_iterator const_iterator;
|
||||
typedef typename std::map<K, V>::size_type size_type;
|
||||
|
||||
protected:
|
||||
std::map<K, V> map;
|
||||
typedef typename std::map<K, V>::iterator iterator;
|
||||
std::multimap<V, iterator> rmap;
|
||||
typedef typename std::multimap<V, iterator>::iterator rmap_iterator;
|
||||
size_type nMaxSize;
|
||||
|
||||
public:
|
||||
explicit limitedmap(size_type nMaxSizeIn)
|
||||
{
|
||||
assert(nMaxSizeIn > 0);
|
||||
nMaxSize = nMaxSizeIn;
|
||||
}
|
||||
const_iterator begin() const { return map.begin(); }
|
||||
const_iterator end() const { return map.end(); }
|
||||
size_type size() const { return map.size(); }
|
||||
bool empty() const { return map.empty(); }
|
||||
const_iterator find(const key_type& k) const { return map.find(k); }
|
||||
size_type count(const key_type& k) const { return map.count(k); }
|
||||
void insert(const value_type& x)
|
||||
{
|
||||
std::pair<iterator, bool> ret = map.insert(x);
|
||||
if (ret.second) {
|
||||
if (map.size() > nMaxSize) {
|
||||
map.erase(rmap.begin()->second);
|
||||
rmap.erase(rmap.begin());
|
||||
}
|
||||
rmap.insert(make_pair(x.second, ret.first));
|
||||
}
|
||||
}
|
||||
void erase(const key_type& k)
|
||||
{
|
||||
iterator itTarget = map.find(k);
|
||||
if (itTarget == map.end())
|
||||
return;
|
||||
std::pair<rmap_iterator, rmap_iterator> itPair = rmap.equal_range(itTarget->second);
|
||||
for (rmap_iterator it = itPair.first; it != itPair.second; ++it)
|
||||
if (it->second == itTarget) {
|
||||
rmap.erase(it);
|
||||
map.erase(itTarget);
|
||||
return;
|
||||
}
|
||||
// Shouldn't ever get here
|
||||
assert(0);
|
||||
}
|
||||
void update(const_iterator itIn, const mapped_type& v)
|
||||
{
|
||||
// Using map::erase() with empty range instead of map::find() to get a non-const iterator,
|
||||
// since it is a constant time operation in C++11. For more details, see
|
||||
// https://stackoverflow.com/questions/765148/how-to-remove-constness-of-const-iterator
|
||||
iterator itTarget = map.erase(itIn, itIn);
|
||||
|
||||
if (itTarget == map.end())
|
||||
return;
|
||||
std::pair<rmap_iterator, rmap_iterator> itPair = rmap.equal_range(itTarget->second);
|
||||
for (rmap_iterator it = itPair.first; it != itPair.second; ++it)
|
||||
if (it->second == itTarget) {
|
||||
rmap.erase(it);
|
||||
itTarget->second = v;
|
||||
rmap.insert(make_pair(v, itTarget));
|
||||
return;
|
||||
}
|
||||
// Shouldn't ever get here
|
||||
assert(0);
|
||||
}
|
||||
size_type max_size() const { return nMaxSize; }
|
||||
size_type max_size(size_type s)
|
||||
{
|
||||
assert(s > 0);
|
||||
while (map.size() > s) {
|
||||
map.erase(rmap.begin()->second);
|
||||
rmap.erase(rmap.begin());
|
||||
}
|
||||
nMaxSize = s;
|
||||
return nMaxSize;
|
||||
}
|
||||
};
|
||||
|
||||
#endif // BITCOIN_LIMITEDMAP_H
|
||||
|
|
@ -14,7 +14,6 @@
|
|||
#include <compat.h>
|
||||
#include <crypto/siphash.h>
|
||||
#include <hash.h>
|
||||
#include <limitedmap.h>
|
||||
#include <net_permissions.h>
|
||||
#include <netaddress.h>
|
||||
#include <optional.h>
|
||||
|
|
|
|||
|
|
@ -1,101 +0,0 @@
|
|||
// Copyright (c) 2012-2019 The Bitcoin Core developers
|
||||
// Distributed under the MIT software license, see the accompanying
|
||||
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
|
||||
#include <limitedmap.h>
|
||||
|
||||
#include <test/util/setup_common.h>
|
||||
|
||||
#include <boost/test/unit_test.hpp>
|
||||
|
||||
BOOST_FIXTURE_TEST_SUITE(limitedmap_tests, BasicTestingSetup)
|
||||
|
||||
BOOST_AUTO_TEST_CASE(limitedmap_test)
|
||||
{
|
||||
// create a limitedmap capped at 10 items
|
||||
limitedmap<int, int> map(10);
|
||||
|
||||
// check that the max size is 10
|
||||
BOOST_CHECK(map.max_size() == 10);
|
||||
|
||||
// check that it's empty
|
||||
BOOST_CHECK(map.size() == 0);
|
||||
|
||||
// insert (-1, -1)
|
||||
map.insert(std::pair<int, int>(-1, -1));
|
||||
|
||||
// make sure that the size is updated
|
||||
BOOST_CHECK(map.size() == 1);
|
||||
|
||||
// make sure that the new item is in the map
|
||||
BOOST_CHECK(map.count(-1) == 1);
|
||||
|
||||
// insert 10 new items
|
||||
for (int i = 0; i < 10; i++) {
|
||||
map.insert(std::pair<int, int>(i, i + 1));
|
||||
}
|
||||
|
||||
// make sure that the map now contains 10 items...
|
||||
BOOST_CHECK(map.size() == 10);
|
||||
|
||||
// ...and that the first item has been discarded
|
||||
BOOST_CHECK(map.count(-1) == 0);
|
||||
|
||||
// iterate over the map, both with an index and an iterator
|
||||
limitedmap<int, int>::const_iterator it = map.begin();
|
||||
for (int i = 0; i < 10; i++) {
|
||||
// make sure the item is present
|
||||
BOOST_CHECK(map.count(i) == 1);
|
||||
|
||||
// use the iterator to check for the expected key and value
|
||||
BOOST_CHECK(it->first == i);
|
||||
BOOST_CHECK(it->second == i + 1);
|
||||
|
||||
// use find to check for the value
|
||||
BOOST_CHECK(map.find(i)->second == i + 1);
|
||||
|
||||
// update and recheck
|
||||
map.update(it, i + 2);
|
||||
BOOST_CHECK(map.find(i)->second == i + 2);
|
||||
|
||||
it++;
|
||||
}
|
||||
|
||||
// check that we've exhausted the iterator
|
||||
BOOST_CHECK(it == map.end());
|
||||
|
||||
// resize the map to 5 items
|
||||
map.max_size(5);
|
||||
|
||||
// check that the max size and size are now 5
|
||||
BOOST_CHECK(map.max_size() == 5);
|
||||
BOOST_CHECK(map.size() == 5);
|
||||
|
||||
// check that items less than 5 have been discarded
|
||||
// and items greater than 5 are retained
|
||||
for (int i = 0; i < 10; i++) {
|
||||
if (i < 5) {
|
||||
BOOST_CHECK(map.count(i) == 0);
|
||||
} else {
|
||||
BOOST_CHECK(map.count(i) == 1);
|
||||
}
|
||||
}
|
||||
|
||||
// erase some items not in the map
|
||||
for (int i = 100; i < 1000; i += 100) {
|
||||
map.erase(i);
|
||||
}
|
||||
|
||||
// check that the size is unaffected
|
||||
BOOST_CHECK(map.size() == 5);
|
||||
|
||||
// erase the remaining elements
|
||||
for (int i = 5; i < 10; i++) {
|
||||
map.erase(i);
|
||||
}
|
||||
|
||||
// check that the map is now empty
|
||||
BOOST_CHECK(map.empty());
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_SUITE_END()
|
||||
Loading…
Add table
Reference in a new issue