From cef84b13d923524e10e497602b6b6c27a62a34d0 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 29 Sep 2020 14:35:05 +0200
Subject: [PATCH] renormalization
---
ipc/messageQueueDefinitions.h | 38 +--
storagemanager/ConstStorageAccessor.cpp | 174 ++++++------
storagemanager/ConstStorageAccessor.h | 232 ++++++++--------
storagemanager/StorageAccessor.cpp | 134 +++++-----
storagemanager/StorageAccessor.h | 90 +++----
storagemanager/StorageManagerIF.h | 334 ++++++++++++------------
6 files changed, 501 insertions(+), 501 deletions(-)
diff --git a/ipc/messageQueueDefinitions.h b/ipc/messageQueueDefinitions.h
index 60c09b05b..b4f861b80 100644
--- a/ipc/messageQueueDefinitions.h
+++ b/ipc/messageQueueDefinitions.h
@@ -1,19 +1,19 @@
-#ifndef FSFW_IPC_MESSAGEQUEUEDEFINITIONS_H_
-#define FSFW_IPC_MESSAGEQUEUEDEFINITIONS_H_
-
-#include <cstdint>
-
-/*
- * TODO: Actually, the definition of this ID to be a uint32_t is not ideal and
- * breaks layering. However, it is difficult to keep layering, as the ID is
- * stored in many places and sent around in MessageQueueMessage.
- * Ideally, one would use the (current) object_id_t only, however, doing a
- * lookup of queueIDs for every call does not sound ideal.
- * In a first step, I'll circumvent the issue by not touching it,
- * maybe in a second step. This also influences Interface design
- * (getCommandQueue) and some other issues..
- */
-using MessageQueueId_t = uint32_t;
-
-
-#endif /* FSFW_IPC_MESSAGEQUEUEDEFINITIONS_H_ */
+#ifndef FSFW_IPC_MESSAGEQUEUEDEFINITIONS_H_
+#define FSFW_IPC_MESSAGEQUEUEDEFINITIONS_H_
+
+#include <cstdint>
+
+/*
+ * TODO: Actually, the definition of this ID to be a uint32_t is not ideal and
+ * breaks layering. However, it is difficult to keep layering, as the ID is
+ * stored in many places and sent around in MessageQueueMessage.
+ * Ideally, one would use the (current) object_id_t only, however, doing a
+ * lookup of queueIDs for every call does not sound ideal.
+ * In a first step, I'll circumvent the issue by not touching it,
+ * maybe in a second step. This also influences Interface design
+ * (getCommandQueue) and some other issues..
+ */
+using MessageQueueId_t = uint32_t;
+
+
+#endif /* FSFW_IPC_MESSAGEQUEUEDEFINITIONS_H_ */
diff --git a/storagemanager/ConstStorageAccessor.cpp b/storagemanager/ConstStorageAccessor.cpp
index ea9f2e444..4ada7f801 100644
--- a/storagemanager/ConstStorageAccessor.cpp
+++ b/storagemanager/ConstStorageAccessor.cpp
@@ -1,87 +1,87 @@
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../storagemanager/ConstStorageAccessor.h"
-#include "../storagemanager/StorageManagerIF.h"
-#include "../globalfunctions/arrayprinter.h"
-
-ConstStorageAccessor::ConstStorageAccessor(store_address_t storeId):
- storeId(storeId) {}
-
-ConstStorageAccessor::ConstStorageAccessor(store_address_t storeId,
- StorageManagerIF* store):
- storeId(storeId), store(store) {
- internalState = AccessState::ASSIGNED;
-}
-
-ConstStorageAccessor::~ConstStorageAccessor() {
- if(deleteData and store != nullptr) {
- sif::debug << "deleting store data" << std::endl;
- store->deleteData(storeId);
- }
-}
-
-ConstStorageAccessor::ConstStorageAccessor(ConstStorageAccessor&& other):
- constDataPointer(other.constDataPointer), storeId(other.storeId),
- size_(other.size_), store(other.store), deleteData(other.deleteData),
- internalState(other.internalState) {
- // This prevent premature deletion
- other.store = nullptr;
-}
-
-ConstStorageAccessor& ConstStorageAccessor::operator=(
- ConstStorageAccessor&& other) {
- constDataPointer = other.constDataPointer;
- storeId = other.storeId;
- store = other.store;
- size_ = other.size_;
- deleteData = other.deleteData;
- this->store = other.store;
- // This prevents premature deletion
- other.store = nullptr;
- return *this;
-}
-
-const uint8_t* ConstStorageAccessor::data() const {
- return constDataPointer;
-}
-
-size_t ConstStorageAccessor::size() const {
- if(internalState == AccessState::UNINIT) {
- sif::warning << "StorageAccessor: Not initialized!" << std::endl;
- }
- return size_;
-}
-
-ReturnValue_t ConstStorageAccessor::getDataCopy(uint8_t *pointer,
- size_t maxSize) {
- if(internalState == AccessState::UNINIT) {
- sif::warning << "StorageAccessor: Not initialized!" << std::endl;
- return HasReturnvaluesIF::RETURN_FAILED;
- }
- if(size_ > maxSize) {
- sif::error << "StorageAccessor: Supplied buffer not large enough" << std::endl;
- return HasReturnvaluesIF::RETURN_FAILED;
- }
- std::copy(constDataPointer, constDataPointer + size_, pointer);
- return HasReturnvaluesIF::RETURN_OK;
-}
-
-void ConstStorageAccessor::release() {
- deleteData = false;
-}
-
-store_address_t ConstStorageAccessor::getId() const {
- return storeId;
-}
-
-void ConstStorageAccessor::print() const {
- if(internalState == AccessState::UNINIT or constDataPointer == nullptr) {
- sif::warning << "StorageAccessor: Not initialized!" << std::endl;
- return;
- }
- arrayprinter::print(constDataPointer, size_);
-}
-
-void ConstStorageAccessor::assignStore(StorageManagerIF* store) {
- internalState = AccessState::ASSIGNED;
- this->store = store;
-}
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../storagemanager/ConstStorageAccessor.h"
+#include "../storagemanager/StorageManagerIF.h"
+#include "../globalfunctions/arrayprinter.h"
+
+ConstStorageAccessor::ConstStorageAccessor(store_address_t storeId):
+ storeId(storeId) {}
+
+ConstStorageAccessor::ConstStorageAccessor(store_address_t storeId,
+ StorageManagerIF* store):
+ storeId(storeId), store(store) {
+ internalState = AccessState::ASSIGNED;
+}
+
+ConstStorageAccessor::~ConstStorageAccessor() {
+ if(deleteData and store != nullptr) {
+ sif::debug << "deleting store data" << std::endl;
+ store->deleteData(storeId);
+ }
+}
+
+ConstStorageAccessor::ConstStorageAccessor(ConstStorageAccessor&& other):
+ constDataPointer(other.constDataPointer), storeId(other.storeId),
+ size_(other.size_), store(other.store), deleteData(other.deleteData),
+ internalState(other.internalState) {
+ // This prevent premature deletion
+ other.store = nullptr;
+}
+
+ConstStorageAccessor& ConstStorageAccessor::operator=(
+ ConstStorageAccessor&& other) {
+ constDataPointer = other.constDataPointer;
+ storeId = other.storeId;
+ store = other.store;
+ size_ = other.size_;
+ deleteData = other.deleteData;
+ this->store = other.store;
+ // This prevents premature deletion
+ other.store = nullptr;
+ return *this;
+}
+
+const uint8_t* ConstStorageAccessor::data() const {
+ return constDataPointer;
+}
+
+size_t ConstStorageAccessor::size() const {
+ if(internalState == AccessState::UNINIT) {
+ sif::warning << "StorageAccessor: Not initialized!" << std::endl;
+ }
+ return size_;
+}
+
+ReturnValue_t ConstStorageAccessor::getDataCopy(uint8_t *pointer,
+ size_t maxSize) {
+ if(internalState == AccessState::UNINIT) {
+ sif::warning << "StorageAccessor: Not initialized!" << std::endl;
+ return HasReturnvaluesIF::RETURN_FAILED;
+ }
+ if(size_ > maxSize) {
+ sif::error << "StorageAccessor: Supplied buffer not large enough" << std::endl;
+ return HasReturnvaluesIF::RETURN_FAILED;
+ }
+ std::copy(constDataPointer, constDataPointer + size_, pointer);
+ return HasReturnvaluesIF::RETURN_OK;
+}
+
+void ConstStorageAccessor::release() {
+ deleteData = false;
+}
+
+store_address_t ConstStorageAccessor::getId() const {
+ return storeId;
+}
+
+void ConstStorageAccessor::print() const {
+ if(internalState == AccessState::UNINIT or constDataPointer == nullptr) {
+ sif::warning << "StorageAccessor: Not initialized!" << std::endl;
+ return;
+ }
+ arrayprinter::print(constDataPointer, size_);
+}
+
+void ConstStorageAccessor::assignStore(StorageManagerIF* store) {
+ internalState = AccessState::ASSIGNED;
+ this->store = store;
+}
diff --git a/storagemanager/ConstStorageAccessor.h b/storagemanager/ConstStorageAccessor.h
index ec2da8cef..573892da5 100644
--- a/storagemanager/ConstStorageAccessor.h
+++ b/storagemanager/ConstStorageAccessor.h
@@ -1,116 +1,116 @@
-#ifndef FRAMEWORK_STORAGEMANAGER_CONSTSTORAGEACCESSOR_H_
-#define FRAMEWORK_STORAGEMANAGER_CONSTSTORAGEACCESSOR_H_
-
-#include "../storagemanager/storeAddress.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include <cstddef>
-
-class StorageManagerIF;
-
-/**
- * @brief Helper classes to facilitate safe access to storages which is also
- * conforming to RAII principles
- * @details
- * Accessor class which can be returned by pool manager or passed and set by
- * pool managers to have safe access to the pool resources.
- *
- * These helper can be used together with the StorageManager classes to manage
- * access to a storage. It can take care of thread-safety while also providing
- * mechanisms to automatically clear storage data.
- */
-class ConstStorageAccessor {
- //! StorageManager classes have exclusive access to private variables.
- template<uint8_t NUMBER_OF_POOLS>
- friend class PoolManager;
- template<uint8_t NUMBER_OF_POOLS>
- friend class LocalPool;
-public:
- /**
- * @brief Simple constructor which takes the store ID of the storage
- * entry to access.
- * @param storeId
- */
- ConstStorageAccessor(store_address_t storeId);
- ConstStorageAccessor(store_address_t storeId, StorageManagerIF* store);
-
- /**
- * @brief The destructor in default configuration takes care of
- * deleting the accessed pool entry and unlocking the mutex
- */
- virtual ~ConstStorageAccessor();
-
- /**
- * @brief Returns a pointer to the read-only data
- * @return
- */
- const uint8_t* data() const;
-
- /**
- * @brief Copies the read-only data to the supplied pointer
- * @param pointer
- */
- virtual ReturnValue_t getDataCopy(uint8_t *pointer, size_t maxSize);
-
- /**
- * @brief Calling this will prevent the Accessor from deleting the data
- * when the destructor is called.
- */
- void release();
-
- /**
- * Get the size of the data
- * @return
- */
- size_t size() const;
-
- /**
- * Get the storage ID.
- * @return
- */
- store_address_t getId() const;
-
- void print() const;
-
- /**
- * @brief Move ctor and move assignment allow returning accessors as
- * a returnvalue. They prevent resource being free prematurely.
- * Refer to: https://github.com/MicrosoftDocs/cpp-docs/blob/master/docs/cpp/
- * move-constructors-and-move-assignment-operators-cpp.md
- * @param
- * @return
- */
- ConstStorageAccessor& operator= (ConstStorageAccessor&&);
- ConstStorageAccessor(ConstStorageAccessor&&);
-
- //! The copy ctor and copy assignemnt should be deleted implicitely
- //! according to https://foonathan.net/2019/02/special-member-functions/
- //! but I still deleted them to make it more explicit. (remember rule of 5).
- ConstStorageAccessor& operator=(const ConstStorageAccessor&) = delete;
- ConstStorageAccessor(const ConstStorageAccessor&) = delete;
-protected:
- const uint8_t* constDataPointer = nullptr;
- store_address_t storeId;
- size_t size_ = 0;
- //! Managing pool, has to assign itself.
- StorageManagerIF* store = nullptr;
- bool deleteData = true;
-
- enum class AccessState {
- UNINIT,
- ASSIGNED
- };
- //! Internal state for safety reasons.
- AccessState internalState = AccessState::UNINIT;
- /**
- * Used by the pool manager instances to assign themselves to the
- * accessor. This is necessary to delete the data when the acessor
- * exits the scope ! The internal state will be considered read
- * when this function is called, so take care all data is set properly as
- * well.
- * @param
- */
- void assignStore(StorageManagerIF*);
-};
-
-
-#endif /* FRAMEWORK_STORAGEMANAGER_CONSTSTORAGEACCESSOR_H_ */
+#ifndef FRAMEWORK_STORAGEMANAGER_CONSTSTORAGEACCESSOR_H_
+#define FRAMEWORK_STORAGEMANAGER_CONSTSTORAGEACCESSOR_H_
+
+#include "../storagemanager/storeAddress.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include <cstddef>
+
+class StorageManagerIF;
+
+/**
+ * @brief Helper classes to facilitate safe access to storages which is also
+ * conforming to RAII principles
+ * @details
+ * Accessor class which can be returned by pool manager or passed and set by
+ * pool managers to have safe access to the pool resources.
+ *
+ * These helper can be used together with the StorageManager classes to manage
+ * access to a storage. It can take care of thread-safety while also providing
+ * mechanisms to automatically clear storage data.
+ */
+class ConstStorageAccessor {
+ //! StorageManager classes have exclusive access to private variables.
+ template<uint8_t NUMBER_OF_POOLS>
+ friend class PoolManager;
+ template<uint8_t NUMBER_OF_POOLS>
+ friend class LocalPool;
+public:
+ /**
+ * @brief Simple constructor which takes the store ID of the storage
+ * entry to access.
+ * @param storeId
+ */
+ ConstStorageAccessor(store_address_t storeId);
+ ConstStorageAccessor(store_address_t storeId, StorageManagerIF* store);
+
+ /**
+ * @brief The destructor in default configuration takes care of
+ * deleting the accessed pool entry and unlocking the mutex
+ */
+ virtual ~ConstStorageAccessor();
+
+ /**
+ * @brief Returns a pointer to the read-only data
+ * @return
+ */
+ const uint8_t* data() const;
+
+ /**
+ * @brief Copies the read-only data to the supplied pointer
+ * @param pointer
+ */
+ virtual ReturnValue_t getDataCopy(uint8_t *pointer, size_t maxSize);
+
+ /**
+ * @brief Calling this will prevent the Accessor from deleting the data
+ * when the destructor is called.
+ */
+ void release();
+
+ /**
+ * Get the size of the data
+ * @return
+ */
+ size_t size() const;
+
+ /**
+ * Get the storage ID.
+ * @return
+ */
+ store_address_t getId() const;
+
+ void print() const;
+
+ /**
+ * @brief Move ctor and move assignment allow returning accessors as
+ * a returnvalue. They prevent resource being free prematurely.
+ * Refer to: https://github.com/MicrosoftDocs/cpp-docs/blob/master/docs/cpp/
+ * move-constructors-and-move-assignment-operators-cpp.md
+ * @param
+ * @return
+ */
+ ConstStorageAccessor& operator= (ConstStorageAccessor&&);
+ ConstStorageAccessor(ConstStorageAccessor&&);
+
+ //! The copy ctor and copy assignemnt should be deleted implicitely
+ //! according to https://foonathan.net/2019/02/special-member-functions/
+ //! but I still deleted them to make it more explicit. (remember rule of 5).
+ ConstStorageAccessor& operator=(const ConstStorageAccessor&) = delete;
+ ConstStorageAccessor(const ConstStorageAccessor&) = delete;
+protected:
+ const uint8_t* constDataPointer = nullptr;
+ store_address_t storeId;
+ size_t size_ = 0;
+ //! Managing pool, has to assign itself.
+ StorageManagerIF* store = nullptr;
+ bool deleteData = true;
+
+ enum class AccessState {
+ UNINIT,
+ ASSIGNED
+ };
+ //! Internal state for safety reasons.
+ AccessState internalState = AccessState::UNINIT;
+ /**
+ * Used by the pool manager instances to assign themselves to the
+ * accessor. This is necessary to delete the data when the acessor
+ * exits the scope ! The internal state will be considered read
+ * when this function is called, so take care all data is set properly as
+ * well.
+ * @param
+ */
+ void assignStore(StorageManagerIF*);
+};
+
+
+#endif /* FRAMEWORK_STORAGEMANAGER_CONSTSTORAGEACCESSOR_H_ */
diff --git a/storagemanager/StorageAccessor.cpp b/storagemanager/StorageAccessor.cpp
index d4d2a54d8..60bd41304 100644
--- a/storagemanager/StorageAccessor.cpp
+++ b/storagemanager/StorageAccessor.cpp
@@ -1,67 +1,67 @@
-#include "../storagemanager/StorageAccessor.h"
-#include "../storagemanager/StorageManagerIF.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-
-StorageAccessor::StorageAccessor(store_address_t storeId):
- ConstStorageAccessor(storeId) {
-}
-
-StorageAccessor::StorageAccessor(store_address_t storeId,
- StorageManagerIF* store):
- ConstStorageAccessor(storeId, store) {
-}
-
-StorageAccessor& StorageAccessor::operator =(
- StorageAccessor&& other) {
- // Call the parent move assignment and also assign own member.
- dataPointer = other.dataPointer;
- StorageAccessor::operator=(std::move(other));
- return * this;
-}
-
-// Call the parent move ctor and also transfer own member.
-StorageAccessor::StorageAccessor(StorageAccessor&& other):
- ConstStorageAccessor(std::move(other)), dataPointer(other.dataPointer) {
-}
-
-ReturnValue_t StorageAccessor::getDataCopy(uint8_t *pointer, size_t maxSize) {
- if(internalState == AccessState::UNINIT) {
- sif::warning << "StorageAccessor: Not initialized!" << std::endl;
- return HasReturnvaluesIF::RETURN_FAILED;
- }
- if(size_ > maxSize) {
- sif::error << "StorageAccessor: Supplied buffer not large "
- "enough" << std::endl;
- return HasReturnvaluesIF::RETURN_FAILED;
- }
- std::copy(dataPointer, dataPointer + size_, pointer);
- return HasReturnvaluesIF::RETURN_OK;
-}
-
-uint8_t* StorageAccessor::data() {
- if(internalState == AccessState::UNINIT) {
- sif::warning << "StorageAccessor: Not initialized!" << std::endl;
- }
- return dataPointer;
-}
-
-ReturnValue_t StorageAccessor::write(uint8_t *data, size_t size,
- uint16_t offset) {
- if(internalState == AccessState::UNINIT) {
- sif::warning << "StorageAccessor: Not initialized!" << std::endl;
- return HasReturnvaluesIF::RETURN_FAILED;
- }
- if(offset + size > size_) {
- sif::error << "StorageAccessor: Data too large for pool "
- "entry!" << std::endl;
- return HasReturnvaluesIF::RETURN_FAILED;
- }
- std::copy(data, data + size, dataPointer + offset);
- return HasReturnvaluesIF::RETURN_OK;
-}
-
-void StorageAccessor::assignConstPointer() {
- constDataPointer = dataPointer;
-}
-
-
+#include "../storagemanager/StorageAccessor.h"
+#include "../storagemanager/StorageManagerIF.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+StorageAccessor::StorageAccessor(store_address_t storeId):
+ ConstStorageAccessor(storeId) {
+}
+
+StorageAccessor::StorageAccessor(store_address_t storeId,
+ StorageManagerIF* store):
+ ConstStorageAccessor(storeId, store) {
+}
+
+StorageAccessor& StorageAccessor::operator =(
+ StorageAccessor&& other) {
+ // Call the parent move assignment and also assign own member.
+ dataPointer = other.dataPointer;
+ StorageAccessor::operator=(std::move(other));
+ return * this;
+}
+
+// Call the parent move ctor and also transfer own member.
+StorageAccessor::StorageAccessor(StorageAccessor&& other):
+ ConstStorageAccessor(std::move(other)), dataPointer(other.dataPointer) {
+}
+
+ReturnValue_t StorageAccessor::getDataCopy(uint8_t *pointer, size_t maxSize) {
+ if(internalState == AccessState::UNINIT) {
+ sif::warning << "StorageAccessor: Not initialized!" << std::endl;
+ return HasReturnvaluesIF::RETURN_FAILED;
+ }
+ if(size_ > maxSize) {
+ sif::error << "StorageAccessor: Supplied buffer not large "
+ "enough" << std::endl;
+ return HasReturnvaluesIF::RETURN_FAILED;
+ }
+ std::copy(dataPointer, dataPointer + size_, pointer);
+ return HasReturnvaluesIF::RETURN_OK;
+}
+
+uint8_t* StorageAccessor::data() {
+ if(internalState == AccessState::UNINIT) {
+ sif::warning << "StorageAccessor: Not initialized!" << std::endl;
+ }
+ return dataPointer;
+}
+
+ReturnValue_t StorageAccessor::write(uint8_t *data, size_t size,
+ uint16_t offset) {
+ if(internalState == AccessState::UNINIT) {
+ sif::warning << "StorageAccessor: Not initialized!" << std::endl;
+ return HasReturnvaluesIF::RETURN_FAILED;
+ }
+ if(offset + size > size_) {
+ sif::error << "StorageAccessor: Data too large for pool "
+ "entry!" << std::endl;
+ return HasReturnvaluesIF::RETURN_FAILED;
+ }
+ std::copy(data, data + size, dataPointer + offset);
+ return HasReturnvaluesIF::RETURN_OK;
+}
+
+void StorageAccessor::assignConstPointer() {
+ constDataPointer = dataPointer;
+}
+
+
diff --git a/storagemanager/StorageAccessor.h b/storagemanager/StorageAccessor.h
index 1ca5f7ddc..a65427b8b 100644
--- a/storagemanager/StorageAccessor.h
+++ b/storagemanager/StorageAccessor.h
@@ -1,45 +1,45 @@
-#ifndef FRAMEWORK_STORAGEMANAGER_STORAGEACCESSOR_H_
-#define FRAMEWORK_STORAGEMANAGER_STORAGEACCESSOR_H_
-
-#include "../storagemanager/ConstStorageAccessor.h"
-
-class StorageManagerIF;
-
-/**
- * @brief Child class for modifyable data. Also has a normal pointer member.
- */
-class StorageAccessor: public ConstStorageAccessor {
- //! StorageManager classes have exclusive access to private variables.
- template<uint8_t NUMBER_OF_POOLS>
- friend class PoolManager;
- template<uint8_t NUMBER_OF_POOLS>
- friend class LocalPool;
-public:
- StorageAccessor(store_address_t storeId);
- StorageAccessor(store_address_t storeId, StorageManagerIF* store);
-
- /**
- * @brief Move ctor and move assignment allow returning accessors as
- * a returnvalue. They prevent resource being freed prematurely.
- * See: https://github.com/MicrosoftDocs/cpp-docs/blob/master/docs/cpp/
- * move-constructors-and-move-assignment-operators-cpp.md
- * @param
- * @return
- */
- StorageAccessor& operator=(StorageAccessor&&);
- StorageAccessor(StorageAccessor&&);
-
- ReturnValue_t write(uint8_t *data, size_t size,
- uint16_t offset = 0);
- uint8_t* data();
- ReturnValue_t getDataCopy(uint8_t *pointer, size_t maxSize) override;
-
-private:
- //! Non-const pointer for modifyable data.
- uint8_t* dataPointer = nullptr;
- //! For modifyable data, the const pointer is assigned to the normal
- //! pointer by the pool manager so both access functions can be used safely
- void assignConstPointer();
-};
-
-#endif /* TEST_PROTOTYPES_STORAGEACCESSOR_H_ */
+#ifndef FRAMEWORK_STORAGEMANAGER_STORAGEACCESSOR_H_
+#define FRAMEWORK_STORAGEMANAGER_STORAGEACCESSOR_H_
+
+#include "../storagemanager/ConstStorageAccessor.h"
+
+class StorageManagerIF;
+
+/**
+ * @brief Child class for modifyable data. Also has a normal pointer member.
+ */
+class StorageAccessor: public ConstStorageAccessor {
+ //! StorageManager classes have exclusive access to private variables.
+ template<uint8_t NUMBER_OF_POOLS>
+ friend class PoolManager;
+ template<uint8_t NUMBER_OF_POOLS>
+ friend class LocalPool;
+public:
+ StorageAccessor(store_address_t storeId);
+ StorageAccessor(store_address_t storeId, StorageManagerIF* store);
+
+ /**
+ * @brief Move ctor and move assignment allow returning accessors as
+ * a returnvalue. They prevent resource being freed prematurely.
+ * See: https://github.com/MicrosoftDocs/cpp-docs/blob/master/docs/cpp/
+ * move-constructors-and-move-assignment-operators-cpp.md
+ * @param
+ * @return
+ */
+ StorageAccessor& operator=(StorageAccessor&&);
+ StorageAccessor(StorageAccessor&&);
+
+ ReturnValue_t write(uint8_t *data, size_t size,
+ uint16_t offset = 0);
+ uint8_t* data();
+ ReturnValue_t getDataCopy(uint8_t *pointer, size_t maxSize) override;
+
+private:
+ //! Non-const pointer for modifyable data.
+ uint8_t* dataPointer = nullptr;
+ //! For modifyable data, the const pointer is assigned to the normal
+ //! pointer by the pool manager so both access functions can be used safely
+ void assignConstPointer();
+};
+
+#endif /* TEST_PROTOTYPES_STORAGEACCESSOR_H_ */
diff --git a/storagemanager/StorageManagerIF.h b/storagemanager/StorageManagerIF.h
index 85341f2e8..2229cdf89 100644
--- a/storagemanager/StorageManagerIF.h
+++ b/storagemanager/StorageManagerIF.h
@@ -1,167 +1,167 @@
-#ifndef STORAGEMANAGERIF_H_H
-#define STORAGEMANAGERIF_H_H
-
-#include "../events/Event.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include "../storagemanager/StorageAccessor.h"
-#include "../storagemanager/storeAddress.h"
-#include <utility>
-#include <cstddef>
-
-using AccessorPair = std::pair<ReturnValue_t, StorageAccessor>;
-using ConstAccessorPair = std::pair<ReturnValue_t, ConstStorageAccessor>;
-
-/**
- * @brief This class provides an interface for intermediate data storage.
- * @details The Storage manager classes shall be used to store larger chunks of
- * data in RAM for exchange between tasks. This interface expects the
- * data to be stored in one consecutive block of memory, so tasks can
- * write directly to the destination pointer.
- * For interprocess communication, the stores must be locked during
- * insertion and deletion. If the receiving storage identifier is
- * passed token-like between tasks, a lock during read and write
- * operations is not necessary.
- * @author Bastian Baetz
- * @date 18.09.2012
- */
-class StorageManagerIF : public HasReturnvaluesIF {
-public:
- static const uint8_t INTERFACE_ID = CLASS_ID::STORAGE_MANAGER_IF; //!< The unique ID for return codes for this interface.
- static const ReturnValue_t DATA_TOO_LARGE = MAKE_RETURN_CODE(1); //!< This return code indicates that the data to be stored is too large for the store.
- static const ReturnValue_t DATA_STORAGE_FULL = MAKE_RETURN_CODE(2); //!< This return code indicates that a data storage is full.
- static const ReturnValue_t ILLEGAL_STORAGE_ID = MAKE_RETURN_CODE(3); //!< This return code indicates that data was requested with an illegal storage ID.
- static const ReturnValue_t DATA_DOES_NOT_EXIST = MAKE_RETURN_CODE(4); //!< This return code indicates that the requested ID was valid, but no data is stored there.
- static const ReturnValue_t ILLEGAL_ADDRESS = MAKE_RETURN_CODE(5);
- static const ReturnValue_t POOL_TOO_LARGE = MAKE_RETURN_CODE(6); //!< Pool size too large on initialization.
-
- static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::OBSW;
- static const Event GET_DATA_FAILED = MAKE_EVENT(0, SEVERITY::LOW);
- static const Event STORE_DATA_FAILED = MAKE_EVENT(1, SEVERITY::LOW);
-
- static const uint32_t INVALID_ADDRESS = 0xFFFFFFFF; //!< Indicates an invalid (i.e unused) storage address.
- /**
- * @brief This is the empty virtual destructor as required for C++ interfaces.
- */
- virtual ~StorageManagerIF() {
- }
- ;
- /**
- * @brief With addData, a free storage position is allocated and data
- * stored there.
- * @details During the allocation, the StorageManager is blocked.
- * @param storageId A pointer to the storageId to retrieve.
- * @param data The data to be stored in the StorageManager.
- * @param size The amount of data to be stored.
- * @return Returns @li RETURN_OK if data was added.
- * @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, size_t size, bool ignoreFault = false) = 0;
- /**
- * @brief With deleteData, the storageManager frees the memory region
- * identified by packet_id.
- * @param packet_id The identifier of the memory region to be freed.
- * @return @li RETURN_OK on success.
- * @li RETURN_FAILED if deletion did not work
- * (e.g. an illegal packet_id was passed).
- */
- 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.
- * @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, size_t size,
- store_address_t* storeId = nullptr) = 0;
-
-
- /**
- * @brief Access the data by supplying a store ID.
- * @details
- * A pair consisting of the retrieval result and an instance of a
- * ConstStorageAccessor class is returned
- * @param storeId
- * @return Pair of return value and a ConstStorageAccessor instance
- */
- virtual ConstAccessorPair getData(store_address_t storeId) = 0;
-
- /**
- * @brief Access the data by supplying a store ID and a helper
- * instance
- * @param storeId
- * @param constAccessor Wrapper function to access store data.
- * @return
- */
- virtual ReturnValue_t getData(store_address_t storeId,
- ConstStorageAccessor& constAccessor) = 0;
-
-
- /**
- * @brief getData returns an address to data and the size of the data
- * for a given packet_id.
- * @param packet_id The id of the data to be returned
- * @param packet_ptr The passed pointer address is set to the the memory
- * position
- * @param size The exact size of the stored data is returned here.
- * @return @li RETURN_OK on success.
- * @li RETURN_FAILED if fetching data did not work
- * (e.g. an illegal packet_id was passed).
- */
- virtual ReturnValue_t getData(store_address_t packet_id,
- const uint8_t** packet_ptr, size_t* size) = 0;
-
-
- /**
- * Modify data by supplying a store ID
- * @param storeId
- * @return Pair of return value and StorageAccessor helper
- */
- virtual AccessorPair modifyData(store_address_t storeId) = 0;
-
- /**
- * Modify data by supplying a store ID and a StorageAccessor helper instance.
- * @param storeId
- * @param accessor Helper class to access the modifiable data.
- * @return
- */
- virtual ReturnValue_t modifyData(store_address_t storeId,
- StorageAccessor& accessor) = 0;
-
- /**
- * Get pointer and size of modifiable data by supplying the storeId
- * @param packet_id
- * @param packet_ptr [out] Pointer to pointer of data to set
- * @param size [out] Pointer to size to set
- * @return
- */
- virtual ReturnValue_t modifyData(store_address_t packet_id,
- uint8_t** packet_ptr, size_t* size) = 0;
- /**
- * This method reserves an element of \c size.
- *
- * It returns the packet id of this element as well as a direct pointer to the
- * data of the element. It must be assured that exactly \c size data is
- * written to p_data!
- * @param storageId A pointer to the storageId to retrieve.
- * @param size The size of the space to be reserved.
- * @param p_data A pointer to the element data is returned here.
- * @return Returns @li RETURN_OK if data was added.
- * @li RETURN_FAILED if data could not be added.
- * storageId is unchanged then.
- */
- 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_ */
+#ifndef STORAGEMANAGERIF_H_H
+#define STORAGEMANAGERIF_H_H
+
+#include "../events/Event.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../storagemanager/StorageAccessor.h"
+#include "../storagemanager/storeAddress.h"
+#include <utility>
+#include <cstddef>
+
+using AccessorPair = std::pair<ReturnValue_t, StorageAccessor>;
+using ConstAccessorPair = std::pair<ReturnValue_t, ConstStorageAccessor>;
+
+/**
+ * @brief This class provides an interface for intermediate data storage.
+ * @details The Storage manager classes shall be used to store larger chunks of
+ * data in RAM for exchange between tasks. This interface expects the
+ * data to be stored in one consecutive block of memory, so tasks can
+ * write directly to the destination pointer.
+ * For interprocess communication, the stores must be locked during
+ * insertion and deletion. If the receiving storage identifier is
+ * passed token-like between tasks, a lock during read and write
+ * operations is not necessary.
+ * @author Bastian Baetz
+ * @date 18.09.2012
+ */
+class StorageManagerIF : public HasReturnvaluesIF {
+public:
+ static const uint8_t INTERFACE_ID = CLASS_ID::STORAGE_MANAGER_IF; //!< The unique ID for return codes for this interface.
+ static const ReturnValue_t DATA_TOO_LARGE = MAKE_RETURN_CODE(1); //!< This return code indicates that the data to be stored is too large for the store.
+ static const ReturnValue_t DATA_STORAGE_FULL = MAKE_RETURN_CODE(2); //!< This return code indicates that a data storage is full.
+ static const ReturnValue_t ILLEGAL_STORAGE_ID = MAKE_RETURN_CODE(3); //!< This return code indicates that data was requested with an illegal storage ID.
+ static const ReturnValue_t DATA_DOES_NOT_EXIST = MAKE_RETURN_CODE(4); //!< This return code indicates that the requested ID was valid, but no data is stored there.
+ static const ReturnValue_t ILLEGAL_ADDRESS = MAKE_RETURN_CODE(5);
+ static const ReturnValue_t POOL_TOO_LARGE = MAKE_RETURN_CODE(6); //!< Pool size too large on initialization.
+
+ static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::OBSW;
+ static const Event GET_DATA_FAILED = MAKE_EVENT(0, SEVERITY::LOW);
+ static const Event STORE_DATA_FAILED = MAKE_EVENT(1, SEVERITY::LOW);
+
+ static const uint32_t INVALID_ADDRESS = 0xFFFFFFFF; //!< Indicates an invalid (i.e unused) storage address.
+ /**
+ * @brief This is the empty virtual destructor as required for C++ interfaces.
+ */
+ virtual ~StorageManagerIF() {
+ }
+ ;
+ /**
+ * @brief With addData, a free storage position is allocated and data
+ * stored there.
+ * @details During the allocation, the StorageManager is blocked.
+ * @param storageId A pointer to the storageId to retrieve.
+ * @param data The data to be stored in the StorageManager.
+ * @param size The amount of data to be stored.
+ * @return Returns @li RETURN_OK if data was added.
+ * @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, size_t size, bool ignoreFault = false) = 0;
+ /**
+ * @brief With deleteData, the storageManager frees the memory region
+ * identified by packet_id.
+ * @param packet_id The identifier of the memory region to be freed.
+ * @return @li RETURN_OK on success.
+ * @li RETURN_FAILED if deletion did not work
+ * (e.g. an illegal packet_id was passed).
+ */
+ 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.
+ * @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, size_t size,
+ store_address_t* storeId = nullptr) = 0;
+
+
+ /**
+ * @brief Access the data by supplying a store ID.
+ * @details
+ * A pair consisting of the retrieval result and an instance of a
+ * ConstStorageAccessor class is returned
+ * @param storeId
+ * @return Pair of return value and a ConstStorageAccessor instance
+ */
+ virtual ConstAccessorPair getData(store_address_t storeId) = 0;
+
+ /**
+ * @brief Access the data by supplying a store ID and a helper
+ * instance
+ * @param storeId
+ * @param constAccessor Wrapper function to access store data.
+ * @return
+ */
+ virtual ReturnValue_t getData(store_address_t storeId,
+ ConstStorageAccessor& constAccessor) = 0;
+
+
+ /**
+ * @brief getData returns an address to data and the size of the data
+ * for a given packet_id.
+ * @param packet_id The id of the data to be returned
+ * @param packet_ptr The passed pointer address is set to the the memory
+ * position
+ * @param size The exact size of the stored data is returned here.
+ * @return @li RETURN_OK on success.
+ * @li RETURN_FAILED if fetching data did not work
+ * (e.g. an illegal packet_id was passed).
+ */
+ virtual ReturnValue_t getData(store_address_t packet_id,
+ const uint8_t** packet_ptr, size_t* size) = 0;
+
+
+ /**
+ * Modify data by supplying a store ID
+ * @param storeId
+ * @return Pair of return value and StorageAccessor helper
+ */
+ virtual AccessorPair modifyData(store_address_t storeId) = 0;
+
+ /**
+ * Modify data by supplying a store ID and a StorageAccessor helper instance.
+ * @param storeId
+ * @param accessor Helper class to access the modifiable data.
+ * @return
+ */
+ virtual ReturnValue_t modifyData(store_address_t storeId,
+ StorageAccessor& accessor) = 0;
+
+ /**
+ * Get pointer and size of modifiable data by supplying the storeId
+ * @param packet_id
+ * @param packet_ptr [out] Pointer to pointer of data to set
+ * @param size [out] Pointer to size to set
+ * @return
+ */
+ virtual ReturnValue_t modifyData(store_address_t packet_id,
+ uint8_t** packet_ptr, size_t* size) = 0;
+ /**
+ * This method reserves an element of \c size.
+ *
+ * It returns the packet id of this element as well as a direct pointer to the
+ * data of the element. It must be assured that exactly \c size data is
+ * written to p_data!
+ * @param storageId A pointer to the storageId to retrieve.
+ * @param size The size of the space to be reserved.
+ * @param p_data A pointer to the element data is returned here.
+ * @return Returns @li RETURN_OK if data was added.
+ * @li RETURN_FAILED if data could not be added.
+ * storageId is unchanged then.
+ */
+ 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_ */