Merge branch 'master' into mueller/serialize-convergence

container/ArrayList.h

@@ -72,11 +72,15 @@ public:
 			return tmp;
 		}
 
-		T operator*() {
+		T& operator*(){
 			return *value;
 		}
 
-		T *operator->() {
+		const T& operator*() const{
+			return *value;
+		}
+
+		T *operator->(){
 			return value;
 		}
 

container/FixedMap.h

@@ -1,5 +1,5 @@
-#ifndef FIXEDMAP_H_
-#define FIXEDMAP_H_
+#ifndef FSFW_CONTAINER_FIXEDMAP_H_
+#define FSFW_CONTAINER_FIXEDMAP_H_
 
 #include "ArrayList.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
@@ -7,7 +7,9 @@
 #include <type_traits>
 
 /**
- * \ingroup container
+ * @warning Iterators return a non-const key_t in the pair.
+ * @warning A User is not allowed to change the key, otherwise the map is corrupted.
+ * @ingroup container
  */
 template<typename key_t, typename T>
 class FixedMap: public SerializeIF {
@@ -50,15 +52,6 @@ public:
 		Iterator(std::pair<key_t, T> *pair) :
 				ArrayList<std::pair<key_t, T>, uint32_t>::Iterator(pair) {
 		}
-
-		T operator*() {
-			return ArrayList<std::pair<key_t, T>, uint32_t>::Iterator::value->second;
-		}
-
-		T *operator->() {
-			return &ArrayList<std::pair<key_t, T>, uint32_t>::Iterator::value->second;
-		}
-
 	};
 
 	Iterator begin() const {
@@ -73,7 +66,7 @@ public:
 		return _size;
 	}
 
-	ReturnValue_t insert(key_t key, T value, Iterator *storedValue = NULL) {
+	ReturnValue_t insert(key_t key, T value, Iterator *storedValue = nullptr) {
 		if (exists(key) == HasReturnvaluesIF::RETURN_OK) {
 			return KEY_ALREADY_EXISTS;
 		}
@@ -82,7 +75,7 @@ public:
 		}
 		theMap[_size].first = key;
 		theMap[_size].second = value;
-		if (storedValue != NULL) {
+		if (storedValue != nullptr) {
 			*storedValue = Iterator(&theMap[_size]);
 		}
 		++_size;
@@ -90,7 +83,7 @@ public:
 	}
 
 	ReturnValue_t insert(std::pair<key_t, T> pair) {
-		return insert(pair.fist, pair.second);
+		return insert(pair.first, pair.second);
 	}
 
 	ReturnValue_t exists(key_t key) const {
@@ -199,4 +192,4 @@ public:
 
 };
 
-#endif /* FIXEDMAP_H_ */
+#endif /* FSFW_CONTAINER_FIXEDMAP_H_ */

container/FixedOrderedMultimap.h

@@ -48,7 +48,7 @@ private:
 		if (_size <= position) {
 			return;
 		}
-		memmove(&theMap[position], &theMap[position + 1],
+		memmove(static_cast<void*>(&theMap[position]), static_cast<void*>(&theMap[position + 1]),
 				(_size - position - 1) * sizeof(std::pair<key_t,T>));
 		--_size;
 	}
@@ -68,15 +68,6 @@ public:
 		Iterator(std::pair<key_t, T> *pair) :
 				ArrayList<std::pair<key_t, T>, uint32_t>::Iterator(pair) {
 		}
-
-		T operator*() {
-			return ArrayList<std::pair<key_t, T>, uint32_t>::Iterator::value->second;
-		}
-
-		T *operator->() {
-			return &ArrayList<std::pair<key_t, T>, uint32_t>::Iterator::value->second;
-		}
-
 	};
 
 	Iterator begin() const {
@@ -91,17 +82,17 @@ public:
 		return _size;
 	}
 
-	ReturnValue_t insert(key_t key, T value, Iterator *storedValue = NULL) {
+	ReturnValue_t insert(key_t key, T value, Iterator *storedValue = nullptr) {
 		if (_size == theMap.maxSize()) {
 			return MAP_FULL;
 		}
 		uint32_t position = findNicePlace(key);
-		memmove(&theMap[position + 1], &theMap[position],
+		memmove(static_cast<void*>(&theMap[position + 1]),static_cast<void*>(&theMap[position]),
 				(_size - position) * sizeof(std::pair<key_t,T>));
 		theMap[position].first = key;
 		theMap[position].second = value;
 		++_size;
-		if (storedValue != NULL) {
+		if (storedValue != nullptr) {
 			*storedValue = Iterator(&theMap[position]);
 		}
 		return HasReturnvaluesIF::RETURN_OK;
@@ -145,12 +136,6 @@ public:
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 
-	//This is potentially unsafe
-//	T *findValue(key_t key) const {
-//		return &theMap[findFirstIndex(key)].second;
-//	}
-
-
 	Iterator find(key_t key) const {
 		ReturnValue_t result = exists(key);
 		if (result != HasReturnvaluesIF::RETURN_OK) {

subsystem/Subsystem.cpp

@@ -550,7 +550,7 @@ Mode_t Subsystem::getFallbackSequence(Mode_t sequence) {
 	for (FixedMap<Mode_t, SequenceInfo>::Iterator iter = modeSequences.begin();
 			iter != modeSequences.end(); ++iter) {
 		if (iter.value->first == sequence) {
-			return iter->fallbackSequence;
+			return iter->second.fallbackSequence;
 		}
 	}
 	return -1;
@@ -559,7 +559,7 @@ Mode_t Subsystem::getFallbackSequence(Mode_t sequence) {
 bool Subsystem::isFallbackSequence(Mode_t SequenceId) {
 	for (FixedMap<Mode_t, SequenceInfo>::Iterator iter = modeSequences.begin();
 			iter != modeSequences.end(); iter++) {
-		if (iter->fallbackSequence == SequenceId) {
+		if (iter->second.fallbackSequence == SequenceId) {
 			return true;
 		}
 	}

tmtcservices/CommandingServiceBase.cpp

@@ -122,8 +122,8 @@ void CommandingServiceBase::handleCommandMessage(CommandMessage* reply) {
 
 
 	// Implemented by child class, specifies what to do with reply.
-	ReturnValue_t result = handleReply(reply, iter->command, &iter->state,
-			&nextCommand, iter->objectId, &isStep);
+	ReturnValue_t result = handleReply(reply, iter->second.command, &iter->second.state,
+			&nextCommand, iter->second.objectId, &isStep);
 
 	/* If the child implementation does not implement special handling for
 	 * rejected replies (RETURN_FAILED or INVALID_REPLY is returned), a
@@ -132,7 +132,7 @@ void CommandingServiceBase::handleCommandMessage(CommandMessage* reply) {
 	if((reply->getCommand() == CommandMessage::REPLY_REJECTED) and
 			(result == RETURN_FAILED or result == INVALID_REPLY)) {
 	    result = reply->getReplyRejectedReason();
-	    failureParameter1 = iter->command;
+	    failureParameter1 = iter->second.command;
 	}
 
 	switch (result) {
@@ -149,14 +149,14 @@ void CommandingServiceBase::handleCommandMessage(CommandMessage* reply) {
 	default:
 		if (isStep) {
 			verificationReporter.sendFailureReport(
-					TC_VERIFY::PROGRESS_FAILURE, iter->tcInfo.ackFlags,
-					iter->tcInfo.tcPacketId, iter->tcInfo.tcSequenceControl,
-					result, ++iter->step, failureParameter1,
+					TC_VERIFY::PROGRESS_FAILURE, iter->second.tcInfo.ackFlags,
+					iter->second.tcInfo.tcPacketId, iter->second.tcInfo.tcSequenceControl,
+					result, ++iter->second.step, failureParameter1,
 					failureParameter2);
 		} else {
 			verificationReporter.sendFailureReport(
-					TC_VERIFY::COMPLETION_FAILURE, iter->tcInfo.ackFlags,
-					iter->tcInfo.tcPacketId, iter->tcInfo.tcSequenceControl,
+					TC_VERIFY::COMPLETION_FAILURE, iter->second.tcInfo.ackFlags,
+					iter->second.tcInfo.tcPacketId, iter->second.tcInfo.tcSequenceControl,
 					result, 0, failureParameter1, failureParameter2);
 		}
 		failureParameter1 = 0;
@@ -170,7 +170,7 @@ void CommandingServiceBase::handleCommandMessage(CommandMessage* reply) {
 void CommandingServiceBase::handleReplyHandlerResult(ReturnValue_t result,
 		CommandMapIter iter, CommandMessage* nextCommand,
 		CommandMessage* reply, bool& isStep) {
-	iter->command = nextCommand->getCommand();
+	iter->second.command = nextCommand->getCommand();
 
 	// In case a new command is to be sent immediately, this is performed here.
 	// If no new command is sent, only analyse reply result by initializing
@@ -185,14 +185,14 @@ void CommandingServiceBase::handleReplyHandlerResult(ReturnValue_t result,
 		if (isStep and result != NO_STEP_MESSAGE) {
 			verificationReporter.sendSuccessReport(
 					TC_VERIFY::PROGRESS_SUCCESS,
-					iter->tcInfo.ackFlags, iter->tcInfo.tcPacketId,
-					iter->tcInfo.tcSequenceControl, ++iter->step);
+					iter->second.tcInfo.ackFlags, iter->second.tcInfo.tcPacketId,
+					iter->second.tcInfo.tcSequenceControl, ++iter->second.step);
 		}
 		else {
 			verificationReporter.sendSuccessReport(
 					TC_VERIFY::COMPLETION_SUCCESS,
-					iter->tcInfo.ackFlags, iter->tcInfo.tcPacketId,
-					iter->tcInfo.tcSequenceControl, 0);
+					iter->second.tcInfo.ackFlags, iter->second.tcInfo.tcPacketId,
+					iter->second.tcInfo.tcSequenceControl, 0);
 			checkAndExecuteFifo(iter);
 		}
 	}
@@ -200,16 +200,16 @@ void CommandingServiceBase::handleReplyHandlerResult(ReturnValue_t result,
 		if (isStep) {
 			nextCommand->clearCommandMessage();
 			verificationReporter.sendFailureReport(
-					TC_VERIFY::PROGRESS_FAILURE, iter->tcInfo.ackFlags,
-					iter->tcInfo.tcPacketId,
-					iter->tcInfo.tcSequenceControl, sendResult,
-					++iter->step, failureParameter1, failureParameter2);
+					TC_VERIFY::PROGRESS_FAILURE, iter->second.tcInfo.ackFlags,
+					iter->second.tcInfo.tcPacketId,
+					iter->second.tcInfo.tcSequenceControl, sendResult,
+					++iter->second.step, failureParameter1, failureParameter2);
 		} else {
 			nextCommand->clearCommandMessage();
 			verificationReporter.sendFailureReport(
 					TC_VERIFY::COMPLETION_FAILURE,
-					iter->tcInfo.ackFlags, iter->tcInfo.tcPacketId,
-					iter->tcInfo.tcSequenceControl, sendResult, 0,
+					iter->second.tcInfo.ackFlags, iter->second.tcInfo.tcPacketId,
+					iter->second.tcInfo.tcSequenceControl, sendResult, 0,
 					failureParameter1, failureParameter2);
 		}
 		failureParameter1 = 0;
@@ -248,7 +248,7 @@ void CommandingServiceBase::handleRequestQueue() {
 		iter = commandMap.find(queue);
 
 		if (iter != commandMap.end()) {
-			result = iter->fifo.insert(address);
+			result = iter->second.fifo.insert(address);
 			if (result != RETURN_OK) {
 				rejectPacket(TC_VERIFY::START_FAILURE, &packet, OBJECT_BUSY);
 			}
@@ -316,11 +316,11 @@ void CommandingServiceBase::startExecution(TcPacketStored *storedPacket,
         CommandMapIter iter) {
     ReturnValue_t result = RETURN_OK;
     CommandMessage command;
-    iter->subservice = storedPacket->getSubService();
-    result = prepareCommand(&command, iter->subservice,
+    iter->second.subservice = storedPacket->getSubService();
+    result = prepareCommand(&command, iter->second.subservice,
             storedPacket->getApplicationData(),
-            storedPacket->getApplicationDataSize(), &iter->state,
-            iter->objectId);
+            storedPacket->getApplicationDataSize(), &iter->second.state,
+            iter->second.objectId);
 
     ReturnValue_t sendResult = RETURN_OK;
 	switch (result) {
@@ -330,13 +330,13 @@ void CommandingServiceBase::startExecution(TcPacketStored *storedPacket,
 					&command);
 		}
 		if (sendResult == RETURN_OK) {
-			Clock::getUptime(&iter->uptimeOfStart);
-			iter->step = 0;
-			iter->subservice = storedPacket->getSubService();
-			iter->command = command.getCommand();
-			iter->tcInfo.ackFlags = storedPacket->getAcknowledgeFlags();
-			iter->tcInfo.tcPacketId = storedPacket->getPacketId();
-			iter->tcInfo.tcSequenceControl =
+			Clock::getUptime(&iter->second.uptimeOfStart);
+			iter->second.step = 0;
+			iter->second.subservice = storedPacket->getSubService();
+			iter->second.command = command.getCommand();
+			iter->second.tcInfo.ackFlags = storedPacket->getAcknowledgeFlags();
+			iter->second.tcInfo.tcPacketId = storedPacket->getPacketId();
+			iter->second.tcInfo.tcSequenceControl =
 					storedPacket->getPacketSequenceControl();
 			acceptPacket(TC_VERIFY::START_SUCCESS, storedPacket);
 		} else {
@@ -386,7 +386,7 @@ void CommandingServiceBase::acceptPacket(uint8_t reportId,
 
 void CommandingServiceBase::checkAndExecuteFifo(CommandMapIter iter) {
 	store_address_t address;
-	if (iter->fifo.retrieve(&address) != RETURN_OK) {
+	if (iter->second.fifo.retrieve(&address) != RETURN_OK) {
 		commandMap.erase(&iter);
 	} else {
 		TcPacketStored newPacket(address);
@@ -412,10 +412,10 @@ void CommandingServiceBase::checkTimeout() {
 	Clock::getUptime(&uptime);
 	CommandMapIter iter;
 	for (iter = commandMap.begin(); iter != commandMap.end(); ++iter) {
-		if ((iter->uptimeOfStart + (timeoutSeconds * 1000)) < uptime) {
+		if ((iter->second.uptimeOfStart + (timeoutSeconds * 1000)) < uptime) {
 			verificationReporter.sendFailureReport(
-					TC_VERIFY::COMPLETION_FAILURE, iter->tcInfo.ackFlags,
-					iter->tcInfo.tcPacketId, iter->tcInfo.tcSequenceControl,
+					TC_VERIFY::COMPLETION_FAILURE, iter->second.tcInfo.ackFlags,
+					iter->second.tcInfo.tcPacketId, iter->second.tcInfo.tcSequenceControl,
 					TIMEOUT);
 			checkAndExecuteFifo(iter);
 		}