mirror of
https://github.com/zeek/zeek.git
synced 2025-10-06 00:28:21 +00:00
0db61f3094
The Zeek code base has very inconsistent #includes. Many sources included a few headers, and those headers included other headers, and in the end, nearly everything is included everywhere, so missing #includes were never noticed. Another side effect was a lot of header bloat which slows down the build. First step to fix it: in each source file, its own header should be included first to verify that each header's includes are correct, and none is missing. After adding the missing #includes, I replaced lots of #includes inside headers with class forward declarations. In most headers, object pointers are never referenced, so declaring the function prototypes with forward-declared classes is just fine. This patch speeds up the build by 19%, because each compilation unit gets smaller. Here are the "time" numbers for a fresh build (with a warm page cache but without ccache): Before this patch: 3144.94user 161.63system 3:02.87elapsed 1808%CPU (0avgtext+0avgdata 2168608maxresident)k 760inputs+12008400outputs (1511major+57747204minor)pagefaults 0swaps After this patch: 2565.17user 141.83system 2:25.46elapsed 1860%CPU (0avgtext+0avgdata 1489076maxresident)k 72576inputs+9130920outputs (1667major+49400430minor)pagefaults 0swaps
90 lines
2.4 KiB
C++
90 lines
2.4 KiB
C++
// Capsulates local and remote event handlers.
|
|
|
|
#pragma once
|
|
|
|
#include "BroList.h"
|
|
|
|
#include <unordered_set>
|
|
#include <string>
|
|
|
|
class Func;
|
|
class FuncType;
|
|
|
|
class EventHandler {
|
|
public:
|
|
explicit EventHandler(const char* name);
|
|
~EventHandler();
|
|
|
|
const char* Name() { return name; }
|
|
Func* LocalHandler() { return local; }
|
|
FuncType* FType(bool check_export = true);
|
|
|
|
void SetLocalHandler(Func* f);
|
|
|
|
void AutoPublish(std::string topic)
|
|
{
|
|
auto_publish.insert(std::move(topic));
|
|
}
|
|
|
|
void AutoUnpublish(const std::string& topic)
|
|
{
|
|
auto_publish.erase(topic);
|
|
}
|
|
|
|
void Call(val_list* vl, bool no_remote = false);
|
|
|
|
// Returns true if there is at least one local or remote handler.
|
|
explicit operator bool() const;
|
|
|
|
void SetUsed() { used = true; }
|
|
bool Used() { return used; }
|
|
|
|
// Handlers marked as error handlers will not be called recursively to
|
|
// avoid infinite loops if they trigger a similar error themselves.
|
|
void SetErrorHandler() { error_handler = true; }
|
|
bool ErrorHandler() { return error_handler; }
|
|
|
|
void SetEnable(bool arg_enable) { enabled = arg_enable; }
|
|
|
|
// Flags the event as interesting even if there is no body defined. In
|
|
// particular, this will then still pass the event on to plugins.
|
|
void SetGenerateAlways() { generate_always = true; }
|
|
bool GenerateAlways() { return generate_always; }
|
|
|
|
private:
|
|
void NewEvent(val_list* vl); // Raise new_event() meta event.
|
|
|
|
const char* name;
|
|
Func* local;
|
|
FuncType* type;
|
|
bool used; // this handler is indeed used somewhere
|
|
bool enabled;
|
|
bool error_handler; // this handler reports error messages.
|
|
bool generate_always;
|
|
|
|
std::unordered_set<std::string> auto_publish;
|
|
};
|
|
|
|
// Encapsulates a ptr to an event handler to overload the boolean operator.
|
|
class EventHandlerPtr {
|
|
public:
|
|
EventHandlerPtr(EventHandler* p = 0) { handler = p; }
|
|
EventHandlerPtr(const EventHandlerPtr& h) { handler = h.handler; }
|
|
|
|
const EventHandlerPtr& operator=(EventHandler* p)
|
|
{ handler = p; return *this; }
|
|
const EventHandlerPtr& operator=(const EventHandlerPtr& h)
|
|
{ handler = h.handler; return *this; }
|
|
|
|
bool operator==(const EventHandlerPtr& h) const
|
|
{ return handler == h.handler; }
|
|
|
|
EventHandler* Ptr() { return handler; }
|
|
|
|
explicit operator bool() const { return handler && *handler; }
|
|
EventHandler* operator->() { return handler; }
|
|
const EventHandler* operator->() const { return handler; }
|
|
|
|
private:
|
|
EventHandler* handler;
|
|
};
|