fsfw/fsfw
fsfw
/
fsfw
10
3
Fork 6
Code Issues 31 Pull Requests 4 Releases 10 Wiki Activity

renormalization

This commit is contained in:
Robin Müller 2020-09-29 14:35:05 +02:00
parent 6f965c74ac
commit cef84b13d9
6 changed files with 501 additions and 501 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

38
ipc/messageQueueDefinitions.h
View File

@ -1,19 +1,19 @@
#ifndef FSFW_IPC_MESSAGEQUEUEDEFINITIONS_H_ #ifndef FSFW_IPC_MESSAGEQUEUEDEFINITIONS_H_
#define FSFW_IPC_MESSAGEQUEUEDEFINITIONS_H_ #define FSFW_IPC_MESSAGEQUEUEDEFINITIONS_H_
#include <cstdint> #include <cstdint>
/* /*
* TODO: Actually, the definition of this ID to be a uint32_t is not ideal and * 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 * breaks layering. However, it is difficult to keep layering, as the ID is
* stored in many places and sent around in MessageQueueMessage. * stored in many places and sent around in MessageQueueMessage.
* Ideally, one would use the (current) object_id_t only, however, doing a * Ideally, one would use the (current) object_id_t only, however, doing a
* lookup of queueIDs for every call does not sound ideal. * lookup of queueIDs for every call does not sound ideal.
* In a first step, I'll circumvent the issue by not touching it, * In a first step, I'll circumvent the issue by not touching it,
* maybe in a second step. This also influences Interface design * maybe in a second step. This also influences Interface design
* (getCommandQueue) and some other issues.. * (getCommandQueue) and some other issues..
*/ */
using MessageQueueId_t = uint32_t; using MessageQueueId_t = uint32_t;
#endif /* FSFW_IPC_MESSAGEQUEUEDEFINITIONS_H_ */ #endif /* FSFW_IPC_MESSAGEQUEUEDEFINITIONS_H_ */

174
storagemanager/ConstStorageAccessor.cpp
View File

@ -1,87 +1,87 @@
#include "../serviceinterface/ServiceInterfaceStream.h" #include "../serviceinterface/ServiceInterfaceStream.h"
#include "../storagemanager/ConstStorageAccessor.h" #include "../storagemanager/ConstStorageAccessor.h"
#include "../storagemanager/StorageManagerIF.h" #include "../storagemanager/StorageManagerIF.h"
#include "../globalfunctions/arrayprinter.h" #include "../globalfunctions/arrayprinter.h"
ConstStorageAccessor::ConstStorageAccessor(store_address_t storeId): ConstStorageAccessor::ConstStorageAccessor(store_address_t storeId):
storeId(storeId) {} storeId(storeId) {}
ConstStorageAccessor::ConstStorageAccessor(store_address_t storeId, ConstStorageAccessor::ConstStorageAccessor(store_address_t storeId,
StorageManagerIF* store): StorageManagerIF* store):
storeId(storeId), store(store) { storeId(storeId), store(store) {
internalState = AccessState::ASSIGNED; internalState = AccessState::ASSIGNED;
} }
ConstStorageAccessor::~ConstStorageAccessor() { ConstStorageAccessor::~ConstStorageAccessor() {
if(deleteData and store != nullptr) { if(deleteData and store != nullptr) {
sif::debug << "deleting store data" << std::endl; sif::debug << "deleting store data" << std::endl;
store->deleteData(storeId); store->deleteData(storeId);
} }
} }
ConstStorageAccessor::ConstStorageAccessor(ConstStorageAccessor&& other): ConstStorageAccessor::ConstStorageAccessor(ConstStorageAccessor&& other):
constDataPointer(other.constDataPointer), storeId(other.storeId), constDataPointer(other.constDataPointer), storeId(other.storeId),
size_(other.size_), store(other.store), deleteData(other.deleteData), size_(other.size_), store(other.store), deleteData(other.deleteData),
internalState(other.internalState) { internalState(other.internalState) {
// This prevent premature deletion // This prevent premature deletion
other.store = nullptr; other.store = nullptr;
} }
ConstStorageAccessor& ConstStorageAccessor::operator=( ConstStorageAccessor& ConstStorageAccessor::operator=(
ConstStorageAccessor&& other) { ConstStorageAccessor&& other) {
constDataPointer = other.constDataPointer; constDataPointer = other.constDataPointer;
storeId = other.storeId; storeId = other.storeId;
store = other.store; store = other.store;
size_ = other.size_; size_ = other.size_;
deleteData = other.deleteData; deleteData = other.deleteData;
this->store = other.store; this->store = other.store;
// This prevents premature deletion // This prevents premature deletion
other.store = nullptr; other.store = nullptr;
return *this; return *this;
} }
const uint8_t* ConstStorageAccessor::data() const { const uint8_t* ConstStorageAccessor::data() const {
return constDataPointer; return constDataPointer;
} }
size_t ConstStorageAccessor::size() const { size_t ConstStorageAccessor::size() const {
if(internalState == AccessState::UNINIT) { if(internalState == AccessState::UNINIT) {
sif::warning << "StorageAccessor: Not initialized!" << std::endl; sif::warning << "StorageAccessor: Not initialized!" << std::endl;
} }
return size_; return size_;
} }
ReturnValue_t ConstStorageAccessor::getDataCopy(uint8_t *pointer, ReturnValue_t ConstStorageAccessor::getDataCopy(uint8_t *pointer,
size_t maxSize) { size_t maxSize) {
if(internalState == AccessState::UNINIT) { if(internalState == AccessState::UNINIT) {
sif::warning << "StorageAccessor: Not initialized!" << std::endl; sif::warning << "StorageAccessor: Not initialized!" << std::endl;
return HasReturnvaluesIF::RETURN_FAILED; return HasReturnvaluesIF::RETURN_FAILED;
} }
if(size_ > maxSize) { if(size_ > maxSize) {
sif::error << "StorageAccessor: Supplied buffer not large enough" << std::endl; sif::error << "StorageAccessor: Supplied buffer not large enough" << std::endl;
return HasReturnvaluesIF::RETURN_FAILED; return HasReturnvaluesIF::RETURN_FAILED;
} }
std::copy(constDataPointer, constDataPointer + size_, pointer); std::copy(constDataPointer, constDataPointer + size_, pointer);
return HasReturnvaluesIF::RETURN_OK; return HasReturnvaluesIF::RETURN_OK;
} }
void ConstStorageAccessor::release() { void ConstStorageAccessor::release() {
deleteData = false; deleteData = false;
} }
store_address_t ConstStorageAccessor::getId() const { store_address_t ConstStorageAccessor::getId() const {
return storeId; return storeId;
} }
void ConstStorageAccessor::print() const { void ConstStorageAccessor::print() const {
if(internalState == AccessState::UNINIT or constDataPointer == nullptr) { if(internalState == AccessState::UNINIT or constDataPointer == nullptr) {
sif::warning << "StorageAccessor: Not initialized!" << std::endl; sif::warning << "StorageAccessor: Not initialized!" << std::endl;
return; return;
} }
arrayprinter::print(constDataPointer, size_); arrayprinter::print(constDataPointer, size_);
} }
void ConstStorageAccessor::assignStore(StorageManagerIF* store) { void ConstStorageAccessor::assignStore(StorageManagerIF* store) {
internalState = AccessState::ASSIGNED; internalState = AccessState::ASSIGNED;
this->store = store; this->store = store;
} }

232
storagemanager/ConstStorageAccessor.h
View File

@ -1,116 +1,116 @@
#ifndef FRAMEWORK_STORAGEMANAGER_CONSTSTORAGEACCESSOR_H_ #ifndef FRAMEWORK_STORAGEMANAGER_CONSTSTORAGEACCESSOR_H_
#define FRAMEWORK_STORAGEMANAGER_CONSTSTORAGEACCESSOR_H_ #define FRAMEWORK_STORAGEMANAGER_CONSTSTORAGEACCESSOR_H_
#include "../storagemanager/storeAddress.h" #include "../storagemanager/storeAddress.h"
#include "../returnvalues/HasReturnvaluesIF.h" #include "../returnvalues/HasReturnvaluesIF.h"
#include <cstddef> #include <cstddef>
class StorageManagerIF; class StorageManagerIF;
/** /**
* @brief Helper classes to facilitate safe access to storages which is also * @brief Helper classes to facilitate safe access to storages which is also
* conforming to RAII principles * conforming to RAII principles
* @details * @details
* Accessor class which can be returned by pool manager or passed and set by * Accessor class which can be returned by pool manager or passed and set by
* pool managers to have safe access to the pool resources. * pool managers to have safe access to the pool resources.
* *
* These helper can be used together with the StorageManager classes to manage * 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 * access to a storage. It can take care of thread-safety while also providing
* mechanisms to automatically clear storage data. * mechanisms to automatically clear storage data.
*/ */
class ConstStorageAccessor { class ConstStorageAccessor {
//! StorageManager classes have exclusive access to private variables. //! StorageManager classes have exclusive access to private variables.
template<uint8_t NUMBER_OF_POOLS> template<uint8_t NUMBER_OF_POOLS>
friend class PoolManager; friend class PoolManager;
template<uint8_t NUMBER_OF_POOLS> template<uint8_t NUMBER_OF_POOLS>
friend class LocalPool; friend class LocalPool;
public: public:
/** /**
* @brief Simple constructor which takes the store ID of the storage * @brief Simple constructor which takes the store ID of the storage
* entry to access. * entry to access.
* @param storeId * @param storeId
*/ */
ConstStorageAccessor(store_address_t storeId); ConstStorageAccessor(store_address_t storeId);
ConstStorageAccessor(store_address_t storeId, StorageManagerIF* store); ConstStorageAccessor(store_address_t storeId, StorageManagerIF* store);
/** /**
* @brief The destructor in default configuration takes care of * @brief The destructor in default configuration takes care of
* deleting the accessed pool entry and unlocking the mutex * deleting the accessed pool entry and unlocking the mutex
*/ */
virtual ~ConstStorageAccessor(); virtual ~ConstStorageAccessor();
/** /**
* @brief Returns a pointer to the read-only data * @brief Returns a pointer to the read-only data
* @return * @return
*/ */
const uint8_t* data() const; const uint8_t* data() const;
/** /**
* @brief Copies the read-only data to the supplied pointer * @brief Copies the read-only data to the supplied pointer
* @param pointer * @param pointer
*/ */
virtual ReturnValue_t getDataCopy(uint8_t *pointer, size_t maxSize); virtual ReturnValue_t getDataCopy(uint8_t *pointer, size_t maxSize);
/** /**
* @brief Calling this will prevent the Accessor from deleting the data * @brief Calling this will prevent the Accessor from deleting the data
* when the destructor is called. * when the destructor is called.
*/ */
void release(); void release();
/** /**
* Get the size of the data * Get the size of the data
* @return * @return
*/ */
size_t size() const; size_t size() const;
/** /**
* Get the storage ID. * Get the storage ID.
* @return * @return
*/ */
store_address_t getId() const; store_address_t getId() const;
void print() const; void print() const;
/** /**
* @brief Move ctor and move assignment allow returning accessors as * @brief Move ctor and move assignment allow returning accessors as
* a returnvalue. They prevent resource being free prematurely. * a returnvalue. They prevent resource being free prematurely.
* Refer to: https://github.com/MicrosoftDocs/cpp-docs/blob/master/docs/cpp/ * Refer to: https://github.com/MicrosoftDocs/cpp-docs/blob/master/docs/cpp/
* move-constructors-and-move-assignment-operators-cpp.md * move-constructors-and-move-assignment-operators-cpp.md
* @param * @param
* @return * @return
*/ */
ConstStorageAccessor& operator= (ConstStorageAccessor&&); ConstStorageAccessor& operator= (ConstStorageAccessor&&);
ConstStorageAccessor(ConstStorageAccessor&&); ConstStorageAccessor(ConstStorageAccessor&&);
//! The copy ctor and copy assignemnt should be deleted implicitely //! The copy ctor and copy assignemnt should be deleted implicitely
//! according to https://foonathan.net/2019/02/special-member-functions/ //! according to https://foonathan.net/2019/02/special-member-functions/
//! but I still deleted them to make it more explicit. (remember rule of 5). //! but I still deleted them to make it more explicit. (remember rule of 5).
ConstStorageAccessor& operator=(const ConstStorageAccessor&) = delete; ConstStorageAccessor& operator=(const ConstStorageAccessor&) = delete;
ConstStorageAccessor(const ConstStorageAccessor&) = delete; ConstStorageAccessor(const ConstStorageAccessor&) = delete;
protected: protected:
const uint8_t* constDataPointer = nullptr; const uint8_t* constDataPointer = nullptr;
store_address_t storeId; store_address_t storeId;
size_t size_ = 0; size_t size_ = 0;
//! Managing pool, has to assign itself. //! Managing pool, has to assign itself.
StorageManagerIF* store = nullptr; StorageManagerIF* store = nullptr;
bool deleteData = true; bool deleteData = true;
enum class AccessState { enum class AccessState {
UNINIT, UNINIT,
ASSIGNED ASSIGNED
}; };
//! Internal state for safety reasons. //! Internal state for safety reasons.
AccessState internalState = AccessState::UNINIT; AccessState internalState = AccessState::UNINIT;
/** /**
* Used by the pool manager instances to assign themselves to the * Used by the pool manager instances to assign themselves to the
* accessor. This is necessary to delete the data when the acessor * accessor. This is necessary to delete the data when the acessor
* exits the scope ! The internal state will be considered read * exits the scope ! The internal state will be considered read
* when this function is called, so take care all data is set properly as * when this function is called, so take care all data is set properly as
* well. * well.
* @param * @param
*/ */
void assignStore(StorageManagerIF*); void assignStore(StorageManagerIF*);
}; };
#endif /* FRAMEWORK_STORAGEMANAGER_CONSTSTORAGEACCESSOR_H_ */ #endif /* FRAMEWORK_STORAGEMANAGER_CONSTSTORAGEACCESSOR_H_ */

134
storagemanager/StorageAccessor.cpp
View File

@ -1,67 +1,67 @@
#include "../storagemanager/StorageAccessor.h" #include "../storagemanager/StorageAccessor.h"
#include "../storagemanager/StorageManagerIF.h" #include "../storagemanager/StorageManagerIF.h"
#include "../serviceinterface/ServiceInterfaceStream.h" #include "../serviceinterface/ServiceInterfaceStream.h"
StorageAccessor::StorageAccessor(store_address_t storeId): StorageAccessor::StorageAccessor(store_address_t storeId):
ConstStorageAccessor(storeId) { ConstStorageAccessor(storeId) {
} }
StorageAccessor::StorageAccessor(store_address_t storeId, StorageAccessor::StorageAccessor(store_address_t storeId,
StorageManagerIF* store): StorageManagerIF* store):
ConstStorageAccessor(storeId, store) { ConstStorageAccessor(storeId, store) {
} }
StorageAccessor& StorageAccessor::operator =( StorageAccessor& StorageAccessor::operator =(
StorageAccessor&& other) { StorageAccessor&& other) {
// Call the parent move assignment and also assign own member. // Call the parent move assignment and also assign own member.
dataPointer = other.dataPointer; dataPointer = other.dataPointer;
StorageAccessor::operator=(std::move(other)); StorageAccessor::operator=(std::move(other));
return * this; return * this;
} }
// Call the parent move ctor and also transfer own member. // Call the parent move ctor and also transfer own member.
StorageAccessor::StorageAccessor(StorageAccessor&& other): StorageAccessor::StorageAccessor(StorageAccessor&& other):
ConstStorageAccessor(std::move(other)), dataPointer(other.dataPointer) { ConstStorageAccessor(std::move(other)), dataPointer(other.dataPointer) {
} }
ReturnValue_t StorageAccessor::getDataCopy(uint8_t *pointer, size_t maxSize) { ReturnValue_t StorageAccessor::getDataCopy(uint8_t *pointer, size_t maxSize) {
if(internalState == AccessState::UNINIT) { if(internalState == AccessState::UNINIT) {
sif::warning << "StorageAccessor: Not initialized!" << std::endl; sif::warning << "StorageAccessor: Not initialized!" << std::endl;
return HasReturnvaluesIF::RETURN_FAILED; return HasReturnvaluesIF::RETURN_FAILED;
} }
if(size_ > maxSize) { if(size_ > maxSize) {
sif::error << "StorageAccessor: Supplied buffer not large " sif::error << "StorageAccessor: Supplied buffer not large "
"enough" << std::endl; "enough" << std::endl;
return HasReturnvaluesIF::RETURN_FAILED; return HasReturnvaluesIF::RETURN_FAILED;
} }
std::copy(dataPointer, dataPointer + size_, pointer); std::copy(dataPointer, dataPointer + size_, pointer);
return HasReturnvaluesIF::RETURN_OK; return HasReturnvaluesIF::RETURN_OK;
} }
uint8_t* StorageAccessor::data() { uint8_t* StorageAccessor::data() {
if(internalState == AccessState::UNINIT) { if(internalState == AccessState::UNINIT) {
sif::warning << "StorageAccessor: Not initialized!" << std::endl; sif::warning << "StorageAccessor: Not initialized!" << std::endl;
} }
return dataPointer; return dataPointer;
} }
ReturnValue_t StorageAccessor::write(uint8_t *data, size_t size, ReturnValue_t StorageAccessor::write(uint8_t *data, size_t size,
uint16_t offset) { uint16_t offset) {
if(internalState == AccessState::UNINIT) { if(internalState == AccessState::UNINIT) {
sif::warning << "StorageAccessor: Not initialized!" << std::endl; sif::warning << "StorageAccessor: Not initialized!" << std::endl;
return HasReturnvaluesIF::RETURN_FAILED; return HasReturnvaluesIF::RETURN_FAILED;
} }
if(offset + size > size_) { if(offset + size > size_) {
sif::error << "StorageAccessor: Data too large for pool " sif::error << "StorageAccessor: Data too large for pool "
"entry!" << std::endl; "entry!" << std::endl;
return HasReturnvaluesIF::RETURN_FAILED; return HasReturnvaluesIF::RETURN_FAILED;
} }
std::copy(data, data + size, dataPointer + offset); std::copy(data, data + size, dataPointer + offset);
return HasReturnvaluesIF::RETURN_OK; return HasReturnvaluesIF::RETURN_OK;
} }
void StorageAccessor::assignConstPointer() { void StorageAccessor::assignConstPointer() {
constDataPointer = dataPointer; constDataPointer = dataPointer;
} }

90
storagemanager/StorageAccessor.h
View File

@ -1,45 +1,45 @@
#ifndef FRAMEWORK_STORAGEMANAGER_STORAGEACCESSOR_H_ #ifndef FRAMEWORK_STORAGEMANAGER_STORAGEACCESSOR_H_
#define FRAMEWORK_STORAGEMANAGER_STORAGEACCESSOR_H_ #define FRAMEWORK_STORAGEMANAGER_STORAGEACCESSOR_H_
#include "../storagemanager/ConstStorageAccessor.h" #include "../storagemanager/ConstStorageAccessor.h"
class StorageManagerIF; class StorageManagerIF;
/** /**
* @brief Child class for modifyable data. Also has a normal pointer member. * @brief Child class for modifyable data. Also has a normal pointer member.
*/ */
class StorageAccessor: public ConstStorageAccessor { class StorageAccessor: public ConstStorageAccessor {
//! StorageManager classes have exclusive access to private variables. //! StorageManager classes have exclusive access to private variables.
template<uint8_t NUMBER_OF_POOLS> template<uint8_t NUMBER_OF_POOLS>
friend class PoolManager; friend class PoolManager;
template<uint8_t NUMBER_OF_POOLS> template<uint8_t NUMBER_OF_POOLS>
friend class LocalPool; friend class LocalPool;
public: public:
StorageAccessor(store_address_t storeId); StorageAccessor(store_address_t storeId);
StorageAccessor(store_address_t storeId, StorageManagerIF* store); StorageAccessor(store_address_t storeId, StorageManagerIF* store);
/** /**
* @brief Move ctor and move assignment allow returning accessors as * @brief Move ctor and move assignment allow returning accessors as
* a returnvalue. They prevent resource being freed prematurely. * a returnvalue. They prevent resource being freed prematurely.
* See: https://github.com/MicrosoftDocs/cpp-docs/blob/master/docs/cpp/ * See: https://github.com/MicrosoftDocs/cpp-docs/blob/master/docs/cpp/
* move-constructors-and-move-assignment-operators-cpp.md * move-constructors-and-move-assignment-operators-cpp.md
* @param * @param
* @return * @return
*/ */
StorageAccessor& operator=(StorageAccessor&&); StorageAccessor& operator=(StorageAccessor&&);
StorageAccessor(StorageAccessor&&); StorageAccessor(StorageAccessor&&);
ReturnValue_t write(uint8_t *data, size_t size, ReturnValue_t write(uint8_t *data, size_t size,
uint16_t offset = 0); uint16_t offset = 0);
uint8_t* data(); uint8_t* data();
ReturnValue_t getDataCopy(uint8_t *pointer, size_t maxSize) override; ReturnValue_t getDataCopy(uint8_t *pointer, size_t maxSize) override;
private: private:
//! Non-const pointer for modifyable data. //! Non-const pointer for modifyable data.
uint8_t* dataPointer = nullptr; uint8_t* dataPointer = nullptr;
//! For modifyable data, the const pointer is assigned to the normal //! For modifyable data, the const pointer is assigned to the normal
//! pointer by the pool manager so both access functions can be used safely //! pointer by the pool manager so both access functions can be used safely
void assignConstPointer(); void assignConstPointer();
}; };
#endif /* TEST_PROTOTYPES_STORAGEACCESSOR_H_ */ #endif /* TEST_PROTOTYPES_STORAGEACCESSOR_H_ */

334
storagemanager/StorageManagerIF.h
View File

@ -1,167 +1,167 @@
#ifndef STORAGEMANAGERIF_H_H #ifndef STORAGEMANAGERIF_H_H
#define STORAGEMANAGERIF_H_H #define STORAGEMANAGERIF_H_H
#include "../events/Event.h" #include "../events/Event.h"
#include "../returnvalues/HasReturnvaluesIF.h" #include "../returnvalues/HasReturnvaluesIF.h"
#include "../storagemanager/StorageAccessor.h" #include "../storagemanager/StorageAccessor.h"
#include "../storagemanager/storeAddress.h" #include "../storagemanager/storeAddress.h"
#include <utility> #include <utility>
#include <cstddef> #include <cstddef>
using AccessorPair = std::pair<ReturnValue_t, StorageAccessor>; using AccessorPair = std::pair<ReturnValue_t, StorageAccessor>;
using ConstAccessorPair = std::pair<ReturnValue_t, ConstStorageAccessor>; using ConstAccessorPair = std::pair<ReturnValue_t, ConstStorageAccessor>;
/** /**
* @brief This class provides an interface for intermediate data storage. * @brief This class provides an interface for intermediate data storage.
* @details The Storage manager classes shall be used to store larger chunks of * @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 in RAM for exchange between tasks. This interface expects the
* data to be stored in one consecutive block of memory, so tasks can * data to be stored in one consecutive block of memory, so tasks can
* write directly to the destination pointer. * write directly to the destination pointer.
* For interprocess communication, the stores must be locked during * For interprocess communication, the stores must be locked during
* insertion and deletion. If the receiving storage identifier is * insertion and deletion. If the receiving storage identifier is
* passed token-like between tasks, a lock during read and write * passed token-like between tasks, a lock during read and write
* operations is not necessary. * operations is not necessary.
* @author Bastian Baetz * @author Bastian Baetz
* @date 18.09.2012 * @date 18.09.2012
*/ */
class StorageManagerIF : public HasReturnvaluesIF { class StorageManagerIF : public HasReturnvaluesIF {
public: public:
static const uint8_t INTERFACE_ID = CLASS_ID::STORAGE_MANAGER_IF; //!< The unique ID for return codes for this interface. 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_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 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 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 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 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 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 uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::OBSW;
static const Event GET_DATA_FAILED = MAKE_EVENT(0, SEVERITY::LOW); static const Event GET_DATA_FAILED = MAKE_EVENT(0, SEVERITY::LOW);
static const Event STORE_DATA_FAILED = MAKE_EVENT(1, 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. 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. * @brief This is the empty virtual destructor as required for C++ interfaces.
*/ */
virtual ~StorageManagerIF() { virtual ~StorageManagerIF() {
} }
; ;
/** /**
* @brief With addData, a free storage position is allocated and data * @brief With addData, a free storage position is allocated and data
* stored there. * stored there.
* @details During the allocation, the StorageManager is blocked. * @details During the allocation, the StorageManager is blocked.
* @param storageId A pointer to the storageId to retrieve. * @param storageId A pointer to the storageId to retrieve.
* @param data The data to be stored in the StorageManager. * @param data The data to be stored in the StorageManager.
* @param size The amount of data to be stored. * @param size The amount of data to be stored.
* @return Returns @li RETURN_OK if data was added. * @return Returns @li RETURN_OK if data was added.
* @li RETURN_FAILED if data could not be added. * @li RETURN_FAILED if data could not be added.
* storageId is unchanged then. * storageId is unchanged then.
*/ */
virtual ReturnValue_t addData(store_address_t* storageId, virtual ReturnValue_t addData(store_address_t* storageId,
const uint8_t * data, size_t size, bool ignoreFault = false) = 0; const uint8_t * data, size_t size, bool ignoreFault = false) = 0;
/** /**
* @brief With deleteData, the storageManager frees the memory region * @brief With deleteData, the storageManager frees the memory region
* identified by packet_id. * identified by packet_id.
* @param packet_id The identifier of the memory region to be freed. * @param packet_id The identifier of the memory region to be freed.
* @return @li RETURN_OK on success. * @return @li RETURN_OK on success.
* @li RETURN_FAILED if deletion did not work * @li RETURN_FAILED if deletion did not work
* (e.g. an illegal packet_id was passed). * (e.g. an illegal packet_id was passed).
*/ */
virtual ReturnValue_t deleteData(store_address_t packet_id) = 0; virtual ReturnValue_t deleteData(store_address_t packet_id) = 0;
/** /**
* @brief Another deleteData which uses the pointer and size of the * @brief Another deleteData which uses the pointer and size of the
* stored data to delete the content. * stored data to delete the content.
* @param buffer Pointer to the data. * @param buffer Pointer to the data.
* @param size Size of data to be stored. * @param size Size of data to be stored.
* @param storeId Store id of the deleted element (optional) * @param storeId Store id of the deleted element (optional)
* @return @li RETURN_OK on success. * @return @li RETURN_OK on success.
* @li failure code if deletion did not work * @li failure code if deletion did not work
*/ */
virtual ReturnValue_t deleteData(uint8_t* buffer, size_t size, virtual ReturnValue_t deleteData(uint8_t* buffer, size_t size,
store_address_t* storeId = nullptr) = 0; store_address_t* storeId = nullptr) = 0;
/** /**
* @brief Access the data by supplying a store ID. * @brief Access the data by supplying a store ID.
* @details * @details
* A pair consisting of the retrieval result and an instance of a * A pair consisting of the retrieval result and an instance of a
* ConstStorageAccessor class is returned * ConstStorageAccessor class is returned
* @param storeId * @param storeId
* @return Pair of return value and a ConstStorageAccessor instance * @return Pair of return value and a ConstStorageAccessor instance
*/ */
virtual ConstAccessorPair getData(store_address_t storeId) = 0; virtual ConstAccessorPair getData(store_address_t storeId) = 0;
/** /**
* @brief Access the data by supplying a store ID and a helper * @brief Access the data by supplying a store ID and a helper
* instance * instance
* @param storeId * @param storeId
* @param constAccessor Wrapper function to access store data. * @param constAccessor Wrapper function to access store data.
* @return * @return
*/ */
virtual ReturnValue_t getData(store_address_t storeId, virtual ReturnValue_t getData(store_address_t storeId,
ConstStorageAccessor& constAccessor) = 0; ConstStorageAccessor& constAccessor) = 0;
/** /**
* @brief getData returns an address to data and the size of the data * @brief getData returns an address to data and the size of the data
* for a given packet_id. * for a given packet_id.
* @param packet_id The id of the data to be returned * @param packet_id The id of the data to be returned
* @param packet_ptr The passed pointer address is set to the the memory * @param packet_ptr The passed pointer address is set to the the memory
* position * position
* @param size The exact size of the stored data is returned here. * @param size The exact size of the stored data is returned here.
* @return @li RETURN_OK on success. * @return @li RETURN_OK on success.
* @li RETURN_FAILED if fetching data did not work * @li RETURN_FAILED if fetching data did not work
* (e.g. an illegal packet_id was passed). * (e.g. an illegal packet_id was passed).
*/ */
virtual ReturnValue_t getData(store_address_t packet_id, virtual ReturnValue_t getData(store_address_t packet_id,
const uint8_t** packet_ptr, size_t* size) = 0; const uint8_t** packet_ptr, size_t* size) = 0;
/** /**
* Modify data by supplying a store ID * Modify data by supplying a store ID
* @param storeId * @param storeId
* @return Pair of return value and StorageAccessor helper * @return Pair of return value and StorageAccessor helper
*/ */
virtual AccessorPair modifyData(store_address_t storeId) = 0; virtual AccessorPair modifyData(store_address_t storeId) = 0;
/** /**
* Modify data by supplying a store ID and a StorageAccessor helper instance. * Modify data by supplying a store ID and a StorageAccessor helper instance.
* @param storeId * @param storeId
* @param accessor Helper class to access the modifiable data. * @param accessor Helper class to access the modifiable data.
* @return * @return
*/ */
virtual ReturnValue_t modifyData(store_address_t storeId, virtual ReturnValue_t modifyData(store_address_t storeId,
StorageAccessor& accessor) = 0; StorageAccessor& accessor) = 0;
/** /**
* Get pointer and size of modifiable data by supplying the storeId * Get pointer and size of modifiable data by supplying the storeId
* @param packet_id * @param packet_id
* @param packet_ptr [out] Pointer to pointer of data to set * @param packet_ptr [out] Pointer to pointer of data to set
* @param size [out] Pointer to size to set * @param size [out] Pointer to size to set
* @return * @return
*/ */
virtual ReturnValue_t modifyData(store_address_t packet_id, virtual ReturnValue_t modifyData(store_address_t packet_id,
uint8_t** packet_ptr, size_t* size) = 0; uint8_t** packet_ptr, size_t* size) = 0;
/** /**
* This method reserves an element of \c size. * This method reserves an element of \c size.
* *
* It returns the packet id of this element as well as a direct pointer to the * 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 * data of the element. It must be assured that exactly \c size data is
* written to p_data! * written to p_data!
* @param storageId A pointer to the storageId to retrieve. * @param storageId A pointer to the storageId to retrieve.
* @param size The size of the space to be reserved. * @param size The size of the space to be reserved.
* @param p_data A pointer to the element data is returned here. * @param p_data A pointer to the element data is returned here.
* @return Returns @li RETURN_OK if data was added. * @return Returns @li RETURN_OK if data was added.
* @li RETURN_FAILED if data could not be added. * @li RETURN_FAILED if data could not be added.
* storageId is unchanged then. * storageId is unchanged then.
*/ */
virtual ReturnValue_t getFreeElement(store_address_t* storageId, virtual ReturnValue_t getFreeElement(store_address_t* storageId,
const size_t size, uint8_t** p_data, bool ignoreFault = false ) = 0; const size_t size, uint8_t** p_data, bool ignoreFault = false ) = 0;
/** /**
* Clears the whole store. * Clears the whole store.
* Use with care! * Use with care!
*/ */
virtual void clearStore() = 0; virtual void clearStore() = 0;
}; };
#endif /* STORAGEMANAGERIF_H_ */ #endif /* STORAGEMANAGERIF_H_ */