renormalized line endings
This commit is contained in:
@ -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;
|
||||
}
|
||||
|
||||
@ -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_ */
|
||||
|
||||
@ -1,189 +1,189 @@
|
||||
#ifndef FRAMEWORK_STORAGEMANAGER_LOCALPOOL_H_
|
||||
#define FRAMEWORK_STORAGEMANAGER_LOCALPOOL_H_
|
||||
|
||||
#include "../objectmanager/SystemObject.h"
|
||||
#include "../serviceinterface/ServiceInterfaceStream.h"
|
||||
#include "../storagemanager/StorageManagerIF.h"
|
||||
#include "../objectmanager/ObjectManagerIF.h"
|
||||
#include "../internalError/InternalErrorReporterIF.h"
|
||||
#include "../storagemanager/StorageAccessor.h"
|
||||
#include <cstring>
|
||||
|
||||
/**
|
||||
* @brief The LocalPool class provides an intermediate data storage with
|
||||
* a fixed pool size policy.
|
||||
* @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.
|
||||
* The overhead is 4 byte per pool element to store the size
|
||||
* information of each stored element.
|
||||
* To maintain an "empty" information, the pool size is limited to
|
||||
* 0xFFFF-1 bytes.
|
||||
* It is possible to store empty packets in the pool.
|
||||
* The local pool is NOT thread-safe.
|
||||
* @author Bastian Baetz
|
||||
*/
|
||||
template<uint8_t NUMBER_OF_POOLS = 5>
|
||||
class LocalPool: public SystemObject, public StorageManagerIF {
|
||||
public:
|
||||
/**
|
||||
* @brief This definition generally sets the number of different sized pools.
|
||||
* @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;
|
||||
|
||||
ConstAccessorPair getData(store_address_t packet_id) override;
|
||||
ReturnValue_t getData(store_address_t packet_id, ConstStorageAccessor&) override;
|
||||
ReturnValue_t getData(store_address_t packet_id, const uint8_t** packet_ptr,
|
||||
size_t * size) override;
|
||||
|
||||
AccessorPair modifyData(store_address_t packet_id) override;
|
||||
ReturnValue_t modifyData(store_address_t packet_id, StorageAccessor&) 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.
|
||||
* This value limits the maximum size of a pool. Change to larger data type
|
||||
* if increase is required.
|
||||
*/
|
||||
static const uint32_t STORAGE_FREE = 0xFFFFFFFF;
|
||||
/**
|
||||
* @brief In this array, the element sizes of each pool is stored.
|
||||
* @details The sizes are maintained for internal pool management. The sizes
|
||||
* must be set in ascending order on construction.
|
||||
*/
|
||||
uint32_t element_sizes[NUMBER_OF_POOLS];
|
||||
/**
|
||||
* @brief n_elements stores the number of elements per pool.
|
||||
* @details These numbers are maintained for internal pool management.
|
||||
*/
|
||||
uint16_t n_elements[NUMBER_OF_POOLS];
|
||||
/**
|
||||
* @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.
|
||||
*/
|
||||
uint8_t* store[NUMBER_OF_POOLS];
|
||||
/**
|
||||
* @brief The size_list attribute stores the size values of every pool element.
|
||||
* @details As the number of elements is determined on construction, the size list
|
||||
* is also dynamically allocated there.
|
||||
*/
|
||||
uint32_t* size_list[NUMBER_OF_POOLS];
|
||||
//! A variable to determine whether higher n pools are used if
|
||||
//! the store is full.
|
||||
bool spillsToHigherPools;
|
||||
/**
|
||||
* @brief This method safely stores the given data in the given packet_id.
|
||||
* @details It also sets the size in size_list. The method does not perform
|
||||
* any range checks, these are done in advance.
|
||||
* @param packet_id The storage identifier in which the data shall be stored.
|
||||
* @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, 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.
|
||||
* @return Returns the size of an element or 0.
|
||||
*/
|
||||
uint32_t getPageSize(uint16_t pool_index);
|
||||
/**
|
||||
* @brief This helper method looks up a fitting pool for a given size.
|
||||
* @details The pools are looked up in ascending order, so the first that
|
||||
* fits is used.
|
||||
* @param packet_size The size of the data to be stored.
|
||||
* @return Returns the pool that fits or StorageManagerIF::INVALID_ADDRESS.
|
||||
*/
|
||||
/**
|
||||
* @brief This helper method looks up a fitting pool for a given size.
|
||||
* @details The pools are looked up in ascending order, so the first that
|
||||
* fits is used.
|
||||
* @param packet_size The size of the data to be stored.
|
||||
* @param[out] poolIndex The fitting pool index found.
|
||||
* @return - #RETURN_OK on success,
|
||||
* - #DATA_TOO_LARGE otherwise.
|
||||
*/
|
||||
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.
|
||||
* @details The method does not perform any range checks, these are done in
|
||||
* advance.
|
||||
* @param packet_id The packet id to look up.
|
||||
* @return Returns the position of the data in store.
|
||||
*/
|
||||
uint32_t getRawPosition(store_address_t packet_id);
|
||||
/**
|
||||
* @brief This is a helper method to find an empty element in a given pool.
|
||||
* @details The method searches size_list for the first empty element, so
|
||||
* duration grows with the fill level of the pool.
|
||||
* @param pool_index The pool in which the search is performed.
|
||||
* @param[out] element The first found element in the pool.
|
||||
* @return - #RETURN_OK on success,
|
||||
* - #DATA_STORAGE_FULL if the store is full
|
||||
*/
|
||||
ReturnValue_t findEmpty(uint16_t pool_index, uint16_t* element);
|
||||
};
|
||||
|
||||
#include "../storagemanager/LocalPool.tpp"
|
||||
|
||||
#endif /* FRAMEWORK_STORAGEMANAGER_LOCALPOOL_H_ */
|
||||
#ifndef FRAMEWORK_STORAGEMANAGER_LOCALPOOL_H_
|
||||
#define FRAMEWORK_STORAGEMANAGER_LOCALPOOL_H_
|
||||
|
||||
#include "../objectmanager/SystemObject.h"
|
||||
#include "../serviceinterface/ServiceInterfaceStream.h"
|
||||
#include "../storagemanager/StorageManagerIF.h"
|
||||
#include "../objectmanager/ObjectManagerIF.h"
|
||||
#include "../internalError/InternalErrorReporterIF.h"
|
||||
#include "../storagemanager/StorageAccessor.h"
|
||||
#include <cstring>
|
||||
|
||||
/**
|
||||
* @brief The LocalPool class provides an intermediate data storage with
|
||||
* a fixed pool size policy.
|
||||
* @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.
|
||||
* The overhead is 4 byte per pool element to store the size
|
||||
* information of each stored element.
|
||||
* To maintain an "empty" information, the pool size is limited to
|
||||
* 0xFFFF-1 bytes.
|
||||
* It is possible to store empty packets in the pool.
|
||||
* The local pool is NOT thread-safe.
|
||||
* @author Bastian Baetz
|
||||
*/
|
||||
template<uint8_t NUMBER_OF_POOLS = 5>
|
||||
class LocalPool: public SystemObject, public StorageManagerIF {
|
||||
public:
|
||||
/**
|
||||
* @brief This definition generally sets the number of different sized pools.
|
||||
* @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;
|
||||
|
||||
ConstAccessorPair getData(store_address_t packet_id) override;
|
||||
ReturnValue_t getData(store_address_t packet_id, ConstStorageAccessor&) override;
|
||||
ReturnValue_t getData(store_address_t packet_id, const uint8_t** packet_ptr,
|
||||
size_t * size) override;
|
||||
|
||||
AccessorPair modifyData(store_address_t packet_id) override;
|
||||
ReturnValue_t modifyData(store_address_t packet_id, StorageAccessor&) 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.
|
||||
* This value limits the maximum size of a pool. Change to larger data type
|
||||
* if increase is required.
|
||||
*/
|
||||
static const uint32_t STORAGE_FREE = 0xFFFFFFFF;
|
||||
/**
|
||||
* @brief In this array, the element sizes of each pool is stored.
|
||||
* @details The sizes are maintained for internal pool management. The sizes
|
||||
* must be set in ascending order on construction.
|
||||
*/
|
||||
uint32_t element_sizes[NUMBER_OF_POOLS];
|
||||
/**
|
||||
* @brief n_elements stores the number of elements per pool.
|
||||
* @details These numbers are maintained for internal pool management.
|
||||
*/
|
||||
uint16_t n_elements[NUMBER_OF_POOLS];
|
||||
/**
|
||||
* @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.
|
||||
*/
|
||||
uint8_t* store[NUMBER_OF_POOLS];
|
||||
/**
|
||||
* @brief The size_list attribute stores the size values of every pool element.
|
||||
* @details As the number of elements is determined on construction, the size list
|
||||
* is also dynamically allocated there.
|
||||
*/
|
||||
uint32_t* size_list[NUMBER_OF_POOLS];
|
||||
//! A variable to determine whether higher n pools are used if
|
||||
//! the store is full.
|
||||
bool spillsToHigherPools;
|
||||
/**
|
||||
* @brief This method safely stores the given data in the given packet_id.
|
||||
* @details It also sets the size in size_list. The method does not perform
|
||||
* any range checks, these are done in advance.
|
||||
* @param packet_id The storage identifier in which the data shall be stored.
|
||||
* @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, 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.
|
||||
* @return Returns the size of an element or 0.
|
||||
*/
|
||||
uint32_t getPageSize(uint16_t pool_index);
|
||||
/**
|
||||
* @brief This helper method looks up a fitting pool for a given size.
|
||||
* @details The pools are looked up in ascending order, so the first that
|
||||
* fits is used.
|
||||
* @param packet_size The size of the data to be stored.
|
||||
* @return Returns the pool that fits or StorageManagerIF::INVALID_ADDRESS.
|
||||
*/
|
||||
/**
|
||||
* @brief This helper method looks up a fitting pool for a given size.
|
||||
* @details The pools are looked up in ascending order, so the first that
|
||||
* fits is used.
|
||||
* @param packet_size The size of the data to be stored.
|
||||
* @param[out] poolIndex The fitting pool index found.
|
||||
* @return - #RETURN_OK on success,
|
||||
* - #DATA_TOO_LARGE otherwise.
|
||||
*/
|
||||
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.
|
||||
* @details The method does not perform any range checks, these are done in
|
||||
* advance.
|
||||
* @param packet_id The packet id to look up.
|
||||
* @return Returns the position of the data in store.
|
||||
*/
|
||||
uint32_t getRawPosition(store_address_t packet_id);
|
||||
/**
|
||||
* @brief This is a helper method to find an empty element in a given pool.
|
||||
* @details The method searches size_list for the first empty element, so
|
||||
* duration grows with the fill level of the pool.
|
||||
* @param pool_index The pool in which the search is performed.
|
||||
* @param[out] element The first found element in the pool.
|
||||
* @return - #RETURN_OK on success,
|
||||
* - #DATA_STORAGE_FULL if the store is full
|
||||
*/
|
||||
ReturnValue_t findEmpty(uint16_t pool_index, uint16_t* element);
|
||||
};
|
||||
|
||||
#include "../storagemanager/LocalPool.tpp"
|
||||
|
||||
#endif /* FRAMEWORK_STORAGEMANAGER_LOCALPOOL_H_ */
|
||||
|
||||
@ -1,49 +1,49 @@
|
||||
#ifndef FRAMEWORK_STORAGEMANAGER_POOLMANAGER_H_
|
||||
#define FRAMEWORK_STORAGEMANAGER_POOLMANAGER_H_
|
||||
|
||||
#include "../storagemanager/LocalPool.h"
|
||||
#include "../ipc/MutexHelper.h"
|
||||
#include "../storagemanager/StorageAccessor.h"
|
||||
|
||||
/**
|
||||
* @brief The PoolManager class provides an intermediate data storage with
|
||||
* a fixed pool size policy for inter-process communication.
|
||||
* @details Uses local pool calls but is thread safe by protecting the call
|
||||
* with a lock.
|
||||
* @author Bastian Baetz
|
||||
*/
|
||||
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. Decorator function which
|
||||
//! wraps LocalPool calls with a mutex protection.
|
||||
ReturnValue_t deleteData(store_address_t) override;
|
||||
ReturnValue_t deleteData(uint8_t* buffer, size_t size,
|
||||
store_address_t* storeId = nullptr) override;
|
||||
|
||||
protected:
|
||||
//! Default mutex timeout value to prevent permanent blocking.
|
||||
static constexpr uint32_t mutexTimeout = 50;
|
||||
|
||||
ReturnValue_t reserveSpace(const uint32_t size, store_address_t* address,
|
||||
bool ignoreFault) override;
|
||||
|
||||
/**
|
||||
* @brief The mutex is created in the constructor and makes
|
||||
* access mutual exclusive.
|
||||
* @details Locking and unlocking is done during searching for free slots
|
||||
* and deleting existing slots.
|
||||
*/
|
||||
MutexIF* mutex;
|
||||
};
|
||||
|
||||
#include "PoolManager.tpp"
|
||||
|
||||
#endif /* POOLMANAGER_H_ */
|
||||
#ifndef FRAMEWORK_STORAGEMANAGER_POOLMANAGER_H_
|
||||
#define FRAMEWORK_STORAGEMANAGER_POOLMANAGER_H_
|
||||
|
||||
#include "../storagemanager/LocalPool.h"
|
||||
#include "../ipc/MutexHelper.h"
|
||||
#include "../storagemanager/StorageAccessor.h"
|
||||
|
||||
/**
|
||||
* @brief The PoolManager class provides an intermediate data storage with
|
||||
* a fixed pool size policy for inter-process communication.
|
||||
* @details Uses local pool calls but is thread safe by protecting the call
|
||||
* with a lock.
|
||||
* @author Bastian Baetz
|
||||
*/
|
||||
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. Decorator function which
|
||||
//! wraps LocalPool calls with a mutex protection.
|
||||
ReturnValue_t deleteData(store_address_t) override;
|
||||
ReturnValue_t deleteData(uint8_t* buffer, size_t size,
|
||||
store_address_t* storeId = nullptr) override;
|
||||
|
||||
protected:
|
||||
//! Default mutex timeout value to prevent permanent blocking.
|
||||
static constexpr uint32_t mutexTimeout = 50;
|
||||
|
||||
ReturnValue_t reserveSpace(const uint32_t size, store_address_t* address,
|
||||
bool ignoreFault) override;
|
||||
|
||||
/**
|
||||
* @brief The mutex is created in the constructor and makes
|
||||
* access mutual exclusive.
|
||||
* @details Locking and unlocking is done during searching for free slots
|
||||
* and deleting existing slots.
|
||||
*/
|
||||
MutexIF* mutex;
|
||||
};
|
||||
|
||||
#include "PoolManager.tpp"
|
||||
|
||||
#endif /* POOLMANAGER_H_ */
|
||||
|
||||
@ -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;
|
||||
}
|
||||
|
||||
|
||||
|
||||
@ -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_ */
|
||||
|
||||
@ -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_ */
|
||||
|
||||
Reference in New Issue
Block a user