From 17d5de15c990be42ad98da412059d7588ded15bd Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 29 Sep 2020 16:10:35 +0200
Subject: [PATCH 01/11] slight changes ,size t replacement

---
 container/ArrayList.h | 218 +++++++++++++++++++++---------------------
 1 file changed, 107 insertions(+), 111 deletions(-)

diff --git a/container/ArrayList.h b/container/ArrayList.h
index 19454777..f347da8e 100644
--- a/container/ArrayList.h
+++ b/container/ArrayList.h
@@ -1,15 +1,15 @@
-#ifndef ARRAYLIST_H_
-#define ARRAYLIST_H_
+#ifndef FSFW_CONTAINER_ARRAYLIST_H_
+#define FSFW_CONTAINER_ARRAYLIST_H_
 
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include "../serialize/SerializeAdapter.h"
 #include "../serialize/SerializeIF.h"
 
 /**
- * A List that stores its values in an array.
- *
- * The backend is an array that can be allocated by the class itself or supplied via ctor.
- *
+ * @brief 	A List that stores its values in an array.
+ * @details
+ * The underlying storage is an array that can be allocated by the class
+ * itself or supplied via ctor.
  *
  * @ingroup container
  */
@@ -21,94 +21,8 @@ public:
 	static const ReturnValue_t FULL = MAKE_RETURN_CODE(0x01);
 
 	/**
-	 * An Iterator to go trough an ArrayList
-	 *
-	 * It stores a pointer to an element and increments the
-	 * pointer when incremented itself.
-	 */
-	class Iterator {
-	public:
-		/**
-		 * Empty ctor, points to NULL
-		 */
-		Iterator() :
-				value(0) {
-
-		}
-
-		/**
-		 * Initializes the Iterator to point to an element
-		 *
-		 * @param initialize
-		 */
-		Iterator(T *initialize) {
-			value = initialize;
-		}
-
-		/**
-		 * The current element the iterator points to
-		 */
-		T *value;
-
-		Iterator& operator++() {
-			value++;
-			return *this;
-		}
-
-		Iterator operator++(int) {
-			Iterator tmp(*this);
-			operator++();
-			return tmp;
-		}
-
-		Iterator& operator--() {
-			value--;
-			return *this;
-		}
-
-		Iterator operator--(int) {
-			Iterator tmp(*this);
-			operator--();
-			return tmp;
-		}
-
-		T& operator*(){
-			return *value;
-		}
-
-		const T& operator*() const{
-			return *value;
-		}
-
-		T *operator->(){
-			return value;
-		}
-
-		const T *operator->() const{
-			return value;
-		}
-
-		//SHOULDDO this should be implemented as non-member
-		bool operator==(const typename ArrayList<T, count_t>::Iterator& other) const{
-			return (value == other.value);
-		}
-
-		//SHOULDDO this should be implemented as non-member
-		bool operator!=(const typename ArrayList<T, count_t>::Iterator& other) const {
-			return !(*this == other);
-		}
-	};
-
-	/**
-	 * Number of Elements stored in this List
-	 */
-	count_t size;
-
-	/**
-	 * This is the allocating constructor;
-	 *
+	 * This is the allocating constructor.
 	 * It allocates an array of the specified size.
-	 *
 	 * @param maxSize
 	 */
 	ArrayList(count_t maxSize) :
@@ -119,7 +33,8 @@ public:
 	/**
 	 * This is the non-allocating constructor
 	 *
-	 * It expects a pointer to an array of a certain size and initializes itself to it.
+	 * It expects a pointer to an array of a certain size and initializes
+	 * itself to it.
 	 *
 	 * @param storage the array to use as backend
 	 * @param maxSize size of storage
@@ -129,6 +44,20 @@ public:
 			size(size), entries(storage), maxSize_(maxSize), allocated(false) {
 	}
 
+    /**
+     * Copying is forbiden by declaring copy ctor and copy assignment deleted
+     * It is too ambigous in this case.
+     * (Allocate a new backend? Use the same? What to do in an modifying call?)
+     */
+	ArrayList(const ArrayList& other) = delete;
+	const ArrayList& operator=(const ArrayList& other) = delete;
+
+	/**
+	 * Number of Elements stored in this List
+	 */
+	count_t size;
+
+
 	/**
 	 * Destructor, if the allocating constructor was used, it deletes the array.
 	 */
@@ -138,6 +67,85 @@ public:
 		}
 	}
 
+    /**
+     * An Iterator to go trough an ArrayList
+     *
+     * It stores a pointer to an element and increments the
+     * pointer when incremented itself.
+     */
+    class Iterator {
+    public:
+        /**
+         * Empty ctor, points to NULL
+         */
+        Iterator(): value(0) {}
+
+        /**
+         * Initializes the Iterator to point to an element
+         *
+         * @param initialize
+         */
+        Iterator(T *initialize) {
+            value = initialize;
+        }
+
+        /**
+         * The current element the iterator points to
+         */
+        T *value;
+
+        Iterator& operator++() {
+            value++;
+            return *this;
+        }
+
+        Iterator operator++(int) {
+            Iterator tmp(*this);
+            operator++();
+            return tmp;
+        }
+
+        Iterator& operator--() {
+            value--;
+            return *this;
+        }
+
+        Iterator operator--(int) {
+            Iterator tmp(*this);
+            operator--();
+            return tmp;
+        }
+
+        T& operator*() {
+            return *value;
+        }
+
+        const T& operator*() const {
+            return *value;
+        }
+
+        T *operator->() {
+            return value;
+        }
+
+        const T *operator->() const {
+            return value;
+        }
+
+
+        //SHOULDDO this should be implemented as non-member
+        bool operator==(const typename
+        		ArrayList<T, count_t>::Iterator& other) const {
+            return (value == other.value);
+        }
+
+        //SHOULDDO this should be implemented as non-member
+        bool operator!=(const typename
+        		ArrayList<T, count_t>::Iterator& other) const {
+        	return !(*this == other);
+        }
+    };
+
 	/**
 	 * Iterator pointing to the first stored elmement
 	 *
@@ -191,7 +199,7 @@ public:
 	 *
 	 * @return maximum number of elements
 	 */
-	uint32_t maxSize() const {
+	size_t maxSize() const {
 		return this->maxSize_;
 	}
 
@@ -226,19 +234,7 @@ public:
 	count_t remaining() {
 		return (maxSize_ - size);
 	}
-private:
-	/**
-	 * This is the copy constructor
-	 *
-	 * It is private, as copying is too ambigous in this case. (Allocate a new backend? Use the same?
-	 * What to do in an modifying call?)
-	 *
-	 * @param other
-	 */
-	ArrayList(const ArrayList& other) :
-			size(other.size), entries(other.entries), maxSize_(other.maxSize_), allocated(
-					false) {
-	}
+
 protected:
 	/**
 	 * pointer to the array in which the entries are stored
@@ -247,12 +243,12 @@ protected:
 	/**
 	 * remembering the maximum size
 	 */
-	uint32_t maxSize_;
+	size_t maxSize_;
 
 	/**
 	 * true if the array was allocated and needs to be deleted in the destructor.
 	 */
 	bool allocated;
-
 };
-#endif /* ARRAYLIST_H_ */
+
+#endif /* FSFW_CONTAINER_ARRAYLIST_H_ */

From 4eef7bfc0133f56021914028818107cbe0e41b64 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 29 Sep 2020 16:12:43 +0200
Subject: [PATCH 02/11] changes taken over

---
 container/ArrayList.h | 144 +++++++++++++++++++++---------------------
 1 file changed, 72 insertions(+), 72 deletions(-)

diff --git a/container/ArrayList.h b/container/ArrayList.h
index f347da8e..426e02b3 100644
--- a/container/ArrayList.h
+++ b/container/ArrayList.h
@@ -26,7 +26,7 @@ public:
 	 * @param maxSize
 	 */
 	ArrayList(count_t maxSize) :
-			size(0), maxSize_(maxSize), allocated(true) {
+		size(0), maxSize_(maxSize), allocated(true) {
 		entries = new T[maxSize];
 	}
 
@@ -41,14 +41,14 @@ public:
 	 * @param size size of data already present in storage
 	 */
 	ArrayList(T *storage, count_t maxSize, count_t size = 0) :
-			size(size), entries(storage), maxSize_(maxSize), allocated(false) {
+		size(size), entries(storage), maxSize_(maxSize), allocated(false) {
 	}
 
-    /**
-     * Copying is forbiden by declaring copy ctor and copy assignment deleted
-     * It is too ambigous in this case.
-     * (Allocate a new backend? Use the same? What to do in an modifying call?)
-     */
+	/**
+	 * Copying is forbiden by declaring copy ctor and copy assignment deleted
+	 * It is too ambigous in this case.
+	 * (Allocate a new backend? Use the same? What to do in an modifying call?)
+	 */
 	ArrayList(const ArrayList& other) = delete;
 	const ArrayList& operator=(const ArrayList& other) = delete;
 
@@ -67,84 +67,84 @@ public:
 		}
 	}
 
-    /**
-     * An Iterator to go trough an ArrayList
-     *
-     * It stores a pointer to an element and increments the
-     * pointer when incremented itself.
-     */
-    class Iterator {
-    public:
-        /**
-         * Empty ctor, points to NULL
-         */
-        Iterator(): value(0) {}
+	/**
+	 * An Iterator to go trough an ArrayList
+	 *
+	 * It stores a pointer to an element and increments the
+	 * pointer when incremented itself.
+	 */
+	class Iterator {
+	public:
+		/**
+		 * Empty ctor, points to NULL
+		 */
+		Iterator(): value(0) {}
 
-        /**
-         * Initializes the Iterator to point to an element
-         *
-         * @param initialize
-         */
-        Iterator(T *initialize) {
-            value = initialize;
-        }
+		/**
+		 * Initializes the Iterator to point to an element
+		 *
+		 * @param initialize
+		 */
+		Iterator(T *initialize) {
+			value = initialize;
+		}
 
-        /**
-         * The current element the iterator points to
-         */
-        T *value;
+		/**
+		 * The current element the iterator points to
+		 */
+		T *value;
 
-        Iterator& operator++() {
-            value++;
-            return *this;
-        }
+		Iterator& operator++() {
+			value++;
+			return *this;
+		}
 
-        Iterator operator++(int) {
-            Iterator tmp(*this);
-            operator++();
-            return tmp;
-        }
+		Iterator operator++(int) {
+			Iterator tmp(*this);
+			operator++();
+			return tmp;
+		}
 
-        Iterator& operator--() {
-            value--;
-            return *this;
-        }
+		Iterator& operator--() {
+			value--;
+			return *this;
+		}
 
-        Iterator operator--(int) {
-            Iterator tmp(*this);
-            operator--();
-            return tmp;
-        }
+		Iterator operator--(int) {
+			Iterator tmp(*this);
+			operator--();
+			return tmp;
+		}
 
-        T& operator*() {
-            return *value;
-        }
+		T& operator*() {
+			return *value;
+		}
 
-        const T& operator*() const {
-            return *value;
-        }
+		const T& operator*() const {
+			return *value;
+		}
 
-        T *operator->() {
-            return value;
-        }
+		T *operator->() {
+			return value;
+		}
 
-        const T *operator->() const {
-            return value;
-        }
+		const T *operator->() const {
+			return value;
+		}
 
 
-        //SHOULDDO this should be implemented as non-member
-        bool operator==(const typename
-        		ArrayList<T, count_t>::Iterator& other) const {
-            return (value == other.value);
-        }
+		//SHOULDDO this should be implemented as non-member
+		bool operator==(const typename
+				ArrayList<T, count_t>::Iterator& other) const {
+			return (value == other.value);
+		}
 
-        //SHOULDDO this should be implemented as non-member
-        bool operator!=(const typename
-        		ArrayList<T, count_t>::Iterator& other) const {
-        	return !(*this == other);
-        }
-    };
+		//SHOULDDO this should be implemented as non-member
+		bool operator!=(const typename
+				ArrayList<T, count_t>::Iterator& other) const {
+			return !(*this == other);
+		}
+	};
 
 	/**
 	 * Iterator pointing to the first stored elmement

From 6c0bb23ed6f24e84a52a2b37c3bf082a39b0c43d Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 29 Sep 2020 17:51:16 +0200
Subject: [PATCH 03/11] non member bool operator

---
 container/ArrayList.h | 25 ++++++++++++-------------
 1 file changed, 12 insertions(+), 13 deletions(-)

diff --git a/container/ArrayList.h b/container/ArrayList.h
index 426e02b3..6bd5c1d5 100644
--- a/container/ArrayList.h
+++ b/container/ArrayList.h
@@ -131,21 +131,18 @@ public:
 		const T *operator->() const {
 			return value;
 		}
-
-
-		//SHOULDDO this should be implemented as non-member
-		bool operator==(const typename
-				ArrayList<T, count_t>::Iterator& other) const {
-			return (value == other.value);
-		}
-
-		//SHOULDDO this should be implemented as non-member
-		bool operator!=(const typename
-				ArrayList<T, count_t>::Iterator& other) const {
-			return !(*this == other);
-		}
 	};
 
+	friend bool operator==(const ArrayList::Iterator& lhs,
+			const ArrayList::Iterator& rhs) {
+		return (lhs.value == rhs.value);
+	}
+
+	friend bool operator!=(const ArrayList::Iterator& lhs,
+			const ArrayList::Iterator& rhs) {
+		return not (lhs.value == rhs.value);
+	}
+
 	/**
 	 * Iterator pointing to the first stored elmement
 	 *
@@ -251,4 +248,6 @@ protected:
 	bool allocated;
 };
 
+
+
 #endif /* FSFW_CONTAINER_ARRAYLIST_H_ */

From a0098e8b17e42d43e64d7d9ef7a78f8cc66b137b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 30 Sep 2020 18:57:30 +0200
Subject: [PATCH 04/11] non member comp operator for iterators

---
 container/FixedMap.h | 39 +++++++++++++++++++++++++++++++++++++--
 1 file changed, 37 insertions(+), 2 deletions(-)

diff --git a/container/FixedMap.h b/container/FixedMap.h
index d1cc31ff..7a5220fa 100644
--- a/container/FixedMap.h
+++ b/container/FixedMap.h
@@ -7,14 +7,21 @@
 #include <type_traits>
 
 /**
+ * @brief    Map implementation for maps with a pre-defined size.
+ * @details
+ * Can be initialized with desired maximum size.
+ * Iterator is used to access <key,value> pair and iterate through map entries.
+ * Complexity O(n).
  * @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 {
-	static_assert (std::is_trivially_copyable<T>::value or std::is_base_of<SerializeIF, T>::value,
-			"Types used in FixedMap must either be trivial copy-able or a derived Class from SerializeIF to be serialize-able");
+	static_assert (std::is_trivially_copyable<T>::value or
+	        std::is_base_of<SerializeIF, T>::value,
+			"Types used in FixedMap must either be trivial copy-able or a "
+			"derived class from SerializeIF to be serialize-able");
 public:
 	static const uint8_t INTERFACE_ID = CLASS_ID::FIXED_MAP;
 	static const ReturnValue_t KEY_ALREADY_EXISTS = MAKE_RETURN_CODE(0x01);
@@ -54,6 +61,16 @@ public:
 		}
 	};
 
+	friend bool operator==(const typename FixedMap::Iterator& lhs,
+			const typename FixedMap::Iterator& rhs) {
+		return (lhs.value == rhs.value);
+	}
+
+	friend bool operator!=(const typename FixedMap::Iterator& lhs,
+			const typename FixedMap::Iterator& rhs) {
+		return not (lhs.value == rhs.value);
+	}
+
 	Iterator begin() const {
 		return Iterator(&theMap[0]);
 	}
@@ -136,6 +153,24 @@ public:
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 
+	bool empty() {
+	    if(_size == 0) {
+	        return true;
+	    }
+	    else {
+	        return false;
+	    }
+	}
+
+	bool full() {
+	    if(_size >= theMap.maxSize()) {
+	        return true;
+	    }
+	    else {
+	        return false;
+	    }
+	}
+
 	void clear() {
 		_size = 0;
 	}

From adf528fce91412c43daf349c02cee9710bf54363 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 1 Oct 2020 11:01:52 +0200
Subject: [PATCH 05/11] DH IF and DH message  form improved

---
 devicehandlers/DeviceHandlerIF.h        | 20 +++++--
 devicehandlers/DeviceHandlerMessage.cpp | 19 +-----
 devicehandlers/DeviceHandlerMessage.h   | 78 ++++++++++---------------
 3 files changed, 48 insertions(+), 69 deletions(-)

diff --git a/devicehandlers/DeviceHandlerIF.h b/devicehandlers/DeviceHandlerIF.h
index 52a3be4d..9c8eb098 100644
--- a/devicehandlers/DeviceHandlerIF.h
+++ b/devicehandlers/DeviceHandlerIF.h
@@ -1,12 +1,19 @@
-#ifndef DEVICEHANDLERIF_H_
-#define DEVICEHANDLERIF_H_
+#ifndef FSFW_DEVICEHANDLERS_DEVICEHANDLERIF_H_
+#define FSFW_DEVICEHANDLERS_DEVICEHANDLERIF_H_
+
+#include "DeviceHandlerMessage.h"
 
 #include "../action/HasActionsIF.h"
-#include "DeviceHandlerMessage.h"
 #include "../events/Event.h"
 #include "../modes/HasModesIF.h"
 #include "../ipc/MessageQueueSenderIF.h"
 
+/**
+ * This is used to uniquely identify commands that are sent to a device
+ * The values are defined in the device-specific implementations
+ */
+using DeviceCommandId_t = uint32_t;
+
 /**
  * @brief 	This is the Interface used to communicate with a device handler.
  * @details Includes all expected return values, events and modes.
@@ -15,6 +22,7 @@
 class DeviceHandlerIF {
 public:
 
+
 	static const uint8_t TRANSITION_MODE_CHILD_ACTION_MASK = 0x20;
 	static const uint8_t TRANSITION_MODE_BASE_ACTION_MASK = 0x10;
 
@@ -47,6 +55,8 @@ public:
 	//! This is a transitional state which can not be commanded.
 	//! The device handler performs all actions and commands to get the device
 	//! shut down. When the device is off, the mode changes to @c MODE_OFF.
+	//! It is possible to set the mode to _MODE_SHUT_DOWN to use the to off
+	//! transition if available.
 	static const Mode_t _MODE_SHUT_DOWN = TRANSITION_MODE_CHILD_ACTION_MASK | 6;
 	//! It is possible to set the mode to _MODE_TO_ON to use the to on
 	//! transition if available.
@@ -96,7 +106,7 @@ public:
 	static const uint8_t INTERFACE_ID = CLASS_ID::DEVICE_HANDLER_IF;
 
 	// Standard codes used when building commands.
-	static const ReturnValue_t NO_COMMAND_DATA = MAKE_RETURN_CODE(0xA0); //!< If the command size is 0. Checked in DHB
+	static const ReturnValue_t NO_COMMAND_DATA = MAKE_RETURN_CODE(0xA0); //!< If no command data was given when expected.
 	static const ReturnValue_t COMMAND_NOT_SUPPORTED = MAKE_RETURN_CODE(0xA1); //!< Command ID not in commandMap. Checked in DHB
 	static const ReturnValue_t COMMAND_ALREADY_SENT = MAKE_RETURN_CODE(0xA2); //!< Command was already executed. Checked in DHB
 	static const ReturnValue_t COMMAND_WAS_NOT_SENT = MAKE_RETURN_CODE(0xA3);
@@ -150,4 +160,4 @@ public:
 
 };
 
-#endif /* DEVICEHANDLERIF_H_ */
+#endif /* FSFW_DEVICEHANDLERS_DEVICEHANDLERIF_H_ */
diff --git a/devicehandlers/DeviceHandlerMessage.cpp b/devicehandlers/DeviceHandlerMessage.cpp
index 564fae21..cb9043db 100644
--- a/devicehandlers/DeviceHandlerMessage.cpp
+++ b/devicehandlers/DeviceHandlerMessage.cpp
@@ -1,10 +1,6 @@
-#include "../objectmanager/ObjectManagerIF.h"
 #include "DeviceHandlerMessage.h"
 #include "../objectmanager/ObjectManagerIF.h"
 
-DeviceHandlerMessage::DeviceHandlerMessage() {
-}
-
 store_address_t DeviceHandlerMessage::getStoreAddress(
 		const CommandMessage* message) {
 	return store_address_t(message->getParameter2());
@@ -25,14 +21,6 @@ uint8_t DeviceHandlerMessage::getWiretappingMode(
 	return message->getParameter();
 }
 
-//void DeviceHandlerMessage::setDeviceHandlerDirectCommandMessage(
-//		CommandMessage* message, DeviceCommandId_t deviceCommand,
-//		store_address_t commandParametersStoreId) {
-//	message->setCommand(CMD_DIRECT);
-//	message->setParameter(deviceCommand);
-//	message->setParameter2(commandParametersStoreId.raw);
-//}
-
 void DeviceHandlerMessage::setDeviceHandlerRawCommandMessage(
 		CommandMessage* message, store_address_t rawPacketStoreId) {
 	message->setCommand(CMD_RAW);
@@ -47,7 +35,7 @@ void DeviceHandlerMessage::setDeviceHandlerWiretappingMessage(
 
 void DeviceHandlerMessage::setDeviceHandlerSwitchIoBoardMessage(
 		CommandMessage* message, uint32_t ioBoardIdentifier) {
-	message->setCommand(CMD_SWITCH_IOBOARD);
+	message->setCommand(CMD_SWITCH_ADDRESS);
 	message->setParameter(ioBoardIdentifier);
 }
 
@@ -79,18 +67,17 @@ void DeviceHandlerMessage::setDeviceHandlerDirectCommandReply(
 void DeviceHandlerMessage::clear(CommandMessage* message) {
 	switch (message->getCommand()) {
 	case CMD_RAW:
-//	case CMD_DIRECT:
 	case REPLY_RAW_COMMAND:
 	case REPLY_RAW_REPLY:
 	case REPLY_DIRECT_COMMAND_DATA: {
 		StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(
 				objects::IPC_STORE);
-		if (ipcStore != NULL) {
+		if (ipcStore != nullptr) {
 			ipcStore->deleteData(getStoreAddress(message));
 		}
 	}
 		/* NO BREAK falls through*/
-	case CMD_SWITCH_IOBOARD:
+	case CMD_SWITCH_ADDRESS:
 	case CMD_WIRETAPPING:
 		message->setCommand(CommandMessage::CMD_NONE);
 		message->setParameter(0);
diff --git a/devicehandlers/DeviceHandlerMessage.h b/devicehandlers/DeviceHandlerMessage.h
index 8d1c94f4..e5da01c8 100644
--- a/devicehandlers/DeviceHandlerMessage.h
+++ b/devicehandlers/DeviceHandlerMessage.h
@@ -1,69 +1,56 @@
-#ifndef DEVICEHANDLERMESSAGE_H_
-#define DEVICEHANDLERMESSAGE_H_
+#ifndef FSFW_DEVICEHANDLERS_DEVICEHANDLERMESSAGE_H_
+#define FSFW_DEVICEHANDLERS_DEVICEHANDLERMESSAGE_H_
 
 #include "../action/ActionMessage.h"
 #include "../ipc/CommandMessage.h"
 #include "../objectmanager/SystemObjectIF.h"
 #include "../storagemanager/StorageManagerIF.h"
-//SHOULDDO: rework the static constructors to name the type of command they are building, maybe even hide setting the commandID.
+// SHOULDDO: rework the static constructors to name the type of command
+// they are building, maybe even hide setting the commandID.
+
 
 /**
- * This is used to uniquely identify commands that are sent to a device
- *
- * The values are defined in the device-specific implementations
- */
-typedef uint32_t DeviceCommandId_t;
-
-/**
- * The DeviceHandlerMessage is used to send Commands to a DeviceHandlerIF
+ * @brief   The DeviceHandlerMessage is used to send commands to classes
+ *          implementing DeviceHandlerIF
  */
 class DeviceHandlerMessage {
-private:
-	DeviceHandlerMessage();
 public:
+    /**
+     * Instantiation forbidden. Instead, use static functions to operate
+     * on messages.
+     */
+	DeviceHandlerMessage() = delete;
+	virtual ~DeviceHandlerMessage() {}
 
 	/**
 	 * These are the commands that can be sent to a DeviceHandlerBase
 	 */
 	static const uint8_t MESSAGE_ID = messagetypes::DEVICE_HANDLER_COMMAND;
-	static const Command_t CMD_RAW = MAKE_COMMAND_ID( 1 ); //!< Sends a raw command, setParameter is a ::store_id_t containing the raw packet to send
-//	static const Command_t CMD_DIRECT = MAKE_COMMAND_ID( 2 ); //!< Sends a direct command, setParameter is a ::DeviceCommandId_t, setParameter2 is a ::store_id_t containing the data needed for the command
-	static const Command_t CMD_SWITCH_IOBOARD = MAKE_COMMAND_ID( 3 ); //!< Requests a IO-Board switch, setParameter() is the IO-Board identifier
-	static const Command_t CMD_WIRETAPPING = MAKE_COMMAND_ID( 4 ); //!< (De)Activates the monitoring of all raw traffic in DeviceHandlers, setParameter is 0 to deactivate, 1 to activate
+	//! Sends a raw command, setParameter is a storeId containing the
+	//! raw packet to send
+	static const Command_t CMD_RAW = MAKE_COMMAND_ID(1);
+	//! Requests a IO-Board switch, setParameter() is the IO-Board identifier
+	static const Command_t CMD_SWITCH_ADDRESS = MAKE_COMMAND_ID(3);
+	//! (De)Activates the monitoring of all raw traffic in DeviceHandlers,
+	//! setParameter is 0 to deactivate, 1 to activate
+	static const Command_t CMD_WIRETAPPING = MAKE_COMMAND_ID(4);
 
-	/*static const Command_t REPLY_SWITCHED_IOBOARD = MAKE_COMMAND_ID(1 );//!< Reply to a @c CMD_SWITCH_IOBOARD, indicates switch was successful, getParameter() contains the board switched to (0: nominal, 1: redundant)
-	 static const Command_t REPLY_CANT_SWITCH_IOBOARD = MAKE_COMMAND_ID( 2);	//!< Reply to a @c CMD_SWITCH_IOBOARD, indicating the switch could not be performed, getParameter() contains the error message
-	 static const Command_t REPLY_WIRETAPPING = MAKE_COMMAND_ID( 3);	//!< Reply to a @c CMD_WIRETAPPING, getParameter() is the current state, 1 enabled, 0 disabled
-
-	 static const Command_t REPLY_COMMAND_WAS_SENT = MAKE_COMMAND_ID(4 );//!< Reply to a @c CMD_RAW or @c CMD_DIRECT, indicates the command was successfully sent to the device, getParameter() contains the ::DeviceCommandId_t
-	 static const Command_t REPLY_COMMAND_NOT_SUPPORTED = MAKE_COMMAND_ID(5 );//!< Reply to a @c CMD_DIRECT, the requested ::DeviceCommand_t is not supported, getParameter() contains the requested ::DeviceCommand_t, getParameter2() contains the ::DeviceCommandId_t
-	 static const Command_t REPLY_COMMAND_WAS_NOT_SENT = MAKE_COMMAND_ID(6 );//!< Reply to a @c CMD_RAW or @c CMD_DIRECT, indicates the command was not sent, getParameter contains the RMAP Return code (@see rmap.h), getParameter2() contains the ::DeviceCommandId_t
-
-	 static const Command_t REPLY_COMMAND_ALREADY_SENT = MAKE_COMMAND_ID(7 );//!< Reply to a @c CMD_DIRECT, the requested ::DeviceCommand_t has already been sent to the device and not ye been answered
-	 static const Command_t REPLY_WRONG_MODE_FOR_CMD = MAKE_COMMAND_ID(8 );//!< Reply to a @c CMD_RAW or @c CMD_DIRECT, indicates that the requested command can not be sent in the curent mode, getParameter() contains the DeviceHandlerCommand_t
-	 static const Command_t REPLY_NO_DATA = MAKE_COMMAND_ID(9 );	//!< Reply to a CMD_RAW or @c CMD_DIRECT, indicates that the ::store_id_t was invalid, getParameter() contains the ::DeviceCommandId_t, getPrameter2() contains the error code
-	 */
-	static const Command_t REPLY_DIRECT_COMMAND_SENT = ActionMessage::STEP_SUCCESS; //!< Signals that a direct command was sent
-	static const Command_t REPLY_RAW_COMMAND = MAKE_COMMAND_ID(0x11 ); //!< Contains a raw command sent to the Device
-	static const Command_t REPLY_RAW_REPLY = MAKE_COMMAND_ID( 0x12); //!< Contains a raw reply from the Device, getParameter() is the ObjcetId of the sender, getParameter2() is a ::store_id_t containing the raw packet received
+	//! Signals that a direct command was sent
+	static const Command_t REPLY_DIRECT_COMMAND_SENT = ActionMessage::STEP_SUCCESS;
+	//! Contains a raw command sent to the Device
+	static const Command_t REPLY_RAW_COMMAND = MAKE_COMMAND_ID(0x11);
+	//! Contains a raw reply from the Device, getParameter() is the ObjcetId
+	//! of the sender, getParameter2() is a ::store_id_t containing the
+	//! raw packet received
+	static const Command_t REPLY_RAW_REPLY = MAKE_COMMAND_ID(0x12);
 	static const Command_t REPLY_DIRECT_COMMAND_DATA = ActionMessage::DATA_REPLY;
 
-	/**
-	 * Default Destructor
-	 */
-	virtual ~DeviceHandlerMessage() {
-	}
-
 	static store_address_t getStoreAddress(const CommandMessage* message);
 	static uint32_t getDeviceCommandId(const CommandMessage* message);
 	static object_id_t getDeviceObjectId(const CommandMessage *message);
 	static object_id_t getIoBoardObjectId(const CommandMessage* message);
 	static uint8_t getWiretappingMode(const CommandMessage* message);
 
-//	static void setDeviceHandlerDirectCommandMessage(CommandMessage* message,
-//			DeviceCommandId_t deviceCommand,
-//			store_address_t commandParametersStoreId);
-
 	static void setDeviceHandlerDirectCommandReply(CommandMessage* message,
 			object_id_t deviceObjectid,
 			store_address_t commandParametersStoreId);
@@ -75,11 +62,6 @@ public:
 			object_id_t deviceObjectid, store_address_t rawPacketStoreId,
 			bool isCommand);
 
-//	static void setDeviceHandlerMessage(CommandMessage* message,
-//			Command_t command, DeviceCommandId_t deviceCommand,
-//			store_address_t commandParametersStoreId);
-//	static void setDeviceHandlerMessage(CommandMessage* message,
-//			Command_t command, store_address_t rawPacketStoreId);
 	static void setDeviceHandlerWiretappingMessage(CommandMessage* message,
 			uint8_t wiretappingMode);
 	static void setDeviceHandlerSwitchIoBoardMessage(CommandMessage* message,
@@ -88,4 +70,4 @@ public:
 	static void clear(CommandMessage* message);
 };
 
-#endif /* DEVICEHANDLERMESSAGE_H_ */
+#endif /* FSFW_DEVICEHANDLERS_DEVICEHANDLERMESSAGE_H_ */

From 7c3f99ed2d4beba650722e596a48abb9edb837c4 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 1 Oct 2020 11:06:46 +0200
Subject: [PATCH 06/11] Revert "DH IF and DH message  form improved"

This reverts commit adf528fce91412c43daf349c02cee9710bf54363.
---
 devicehandlers/DeviceHandlerIF.h        | 20 ++-----
 devicehandlers/DeviceHandlerMessage.cpp | 19 +++++-
 devicehandlers/DeviceHandlerMessage.h   | 78 +++++++++++++++----------
 3 files changed, 69 insertions(+), 48 deletions(-)

diff --git a/devicehandlers/DeviceHandlerIF.h b/devicehandlers/DeviceHandlerIF.h
index 9c8eb098..52a3be4d 100644
--- a/devicehandlers/DeviceHandlerIF.h
+++ b/devicehandlers/DeviceHandlerIF.h
@@ -1,19 +1,12 @@
-#ifndef FSFW_DEVICEHANDLERS_DEVICEHANDLERIF_H_
-#define FSFW_DEVICEHANDLERS_DEVICEHANDLERIF_H_
-
-#include "DeviceHandlerMessage.h"
+#ifndef DEVICEHANDLERIF_H_
+#define DEVICEHANDLERIF_H_
 
 #include "../action/HasActionsIF.h"
+#include "DeviceHandlerMessage.h"
 #include "../events/Event.h"
 #include "../modes/HasModesIF.h"
 #include "../ipc/MessageQueueSenderIF.h"
 
-/**
- * This is used to uniquely identify commands that are sent to a device
- * The values are defined in the device-specific implementations
- */
-using DeviceCommandId_t = uint32_t;
-
 /**
  * @brief 	This is the Interface used to communicate with a device handler.
  * @details Includes all expected return values, events and modes.
@@ -22,7 +15,6 @@ using DeviceCommandId_t = uint32_t;
 class DeviceHandlerIF {
 public:
 
-
 	static const uint8_t TRANSITION_MODE_CHILD_ACTION_MASK = 0x20;
 	static const uint8_t TRANSITION_MODE_BASE_ACTION_MASK = 0x10;
 
@@ -55,8 +47,6 @@ public:
 	//! This is a transitional state which can not be commanded.
 	//! The device handler performs all actions and commands to get the device
 	//! shut down. When the device is off, the mode changes to @c MODE_OFF.
-	//! It is possible to set the mode to _MODE_SHUT_DOWN to use the to off
-	//! transition if available.
 	static const Mode_t _MODE_SHUT_DOWN = TRANSITION_MODE_CHILD_ACTION_MASK | 6;
 	//! It is possible to set the mode to _MODE_TO_ON to use the to on
 	//! transition if available.
@@ -106,7 +96,7 @@ public:
 	static const uint8_t INTERFACE_ID = CLASS_ID::DEVICE_HANDLER_IF;
 
 	// Standard codes used when building commands.
-	static const ReturnValue_t NO_COMMAND_DATA = MAKE_RETURN_CODE(0xA0); //!< If no command data was given when expected.
+	static const ReturnValue_t NO_COMMAND_DATA = MAKE_RETURN_CODE(0xA0); //!< If the command size is 0. Checked in DHB
 	static const ReturnValue_t COMMAND_NOT_SUPPORTED = MAKE_RETURN_CODE(0xA1); //!< Command ID not in commandMap. Checked in DHB
 	static const ReturnValue_t COMMAND_ALREADY_SENT = MAKE_RETURN_CODE(0xA2); //!< Command was already executed. Checked in DHB
 	static const ReturnValue_t COMMAND_WAS_NOT_SENT = MAKE_RETURN_CODE(0xA3);
@@ -160,4 +150,4 @@ public:
 
 };
 
-#endif /* FSFW_DEVICEHANDLERS_DEVICEHANDLERIF_H_ */
+#endif /* DEVICEHANDLERIF_H_ */
diff --git a/devicehandlers/DeviceHandlerMessage.cpp b/devicehandlers/DeviceHandlerMessage.cpp
index cb9043db..564fae21 100644
--- a/devicehandlers/DeviceHandlerMessage.cpp
+++ b/devicehandlers/DeviceHandlerMessage.cpp
@@ -1,6 +1,10 @@
+#include "../objectmanager/ObjectManagerIF.h"
 #include "DeviceHandlerMessage.h"
 #include "../objectmanager/ObjectManagerIF.h"
 
+DeviceHandlerMessage::DeviceHandlerMessage() {
+}
+
 store_address_t DeviceHandlerMessage::getStoreAddress(
 		const CommandMessage* message) {
 	return store_address_t(message->getParameter2());
@@ -21,6 +25,14 @@ uint8_t DeviceHandlerMessage::getWiretappingMode(
 	return message->getParameter();
 }
 
+//void DeviceHandlerMessage::setDeviceHandlerDirectCommandMessage(
+//		CommandMessage* message, DeviceCommandId_t deviceCommand,
+//		store_address_t commandParametersStoreId) {
+//	message->setCommand(CMD_DIRECT);
+//	message->setParameter(deviceCommand);
+//	message->setParameter2(commandParametersStoreId.raw);
+//}
+
 void DeviceHandlerMessage::setDeviceHandlerRawCommandMessage(
 		CommandMessage* message, store_address_t rawPacketStoreId) {
 	message->setCommand(CMD_RAW);
@@ -35,7 +47,7 @@ void DeviceHandlerMessage::setDeviceHandlerWiretappingMessage(
 
 void DeviceHandlerMessage::setDeviceHandlerSwitchIoBoardMessage(
 		CommandMessage* message, uint32_t ioBoardIdentifier) {
-	message->setCommand(CMD_SWITCH_ADDRESS);
+	message->setCommand(CMD_SWITCH_IOBOARD);
 	message->setParameter(ioBoardIdentifier);
 }
 
@@ -67,17 +79,18 @@ void DeviceHandlerMessage::setDeviceHandlerDirectCommandReply(
 void DeviceHandlerMessage::clear(CommandMessage* message) {
 	switch (message->getCommand()) {
 	case CMD_RAW:
+//	case CMD_DIRECT:
 	case REPLY_RAW_COMMAND:
 	case REPLY_RAW_REPLY:
 	case REPLY_DIRECT_COMMAND_DATA: {
 		StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(
 				objects::IPC_STORE);
-		if (ipcStore != nullptr) {
+		if (ipcStore != NULL) {
 			ipcStore->deleteData(getStoreAddress(message));
 		}
 	}
 		/* NO BREAK falls through*/
-	case CMD_SWITCH_ADDRESS:
+	case CMD_SWITCH_IOBOARD:
 	case CMD_WIRETAPPING:
 		message->setCommand(CommandMessage::CMD_NONE);
 		message->setParameter(0);
diff --git a/devicehandlers/DeviceHandlerMessage.h b/devicehandlers/DeviceHandlerMessage.h
index e5da01c8..8d1c94f4 100644
--- a/devicehandlers/DeviceHandlerMessage.h
+++ b/devicehandlers/DeviceHandlerMessage.h
@@ -1,56 +1,69 @@
-#ifndef FSFW_DEVICEHANDLERS_DEVICEHANDLERMESSAGE_H_
-#define FSFW_DEVICEHANDLERS_DEVICEHANDLERMESSAGE_H_
+#ifndef DEVICEHANDLERMESSAGE_H_
+#define DEVICEHANDLERMESSAGE_H_
 
 #include "../action/ActionMessage.h"
 #include "../ipc/CommandMessage.h"
 #include "../objectmanager/SystemObjectIF.h"
 #include "../storagemanager/StorageManagerIF.h"
-// SHOULDDO: rework the static constructors to name the type of command
-// they are building, maybe even hide setting the commandID.
-
+//SHOULDDO: rework the static constructors to name the type of command they are building, maybe even hide setting the commandID.
 
 /**
- * @brief   The DeviceHandlerMessage is used to send commands to classes
- *          implementing DeviceHandlerIF
+ * This is used to uniquely identify commands that are sent to a device
+ *
+ * The values are defined in the device-specific implementations
+ */
+typedef uint32_t DeviceCommandId_t;
+
+/**
+ * The DeviceHandlerMessage is used to send Commands to a DeviceHandlerIF
  */
 class DeviceHandlerMessage {
+private:
+	DeviceHandlerMessage();
 public:
-    /**
-     * Instantiation forbidden. Instead, use static functions to operate
-     * on messages.
-     */
-	DeviceHandlerMessage() = delete;
-	virtual ~DeviceHandlerMessage() {}
 
 	/**
 	 * These are the commands that can be sent to a DeviceHandlerBase
 	 */
 	static const uint8_t MESSAGE_ID = messagetypes::DEVICE_HANDLER_COMMAND;
-	//! Sends a raw command, setParameter is a storeId containing the
-	//! raw packet to send
-	static const Command_t CMD_RAW = MAKE_COMMAND_ID(1);
-	//! Requests a IO-Board switch, setParameter() is the IO-Board identifier
-	static const Command_t CMD_SWITCH_ADDRESS = MAKE_COMMAND_ID(3);
-	//! (De)Activates the monitoring of all raw traffic in DeviceHandlers,
-	//! setParameter is 0 to deactivate, 1 to activate
-	static const Command_t CMD_WIRETAPPING = MAKE_COMMAND_ID(4);
+	static const Command_t CMD_RAW = MAKE_COMMAND_ID( 1 ); //!< Sends a raw command, setParameter is a ::store_id_t containing the raw packet to send
+//	static const Command_t CMD_DIRECT = MAKE_COMMAND_ID( 2 ); //!< Sends a direct command, setParameter is a ::DeviceCommandId_t, setParameter2 is a ::store_id_t containing the data needed for the command
+	static const Command_t CMD_SWITCH_IOBOARD = MAKE_COMMAND_ID( 3 ); //!< Requests a IO-Board switch, setParameter() is the IO-Board identifier
+	static const Command_t CMD_WIRETAPPING = MAKE_COMMAND_ID( 4 ); //!< (De)Activates the monitoring of all raw traffic in DeviceHandlers, setParameter is 0 to deactivate, 1 to activate
 
-	//! Signals that a direct command was sent
-	static const Command_t REPLY_DIRECT_COMMAND_SENT = ActionMessage::STEP_SUCCESS;
-	//! Contains a raw command sent to the Device
-	static const Command_t REPLY_RAW_COMMAND = MAKE_COMMAND_ID(0x11);
-	//! Contains a raw reply from the Device, getParameter() is the ObjcetId
-	//! of the sender, getParameter2() is a ::store_id_t containing the
-	//! raw packet received
-	static const Command_t REPLY_RAW_REPLY = MAKE_COMMAND_ID(0x12);
+	/*static const Command_t REPLY_SWITCHED_IOBOARD = MAKE_COMMAND_ID(1 );//!< Reply to a @c CMD_SWITCH_IOBOARD, indicates switch was successful, getParameter() contains the board switched to (0: nominal, 1: redundant)
+	 static const Command_t REPLY_CANT_SWITCH_IOBOARD = MAKE_COMMAND_ID( 2);	//!< Reply to a @c CMD_SWITCH_IOBOARD, indicating the switch could not be performed, getParameter() contains the error message
+	 static const Command_t REPLY_WIRETAPPING = MAKE_COMMAND_ID( 3);	//!< Reply to a @c CMD_WIRETAPPING, getParameter() is the current state, 1 enabled, 0 disabled
+
+	 static const Command_t REPLY_COMMAND_WAS_SENT = MAKE_COMMAND_ID(4 );//!< Reply to a @c CMD_RAW or @c CMD_DIRECT, indicates the command was successfully sent to the device, getParameter() contains the ::DeviceCommandId_t
+	 static const Command_t REPLY_COMMAND_NOT_SUPPORTED = MAKE_COMMAND_ID(5 );//!< Reply to a @c CMD_DIRECT, the requested ::DeviceCommand_t is not supported, getParameter() contains the requested ::DeviceCommand_t, getParameter2() contains the ::DeviceCommandId_t
+	 static const Command_t REPLY_COMMAND_WAS_NOT_SENT = MAKE_COMMAND_ID(6 );//!< Reply to a @c CMD_RAW or @c CMD_DIRECT, indicates the command was not sent, getParameter contains the RMAP Return code (@see rmap.h), getParameter2() contains the ::DeviceCommandId_t
+
+	 static const Command_t REPLY_COMMAND_ALREADY_SENT = MAKE_COMMAND_ID(7 );//!< Reply to a @c CMD_DIRECT, the requested ::DeviceCommand_t has already been sent to the device and not ye been answered
+	 static const Command_t REPLY_WRONG_MODE_FOR_CMD = MAKE_COMMAND_ID(8 );//!< Reply to a @c CMD_RAW or @c CMD_DIRECT, indicates that the requested command can not be sent in the curent mode, getParameter() contains the DeviceHandlerCommand_t
+	 static const Command_t REPLY_NO_DATA = MAKE_COMMAND_ID(9 );	//!< Reply to a CMD_RAW or @c CMD_DIRECT, indicates that the ::store_id_t was invalid, getParameter() contains the ::DeviceCommandId_t, getPrameter2() contains the error code
+	 */
+	static const Command_t REPLY_DIRECT_COMMAND_SENT = ActionMessage::STEP_SUCCESS; //!< Signals that a direct command was sent
+	static const Command_t REPLY_RAW_COMMAND = MAKE_COMMAND_ID(0x11 ); //!< Contains a raw command sent to the Device
+	static const Command_t REPLY_RAW_REPLY = MAKE_COMMAND_ID( 0x12); //!< Contains a raw reply from the Device, getParameter() is the ObjcetId of the sender, getParameter2() is a ::store_id_t containing the raw packet received
 	static const Command_t REPLY_DIRECT_COMMAND_DATA = ActionMessage::DATA_REPLY;
 
+	/**
+	 * Default Destructor
+	 */
+	virtual ~DeviceHandlerMessage() {
+	}
+
 	static store_address_t getStoreAddress(const CommandMessage* message);
 	static uint32_t getDeviceCommandId(const CommandMessage* message);
 	static object_id_t getDeviceObjectId(const CommandMessage *message);
 	static object_id_t getIoBoardObjectId(const CommandMessage* message);
 	static uint8_t getWiretappingMode(const CommandMessage* message);
 
+//	static void setDeviceHandlerDirectCommandMessage(CommandMessage* message,
+//			DeviceCommandId_t deviceCommand,
+//			store_address_t commandParametersStoreId);
+
 	static void setDeviceHandlerDirectCommandReply(CommandMessage* message,
 			object_id_t deviceObjectid,
 			store_address_t commandParametersStoreId);
@@ -62,6 +75,11 @@ public:
 			object_id_t deviceObjectid, store_address_t rawPacketStoreId,
 			bool isCommand);
 
+//	static void setDeviceHandlerMessage(CommandMessage* message,
+//			Command_t command, DeviceCommandId_t deviceCommand,
+//			store_address_t commandParametersStoreId);
+//	static void setDeviceHandlerMessage(CommandMessage* message,
+//			Command_t command, store_address_t rawPacketStoreId);
 	static void setDeviceHandlerWiretappingMessage(CommandMessage* message,
 			uint8_t wiretappingMode);
 	static void setDeviceHandlerSwitchIoBoardMessage(CommandMessage* message,
@@ -70,4 +88,4 @@ public:
 	static void clear(CommandMessage* message);
 };
 
-#endif /* FSFW_DEVICEHANDLERS_DEVICEHANDLERMESSAGE_H_ */
+#endif /* DEVICEHANDLERMESSAGE_H_ */

From 1f3a10b37554c1b8872a2dd82e0ebb4673e270f7 Mon Sep 17 00:00:00 2001
From: Steffen Gaisser <gaisser@irs.uni-stuttgart.de>
Date: Thu, 1 Oct 2020 13:30:28 +0200
Subject: [PATCH 07/11] Fixes and comments in FixedOrderedMultimap

---
 container/FixedOrderedMultimap.h | 208 +++++++++++++++++++++++--------
 1 file changed, 159 insertions(+), 49 deletions(-)

diff --git a/container/FixedOrderedMultimap.h b/container/FixedOrderedMultimap.h
index 717575d7..a9f093d6 100644
--- a/container/FixedOrderedMultimap.h
+++ b/container/FixedOrderedMultimap.h
@@ -5,6 +5,24 @@
 #include <cstring>
 #include <set>
 /**
+ * @brief A "Map" which allows multiple entries of the same key.
+ * @details
+ * Same keys are ordered by KEY_COMPARE function which is std::less<key_t> > by default.
+ *
+ * It uses the ArrayList, so technically this is not a real map, it is an array of pairs
+ * of type key_t, T. It is ordered by key_t as FixedMap but allows same keys.
+ *
+ * Its of fixed size so no allocations are performed after the construction.
+ *
+ * The maximum size is given as first parameter of the constructor.
+ *
+ * It provides an iterator to do list iterations.
+ *
+ * The type T must have a copy constructor if it is not trivial copy-able.
+ *
+ * @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, typename KEY_COMPARE = std::less<key_t>>
@@ -14,78 +32,84 @@ public:
 	static const ReturnValue_t MAP_FULL = MAKE_RETURN_CODE(0x01);
 	static const ReturnValue_t KEY_DOES_NOT_EXIST = MAKE_RETURN_CODE(0x02);
 
-private:
-	typedef KEY_COMPARE compare;
-	compare myComp;
-	ArrayList<std::pair<key_t, T>, uint32_t> theMap;
-	uint32_t _size;
-
-	uint32_t findFirstIndex(key_t key, uint32_t startAt = 0) const {
-		if (startAt >= _size) {
-			return startAt + 1;
-		}
-		uint32_t i = startAt;
-		for (i = startAt; i < _size; ++i) {
-			if (theMap[i].first == key) {
-				return i;
-			}
-		}
-		return i;
-	}
-
-	uint32_t findNicePlace(key_t key) const {
-		uint32_t i = 0;
-		for (i = 0; i < _size; ++i) {
-			if (myComp(key, theMap[i].first)) {
-				return i;
-			}
-		}
-		return i;
-	}
-
-	void removeFromPosition(uint32_t position) {
-		if (_size <= position) {
-			return;
-		}
-		memmove(static_cast<void*>(&theMap[position]), static_cast<void*>(&theMap[position + 1]),
-				(_size - position - 1) * sizeof(std::pair<key_t,T>));
-		--_size;
-	}
-public:
-	FixedOrderedMultimap(uint32_t maxSize) :
-			theMap(maxSize), _size(0) {
+	/***
+	 * Constructor which needs a size_t for the maximum allowed size
+	 *
+	 * Can not be resized during runtime
+	 *
+	 * Allocates memory at construction
+	 * @param maxSize size_t of Maximum allowed size
+	 */
+	FixedOrderedMultimap(size_t maxSize) :
+		theMap(maxSize), _size(0) {
 	}
+	/***
+	 * Virtual destructor frees Memory by deleting its member
+	 */
 	virtual ~FixedOrderedMultimap() {
 	}
 
-	class Iterator: public ArrayList<std::pair<key_t, T>, uint32_t>::Iterator {
+	/***
+	 * Special iterator for FixedOrderedMultimap
+	 */
+	class Iterator: public ArrayList<std::pair<key_t, T>, size_t>::Iterator {
 	public:
 		Iterator() :
-				ArrayList<std::pair<key_t, T>, uint32_t>::Iterator() {
+			ArrayList<std::pair<key_t, T>, size_t>::Iterator() {
 		}
 
 		Iterator(std::pair<key_t, T> *pair) :
-				ArrayList<std::pair<key_t, T>, uint32_t>::Iterator(pair) {
+			ArrayList<std::pair<key_t, T>, size_t>::Iterator(pair) {
 		}
 	};
 
+	friend bool operator==(const typename FixedOrderedMultimap::Iterator& lhs,
+			const typename FixedOrderedMultimap::Iterator& rhs) {
+		return (lhs.value == rhs.value);
+	}
+
+	friend bool operator!=(const typename FixedOrderedMultimap::Iterator& lhs,
+			const typename FixedOrderedMultimap::Iterator& rhs) {
+		return not (lhs.value == rhs.value);
+	}
+
+	/***
+	 * Returns an iterator on the first element
+	 * @return Iterator pointing to first element
+	 */
 	Iterator begin() const {
 		return Iterator(&theMap[0]);
 	}
 
+	/**
+	 * Returns an iterator pointing to one element past the end
+	 * @return Iterator pointing to one element past the end
+	 */
 	Iterator end() const {
 		return Iterator(&theMap[_size]);
 	}
 
-	uint32_t size() const {
+	/***
+	 * Returns the current size of the map (not maximum size!)
+	 * @return Current size
+	 */
+	size_t size() const {
 		return _size;
 	}
 
+	/***
+	 * Used to insert a key and value separately.
+	 *
+	 * @param[in] key Key of the new element
+	 * @param[in] value Value of the new element
+	 * @param[in/out] (optional) storedValue On success this points to the new value, otherwise a nullptr
+	 * @return RETURN_OK if insert was successful, MAP_FULL if no space is available
+	 */
 	ReturnValue_t insert(key_t key, T value, Iterator *storedValue = nullptr) {
 		if (_size == theMap.maxSize()) {
 			return MAP_FULL;
 		}
-		uint32_t position = findNicePlace(key);
+		size_t position = findNicePlace(key);
 		memmove(static_cast<void*>(&theMap[position + 1]),static_cast<void*>(&theMap[position]),
 				(_size - position) * sizeof(std::pair<key_t,T>));
 		theMap[position].first = key;
@@ -97,10 +121,21 @@ public:
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 
+	/***
+	 * Used to insert new pair instead of single values
+	 *
+	 * @param pair Pair to be inserted
+	 * @return RETURN_OK if insert was successful, MAP_FULL if no space is available
+	 */
 	ReturnValue_t insert(std::pair<key_t, T> pair) {
 		return insert(pair.first, pair.second);
 	}
 
+	/***
+	 * Can be used to check if a certain key is in the map
+	 * @param key Key to be checked
+	 * @return RETURN_OK if the key exists KEY_DOES_NOT_EXIST otherwise
+	 */
 	ReturnValue_t exists(key_t key) const {
 		ReturnValue_t result = KEY_DOES_NOT_EXIST;
 		if (findFirstIndex(key) < _size) {
@@ -109,8 +144,18 @@ public:
 		return result;
 	}
 
+	/***
+	 * Used to delete the element in the iterator
+	 *
+	 * The iterator will point to the element before or begin(),
+	 *  but never to one element in front of the map.
+	 *
+	 * @warning The iterator needs to be valid and dereferenceable
+	 * @param[in/out] iter Pointer to iterator to the element that needs to be ereased
+	 * @return RETURN_OK if erased, KEY_DOES_NOT_EXIST if the there is no element like this
+	 */
 	ReturnValue_t erase(Iterator *iter) {
-		uint32_t i;
+		size_t i;
 		if ((i = findFirstIndex((*iter).value->first)) >= _size) {
 			return KEY_DOES_NOT_EXIST;
 		}
@@ -123,8 +168,13 @@ public:
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 
+	/***
+	 * Used to erase by key
+	 * @param key Key to be erased
+	 * @return RETURN_OK if erased, KEY_DOES_NOT_EXIST if the there is no element like this
+	 */
 	ReturnValue_t erase(key_t key) {
-		uint32_t i;
+		size_t i;
 		if ((i = findFirstIndex(key)) >= _size) {
 			return KEY_DOES_NOT_EXIST;
 		}
@@ -135,6 +185,14 @@ public:
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 
+	/***
+	 * Find returns the first appearance of the key
+	 *
+	 * If the key does not exist, it points to end()
+	 *
+	 * @param key Key to search for
+	 * @return Iterator pointing to the first entry of key
+	 */
 	Iterator find(key_t key) const {
 		ReturnValue_t result = exists(key);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
@@ -143,6 +201,15 @@ public:
 		return Iterator(&theMap[findFirstIndex(key)]);
 	}
 
+	/***
+	 * Finds first entry of the given key and returns a
+	 * pointer to the value
+	 *
+	 * @param key Key to search for
+	 * @param value Found value
+	 * @return RETURN_OK if it points to the value,
+	 * KEY_DOES_NOT_EXIST if the key is not in the map
+	 */
 	ReturnValue_t find(key_t key, T **value) const {
 		ReturnValue_t result = exists(key);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
@@ -151,15 +218,58 @@ public:
 		*value = &theMap[findFirstIndex(key)].second;
 		return HasReturnvaluesIF::RETURN_OK;
 	}
-
+	/**
+	 * Clears the map, does not deallocate any memory
+	 */
 	void clear() {
 		_size = 0;
 	}
 
-	uint32_t maxSize() const {
+	/**
+	 * Returns the maximum size of the map
+	 * @return Maximum size of the map
+	 */
+	size_t maxSize() const {
 		return theMap.maxSize();
 	}
 
+private:
+	typedef KEY_COMPARE compare;
+	compare myComp;
+	ArrayList<std::pair<key_t, T>, size_t> theMap;
+	size_t _size;
+
+	size_t findFirstIndex(key_t key, size_t startAt = 0) const {
+		if (startAt >= _size) {
+			return startAt + 1;
+		}
+		size_t i = startAt;
+		for (i = startAt; i < _size; ++i) {
+			if (theMap[i].first == key) {
+				return i;
+			}
+		}
+		return i;
+	}
+
+	size_t findNicePlace(key_t key) const {
+		size_t i = 0;
+		for (i = 0; i < _size; ++i) {
+			if (myComp(key, theMap[i].first)) {
+				return i;
+			}
+		}
+		return i;
+	}
+
+	void removeFromPosition(size_t position) {
+		if (_size <= position) {
+			return;
+		}
+		memmove(static_cast<void*>(&theMap[position]), static_cast<void*>(&theMap[position + 1]),
+				(_size - position - 1) * sizeof(std::pair<key_t,T>));
+		--_size;
+	}
 };
 
 #endif /* FRAMEWORK_CONTAINER_FIXEDORDEREDMULTIMAP_H_ */

From c86d654fdfedfb3319e9ace45dc83874ce8d5c6a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 1 Oct 2020 13:58:20 +0200
Subject: [PATCH 08/11] tpp file added

---
 container/FixedOrderedMultimap.h   | 197 ++++++++++++-----------------
 container/FixedOrderedMultimap.tpp | 143 +++++++++++++++++++++
 2 files changed, 222 insertions(+), 118 deletions(-)
 create mode 100644 container/FixedOrderedMultimap.tpp

diff --git a/container/FixedOrderedMultimap.h b/container/FixedOrderedMultimap.h
index 717575d7..cb8ab10f 100644
--- a/container/FixedOrderedMultimap.h
+++ b/container/FixedOrderedMultimap.h
@@ -1,24 +1,91 @@
-#ifndef FRAMEWORK_CONTAINER_FIXEDORDEREDMULTIMAP_H_
-#define FRAMEWORK_CONTAINER_FIXEDORDEREDMULTIMAP_H_
+#ifndef FSFW_CONTAINER_FIXEDORDEREDMULTIMAP_H_
+#define FSFW_CONTAINER_FIXEDORDEREDMULTIMAP_H_
 
 #include "ArrayList.h"
 #include <cstring>
-#include <set>
+
 /**
- * \ingroup container
+ * @brief   Map implementation which allows entries with identical keys
+ * @details
+ * Performs no dynamic memory allocation except on initialization.
+ * Uses an ArrayList as the underlying container and thus has a linear
+ * complexity O(n). As long as the number of entries remains low, this
+ * should not be an issue.
+ * The number of insertion and deletion operation should be minimized
+ * as those incur exensive memory move operations (the underlying container
+ * is not node based).
+ * @ingroup container
  */
 template<typename key_t, typename T, typename KEY_COMPARE = std::less<key_t>>
 class FixedOrderedMultimap {
 public:
 	static const uint8_t INTERFACE_ID = CLASS_ID::FIXED_MULTIMAP;
-	static const ReturnValue_t MAP_FULL = MAKE_RETURN_CODE(0x01);
-	static const ReturnValue_t KEY_DOES_NOT_EXIST = MAKE_RETURN_CODE(0x02);
+	static const ReturnValue_t KEY_ALREADY_EXISTS = MAKE_RETURN_CODE(0x01);
+	static const ReturnValue_t MAP_FULL = MAKE_RETURN_CODE(0x02);
+	static const ReturnValue_t KEY_DOES_NOT_EXIST = MAKE_RETURN_CODE(0x03);
+
+	/**
+	 * Initializes the ordered multimap with a fixed maximum size.
+	 * @param maxSize
+	 */
+    FixedOrderedMultimap(size_t maxSize);
+
+    virtual ~FixedOrderedMultimap() {}
+
+    class Iterator: public ArrayList<std::pair<key_t, T>, uint32_t>::Iterator {
+    public:
+        /** Returns an iterator to nullptr */
+        Iterator();
+        /** Initializes iterator to given entry */
+        Iterator(std::pair<key_t, T> *pair);
+    };
+
+    /** Iterator to start of map */
+    Iterator begin() const;
+    /** Iterator to end of map */
+    Iterator end() const;
+    /** Current (variable) size of the map */
+    size_t size() const;
+
+    /**
+     * Insert a key/value pair inside the map. An iterator to the stored
+     * value might be returned optionally.
+     * @param key
+     * @param value
+     * @param storedValue
+     * @return
+     */
+    ReturnValue_t insert(key_t key, T value, Iterator *storedValue = nullptr);
+    /**
+     * Insert a given std::pair<key, value>
+     * @param pair
+     * @return
+     */
+    ReturnValue_t insert(std::pair<key_t, T> pair);
+    /**
+     * Checks existence of key in map.
+     * @param key
+     * @return
+     * - @c KEY_DOES_NOT_EXIST if key does not exists.
+     * - @c RETURN_OK otherwise.
+     */
+    ReturnValue_t exists(key_t key) const;
+
+    ReturnValue_t erase(Iterator *iter);
+    ReturnValue_t erase(key_t key);
+
+    Iterator find(key_t key) const;
+    ReturnValue_t find(key_t key, T **value) const;
+
+    void clear();
+
+    size_t maxSize() const;
 
 private:
 	typedef KEY_COMPARE compare;
 	compare myComp;
 	ArrayList<std::pair<key_t, T>, uint32_t> theMap;
-	uint32_t _size;
+	size_t _size;
 
 	uint32_t findFirstIndex(key_t key, uint32_t startAt = 0) const {
 		if (startAt >= _size) {
@@ -47,119 +114,13 @@ private:
 		if (_size <= position) {
 			return;
 		}
-		memmove(static_cast<void*>(&theMap[position]), static_cast<void*>(&theMap[position + 1]),
+		std::memmove(static_cast<void*>(&theMap[position]),
+		        static_cast<void*>(&theMap[position + 1]),
 				(_size - position - 1) * sizeof(std::pair<key_t,T>));
 		--_size;
 	}
-public:
-	FixedOrderedMultimap(uint32_t maxSize) :
-			theMap(maxSize), _size(0) {
-	}
-	virtual ~FixedOrderedMultimap() {
-	}
-
-	class Iterator: public ArrayList<std::pair<key_t, T>, uint32_t>::Iterator {
-	public:
-		Iterator() :
-				ArrayList<std::pair<key_t, T>, uint32_t>::Iterator() {
-		}
-
-		Iterator(std::pair<key_t, T> *pair) :
-				ArrayList<std::pair<key_t, T>, uint32_t>::Iterator(pair) {
-		}
-	};
-
-	Iterator begin() const {
-		return Iterator(&theMap[0]);
-	}
-
-	Iterator end() const {
-		return Iterator(&theMap[_size]);
-	}
-
-	uint32_t size() const {
-		return _size;
-	}
-
-	ReturnValue_t insert(key_t key, T value, Iterator *storedValue = nullptr) {
-		if (_size == theMap.maxSize()) {
-			return MAP_FULL;
-		}
-		uint32_t position = findNicePlace(key);
-		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 != nullptr) {
-			*storedValue = Iterator(&theMap[position]);
-		}
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-
-	ReturnValue_t insert(std::pair<key_t, T> pair) {
-		return insert(pair.first, pair.second);
-	}
-
-	ReturnValue_t exists(key_t key) const {
-		ReturnValue_t result = KEY_DOES_NOT_EXIST;
-		if (findFirstIndex(key) < _size) {
-			result = HasReturnvaluesIF::RETURN_OK;
-		}
-		return result;
-	}
-
-	ReturnValue_t erase(Iterator *iter) {
-		uint32_t i;
-		if ((i = findFirstIndex((*iter).value->first)) >= _size) {
-			return KEY_DOES_NOT_EXIST;
-		}
-		removeFromPosition(i);
-		if (*iter != begin()) {
-			(*iter)--;
-		} else {
-			*iter = begin();
-		}
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-
-	ReturnValue_t erase(key_t key) {
-		uint32_t i;
-		if ((i = findFirstIndex(key)) >= _size) {
-			return KEY_DOES_NOT_EXIST;
-		}
-		do {
-			removeFromPosition(i);
-			i = findFirstIndex(key, i);
-		} while (i < _size);
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-
-	Iterator find(key_t key) const {
-		ReturnValue_t result = exists(key);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return end();
-		}
-		return Iterator(&theMap[findFirstIndex(key)]);
-	}
-
-	ReturnValue_t find(key_t key, T **value) const {
-		ReturnValue_t result = exists(key);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		*value = &theMap[findFirstIndex(key)].second;
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-
-	void clear() {
-		_size = 0;
-	}
-
-	uint32_t maxSize() const {
-		return theMap.maxSize();
-	}
-
 };
 
-#endif /* FRAMEWORK_CONTAINER_FIXEDORDEREDMULTIMAP_H_ */
+#include "FixedOrderedMultimap.tpp"
+
+#endif /* FSFW_CONTAINER_FIXEDORDEREDMULTIMAP_H_ */
diff --git a/container/FixedOrderedMultimap.tpp b/container/FixedOrderedMultimap.tpp
new file mode 100644
index 00000000..bc76c594
--- /dev/null
+++ b/container/FixedOrderedMultimap.tpp
@@ -0,0 +1,143 @@
+#ifndef FRAMEWORK_CONTAINER_FIXEDORDEREDMULTIMAP_TPP_
+#define FRAMEWORK_CONTAINER_FIXEDORDEREDMULTIMAP_TPP_
+
+template<typename key_t, typename T, typename KEY_COMPARE>
+inline FixedOrderedMultimap<key_t, T, KEY_COMPARE>::Iterator::Iterator():
+        ArrayList<std::pair<key_t, T>, uint32_t>::Iterator(){}
+
+template<typename key_t, typename T, typename KEY_COMPARE>
+inline FixedOrderedMultimap<key_t, T, KEY_COMPARE>::Iterator::Iterator(
+        std::pair<key_t, T> *pair):
+        ArrayList<std::pair<key_t, T>, uint32_t>::Iterator(pair){}
+
+template<typename key_t, typename T, typename KEY_COMPARE>
+inline typename FixedOrderedMultimap<key_t, T, KEY_COMPARE>::Iterator
+FixedOrderedMultimap<key_t, T, KEY_COMPARE>::begin() const {
+    return Iterator(&theMap[0]);
+}
+
+template<typename key_t, typename T, typename KEY_COMPARE>
+inline typename FixedOrderedMultimap<key_t, T, KEY_COMPARE>::Iterator
+FixedOrderedMultimap<key_t, T, KEY_COMPARE>::end() const {
+    return Iterator(&theMap[_size]);
+}
+
+
+template<typename key_t, typename T, typename KEY_COMPARE>
+inline size_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::size() const {
+    return _size;
+}
+
+template<typename key_t, typename T, typename KEY_COMPARE>
+inline FixedOrderedMultimap<key_t, T, KEY_COMPARE>::FixedOrderedMultimap(
+        size_t maxSize): theMap(maxSize), _size(0) {}
+
+
+template<typename key_t, typename T, typename KEY_COMPARE>
+inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::insert(
+        key_t key, T value, Iterator *storedValue) {
+    if (_size == theMap.maxSize()) {
+        return MAP_FULL;
+    }
+    uint32_t position = findNicePlace(key);
+    // Compiler might emitt warning because std::pair is not a POD type (yet..)
+    // See: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2342.htm#std::pair-example
+    // Circumvent warning by casting to void*
+    std::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 != nullptr) {
+        *storedValue = Iterator(&theMap[position]);
+    }
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+template<typename key_t, typename T, typename KEY_COMPARE>
+inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::insert(
+        std::pair<key_t, T> pair) {
+    return insert(pair.fist, pair.second);
+}
+
+template<typename key_t, typename T, typename KEY_COMPARE>
+inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::exists(
+        key_t key) const {
+    ReturnValue_t result = KEY_DOES_NOT_EXIST;
+    if (findFirstIndex(key) < _size) {
+        result = HasReturnvaluesIF::RETURN_OK;
+    }
+    return result;
+}
+
+template<typename key_t, typename T, typename KEY_COMPARE>
+inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::erase(
+        Iterator *iter)
+{
+    uint32_t i;
+    if ((i = findFirstIndex((*iter).value->first)) >= _size) {
+        return KEY_DOES_NOT_EXIST;
+    }
+    removeFromPosition(i);
+    if (*iter != begin()) {
+        (*iter)--;
+    } else {
+        *iter = begin();
+    }
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+template<typename key_t, typename T, typename KEY_COMPARE>
+inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::erase(
+        key_t key)
+{
+    uint32_t i;
+    if ((i = findFirstIndex(key)) >= _size) {
+        return KEY_DOES_NOT_EXIST;
+    }
+    do {
+        removeFromPosition(i);
+        i = findFirstIndex(key, i);
+    } while (i < _size);
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+template<typename key_t, typename T, typename KEY_COMPARE>
+inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::find(
+        key_t key, T **value) const
+{
+    ReturnValue_t result = exists(key);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
+    *value = &theMap[findFirstIndex(key)].second;
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+template<typename key_t, typename T, typename KEY_COMPARE>
+inline typename FixedOrderedMultimap<key_t, T, KEY_COMPARE>::Iterator
+FixedOrderedMultimap<key_t, T, KEY_COMPARE>::find(
+        key_t key) const
+{
+    ReturnValue_t result = exists(key);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        return end();
+    }
+    return Iterator(&theMap[findFirstIndex(key)]);
+}
+
+template<typename key_t, typename T, typename KEY_COMPARE>
+inline void FixedOrderedMultimap<key_t, T, KEY_COMPARE>::clear()
+{
+    _size = 0;
+}
+
+template<typename key_t, typename T, typename KEY_COMPARE>
+inline size_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::maxSize() const
+{
+    return theMap.maxSize();
+}
+
+
+#endif /* FRAMEWORK_CONTAINER_FIXEDORDEREDMULTIMAP_TPP_ */

From 587f87d270b282726363f348467f130370d61f96 Mon Sep 17 00:00:00 2001
From: Steffen Gaisser <gaisser@irs.uni-stuttgart.de>
Date: Thu, 1 Oct 2020 17:27:24 +0200
Subject: [PATCH 09/11] Feedback from Robin

---
 container/FixedOrderedMultimap.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/container/FixedOrderedMultimap.h b/container/FixedOrderedMultimap.h
index 4bbea302..82d388c9 100644
--- a/container/FixedOrderedMultimap.h
+++ b/container/FixedOrderedMultimap.h
@@ -5,7 +5,7 @@
 #include <cstring>
 
 /**
- * @brief A "Map" which allows multiple entries of the same key.
+ * @brief  An associative container which allows multiple entries of the same key.
  * @details
  * Same keys are ordered by KEY_COMPARE function which is std::less<key_t> > by default.
  *

From f1bc9972f3217981b895a6e48e9aca816340512c Mon Sep 17 00:00:00 2001
From: Steffen Gaisser <gaisser@irs.uni-stuttgart.de>
Date: Thu, 1 Oct 2020 17:36:46 +0200
Subject: [PATCH 10/11] Fixed bugs

---
 container/FixedOrderedMultimap.tpp | 24 ++++++++++++------------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/container/FixedOrderedMultimap.tpp b/container/FixedOrderedMultimap.tpp
index 715bf474..16a7124b 100644
--- a/container/FixedOrderedMultimap.tpp
+++ b/container/FixedOrderedMultimap.tpp
@@ -2,8 +2,8 @@
 #define FRAMEWORK_CONTAINER_FIXEDORDEREDMULTIMAP_TPP_
 
 
-template<typename key_t, typename T, typename KEY_COMPARE = std::less<key_t>>
-ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::insert(key_t key, T value, Iterator *storedValue = nullptr) {
+template<typename key_t, typename T, typename KEY_COMPARE>
+ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::insert(key_t key, T value, Iterator *storedValue) {
 	if (_size == theMap.maxSize()) {
 		return MAP_FULL;
 	}
@@ -18,12 +18,12 @@ ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::insert(key_t key, T v
 	}
 	return HasReturnvaluesIF::RETURN_OK;
 }
-template<typename key_t, typename T, typename KEY_COMPARE = std::less<key_t>>
+template<typename key_t, typename T, typename KEY_COMPARE>
 ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::insert(std::pair<key_t, T> pair) {
 	return insert(pair.first, pair.second);
 }
 
-template<typename key_t, typename T, typename KEY_COMPARE = std::less<key_t>>
+template<typename key_t, typename T, typename KEY_COMPARE>
 ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::exists(key_t key) const {
 	ReturnValue_t result = KEY_DOES_NOT_EXIST;
 	if (findFirstIndex(key) < _size) {
@@ -32,7 +32,7 @@ ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::exists(key_t key) con
 	return result;
 }
 
-template<typename key_t, typename T, typename KEY_COMPARE = std::less<key_t>>
+template<typename key_t, typename T, typename KEY_COMPARE>
 ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::erase(Iterator *iter) {
 	size_t i;
 	if ((i = findFirstIndex((*iter).value->first)) >= _size) {
@@ -47,7 +47,7 @@ ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::erase(Iterator *iter)
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
-template<typename key_t, typename T, typename KEY_COMPARE = std::less<key_t>>
+template<typename key_t, typename T, typename KEY_COMPARE>
 ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::erase(key_t key) {
 	size_t i;
 	if ((i = findFirstIndex(key)) >= _size) {
@@ -60,7 +60,7 @@ ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::erase(key_t key) {
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
-template<typename key_t, typename T, typename KEY_COMPARE = std::less<key_t>>
+template<typename key_t, typename T, typename KEY_COMPARE>
 FixedOrderedMultimap<key_t, T, KEY_COMPARE>::Iterator FixedOrderedMultimap<key_t, T, KEY_COMPARE>::find(key_t key) const {
 	ReturnValue_t result = exists(key);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
@@ -69,7 +69,7 @@ FixedOrderedMultimap<key_t, T, KEY_COMPARE>::Iterator FixedOrderedMultimap<key_t
 	return Iterator(&theMap[findFirstIndex(key)]);
 }
 
-template<typename key_t, typename T, typename KEY_COMPARE = std::less<key_t>>
+template<typename key_t, typename T, typename KEY_COMPARE>
 ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::find(key_t key, T **value) const {
 	ReturnValue_t result = exists(key);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
@@ -79,8 +79,8 @@ ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::find(key_t key, T **v
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
-template<typename key_t, typename T, typename KEY_COMPARE = std::less<key_t>>
-size_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::findFirstIndex(key_t key, size_t startAt = 0) const {
+template<typename key_t, typename T, typename KEY_COMPARE>
+size_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::findFirstIndex(key_t key, size_t startAt) const {
 	if (startAt >= _size) {
 		return startAt + 1;
 	}
@@ -93,7 +93,7 @@ size_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::findFirstIndex(key_t key, si
 	return i;
 }
 
-template<typename key_t, typename T, typename KEY_COMPARE = std::less<key_t>>
+template<typename key_t, typename T, typename KEY_COMPARE>
 size_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::findNicePlace(key_t key) const {
 	size_t i = 0;
 	for (i = 0; i < _size; ++i) {
@@ -104,7 +104,7 @@ size_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::findNicePlace(key_t key) con
 	return i;
 }
 
-template<typename key_t, typename T, typename KEY_COMPARE = std::less<key_t>>
+template<typename key_t, typename T, typename KEY_COMPARE>
 void FixedOrderedMultimap<key_t, T, KEY_COMPARE>::removeFromPosition(size_t position) {
 	if (_size <= position) {
 		return;

From 6776ca86eb0df44f2580139c48f6f394b5e6a727 Mon Sep 17 00:00:00 2001
From: Steffen Gaisser <gaisser@irs.uni-stuttgart.de>
Date: Thu, 1 Oct 2020 17:44:23 +0200
Subject: [PATCH 11/11] Made tpp file less cluttered and added inline qualifier

---
 container/FixedOrderedMultimap.h   |  8 +++++++-
 container/FixedOrderedMultimap.tpp | 27 +++++++++------------------
 2 files changed, 16 insertions(+), 19 deletions(-)

diff --git a/container/FixedOrderedMultimap.h b/container/FixedOrderedMultimap.h
index 82d388c9..96bc0073 100644
--- a/container/FixedOrderedMultimap.h
+++ b/container/FixedOrderedMultimap.h
@@ -159,7 +159,13 @@ public:
 	 * @param key Key to search for
 	 * @return Iterator pointing to the first entry of key
 	 */
-	Iterator find(key_t key) const;
+	Iterator find(key_t key) const{
+		ReturnValue_t result = exists(key);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return end();
+		}
+		return Iterator(&theMap[findFirstIndex(key)]);
+	};
 
 	/***
 	 * Finds first entry of the given key and returns a
diff --git a/container/FixedOrderedMultimap.tpp b/container/FixedOrderedMultimap.tpp
index 16a7124b..4aa85e97 100644
--- a/container/FixedOrderedMultimap.tpp
+++ b/container/FixedOrderedMultimap.tpp
@@ -3,7 +3,7 @@
 
 
 template<typename key_t, typename T, typename KEY_COMPARE>
-ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::insert(key_t key, T value, Iterator *storedValue) {
+inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::insert(key_t key, T value, Iterator *storedValue) {
 	if (_size == theMap.maxSize()) {
 		return MAP_FULL;
 	}
@@ -19,12 +19,12 @@ ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::insert(key_t key, T v
 	return HasReturnvaluesIF::RETURN_OK;
 }
 template<typename key_t, typename T, typename KEY_COMPARE>
-ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::insert(std::pair<key_t, T> pair) {
+inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::insert(std::pair<key_t, T> pair) {
 	return insert(pair.first, pair.second);
 }
 
 template<typename key_t, typename T, typename KEY_COMPARE>
-ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::exists(key_t key) const {
+inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::exists(key_t key) const {
 	ReturnValue_t result = KEY_DOES_NOT_EXIST;
 	if (findFirstIndex(key) < _size) {
 		result = HasReturnvaluesIF::RETURN_OK;
@@ -33,7 +33,7 @@ ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::exists(key_t key) con
 }
 
 template<typename key_t, typename T, typename KEY_COMPARE>
-ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::erase(Iterator *iter) {
+inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::erase(Iterator *iter) {
 	size_t i;
 	if ((i = findFirstIndex((*iter).value->first)) >= _size) {
 		return KEY_DOES_NOT_EXIST;
@@ -48,7 +48,7 @@ ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::erase(Iterator *iter)
 }
 
 template<typename key_t, typename T, typename KEY_COMPARE>
-ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::erase(key_t key) {
+inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::erase(key_t key) {
 	size_t i;
 	if ((i = findFirstIndex(key)) >= _size) {
 		return KEY_DOES_NOT_EXIST;
@@ -61,16 +61,7 @@ ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::erase(key_t key) {
 }
 
 template<typename key_t, typename T, typename KEY_COMPARE>
-FixedOrderedMultimap<key_t, T, KEY_COMPARE>::Iterator FixedOrderedMultimap<key_t, T, KEY_COMPARE>::find(key_t key) const {
-	ReturnValue_t result = exists(key);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return end();
-	}
-	return Iterator(&theMap[findFirstIndex(key)]);
-}
-
-template<typename key_t, typename T, typename KEY_COMPARE>
-ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::find(key_t key, T **value) const {
+inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::find(key_t key, T **value) const {
 	ReturnValue_t result = exists(key);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
@@ -80,7 +71,7 @@ ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::find(key_t key, T **v
 }
 
 template<typename key_t, typename T, typename KEY_COMPARE>
-size_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::findFirstIndex(key_t key, size_t startAt) const {
+inline size_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::findFirstIndex(key_t key, size_t startAt) const {
 	if (startAt >= _size) {
 		return startAt + 1;
 	}
@@ -94,7 +85,7 @@ size_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::findFirstIndex(key_t key, si
 }
 
 template<typename key_t, typename T, typename KEY_COMPARE>
-size_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::findNicePlace(key_t key) const {
+inline size_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::findNicePlace(key_t key) const {
 	size_t i = 0;
 	for (i = 0; i < _size; ++i) {
 		if (myComp(key, theMap[i].first)) {
@@ -105,7 +96,7 @@ size_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::findNicePlace(key_t key) con
 }
 
 template<typename key_t, typename T, typename KEY_COMPARE>
-void FixedOrderedMultimap<key_t, T, KEY_COMPARE>::removeFromPosition(size_t position) {
+inline void FixedOrderedMultimap<key_t, T, KEY_COMPARE>::removeFromPosition(size_t position) {
 	if (_size <= position) {
 		return;
 	}