mirror of
https://github.com/zerotier/ZeroTierOne.git
synced 2024-12-25 23:51:06 +00:00
441 lines
10 KiB
C++
441 lines
10 KiB
C++
/*
|
|
* Copyright (c)2019 ZeroTier, Inc.
|
|
*
|
|
* Use of this software is governed by the Business Source License included
|
|
* in the LICENSE.TXT file in the project's root directory.
|
|
*
|
|
* Change Date: 2026-01-01
|
|
*
|
|
* On the date above, in accordance with the Business Source License, use
|
|
* of this software will be governed by version 2.0 of the Apache License.
|
|
*/
|
|
/****/
|
|
|
|
#ifndef ZT_HASHTABLE_HPP
|
|
#define ZT_HASHTABLE_HPP
|
|
|
|
#include "Constants.hpp"
|
|
|
|
#include <algorithm>
|
|
#include <stdexcept>
|
|
#include <stdint.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <utility>
|
|
#include <vector>
|
|
|
|
namespace ZeroTier {
|
|
|
|
/**
|
|
* A minimal hash table implementation for the ZeroTier core
|
|
*/
|
|
template <typename K, typename V> class Hashtable {
|
|
private:
|
|
struct _Bucket {
|
|
_Bucket(const K& k, const V& v) : k(k), v(v)
|
|
{
|
|
}
|
|
_Bucket(const K& k) : k(k), v()
|
|
{
|
|
}
|
|
_Bucket(const _Bucket& b) : k(b.k), v(b.v)
|
|
{
|
|
}
|
|
inline _Bucket& operator=(const _Bucket& b)
|
|
{
|
|
k = b.k;
|
|
v = b.v;
|
|
return *this;
|
|
}
|
|
K k;
|
|
V v;
|
|
_Bucket* next; // must be set manually for each _Bucket
|
|
};
|
|
|
|
public:
|
|
/**
|
|
* A simple forward iterator (different from STL)
|
|
*
|
|
* It's safe to erase the last key, but not others. Don't use set() since that
|
|
* may rehash and invalidate the iterator. Note the erasing the key will destroy
|
|
* the targets of the pointers returned by next().
|
|
*/
|
|
class Iterator {
|
|
public:
|
|
/**
|
|
* @param ht Hash table to iterate over
|
|
*/
|
|
Iterator(Hashtable& ht) : _idx(0), _ht(&ht), _b(ht._t[0])
|
|
{
|
|
}
|
|
|
|
/**
|
|
* @param kptr Pointer to set to point to next key
|
|
* @param vptr Pointer to set to point to next value
|
|
* @return True if kptr and vptr are set, false if no more entries
|
|
*/
|
|
inline bool next(K*& kptr, V*& vptr)
|
|
{
|
|
for (;;) {
|
|
if (_b) {
|
|
kptr = &(_b->k);
|
|
vptr = &(_b->v);
|
|
_b = _b->next;
|
|
return true;
|
|
}
|
|
++_idx;
|
|
if (_idx >= _ht->_bc) {
|
|
return false;
|
|
}
|
|
_b = _ht->_t[_idx];
|
|
}
|
|
}
|
|
|
|
private:
|
|
unsigned long _idx;
|
|
Hashtable* _ht;
|
|
_Bucket* _b;
|
|
};
|
|
// friend class Hashtable<K,V>::Iterator;
|
|
|
|
/**
|
|
* @param bc Initial capacity in buckets (default: 64, must be nonzero)
|
|
*/
|
|
Hashtable(unsigned long bc = 64) : _t(reinterpret_cast<_Bucket**>(::malloc(sizeof(_Bucket*) * bc))), _bc(bc), _s(0)
|
|
{
|
|
if (! _t) {
|
|
throw ZT_EXCEPTION_OUT_OF_MEMORY;
|
|
}
|
|
for (unsigned long i = 0; i < bc; ++i) {
|
|
_t[i] = (_Bucket*)0;
|
|
}
|
|
}
|
|
|
|
Hashtable(const Hashtable<K, V>& ht) : _t(reinterpret_cast<_Bucket**>(::malloc(sizeof(_Bucket*) * ht._bc))), _bc(ht._bc), _s(ht._s)
|
|
{
|
|
if (! _t) {
|
|
throw ZT_EXCEPTION_OUT_OF_MEMORY;
|
|
}
|
|
for (unsigned long i = 0; i < _bc; ++i) {
|
|
_t[i] = (_Bucket*)0;
|
|
}
|
|
for (unsigned long i = 0; i < _bc; ++i) {
|
|
const _Bucket* b = ht._t[i];
|
|
while (b) {
|
|
_Bucket* nb = new _Bucket(*b);
|
|
nb->next = _t[i];
|
|
_t[i] = nb;
|
|
b = b->next;
|
|
}
|
|
}
|
|
}
|
|
|
|
~Hashtable()
|
|
{
|
|
this->clear();
|
|
::free(_t);
|
|
}
|
|
|
|
inline Hashtable& operator=(const Hashtable<K, V>& ht)
|
|
{
|
|
this->clear();
|
|
if (ht._s) {
|
|
for (unsigned long i = 0; i < ht._bc; ++i) {
|
|
const _Bucket* b = ht._t[i];
|
|
while (b) {
|
|
this->set(b->k, b->v);
|
|
b = b->next;
|
|
}
|
|
}
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
/**
|
|
* Erase all entries
|
|
*/
|
|
inline void clear()
|
|
{
|
|
if (_s) {
|
|
for (unsigned long i = 0; i < _bc; ++i) {
|
|
_Bucket* b = _t[i];
|
|
while (b) {
|
|
_Bucket* const nb = b->next;
|
|
delete b;
|
|
b = nb;
|
|
}
|
|
_t[i] = (_Bucket*)0;
|
|
}
|
|
_s = 0;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @return Vector of all keys
|
|
*/
|
|
inline typename std::vector<K> keys() const
|
|
{
|
|
typename std::vector<K> k;
|
|
if (_s) {
|
|
k.reserve(_s);
|
|
for (unsigned long i = 0; i < _bc; ++i) {
|
|
_Bucket* b = _t[i];
|
|
while (b) {
|
|
k.push_back(b->k);
|
|
b = b->next;
|
|
}
|
|
}
|
|
}
|
|
return k;
|
|
}
|
|
|
|
/**
|
|
* Append all keys (in unspecified order) to the supplied vector or list
|
|
*
|
|
* @param v Vector, list, or other compliant container
|
|
* @tparam Type of V (generally inferred)
|
|
*/
|
|
template <typename C> inline void appendKeys(C& v) const
|
|
{
|
|
if (_s) {
|
|
for (unsigned long i = 0; i < _bc; ++i) {
|
|
_Bucket* b = _t[i];
|
|
while (b) {
|
|
v.push_back(b->k);
|
|
b = b->next;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @return Vector of all entries (pairs of K,V)
|
|
*/
|
|
inline typename std::vector<std::pair<K, V> > entries() const
|
|
{
|
|
typename std::vector<std::pair<K, V> > k;
|
|
if (_s) {
|
|
k.reserve(_s);
|
|
for (unsigned long i = 0; i < _bc; ++i) {
|
|
_Bucket* b = _t[i];
|
|
while (b) {
|
|
k.push_back(std::pair<K, V>(b->k, b->v));
|
|
b = b->next;
|
|
}
|
|
}
|
|
}
|
|
return k;
|
|
}
|
|
|
|
/**
|
|
* @param k Key
|
|
* @return Pointer to value or NULL if not found
|
|
*/
|
|
inline V* get(const K& k)
|
|
{
|
|
_Bucket* b = _t[_hc(k) % _bc];
|
|
while (b) {
|
|
if (b->k == k) {
|
|
return &(b->v);
|
|
}
|
|
b = b->next;
|
|
}
|
|
return (V*)0;
|
|
}
|
|
inline const V* get(const K& k) const
|
|
{
|
|
return const_cast<Hashtable*>(this)->get(k);
|
|
}
|
|
|
|
/**
|
|
* @param k Key
|
|
* @param v Value to fill with result
|
|
* @return True if value was found and set (if false, v is not modified)
|
|
*/
|
|
inline bool get(const K& k, V& v) const
|
|
{
|
|
_Bucket* b = _t[_hc(k) % _bc];
|
|
while (b) {
|
|
if (b->k == k) {
|
|
v = b->v;
|
|
return true;
|
|
}
|
|
b = b->next;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* @param k Key to check
|
|
* @return True if key is present
|
|
*/
|
|
inline bool contains(const K& k) const
|
|
{
|
|
_Bucket* b = _t[_hc(k) % _bc];
|
|
while (b) {
|
|
if (b->k == k) {
|
|
return true;
|
|
}
|
|
b = b->next;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* @param k Key
|
|
* @return True if value was present
|
|
*/
|
|
inline bool erase(const K& k)
|
|
{
|
|
const unsigned long bidx = _hc(k) % _bc;
|
|
_Bucket* lastb = (_Bucket*)0;
|
|
_Bucket* b = _t[bidx];
|
|
while (b) {
|
|
if (b->k == k) {
|
|
if (lastb) {
|
|
lastb->next = b->next;
|
|
}
|
|
else {
|
|
_t[bidx] = b->next;
|
|
}
|
|
delete b;
|
|
--_s;
|
|
return true;
|
|
}
|
|
lastb = b;
|
|
b = b->next;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* @param k Key
|
|
* @param v Value
|
|
* @return Reference to value in table
|
|
*/
|
|
inline V& set(const K& k, const V& v)
|
|
{
|
|
const unsigned long h = _hc(k);
|
|
unsigned long bidx = h % _bc;
|
|
|
|
_Bucket* b = _t[bidx];
|
|
while (b) {
|
|
if (b->k == k) {
|
|
b->v = v;
|
|
return b->v;
|
|
}
|
|
b = b->next;
|
|
}
|
|
|
|
if (_s >= _bc) {
|
|
_grow();
|
|
bidx = h % _bc;
|
|
}
|
|
|
|
b = new _Bucket(k, v);
|
|
b->next = _t[bidx];
|
|
_t[bidx] = b;
|
|
++_s;
|
|
return b->v;
|
|
}
|
|
|
|
/**
|
|
* @param k Key
|
|
* @return Value, possibly newly created
|
|
*/
|
|
inline V& operator[](const K& k)
|
|
{
|
|
const unsigned long h = _hc(k);
|
|
unsigned long bidx = h % _bc;
|
|
|
|
_Bucket* b = _t[bidx];
|
|
while (b) {
|
|
if (b->k == k) {
|
|
return b->v;
|
|
}
|
|
b = b->next;
|
|
}
|
|
|
|
if (_s >= _bc) {
|
|
_grow();
|
|
bidx = h % _bc;
|
|
}
|
|
|
|
b = new _Bucket(k);
|
|
b->next = _t[bidx];
|
|
_t[bidx] = b;
|
|
++_s;
|
|
return b->v;
|
|
}
|
|
|
|
/**
|
|
* @return Number of entries
|
|
*/
|
|
inline unsigned long size() const
|
|
{
|
|
return _s;
|
|
}
|
|
|
|
/**
|
|
* @return True if table is empty
|
|
*/
|
|
inline bool empty() const
|
|
{
|
|
return (_s == 0);
|
|
}
|
|
|
|
private:
|
|
template <typename O> static inline unsigned long _hc(const O& obj)
|
|
{
|
|
return (unsigned long)obj.hashCode();
|
|
}
|
|
static inline unsigned long _hc(const uint64_t i)
|
|
{
|
|
return (unsigned long)(i ^ (i >> 32)); // good for network IDs and addresses
|
|
}
|
|
static inline unsigned long _hc(const uint32_t i)
|
|
{
|
|
return ((unsigned long)i * (unsigned long)0x9e3779b1);
|
|
}
|
|
static inline unsigned long _hc(const uint16_t i)
|
|
{
|
|
return ((unsigned long)i * (unsigned long)0x9e3779b1);
|
|
}
|
|
static inline unsigned long _hc(const int i)
|
|
{
|
|
return ((unsigned long)i * (unsigned long)0x9e3379b1);
|
|
}
|
|
|
|
inline void _grow()
|
|
{
|
|
const unsigned long nc = _bc * 2;
|
|
_Bucket** nt = reinterpret_cast<_Bucket**>(::malloc(sizeof(_Bucket*) * nc));
|
|
if (nt) {
|
|
for (unsigned long i = 0; i < nc; ++i) {
|
|
nt[i] = (_Bucket*)0;
|
|
}
|
|
for (unsigned long i = 0; i < _bc; ++i) {
|
|
_Bucket* b = _t[i];
|
|
while (b) {
|
|
_Bucket* const nb = b->next;
|
|
const unsigned long nidx = _hc(b->k) % nc;
|
|
b->next = nt[nidx];
|
|
nt[nidx] = b;
|
|
b = nb;
|
|
}
|
|
}
|
|
::free(_t);
|
|
_t = nt;
|
|
_bc = nc;
|
|
}
|
|
}
|
|
|
|
_Bucket** _t;
|
|
unsigned long _bc;
|
|
unsigned long _s;
|
|
};
|
|
|
|
} // namespace ZeroTier
|
|
|
|
#endif
|