added new storage raw accessor

storagemanager/StorageAccessor.cpp

@@ -0,0 +1,154 @@
+#include <test/prototypes/StorageAccessor.h>
+
+ConstStorageAccessor::ConstStorageAccessor(store_address_t storeId): storeId(storeId) {}
+
+ConstStorageAccessor::~ConstStorageAccessor() {
+	if(deleteData and store != nullptr) {
+		sif::debug << "deleting store data" << std::endl;
+		store->deleteDataNonLocking(storeId);
+	}
+	if(mutexLock != nullptr) {
+		sif::debug << "unlocking mutex lock" << std::endl;
+		mutexLock.reset();
+	}
+}
+
+ConstStorageAccessor& ConstStorageAccessor::operator=(
+		ConstStorageAccessor&& other) {
+	constDataPointer = other.constDataPointer;
+	storeId = other.storeId;
+	store = other.store;
+	size_ = other.size_;
+	deleteData = other.deleteData;
+	this->store = other.store;
+	// Transfer ownership of the lock.
+	mutexLock = std::move(other.mutexLock);
+	// This prevents double deletion of the resource
+	other.mutexLock = nullptr;
+	// This prevent premature deletion
+	other.store = nullptr;
+	return *this;
+}
+
+StorageAccessor::StorageAccessor(store_address_t storeId):
+		ConstStorageAccessor(storeId) {
+}
+
+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) {
+}
+
+ConstStorageAccessor::ConstStorageAccessor(ConstStorageAccessor&& other):
+		constDataPointer(other.constDataPointer), storeId(other.storeId),
+		size_(other.size_), store(other.store), deleteData(other.deleteData),
+		internalState(other.internalState) {
+	// Transfer ownership of the lock.
+	mutexLock = std::move(other.mutexLock);
+	// This prevents double deletion of the resource. Not strictly necessary,
+	// from the testing I have conducted so far but I am not familiar enough
+	// with move semantics so I will just set the other lock to nullptr for now.
+	other.mutexLock = nullptr;
+	// This prevent premature deletion
+	other.store = nullptr;
+}
+
+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_;
+}
+
+void ConstStorageAccessor::getDataCopy(uint8_t *pointer) {
+	if(internalState == AccessState::UNINIT) {
+		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
+		return;
+	}
+	std::copy(constDataPointer, constDataPointer + size_, pointer);
+}
+
+void ConstStorageAccessor::release() {
+	deleteData = false;
+}
+
+ReturnValue_t ConstStorageAccessor::lock(MutexIF* mutex, uint32_t mutexTimeout) {
+	if(mutexLock == nullptr) {
+		mutexLock = std::unique_ptr<MutexHelper>(new MutexHelper(mutex, mutexTimeout));
+		return mutexLock.get()->getResult();
+	}
+	else {
+		sif::warning << "StorageAccessor: Attempted to lock twice. Check code!" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+void ConstStorageAccessor::unlock() {
+	if(mutexLock != nullptr) {
+		mutexLock.reset();
+	}
+}
+
+store_address_t ConstStorageAccessor::getId() const {
+	return storeId;
+}
+
+void ConstStorageAccessor::print() const {
+	if(internalState == AccessState::UNINIT) {
+		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
+		return;
+	}
+	sif::info << "StorageAccessor: Printing data: [";
+	for(uint16_t iPool = 0; iPool < size_; iPool++) {
+		sif::info << std::hex << (int)constDataPointer[iPool];
+		if(iPool < size_ - 1){
+			sif::info << " , ";
+		}
+	}
+	sif::info << " ] " << std::endl;
+}
+
+void ConstStorageAccessor::assignStore(StorageManagerIF* store) {
+	internalState = AccessState::READ;
+	this->store = store;
+}
+
+
+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);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void StorageAccessor::assignConstPointer() {
+	constDataPointer = dataPointer;
+}
+
+

storagemanager/StorageAccessor.h

@@ -0,0 +1,174 @@
+/**
+ * @brief 	Helper classes to facilitate safe access to storages which is also
+ * 			conforming to RAII principles
+ * @details	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 and unlocking the
+ * 			pool.
+ */
+#ifndef TEST_PROTOTYPES_STORAGEACCESSOR_H_
+#define TEST_PROTOTYPES_STORAGEACCESSOR_H_
+
+#include <framework/ipc/MutexHelper.h>
+#include <framework/storagemanager/StorageManagerIF.h>
+#include <memory>
+
+
+/**
+ * @brief   Accessor class which can be returned by pool managers
+ *          or passed and set by pool managers to have safe access to the pool
+ *          resources.
+ */
+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);
+
+	/**
+	 * @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= (ConstStorageAccessor&) = delete;
+	ConstStorageAccessor (ConstStorageAccessor&) = delete;
+
+	/**
+	 * @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
+	 */
+	void getDataCopy(uint8_t *pointer);
+
+	/**
+	 * @brief   Calling this will prevent the Accessor from deleting the data
+	 *          when the destructor is called.
+	 */
+	void release();
+	/**
+	 * @brief 	Locks the supplied mutex.
+	 * @details
+	 * The mutex will be unlocked automatically
+	 * when this class is destroyed (for example when exiting the scope).
+	 * Only one mutex can be locked at a time!
+	 * @param mutex
+	 * @param mutexTimeout
+	 * @return
+	 */
+	ReturnValue_t lock(MutexIF* mutex,
+			uint32_t mutexTimeout = MutexIF::NO_TIMEOUT);
+	/**
+	 * @brief	Unlocks the mutex (if one has been locked previously).
+	 *          Unless this function is called, the mutex is unlocked
+	 *          when the class exits the scope.
+	 */
+	void unlock();
+
+
+	/**
+	 * Get the size of the data
+	 * @return
+	 */
+	size_t size() const;
+
+	/**
+	 * Get the storage ID.
+	 * @return
+	 */
+	store_address_t getId() const;
+
+	void print() const;
+protected:
+	const uint8_t* constDataPointer = nullptr;
+	store_address_t storeId;
+	size_t size_ = 0;
+	//! Managing pool, has to assign itself.
+	StorageManagerIF* store = nullptr;
+	//! Unique pointer to the mutex lock instance. Is initialized by
+	//! the pool manager.
+	std::unique_ptr<MutexHelper> mutexLock = nullptr;
+	bool deleteData = true;
+
+	enum class AccessState {
+		UNINIT,
+		READ
+	};
+	//! 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*);
+
+};
+
+
+/**
+ * @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);
+	/**
+	 * @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
+	 */
+	StorageAccessor& operator= (StorageAccessor&&);
+	StorageAccessor (StorageAccessor&&);
+
+	ReturnValue_t write(uint8_t *data, size_t size,
+		uint16_t offset);
+	uint8_t* data();
+
+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_ */