Today's the day. Renamed platform to framework.

events/eventmatching/EventIdRangeMatcher.cpp

@@ -0,0 +1,19 @@
+/*
+ * EventIdRangeMatcher.cpp
+ *
+ *  Created on: 27.08.2015
+ *      Author: baetz
+ */
+
+#include <framework/events/eventmatching/EventIdRangeMatcher.h>
+
+EventIdRangeMatcher::EventIdRangeMatcher(EventId_t lower, EventId_t upper,
+		bool inverted) : EventRangeMatcherBase<EventId_t>(lower, upper, inverted) {
+}
+
+EventIdRangeMatcher::~EventIdRangeMatcher() {
+}
+
+bool EventIdRangeMatcher::match(EventMessage* message) {
+	return rangeMatcher.match(message->getEventId());
+}

events/eventmatching/EventIdRangeMatcher.h

@@ -0,0 +1,20 @@
+/*
+ * EventIdRangeMatcher.h
+ *
+ *  Created on: 27.08.2015
+ *      Author: baetz
+ */
+
+#ifndef FRAMEWORK_EVENTS_EVENTMATCHING_EVENTIDRANGEMATCHER_H_
+#define FRAMEWORK_EVENTS_EVENTMATCHING_EVENTIDRANGEMATCHER_H_
+
+#include <framework/events/eventmatching/EventRangeMatcherBase.h>
+
+class EventIdRangeMatcher: public EventRangeMatcherBase<EventId_t> {
+public:
+	EventIdRangeMatcher(EventId_t lower, EventId_t upper, bool inverted);
+	~EventIdRangeMatcher();
+	bool match(EventMessage* message);
+};
+
+#endif /* FRAMEWORK_EVENTS_EVENTMATCHING_EVENTIDRANGEMATCHER_H_ */

events/eventmatching/EventMatchTree.cpp

@@ -0,0 +1,151 @@
+/*
+ * EventMatchTree.cpp
+ *
+ *  Created on: 27.08.2015
+ *      Author: baetz
+ */
+
+#include <framework/events/eventmatching/EventIdRangeMatcher.h>
+#include <framework/events/eventmatching/EventMatchTree.h>
+#include <framework/events/eventmatching/ReporterRangeMatcher.h>
+#include <framework/events/eventmatching/SeverityRangeMatcher.h>
+
+EventMatchTree::EventMatchTree(StorageManagerIF* storageBackend, bool invertedMatch) :
+		MatchTree<EventMessage*>(end(), 1), factory(storageBackend), invertedMatch(invertedMatch) {
+}
+
+EventMatchTree::~EventMatchTree() {
+}
+
+bool EventMatchTree::match(EventMessage* number) {
+	if (invertedMatch) {
+		return !MatchTree<EventMessage*>::match(number);
+	} else {
+		return MatchTree<EventMessage*>::match(number);
+	}
+}
+
+ReturnValue_t EventMatchTree::addMatch(EventId_t idFrom,
+		EventId_t idTo, bool idInverted, object_id_t reporterFrom,
+		object_id_t reporterTo, bool reporterInverted) {
+	if (idFrom == 0) {
+		//Assuming all events shall be forwarded.
+		idTo = 0;
+		idInverted = true;
+	}
+	if (idTo == 0) {
+		idTo = idFrom;
+	}
+	iterator lastTest;
+	ReturnValue_t result = findOrInsertRangeMatcher<EventId_t, EventIdRangeMatcher>(
+			begin(), idFrom, idTo, idInverted, &lastTest);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	if (reporterFrom == 0) {
+		//No need to add another AND branch
+		return RETURN_OK;
+	}
+	if (reporterTo == 0) {
+		reporterTo = reporterFrom;
+	}
+	return findOrInsertRangeMatcher<object_id_t, ReporterRangeMatcher>(
+			lastTest.left(), reporterFrom, reporterTo, reporterInverted,
+			&lastTest);
+}
+
+ReturnValue_t EventMatchTree::removeMatch(EventId_t idFrom,
+		EventId_t idTo, bool idInverted, object_id_t reporterFrom,
+		object_id_t reporterTo, bool reporterInverted) {
+
+	iterator foundElement;
+
+	if (idFrom == 0) {
+		//Assuming a "forward all events" request.
+		idTo = 0;
+		idInverted = true;
+	}
+	if (idTo == 0) {
+		idTo = idFrom;
+	}
+	foundElement = findRangeMatcher<EventId_t, EventIdRangeMatcher>(
+			begin(), idFrom, idTo, idInverted);
+	if (foundElement == end()) {
+		return NO_MATCH; //Can't tell if too detailed or just not found.
+	}
+	if (reporterFrom == 0) {
+		if (foundElement.left() == end()) {
+			return removeElementAndReconnectChildren(foundElement);
+		} else {
+			return TOO_GENERAL_REQUEST;
+		}
+	}
+	if (reporterTo == 0) {
+		reporterTo = reporterFrom;
+	}
+	foundElement = findRangeMatcher<object_id_t, ReporterRangeMatcher>(
+			foundElement.left(), reporterFrom, reporterTo, reporterInverted);
+	if (foundElement == end()) {
+		return NO_MATCH;
+	} else {
+		return removeElementAndReconnectChildren(foundElement);
+	}
+}
+
+template<typename VALUE_T, typename INSERTION_T>
+inline ReturnValue_t EventMatchTree::findOrInsertRangeMatcher(iterator start,
+		VALUE_T idFrom, VALUE_T idTo, bool inverted, iterator* lastTest) {
+	bool attachToBranch = AND;
+	iterator iter = start;
+	while (iter != end()) {
+		INSERTION_T* matcher = static_cast<INSERTION_T*>(*iter);
+		attachToBranch = OR;
+		*lastTest = iter;
+		if ((matcher->rangeMatcher.lowerBound == idFrom)
+				&& (matcher->rangeMatcher.upperBound == idTo)
+				&& (matcher->rangeMatcher.inverted == inverted)) {
+			return RETURN_OK;
+		} else {
+			iter = iter.right();
+		}
+	}
+	//Only reached if nothing was found.
+	SerializeableMatcherIF<EventMessage*>* newContent = factory.generate<
+			INSERTION_T>(idFrom, idTo, inverted);
+	if (newContent == NULL) {
+		return FULL;
+	}
+	Node* newNode = factory.generate<Node>(newContent);
+	if (newNode == NULL) {
+		return FULL;
+	}
+	*lastTest = insert(attachToBranch, *lastTest, newNode);
+	if (*lastTest == end()) {
+		//This actaully never fails, so creating a dedicated returncode seems an overshoot.
+		return RETURN_FAILED;
+	}
+	return RETURN_OK;
+}
+
+template<typename VALUE_T, typename INSERTION_T>
+EventMatchTree::iterator EventMatchTree::findRangeMatcher(iterator start,
+		VALUE_T idFrom, VALUE_T idTo, bool inverted) {
+	iterator iter = start;
+	while (iter != end()) {
+		INSERTION_T* matcher = static_cast<INSERTION_T*>(*iter);
+		if ((matcher->rangeMatcher.lowerBound == idFrom)
+				&& (matcher->rangeMatcher.upperBound == idTo)
+				&& (matcher->rangeMatcher.inverted == inverted)) {
+			break;
+		} else {
+			iter = iter.right(); //next OR element
+		}
+	}
+	return iter;
+}
+
+ReturnValue_t EventMatchTree::cleanUpElement(iterator position) {
+	//TODO: What if first deletion fails?
+	factory.destroy(position.element->value);
+	return factory.destroy(position.element);
+}

events/eventmatching/EventMatchTree.h

@@ -0,0 +1,43 @@
+/*
+ * EventMatchTree.h
+ *
+ *  Created on: 27.08.2015
+ *      Author: baetz
+ */
+
+#ifndef FRAMEWORK_EVENTS_EVENTMATCHING_EVENTMATCHTREE_H_
+#define FRAMEWORK_EVENTS_EVENTMATCHING_EVENTMATCHTREE_H_
+
+#include <framework/container/PlacementFactory.h>
+#include <framework/events/EventMessage.h>
+#include <framework/globalfunctions/matching/MatchTree.h>
+#include <framework/returnvalues/HasReturnvaluesIF.h>
+class StorageManagerIF;
+
+class EventMatchTree: public MatchTree<EventMessage*>, public HasReturnvaluesIF {
+public:
+	EventMatchTree(StorageManagerIF* storageBackend, bool invertedMatch);
+	virtual ~EventMatchTree();
+	ReturnValue_t addMatch(EventId_t idFrom = 0, EventId_t idTo = 0, bool idInverted = false,
+			object_id_t reporterFrom = 0, object_id_t reporterTo = 0,
+			bool reporterInverted = false);
+	ReturnValue_t removeMatch(EventId_t idFrom = 0, EventId_t idTo = 0, bool idInverted = false,
+			object_id_t reporterFrom = 0, object_id_t reporterTo = 0,
+			bool reporterInverted = false);
+	bool match(EventMessage* number);
+protected:
+	ReturnValue_t cleanUpElement(iterator position);
+private:
+	PlacementFactory factory;
+	bool invertedMatch;
+	template<typename VALUE_T, typename INSERTION_T>
+	ReturnValue_t findOrInsertRangeMatcher(iterator start, VALUE_T idFrom,
+			VALUE_T idTo, bool inverted, iterator* lastTest);
+
+	template<typename VALUE_T, typename INSERTION_T>
+	iterator findRangeMatcher(iterator start, VALUE_T idFrom, VALUE_T idTo,
+			bool inverted);
+
+};
+
+#endif /* FRAMEWORK_EVENTS_EVENTMATCHING_EVENTMATCHTREE_H_ */

events/eventmatching/EventRangeMatcherBase.h

@@ -0,0 +1,36 @@
+/*
+ * EventRangeMatcherBase.h
+ *
+ *  Created on: 27.08.2015
+ *      Author: baetz
+ */
+
+#ifndef FRAMEWORK_EVENTS_EVENTMATCHING_EVENTRANGEMATCHERBASE_H_
+#define FRAMEWORK_EVENTS_EVENTMATCHING_EVENTRANGEMATCHERBASE_H_
+
+#include <framework/events/EventMessage.h>
+#include <framework/globalfunctions/matching/RangeMatcher.h>
+#include <framework/globalfunctions/matching/SerializeableMatcherIF.h>
+
+template <typename T>
+class EventRangeMatcherBase: public SerializeableMatcherIF<EventMessage*> {
+	friend class EventMatchTree;
+public:
+	EventRangeMatcherBase(T from, T till, bool inverted) : rangeMatcher(from, till, inverted) {	}
+	virtual ~EventRangeMatcherBase() { }
+	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
+			const uint32_t max_size, bool bigEndian) const {
+		return rangeMatcher.serialize(buffer, size, max_size, bigEndian);
+	}
+	uint32_t getSerializedSize() const {
+		return rangeMatcher.getSerializedSize();
+	}
+	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+			bool bigEndian) {
+		return rangeMatcher.deSerialize(buffer, size, bigEndian);
+	}
+protected:
+	RangeMatcher<T> rangeMatcher;
+};
+
+#endif /* FRAMEWORK_EVENTS_EVENTMATCHING_EVENTRANGEMATCHERBASE_H_ */

events/eventmatching/ReporterRangeMatcher.cpp

@@ -0,0 +1,20 @@
+/*
+ * ReporterRangeMatcher.cpp
+ *
+ *  Created on: 27.08.2015
+ *      Author: baetz
+ */
+
+#include <framework/events/eventmatching/ReporterRangeMatcher.h>
+
+ReporterRangeMatcher::ReporterRangeMatcher(object_id_t lower, object_id_t upper,
+		bool inverted) : EventRangeMatcherBase<object_id_t>(lower, upper, inverted) {
+}
+
+ReporterRangeMatcher::~ReporterRangeMatcher() {
+	
+}
+
+bool ReporterRangeMatcher::match(EventMessage* message) {
+	return rangeMatcher.match(message->getReporter());
+}

events/eventmatching/ReporterRangeMatcher.h

@@ -0,0 +1,20 @@
+/*
+ * ReporterRangeMatcher.h
+ *
+ *  Created on: 27.08.2015
+ *      Author: baetz
+ */
+
+#ifndef FRAMEWORK_EVENTS_EVENTMATCHING_REPORTERRANGEMATCHER_H_
+#define FRAMEWORK_EVENTS_EVENTMATCHING_REPORTERRANGEMATCHER_H_
+
+#include <framework/events/eventmatching/EventRangeMatcherBase.h>
+
+class ReporterRangeMatcher: public EventRangeMatcherBase<object_id_t> {
+public:
+	ReporterRangeMatcher(object_id_t lower, object_id_t upper, bool inverted);
+	~ReporterRangeMatcher();
+	bool match(EventMessage* message);
+};
+
+#endif /* FRAMEWORK_EVENTS_EVENTMATCHING_REPORTERRANGEMATCHER_H_ */

events/eventmatching/SeverityRangeMatcher.cpp

@@ -0,0 +1,21 @@
+/*
+ * SeverityRangeMatcher.cpp
+ *
+ *  Created on: 27.08.2015
+ *      Author: baetz
+ */
+
+#include <framework/events/eventmatching/SeverityRangeMatcher.h>
+#include <framework/events/EventMessage.h>
+#include <framework/serialize/SerializeAdapter.h>
+
+SeverityRangeMatcher::SeverityRangeMatcher(EventSeverity_t from,
+		EventSeverity_t till, bool inverted) : EventRangeMatcherBase<EventSeverity_t>(from, till, inverted) {
+}
+
+SeverityRangeMatcher::~SeverityRangeMatcher() {
+}
+
+bool SeverityRangeMatcher::match(EventMessage* message) {
+	return rangeMatcher.match(message->getSeverity());
+}

events/eventmatching/SeverityRangeMatcher.h

@@ -0,0 +1,20 @@
+/*
+ * SeverityRangeMatcher.h
+ *
+ *  Created on: 27.08.2015
+ *      Author: baetz
+ */
+
+#ifndef FRAMEWORK_EVENTS_EVENTMATCHING_SEVERITYRANGEMATCHER_H_
+#define FRAMEWORK_EVENTS_EVENTMATCHING_SEVERITYRANGEMATCHER_H_
+
+#include <framework/events/eventmatching/EventRangeMatcherBase.h>
+
+class SeverityRangeMatcher: public EventRangeMatcherBase<EventSeverity_t> {
+public:
+	SeverityRangeMatcher(EventSeverity_t from, EventSeverity_t till, bool inverted);
+	~SeverityRangeMatcher();
+	bool match(EventMessage* message);
+};
+
+#endif /* FRAMEWORK_EVENTS_EVENTMATCHING_SEVERITYRANGEMATCHER_H_ */

events/eventmatching/eventmatching.h

@@ -0,0 +1,10 @@
+#ifndef EVENTMATCHING_H_
+#define EVENTMATCHING_H_
+
+#include <framework/events/eventmatching/EventIdRangeMatcher.h>
+#include <framework/events/eventmatching/EventMatchTree.h>
+#include <framework/events/eventmatching/ReporterRangeMatcher.h>
+#include <framework/events/eventmatching/SeverityRangeMatcher.h>
+
+
+#endif /* EVENTMATCHING_H_ */