From 67ce8d2e24dcb8636f2dd4b04e3d275bb18a7fe4 Mon Sep 17 00:00:00 2001 From: "Robin.Mueller" Date: Thu, 14 Jan 2021 11:50:33 +0100 Subject: [PATCH] improved internal interface --- controller/ExtendedControllerBase.cpp | 8 ++------ controller/ExtendedControllerBase.h | 11 +---------- datapoollocal/HasLocalDataPoolIF.h | 25 +++++++++++++++++++------ devicehandlers/DeviceHandlerBase.cpp | 8 ++------ devicehandlers/DeviceHandlerBase.h | 8 ++------ internalError/InternalErrorReporter.cpp | 8 ++------ internalError/InternalErrorReporter.h | 3 +-- 7 files changed, 29 insertions(+), 42 deletions(-) diff --git a/controller/ExtendedControllerBase.cpp b/controller/ExtendedControllerBase.cpp index e0aec63a5..397c8c10f 100644 --- a/controller/ExtendedControllerBase.cpp +++ b/controller/ExtendedControllerBase.cpp @@ -26,10 +26,6 @@ object_id_t ExtendedControllerBase::getObjectId() const { return SystemObject::getObjectId(); } -AccessPoolManagerIF* ExtendedControllerBase::getAccessorHandle() { - return &poolManager; -} - uint32_t ExtendedControllerBase::getPeriodicOperationFrequency() const { return this->executingTask->getPeriodMs(); } @@ -114,6 +110,6 @@ LocalPoolDataSetBase* ExtendedControllerBase::getDataSetHandle(sid_t sid) { return nullptr; } -ProvidesDataPoolSubscriptionIF* ExtendedControllerBase::getSubscriptionInterface() { - return &poolManager; +LocalDataPoolManager* ExtendedControllerBase::getHkManagerHandle() { + return &poolManager; } diff --git a/controller/ExtendedControllerBase.h b/controller/ExtendedControllerBase.h index b27605141..bcb414dd3 100644 --- a/controller/ExtendedControllerBase.h +++ b/controller/ExtendedControllerBase.h @@ -32,20 +32,10 @@ public: virtual ReturnValue_t performOperation(uint8_t opCode) override; virtual ReturnValue_t initializeAfterTaskCreation() override; - /** - * Provides a subscription interface for objects which required updates on changed - * controller variables or datasets - * @return - */ - ProvidesDataPoolSubscriptionIF* getSubscriptionInterface() override; - protected: LocalDataPoolManager poolManager; ActionHelper actionHelper; - //! Accessor handle required for internal handling - AccessPoolManagerIF* getAccessorHandle() override; - /** * Implemented by child class. Handle all command messages which are * not health, mode, action or housekeeping messages. @@ -68,6 +58,7 @@ protected: size_t size) override; /** HasLocalDatapoolIF overrides */ + virtual LocalDataPoolManager* getHkManagerHandle() override; virtual object_id_t getObjectId() const override; virtual ReturnValue_t initializeLocalDataPool( localpool::DataPool& localDataPoolMap, diff --git a/datapoollocal/HasLocalDataPoolIF.h b/datapoollocal/HasLocalDataPoolIF.h index 3d822650b..1d87d47c9 100644 --- a/datapoollocal/HasLocalDataPoolIF.h +++ b/datapoollocal/HasLocalDataPoolIF.h @@ -2,6 +2,7 @@ #define FSFW_DATAPOOLLOCAL_HASLOCALDATAPOOLIF_H_ #include "localPoolDefinitions.h" +#include "LocalDataPoolManager.h" #include "../datapool/PoolEntryIF.h" #include "../serviceinterface/ServiceInterface.h" @@ -14,7 +15,6 @@ class AccessPoolManagerIF; class ProvidesDataPoolSubscriptionIF; class LocalPoolDataSetBase; class LocalPoolObjectBase; -class LocalDataPoolManager; /** * @brief This interface is implemented by classes which posses a local data pool (not the @@ -104,19 +104,32 @@ public: * which allows subscriptions to dataset and variable updates in form of messages. * The consumers can then read the most recent variable value by calling read with * an own pool variable or set instance or using the deserialized snapshot data. + * Returns the HK manager casted to the required interface by default. * @return */ - virtual ProvidesDataPoolSubscriptionIF* getSubscriptionInterface() = 0; + virtual ProvidesDataPoolSubscriptionIF* getSubscriptionInterface() { + return getHkManagerHandle(); + } protected: /** - * Accessor handle required for internal handling. Not intended for users and therefore - * declared protected. Users should instead use pool variables, sets or the subscription - * interface to access pool entries. + * Every class implementing this interface should have a local data pool manager. This + * function will return a reference to the manager. * @return */ - virtual AccessPoolManagerIF* getAccessorHandle() = 0; + virtual LocalDataPoolManager* getHkManagerHandle() = 0; + + /** + * Accessor handle required for internal handling. Not intended for users and therefore + * declared protected. Users should instead use pool variables, sets or the subscription + * interface to access pool entries. Returns the HK manager casted to a different interface + * by default. + * @return + */ + virtual AccessPoolManagerIF* getAccessorHandle() { + return getHkManagerHandle(); + } /** * This function is used by the pool manager to get a valid dataset diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp index c40985255..6092a89f8 100644 --- a/devicehandlers/DeviceHandlerBase.cpp +++ b/devicehandlers/DeviceHandlerBase.cpp @@ -1483,10 +1483,6 @@ void DeviceHandlerBase::setNormalDatapoolEntriesInvalid() { } } -AccessPoolManagerIF* DeviceHandlerBase::getAccessorHandle() { - return &poolManager; -} - void DeviceHandlerBase::printWarningOrError(sif::OutputTypes errorType, const char *functionName, ReturnValue_t errorCode, const char *errorPrint) { @@ -1532,6 +1528,6 @@ void DeviceHandlerBase::printWarningOrError(sif::OutputTypes errorType, } -ProvidesDataPoolSubscriptionIF* DeviceHandlerBase::getSubscriptionInterface() { - return &poolManager; +LocalDataPoolManager* DeviceHandlerBase::getHkManagerHandle() { + return &poolManager; } diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h index 43f61897a..3a993aff0 100644 --- a/devicehandlers/DeviceHandlerBase.h +++ b/devicehandlers/DeviceHandlerBase.h @@ -518,14 +518,10 @@ protected: LocalDataPoolManager& poolManager) override; /** - * Provides the subscription handle which can be used by classes like controllers - * to get messages on data updates. + * Required for HasLocalDataPoolIF, return a handle to the local pool manager. * @return */ - ProvidesDataPoolSubscriptionIF* getSubscriptionInterface() override; - - //! Accessor handle required for internal handling. - AccessPoolManagerIF* getAccessorHandle() override; + LocalDataPoolManager* getHkManagerHandle() override; /** * @brief Hook function for child handlers which is called once per diff --git a/internalError/InternalErrorReporter.cpp b/internalError/InternalErrorReporter.cpp index bc72ada24..7e5a316ca 100644 --- a/internalError/InternalErrorReporter.cpp +++ b/internalError/InternalErrorReporter.cpp @@ -139,10 +139,6 @@ uint32_t InternalErrorReporter::getStoreHits() { return value; } -AccessPoolManagerIF* InternalErrorReporter::getAccessorHandle() { - return &poolManager; -} - void InternalErrorReporter::incrementStoreHits() { mutex->lockMutex(timeoutType, timeoutMs); storeHits++; @@ -201,6 +197,6 @@ void InternalErrorReporter::setMutexTimeout(MutexIF::TimeoutType timeoutType, this->timeoutMs = timeoutMs; } -ProvidesDataPoolSubscriptionIF* InternalErrorReporter::getSubscriptionInterface() { - return &poolManager; +LocalDataPoolManager* InternalErrorReporter::getHkManagerHandle() { + return &poolManager; } diff --git a/internalError/InternalErrorReporter.h b/internalError/InternalErrorReporter.h index ec9134d42..a237418ed 100644 --- a/internalError/InternalErrorReporter.h +++ b/internalError/InternalErrorReporter.h @@ -45,8 +45,7 @@ public: LocalDataPoolManager& poolManager) override; virtual dur_millis_t getPeriodicOperationFrequency() const override; virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override; - ProvidesDataPoolSubscriptionIF* getSubscriptionInterface() override; - AccessPoolManagerIF* getAccessorHandle() override; + LocalDataPoolManager* getHkManagerHandle() override; virtual ReturnValue_t initialize() override; virtual ReturnValue_t initializeAfterTaskCreation() override;