/* * ZeroTier One - Network Virtualization Everywhere * Copyright (C) 2011-2017 ZeroTier, Inc. https://www.zerotier.com/ * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see . * * -- * * You can be released from the requirements of the license by purchasing * a commercial license. Buying such a license is mandatory as soon as you * develop commercial closed-source software that incorporates or links * directly against ZeroTier software without disclosing the source code * of your own application. */ #ifndef ZT_HASHTABLE_HPP #define ZT_HASHTABLE_HPP #include #include #include #include #include #include #include namespace ZeroTier { /** * A minimal hash table implementation for the ZeroTier core * * This is not a drop-in replacement for STL containers, and has several * limitations. Keys can be uint64_t or an object, and if the latter they * must implement a method called hashCode() that returns an unsigned long * value that is evenly distributed. */ template 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::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 &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 &ht) { this->clear(); if (ht._s) { for(unsigned long i=0;iset(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 keys() const { typename std::vector 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 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 > entries() const { typename std::vector< std::pair > 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(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(this)->get(k); } /** * @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 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); } 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;inext; 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