Merge branch 'mueller_framework' into front_branch

container/HybridIterator.h

@@ -1,5 +1,5 @@
-#ifndef HYBRIDITERATOR_H_
+#ifndef FRAMEWORK_CONTAINER_HYBRIDITERATOR_H_
-#define HYBRIDITERATOR_H_
+#define FRAMEWORK_CONTAINER_HYBRIDITERATOR_H_
 
 #include <framework/container/ArrayList.h>
 #include <framework/container/SinglyLinkedList.h>
@@ -17,23 +17,23 @@ public:
 	}
 
 	HybridIterator(LinkedElement<T> *start) :
-		LinkedElement<T>::Iterator(start), value(
+		LinkedElement<T>::Iterator(start), value(start->value),
-					start->value), linked(true), end(NULL) {
+		linked(true) {
 
 	}
 
 	HybridIterator(typename ArrayList<T, count_t>::Iterator start,
 			typename ArrayList<T, count_t>::Iterator end) :
-			ArrayList<T, count_t>::Iterator(start), value(start.value), linked(
+			ArrayList<T, count_t>::Iterator(start), value(start.value),
-					false), end(end.value) {
+			linked(false), end(end.value) {
 		if (value == this->end) {
 			value = NULL;
 		}
 	}
 
 	HybridIterator(T *firstElement, T *lastElement) :
-			ArrayList<T, count_t>::Iterator(firstElement), value(firstElement), linked(
+			ArrayList<T, count_t>::Iterator(firstElement), value(firstElement),
-					false), end(++lastElement) {
+			linked(false), end(++lastElement) {
 		if (value == end) {
 			value = NULL;
 		}
@@ -42,17 +42,17 @@ public:
 	HybridIterator& operator++() {
 		if (linked) {
 			LinkedElement<T>::Iterator::operator++();
-			if (LinkedElement<T>::Iterator::value != NULL) {
+			if (LinkedElement<T>::Iterator::value != nullptr) {
 				value = LinkedElement<T>::Iterator::value->value;
 			} else {
-				value = NULL;
+				value = nullptr;
 			}
 		} else {
 			ArrayList<T, count_t>::Iterator::operator++();
 			value = ArrayList<T, count_t>::Iterator::value;
 
 			if (value == end) {
-				value = NULL;
+				value = nullptr;
 			}
 		}
 		return *this;
@@ -64,11 +64,11 @@ public:
 		return tmp;
 	}
 
-	bool operator==(const HybridIterator& other) {
+	bool operator==(const HybridIterator& other) const {
 		return value == other.value;
 	}
 
-	bool operator!=(const HybridIterator& other) {
+	bool operator!=(const HybridIterator& other) const {
 		return !(*this == other);
 	}
 
@@ -87,4 +87,4 @@ private:
 	T *end = nullptr;
 };
 
-#endif /* HYBRIDITERATOR_H_ */
+#endif /* FRAMEWORK_CONTAINER_HYBRIDITERATOR_H_ */

container/SinglyLinkedList.h

@@ -16,8 +16,13 @@ public:
 	class Iterator {
 	public:
 		LinkedElement<T> *value = nullptr;
+		//! Creates an uninitialized iterator which points to nullptr.
 		Iterator() {}
 
+		/**
+		 * Initialize iterator at specified linked element.
+		 * @param element
+		 */
 		Iterator(LinkedElement<T> *element) :
 				value(element) {
 		}
@@ -72,6 +77,11 @@ private:
 	LinkedElement *next;
 };
 
+/**
+ * @brief 	SinglyLinkedList data structure which keeps a pointer to its
+ * 			first element to perform all operations.
+ * @tparam T
+ */
 template<typename T>
 class SinglyLinkedList {
 public:
@@ -88,14 +98,19 @@ public:
 	ElementIterator begin() const {
 		return ElementIterator::Iterator(start);
 	}
-	typename ElementIterator::Iterator end() const {
+
-		return ElementIterator::Iterator();
+	ElementIterator end() const {
+		LinkedElement<T> *element = start;
+		while (element != nullptr) {
+			element = element->getNext();
+		}
+		return ElementIterator::Iterator(element);
 	}
 
-	uint32_t getSize() const {
+	size_t getSize() const {
-		uint32_t size = 0;
+		size_t size = 0;
 		LinkedElement<T> *element = start;
-		while (element != NULL) {
+		while (element != nullptr) {
 			size++;
 			element = element->getNext();
 		}

housekeeping/HousekeepingMessage.cpp

@@ -1,67 +1,48 @@
 #include <framework/housekeeping/HousekeepingMessage.h>
 #include <cstring>
 
-HousekeepingMessage::HousekeepingMessage(): CommandMessage() {
-}
-
 HousekeepingMessage::~HousekeepingMessage() {}
 
-void HousekeepingMessage::setParameter(uint32_t parameter) {
+void HousekeepingMessage::setHkReportMessage(CommandMessage* message, sid_t sid,
-	std::memcpy(getData(), &parameter, sizeof(parameter));
-}
-
-uint32_t HousekeepingMessage::getParameter() const {
-	uint32_t parameter;
-	std::memcpy(&parameter, getData(), sizeof(parameter));
-	return parameter;
-}
-
-void HousekeepingMessage::setHkReportMessage(sid_t sid,
 		store_address_t storeId) {
-	CommandMessage::setCommand(HK_REPORT);
+	message->setCommand(HK_REPORT);
-	setSid(sid);
+	message->setMessageSize(HK_MESSAGE_SIZE);
-	setParameter(storeId.raw);
+	setSid(message, sid);
+	setParameter(message, storeId.raw);
 }
 
-void HousekeepingMessage::setHkDiagnosticsMessage(sid_t sid,
+void HousekeepingMessage::setHkDiagnosticsMessage(CommandMessage* message,
-		store_address_t storeId) {
+		sid_t sid, store_address_t storeId) {
-	CommandMessage::setCommand(DIAGNOSTICS_REPORT);
+	message->setCommand(DIAGNOSTICS_REPORT);
-	setSid(sid);
+	message->setMessageSize(HK_MESSAGE_SIZE);
-	setParameter(storeId.raw);
+	setSid(message, sid);
+	setParameter(message, storeId.raw);
 }
 
-//size_t HousekeepingMessage::getMinimumMessageSize() const {
+sid_t HousekeepingMessage::getHkReportMessage(const CommandMessage *message,
-//	return HK_MESSAGE_SIZE;
+		store_address_t *storeIdToSet) {
-//}
+	if(storeIdToSet != nullptr) {
+		*storeIdToSet = getParameter(message);
+	}
+	return getSid(message);
+}
 
-sid_t HousekeepingMessage::getSid() const {
+sid_t HousekeepingMessage::getSid(const CommandMessage* message) {
 	sid_t sid;
-	std::memcpy(&sid.raw, CommandMessage::getData(), sizeof(sid.raw));
+	std::memcpy(&sid.raw, message->getData(), sizeof(sid.raw));
 	return sid;
 }
 
-
+void HousekeepingMessage::setSid(CommandMessage *message, sid_t sid) {
-sid_t HousekeepingMessage::getHkReportMessage(
+	std::memcpy(message->getData(), &sid.raw, sizeof(sid.raw));
-		store_address_t *storeIdToSet) const {
-	if(storeIdToSet != nullptr) {
-		*storeIdToSet = getParameter();
-	}
-	return getSid();
-}
-
-void HousekeepingMessage::setSid(sid_t sid) {
-	std::memcpy(CommandMessage::getData(), &sid.raw, sizeof(sid.raw));
 }
 
 
-uint8_t* HousekeepingMessage::getData() {
+void HousekeepingMessage::setParameter(CommandMessage *message,
-	return CommandMessage::getData() + sizeof(sid_t);
+		uint32_t parameter) {
+	message->setParameter3(parameter);
 }
 
-const uint8_t* HousekeepingMessage::getData() const {
+uint32_t HousekeepingMessage::getParameter(const CommandMessage *message) {
-	return CommandMessage::getData() + sizeof(sid_t);
+	return message->getParameter3();
-}
-
-void HousekeepingMessage::clear() {
-	// clear IPC store where it is needed.
 }

housekeeping/HousekeepingMessage.h

@@ -34,7 +34,7 @@ union sid_t {
  * This message is slightly larger than regular command messages to accomodate
  * the uint64_t structure ID (SID).
  */
-class HousekeepingMessage : public CommandMessage {
+class HousekeepingMessage {
 public:
 
 	static constexpr size_t HK_MESSAGE_SIZE = CommandMessageIF::HEADER_SIZE +
@@ -45,7 +45,7 @@ public:
 	 * the message data, see CommandMessageIF and getInternalMessage().
 	 * @param message
 	 */
-	HousekeepingMessage();
+	HousekeepingMessage() = delete;
 	virtual ~HousekeepingMessage();
 
 	static constexpr uint8_t MESSAGE_ID = messagetypes::HOUSEKEEPING;
@@ -94,25 +94,22 @@ public:
 	static constexpr Command_t MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL =
 			MAKE_COMMAND_ID(32);
 
+	static sid_t getSid(const CommandMessage* message);
 
-	void setParameter(uint32_t parameter);
+	static void setHkReportMessage(CommandMessage* message, sid_t sid,
-	uint32_t getParameter() const;
+			store_address_t storeId);
-	sid_t getSid() const;
+	static void setHkDiagnosticsMessage(CommandMessage* message, sid_t sid,
+			store_address_t storeId);
 
-	void setHkReportMessage(sid_t sid, store_address_t storeId);
-	void setHkDiagnosticsMessage(sid_t sid, store_address_t storeId);
 	//! Get the respective SID and store ID. Command ID can be used beforehand
 	//! to distinguish between diagnostics and regular HK packets
-	sid_t getHkReportMessage(store_address_t * storeIdToSet) const;
+	static sid_t getHkReportMessage(const CommandMessage* message,
+			store_address_t * storeIdToSet);
 
-	//virtual size_t getMinimumMessageSize() const override;
-	virtual void clear() override;
 private:
-
+	static void setSid(CommandMessage* message, sid_t sid);
-	void setSid(sid_t sid);
+	static void setParameter(CommandMessage* message, uint32_t parameter);
-
+	static uint32_t getParameter(const CommandMessage* message);
-	virtual uint8_t* getData() override;
-	virtual const uint8_t* getData() const override;
 };
 
 

ipc/CommandMessage.cpp

@@ -52,6 +52,18 @@ void CommandMessage::setParameter2(uint32_t parameter2) {
             sizeof(parameter2));
 }
 
+uint32_t CommandMessage::getParameter3() const {
+    uint32_t parameter3;
+    std::memcpy(&parameter3, this->getData() + 2 * sizeof(uint32_t),
+            sizeof(parameter3));
+    return parameter3;
+}
+
+void CommandMessage::setParameter3(uint32_t parameter3) {
+    std::memcpy(this->getData()  + 2 * sizeof(uint32_t), &parameter3,
+            sizeof(parameter3));
+}
+
 size_t CommandMessage::getMinimumMessageSize() const {
     return MINIMUM_COMMAND_MESSAGE_SIZE;
 }

ipc/CommandMessage.h

@@ -66,29 +66,21 @@ public:
 
     virtual uint8_t* getData() override;
     virtual const uint8_t* getData() const override;
+
 	/**
 	 * Get the first parameter of the message
 	 * @return the first Parameter of the message
 	 */
 	uint32_t getParameter() const;
-
 	/**
 	 * Set the first parameter of the message
 	 * @param the first parameter of the message
 	 */
 	void setParameter(uint32_t parameter1);
-
-	/**
-	 * Get the second parameter of the message
-	 * @return the second Parameter of the message
-	 */
 	uint32_t getParameter2() const;
-
-	/**
-	 * Set the second parameter of the message
-	 * @param the second parameter of the message
-	 */
 	void setParameter2(uint32_t parameter2);
+	uint32_t getParameter3() const;
+	void setParameter3(uint32_t parameter3);
 
 	/**
 	 * check if a message was cleared

tasks/FixedSlotSequence.h

@@ -6,9 +6,6 @@
 
 #include <set>
 
-using SlotList = std::multiset<FixedSequenceSlot>;
-using SlotListIter = std::multiset<FixedSequenceSlot>::iterator;
-
 /**
  * @brief	This class is the representation of a Polling Sequence Table in software.
  * @details
@@ -27,6 +24,8 @@ using SlotListIter = std::multiset<FixedSequenceSlot>::iterator;
  */
 class FixedSlotSequence {
 public:
+	using SlotList = std::multiset<FixedSequenceSlot>;
+	using SlotListIter = std::multiset<FixedSequenceSlot>::iterator;
 
 	/**
 	 * @brief	The constructor of the FixedSlotSequence object.