mirror of
https://github.com/zeek/zeek.git
synced 2025-10-10 02:28:21 +00:00
Reformat the world
This commit is contained in:
Tim Wojtulewicz
parent
194cb24547
commit
b2f171ec69
714 changed files with 35149 additions and 35203 deletions
294
src/Dict.h
294
src/Dict.h
|
|
@ -3,31 +3,37 @@
|
|||
#pragma once
|
||||
|
||||
#include <cstdint>
|
||||
#include <vector>
|
||||
#include <memory>
|
||||
#include <vector>
|
||||
|
||||
#include "zeek/Hash.h"
|
||||
|
||||
// Type for function to be called when deleting elements.
|
||||
typedef void (*dict_delete_func)(void*);
|
||||
|
||||
namespace zeek {
|
||||
namespace zeek
|
||||
{
|
||||
|
||||
class IterCookie;
|
||||
class Dictionary;
|
||||
|
||||
enum DictOrder { ORDERED, UNORDERED };
|
||||
enum DictOrder
|
||||
{
|
||||
ORDERED,
|
||||
UNORDERED
|
||||
};
|
||||
|
||||
// A dict_delete_func that just calls delete.
|
||||
extern void generic_delete_func(void*);
|
||||
|
||||
namespace detail {
|
||||
namespace detail
|
||||
{
|
||||
|
||||
class DictEntry;
|
||||
|
||||
// Default number of hash buckets in dictionary. The dictionary will increase the size
|
||||
// of the hash table as needed.
|
||||
constexpr uint32_t HASH_MASK = 0xFFFFFFFF; //only lower 32 bits.
|
||||
constexpr uint32_t HASH_MASK = 0xFFFFFFFF; // only lower 32 bits.
|
||||
|
||||
// These four variables can be used to build different targets with -Dxxx for performance
|
||||
// or for debugging purposes.
|
||||
|
|
@ -54,9 +60,9 @@ constexpr uint16_t TOO_FAR_TO_REACH = 0xFFFF;
|
|||
/**
|
||||
* An entry stored in the dictionary.
|
||||
*/
|
||||
class DictEntry {
|
||||
class DictEntry
|
||||
{
|
||||
public:
|
||||
|
||||
#ifdef DEBUG
|
||||
int bucket = 0;
|
||||
#endif
|
||||
|
|
@ -72,10 +78,10 @@ public:
|
|||
uint32_t hash = 0;
|
||||
|
||||
void* value = nullptr;
|
||||
union {
|
||||
char key_here[8]; //hold key len<=8. when over 8, it's a pointer to real keys.
|
||||
union {
|
||||
char key_here[8]; // hold key len<=8. when over 8, it's a pointer to real keys.
|
||||
char* key;
|
||||
};
|
||||
};
|
||||
|
||||
DictEntry(void* arg_key, int key_size = 0, hash_t hash = 0, void* value = nullptr,
|
||||
int16_t d = TOO_FAR_TO_REACH, bool copy_key = false)
|
||||
|
|
@ -88,7 +94,7 @@ public:
|
|||
{
|
||||
memcpy(key_here, arg_key, key_size);
|
||||
if ( ! copy_key )
|
||||
delete [] (char*)arg_key; //own the arg_key, now don't need it.
|
||||
delete[](char*) arg_key; // own the arg_key, now don't need it.
|
||||
}
|
||||
else
|
||||
{
|
||||
|
|
@ -104,7 +110,7 @@ public:
|
|||
}
|
||||
}
|
||||
|
||||
bool Empty() const { return distance == TOO_FAR_TO_REACH; }
|
||||
bool Empty() const { return distance == TOO_FAR_TO_REACH; }
|
||||
void SetEmpty()
|
||||
{
|
||||
distance = TOO_FAR_TO_REACH;
|
||||
|
|
@ -115,13 +121,13 @@ public:
|
|||
value = nullptr;
|
||||
key_size = 0;
|
||||
bucket = 0;
|
||||
#endif//DEBUG
|
||||
#endif // DEBUG
|
||||
}
|
||||
|
||||
void Clear()
|
||||
{
|
||||
if( key_size > 8 )
|
||||
delete [] key;
|
||||
if ( key_size > 8 )
|
||||
delete[] key;
|
||||
SetEmpty();
|
||||
}
|
||||
|
||||
|
|
@ -131,27 +137,21 @@ public:
|
|||
return std::make_unique<detail::HashKey>(GetKey(), key_size, hash);
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
T GetValue() const { return static_cast<T>(value); }
|
||||
template <typename T> T GetValue() const { return static_cast<T>(value); }
|
||||
|
||||
bool Equal(const char* arg_key, int arg_key_size, hash_t arg_hash) const
|
||||
{//only 40-bit hash comparison.
|
||||
return ( 0 == ((hash ^ arg_hash) & HASH_MASK) )
|
||||
&& key_size == arg_key_size && 0 == memcmp(GetKey(), arg_key, key_size);
|
||||
{ // only 40-bit hash comparison.
|
||||
return (0 == ((hash ^ arg_hash) & HASH_MASK)) && key_size == arg_key_size &&
|
||||
0 == memcmp(GetKey(), arg_key, key_size);
|
||||
}
|
||||
bool operator==(const DictEntry& r) const
|
||||
{
|
||||
return Equal(r.GetKey(), r.key_size, r.hash);
|
||||
}
|
||||
bool operator!=(const DictEntry& r) const
|
||||
{
|
||||
return ! Equal(r.GetKey(), r.key_size, r.hash);
|
||||
}
|
||||
};
|
||||
bool operator==(const DictEntry& r) const { return Equal(r.GetKey(), r.key_size, r.hash); }
|
||||
bool operator!=(const DictEntry& r) const { return ! Equal(r.GetKey(), r.key_size, r.hash); }
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
} // namespace detail
|
||||
|
||||
class DictIterator {
|
||||
class DictIterator
|
||||
{
|
||||
public:
|
||||
using value_type = detail::DictEntry;
|
||||
using reference = detail::DictEntry&;
|
||||
|
|
@ -171,13 +171,17 @@ public:
|
|||
pointer operator->() { return curr; }
|
||||
|
||||
DictIterator& operator++();
|
||||
DictIterator operator++(int) { auto temp(*this); ++*this; return temp; }
|
||||
DictIterator operator++(int)
|
||||
{
|
||||
auto temp(*this);
|
||||
++*this;
|
||||
return temp;
|
||||
}
|
||||
|
||||
bool operator==( const DictIterator& that ) const { return curr == that.curr; }
|
||||
bool operator!=( const DictIterator& that ) const { return !(*this == that); }
|
||||
bool operator==(const DictIterator& that) const { return curr == that.curr; }
|
||||
bool operator!=(const DictIterator& that) const { return ! (*this == that); }
|
||||
|
||||
private:
|
||||
|
||||
friend class Dictionary;
|
||||
|
||||
DictIterator(const Dictionary* d, detail::DictEntry* begin, detail::DictEntry* end);
|
||||
|
|
@ -185,9 +189,10 @@ private:
|
|||
Dictionary* dict = nullptr;
|
||||
detail::DictEntry* curr = nullptr;
|
||||
detail::DictEntry* end = nullptr;
|
||||
};
|
||||
};
|
||||
|
||||
class RobustDictIterator {
|
||||
class RobustDictIterator
|
||||
{
|
||||
public:
|
||||
using value_type = detail::DictEntry;
|
||||
using reference = detail::DictEntry&;
|
||||
|
|
@ -195,20 +200,25 @@ public:
|
|||
using difference_type = std::ptrdiff_t;
|
||||
using iterator_category = std::forward_iterator_tag;
|
||||
|
||||
RobustDictIterator() : curr(nullptr) {}
|
||||
RobustDictIterator() : curr(nullptr) { }
|
||||
RobustDictIterator(Dictionary* d);
|
||||
RobustDictIterator(const RobustDictIterator& other);
|
||||
RobustDictIterator(RobustDictIterator&& other);
|
||||
~RobustDictIterator();
|
||||
~RobustDictIterator();
|
||||
|
||||
reference operator*() { return curr; }
|
||||
pointer operator->() { return &curr; }
|
||||
|
||||
RobustDictIterator& operator++();
|
||||
RobustDictIterator operator++(int) { auto temp(*this); ++*this; return temp; }
|
||||
RobustDictIterator operator++(int)
|
||||
{
|
||||
auto temp(*this);
|
||||
++*this;
|
||||
return temp;
|
||||
}
|
||||
|
||||
bool operator==( const RobustDictIterator& that ) const { return curr == that.curr; }
|
||||
bool operator!=( const RobustDictIterator& that ) const { return !(*this == that); }
|
||||
bool operator==(const RobustDictIterator& that) const { return curr == that.curr; }
|
||||
bool operator!=(const RobustDictIterator& that) const { return ! (*this == that); }
|
||||
|
||||
private:
|
||||
friend class Dictionary;
|
||||
|
|
@ -225,7 +235,7 @@ private:
|
|||
detail::DictEntry curr;
|
||||
Dictionary* dict = nullptr;
|
||||
int next = -1;
|
||||
};
|
||||
};
|
||||
|
||||
/**
|
||||
* A dictionary type that uses clustered hashing, a variation of Robinhood/Open Addressing
|
||||
|
|
@ -239,16 +249,18 @@ private:
|
|||
* the keys but not the values. The dictionary size will be bounded at around 100K. 1M
|
||||
* entries is the absolute limit. Only Connections use that many entries, and that is rare.
|
||||
*/
|
||||
class Dictionary {
|
||||
class Dictionary
|
||||
{
|
||||
public:
|
||||
explicit Dictionary(DictOrder ordering = UNORDERED, int initial_size = detail::DEFAULT_DICT_SIZE);
|
||||
explicit Dictionary(DictOrder ordering = UNORDERED,
|
||||
int initial_size = detail::DEFAULT_DICT_SIZE);
|
||||
~Dictionary();
|
||||
|
||||
// Member functions for looking up a key, inserting/changing its
|
||||
// contents, and deleting it. These come in two flavors: one
|
||||
// which takes a zeek::detail::HashKey, and the other which takes a raw key,
|
||||
// its size, and its (unmodulated) hash.
|
||||
//lookup may move the key to right place if in the old zone to speed up the next lookup.
|
||||
// lookup may move the key to right place if in the old zone to speed up the next lookup.
|
||||
void* Lookup(const detail::HashKey* key) const;
|
||||
void* Lookup(const void* key, int key_size, detail::hash_t h) const;
|
||||
|
||||
|
|
@ -256,14 +268,17 @@ public:
|
|||
// If iterators_invalidated is supplied, its value is set to true
|
||||
// if the removal may have invalidated any existing iterators.
|
||||
void* Insert(detail::HashKey* key, void* val, bool* iterators_invalidated = nullptr)
|
||||
{ return Insert(key->TakeKey(), key->Size(), key->Hash(), val, false, iterators_invalidated); }
|
||||
{
|
||||
return Insert(key->TakeKey(), key->Size(), key->Hash(), val, false, iterators_invalidated);
|
||||
}
|
||||
|
||||
// If copy_key is true, then the key is copied, otherwise it's assumed
|
||||
// that it's a heap pointer that now belongs to the Dictionary to
|
||||
// manage as needed.
|
||||
// If iterators_invalidated is supplied, its value is set to true
|
||||
// if the removal may have invalidated any existing iterators.
|
||||
void* Insert(void* key, int key_size, detail::hash_t hash, void* val, bool copy_key, bool* iterators_invalidated = nullptr);
|
||||
void* Insert(void* key, int key_size, detail::hash_t hash, void* val, bool copy_key,
|
||||
bool* iterators_invalidated = nullptr);
|
||||
|
||||
// Removes the given element. Returns a pointer to the element in
|
||||
// case it needs to be deleted. Returns 0 if no such element exists.
|
||||
|
|
@ -271,23 +286,23 @@ public:
|
|||
// If iterators_invalidated is supplied, its value is set to true
|
||||
// if the removal may have invalidated any existing iterators.
|
||||
void* Remove(const detail::HashKey* key, bool* iterators_invalidated = nullptr)
|
||||
{ return Remove(key->Key(), key->Size(), key->Hash(), false, iterators_invalidated); }
|
||||
void* Remove(const void* key, int key_size, detail::hash_t hash, bool dont_delete = false, bool* iterators_invalidated = nullptr);
|
||||
{
|
||||
return Remove(key->Key(), key->Size(), key->Hash(), false, iterators_invalidated);
|
||||
}
|
||||
void* Remove(const void* key, int key_size, detail::hash_t hash, bool dont_delete = false,
|
||||
bool* iterators_invalidated = nullptr);
|
||||
|
||||
// Number of entries.
|
||||
int Length() const
|
||||
{ return num_entries; }
|
||||
int Length() const { return num_entries; }
|
||||
|
||||
// Largest it's ever been.
|
||||
int MaxLength() const
|
||||
{ return max_entries; }
|
||||
int MaxLength() const { return max_entries; }
|
||||
|
||||
// Total number of entries ever.
|
||||
uint64_t NumCumulativeInserts() const
|
||||
{ return cum_entries; }
|
||||
uint64_t NumCumulativeInserts() const { return cum_entries; }
|
||||
|
||||
// True if the dictionary is ordered, false otherwise.
|
||||
int IsOrdered() const { return order != nullptr; }
|
||||
int IsOrdered() const { return order != nullptr; }
|
||||
|
||||
// If the dictionary is ordered then returns the n'th entry's value;
|
||||
// the second method also returns the key. The first entry inserted
|
||||
|
|
@ -316,14 +331,17 @@ public:
|
|||
//
|
||||
// If return_hash is true, a HashKey for the entry is returned in h,
|
||||
// which should be delete'd when no longer needed.
|
||||
[[deprecated("Remove in v5.1. Use begin() and the standard-library-compatible version of iteration.")]]
|
||||
IterCookie* InitForIteration() const;
|
||||
[[deprecated("Remove in v5.1. Use begin() and the standard-library-compatible version of iteration.")]]
|
||||
void* NextEntry(detail::HashKey*& h, IterCookie*& cookie, bool return_hash) const;
|
||||
[[deprecated("Remove in v5.1. Use begin() and the standard-library-compatible version of iteration.")]]
|
||||
void StopIteration(IterCookie* cookie) const;
|
||||
[[deprecated("Remove in v5.1. Use begin() and the standard-library-compatible version of "
|
||||
"iteration.")]] IterCookie*
|
||||
InitForIteration() const;
|
||||
[[deprecated("Remove in v5.1. Use begin() and the standard-library-compatible version of "
|
||||
"iteration.")]] void*
|
||||
NextEntry(detail::HashKey*& h, IterCookie*& cookie, bool return_hash) const;
|
||||
[[deprecated("Remove in v5.1. Use begin() and the standard-library-compatible version of "
|
||||
"iteration.")]] void
|
||||
StopIteration(IterCookie* cookie) const;
|
||||
|
||||
void SetDeleteFunc(dict_delete_func f) { delete_func = f; }
|
||||
void SetDeleteFunc(dict_delete_func f) { delete_func = f; }
|
||||
|
||||
// With a robust cookie, it is safe to change the dictionary while
|
||||
// iterating. This means that (i) we will eventually visit all
|
||||
|
|
@ -331,23 +349,25 @@ public:
|
|||
// and (ii) we won't visit any still-unseen entries which are getting
|
||||
// removed. (We don't get this for free, so only use it if
|
||||
// necessary.)
|
||||
[[deprecated("Remove in v5.1. Use begin_robust() and the standard-library-compatible version of iteration.")]]
|
||||
void MakeRobustCookie(IterCookie* cookie);
|
||||
[[deprecated("Remove in v5.1. Use begin_robust() and the standard-library-compatible version "
|
||||
"of iteration.")]] void
|
||||
MakeRobustCookie(IterCookie* cookie);
|
||||
|
||||
// Remove all entries.
|
||||
void Clear();
|
||||
|
||||
[[deprecated("Remove in v5.1. MemoryAllocation() is deprecated and will be removed. See GHI-572.")]]
|
||||
size_t MemoryAllocation() const;
|
||||
[[deprecated("Remove in v5.1. MemoryAllocation() is deprecated and will be removed. See "
|
||||
"GHI-572.")]] size_t
|
||||
MemoryAllocation() const;
|
||||
|
||||
/// The capacity of the table, Buckets + Overflow Size.
|
||||
int Capacity(bool expected = false) const;
|
||||
|
||||
//Debugging
|
||||
// Debugging
|
||||
#ifdef DEBUG
|
||||
void AssertValid() const;
|
||||
#endif//DEBUG
|
||||
void Dump(int level=0) const;
|
||||
#endif // DEBUG
|
||||
void Dump(int level = 0) const;
|
||||
void DistanceStats(int& max_distance, int* distances = 0, int num_distances = 0) const;
|
||||
void DumpKeys() const;
|
||||
|
||||
|
|
@ -362,12 +382,12 @@ public:
|
|||
using reverse_iterator = std::reverse_iterator<iterator>;
|
||||
using const_reverse_iterator = std::reverse_iterator<const_iterator>;
|
||||
|
||||
iterator begin() { return { this, table, table + Capacity() }; }
|
||||
iterator end() { return { this, table + Capacity(), table + Capacity() }; }
|
||||
const_iterator begin() const { return { this, table, table + Capacity() }; }
|
||||
const_iterator end() const { return { this, table + Capacity(), table + Capacity() }; }
|
||||
const_iterator cbegin() { return { this, table, table + Capacity() }; }
|
||||
const_iterator cend() { return { this, table + Capacity(), table + Capacity() }; }
|
||||
iterator begin() { return {this, table, table + Capacity()}; }
|
||||
iterator end() { return {this, table + Capacity(), table + Capacity()}; }
|
||||
const_iterator begin() const { return {this, table, table + Capacity()}; }
|
||||
const_iterator end() const { return {this, table + Capacity(), table + Capacity()}; }
|
||||
const_iterator cbegin() { return {this, table, table + Capacity()}; }
|
||||
const_iterator cend() { return {this, table + Capacity(), table + Capacity()}; }
|
||||
|
||||
RobustDictIterator begin_robust() { return MakeRobustIterator(); }
|
||||
RobustDictIterator end_robust() { return RobustDictIterator(); }
|
||||
|
|
@ -380,7 +400,7 @@ private:
|
|||
/// Buckets of the table, not including overflow size.
|
||||
int Buckets(bool expected = false) const;
|
||||
|
||||
//bucket math
|
||||
// bucket math
|
||||
int Log2(int num) const;
|
||||
int ThresholdEntries() const;
|
||||
|
||||
|
|
@ -419,47 +439,55 @@ private:
|
|||
void Init();
|
||||
|
||||
// Iteration
|
||||
[[deprecated("Remove in v5.1. Use begin() and the standard-library-compatible version of iteration.")]]
|
||||
IterCookie* InitForIterationNonConst();
|
||||
[[deprecated("Remove in v5.1. Use begin() and the standard-library-compatible version of iteration.")]]
|
||||
void* NextEntryNonConst(detail::HashKey*& h, IterCookie*& cookie, bool return_hash);
|
||||
[[deprecated("Remove in v5.1. Use begin() and the standard-library-compatible version of iteration.")]]
|
||||
void StopIterationNonConst(IterCookie* cookie);
|
||||
[[deprecated("Remove in v5.1. Use begin() and the standard-library-compatible version of "
|
||||
"iteration.")]] IterCookie*
|
||||
InitForIterationNonConst();
|
||||
[[deprecated("Remove in v5.1. Use begin() and the standard-library-compatible version of "
|
||||
"iteration.")]] void*
|
||||
NextEntryNonConst(detail::HashKey*& h, IterCookie*& cookie, bool return_hash);
|
||||
[[deprecated("Remove in v5.1. Use begin() and the standard-library-compatible version of "
|
||||
"iteration.")]] void
|
||||
StopIterationNonConst(IterCookie* cookie);
|
||||
|
||||
//Lookup
|
||||
// Lookup
|
||||
int LinearLookupIndex(const void* key, int key_size, detail::hash_t hash) const;
|
||||
int LookupIndex(const void* key, int key_size, detail::hash_t hash, int* insert_position = nullptr,
|
||||
int* insert_distance = nullptr);
|
||||
int LookupIndex(const void* key, int key_size, detail::hash_t hash,
|
||||
int* insert_position = nullptr, int* insert_distance = nullptr);
|
||||
int LookupIndex(const void* key, int key_size, detail::hash_t hash, int begin, int end,
|
||||
int* insert_position = nullptr, int* insert_distance = nullptr);
|
||||
int* insert_position = nullptr, int* insert_distance = nullptr);
|
||||
|
||||
/// Insert entry, Adjust cookies when necessary.
|
||||
void InsertRelocateAndAdjust(detail::DictEntry& entry, int insert_position);
|
||||
|
||||
/// insert entry into position, relocate other entries when necessary.
|
||||
void InsertAndRelocate(detail::DictEntry& entry, int insert_position, int* last_affected_position = nullptr);
|
||||
void InsertAndRelocate(detail::DictEntry& entry, int insert_position,
|
||||
int* last_affected_position = nullptr);
|
||||
|
||||
/// Adjust Cookies on Insert.
|
||||
[[deprecated("Remove in v5.1. Use the standard-library-compatible version of iteration and the version that takes a RobustDictIterator.")]]
|
||||
void AdjustOnInsert(IterCookie* c, const detail::DictEntry& entry, int insert_position, int last_affected_position);
|
||||
void AdjustOnInsert(RobustDictIterator* c, const detail::DictEntry& entry,
|
||||
int insert_position, int last_affected_position);
|
||||
[[deprecated("Remove in v5.1. Use the standard-library-compatible version of iteration and the "
|
||||
"version that takes a RobustDictIterator.")]] void
|
||||
AdjustOnInsert(IterCookie* c, const detail::DictEntry& entry, int insert_position,
|
||||
int last_affected_position);
|
||||
void AdjustOnInsert(RobustDictIterator* c, const detail::DictEntry& entry, int insert_position,
|
||||
int last_affected_position);
|
||||
|
||||
///Remove, Relocate & Adjust cookies.
|
||||
/// Remove, Relocate & Adjust cookies.
|
||||
detail::DictEntry RemoveRelocateAndAdjust(int position);
|
||||
|
||||
///Remove & Relocate
|
||||
/// Remove & Relocate
|
||||
detail::DictEntry RemoveAndRelocate(int position, int* last_affected_position = nullptr);
|
||||
|
||||
///Adjust safe cookies after Removal of entry at position.
|
||||
[[deprecated("Remove in v5.1. Use the standard-library-compatible version of iteration and the version that takes a RobustDictIterator.")]]
|
||||
void AdjustOnRemove(IterCookie* c, const detail::DictEntry& entry, int position, int last_affected_position);
|
||||
void AdjustOnRemove(RobustDictIterator* c, const detail::DictEntry& entry,
|
||||
int position, int last_affected_position);
|
||||
/// Adjust safe cookies after Removal of entry at position.
|
||||
[[deprecated("Remove in v5.1. Use the standard-library-compatible version of iteration and the "
|
||||
"version that takes a RobustDictIterator.")]] void
|
||||
AdjustOnRemove(IterCookie* c, const detail::DictEntry& entry, int position,
|
||||
int last_affected_position);
|
||||
void AdjustOnRemove(RobustDictIterator* c, const detail::DictEntry& entry, int position,
|
||||
int last_affected_position);
|
||||
|
||||
bool Remapping() const { return remap_end >= 0;} //remap in reverse order.
|
||||
bool Remapping() const { return remap_end >= 0; } // remap in reverse order.
|
||||
|
||||
///One round of remap.
|
||||
/// One round of remap.
|
||||
void Remap();
|
||||
|
||||
// Remap an item in position to a new position. Returns true if the relocation was
|
||||
|
|
@ -471,16 +499,18 @@ private:
|
|||
|
||||
bool HaveOnlyRobustIterators() const
|
||||
{
|
||||
return (num_iterators == 0) || ((cookies ? cookies->size() : 0) + (iterators ? iterators->size() : 0) == num_iterators);
|
||||
return (num_iterators == 0) ||
|
||||
((cookies ? cookies->size() : 0) + (iterators ? iterators->size() : 0) ==
|
||||
num_iterators);
|
||||
}
|
||||
|
||||
RobustDictIterator MakeRobustIterator();
|
||||
detail::DictEntry GetNextRobustIteration(RobustDictIterator* iter);
|
||||
|
||||
void IncrIters() { ++num_iterators; }
|
||||
void DecrIters() { --num_iterators; }
|
||||
void IncrIters() { ++num_iterators; }
|
||||
void DecrIters() { --num_iterators; }
|
||||
|
||||
//alligned on 8-bytes with 4-leading bytes. 7*8=56 bytes a dictionary.
|
||||
// alligned on 8-bytes with 4-leading bytes. 7*8=56 bytes a dictionary.
|
||||
|
||||
// when sizeup but the current mapping is in progress. the current mapping will be ignored
|
||||
// as it will be remapped to new dict size anyway. however, the missed count is recorded
|
||||
|
|
@ -507,58 +537,64 @@ private:
|
|||
|
||||
// Order means the order of insertion. means no deletion until exit. will be inefficient.
|
||||
std::vector<detail::DictEntry>* order = nullptr;
|
||||
};
|
||||
};
|
||||
|
||||
/*
|
||||
* Template specialization of Dictionary that stores pointers for values.
|
||||
*/
|
||||
template<typename T>
|
||||
class PDict : public Dictionary {
|
||||
template <typename T> class PDict : public Dictionary
|
||||
{
|
||||
public:
|
||||
explicit PDict(DictOrder ordering = UNORDERED, int initial_size = 0) :
|
||||
Dictionary(ordering, initial_size) {}
|
||||
explicit PDict(DictOrder ordering = UNORDERED, int initial_size = 0)
|
||||
: Dictionary(ordering, initial_size)
|
||||
{
|
||||
}
|
||||
T* Lookup(const char* key) const
|
||||
{
|
||||
detail::HashKey h(key);
|
||||
return (T*) Dictionary::Lookup(&h);
|
||||
return (T*)Dictionary::Lookup(&h);
|
||||
}
|
||||
T* Lookup(const detail::HashKey* key) const
|
||||
{ return (T*) Dictionary::Lookup(key); }
|
||||
T* Lookup(const detail::HashKey* key) const { return (T*)Dictionary::Lookup(key); }
|
||||
T* Insert(const char* key, T* val, bool* iterators_invalidated = nullptr)
|
||||
{
|
||||
detail::HashKey h(key);
|
||||
return (T*) Dictionary::Insert(&h, (void*) val, iterators_invalidated);
|
||||
return (T*)Dictionary::Insert(&h, (void*)val, iterators_invalidated);
|
||||
}
|
||||
T* Insert(detail::HashKey* key, T* val, bool* iterators_invalidated = nullptr)
|
||||
{ return (T*) Dictionary::Insert(key, (void*) val, iterators_invalidated); }
|
||||
T* NthEntry(int n) const
|
||||
{ return (T*) Dictionary::NthEntry(n); }
|
||||
{
|
||||
return (T*)Dictionary::Insert(key, (void*)val, iterators_invalidated);
|
||||
}
|
||||
T* NthEntry(int n) const { return (T*)Dictionary::NthEntry(n); }
|
||||
T* NthEntry(int n, const char*& key) const
|
||||
{
|
||||
int key_len;
|
||||
return (T*) Dictionary::NthEntry(n, (const void*&) key, key_len);
|
||||
return (T*)Dictionary::NthEntry(n, (const void*&)key, key_len);
|
||||
}
|
||||
[[deprecated("Remove in v5.1. Use the standard-library-compatible version of iteration.")]]
|
||||
T* NextEntry(IterCookie*& cookie) const
|
||||
[[deprecated("Remove in v5.1. Use the standard-library-compatible version of iteration.")]] T*
|
||||
NextEntry(IterCookie*& cookie) const
|
||||
{
|
||||
detail::HashKey* h;
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
|
||||
return (T*) Dictionary::NextEntry(h, cookie, false);
|
||||
return (T*)Dictionary::NextEntry(h, cookie, false);
|
||||
#pragma GCC diagnostic pop
|
||||
}
|
||||
[[deprecated("Remove in v5.1. Use the standard-library-compatible version of iteration.")]]
|
||||
T* NextEntry(detail::HashKey*& h, IterCookie*& cookie) const
|
||||
[[deprecated("Remove in v5.1. Use the standard-library-compatible version of iteration.")]] T*
|
||||
NextEntry(detail::HashKey*& h, IterCookie*& cookie) const
|
||||
{
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
|
||||
return (T*) Dictionary::NextEntry(h, cookie, true);
|
||||
return (T*)Dictionary::NextEntry(h, cookie, true);
|
||||
#pragma GCC diagnostic pop
|
||||
}
|
||||
T* RemoveEntry(const detail::HashKey* key, bool* iterators_invalidated = nullptr)
|
||||
{ return (T*) Remove(key->Key(), key->Size(), key->Hash(), false, iterators_invalidated); }
|
||||
{
|
||||
return (T*)Remove(key->Key(), key->Size(), key->Hash(), false, iterators_invalidated);
|
||||
}
|
||||
T* RemoveEntry(const detail::HashKey& key, bool* iterators_invalidated = nullptr)
|
||||
{ return (T*) Remove(key.Key(), key.Size(), key.Hash(), false, iterators_invalidated); }
|
||||
};
|
||||
{
|
||||
return (T*)Remove(key.Key(), key.Size(), key.Hash(), false, iterators_invalidated);
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace zeek
|
||||
} // namespace zeek
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue