Merge remote-tracking branch 'upstream/master' into mueller_initializer_list

action/ActionHelper.cpp

@@ -49,7 +49,7 @@ void ActionHelper::setQueueToUse(MessageQueueIF* queue) {
 void ActionHelper::prepareExecution(MessageQueueId_t commandedBy, ActionId_t actionId,
 		store_address_t dataAddress) {
 	const uint8_t* dataPtr = NULL;
-	uint32_t size = 0;
+	size_t size = 0;
 	ReturnValue_t result = ipcStore->getData(dataAddress, &dataPtr, &size);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		CommandMessage reply;

action/CommandActionHelper.cpp

@@ -113,7 +113,7 @@ uint8_t CommandActionHelper::getCommandCount() const {
 
 void CommandActionHelper::extractDataForOwner(ActionId_t actionId, store_address_t storeId) {
 	const uint8_t * data = NULL;
-	uint32_t size = 0;
+	size_t size = 0;
 	ReturnValue_t result = ipcStore->getData(storeId, &data, &size);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return;

action/SimpleActionHelper.cpp

@@ -44,7 +44,7 @@ void SimpleActionHelper::prepareExecution(MessageQueueId_t commandedBy,
 		queueToUse->sendMessage(commandedBy, &reply);
 	}
 	const uint8_t* dataPtr = NULL;
-	uint32_t size = 0;
+	size_t size = 0;
 	ReturnValue_t result = ipcStore->getData(dataAddress, &dataPtr, &size);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		ActionMessage::setStepReply(&reply, actionId, 0, result);

container/FIFO.h

@@ -3,6 +3,11 @@
 
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 
+/**
+ * @brief Simple First-In-First-Out data structure
+ * @tparam T Entry Type
+ * @tparam capacity Maximum capacity
+ */
 template<typename T, uint8_t capacity>
 class FIFO {
 private:
@@ -54,6 +59,21 @@ public:
 			return HasReturnvaluesIF::RETURN_OK;
 		}
 	}
+
+	ReturnValue_t peek(T * value) {
+	    if(empty()) {
+	        return EMPTY;
+	    } else {
+	       *value = data[readIndex];
+	       return HasReturnvaluesIF::RETURN_OK;
+	    }
+	}
+
+	ReturnValue_t pop() {
+		T value;
+		return this->retrieve(&value);
+	}
+
 	static const uint8_t INTERFACE_ID = CLASS_ID::FIFO_CLASS;
 	static const ReturnValue_t FULL = MAKE_RETURN_CODE(1);
 	static const ReturnValue_t EMPTY = MAKE_RETURN_CODE(2);

datapool/DataPoolAdmin.cpp

@@ -215,7 +215,7 @@ ReturnValue_t DataPoolAdmin::handleParameterCommand(CommandMessage* command) {
 				ParameterMessage::getParameterId(command));
 
 		const uint8_t *storedStream;
-		uint32_t storedStreamSize;
+		size_t storedStreamSize;
 		result = storage->getData(ParameterMessage::getStoreId(command),
 				&storedStream, &storedStreamSize);
 		if (result != HasReturnvaluesIF::RETURN_OK) {

devicehandlers/DeviceHandlerBase.cpp

@@ -558,7 +558,7 @@ void DeviceHandlerBase::doGetRead() {
 
 ReturnValue_t DeviceHandlerBase::getStorageData(store_address_t storageAddress,
 		uint8_t * *data, uint32_t * len) {
-	uint32_t lenTmp;
+	size_t lenTmp;
 
 	if (IPCStore == NULL) {
 		*data = NULL;

globalfunctions/printer.cpp

@@ -0,0 +1,61 @@
+#include <framework/globalfunctions/printer.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include <bitset>
+
+void printer::print(const uint8_t *data, size_t size, OutputType type,
+		bool printInfo, size_t maxCharPerLine) {
+	if(printInfo) {
+		sif::info << "Printing data with size " << size << ": ";
+	}
+	sif::info << "[";
+	if(type == OutputType::HEX) {
+		printer::printHex(data, size, maxCharPerLine);
+	}
+	else if (type == OutputType::DEC) {
+		printer::printDec(data, size, maxCharPerLine);
+	}
+	else if(type == OutputType::BIN) {
+	    printer::printBin(data, size);
+	}
+}
+
+void printer::printHex(const uint8_t *data, size_t size,
+		size_t maxCharPerLine) {
+	sif::info << std::hex;
+	for(size_t i = 0; i < size; i++) {
+		sif::info << "0x" << static_cast<int>(data[i]);
+		if(i < size - 1){
+			sif::info << " , ";
+			if(i > 0 and i % maxCharPerLine == 0) {
+				sif::info << std::endl;
+			}
+		}
+
+	}
+	sif::info << std::dec;
+	sif::info << "]" << std::endl;
+}
+
+void printer::printDec(const uint8_t *data, size_t size,
+		size_t maxCharPerLine) {
+	sif::info << std::dec;
+	for(size_t i = 0; i < size; i++) {
+		sif::info << static_cast<int>(data[i]);
+		if(i < size - 1){
+			sif::info << " , ";
+			if(i > 0 and i % maxCharPerLine == 0) {
+				sif::info << std::endl;
+			}
+		}
+	}
+	sif::info << "]" << std::endl;
+}
+
+void printer::printBin(const uint8_t *data, size_t size) {
+    sif::info << "\n" << std::flush;
+    for(size_t i = 0; i < size; i++) {
+        sif::info << "Byte " << i + 1 << ": 0b"<<
+                std::bitset<8>(data[i]) << ",\n" << std::flush;
+    }
+    sif::info << "]" << std::endl;
+}

globalfunctions/printer.h

@@ -0,0 +1,21 @@
+#ifndef FRAMEWORK_GLOBALFUNCTIONS_PRINTER_H_
+#define FRAMEWORK_GLOBALFUNCTIONS_PRINTER_H_
+#include <cstdint>
+#include <cstddef>
+
+namespace printer {
+
+enum class OutputType {
+	DEC,
+	HEX,
+	BIN
+};
+
+void print(const uint8_t* data, size_t size, OutputType type = OutputType::HEX,
+		bool printInfo = true, size_t maxCharPerLine = 12);
+void printHex(const uint8_t* data, size_t size, size_t maxCharPerLine = 12);
+void printDec(const uint8_t* data, size_t size, size_t maxCharPerLine = 12);
+void printBin(const uint8_t* data, size_t size);
+}
+
+#endif /* FRAMEWORK_GLOBALFUNCTIONS_PRINTER_H_ */

memory/MemoryHelper.cpp

@@ -152,7 +152,7 @@ void MemoryHelper::handleMemoryLoad(CommandMessage* message) {
 	ipcAddress = MemoryMessage::getStoreID(message);
 	const uint8_t* p_data = NULL;
 	uint8_t* dataPointer = NULL;
-	uint32_t size = 0;
+	size_t size = 0;
 	ReturnValue_t returnCode = ipcStore->getData(ipcAddress, &p_data, &size);
 	if (returnCode == RETURN_OK) {
 		returnCode = workOnThis->handleMemoryLoad(address, p_data, size,

modes/ModeMessage.cpp

@@ -16,6 +16,10 @@ ReturnValue_t ModeMessage::setModeMessage(CommandMessage* message, Command_t com
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
+ReturnValue_t ModeMessage::getCantReachModeReason(const CommandMessage* message) {
+	return message->getParameter();
+}
+
 void ModeMessage::clear(CommandMessage* message) {
 	message->setCommand(CommandMessage::CMD_NONE);
 }

modes/ModeMessage.h

@@ -23,7 +23,6 @@ public:
 	static const Command_t REPLY_MODE_REPLY = MAKE_COMMAND_ID(0x02);//!> Reply to a CMD_MODE_COMMAND or CMD_MODE_READ
 	static const Command_t REPLY_MODE_INFO = MAKE_COMMAND_ID(0x03);	//!> Unrequested info about the current mode (used for composites to inform their container of a changed mode)
 	static const Command_t REPLY_CANT_REACH_MODE = MAKE_COMMAND_ID(0x04); //!> Reply in case a mode command can't be executed. Par1: returnCode, Par2: 0
-	//SHOULDDO is there a way we can transmit a returnvalue when responding that the mode is wrong, so we can give a nice failure code when commanded by PUS?
 	static const Command_t REPLY_WRONG_MODE_REPLY = MAKE_COMMAND_ID(0x05);//!> Reply to a CMD_MODE_COMMAND, indicating that a mode was commanded and a transition started but was aborted; the parameters contain the mode that was reached
 	static const Command_t CMD_MODE_READ = MAKE_COMMAND_ID(0x06);//!> Command to read the current mode and reply with a REPLY_MODE_REPLY
 	static const Command_t CMD_MODE_ANNOUNCE = MAKE_COMMAND_ID(0x07);//!> Command to trigger an ModeInfo Event. This command does NOT have a reply.
@@ -34,6 +33,7 @@ public:
 	static ReturnValue_t setModeMessage(CommandMessage* message,
 			Command_t command, Mode_t mode, Submode_t submode);
 	static void cantReachMode(CommandMessage* message, ReturnValue_t reason);
+	static ReturnValue_t getCantReachModeReason(const CommandMessage* message);
 	static void clear(CommandMessage* message);
 };
 

osal/FreeRTOS/MessageQueue.cpp

@@ -97,7 +97,8 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
 		bool ignoreFault) {
 	message->setSender(sentFrom);
 
-	BaseType_t result = xQueueSendToBack(reinterpret_cast<void*>(sendTo),reinterpret_cast<const void*>(message->getBuffer()), 0);
+	BaseType_t result = xQueueSendToBack(reinterpret_cast<QueueHandle_t>(sendTo),
+			reinterpret_cast<const void*>(message->getBuffer()), 0);
 	if (result != pdPASS) {
 		if (!ignoreFault) {
 			InternalErrorReporterIF* internalErrorReporter = objectManager->get<InternalErrorReporterIF>(

parameters/ParameterHelper.cpp

@@ -37,7 +37,7 @@ ReturnValue_t ParameterHelper::handleParameterMessage(CommandMessage *message) {
 				ParameterMessage::getParameterId(message));
 
 		const uint8_t *storedStream;
-		uint32_t storedStreamSize;
+		size_t storedStreamSize;
 		result = storage->getData(
 				ParameterMessage::getStoreId(message), &storedStream,
 				&storedStreamSize);

storagemanager/LocalPool.h

@@ -1,14 +1,11 @@
-#ifndef FRAMEWORK_STORAGEMANAGER_LOCALPOOL_H_
-#define FRAMEWORK_STORAGEMANAGER_LOCALPOOL_H_
-
 /**
  *	@file	LocalPool
- *
  *  @date	02.02.2012
  *	@author	Bastian Baetz
- *
  *	@brief	This file contains the definition of the LocalPool class.
  */
+#ifndef FRAMEWORK_STORAGEMANAGER_LOCALPOOL_H_
+#define FRAMEWORK_STORAGEMANAGER_LOCALPOOL_H_
 
 #include <framework/objectmanager/SystemObject.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
@@ -20,7 +17,7 @@
 /**
  * @brief	The LocalPool class provides an intermediate data storage with
  * 			a fixed pool size policy.
- * \details	The class implements the StorageManagerIF interface. While the
+ * @details	The class implements the StorageManagerIF interface. While the
  * 			total number of pools is fixed, the element sizes in one pool and
  * 			the number of pool elements per pool are set on construction.
  * 			The full amount of memory is allocated on construction.
@@ -31,7 +28,6 @@
  * 			It is possible to store empty packets in the pool.
  * 			The local pool is NOT thread-safe.
  */
-
 template<uint8_t NUMBER_OF_POOLS = 5>
 class LocalPool: public SystemObject, public StorageManagerIF {
 public:
@@ -40,6 +36,64 @@ public:
 	 * @details This must be less than the maximum number of pools (currently 0xff).
 	 */
 	//	static const uint32_t NUMBER_OF_POOLS;
+	/**
+	 * @brief	This is the default constructor for a pool manager instance.
+	 * @details	By passing two arrays of size NUMBER_OF_POOLS, the constructor
+	 * 			allocates memory (with \c new) for store and size_list. These
+	 * 			regions are all set to zero on start up.
+	 * @param setObjectId	The object identifier to be set. This allows for
+	 * 						multiple instances of LocalPool in the system.
+	 * @param element_sizes	An array of size NUMBER_OF_POOLS in which the size
+	 * 						of a single element in each pool is determined.
+	 * 						<b>The sizes must be provided in ascending order.
+	 * 						</b>
+	 * @param n_elements	An array of size NUMBER_OF_POOLS in which the
+	 * 						number of elements for each pool is determined.
+	 * 						The position of these values correspond to those in
+	 * 						element_sizes.
+	 * @param registered	Register the pool in object manager or not.
+	 * Default is false (local pool).
+	 * @param spillsToHigherPools A variable to determine whether
+	 * higher n pools are used if the store is full.
+	 */
+	LocalPool(object_id_t setObjectId,
+			const uint16_t element_sizes[NUMBER_OF_POOLS],
+			const uint16_t n_elements[NUMBER_OF_POOLS],
+			bool registered = false,
+			bool spillsToHigherPools = false);
+	/**
+	 * @brief	In the LocalPool's destructor all allocated memory is freed.
+	 */
+	virtual ~LocalPool(void);
+
+	/**
+	 * Documentation: See StorageManagerIF.h
+	 */
+	ReturnValue_t addData(store_address_t* storageId, const uint8_t * data,
+			size_t size, bool ignoreFault = false) override;
+	ReturnValue_t getFreeElement(store_address_t* storageId,const size_t size,
+			uint8_t** p_data, bool ignoreFault = false) override;
+	ReturnValue_t getData(store_address_t packet_id, const uint8_t** packet_ptr,
+			size_t * size) override;
+	ReturnValue_t modifyData(store_address_t packet_id, uint8_t** packet_ptr,
+			size_t * size) override;
+	virtual ReturnValue_t deleteData(store_address_t) override;
+	virtual ReturnValue_t deleteData(uint8_t* ptr, size_t size,
+			store_address_t* storeId = NULL) override;
+	void clearStore() override;
+	ReturnValue_t initialize() override;
+protected:
+	/**
+	 * With this helper method, a free element of \c size is reserved.
+	 * @param size	The minimum packet size that shall be reserved.
+	 * @param[out] address Storage ID of the reserved data.
+	 * @return	- #RETURN_OK on success,
+	 * 			- the return codes of #getPoolIndex or #findEmpty otherwise.
+	 */
+	virtual ReturnValue_t reserveSpace(const uint32_t size,
+			store_address_t* address, bool ignoreFault);
+
+	InternalErrorReporterIF *internalErrorReporter;
 private:
 	/**
 	 * Indicates that this element is free.
@@ -60,7 +114,7 @@ private:
 	/**
 	 * @brief	store represents the actual memory pool.
 	 * @details	It is an array of pointers to memory, which was allocated with
-	 * 			a \c new call on construction.
+	 * 			a @c new call on construction.
 	 */
 	uint8_t* store[NUMBER_OF_POOLS];
 	/**
@@ -78,7 +132,7 @@ private:
 	 * @param data		The data to be stored.
 	 * @param size		The size of the data to be stored.
 	 */
-	void write(store_address_t packet_id, const uint8_t* data, uint32_t size);
+	void write(store_address_t packet_id, const uint8_t* data, size_t size);
 	/**
 	 * @brief	A helper method to read the element size of a certain pool.
 	 * @param pool_index	The pool in which to look.
@@ -101,7 +155,8 @@ private:
 	 * @return	- #RETURN_OK on success,
 	 * 			- #DATA_TOO_LARGE otherwise.
 	 */
-	ReturnValue_t getPoolIndex(uint32_t packet_size, uint16_t* poolIndex, uint16_t startAtIndex = 0);
+	ReturnValue_t getPoolIndex(size_t packet_size, uint16_t* poolIndex,
+			uint16_t startAtIndex = 0);
 	/**
 	 * @brief	This helper method calculates the true array position in store
 	 * 			of a given packet id.
@@ -121,310 +176,8 @@ private:
 	 * 			- #DATA_STORAGE_FULL if the store is full
 	 */
 	ReturnValue_t findEmpty(uint16_t pool_index, uint16_t* element);
-protected:
-	/**
-	 * With this helper method, a free element of \c size is reserved.
-	 * @param size	The minimum packet size that shall be reserved.
-	 * @param[out] address Storage ID of the reserved data.
-	 * @return	- #RETURN_OK on success,
-	 * 			- the return codes of #getPoolIndex or #findEmpty otherwise.
-	 */
-	virtual ReturnValue_t reserveSpace(const uint32_t size, store_address_t* address, bool ignoreFault);
-
-	InternalErrorReporterIF *internalErrorReporter;
-public:
-	/**
-	 * @brief	This is the default constructor for a pool manager instance.
-	 * @details	By passing two arrays of size NUMBER_OF_POOLS, the constructor
-	 * 			allocates memory (with \c new) for store and size_list. These
-	 * 			regions are all set to zero on start up.
-	 * @param setObjectId	The object identifier to be set. This allows for
-	 * 						multiple instances of LocalPool in the system.
-	 * @param element_sizes	An array of size NUMBER_OF_POOLS in which the size
-	 * 						of a single element in each pool is determined.
-	 * 						<b>The sizes must be provided in ascending order.
-	 * 						</b>
-	 * @param n_elements	An array of size NUMBER_OF_POOLS in which the
-	 * 						number of elements for each pool is determined.
-	 * 						The position of these values correspond to those in
-	 * 						element_sizes.
-	 * @param registered	Register the pool in object manager or not. Default is false (local pool).
-	 */
-	LocalPool(object_id_t setObjectId,
-			const uint16_t element_sizes[NUMBER_OF_POOLS],
-			const uint16_t n_elements[NUMBER_OF_POOLS],
-			bool registered = false,
-			bool spillsToHigherPools = false);
-	/**
-	 * @brief	In the LocalPool's destructor all allocated memory is freed.
-	 */
-	virtual ~LocalPool(void);
-	ReturnValue_t addData(store_address_t* storageId, const uint8_t * data,
-			uint32_t size, bool ignoreFault = false);
-
-	/**
-	 * With this helper method, a free element of \c size is reserved.
-	 *
-	 * @param size	The minimum packet size that shall be reserved.
-	 * @return	Returns the storage identifier within the storage or
-	 * 			StorageManagerIF::INVALID_ADDRESS (in raw).
-	 */
-	ReturnValue_t getFreeElement(store_address_t* storageId,
-			const uint32_t size, uint8_t** p_data, bool ignoreFault = false);
-	ReturnValue_t getData(store_address_t packet_id, const uint8_t** packet_ptr,
-			uint32_t* size);
-	ReturnValue_t modifyData(store_address_t packet_id, uint8_t** packet_ptr,
-			uint32_t* size);
-	virtual ReturnValue_t deleteData(store_address_t);
-	virtual ReturnValue_t deleteData(uint8_t* ptr, uint32_t size,
-			store_address_t* storeId = NULL);
-	void clearStore();
-	ReturnValue_t initialize();
 };
 
-template<uint8_t NUMBER_OF_POOLS>
+#include <framework/storagemanager/LocalPool.tpp>
-inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::findEmpty(uint16_t pool_index,
-		uint16_t* element) {
-	ReturnValue_t status = DATA_STORAGE_FULL;
-	for (uint16_t foundElement = 0; foundElement < n_elements[pool_index];
-			foundElement++) {
-		if (size_list[pool_index][foundElement] == STORAGE_FREE) {
-			*element = foundElement;
-			status = RETURN_OK;
-			break;
-		}
-	}
-	return status;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline void LocalPool<NUMBER_OF_POOLS>::write(store_address_t packet_id,
-		const uint8_t* data, uint32_t size) {
-	uint8_t* ptr;
-	uint32_t packet_position = getRawPosition(packet_id);
-
-	//check size? -> Not necessary, because size is checked before calling this function.
-	ptr = &store[packet_id.pool_index][packet_position];
-	memcpy(ptr, data, size);
-	size_list[packet_id.pool_index][packet_id.packet_index] = size;
-}
-
-//Returns page size of 0 in case store_index is illegal
-template<uint8_t NUMBER_OF_POOLS>
-inline uint32_t LocalPool<NUMBER_OF_POOLS>::getPageSize(uint16_t pool_index) {
-	if (pool_index < NUMBER_OF_POOLS) {
-		return element_sizes[pool_index];
-	} else {
-		return 0;
-	}
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::getPoolIndex(
-		uint32_t packet_size, uint16_t* poolIndex, uint16_t startAtIndex) {
-	for (uint16_t n = startAtIndex; n < NUMBER_OF_POOLS; n++) {
-//		debug << "LocalPool " << getObjectId() << "::getPoolIndex: Pool: " << n << ", Element Size: " << element_sizes[n] << std::endl;
-		if (element_sizes[n] >= packet_size) {
-			*poolIndex = n;
-			return RETURN_OK;
-		}
-	}
-	return DATA_TOO_LARGE;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline uint32_t LocalPool<NUMBER_OF_POOLS>::getRawPosition(
-		store_address_t packet_id) {
-	return packet_id.packet_index * element_sizes[packet_id.pool_index];
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::reserveSpace(
-		const uint32_t size, store_address_t* address, bool ignoreFault) {
-	ReturnValue_t status = getPoolIndex(size, &address->pool_index);
-	if (status != RETURN_OK) {
-		sif::error << "LocalPool( " << std::hex << getObjectId() << std::dec
-				   << " )::reserveSpace: Packet too large." << std::endl;
-		return status;
-	}
-	status = findEmpty(address->pool_index, &address->packet_index);
-	while (status != RETURN_OK && spillsToHigherPools) {
-		status = getPoolIndex(size, &address->pool_index, address->pool_index + 1);
-		if (status != RETURN_OK) {
-			//We don't find any fitting pool anymore.
-			break;
-		}
-		status = findEmpty(address->pool_index, &address->packet_index);
-	}
-	if (status == RETURN_OK) {
-//		if (getObjectId() == objects::IPC_STORE && address->pool_index >= 3) {
-//			debug << "Reserve: Pool: " << std::dec << address->pool_index << " Index: " << address->packet_index << std::endl;
-//		}
-
-		size_list[address->pool_index][address->packet_index] = size;
-	} else {
-		if (!ignoreFault) {
-			internalErrorReporter->storeFull();
-		}
-//		error << "LocalPool( " << std::hex << getObjectId() << std::dec
-//				<< " )::reserveSpace: Packet store is full." << std::endl;
-	}
-	return status;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline LocalPool<NUMBER_OF_POOLS>::LocalPool(object_id_t setObjectId,
-		const uint16_t element_sizes[NUMBER_OF_POOLS],
-		const uint16_t n_elements[NUMBER_OF_POOLS], bool registered, bool spillsToHigherPools) :
-		SystemObject(setObjectId, registered), spillsToHigherPools(spillsToHigherPools), internalErrorReporter(NULL) {
-	for (uint16_t n = 0; n < NUMBER_OF_POOLS; n++) {
-		this->element_sizes[n] = element_sizes[n];
-		this->n_elements[n] = n_elements[n];
-		store[n] = new uint8_t[n_elements[n] * element_sizes[n]];
-		size_list[n] = new uint32_t[n_elements[n]];
-		memset(store[n], 0x00, (n_elements[n] * element_sizes[n]));
-		memset(size_list[n], STORAGE_FREE, (n_elements[n] * sizeof(**size_list))); //TODO checkme
-	}
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline LocalPool<NUMBER_OF_POOLS>::~LocalPool(void) {
-	for (uint16_t n = 0; n < NUMBER_OF_POOLS; n++) {
-		delete[] store[n];
-		delete[] size_list[n];
-	}
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::addData(
-		store_address_t* storageId, const uint8_t* data, uint32_t size, bool ignoreFault) {
-	ReturnValue_t status = reserveSpace(size, storageId, ignoreFault);
-	if (status == RETURN_OK) {
-		write(*storageId, data, size);
-	}
-	return status;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::getFreeElement(
-		store_address_t* storageId, const uint32_t size, uint8_t** p_data, bool ignoreFault) {
-	ReturnValue_t status = reserveSpace(size, storageId, ignoreFault);
-	if (status == RETURN_OK) {
-		*p_data = &store[storageId->pool_index][getRawPosition(*storageId)];
-	} else {
-		*p_data = NULL;
-	}
-	return status;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::getData(
-		store_address_t packet_id, const uint8_t** packet_ptr, uint32_t* size) {
-	uint8_t* tempData = NULL;
-	ReturnValue_t status = modifyData(packet_id, &tempData, size);
-	*packet_ptr = tempData;
-	return status;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::modifyData(store_address_t packet_id,
-		uint8_t** packet_ptr, uint32_t* size) {
-	ReturnValue_t status = RETURN_FAILED;
-	if (packet_id.pool_index >= NUMBER_OF_POOLS) {
-		return ILLEGAL_STORAGE_ID;
-	}
-	if ((packet_id.packet_index >= n_elements[packet_id.pool_index])) {
-		return ILLEGAL_STORAGE_ID;
-	}
-	if (size_list[packet_id.pool_index][packet_id.packet_index]
-			!= STORAGE_FREE) {
-		uint32_t packet_position = getRawPosition(packet_id);
-		*packet_ptr = &store[packet_id.pool_index][packet_position];
-		*size = size_list[packet_id.pool_index][packet_id.packet_index];
-		status = RETURN_OK;
-	} else {
-		status = DATA_DOES_NOT_EXIST;
-	}
-	return status;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::deleteData(
-		store_address_t packet_id) {
-
-//	if (getObjectId() == objects::IPC_STORE && packet_id.pool_index >= 3) {
-//		debug << "Delete: Pool: " << std::dec << packet_id.pool_index << " Index: " << packet_id.packet_index << std::endl;
-//	}
-	ReturnValue_t status = RETURN_OK;
-	uint32_t page_size = getPageSize(packet_id.pool_index);
-	if ((page_size != 0)
-			&& (packet_id.packet_index < n_elements[packet_id.pool_index])) {
-		uint16_t packet_position = getRawPosition(packet_id);
-		uint8_t* ptr = &store[packet_id.pool_index][packet_position];
-		memset(ptr, 0, page_size);
-		//Set free list
-		size_list[packet_id.pool_index][packet_id.packet_index] = STORAGE_FREE;
-	} else {
-		//pool_index or packet_index is too large
-		sif::error << "LocalPool:deleteData failed." << std::endl;
-		status = ILLEGAL_STORAGE_ID;
-	}
-	return status;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline void LocalPool<NUMBER_OF_POOLS>::clearStore() {
-	for (uint16_t n = 0; n < NUMBER_OF_POOLS; n++) {
-		memset(size_list[n], STORAGE_FREE, (n_elements[n] * sizeof(**size_list)));//TODO checkme
-	}
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::deleteData(uint8_t* ptr,
-		uint32_t size, store_address_t* storeId) {
-	store_address_t localId;
-	ReturnValue_t result = ILLEGAL_ADDRESS;
-	for (uint16_t n = 0; n < NUMBER_OF_POOLS; n++) {
-		//Not sure if new allocates all stores in order. so better be careful.
-		if ((store[n] <= ptr) && (&store[n][n_elements[n]*element_sizes[n]]) > ptr) {
-			localId.pool_index = n;
-			uint32_t deltaAddress = ptr - store[n];
-			//Getting any data from the right "block" is ok. This is necessary, as IF's sometimes don't point to the first element of an object.
-			localId.packet_index = deltaAddress / element_sizes[n];
-			result = deleteData(localId);
-//			if (deltaAddress % element_sizes[n] != 0) {
-//				error << "Pool::deleteData: address not aligned!" << std::endl;
-//			}
-			break;
-		}
-	}
-	if (storeId != NULL) {
-		*storeId = localId;
-	}
-	return result;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::initialize() {
-	ReturnValue_t result = SystemObject::initialize();
-	if (result != RETURN_OK) {
-		return result;
-	}
-	internalErrorReporter = objectManager->get<InternalErrorReporterIF>(objects::INTERNAL_ERROR_REPORTER);
-	if (internalErrorReporter == NULL){
-		return RETURN_FAILED;
-	}
-
-	//Check if any pool size is large than the maximum allowed.
-	for (uint8_t count = 0; count < NUMBER_OF_POOLS; count++) {
-		if (element_sizes[count] >= STORAGE_FREE) {
-			sif::error
-					<< "LocalPool::initialize: Pool is too large! Max. allowed size is: "
-					<< (STORAGE_FREE - 1) << std::endl;
-			return RETURN_FAILED;
-		}
-	}
-	return RETURN_OK;
-}
 
 #endif /* FRAMEWORK_STORAGEMANAGER_LOCALPOOL_H_ */

storagemanager/LocalPool.tpp

@@ -0,0 +1,260 @@
+#ifndef FRAMEWORK_STORAGEMANAGER_LOCALPOOL_TPP_
+#define FRAMEWORK_STORAGEMANAGER_LOCALPOOL_TPP_
+
+template<uint8_t NUMBER_OF_POOLS>
+inline LocalPool<NUMBER_OF_POOLS>::LocalPool(object_id_t setObjectId,
+		const uint16_t element_sizes[NUMBER_OF_POOLS],
+		const uint16_t n_elements[NUMBER_OF_POOLS], bool registered,
+		bool spillsToHigherPools) :
+		SystemObject(setObjectId, registered),  internalErrorReporter(nullptr),
+		spillsToHigherPools(spillsToHigherPools)
+{
+	for (uint16_t n = 0; n < NUMBER_OF_POOLS; n++) {
+		this->element_sizes[n] = element_sizes[n];
+		this->n_elements[n] = n_elements[n];
+		store[n] = new uint8_t[n_elements[n] * element_sizes[n]];
+		size_list[n] = new uint32_t[n_elements[n]];
+		memset(store[n], 0x00, (n_elements[n] * element_sizes[n]));
+		//TODO checkme
+		memset(size_list[n], STORAGE_FREE, (n_elements[n] * sizeof(**size_list)));
+	}
+}
+
+
+template<uint8_t NUMBER_OF_POOLS>
+inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::findEmpty(uint16_t pool_index,
+		uint16_t* element) {
+	ReturnValue_t status = DATA_STORAGE_FULL;
+	for (uint16_t foundElement = 0; foundElement < n_elements[pool_index];
+			foundElement++) {
+		if (size_list[pool_index][foundElement] == STORAGE_FREE) {
+			*element = foundElement;
+			status = RETURN_OK;
+			break;
+		}
+	}
+	return status;
+}
+
+template<uint8_t NUMBER_OF_POOLS>
+inline void LocalPool<NUMBER_OF_POOLS>::write(store_address_t packet_id,
+		const uint8_t* data, size_t size) {
+	uint8_t* ptr;
+	uint32_t packet_position = getRawPosition(packet_id);
+
+	//check size? -> Not necessary, because size is checked before calling this function.
+	ptr = &store[packet_id.pool_index][packet_position];
+	memcpy(ptr, data, size);
+	size_list[packet_id.pool_index][packet_id.packet_index] = size;
+}
+
+//Returns page size of 0 in case store_index is illegal
+template<uint8_t NUMBER_OF_POOLS>
+inline uint32_t LocalPool<NUMBER_OF_POOLS>::getPageSize(uint16_t pool_index) {
+	if (pool_index < NUMBER_OF_POOLS) {
+		return element_sizes[pool_index];
+	} else {
+		return 0;
+	}
+}
+
+template<uint8_t NUMBER_OF_POOLS>
+inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::getPoolIndex(
+		size_t packet_size, uint16_t* poolIndex, uint16_t startAtIndex) {
+	for (uint16_t n = startAtIndex; n < NUMBER_OF_POOLS; n++) {
+		//debug << "LocalPool " << getObjectId() << "::getPoolIndex: Pool: " <<
+		//		n << ", Element Size: " << element_sizes[n] << std::endl;
+		if (element_sizes[n] >= packet_size) {
+			*poolIndex = n;
+			return RETURN_OK;
+		}
+	}
+	return DATA_TOO_LARGE;
+}
+
+template<uint8_t NUMBER_OF_POOLS>
+inline uint32_t LocalPool<NUMBER_OF_POOLS>::getRawPosition(
+		store_address_t packet_id) {
+	return packet_id.packet_index * element_sizes[packet_id.pool_index];
+}
+
+template<uint8_t NUMBER_OF_POOLS>
+inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::reserveSpace(
+		const uint32_t size, store_address_t* address, bool ignoreFault) {
+	ReturnValue_t status = getPoolIndex(size, &address->pool_index);
+	if (status != RETURN_OK) {
+		sif::error << "LocalPool( " << std::hex << getObjectId() << std::dec
+				<< " )::reserveSpace: Packet too large." << std::endl;
+		return status;
+	}
+	status = findEmpty(address->pool_index, &address->packet_index);
+	while (status != RETURN_OK && spillsToHigherPools) {
+		status = getPoolIndex(size, &address->pool_index, address->pool_index + 1);
+		if (status != RETURN_OK) {
+			//We don't find any fitting pool anymore.
+			break;
+		}
+		status = findEmpty(address->pool_index, &address->packet_index);
+	}
+	if (status == RETURN_OK) {
+		// if (getObjectId() == objects::IPC_STORE && address->pool_index >= 3) {
+		//	   debug << "Reserve: Pool: " << std::dec << address->pool_index <<
+		//				" Index: " << address->packet_index << std::endl;
+		// }
+
+		size_list[address->pool_index][address->packet_index] = size;
+	} else {
+		if (!ignoreFault and internalErrorReporter != nullptr) {
+			internalErrorReporter->storeFull();
+		}
+		// error << "LocalPool( " << std::hex << getObjectId() << std::dec
+		// 			<< " )::reserveSpace: Packet store is full." << std::endl;
+	}
+	return status;
+}
+
+template<uint8_t NUMBER_OF_POOLS>
+inline LocalPool<NUMBER_OF_POOLS>::~LocalPool(void) {
+	for (uint16_t n = 0; n < NUMBER_OF_POOLS; n++) {
+		delete[] store[n];
+		delete[] size_list[n];
+	}
+}
+
+template<uint8_t NUMBER_OF_POOLS>
+inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::addData(store_address_t* storageId,
+		const uint8_t* data, size_t size, bool ignoreFault) {
+	ReturnValue_t status = reserveSpace(size, storageId, ignoreFault);
+	if (status == RETURN_OK) {
+		write(*storageId, data, size);
+	}
+	return status;
+}
+
+template<uint8_t NUMBER_OF_POOLS>
+inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::getFreeElement(
+		store_address_t* storageId, const size_t size,
+		uint8_t** p_data, bool ignoreFault) {
+	ReturnValue_t status = reserveSpace(size, storageId, ignoreFault);
+	if (status == RETURN_OK) {
+		*p_data = &store[storageId->pool_index][getRawPosition(*storageId)];
+	} else {
+		*p_data = NULL;
+	}
+	return status;
+}
+
+template<uint8_t NUMBER_OF_POOLS>
+inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::getData(
+		store_address_t packet_id, const uint8_t** packet_ptr, size_t* size) {
+	uint8_t* tempData = NULL;
+	ReturnValue_t status = modifyData(packet_id, &tempData, size);
+	*packet_ptr = tempData;
+	return status;
+}
+
+template<uint8_t NUMBER_OF_POOLS>
+inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::modifyData(
+		store_address_t packet_id, uint8_t** packet_ptr, size_t* size) {
+	ReturnValue_t status = RETURN_FAILED;
+	if (packet_id.pool_index >= NUMBER_OF_POOLS) {
+		return ILLEGAL_STORAGE_ID;
+	}
+	if ((packet_id.packet_index >= n_elements[packet_id.pool_index])) {
+		return ILLEGAL_STORAGE_ID;
+	}
+	if (size_list[packet_id.pool_index][packet_id.packet_index]
+			!= STORAGE_FREE) {
+		uint32_t packet_position = getRawPosition(packet_id);
+		*packet_ptr = &store[packet_id.pool_index][packet_position];
+		*size = size_list[packet_id.pool_index][packet_id.packet_index];
+		status = RETURN_OK;
+	} else {
+		status = DATA_DOES_NOT_EXIST;
+	}
+	return status;
+}
+
+template<uint8_t NUMBER_OF_POOLS>
+inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::deleteData(
+		store_address_t packet_id) {
+	//if (getObjectId() == objects::IPC_STORE && packet_id.pool_index >= 3) {
+	//	debug << "Delete: Pool: " << std::dec << packet_id.pool_index << " Index: "
+	//	         << packet_id.packet_index << std::endl;
+	//}
+	ReturnValue_t status = RETURN_OK;
+	uint32_t page_size = getPageSize(packet_id.pool_index);
+	if ((page_size != 0)
+			&& (packet_id.packet_index < n_elements[packet_id.pool_index])) {
+		uint16_t packet_position = getRawPosition(packet_id);
+		uint8_t* ptr = &store[packet_id.pool_index][packet_position];
+		memset(ptr, 0, page_size);
+		//Set free list
+		size_list[packet_id.pool_index][packet_id.packet_index] = STORAGE_FREE;
+	} else {
+		//pool_index or packet_index is too large
+		sif::error << "LocalPool:deleteData failed." << std::endl;
+		status = ILLEGAL_STORAGE_ID;
+	}
+	return status;
+}
+
+template<uint8_t NUMBER_OF_POOLS>
+inline void LocalPool<NUMBER_OF_POOLS>::clearStore() {
+	for (uint16_t n = 0; n < NUMBER_OF_POOLS; n++) {
+		//TODO checkme
+		memset(size_list[n], STORAGE_FREE, (n_elements[n] * sizeof(**size_list)));
+	}
+}
+
+template<uint8_t NUMBER_OF_POOLS>
+inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::deleteData(uint8_t* ptr,
+		size_t size, store_address_t* storeId) {
+	store_address_t localId;
+	ReturnValue_t result = ILLEGAL_ADDRESS;
+	for (uint16_t n = 0; n < NUMBER_OF_POOLS; n++) {
+		//Not sure if new allocates all stores in order. so better be careful.
+		if ((store[n] <= ptr) && (&store[n][n_elements[n]*element_sizes[n]]) > ptr) {
+			localId.pool_index = n;
+			uint32_t deltaAddress = ptr - store[n];
+			// Getting any data from the right "block" is ok.
+			// This is necessary, as IF's sometimes don't point to the first
+			// element of an object.
+			localId.packet_index = deltaAddress / element_sizes[n];
+			result = deleteData(localId);
+			//if (deltaAddress % element_sizes[n] != 0) {
+			//	error << "Pool::deleteData: address not aligned!" << std::endl;
+			//}
+			break;
+		}
+	}
+	if (storeId != NULL) {
+		*storeId = localId;
+	}
+	return result;
+}
+
+template<uint8_t NUMBER_OF_POOLS>
+inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::initialize() {
+	ReturnValue_t result = SystemObject::initialize();
+	if (result != RETURN_OK) {
+		return result;
+	}
+	internalErrorReporter = objectManager->get<InternalErrorReporterIF>(
+			objects::INTERNAL_ERROR_REPORTER);
+	if (internalErrorReporter == NULL){
+		return RETURN_FAILED;
+	}
+
+	//Check if any pool size is large than the maximum allowed.
+	for (uint8_t count = 0; count < NUMBER_OF_POOLS; count++) {
+		if (element_sizes[count] >= STORAGE_FREE) {
+			sif::error << "LocalPool::initialize: Pool is too large! "
+					"Max. allowed size is: " << (STORAGE_FREE - 1) << std::endl;
+			return RETURN_FAILED;
+		}
+	}
+	return RETURN_OK;
+}
+
+#endif

storagemanager/PoolManager.h

@@ -1,12 +1,3 @@
-/**
- *	@file	PoolManager
- *
- *  @date	02.02.2012
- *	@author	Bastian Baetz
- *
- *	@brief	This file contains the definition of the PoolManager class.
- */
-
 #ifndef POOLMANAGER_H_
 #define POOLMANAGER_H_
 
@@ -17,70 +8,39 @@
 /**
  * @brief	The PoolManager class provides an intermediate data storage with
  * 			a fixed pool size policy for inter-process communication.
- * \details	Uses local pool, but is thread-safe.
+ * @details	Uses local pool calls but is thread safe by protecting the call
+ * 			with a lock.
  */
 
 template <uint8_t NUMBER_OF_POOLS = 5>
 class PoolManager : public LocalPool<NUMBER_OF_POOLS> {
+public:
+	PoolManager(object_id_t setObjectId,
+			const uint16_t element_sizes[NUMBER_OF_POOLS],
+			const uint16_t n_elements[NUMBER_OF_POOLS]);
+
+	//! @brief	In the PoolManager's destructor all allocated memory is freed.
+	virtual ~PoolManager();
+
+	//! @brief LocalPool overrides for thread-safety.
+	ReturnValue_t deleteData(store_address_t) override;
+	ReturnValue_t deleteData(uint8_t* buffer, size_t size,
+			store_address_t* storeId = NULL) override;
+	ReturnValue_t modifyData(store_address_t packet_id, uint8_t** packet_ptr,
+				size_t* size) override;
 protected:
-	/**
+	ReturnValue_t reserveSpace(const uint32_t size, store_address_t* address,
-	 * Overwritten for thread safety.
+			bool ignoreFault) override;
-	 * Locks during execution.
-	 */
-	virtual ReturnValue_t reserveSpace(const uint32_t size, store_address_t* address, bool ignoreFault);
 
 	/**
-	 * \brief	The mutex is created in the constructor and makes access mutual exclusive.
+	 * @brief	The mutex is created in the constructor and makes
-	 * \details	Locking and unlocking is done during searching for free slots and deleting existing slots.
+	 * 			access mutual exclusive.
+	 * @details	Locking and unlocking is done during searching for free slots
+	 * 			and deleting existing slots.
 	 */
 	MutexIF* mutex;
-public:
-	PoolManager( object_id_t setObjectId, const uint16_t element_sizes[NUMBER_OF_POOLS], const uint16_t n_elements[NUMBER_OF_POOLS] );
-	/**
-	 * @brief	In the PoolManager's destructor all allocated memory is freed.
-	 */
-	virtual ~PoolManager( void );
-	/**
-	 * Overwritten for thread safety.
-	 */
-	virtual ReturnValue_t deleteData(store_address_t);
-	virtual ReturnValue_t deleteData(uint8_t* buffer, uint32_t size, store_address_t* storeId = NULL);
 };
 
-template<uint8_t NUMBER_OF_POOLS>
+#include "PoolManager.tpp"
-inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::reserveSpace(const uint32_t size, store_address_t* address, bool ignoreFault) {
-	MutexHelper mutexHelper(mutex,MutexIF::NO_TIMEOUT);
-	ReturnValue_t status = LocalPool<NUMBER_OF_POOLS>::reserveSpace(size,address,ignoreFault);
-	return status;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline PoolManager<NUMBER_OF_POOLS>::PoolManager(object_id_t setObjectId,
-		const uint16_t element_sizes[NUMBER_OF_POOLS],
-		const uint16_t n_elements[NUMBER_OF_POOLS]) : LocalPool<NUMBER_OF_POOLS>(setObjectId, element_sizes, n_elements, true) {
-	mutex = MutexFactory::instance()->createMutex();
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline PoolManager<NUMBER_OF_POOLS>::~PoolManager(void) {
-	MutexFactory::instance()->deleteMutex(mutex);
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::deleteData(
-		store_address_t packet_id) {
-	//	debug << "PoolManager( " << translateObject(getObjectId()) << " )::deleteData from store " << packet_id.pool_index << ". id is " << packet_id.packet_index << std::endl;
-		MutexHelper mutexHelper(mutex,MutexIF::NO_TIMEOUT);
-		ReturnValue_t status = LocalPool<NUMBER_OF_POOLS>::deleteData(packet_id);
-		return status;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::deleteData(uint8_t* buffer, uint32_t size,
-		store_address_t* storeId) {
-	MutexHelper mutexHelper(mutex,MutexIF::NO_TIMEOUT);
-	ReturnValue_t status = LocalPool<NUMBER_OF_POOLS>::deleteData(buffer, size, storeId);
-	return status;
-}
 
 #endif /* POOLMANAGER_H_ */

storagemanager/PoolManager.tpp

@@ -0,0 +1,55 @@
+#ifndef FRAMEWORK_STORAGEMANAGER_POOLMANAGER_TPP_
+#define FRAMEWORK_STORAGEMANAGER_POOLMANAGER_TPP_
+
+template<uint8_t NUMBER_OF_POOLS>
+inline PoolManager<NUMBER_OF_POOLS>::PoolManager(object_id_t setObjectId,
+		const uint16_t element_sizes[NUMBER_OF_POOLS],
+		const uint16_t n_elements[NUMBER_OF_POOLS]) :
+		LocalPool<NUMBER_OF_POOLS>(setObjectId, element_sizes, n_elements, true) {
+	mutex = MutexFactory::instance()->createMutex();
+}
+
+template<uint8_t NUMBER_OF_POOLS>
+inline PoolManager<NUMBER_OF_POOLS>::~PoolManager(void) {
+	MutexFactory::instance()->deleteMutex(mutex);
+}
+
+template<uint8_t NUMBER_OF_POOLS>
+inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::reserveSpace(
+		const uint32_t size, store_address_t* address, bool ignoreFault) {
+	MutexHelper mutexHelper(mutex,MutexIF::NO_TIMEOUT);
+	ReturnValue_t status = LocalPool<NUMBER_OF_POOLS>::reserveSpace(size,
+			address,ignoreFault);
+	return status;
+}
+
+template<uint8_t NUMBER_OF_POOLS>
+inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::deleteData(
+		store_address_t packet_id) {
+	// debug << "PoolManager( " << translateObject(getObjectId()) <<
+	//       " )::deleteData from store " << packet_id.pool_index <<
+	//       ". id is "<< packet_id.packet_index << std::endl;
+	MutexHelper mutexHelper(mutex,MutexIF::NO_TIMEOUT);
+	ReturnValue_t status = LocalPool<NUMBER_OF_POOLS>::deleteData(packet_id);
+	return status;
+}
+
+template<uint8_t NUMBER_OF_POOLS>
+inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::deleteData(uint8_t* buffer,
+		size_t size, store_address_t* storeId) {
+	MutexHelper mutexHelper(mutex,MutexIF::NO_TIMEOUT);
+	ReturnValue_t status = LocalPool<NUMBER_OF_POOLS>::deleteData(buffer,
+			size, storeId);
+	return status;
+}
+
+template<uint8_t NUMBER_OF_POOLS>
+inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::modifyData(
+		store_address_t packet_id, uint8_t** packet_ptr, size_t* size) {
+	MutexHelper mutexHelper(mutex,MutexIF::NO_TIMEOUT);
+	ReturnValue_t status = LocalPool<NUMBER_OF_POOLS>::modifyData(packet_id,
+				packet_ptr, size);
+	return status;
+}
+
+#endif

storagemanager/StorageManagerIF.h

@@ -6,18 +6,19 @@
 #include <stddef.h>
 
 /**
- * This union defines the type that identifies where a data packet is stored in the store.
+ * @brief 	This union defines the type that identifies where a data packet is
- * It comprises of a raw part to read it as raw value and a structured part to use it in
+ * 			stored in the store.
- * pool-like stores.
+ * It consists of a raw part to read it as raw value and
+ * a structured part to use it in pool-like stores.
  */
 union store_address_t {
 	/**
 	 * Default Constructor, initializing to INVALID_ADDRESS
 	 */
 	store_address_t():raw(0xFFFFFFFF){}
+
 	/**
 	 * Constructor to create an address object using the raw address
-	 *
 	 * @param rawAddress
 	 */
 	store_address_t(uint32_t rawAddress):raw(rawAddress){}
@@ -31,6 +32,7 @@ union store_address_t {
 	 */
 	store_address_t(uint16_t poolIndex, uint16_t packetIndex):
 			pool_index(poolIndex),packet_index(packetIndex) {}
+
 	/**
 	 * A structure with two elements to access the store address pool-like.
 	 */
@@ -48,6 +50,10 @@ union store_address_t {
 	 * Alternative access to the raw value.
 	 */
 	uint32_t raw;
+
+	bool operator==(const store_address_t& other) const {
+		return raw == other.raw;
+	}
 };
 
 /**
@@ -94,7 +100,8 @@ public:
 	 * 					@li	RETURN_FAILED if data could not be added.
 	 * 						storageId is unchanged then.
 	 */
-	virtual ReturnValue_t addData(store_address_t* storageId, const uint8_t * data, uint32_t size, bool ignoreFault = false) = 0;
+	virtual ReturnValue_t addData(store_address_t* storageId,
+			const uint8_t * data, size_t size, bool ignoreFault = false) = 0;
 	/**
 	 * @brief	With deleteData, the storageManager frees the memory region
 	 * 			identified by packet_id.
@@ -105,14 +112,16 @@ public:
 	 */
 	virtual ReturnValue_t deleteData(store_address_t packet_id) = 0;
 	/**
-	 * @brief	Another deleteData which uses the pointer and size of the stored data to delete the content.
+	 * @brief	Another deleteData which uses the pointer and size of the
+	 * 			stored data to delete the content.
 	 * @param buffer	Pointer to the data.
 	 * @param size		Size of data to be stored.
 	 * @param storeId	Store id of the deleted element (optional)
 	 * @return	@li RETURN_OK on success.
 	 * 			@li	failure code if deletion did not work
 	 */
-	virtual ReturnValue_t deleteData(uint8_t* buffer, uint32_t size, store_address_t* storeId = NULL) = 0;
+	virtual ReturnValue_t deleteData(uint8_t* buffer, size_t size,
+			store_address_t* storeId = nullptr) = 0;
 	/**
 	 * @brief	getData returns an address to data and the size of the data
 	 * 			for a given packet_id.
@@ -125,12 +134,12 @@ public:
 	 * 				(e.g. an illegal packet_id was passed).
 	 */
 	virtual ReturnValue_t getData(store_address_t packet_id,
-			const uint8_t** packet_ptr, uint32_t* size) = 0;
+			const uint8_t** packet_ptr, size_t* size) = 0;
 	/**
 	 * Same as above, but not const and therefore modifiable.
 	 */
 	virtual ReturnValue_t modifyData(store_address_t packet_id,
-			uint8_t** packet_ptr, uint32_t* size) = 0;
+			uint8_t** packet_ptr, size_t* size) = 0;
 	/**
 	 * This method reserves an element of \c size.
 	 *
@@ -144,13 +153,13 @@ public:
 	 * 					@li	RETURN_FAILED if data could not be added.
 	 * 						storageId is unchanged then.
 	 */
-	virtual ReturnValue_t getFreeElement(store_address_t* storageId, const uint32_t size, uint8_t** p_data, bool ignoreFault = false ) = 0;
+	virtual ReturnValue_t getFreeElement(store_address_t* storageId,
+			const size_t size, uint8_t** p_data, bool ignoreFault = false ) = 0;
 	/**
 	 * Clears the whole store.
 	 * Use with care!
 	 */
 	virtual void clearStore() = 0;
-
 };
 
 #endif /* STORAGEMANAGERIF_H_ */

subsystem/Subsystem.cpp

@@ -162,7 +162,7 @@ ReturnValue_t Subsystem::handleCommandMessage(CommandMessage* message) {
 	case ModeSequenceMessage::ADD_SEQUENCE: {
 		FixedArrayList<ModeListEntry, MAX_LENGTH_OF_TABLE_OR_SEQUENCE> sequence;
 		const uint8_t *pointer;
-		uint32_t sizeRead;
+		size_t sizeRead;
 		result = IPCStore->getData(
 				ModeSequenceMessage::getStoreAddress(message), &pointer,
 				&sizeRead);
@@ -188,7 +188,7 @@ ReturnValue_t Subsystem::handleCommandMessage(CommandMessage* message) {
 	case ModeSequenceMessage::ADD_TABLE: {
 		FixedArrayList<ModeListEntry, MAX_LENGTH_OF_TABLE_OR_SEQUENCE> table;
 		const uint8_t *pointer;
-		uint32_t sizeRead;
+		size_t sizeRead;
 		result = IPCStore->getData(
 				ModeSequenceMessage::getStoreAddress(message), &pointer,
 				&sizeRead);

tcdistribution/CCSDSDistributor.cpp

@@ -13,7 +13,7 @@ CCSDSDistributor::~CCSDSDistributor() {
 iterator_t CCSDSDistributor::selectDestination() {
 //	debug << "CCSDSDistributor::selectDestination received: " << this->currentMessage.getStorageId().pool_index << ", " << this->currentMessage.getStorageId().packet_index << std::endl;
 	const uint8_t* p_packet = NULL;
-	uint32_t size = 0;
+	size_t size = 0;
 	//TODO check returncode?
 	this->tcStore->getData( this->currentMessage.getStorageId(), &p_packet, &size );
 	SpacePacketBase current_packet( p_packet );

tmtcpacket/pus/TcPacketStored.cpp

@@ -59,7 +59,7 @@ bool TcPacketStored::checkAndSetStore() {
 void TcPacketStored::setStoreAddress(store_address_t setAddress) {
 	this->storeAddress = setAddress;
 	const uint8_t* temp_data = NULL;
-	uint32_t temp_size;
+	size_t temp_size;
 	ReturnValue_t status = StorageManagerIF::RETURN_FAILED;
 	if (this->checkAndSetStore()) {
 		status = this->store->getData(this->storeAddress, &temp_data,
@@ -79,7 +79,7 @@ store_address_t TcPacketStored::getStoreAddress() {
 
 bool TcPacketStored::isSizeCorrect() {
 	const uint8_t* temp_data = NULL;
-	uint32_t temp_size;
+	size_t temp_size;
 	ReturnValue_t status = this->store->getData(this->storeAddress, &temp_data,
 			&temp_size);
 	if (status == StorageManagerIF::RETURN_OK) {

tmtcpacket/pus/TmPacketStored.cpp

@@ -81,7 +81,7 @@ void TmPacketStored::deletePacket() {
 void TmPacketStored::setStoreAddress(store_address_t setAddress) {
 	storeAddress = setAddress;
 	const uint8_t* temp_data = NULL;
-	uint32_t temp_size;
+	size_t temp_size;
 	if (!checkAndSetStore()) {
 		return;
 	}