amxmodx/dlls/nvault/sdk/sh_tinyhash.h

583 lines
11 KiB
C
Raw Normal View History

2005-09-18 06:59:36 +04:00
/* ======== SourceMM ========
* Copyright (C) 2004-2005 Metamod:Source Development Team
* No warranties of any kind
*
* License: zlib/libpng
*
* Author(s): David "BAILOPAN" Anderson
* ============================
*/
#ifndef _INCLUDE_SH_TINYHASH_H_
#define _INCLUDE_SH_TINYHASH_H_
#include <time.h>
#include "sh_list.h"
#define _T_INIT_HASH_SIZE 32
//namespace SourceHook
//{
2006-01-25 01:51:29 +03:00
template <class K>
int HashFunction(const K & k);
2005-09-18 06:59:36 +04:00
2006-01-25 01:51:29 +03:00
template <class K>
int Compare(const K & k1, const K & k2);
2005-09-18 06:59:36 +04:00
2006-01-25 01:51:29 +03:00
/**
* This is a tiny, growable hash class.
* Meant for quick and dirty dictionaries only!
*/
template <class K, class V>
class THash
{
public:
struct THashNode
2005-09-18 06:59:36 +04:00
{
2006-01-25 01:51:29 +03:00
THashNode(const K & k, const V & v) :
key(k), val(v)
{
};
THashNode & operator =(const THashNode &other)
{
key = other.key;
val = other.val;
}
K key;
V val;
time_t stamp;
};
typedef List<THashNode *> * NodePtr;
public:
class const_iterator;
THash() : m_Buckets(NULL), m_numBuckets(0), m_percentUsed(0.0f), m_Items(0)
{
_Refactor();
}
THash(const THash &other) : m_Buckets(new NodePtr[other.numBuckets]),
m_numBuckets(other.m_numBuckets),
m_percentUsed(other.m_percentUsed)
{
for (size_t i=0; i<m_numBuckets; i++)
m_Buckets[i] = NULL;
for (const_iterator iter=other.begin(); iter != other.end(); ++iter)
_FindOrInsert(iter->key)->val = iter->val;
}
void operator=(const THash &other)
{
2006-02-05 05:26:00 +03:00
Clear();
2006-01-25 01:51:29 +03:00
for (const_iterator iter=other.begin(); iter!=other.end(); ++iter)
_FindOrInsert(iter->key)->val = iter->val;
}
~THash()
{
_Clear();
}
void Clear()
{
_Clear();
_Refactor();
}
void Insert(const K & key, const V & val)
{
Insert(key, val, time(NULL));
}
void Insert(const K & key, const V & val, time_t stamp)
{
THashNode *pNode = _FindOrInsert(key);
pNode->val = val;
pNode->stamp = stamp;
}
bool Exists(const K & key)
{
size_t place = HashFunction(key) % m_numBuckets;
if (!m_Buckets[place])
return false;
typename List<THashNode *>::iterator iter;
for (iter = m_Buckets[place]->begin(); iter != m_Buckets[place]->end(); iter++)
2005-09-18 06:59:36 +04:00
{
2006-01-25 01:51:29 +03:00
if (Compare(key, (*iter)->key) == 0)
return true;
2005-09-18 06:59:36 +04:00
}
2006-01-25 01:51:29 +03:00
return false;
}
V & Retrieve(const K & k, time_t & stamp)
{
THashNode *pNode = _FindOrInsert(k);
stamp = pNode->stamp;
return pNode->val;
}
2006-08-21 01:23:38 +04:00
void Touch(const K & k, time_t stamp)
{
THashNode *pNode = _FindOrInsert(k);
pNode->stamp = stamp;
}
2006-01-25 01:51:29 +03:00
V & Retrieve(const K & k)
{
time_t stamp;
return Retrieve(k, stamp);
}
void Remove(const K & key)
{
size_t place = HashFunction(key) % m_numBuckets;
2005-09-18 06:59:36 +04:00
2006-01-25 01:51:29 +03:00
if (!m_Buckets[place])
return;
2005-09-18 06:59:36 +04:00
2006-01-25 01:51:29 +03:00
typename List<THashNode *>::iterator iter;
for (iter = m_Buckets[place]->begin(); iter != m_Buckets[place]->end(); iter++)
{
if (Compare(key, (*iter)->key) == 0)
2005-09-18 06:59:36 +04:00
{
2006-01-25 01:51:29 +03:00
iter = m_Buckets[place]->erase(iter);
m_Items--;
return;
2005-09-18 06:59:36 +04:00
}
}
2006-01-25 01:51:29 +03:00
}
size_t Prune(time_t start=0, time_t end=0)
{
typename List<THashNode *>::iterator iter;
time_t stamp;
size_t removed = 0;
for (size_t i=0; i<m_numBuckets; i++)
2005-09-18 06:59:36 +04:00
{
2006-01-25 01:51:29 +03:00
if (!m_Buckets[i])
continue;
iter = m_Buckets[i]->begin();
bool remove;
while (iter != m_Buckets[i]->end())
{
stamp = (*iter)->stamp;
remove = false;
if (stamp != 0)
{
if (start == 0 && end == 0)
remove = true;
else if (start == 0 && stamp < end)
remove = true;
else if (end == 0 && stamp > start)
remove = true;
else if (stamp > start && stamp < end)
remove = true;
if (remove)
{
iter = m_Buckets[i]->erase(iter);
removed++;
} else {
iter++;
}
2006-12-19 06:32:58 +03:00
} else {
iter++;
2006-01-25 01:51:29 +03:00
}
}
2005-09-18 06:59:36 +04:00
}
2006-01-25 01:51:29 +03:00
m_Items -= removed;
return removed;
}
size_t Size()
{
return m_Items;
}
size_t GetBuckets()
{
return m_numBuckets;
}
float PercentUsed()
{
return m_percentUsed;
}
V & operator [](const K & key)
{
THashNode *pNode = _FindOrInsert(key);
return pNode->val;
}
private:
void _Clear()
{
typename List<THashNode *>::iterator iter, end;
for (size_t i=0; i<m_numBuckets; i++)
2005-09-18 06:59:36 +04:00
{
2006-01-25 01:51:29 +03:00
if (m_Buckets[i])
{
end = m_Buckets[i]->end();
iter = m_Buckets[i]->begin();
while (iter != end)
{
delete (*iter);
iter++;
}
m_Buckets[i]->clear();
delete m_Buckets[i];
}
2005-09-18 06:59:36 +04:00
}
2006-01-25 01:51:29 +03:00
if (m_Buckets)
delete [] m_Buckets;
m_numBuckets = 0;
m_Items = 0;
m_Buckets = NULL;
}
THashNode *_FindOrInsert(const K & key)
{
size_t place = HashFunction(key) % m_numBuckets;
THashNode *pNode = NULL;
if (!m_Buckets[place])
2005-09-18 06:59:36 +04:00
{
2006-01-25 01:51:29 +03:00
m_Buckets[place] = new List<THashNode *>;
pNode = new THashNode(key, V());
m_Buckets[place]->push_back(pNode);
m_percentUsed += (1.0f / (float)m_numBuckets);
m_Items++;
} else {
2005-09-18 06:59:36 +04:00
typename List<THashNode *>::iterator iter;
2006-01-25 01:51:29 +03:00
for (iter=m_Buckets[place]->begin(); iter!=m_Buckets[place]->end(); iter++)
2005-09-18 06:59:36 +04:00
{
2006-01-25 01:51:29 +03:00
if (Compare((*iter)->key, key) == 0)
return (*iter);
2005-09-18 06:59:36 +04:00
}
2006-01-25 01:51:29 +03:00
//node does not exist
pNode = new THashNode(key, V());
m_Buckets[place]->push_back(pNode);
m_Items++;
2005-09-18 06:59:36 +04:00
}
2006-01-25 01:51:29 +03:00
if (PercentUsed() > 0.75f)
_Refactor();
return pNode;
}
void _Refactor()
{
m_percentUsed = 0.0f;
if (!m_numBuckets)
2005-09-18 06:59:36 +04:00
{
2006-01-25 01:51:29 +03:00
m_numBuckets = _T_INIT_HASH_SIZE;
m_Buckets = new NodePtr[m_numBuckets];
for (size_t i=0; i<m_numBuckets; i++)
m_Buckets[i] = NULL;
} else {
size_t oldSize = m_numBuckets;
m_numBuckets *= 2;
2005-09-18 06:59:36 +04:00
typename List<THashNode *>::iterator iter;
2006-01-25 01:51:29 +03:00
size_t place;
THashNode *pHashNode;
NodePtr *temp = new NodePtr[m_numBuckets];
2005-09-18 06:59:36 +04:00
for (size_t i=0; i<m_numBuckets; i++)
2006-01-25 01:51:29 +03:00
temp[i] = NULL;
//look in old hash table
for (size_t i=0; i<oldSize; i++)
2005-09-18 06:59:36 +04:00
{
2006-01-25 01:51:29 +03:00
//does a bucket have anything?
if (m_Buckets[i])
2005-09-18 06:59:36 +04:00
{
2006-01-25 01:51:29 +03:00
//go through the list of items
for (iter = m_Buckets[i]->begin(); iter != m_Buckets[i]->end(); iter++)
2005-09-18 06:59:36 +04:00
{
2006-01-25 01:51:29 +03:00
pHashNode = (*iter);
//rehash it with the new bucket filter
place = HashFunction(pHashNode->key) % m_numBuckets;
//add it to the new hash table
if (!temp[place])
2005-09-18 06:59:36 +04:00
{
2006-01-25 01:51:29 +03:00
temp[place] = new List<THashNode *>;
m_percentUsed += (1.0f / (float)m_numBuckets);
2005-09-18 06:59:36 +04:00
}
2006-01-25 01:51:29 +03:00
temp[place]->push_back(pHashNode);
2005-09-18 06:59:36 +04:00
}
2006-01-25 01:51:29 +03:00
//delete that bucket!
delete m_Buckets[i];
m_Buckets[i] = NULL;
2005-09-18 06:59:36 +04:00
}
}
2006-01-25 01:51:29 +03:00
//reassign bucket table
delete [] m_Buckets;
m_Buckets = temp;
2005-09-18 06:59:36 +04:00
}
2006-01-25 01:51:29 +03:00
}
public:
friend class iterator;
friend class const_iterator;
class iterator
{
friend class THash;
public:
iterator() : curbucket(-1), hash(NULL), end(true)
{
};
iterator(THash *h) : curbucket(-1), hash(h), end(false)
2005-09-18 06:59:36 +04:00
{
2006-01-25 01:51:29 +03:00
if (!h->m_Buckets)
end = true;
else
_Inc();
};
//pre increment
iterator & operator++()
{
_Inc();
return *this;
2005-09-18 06:59:36 +04:00
}
2006-01-25 01:51:29 +03:00
//post increment
iterator operator++(int)
2005-09-18 06:59:36 +04:00
{
2006-01-25 01:51:29 +03:00
iterator old(*this);
_Inc();
return old;
2005-09-18 06:59:36 +04:00
}
2006-01-25 01:51:29 +03:00
const THashNode & operator * () const
2005-09-18 06:59:36 +04:00
{
2006-01-25 01:51:29 +03:00
return *(*iter);
2005-09-18 06:59:36 +04:00
}
2006-01-25 01:51:29 +03:00
THashNode & operator * ()
2005-09-18 06:59:36 +04:00
{
2006-01-25 01:51:29 +03:00
return *(*iter);
2005-09-18 06:59:36 +04:00
}
2006-01-25 01:51:29 +03:00
const THashNode * operator ->() const
2005-09-18 06:59:36 +04:00
{
2006-01-25 01:51:29 +03:00
return (*iter);
2005-09-18 06:59:36 +04:00
}
2006-01-25 01:51:29 +03:00
THashNode * operator ->()
2005-09-18 06:59:36 +04:00
{
2006-01-25 01:51:29 +03:00
return (*iter);
}
bool operator ==(const iterator &where) const
{
if (where.hash == this->hash
&& where.end == this->end
&&
(this->end ||
((where.curbucket == this->curbucket)
&& (where.iter == iter))
))
return true;
return false;
}
bool operator !=(const iterator &where) const
{
return !( (*this) == where );
2005-09-18 06:59:36 +04:00
}
2006-01-25 01:51:29 +03:00
private:
void _Inc()
2005-09-18 06:59:36 +04:00
{
2006-01-25 01:51:29 +03:00
if (end || !hash || curbucket >= static_cast<int>(hash->m_numBuckets))
return;
if (curbucket < 0)
2005-09-18 06:59:36 +04:00
{
2006-01-25 01:51:29 +03:00
for (int i=0; i<(int)hash->m_numBuckets; i++)
2005-09-18 06:59:36 +04:00
{
2006-01-25 01:51:29 +03:00
if (hash->m_Buckets[i])
2005-09-18 06:59:36 +04:00
{
2006-01-25 01:51:29 +03:00
iter = hash->m_Buckets[i]->begin();
if (iter == hash->m_Buckets[i]->end())
continue;
curbucket = i;
break;
2005-09-18 06:59:36 +04:00
}
}
if (curbucket < 0)
2006-01-25 01:51:29 +03:00
end = true;
} else {
if (iter != hash->m_Buckets[curbucket]->end())
iter++;
if (iter == hash->m_Buckets[curbucket]->end())
2005-09-18 06:59:36 +04:00
{
2006-01-25 01:51:29 +03:00
int oldbucket = curbucket;
for (int i=curbucket+1; i<(int)hash->m_numBuckets; i++)
2005-09-18 06:59:36 +04:00
{
if (hash->m_Buckets[i])
{
iter = hash->m_Buckets[i]->begin();
if (iter == hash->m_Buckets[i]->end())
continue;
curbucket = i;
break;
}
}
2006-01-25 01:51:29 +03:00
if (curbucket == oldbucket)
2005-09-18 06:59:36 +04:00
end = true;
}
}
2006-01-25 01:51:29 +03:00
}
private:
int curbucket;
typename List<THashNode *>::iterator iter;
THash *hash;
bool end;
};
class const_iterator
{
friend class THash;
public:
const_iterator() : curbucket(-1), hash(NULL), end(true)
{
2005-09-18 06:59:36 +04:00
};
2006-01-25 01:51:29 +03:00
const_iterator(const THash *h) : curbucket(-1), hash(h), end(true)
{
2006-01-25 01:51:29 +03:00
if (!h->m_Buckets)
end = true;
else
_Inc();
2006-01-25 01:51:29 +03:00
};
const_iterator & operator++()
{
_Inc();
return *this;
}
const_iterator operator++(int)
{
iterator old(*this);
_Inc();
return old;
}
void erase()
{
if (end || !hash || curbucket < 0 || curbucket >= static_cast<int>(hash->m_numBuckets))
return true;
2006-01-25 01:51:29 +03:00
iterator tmp = *this;
++tmp;
delete (*iter);
hash->m_Items--;
hash->m_Buckets[curbucket]->erase(iter);
*this = tmp;
}
const THashNode & operator *() const
{
return *(*iter);
}
const THashNode * operator ->() const
{
return (*iter);
}
bool operator ==(const const_iterator &where) const
{
if (where.hash == this->hash
&& where.end == this->end
&&
(this->end ||
((where.curbucket == this->curbucket)
&& (where.iter == iter))
))
return true;
return false;
}
bool operator !=(const const_iterator &where) const
{
return !((*this)==where);
}
private:
void _Inc()
{
if (end || !hash || curbucket >= static_cast<int>(hash->m_numBuckets))
return;
if (curbucket < 0)
{
2006-01-25 01:51:29 +03:00
for (int i=0; i<(int)hash->m_numBuckets; i++)
{
if (hash->m_Buckets[i])
{
iter = hash->m_Buckets[i]->begin();
if (iter == hash->m_Buckets[i]->end())
continue;
curbucket = i;
break;
}
}
if (curbucket < 0)
2006-01-25 01:51:29 +03:00
end = true;
} else {
if (iter != hash->m_Buckets[curbucket]->end())
iter++;
if (iter == hash->m_Buckets[curbucket]->end())
{
2006-01-25 01:51:29 +03:00
int oldbucket = curbucket;
for (int i=curbucket+1; i<(int)hash->m_numBuckets; i++)
{
if (hash->m_Buckets[i])
{
iter = hash->m_Buckets[i]->begin();
if (iter == hash->m_Buckets[i]->end())
continue;
curbucket = i;
break;
}
}
2006-01-25 01:51:29 +03:00
if (curbucket == oldbucket)
end = true;
}
}
}
2006-01-25 01:51:29 +03:00
private:
int curbucket;
typename List<THashNode *>::iterator iter;
const THash *hash;
bool end;
};
public:
iterator begin()
{
return iterator(this);
}
iterator end()
{
iterator iter;
iter.hash = this;
return iter;
}
const_iterator begin() const
{
return const_iterator(this);
}
const_iterator end() const
{
const_iterator iter;
iter.hash = this;
return iter;
}
iterator erase(iterator where)
{
where.erase();
return where;
}
template <typename U>
void erase(const U & u)
2006-01-25 01:51:29 +03:00
{
iterator iter = find(u);
if (iter == end())
return;
iter.erase();
}
template <typename U>
2005-09-18 06:59:36 +04:00
iterator find(const U & u) const
2006-01-25 01:51:29 +03:00
{
iterator b = begin();
iterator e = end();
for (iterator iter = b; iter != e; iter++)
2005-09-18 06:59:36 +04:00
{
2006-01-25 01:51:29 +03:00
if ( (*iter).key == u )
return iter;
2005-09-18 06:59:36 +04:00
}
2006-01-25 01:51:29 +03:00
return end();
}
template <typename U>
2005-09-18 06:59:36 +04:00
iterator find(const U & u)
2006-01-25 01:51:29 +03:00
{
iterator b = begin();
iterator e = end();
for (iterator iter = b; iter != e; iter++)
2005-09-18 06:59:36 +04:00
{
2006-01-25 01:51:29 +03:00
if ( (*iter).key == u )
return iter;
2005-09-18 06:59:36 +04:00
}
2006-01-25 01:51:29 +03:00
return end();
}
private:
NodePtr *m_Buckets;
size_t m_numBuckets;
float m_percentUsed;
size_t m_Items;
};
2005-09-18 06:59:36 +04:00
//};
#endif //_INCLUDE_SH_TINYHASH_H_