From 91cb061da941f610d2c7001ed2e47d64eaa6872f Mon Sep 17 00:00:00 2001 From: Robin Mueller Date: Mon, 28 Dec 2020 17:55:19 +0100 Subject: [PATCH] datapool updates, fixes, pool read helper --- datapool/PoolDataSetBase.cpp | 49 ++++++++++++++++++++------ datapool/PoolDataSetBase.h | 31 +++++++++++----- datapool/PoolDataSetIF.h | 6 ++-- datapool/PoolVariableIF.h | 40 ++------------------- datapool/ReadCommitIF.h | 31 ++++++++++++++++ datapoollocal/HasLocalDataPoolIF.h | 3 ++ datapoollocal/LocalDataPoolManager.cpp | 2 +- datapoollocal/LocalDataPoolManager.h | 15 ++++---- datapoollocal/LocalPoolDataSetBase.cpp | 32 ++++++++++------- datapoollocal/LocalPoolDataSetBase.h | 15 ++++++-- datapoollocal/LocalPoolVariable.tpp | 18 +++++----- datapoollocal/PoolReadHelper.h | 41 +++++++++++++++++++++ 12 files changed, 191 insertions(+), 92 deletions(-) create mode 100644 datapool/ReadCommitIF.h create mode 100644 datapoollocal/PoolReadHelper.h diff --git a/datapool/PoolDataSetBase.cpp b/datapool/PoolDataSetBase.cpp index cb2348f7..8f073359 100644 --- a/datapool/PoolDataSetBase.cpp +++ b/datapool/PoolDataSetBase.cpp @@ -9,9 +9,10 @@ PoolDataSetBase::PoolDataSetBase(PoolVariableIF** registeredVariablesArray, PoolDataSetBase::~PoolDataSetBase() {} + ReturnValue_t PoolDataSetBase::registerVariable( PoolVariableIF *variable) { - if (state != States::DATA_SET_UNINITIALISED) { + if (state != States::STATE_SET_UNINITIALISED) { sif::error << "DataSet::registerVariable: " "Call made in wrong position." << std::endl; return DataSetIF::DATA_SET_UNINITIALISED; @@ -33,15 +34,16 @@ ReturnValue_t PoolDataSetBase::registerVariable( ReturnValue_t PoolDataSetBase::read(uint32_t lockTimeout) { ReturnValue_t result = HasReturnvaluesIF::RETURN_OK; - if (state == States::DATA_SET_UNINITIALISED) { + ReturnValue_t error = result; + if (state == States::STATE_SET_UNINITIALISED) { lockDataPool(lockTimeout); for (uint16_t count = 0; count < fillCount; count++) { result = readVariable(count); if(result != RETURN_OK) { - break; + error = result; } } - state = States::DATA_SET_WAS_READ; + state = States::STATE_SET_WAS_READ; unlockDataPool(); } else { @@ -50,6 +52,10 @@ ReturnValue_t PoolDataSetBase::read(uint32_t lockTimeout) { " member datasets!" << std::endl; result = SET_WAS_ALREADY_READ; } + + if(error != HasReturnvaluesIF::RETURN_OK) { + result = error; + } return result; } @@ -71,7 +77,13 @@ ReturnValue_t PoolDataSetBase::readVariable(uint16_t count) { registeredVariables[count]->getDataPoolId() != PoolVariableIF::NO_PARAMETER) { - result = registeredVariables[count]->readWithoutLock(); + if(protectEveryReadCommitCall) { + result = registeredVariables[count]->read(mutexTimeout); + } + else { + result = registeredVariables[count]->readWithoutLock(); + } + if(result != HasReturnvaluesIF::RETURN_OK) { result = INVALID_PARAMETER_DEFINITION; } @@ -80,7 +92,7 @@ ReturnValue_t PoolDataSetBase::readVariable(uint16_t count) { } ReturnValue_t PoolDataSetBase::commit(uint32_t lockTimeout) { - if (state == States::DATA_SET_WAS_READ) { + if (state == States::STATE_SET_WAS_READ) { handleAlreadyReadDatasetCommit(lockTimeout); return HasReturnvaluesIF::RETURN_OK; } @@ -96,10 +108,15 @@ void PoolDataSetBase::handleAlreadyReadDatasetCommit(uint32_t lockTimeout) { != PoolVariableIF::VAR_READ && registeredVariables[count]->getDataPoolId() != PoolVariableIF::NO_PARAMETER) { - registeredVariables[count]->commitWithoutLock(); + if(protectEveryReadCommitCall) { + registeredVariables[count]->commit(mutexTimeout); + } + else { + registeredVariables[count]->commitWithoutLock(); + } } } - state = States::DATA_SET_UNINITIALISED; + state = States::STATE_SET_UNINITIALISED; unlockDataPool(); } @@ -111,7 +128,13 @@ ReturnValue_t PoolDataSetBase::handleUnreadDatasetCommit(uint32_t lockTimeout) { == PoolVariableIF::VAR_WRITE && registeredVariables[count]->getDataPoolId() != PoolVariableIF::NO_PARAMETER) { - registeredVariables[count]->commitWithoutLock(); + if(protectEveryReadCommitCall) { + result = registeredVariables[count]->commit(mutexTimeout); + } + else { + result = registeredVariables[count]->commitWithoutLock(); + } + } else if (registeredVariables[count]->getDataPoolId() != PoolVariableIF::NO_PARAMETER) { if (result != COMMITING_WITHOUT_READING) { @@ -121,7 +144,7 @@ ReturnValue_t PoolDataSetBase::handleUnreadDatasetCommit(uint32_t lockTimeout) { } } } - state = States::DATA_SET_UNINITIALISED; + state = States::STATE_SET_UNINITIALISED; unlockDataPool(); return result; } @@ -172,3 +195,9 @@ size_t PoolDataSetBase::getSerializedSize() const { void PoolDataSetBase::setContainer(PoolVariableIF **variablesContainer) { this->registeredVariables = variablesContainer; } + +void PoolDataSetBase::setReadCommitProtectionBehaviour( + bool protectEveryReadCommit, uint32_t mutexTimeout) { + this->protectEveryReadCommitCall = protectEveryReadCommit; + this->mutexTimeout = mutexTimeout; +} diff --git a/datapool/PoolDataSetBase.h b/datapool/PoolDataSetBase.h index a8931d62..7c1d84a4 100644 --- a/datapool/PoolDataSetBase.h +++ b/datapool/PoolDataSetBase.h @@ -44,6 +44,7 @@ public: /** * @brief The read call initializes reading out all registered variables. + * It is mandatory to call commit after every read call! * @details * It iterates through the list of registered variables and calls all read() * functions of the registered pool variables (which read out their values @@ -52,13 +53,14 @@ public: * the operation is aborted and @c INVALID_PARAMETER_DEFINITION returned. * * The data pool is locked during the whole read operation and - * freed afterwards.The state changes to "was written" after this operation. + * freed afterwards. It is mandatory to call commit after a read call, + * even if the read operation is not successful! * @return * - @c RETURN_OK if all variables were read successfully. - * - @c INVALID_PARAMETER_DEFINITION if PID, size or type of the - * requested variable is invalid. + * - @c INVALID_PARAMETER_DEFINITION if a pool entry does not exist or there + * is a type conflict. * - @c SET_WAS_ALREADY_READ if read() is called twice without calling - * commit() in between + * commit() in between */ virtual ReturnValue_t read(uint32_t lockTimeout = MutexIF::BLOCKING) override; @@ -75,7 +77,7 @@ public: * If the set does contain at least one variable which is not write-only * commit() can only be called after read(). If the set only contains * variables which are write only, commit() can be called without a - * preceding read() call. + * preceding read() call. Every read call must be followed by a commit call! * @return - @c RETURN_OK if all variables were read successfully. * - @c COMMITING_WITHOUT_READING if set was not read yet and * contains non write-only variables @@ -89,6 +91,7 @@ public: * @return */ virtual ReturnValue_t registerVariable( PoolVariableIF* variable) override; + /** * Provides the means to lock the underlying data structure to ensure * thread-safety. Default implementation is empty @@ -114,6 +117,15 @@ public: SerializeIF::Endianness streamEndianness) override; protected: + + /** + * Can be used to individually protect every read and commit call. + * @param protectEveryReadCommit + * @param mutexTimeout + */ + void setReadCommitProtectionBehaviour(bool protectEveryReadCommit, + uint32_t mutexTimeout = 20); + /** * @brief The fill_count attribute ensures that the variables * register in the correct array position and that the maximum @@ -124,14 +136,14 @@ protected: * States of the seet. */ enum class States { - DATA_SET_UNINITIALISED, //!< DATA_SET_UNINITIALISED - DATA_SET_WAS_READ //!< DATA_SET_WAS_READ + STATE_SET_UNINITIALISED, //!< DATA_SET_UNINITIALISED + STATE_SET_WAS_READ //!< DATA_SET_WAS_READ }; /** * @brief state manages the internal state of the data set, * which is important e.g. for the behavior on destruction. */ - States state = States::DATA_SET_UNINITIALISED; + States state = States::STATE_SET_UNINITIALISED; /** * @brief This array represents all pool variables registered in this set. @@ -144,6 +156,9 @@ protected: void setContainer(PoolVariableIF** variablesContainer); private: + bool protectEveryReadCommitCall = false; + uint32_t mutexTimeout = 20; + ReturnValue_t readVariable(uint16_t count); void handleAlreadyReadDatasetCommit(uint32_t lockTimeout); ReturnValue_t handleUnreadDatasetCommit(uint32_t lockTimeout); diff --git a/datapool/PoolDataSetIF.h b/datapool/PoolDataSetIF.h index aa45fa54..99c06cfd 100644 --- a/datapool/PoolDataSetIF.h +++ b/datapool/PoolDataSetIF.h @@ -1,19 +1,17 @@ #ifndef FSFW_DATAPOOL_POOLDATASETIF_H_ #define FSFW_DATAPOOL_POOLDATASETIF_H_ +#include "ReadCommitIF.h" #include "DataSetIF.h" /** * @brief Extendes the DataSetIF by adding abstract functions to lock * and unlock a data pool and read/commit semantics. */ -class PoolDataSetIF: public DataSetIF { +class PoolDataSetIF: public DataSetIF, public ReadCommitIF { public: virtual~ PoolDataSetIF() {}; - virtual ReturnValue_t read(dur_millis_t lockTimeout) = 0; - virtual ReturnValue_t commit(dur_millis_t lockTimeout) = 0; - /** * @brief Most underlying data structures will have a pool like structure * and will require a lock and unlock mechanism to ensure diff --git a/datapool/PoolVariableIF.h b/datapool/PoolVariableIF.h index cd15f744..9740fc12 100644 --- a/datapool/PoolVariableIF.h +++ b/datapool/PoolVariableIF.h @@ -3,6 +3,7 @@ #include "../returnvalues/HasReturnvaluesIF.h" #include "../serialize/SerializeIF.h" +#include "ReadCommitIF.h" /** * @brief This interface is used to control data pool @@ -17,9 +18,9 @@ * @author Bastian Baetz * @ingroup data_pool */ -class PoolVariableIF : public SerializeIF { +class PoolVariableIF : public SerializeIF, + public ReadCommitIF { friend class PoolDataSetBase; - friend class GlobDataSet; friend class LocalPoolDataSetBase; public: static constexpr uint8_t INTERFACE_ID = CLASS_ID::POOL_VARIABLE_IF; @@ -57,41 +58,6 @@ public: */ virtual void setValid(bool validity) = 0; - /** - * @brief The commit call shall write back a newly calculated local - * value to the data pool. - * @details - * It is assumed that these calls are implemented in a thread-safe manner! - */ - virtual ReturnValue_t commit(uint32_t lockTimeout) = 0; - /** - * @brief The read call shall read the value of this parameter from - * the data pool and store the content locally. - * @details - * It is assumbed that these calls are implemented in a thread-safe manner! - */ - virtual ReturnValue_t read(uint32_t lockTimeout) = 0; - -protected: - - /** - * @brief Same as commit with the difference that comitting will be - * performed without a lock - * @return - * This can be used if the lock protection is handled externally - * to avoid the overhead of locking and unlocking consecutively. - * Declared protected to avoid free public usage. - */ - virtual ReturnValue_t readWithoutLock() = 0; - /** - * @brief Same as commit with the difference that comitting will be - * performed without a lock - * @return - * This can be used if the lock protection is handled externally - * to avoid the overhead of locking and unlocking consecutively. - * Declared protected to avoid free public usage. - */ - virtual ReturnValue_t commitWithoutLock() = 0; }; using pool_rwm_t = PoolVariableIF::ReadWriteMode_t; diff --git a/datapool/ReadCommitIF.h b/datapool/ReadCommitIF.h new file mode 100644 index 00000000..0cdce371 --- /dev/null +++ b/datapool/ReadCommitIF.h @@ -0,0 +1,31 @@ +#ifndef FSFW_DATAPOOL_READCOMMITIF_H_ +#define FSFW_DATAPOOL_READCOMMITIF_H_ + +#include + +/** + * @brief Common interface for all software objects which employ read-commit + * semantics. + */ +class ReadCommitIF { +public: + virtual ~ReadCommitIF() {} + virtual ReturnValue_t read(uint32_t mutexTimeout) = 0; + virtual ReturnValue_t commit(uint32_t mutexTimeout) = 0; + +protected: + + //! Optional and protected because this is interesting for classes grouping + //! members with commit and read semantics where the lock is only necessary + //! once. + virtual ReturnValue_t readWithoutLock() { + return read(20); + } + + virtual ReturnValue_t commitWithoutLock() { + return commit(20); + } +}; + + +#endif /* FSFW_DATAPOOL_READCOMMITIF_H_ */ diff --git a/datapoollocal/HasLocalDataPoolIF.h b/datapoollocal/HasLocalDataPoolIF.h index 7f1f202e..df855110 100644 --- a/datapoollocal/HasLocalDataPoolIF.h +++ b/datapoollocal/HasLocalDataPoolIF.h @@ -44,6 +44,9 @@ public: static constexpr uint8_t INTERFACE_ID = CLASS_ID::LOCAL_POOL_OWNER_IF; + static constexpr ReturnValue_t POOL_ENTRY_NOT_FOUND = MAKE_RETURN_CODE(0x00); + static constexpr ReturnValue_t POOL_ENTRY_TYPE_CONFLICT = MAKE_RETURN_CODE(0x01); + static constexpr uint32_t INVALID_LPID = localpool::INVALID_LPID; virtual object_id_t getObjectId() const = 0; diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp index f649a362..5f0d15d3 100644 --- a/datapoollocal/LocalDataPoolManager.cpp +++ b/datapoollocal/LocalDataPoolManager.cpp @@ -577,7 +577,7 @@ ReturnValue_t LocalDataPoolManager::printPoolEntry( if (poolIter == localPoolMap.end()) { sif::debug << "HousekeepingManager::fechPoolEntry:" << " Pool entry not found." << std::endl; - return POOL_ENTRY_NOT_FOUND; + return HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND; } poolIter->second->print(); return HasReturnvaluesIF::RETURN_OK; diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h index c4024cf9..cdefa2c2 100644 --- a/datapoollocal/LocalDataPoolManager.h +++ b/datapoollocal/LocalDataPoolManager.h @@ -55,14 +55,11 @@ class LocalDataPoolManager { public: static constexpr uint8_t INTERFACE_ID = CLASS_ID::HOUSEKEEPING_MANAGER; - static constexpr ReturnValue_t POOL_ENTRY_NOT_FOUND = MAKE_RETURN_CODE(0x00); - static constexpr ReturnValue_t POOL_ENTRY_TYPE_CONFLICT = MAKE_RETURN_CODE(0x01); + static constexpr ReturnValue_t QUEUE_OR_DESTINATION_NOT_SET = MAKE_RETURN_CODE(0x0); - static constexpr ReturnValue_t QUEUE_OR_DESTINATION_NOT_SET = MAKE_RETURN_CODE(0x02); - - static constexpr ReturnValue_t WRONG_HK_PACKET_TYPE = MAKE_RETURN_CODE(0x03); - static constexpr ReturnValue_t REPORTING_STATUS_UNCHANGED = MAKE_RETURN_CODE(0x04); - static constexpr ReturnValue_t PERIODIC_HELPER_INVALID = MAKE_RETURN_CODE(0x05); + static constexpr ReturnValue_t WRONG_HK_PACKET_TYPE = MAKE_RETURN_CODE(0x01); + static constexpr ReturnValue_t REPORTING_STATUS_UNCHANGED = MAKE_RETURN_CODE(0x02); + static constexpr ReturnValue_t PERIODIC_HELPER_INVALID = MAKE_RETURN_CODE(0x03); /** * This constructor is used by a class which wants to implement @@ -380,14 +377,14 @@ ReturnValue_t LocalDataPoolManager::fetchPoolEntry(lp_id_t localPoolId, if (poolIter == localPoolMap.end()) { sif::warning << "HousekeepingManager::fechPoolEntry: Pool entry " "not found." << std::endl; - return POOL_ENTRY_NOT_FOUND; + return HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND; } *poolEntry = dynamic_cast< PoolEntry* >(poolIter->second); if(*poolEntry == nullptr) { sif::debug << "HousekeepingManager::fetchPoolEntry:" " Pool entry not found." << std::endl; - return POOL_ENTRY_TYPE_CONFLICT; + return HasLocalDataPoolIF::POOL_ENTRY_TYPE_CONFLICT; } return HasReturnvaluesIF::RETURN_OK; } diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp index 640956db..9ecad218 100644 --- a/datapoollocal/LocalPoolDataSetBase.cpp +++ b/datapoollocal/LocalPoolDataSetBase.cpp @@ -8,7 +8,7 @@ LocalPoolDataSetBase::LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner, uint32_t setId, PoolVariableIF** registeredVariablesArray, - const size_t maxNumberOfVariables, bool noPeriodicHandling): + const size_t maxNumberOfVariables, bool periodicHandling): PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables) { if(hkOwner == nullptr) { // Configuration error. @@ -23,7 +23,7 @@ LocalPoolDataSetBase::LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner, mutex = MutexFactory::instance()->createMutex(); // Data creators get a periodic helper for periodic HK data generation. - if(not noPeriodicHandling) { + if(periodicHandling) { periodicHelper = new PeriodicHousekeepingHelper(this); } } @@ -34,13 +34,9 @@ LocalPoolDataSetBase::LocalPoolDataSetBase(sid_t sid, PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables) { HasLocalDataPoolIF* hkOwner = objectManager->get( sid.objectId); - if(hkOwner == nullptr) { - // Configuration error. - sif::error << "LocalPoolDataSetBase::LocalPoolDataSetBase: Owner " - << "invalid!" << std::endl; - return; + if(hkOwner != nullptr) { + hkManager = hkOwner->getHkManagerHandle(); } - hkManager = hkOwner->getHkManagerHandle(); this->sid = sid; mutex = MutexFactory::instance()->createMutex(); @@ -50,8 +46,11 @@ LocalPoolDataSetBase::~LocalPoolDataSetBase() { } ReturnValue_t LocalPoolDataSetBase::lockDataPool(uint32_t timeoutMs) { - MutexIF* mutex = hkManager->getMutexHandle(); - return mutex->lockMutex(MutexIF::TimeoutType::WAITING, timeoutMs); + if(hkManager != nullptr) { + MutexIF* mutex = hkManager->getMutexHandle(); + return mutex->lockMutex(MutexIF::TimeoutType::WAITING, timeoutMs); + } + return HasReturnvaluesIF::RETURN_OK; } ReturnValue_t LocalPoolDataSetBase::serializeWithValidityBuffer(uint8_t **buffer, @@ -127,8 +126,11 @@ ReturnValue_t LocalPoolDataSetBase::deSerializeWithValidityBuffer( } ReturnValue_t LocalPoolDataSetBase::unlockDataPool() { - MutexIF* mutex = hkManager->getMutexHandle(); - return mutex->unlockMutex(); + if(hkManager != nullptr) { + MutexIF* mutex = hkManager->getMutexHandle(); + return mutex->unlockMutex(); + } + return HasReturnvaluesIF::RETURN_OK; } ReturnValue_t LocalPoolDataSetBase::serializeLocalPoolIds(uint8_t** buffer, @@ -276,3 +278,9 @@ void LocalPoolDataSetBase::setValidity(bool valid, bool setEntriesRecursively) { } this->valid = valid; } + +void LocalPoolDataSetBase::setReadCommitProtectionBehaviour( + bool protectEveryReadCommit, uint32_t mutexTimeout) { + PoolDataSetBase::setReadCommitProtectionBehaviour(protectEveryReadCommit, + mutexTimeout); +} diff --git a/datapoollocal/LocalPoolDataSetBase.h b/datapoollocal/LocalPoolDataSetBase.h index aa155bf1..d9b6a221 100644 --- a/datapoollocal/LocalPoolDataSetBase.h +++ b/datapoollocal/LocalPoolDataSetBase.h @@ -54,7 +54,7 @@ public: */ LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner, uint32_t setId, PoolVariableIF** registeredVariablesArray, - const size_t maxNumberOfVariables, bool noPeriodicHandling = false); + const size_t maxNumberOfVariables, bool periodicHandling = true); /** * @brief Constructor for users of local pool data. @@ -77,6 +77,16 @@ public: */ ~LocalPoolDataSetBase(); + /** + * If the data is pulled from different local data pools, every read and + * commit call should be mutex protected for thread safety. + * This can be specified with the second parameter. + * @param dataCreator + * @param protectEveryReadCommit + */ + void setReadCommitProtectionBehaviour(bool protectEveryReadCommit, + uint32_t mutexTimeout = 20); + void setValidityBufferGeneration(bool withValidityBuffer); sid_t getSid() const; @@ -128,6 +138,7 @@ public: protected: sid_t sid; + uint32_t mutexTimeout = 20; MutexIF* mutex = nullptr; bool diagnostic = false; @@ -181,7 +192,7 @@ protected: */ ReturnValue_t unlockDataPool() override; - LocalDataPoolManager* hkManager; + LocalDataPoolManager* hkManager = nullptr; /** * Set n-th bit of a byte, with n being the position from 0 diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp index 48649ad5..a685ea8d 100644 --- a/datapoollocal/LocalPoolVariable.tpp +++ b/datapoollocal/LocalPoolVariable.tpp @@ -11,14 +11,14 @@ inline LocalPoolVariable::LocalPoolVariable(HasLocalDataPoolIF* hkOwner, LocalPoolObjectBase(poolId, hkOwner, dataSet, setReadWriteMode) {} template -inline LocalPoolVariable::LocalPoolVariable(object_id_t poolOwner, lp_id_t poolId, - DataSetIF *dataSet, pool_rwm_t setReadWriteMode): +inline LocalPoolVariable::LocalPoolVariable(object_id_t poolOwner, + lp_id_t poolId, DataSetIF *dataSet, pool_rwm_t setReadWriteMode): LocalPoolObjectBase(poolOwner, poolId, dataSet, setReadWriteMode) {} template -inline LocalPoolVariable::LocalPoolVariable(gp_id_t globalPoolId, DataSetIF *dataSet, - pool_rwm_t setReadWriteMode): +inline LocalPoolVariable::LocalPoolVariable(gp_id_t globalPoolId, + DataSetIF *dataSet, pool_rwm_t setReadWriteMode): LocalPoolObjectBase(globalPoolId.objectId, globalPoolId.localPoolId, dataSet, setReadWriteMode){} @@ -40,11 +40,11 @@ inline ReturnValue_t LocalPoolVariable::readWithoutLock() { PoolEntry* poolEntry = nullptr; ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry); - if(result != RETURN_OK and poolEntry != nullptr) { + if(result != RETURN_OK or poolEntry == nullptr) { sif::error << "PoolVector: Read of local pool variable of object " - "0x" << std::hex << std::setw(8) << std::setfill('0') << - hkManager->getOwner() << " and lp ID 0x" << localPoolId << - std::dec << " failed.\n" << std::flush; + << std::hex << std::setw(8) << std::setfill('0') + << hkManager->getOwner() << " and lp ID " << localPoolId + << std::dec << " failed." << std::setfill(' ') << std::endl; return result; } this->value = *(poolEntry->address); @@ -62,7 +62,7 @@ inline ReturnValue_t LocalPoolVariable::commit(dur_millis_t lockTimeout) { template inline ReturnValue_t LocalPoolVariable::commitWithoutLock() { if(readWriteMode == pool_rwm_t::VAR_READ) { - sif::debug << "LocalPoolVar: Invalid read write " + sif::debug << "LocalPoolVariable: Invalid read write " "mode for commit() call." << std::endl; return PoolVariableIF::INVALID_READ_WRITE_MODE; } diff --git a/datapoollocal/PoolReadHelper.h b/datapoollocal/PoolReadHelper.h new file mode 100644 index 00000000..4fe506ee --- /dev/null +++ b/datapoollocal/PoolReadHelper.h @@ -0,0 +1,41 @@ +#ifndef FSFW_DATAPOOLLOCAL_POOLREADHELPER_H_ +#define FSFW_DATAPOOLLOCAL_POOLREADHELPER_H_ + +#include +#include + +/** + * @brief Helper class to read data sets or pool variables + */ +class PoolReadHelper { +public: + PoolReadHelper(ReadCommitIF* readObject, uint32_t mutexTimeout = 20): + readObject(readObject), mutexTimeout(mutexTimeout) { + if(readObject != nullptr) { + readResult = readObject->read(mutexTimeout); +#if FSFW_PRINT_VERBOSITY_LEVEL == 1 + sif::error << "PoolReadHelper: Read failed!" << std::endl; +#endif + } + } + + ReturnValue_t getReadResult() const { + return readResult; + } + + ~PoolReadHelper() { + if(readObject != nullptr) { + readObject->commit(mutexTimeout); + } + + } + +private: + ReadCommitIF* readObject = nullptr; + ReturnValue_t readResult = HasReturnvaluesIF::RETURN_OK; + uint32_t mutexTimeout = 20; +}; + + + +#endif /* FSFW_DATAPOOLLOCAL_POOLREADHELPER_H_ */