221 lines
8.6 KiB
C++
221 lines
8.6 KiB
C++
#ifndef FSFW_STORAGEMANAGER_STORAGEMANAGERIF_H_
|
|
#define FSFW_STORAGEMANAGER_STORAGEMANAGERIF_H_
|
|
|
|
#include <cstddef>
|
|
#include <utility>
|
|
|
|
#include "../events/Event.h"
|
|
#include "../returnvalues/returnvalue.h"
|
|
#include "StorageAccessor.h"
|
|
#include "storeAddress.h"
|
|
|
|
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:
|
|
using size_type = size_t;
|
|
using max_subpools_t = uint8_t;
|
|
|
|
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);
|
|
|
|
//!< Indicates an invalid (i.e unused) storage address.
|
|
static const uint32_t INVALID_ADDRESS = 0xFFFFFFFF;
|
|
|
|
/**
|
|
* @brief This is the empty virtual destructor as required for C++ interfaces.
|
|
*/
|
|
virtual ~StorageManagerIF() = default;
|
|
/**
|
|
* @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 @returnvalue::OK if data was added.
|
|
* @returnvalue::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) = 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 returnvalue::OK on success.
|
|
* @li returnvalue::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 returnvalue::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) = 0;
|
|
virtual ReturnValue_t deleteData(uint8_t* buffer, size_t size) {
|
|
return deleteData(buffer, size, nullptr);
|
|
}
|
|
/**
|
|
* @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) {
|
|
uint8_t* tempData = nullptr;
|
|
ConstStorageAccessor constAccessor(storeId, this);
|
|
ReturnValue_t status = modifyData(storeId, &tempData, &constAccessor.size_);
|
|
constAccessor.constDataPointer = tempData;
|
|
return {status, std::move(constAccessor)};
|
|
}
|
|
|
|
/**
|
|
* @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& accessor) {
|
|
uint8_t* tempData = nullptr;
|
|
ReturnValue_t status = modifyData(storeId, &tempData, &accessor.size_);
|
|
accessor.assignStore(this);
|
|
accessor.constDataPointer = tempData;
|
|
return status;
|
|
}
|
|
|
|
/**
|
|
* @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 @returnvalue::OK on success.
|
|
* @returnvalue::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) {
|
|
StorageAccessor accessor(storeId, this);
|
|
ReturnValue_t status = modifyData(storeId, &accessor.dataPointer, &accessor.size_);
|
|
accessor.assignConstPointer();
|
|
return {status, std::move(accessor)};
|
|
}
|
|
|
|
/**
|
|
* 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) {
|
|
accessor.assignStore(this);
|
|
ReturnValue_t status = modifyData(storeId, &accessor.dataPointer, &accessor.size_);
|
|
accessor.assignConstPointer();
|
|
return status;
|
|
}
|
|
|
|
/**
|
|
* 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 dataPtr A pointer to the element data is returned here.
|
|
* @return Returns @returnvalue::OK if data was added.
|
|
* @returnvalue::FAILED if data could not be added, storageId is unchanged then.
|
|
*/
|
|
virtual ReturnValue_t getFreeElement(store_address_t* storageId, size_t size, uint8_t** dataPtr) = 0;
|
|
|
|
[[nodiscard]] virtual bool hasDataAtId(store_address_t storeId) const = 0;
|
|
|
|
/**
|
|
* Clears the whole store.
|
|
* Use with care!
|
|
*/
|
|
virtual void clearStore() = 0;
|
|
|
|
/**
|
|
* Clears a pool in the store with the given pool index. Use with care!
|
|
* @param pageIndex
|
|
*/
|
|
virtual void clearSubPool(uint8_t poolIndex) = 0;
|
|
|
|
/**
|
|
* Get the fill count of the pool. Each character inside the provided
|
|
* buffer will be assigned to a rounded percentage fill count for each
|
|
* page. The last written byte (at the index bytesWritten - 1)
|
|
* will contain the total fill count of the pool as a mean of the
|
|
* percentages of single pages.
|
|
* @param buffer
|
|
* @param maxSize
|
|
*/
|
|
virtual void getFillCount(uint8_t* buffer, uint8_t* bytesWritten) = 0;
|
|
|
|
virtual size_t getTotalSize(size_t* additionalSize) = 0;
|
|
|
|
/**
|
|
* Get number of pools.
|
|
* @return
|
|
*/
|
|
[[nodiscard]] virtual max_subpools_t getNumberOfSubPools() const = 0;
|
|
};
|
|
|
|
#endif /* FSFW_STORAGEMANAGER_STORAGEMANAGERIF_H_ */
|