175 lines
5.4 KiB
C++
175 lines
5.4 KiB
C++
///**
|
|
// * @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_ */
|