mirror of
https://github.com/ZeroTier/ZeroTierOne
synced 2025-07-05 20:41:44 -07:00
clang-format
This commit is contained in:
Adam Ierymenko
parent
d45f280cb7
commit
ba2a4a605c
140 changed files with 19214 additions and 17403 deletions
|
|
@ -16,36 +16,43 @@
|
|||
|
||||
#include "Constants.hpp"
|
||||
|
||||
#include <algorithm>
|
||||
#include <stdexcept>
|
||||
#include <stdint.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#include <stdexcept>
|
||||
#include <vector>
|
||||
#include <utility>
|
||||
#include <algorithm>
|
||||
#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; }
|
||||
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
|
||||
_Bucket* next; // must be set manually for each _Bucket
|
||||
};
|
||||
|
||||
public:
|
||||
public:
|
||||
/**
|
||||
* A simple forward iterator (different from STL)
|
||||
*
|
||||
|
|
@ -53,16 +60,12 @@ public:
|
|||
* may rehash and invalidate the iterator. Note the erasing the key will destroy
|
||||
* the targets of the pointers returned by next().
|
||||
*/
|
||||
class Iterator
|
||||
{
|
||||
public:
|
||||
class Iterator {
|
||||
public:
|
||||
/**
|
||||
* @param ht Hash table to iterate over
|
||||
*/
|
||||
Iterator(Hashtable &ht) :
|
||||
_idx(0),
|
||||
_ht(&ht),
|
||||
_b(ht._t[0])
|
||||
Iterator(Hashtable& ht) : _idx(0), _ht(&ht), _b(ht._t[0])
|
||||
{
|
||||
}
|
||||
|
||||
|
|
@ -71,9 +74,9 @@ public:
|
|||
* @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)
|
||||
inline bool next(K*& kptr, V*& vptr)
|
||||
{
|
||||
for(;;) {
|
||||
for (;;) {
|
||||
if (_b) {
|
||||
kptr = &(_b->k);
|
||||
vptr = &(_b->v);
|
||||
|
|
@ -88,44 +91,38 @@ public:
|
|||
}
|
||||
}
|
||||
|
||||
private:
|
||||
private:
|
||||
unsigned long _idx;
|
||||
Hashtable *_ht;
|
||||
_Bucket *_b;
|
||||
Hashtable* _ht;
|
||||
_Bucket* _b;
|
||||
};
|
||||
//friend class Hashtable<K,V>::Iterator;
|
||||
// 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)
|
||||
Hashtable(unsigned long bc = 64) : _t(reinterpret_cast<_Bucket**>(::malloc(sizeof(_Bucket*) * bc))), _bc(bc), _s(0)
|
||||
{
|
||||
if (!_t) {
|
||||
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) {
|
||||
_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)
|
||||
Hashtable(const Hashtable<K, V>& ht) : _t(reinterpret_cast<_Bucket**>(::malloc(sizeof(_Bucket*) * ht._bc))), _bc(ht._bc), _s(ht._s)
|
||||
{
|
||||
if (!_t) {
|
||||
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) {
|
||||
_t[i] = (_Bucket*)0;
|
||||
}
|
||||
for(unsigned long i=0;i<_bc;++i) {
|
||||
const _Bucket *b = ht._t[i];
|
||||
for (unsigned long i = 0; i < _bc; ++i) {
|
||||
const _Bucket* b = ht._t[i];
|
||||
while (b) {
|
||||
_Bucket *nb = new _Bucket(*b);
|
||||
_Bucket* nb = new _Bucket(*b);
|
||||
nb->next = _t[i];
|
||||
_t[i] = nb;
|
||||
b = b->next;
|
||||
|
|
@ -139,14 +136,14 @@ public:
|
|||
::free(_t);
|
||||
}
|
||||
|
||||
inline Hashtable &operator=(const Hashtable<K,V> &ht)
|
||||
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];
|
||||
for (unsigned long i = 0; i < ht._bc; ++i) {
|
||||
const _Bucket* b = ht._t[i];
|
||||
while (b) {
|
||||
this->set(b->k,b->v);
|
||||
this->set(b->k, b->v);
|
||||
b = b->next;
|
||||
}
|
||||
}
|
||||
|
|
@ -160,14 +157,14 @@ public:
|
|||
inline void clear()
|
||||
{
|
||||
if (_s) {
|
||||
for(unsigned long i=0;i<_bc;++i) {
|
||||
_Bucket *b = _t[i];
|
||||
for (unsigned long i = 0; i < _bc; ++i) {
|
||||
_Bucket* b = _t[i];
|
||||
while (b) {
|
||||
_Bucket *const nb = b->next;
|
||||
_Bucket* const nb = b->next;
|
||||
delete b;
|
||||
b = nb;
|
||||
}
|
||||
_t[i] = (_Bucket *)0;
|
||||
_t[i] = (_Bucket*)0;
|
||||
}
|
||||
_s = 0;
|
||||
}
|
||||
|
|
@ -181,8 +178,8 @@ public:
|
|||
typename std::vector<K> k;
|
||||
if (_s) {
|
||||
k.reserve(_s);
|
||||
for(unsigned long i=0;i<_bc;++i) {
|
||||
_Bucket *b = _t[i];
|
||||
for (unsigned long i = 0; i < _bc; ++i) {
|
||||
_Bucket* b = _t[i];
|
||||
while (b) {
|
||||
k.push_back(b->k);
|
||||
b = b->next;
|
||||
|
|
@ -198,12 +195,11 @@ public:
|
|||
* @param v Vector, list, or other compliant container
|
||||
* @tparam Type of V (generally inferred)
|
||||
*/
|
||||
template<typename C>
|
||||
inline void appendKeys(C &v) const
|
||||
template <typename C> inline void appendKeys(C& v) const
|
||||
{
|
||||
if (_s) {
|
||||
for(unsigned long i=0;i<_bc;++i) {
|
||||
_Bucket *b = _t[i];
|
||||
for (unsigned long i = 0; i < _bc; ++i) {
|
||||
_Bucket* b = _t[i];
|
||||
while (b) {
|
||||
v.push_back(b->k);
|
||||
b = b->next;
|
||||
|
|
@ -215,15 +211,15 @@ public:
|
|||
/**
|
||||
* @return Vector of all entries (pairs of K,V)
|
||||
*/
|
||||
inline typename std::vector< std::pair<K,V> > entries() const
|
||||
inline typename std::vector<std::pair<K, V> > entries() const
|
||||
{
|
||||
typename std::vector< std::pair<K,V> > k;
|
||||
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];
|
||||
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));
|
||||
k.push_back(std::pair<K, V>(b->k, b->v));
|
||||
b = b->next;
|
||||
}
|
||||
}
|
||||
|
|
@ -235,27 +231,30 @@ public:
|
|||
* @param k Key
|
||||
* @return Pointer to value or NULL if not found
|
||||
*/
|
||||
inline V *get(const K &k)
|
||||
inline V* get(const K& k)
|
||||
{
|
||||
_Bucket *b = _t[_hc(k) % _bc];
|
||||
_Bucket* b = _t[_hc(k) % _bc];
|
||||
while (b) {
|
||||
if (b->k == k) {
|
||||
return &(b->v);
|
||||
}
|
||||
b = b->next;
|
||||
}
|
||||
return (V *)0;
|
||||
return (V*)0;
|
||||
}
|
||||
inline const V* get(const K& k) const
|
||||
{
|
||||
return const_cast<Hashtable*>(this)->get(k);
|
||||
}
|
||||
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
|
||||
inline bool get(const K& k, V& v) const
|
||||
{
|
||||
_Bucket *b = _t[_hc(k) % _bc];
|
||||
_Bucket* b = _t[_hc(k) % _bc];
|
||||
while (b) {
|
||||
if (b->k == k) {
|
||||
v = b->v;
|
||||
|
|
@ -270,9 +269,9 @@ public:
|
|||
* @param k Key to check
|
||||
* @return True if key is present
|
||||
*/
|
||||
inline bool contains(const K &k) const
|
||||
inline bool contains(const K& k) const
|
||||
{
|
||||
_Bucket *b = _t[_hc(k) % _bc];
|
||||
_Bucket* b = _t[_hc(k) % _bc];
|
||||
while (b) {
|
||||
if (b->k == k) {
|
||||
return true;
|
||||
|
|
@ -286,16 +285,17 @@ public:
|
|||
* @param k Key
|
||||
* @return True if value was present
|
||||
*/
|
||||
inline bool erase(const K &k)
|
||||
inline bool erase(const K& k)
|
||||
{
|
||||
const unsigned long bidx = _hc(k) % _bc;
|
||||
_Bucket *lastb = (_Bucket *)0;
|
||||
_Bucket *b = _t[bidx];
|
||||
_Bucket* lastb = (_Bucket*)0;
|
||||
_Bucket* b = _t[bidx];
|
||||
while (b) {
|
||||
if (b->k == k) {
|
||||
if (lastb) {
|
||||
lastb->next = b->next;
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
_t[bidx] = b->next;
|
||||
}
|
||||
delete b;
|
||||
|
|
@ -313,12 +313,12 @@ public:
|
|||
* @param v Value
|
||||
* @return Reference to value in table
|
||||
*/
|
||||
inline V &set(const K &k,const V &v)
|
||||
inline V& set(const K& k, const V& v)
|
||||
{
|
||||
const unsigned long h = _hc(k);
|
||||
unsigned long bidx = h % _bc;
|
||||
|
||||
_Bucket *b = _t[bidx];
|
||||
_Bucket* b = _t[bidx];
|
||||
while (b) {
|
||||
if (b->k == k) {
|
||||
b->v = v;
|
||||
|
|
@ -332,7 +332,7 @@ public:
|
|||
bidx = h % _bc;
|
||||
}
|
||||
|
||||
b = new _Bucket(k,v);
|
||||
b = new _Bucket(k, v);
|
||||
b->next = _t[bidx];
|
||||
_t[bidx] = b;
|
||||
++_s;
|
||||
|
|
@ -343,12 +343,12 @@ public:
|
|||
* @param k Key
|
||||
* @return Value, possibly newly created
|
||||
*/
|
||||
inline V &operator[](const K &k)
|
||||
inline V& operator[](const K& k)
|
||||
{
|
||||
const unsigned long h = _hc(k);
|
||||
unsigned long bidx = h % _bc;
|
||||
|
||||
_Bucket *b = _t[bidx];
|
||||
_Bucket* b = _t[bidx];
|
||||
while (b) {
|
||||
if (b->k == k) {
|
||||
return b->v;
|
||||
|
|
@ -371,22 +371,27 @@ public:
|
|||
/**
|
||||
* @return Number of entries
|
||||
*/
|
||||
inline unsigned long size() const { return _s; }
|
||||
inline unsigned long size() const
|
||||
{
|
||||
return _s;
|
||||
}
|
||||
|
||||
/**
|
||||
* @return True if table is empty
|
||||
*/
|
||||
inline bool empty() const { return (_s == 0); }
|
||||
inline bool empty() const
|
||||
{
|
||||
return (_s == 0);
|
||||
}
|
||||
|
||||
private:
|
||||
template<typename O>
|
||||
static inline unsigned long _hc(const O &obj)
|
||||
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
|
||||
return (unsigned long)(i ^ (i >> 32)); // good for network IDs and addresses
|
||||
}
|
||||
static inline unsigned long _hc(const uint32_t i)
|
||||
{
|
||||
|
|
@ -404,15 +409,15 @@ private:
|
|||
inline void _grow()
|
||||
{
|
||||
const unsigned long nc = _bc * 2;
|
||||
_Bucket **nt = reinterpret_cast<_Bucket **>(::malloc(sizeof(_Bucket *) * nc));
|
||||
_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 < nc; ++i) {
|
||||
nt[i] = (_Bucket*)0;
|
||||
}
|
||||
for(unsigned long i=0;i<_bc;++i) {
|
||||
_Bucket *b = _t[i];
|
||||
for (unsigned long i = 0; i < _bc; ++i) {
|
||||
_Bucket* b = _t[i];
|
||||
while (b) {
|
||||
_Bucket *const nb = b->next;
|
||||
_Bucket* const nb = b->next;
|
||||
const unsigned long nidx = _hc(b->k) % nc;
|
||||
b->next = nt[nidx];
|
||||
nt[nidx] = b;
|
||||
|
|
@ -425,11 +430,11 @@ private:
|
|||
}
|
||||
}
|
||||
|
||||
_Bucket **_t;
|
||||
_Bucket** _t;
|
||||
unsigned long _bc;
|
||||
unsigned long _s;
|
||||
};
|
||||
|
||||
} // namespace ZeroTier
|
||||
} // namespace ZeroTier
|
||||
|
||||
#endif
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue