souffle::profile::EventProcessorSingleton Class Reference

Event Processor Singleton. More...

#include <EventProcessor.h>

Collaboration diagram for souffle::profile::EventProcessorSingleton:

Public Member Functions
void	process (ProfileDatabase &db, const char *txt,...)
	process a profile event More...
void	registerEventProcessor (const std::string &keyword, EventProcessor *processor)
	register an event processor with its keyword More...

Static Public Member Functions
static EventProcessorSingleton &	instance ()
	get instance More...

Private Member Functions
std::string	escape (const std::string &text)
	Escape escape characters. More...
	EventProcessorSingleton ()=default

Static Private Member Functions
static std::vector< std::string >	split (std::string str, std::string split_str)
	split string More...
static std::vector< std::string >	splitSignature (std::string str)
	split string separated by semi-colon More...

Private Attributes
std::map< std::string, EventProcessor * >	registry
	keyword / event processor mapping More...

Detailed Description

Event Processor Singleton.

Singleton that is the connection point for events

Definition at line 67 of file EventProcessor.h.

Constructor & Destructor Documentation

EventProcessorSingleton()

souffle::profile::EventProcessorSingleton::EventProcessorSingleton ( )

privatedefault

Member Function Documentation

escape()

std::string souffle::profile::EventProcessorSingleton::escape ( const std::string &  text )

inlineprivate

Escape escape characters.

Remove all escapes, then escape double quotes.

Definition at line 111 of file EventProcessor.h.

                                                                          {
        // repeat value when splitting so "a   b" -> ["a","b"] not ["a","","","","b"]
        bool repeat = (split_str == " ");
 
        std::vector<std::string> elems;
 
        std::string temp;
        std::string hold;
        for (size_t i = 0; i < str.size(); i++) {
            if (repeat) {
                if (str.at(i) == split_str.at(0)) {
                    while (str.at(++i) == split_str.at(0)) {

instance()

static EventProcessorSingleton& souffle::profile::EventProcessorSingleton::instance ( )

inlinestatic

get instance

Definition at line 70 of file EventProcessor.h.

Referenced by souffle::ProfileEventSingleton::makeConfigRecord(), souffle::profile::NonRecursiveRuleNumberProcessor::process(), souffle::profile::NonRecursiveRelationNumberProcessor::process(), souffle::profile::RecursiveRelationNumberProcessor::process(), souffle::profile::RelationIOTimingProcessor::process(), souffle::profile::ProgramResourceUtilisationProcessor::process(), and souffle::ProfileEventSingleton::~ProfileEventSingleton().

process()

void souffle::profile::EventProcessorSingleton::process ( ProfileDatabase &  db, const char *  txt,   ...  )

inline

process a profile event

Definition at line 81 of file EventProcessor.h.

       :
    /** keyword / event processor mapping */
    std::map<std::string, EventProcessor*> registry;
 
    EventProcessorSingleton() = default;
 
    /**
     * Escape escape characters.
     *
     * Remove all escapes, then escape double quotes.
     */
    std::string escape(const std::string& text) {
        std::string str(text);

Referenced by souffle::ProfileEventSingleton::makeConfigRecord(), and souffle::ProfileEventSingleton::~ProfileEventSingleton().

registerEventProcessor()

void souffle::profile::EventProcessorSingleton::registerEventProcessor ( const std::string &  keyword, EventProcessor *  processor  )

inline

register an event processor with its keyword

Definition at line 76 of file EventProcessor.h.

       :
    /** keyword / event processor mapping */

Referenced by souffle::profile::NonRecursiveRuleNumberProcessor::process(), souffle::profile::NonRecursiveRelationNumberProcessor::process(), souffle::profile::RecursiveRelationNumberProcessor::process(), souffle::profile::RelationIOTimingProcessor::process(), and souffle::profile::ProgramResourceUtilisationProcessor::process().

split()

static std::vector<std::string> souffle::profile::EventProcessorSingleton::split ( std::string  str, std::string  split_str  )

inlinestaticprivate

split string

Definition at line 130 of file EventProcessor.h.

                   {
                temp += str.at(i);
                hold += str.at(i);
                for (size_t j = 0; j < hold.size(); j++) {
                    if (hold[j] != split_str[j]) {
                        hold = "";
                    }
                }
                if (hold.size() == split_str.size()) {
                    elems.push_back(temp.substr(0, temp.size() - hold.size()));
                    hold = "";
                    temp = "";
                }
            }
        }
        if (!temp.empty()) {
            elems.push_back(temp);
        }
 
        return elems;
    }
 
    /** split string separated by semi-colon */
    static std::vector<std::string> splitSignature(std::string str) {
        for (size_t i = 0; i < str.size(); i++) {
            if (i > 0 && str[i] == ';' && str[i - 1] == '\\') {
                // I'm assuming this isn't a thing that will be naturally found in souffle profiler files
                str[i - 1] = '\b';
                str.erase(i--, 1);
            }
        }
        std::vector<std::string> result = split(str, ";");
        for (auto& i : result) {
            for (char& j : i) {
                if (j == '\b') {

splitSignature()

static std::vector<std::string> souffle::profile::EventProcessorSingleton::splitSignature ( std::string  str )

inlinestaticprivate

split string separated by semi-colon

Definition at line 171 of file EventProcessor.h.

                                            : public EventProcessor {
public:
    NonRecursiveRuleTimingProcessor() {
        EventProcessorSingleton::instance().registerEventProcessor("@t-nonrecursive-rule", this);
    }
    void process(ProfileDatabase& db, const std::vector<std::string>& signature, va_list& args) override {
        const std::string& relation = signature[1];
        const std::string& srcLocator = signature[2];
        const std::string& rule = signature[3];

Field Documentation

registry

std::map<std::string, EventProcessor*> souffle::profile::EventProcessorSingleton::registry

private

keyword / event processor mapping

Definition at line 102 of file EventProcessor.h.

---

The documentation for this class was generated from the following file:

• include/souffle/profile/EventProcessor.h