270 lines
7.8 KiB
C++
270 lines
7.8 KiB
C++
#pragma once
|
|
|
|
#ifndef TCG_HASH_H
|
|
#define TCG_HASH_H
|
|
|
|
// tcg includes
|
|
#include "list.h"
|
|
|
|
namespace tcg {
|
|
|
|
//============================================================================================
|
|
|
|
/*!
|
|
The hash class implements a hash map using tcg lists
|
|
*/
|
|
|
|
template <typename K, typename T, typename Hash_functor = size_t (*)(const K &)>
|
|
class hash {
|
|
public:
|
|
typedef K key_type;
|
|
typedef T value_type;
|
|
typedef Hash_functor hash_type;
|
|
|
|
struct BucketNode {
|
|
K m_key;
|
|
T m_val;
|
|
size_t m_next;
|
|
size_t m_prev;
|
|
|
|
BucketNode(const K &key, const T &val)
|
|
: m_key(key), m_val(val), m_next(-1), m_prev(-1) {}
|
|
BucketNode(const std::pair<K, T> &pair)
|
|
: m_key(pair.first), m_val(pair.second), m_next(-1), m_prev(-1) {}
|
|
~BucketNode() {}
|
|
};
|
|
|
|
typedef typename tcg::list<BucketNode>::size_t size_t;
|
|
|
|
typedef typename tcg::list<BucketNode>::iterator iterator;
|
|
typedef typename tcg::list<BucketNode>::const_iterator const_iterator;
|
|
|
|
private:
|
|
std::vector<size_t> m_bucketsIdx;
|
|
tcg::list<BucketNode> m_items;
|
|
Hash_functor m_hash;
|
|
|
|
private:
|
|
bool createItem(const K &key, const T &val) {
|
|
m_items.push_back(BucketNode(key, val));
|
|
|
|
size_t itemsCount = m_items.size(), bucketsCount = m_bucketsIdx.size();
|
|
if (itemsCount > bucketsCount) {
|
|
do
|
|
bucketsCount =
|
|
2 * bucketsCount + 1; // Please, note that 2n here would be moronic
|
|
while (itemsCount > bucketsCount);
|
|
|
|
rehash(bucketsCount);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
size_t touchKey(const K &key, const T &val = T()) {
|
|
size_t hashValue = m_hash(key) % m_bucketsIdx.size();
|
|
size_t bucketIdx = m_bucketsIdx[hashValue];
|
|
size_t oldIdx = _neg;
|
|
|
|
if (bucketIdx == _neg) {
|
|
// A new bucket is created
|
|
bool rehashed = createItem(key, val);
|
|
bucketIdx = m_items.last().m_idx;
|
|
|
|
if (!rehashed)
|
|
// Need to manually update the stored bucket index
|
|
m_bucketsIdx[hashValue] = bucketIdx;
|
|
|
|
return bucketIdx;
|
|
} else {
|
|
// Bucket exists - search key in it
|
|
for (; bucketIdx != _neg && m_items[bucketIdx].m_key != key;
|
|
oldIdx = bucketIdx, bucketIdx = m_items[bucketIdx].m_next)
|
|
;
|
|
}
|
|
|
|
if (bucketIdx == _neg) {
|
|
// Key was not found - create an item and insert it
|
|
bool rehashed = createItem(key, val);
|
|
bucketIdx = m_items.last().m_idx;
|
|
|
|
if (!rehashed && oldIdx != _neg) {
|
|
// Need to relink manually
|
|
m_items[oldIdx].m_next = bucketIdx;
|
|
m_items[bucketIdx].m_prev = oldIdx;
|
|
}
|
|
}
|
|
|
|
return bucketIdx;
|
|
}
|
|
|
|
public:
|
|
// NOTE: The defaulted 89 is a *good* initial buckets size when expanding by
|
|
// the (2n+1) rule.
|
|
// See http://www.concentric.net/~ttwang/tech/hashsize.htm for details
|
|
|
|
hash(const Hash_functor &func = Hash_functor(), size_t bucketsCount = 89)
|
|
: m_bucketsIdx(bucketsCount, _neg), m_hash(func) {}
|
|
|
|
template <typename ForIt>
|
|
hash(ForIt begin, ForIt end, const Hash_functor &func = Hash_functor(),
|
|
size_t bucketsCount = 89)
|
|
: m_items(begin, end), m_hash(func) {
|
|
for (size_t nCount = m_items.nodesCount(); bucketsCount < nCount;
|
|
bucketsCount = 2 * bucketsCount + 1)
|
|
;
|
|
rehash(bucketsCount);
|
|
}
|
|
|
|
//! Constructs from a range of (index, value) item pairs
|
|
template <typename BidIt>
|
|
hash(BidIt begin, BidIt end, size_t nodesCount,
|
|
const Hash_functor &func = Hash_functor(), size_t bucketsCount = 89)
|
|
: m_items(begin, end, nodesCount), m_hash(func) {
|
|
for (size_t nCount = m_items.nodesCount(); bucketsCount < nCount;
|
|
bucketsCount = 2 * bucketsCount + 1)
|
|
;
|
|
rehash(bucketsCount);
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
|
|
void rehash(size_t newSize) {
|
|
m_bucketsIdx.clear();
|
|
m_bucketsIdx.resize(newSize, _neg);
|
|
|
|
size_t bucketIdx;
|
|
|
|
iterator it, iEnd = end();
|
|
for (it = begin(); it != iEnd; ++it) {
|
|
bucketIdx = m_hash(it->m_key) % newSize;
|
|
size_t &idx = m_bucketsIdx[bucketIdx];
|
|
|
|
it->m_next = idx;
|
|
it->m_prev = _neg;
|
|
|
|
if (idx != _neg) m_items[idx].m_prev = it.m_idx;
|
|
idx = it.m_idx;
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
|
|
size_t size() const { return m_items.size(); }
|
|
bool empty() { return size() == 0; }
|
|
|
|
void clear() {
|
|
m_items.clear();
|
|
m_bucketsIdx.clear();
|
|
m_bucketsIdx.resize(1, _neg);
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
|
|
iterator begin() { return m_items.begin(); }
|
|
iterator last() { return m_items.last(); }
|
|
iterator end() { return m_items.end(); }
|
|
|
|
//--------------------------------------------------------------------------
|
|
|
|
const_iterator begin() const { return m_items.begin(); }
|
|
const_iterator last() const { return m_items.last(); }
|
|
const_iterator end() const { return m_items.end(); }
|
|
|
|
//--------------------------------------------------------------------------
|
|
|
|
iterator find(const K &key) {
|
|
size_t hashValue = m_hash(key) % m_bucketsIdx.size();
|
|
size_t bucketIdx = m_bucketsIdx[hashValue];
|
|
|
|
if (bucketIdx == _neg) return end();
|
|
|
|
for (; bucketIdx != _neg && m_items[bucketIdx].m_key != key;
|
|
bucketIdx = m_items[bucketIdx].m_next)
|
|
;
|
|
|
|
return bucketIdx == _neg ? end() : iterator(&m_items, bucketIdx);
|
|
}
|
|
|
|
const_iterator find(const K &key) const {
|
|
return const_iterator(&m_items, const_cast<hash *>(this)->find(key).m_idx);
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
|
|
iterator insert(const K &key, const T &val) {
|
|
size_t idx = touchKey(key);
|
|
m_items[idx].m_val = val;
|
|
return iterator(&m_items, idx);
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
|
|
//!\warning Assignment of the kind hash_map[i1] = hash_map[i2] are DANGEROUS!
|
|
//! The
|
|
//! reference returned on the right may be INVALIDATED if the first key is
|
|
//! inserted!
|
|
T &operator[](const K &key) { return m_items[touchKey(key)].m_val; }
|
|
|
|
//--------------------------------------------------------------------------
|
|
|
|
//!\warning The same remark of operator[] applies here!
|
|
T &touch(const K &key, const T &val) {
|
|
return m_items[touchKey(key, val)].m_val;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
|
|
iterator insert(const std::pair<K, T> &pair) {
|
|
return insert(pair.first, pair.second);
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
|
|
void erase(iterator it) {
|
|
BucketNode &node = *it;
|
|
if (node.m_next != _neg) m_items[node.m_next].m_prev = node.m_prev;
|
|
if (node.m_prev != _neg)
|
|
m_items[node.m_prev].m_next = node.m_next;
|
|
else
|
|
m_bucketsIdx[m_hash(node.m_key) % m_bucketsIdx.size()] = _neg;
|
|
|
|
m_items.erase(it);
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
|
|
void erase(const K &key) {
|
|
iterator it = find(key);
|
|
if (it != end()) erase(it);
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
|
|
friend void swap(hash &a, hash &b) {
|
|
using std::swap;
|
|
|
|
a.m_bucketsIdx.swap(b.m_bucketsIdx);
|
|
swap(a.m_items, b.m_items);
|
|
swap(a.m_hash, b.m_hash);
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
|
|
const tcg::list<BucketNode> &items() const { return m_items; }
|
|
|
|
//--------------------------------------------------------------------------
|
|
|
|
const std::vector<size_t> &buckets() const { return m_bucketsIdx; }
|
|
|
|
//--------------------------------------------------------------------------
|
|
|
|
const Hash_functor &hashFunctor() const { return m_hash; }
|
|
|
|
//! Remember to rehash() if the hash functor changes
|
|
Hash_functor &hashFunctor() { return m_hash; }
|
|
};
|
|
|
|
} // namespace tcg
|
|
|
|
#endif // TCG_HASH_H
|