Mirror/zeek
1
0
Fork 0
mirror of https://github.com/zeek/zeek.git synced 2025-10-07 17:18:20 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

Base: Clean up explicit uses of namespaces in places where they're not necessary.

Browse source 
This commit covers all of the common and base classes.
This commit is contained in:
Tim Wojtulewicz 2020-08-21 09:29:37 -07:00
parent 9f802b2a4d
commit fe0c22c789
240 changed files with 6823 additions and 6787 deletions
Download patch file Download diff file Expand all files Collapse all files

12
src/probabilistic/BloomFilter.cc
View file

@ -110,13 +110,13 @@ bool BasicBloomFilter::Merge(const BloomFilter* other)
if ( ! hasher->Equals(o->hasher) )
{
zeek::reporter->Error("incompatible hashers in BasicBloomFilter merge");
reporter->Error("incompatible hashers in BasicBloomFilter merge");
return false;
}
else if ( bits->Size() != o->bits->Size() )
{
zeek::reporter->Error("different bitvector size in BasicBloomFilter merge");
reporter->Error("different bitvector size in BasicBloomFilter merge");
return false;
}
@ -137,7 +137,7 @@ BasicBloomFilter* BasicBloomFilter::Clone() const
std::string BasicBloomFilter::InternalState() const
{
return zeek::util::fmt("%" PRIu64, bits->Hash());
return util::fmt("%" PRIu64, bits->Hash());
}
BasicBloomFilter::BasicBloomFilter()
@ -229,13 +229,13 @@ bool CountingBloomFilter::Merge(const BloomFilter* other)
if ( ! hasher->Equals(o->hasher) )
{
zeek::reporter->Error("incompatible hashers in CountingBloomFilter merge");
reporter->Error("incompatible hashers in CountingBloomFilter merge");
return false;
}
else if ( cells->Size() != o->cells->Size() )
{
zeek::reporter->Error("different bitvector size in CountingBloomFilter merge");
reporter->Error("different bitvector size in CountingBloomFilter merge");
return false;
}
@ -256,7 +256,7 @@ CountingBloomFilter* CountingBloomFilter::Clone() const
std::string CountingBloomFilter::InternalState() const
{
return zeek::util::fmt("%" PRIu64, cells->Hash());
return util::fmt("%" PRIu64, cells->Hash());
}
// TODO: Use partitioning in add/count to allow for reusing CMS bounds.

4
src/probabilistic/CardinalityCounter.cc
View file

@ -50,11 +50,11 @@ void CardinalityCounter::Init(uint64_t size)
alpha_m = 0.7213 / (1 + 1.079 / m);
else
zeek::reporter->InternalError("Invalid size %" PRIu64 ". Size either has to be 16, 32, 64 or bigger than 128", size);
reporter->InternalError("Invalid size %" PRIu64 ". Size either has to be 16, 32, 64 or bigger than 128", size);
double calc_p = log2(m);
if ( trunc(calc_p) != calc_p )
zeek::reporter->InternalError("Invalid size %" PRIu64 ". Size either has to be a power of 2", size);
reporter->InternalError("Invalid size %" PRIu64 ". Size either has to be a power of 2", size);
p = calc_p;

8
src/probabilistic/Hasher.cc
View file

@ -23,7 +23,7 @@ Hasher::seed_t Hasher::MakeSeed(const void* data, size_t size)
assert(sizeof(tmpseed) == 16);
static auto global_hash_seed = zeek::id::find_val<zeek::StringVal>("global_hash_seed");
static auto global_hash_seed = id::find_val<StringVal>("global_hash_seed");
if ( data )
zeek::detail::hash_update(ctx, data, size);
@ -33,7 +33,7 @@ Hasher::seed_t Hasher::MakeSeed(const void* data, size_t size)
else
{
unsigned int first_seed = zeek::util::detail::initial_seed();
unsigned int first_seed = util::detail::initial_seed();
zeek::detail::hash_update(ctx, &first_seed, sizeof(first_seed));
}
@ -119,7 +119,7 @@ DefaultHasher::DefaultHasher(size_t k, Hasher::seed_t seed)
for ( size_t i = 1; i <= k; ++i )
{
seed_t s = Seed();
s.h[0] += zeek::util::detail::prng(i);
s.h[0] += util::detail::prng(i);
hash_functions.push_back(UHF(s));
}
}
@ -149,7 +149,7 @@ bool DefaultHasher::Equals(const Hasher* other) const
}
DoubleHasher::DoubleHasher(size_t k, seed_t seed)
: Hasher(k, seed), h1(seed + zeek::util::detail::prng(1)), h2(seed + zeek::util::detail::prng(2))
: Hasher(k, seed), h1(seed + util::detail::prng(1)), h2(seed + util::detail::prng(2))
{
}

36
src/probabilistic/Topk.cc
View file

@ -17,11 +17,11 @@ static void topk_element_hash_delete_func(void* val)
delete e;
}
void TopkVal::Typify(zeek::TypePtr t)
void TopkVal::Typify(TypePtr t)
{
assert(!hash && !type);
type = std::move(t);
auto tl = zeek::make_intrusive<zeek::TypeList>(type);
auto tl = make_intrusive<TypeList>(type);
tl->Append(type);
hash = new zeek::detail::CompositeHash(std::move(tl));
}
@ -35,7 +35,7 @@ zeek::detail::HashKey* TopkVal::GetHash(Val* v) const
TopkVal::TopkVal(uint64_t arg_size) : OpaqueVal(topk_type)
{
elementDict = new zeek::PDict<Element>;
elementDict = new PDict<Element>;
elementDict->SetDeleteFunc(topk_element_hash_delete_func);
size = arg_size;
numElements = 0;
@ -45,7 +45,7 @@ TopkVal::TopkVal(uint64_t arg_size) : OpaqueVal(topk_type)
TopkVal::TopkVal() : OpaqueVal(topk_type)
{
elementDict = new zeek::PDict<Element>;
elementDict = new PDict<Element>;
elementDict->SetDeleteFunc(topk_element_hash_delete_func);
size = 0;
numElements = 0;
@ -87,7 +87,7 @@ void TopkVal::Merge(const TopkVal* value, bool doPrune)
{
if ( ! same_type(type, value->type) )
{
zeek::reporter->Error("Cannot merge top-k elements of differing types.");
reporter->Error("Cannot merge top-k elements of differing types.");
return;
}
}
@ -175,23 +175,23 @@ void TopkVal::Merge(const TopkVal* value, bool doPrune)
}
}
zeek::ValPtr TopkVal::DoClone(CloneState* state)
ValPtr TopkVal::DoClone(CloneState* state)
{
auto clone = zeek::make_intrusive<TopkVal>(size);
auto clone = make_intrusive<TopkVal>(size);
clone->Merge(this);
return state->NewClone(this, std::move(clone));
}
zeek::VectorValPtr TopkVal::GetTopK(int k) const // returns vector
VectorValPtr TopkVal::GetTopK(int k) const // returns vector
{
if ( numElements == 0 )
{
zeek::reporter->Error("Cannot return topk of empty");
reporter->Error("Cannot return topk of empty");
return nullptr;
}
auto v = zeek::make_intrusive<zeek::VectorType>(type);
auto t = zeek::make_intrusive<zeek::VectorVal>(std::move(v));
auto v = make_intrusive<VectorType>(type);
auto t = make_intrusive<VectorVal>(std::move(v));
// this does no estimation if the results is correct!
// in any case - just to make this future-proof (and I am lazy) - this can return more than k.
@ -228,7 +228,7 @@ uint64_t TopkVal::GetCount(Val* value) const
if ( e == nullptr )
{
zeek::reporter->Error("GetCount for element that is not in top-k");
reporter->Error("GetCount for element that is not in top-k");
return 0;
}
@ -243,7 +243,7 @@ uint64_t TopkVal::GetEpsilon(Val* value) const
if ( e == nullptr )
{
zeek::reporter->Error("GetEpsilon for element that is not in top-k");
reporter->Error("GetEpsilon for element that is not in top-k");
return 0;
}
@ -263,12 +263,12 @@ uint64_t TopkVal::GetSum() const
}
if ( pruned )
zeek::reporter->Warning("TopkVal::GetSum() was used on a pruned data structure. Result values do not represent total element count");
reporter->Warning("TopkVal::GetSum() was used on a pruned data structure. Result values do not represent total element count");
return sum;
}
void TopkVal::Encountered(zeek::ValPtr encountered)
void TopkVal::Encountered(ValPtr encountered)
{
// ok, let's see if we already know this one.
@ -277,7 +277,7 @@ void TopkVal::Encountered(zeek::ValPtr encountered)
else
if ( ! same_type(type, encountered->GetType()) )
{
zeek::reporter->Error("Trying to add element to topk with differing type from other elements");
reporter->Error("Trying to add element to topk with differing type from other elements");
return;
}
@ -429,7 +429,7 @@ broker::expected<broker::data> TopkVal::DoSerialize() const
{
Element* element = *eit;
d.emplace_back(element->epsilon);
auto v = zeek::Broker::detail::val_to_data(element->value.get());
auto v = Broker::detail::val_to_data(element->value.get());
if ( ! v )
return broker::ec::invalid_data;
@ -494,7 +494,7 @@ bool TopkVal::DoUnserialize(const broker::data& data)
for ( uint64_t j = 0; j < *elements_count; j++ )
{
auto epsilon = caf::get_if<uint64_t>(&(*v)[idx++]);
auto val = zeek::Broker::detail::data_to_val((*v)[idx++], type.get());
auto val = Broker::detail::data_to_val((*v)[idx++], type.get());
if ( ! (epsilon && val) )
return false;

18
src/probabilistic/Topk.h
View file

@ -27,11 +27,11 @@ struct Bucket {
struct Element {
uint64_t epsilon;
zeek::ValPtr value;
ValPtr value;
Bucket* parent;
};
class TopkVal : public zeek::OpaqueVal {
class TopkVal : public OpaqueVal {
public:
/**
@ -55,7 +55,7 @@ public:
*
* @param value The encountered element
*/
void Encountered(zeek::ValPtr value);
void Encountered(ValPtr value);
/**
* Get the first *k* elements of the result vector. At the moment,
@ -66,7 +66,7 @@ public:
*
* @returns The top-k encountered elements
*/
zeek::VectorValPtr GetTopK(int k) const;
VectorValPtr GetTopK(int k) const;
/**
* Get the current count tracked in the top-k data structure for a
@ -125,7 +125,7 @@ public:
*
* @returns cloned TopkVal
*/
zeek::ValPtr DoClone(CloneState* state) override;
ValPtr DoClone(CloneState* state) override;
DECLARE_OPAQUE_VALUE(TopkVal)
@ -153,7 +153,7 @@ private:
* @returns HashKey for value
*/
zeek::detail::HashKey* GetHash(Val* v) const; // this probably should go somewhere else.
zeek::detail::HashKey* GetHash(const zeek::ValPtr& v) const
zeek::detail::HashKey* GetHash(const ValPtr& v) const
{ return GetHash(v.get()); }
/**
@ -161,12 +161,12 @@ private:
*
* @param t type that is tracked
*/
void Typify(zeek::TypePtr t);
void Typify(TypePtr t);
zeek::TypePtr type;
TypePtr type;
zeek::detail::CompositeHash* hash;
std::list<Bucket*> buckets;
zeek::PDict<Element>* elementDict;
PDict<Element>* elementDict;
uint64_t size; // how many elements are we tracking?
uint64_t numElements; // how many elements do we have at the moment
bool pruned; // was this data structure pruned?