it compiles again

monitoring/AbsLimitMonitor.h

@@ -8,12 +8,11 @@ template<typename T>
 class AbsLimitMonitor: public MonitorBase<T> {
 public:
 	AbsLimitMonitor(object_id_t reporterId, uint8_t monitorId,
-	        object_id_t dataCreatorId, lp_id_t localPoolId,
-	        uint16_t confirmationLimit, T limit,
+	        gp_id_t globalPoolId, uint16_t confirmationLimit, T limit,
 	        Event violationEvent = MonitoringIF::VALUE_OUT_OF_RANGE,
 	        bool aboveIsViolation = true) :
-			MonitorBase<T>(reporterId, monitorId, dataCreatorId, localPoolId,
-			        confirmationLimit),
+			MonitorBase<T>(reporterId, monitorId, globalPoolId,
+					confirmationLimit),
 			limit(limit), violationEvent(violationEvent),
 			aboveIsViolation(aboveIsViolation) {
 	}
@@ -67,7 +66,8 @@ protected:
 		switch (state) {
 		case MonitoringIF::OUT_OF_RANGE:
 			EventManagerIF::triggerEvent(this->reportingId,
-			        violationEvent, this->parameterId);
+			        violationEvent, this->parameterId.objectId,
+					this->parameterId.localPoolId);
 			break;
 		default:
 			break;

monitoring/LimitMonitor.h

@@ -13,11 +13,11 @@ template<typename T>
 class LimitMonitor: public MonitorBase<T> {
 public:
 	LimitMonitor(object_id_t reporterId, uint8_t monitorId,
-	        object_id_t creatorId, lp_id_t localPoolId,
-			uint16_t confirmationLimit, T lowerLimit, T upperLimit,
-			Event belowLowEvent = MonitoringIF::VALUE_BELOW_LOW_LIMIT,
+	        gp_id_t globalPoolId, uint16_t confirmationLimit, T lowerLimit,
+			T upperLimit, Event belowLowEvent =
+					MonitoringIF::VALUE_BELOW_LOW_LIMIT,
 			Event aboveHighEvent = MonitoringIF::VALUE_ABOVE_HIGH_LIMIT) :
-			MonitorBase<T>(reporterId, monitorId, creatorId, localPoolId,
+			MonitorBase<T>(reporterId, monitorId, globalPoolId,
 			        confirmationLimit),
 			lowerLimit(lowerLimit), upperLimit(upperLimit),
 			belowLowEvent(belowLowEvent), aboveHighEvent(aboveHighEvent) {
@@ -80,11 +80,11 @@ protected:
 		switch (state) {
 		case MonitoringIF::BELOW_LOW_LIMIT:
 			EventManagerIF::triggerEvent(this->reportingId, belowLowEvent,
-			        this->parameterId);
+			        this->parameterId.objectId, this->parameterId.localPoolId);
 			break;
 		case MonitoringIF::ABOVE_HIGH_LIMIT:
 			EventManagerIF::triggerEvent(this->reportingId, aboveHighEvent,
-			        this->parameterId);
+			        this->parameterId.objectId, this->parameterId.localPoolId);
 			break;
 		default:
 			break;

monitoring/MonitorBase.h

@@ -25,11 +25,10 @@ class MonitorBase: public MonitorReporter<T> {
 public:
 
 	MonitorBase(object_id_t reporterId, uint8_t monitorId,
-	        object_id_t dataCreatorId, lp_id_t localPoolId,
-	        uint16_t confirmationLimit):
-	        MonitorReporter<T>(reporterId, monitorId, dataCreatorId,
+	        gp_id_t globalPoolId, uint16_t confirmationLimit):
+	        MonitorReporter<T>(reporterId, monitorId, globalPoolId,
 	                confirmationLimit),
-	        poolVariable(dataCreatorId, localPoolId) {
+	        poolVariable(globalPoolId) {
 	}
 
 	virtual ~MonitorBase() {

monitoring/MonitorReporter.h

@@ -5,6 +5,7 @@
 #include "MonitoringIF.h"
 #include "MonitoringMessageContent.h"
 
+#include "../datapoollocal/locPoolDefinitions.h"
 #include "../events/EventManagerIF.h"
 #include "../parameters/HasParametersIF.h"
 
@@ -18,7 +19,7 @@ public:
 	// TODO: Adapt to use SID instead of parameter ID.
 
 	MonitorReporter(object_id_t reportingId, uint8_t monitorId,
-	        uint32_t parameterId, uint16_t confirmationLimit) :
+	        gp_id_t globalPoolId, uint16_t confirmationLimit) :
 			monitorId(monitorId), parameterId(parameterId),
 			reportingId(reportingId), oldState(MonitoringIF::UNCHECKED),
 			reportingEnabled(ENABLED), eventEnabled(ENABLED), currentCounter(0),
@@ -95,7 +96,7 @@ public:
 
 protected:
 	const uint8_t monitorId;
-	const uint32_t parameterId;
+	const gp_id_t parameterId;
 	object_id_t reportingId;
 	ReturnValue_t oldState;
 

monitoring/MonitoringMessageContent.h

@@ -3,6 +3,7 @@
 
 #include "HasMonitorsIF.h"
 #include "MonitoringIF.h"
+#include "../datapoollocal/locPoolDefinitions.h"
 #include "../objectmanager/ObjectManagerIF.h"
 #include "../serialize/SerialBufferAdapter.h"
 #include "../serialize/SerialFixedArrayListAdapter.h"
@@ -16,12 +17,17 @@ void setStaticFrameworkObjectIds();
 }
 
 //PID(uint32_t), TYPE, LIMIT_ID, value,limitValue, previous, later, timestamp
+/**
+ * @brief	Does magic.
+ * @tparam T
+ */
 template<typename T>
 class MonitoringReportContent: public SerialLinkedListAdapter<SerializeIF> {
 	friend void (Factory::setStaticFrameworkObjectIds)();
 public:
 	SerializeElement<uint8_t> monitorId;
-	SerializeElement<uint32_t> parameterId;
+	SerializeElement<uint32_t> parameterObjectId;
+	SerializeElement<lp_id_t> localPoolId;
 	SerializeElement<T> parameterValue;
 	SerializeElement<T> limitValue;
 	SerializeElement<ReturnValue_t> oldState;
@@ -30,20 +36,23 @@ public:
 	SerializeElement<SerialBufferAdapter<uint8_t>> timestampSerializer;
 	TimeStamperIF* timeStamper;
 	MonitoringReportContent() :
-			SerialLinkedListAdapter<SerializeIF>(
-					LinkedElement<SerializeIF>::Iterator(&parameterId)), monitorId(0), parameterId(
-					0), parameterValue(0), limitValue(0), oldState(0), newState(
-					0), rawTimestamp( { 0 }), timestampSerializer(rawTimestamp,
+			SerialLinkedListAdapter<SerializeIF>(&parameterObjectId),
+					monitorId(0), parameterObjectId(0),
+					localPoolId(0), parameterValue(0),
+					limitValue(0), oldState(0), newState(0),
+					rawTimestamp( { 0 }), timestampSerializer(rawTimestamp,
 					sizeof(rawTimestamp)), timeStamper(NULL) {
 		setAllNext();
 	}
-	MonitoringReportContent(uint32_t setPID, T value, T limitValue,
+	MonitoringReportContent(gp_id_t globalPoolId, T value, T limitValue,
 			ReturnValue_t oldState, ReturnValue_t newState) :
-			SerialLinkedListAdapter<SerializeIF>(
-					LinkedElement<SerializeIF>::Iterator(&parameterId)), monitorId(0), parameterId(
-					setPID), parameterValue(value), limitValue(limitValue), oldState(
-					oldState), newState(newState), timestampSerializer(rawTimestamp,
-							sizeof(rawTimestamp)), timeStamper(NULL) {
+			SerialLinkedListAdapter<SerializeIF>(&parameterObjectId),
+					monitorId(0), parameterObjectId(globalPoolId.objectId),
+					localPoolId(globalPoolId.localPoolId),
+					parameterValue(value), limitValue(limitValue),
+					oldState(oldState), newState(newState),
+					timestampSerializer(rawTimestamp, sizeof(rawTimestamp)),
+					timeStamper(NULL) {
 		setAllNext();
 		if (checkAndSetStamper()) {
 			timeStamper->addTimeStamp(rawTimestamp, sizeof(rawTimestamp));
@@ -53,16 +62,16 @@ private:
 
 	static object_id_t timeStamperId;
 	void setAllNext() {
-		parameterId.setNext(&parameterValue);
+		parameterObjectId.setNext(&parameterValue);
 		parameterValue.setNext(&limitValue);
 		limitValue.setNext(&oldState);
 		oldState.setNext(&newState);
 		newState.setNext(&timestampSerializer);
 	}
 	bool checkAndSetStamper() {
-		if (timeStamper == NULL) {
+		if (timeStamper == nullptr) {
 			timeStamper = objectManager->get<TimeStamperIF>( timeStamperId );
-			if ( timeStamper == NULL ) {
+			if ( timeStamper == nullptr ) {
 				sif::error << "MonitoringReportContent::checkAndSetStamper: "
 				        "Stamper not found!" << std::endl;
 				return false;