const store accessor in separate file now

storagemanager/ConstStoreAccessor.cpp

@@ -0,0 +1,93 @@
+#include <framework/storagemanager/ConstStoreAccessor.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include <framework/storagemanager/StorageManagerIF.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) {
+		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::ASSIGNED;
+	this->store = store;
+}

storagemanager/ConstStoreAccessor.h

@@ -0,0 +1,116 @@
+#ifndef FRAMEWORK_STORAGEMANAGER_CONSTSTOREACCESSOR_H_
+#define FRAMEWORK_STORAGEMANAGER_CONSTSTOREACCESSOR_H_
+
+#include <framework/storagemanager/storeAddress.h>
+#include <framework/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= (ConstStorageAccessor&) = delete;
+	ConstStorageAccessor (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_CONSTSTOREACCESSOR_H_ */

storagemanager/StorageAccessor.cpp

@@ -1,96 +1,6 @@
 #include <framework/storagemanager/StorageAccessor.h>
 #include <framework/storagemanager/StorageManagerIF.h>
-
+#include <framework/serviceinterface/ServiceInterfaceStream.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) {
-		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::ASSIGNED;
-	this->store = store;
-}
-
 
 StorageAccessor::StorageAccessor(store_address_t storeId):
 		ConstStorageAccessor(storeId) {
@@ -120,7 +30,8 @@ ReturnValue_t StorageAccessor::getDataCopy(uint8_t *pointer, size_t maxSize) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	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;
 	}
 	std::copy(dataPointer, dataPointer + size_, pointer);
@@ -141,7 +52,8 @@ ReturnValue_t StorageAccessor::write(uint8_t *data, size_t size,
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	if(offset + size > size_) {
-		sif::error << "StorageAccessor: Data too large for pool entry!" << std::endl;
+		sif::error << "StorageAccessor: Data too large for pool "
+				"entry!" << std::endl;
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	std::copy(data, data + size, dataPointer + offset);

storagemanager/StorageAccessor.h

@@ -1,117 +1,10 @@
 #ifndef FRAMEWORK_STORAGEMANAGER_STORAGEACCESSOR_H_
 #define FRAMEWORK_STORAGEMANAGER_STORAGEACCESSOR_H_
 
-#include <framework/ipc/MutexHelper.h>
+#include <framework/storagemanager/ConstStoreAccessor.h>
-#include <framework/storagemanager/storeAddress.h>
 
 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= (ConstStorageAccessor&) = delete;
-	ConstStorageAccessor (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*);
-};
-
-
 /**
  * @brief   Child class for modifyable data. Also has a normal pointer member.
  */