weird bug

datapoollocal/SharedLocalDataSet.cpp

@@ -1,5 +1,6 @@
 #include "SharedLocalDataSet.h"
 
+
 SharedLocalDataSet::SharedLocalDataSet(object_id_t objectId, sid_t sid,
         const size_t maxSize): SystemObject(objectId),
         LocalPoolDataSetBase(sid, nullptr, maxSize) {
@@ -11,6 +12,18 @@ ReturnValue_t SharedLocalDataSet::lockDataset(dur_millis_t mutexTimeout) {
     return datasetLock->lockMutex(MutexIF::TimeoutType::WAITING, mutexTimeout);
 }
 
+SharedLocalDataSet::SharedLocalDataSet(object_id_t objectId,
+        HasLocalDataPoolIF *owner, uint32_t setId,
+        const size_t maxSize): SystemObject(objectId),
+        LocalPoolDataSetBase(owner, setId, nullptr, maxSize) {
+    this->setContainer(poolVarVector.data());
+    datasetLock = MutexFactory::instance()->createMutex();
+}
+
+SharedLocalDataSet::~SharedLocalDataSet() {
+    MutexFactory::instance()->deleteMutex(datasetLock);
+}
+
 ReturnValue_t SharedLocalDataSet::unlockDataset() {
     return datasetLock->unlockMutex();
 }

datapoollocal/SharedLocalDataSet.h

@@ -11,15 +11,20 @@
  * multiple threads. It provides a lock in addition to all other functionalities provided
  * by the LocalPoolDataSetBase class.
  *
- * TODO: override and protect read, commit and some other calls used by pool manager.
+ * The user is completely responsible for lockingand unlocking the dataset when using the
+ * shared dataset.
  */
 class SharedLocalDataSet:
         public SystemObject,
         public LocalPoolDataSetBase,
         public SharedDataSetIF {
 public:
-    SharedLocalDataSet(object_id_t objectId, sid_t sid,
+    SharedLocalDataSet(object_id_t objectId, HasLocalDataPoolIF* owner, uint32_t setId,
             const size_t maxSize);
+    SharedLocalDataSet(object_id_t objectId, sid_t sid, const size_t maxSize);
+
+    virtual~ SharedLocalDataSet();
+
     ReturnValue_t lockDataset(dur_millis_t mutexTimeout) override;
     ReturnValue_t unlockDataset() override;
 private:

unittest/tests/datapoollocal/DataSetTest.cpp

@@ -6,6 +6,7 @@
 #include <fsfw/datapoollocal/HasLocalDataPoolIF.h>
 #include <fsfw/datapoollocal/StaticLocalDataSet.h>
 #include <fsfw/datapool/PoolReadGuard.h>
+#include <fsfw/datapoollocal/SharedLocalDataSet.h>
 #include <fsfw/globalfunctions/bitutility.h>
 
 #include <unittest/core/CatchDefinitions.h>
@@ -252,6 +253,11 @@ TEST_CASE("DataSetTest" , "[DataSetTest]") {
         CHECK(localSet.localPoolUint16Vec.isValid() == true);
     }
 
+    SECTION("SharedDataSet") {
+        object_id_t sharedSetId = objects::SHARED_SET_ID;
+        SharedLocalDataSet sharedSet(sharedSetId, poolOwner, 2, 5);
+    }
+
     /* we need to reset the subscription list because the pool owner
     is a global object. */
     CHECK(poolOwner->reset() == retval::CATCH_OK);

unittest/tests/datapoollocal/LocalPoolManagerTest.cpp

@@ -278,6 +278,11 @@ TEST_CASE("LocalPoolManagerTest" , "[LocManTest]") {
         CHECK(messagesSent == 1);
 
         HousekeepingMessage::setUpdateNotificationSetCommand(&hkCmd, lpool::testSid);
+        sid_t sidToCheck;
+        store_address_t storeId;
+        CHECK(poolOwner->poolManager.handleHousekeepingMessage(&hkCmd) == retval::CATCH_OK);
+        CHECK(poolOwner->changedDataSetCallbackWasCalled(sidToCheck, storeId) == true);
+        CHECK(sidToCheck == lpool::testSid);
     }
 
     /* we need to reset the subscription list because the pool owner

unittest/tests/datapoollocal/LocalPoolOwnerBase.cpp

@@ -89,3 +89,46 @@ ReturnValue_t LocalPoolOwnerBase::reset() {
     }
     return status;
 }
+
+bool LocalPoolOwnerBase::changedDataSetCallbackWasCalled(sid_t &sid, store_address_t &storeId) {
+    bool condition = false;
+    if(not this->changedDatasetSid.notSet()) {
+        condition = true;
+    }
+    sid = changedDatasetSid;
+    storeId = storeIdForChangedSet;
+    this->changedDatasetSid.raw = sid_t::INVALID_SID;
+    this->storeIdForChangedSet = storeId::INVALID_STORE_ADDRESS;
+    return condition;
+}
+
+void LocalPoolOwnerBase::handleChangedDataset(sid_t sid, store_address_t storeId) {
+    this->changedDatasetSid = sid;
+    this->storeIdForChangedSet = storeId;
+}
+
+bool LocalPoolOwnerBase::changedVariableCallbackWasCalled(gp_id_t &gpid, store_address_t &storeId) {
+    bool condition = false;
+    if(not this->changedPoolVariableGpid.notSet()) {
+        condition = true;
+    }
+    gpid = changedPoolVariableGpid;
+    storeId = storeIdForChangedVariable;
+    this->changedPoolVariableGpid.raw = gp_id_t::INVALID_GPID;
+    this->storeIdForChangedVariable = storeId::INVALID_STORE_ADDRESS;
+    return condition;
+}
+
+ReturnValue_t LocalPoolOwnerBase::initializeHkManagerAfterTaskCreation() {
+    if(not initializedAfterTaskCreation) {
+        initializedAfterTaskCreation = true;
+        return poolManager.initializeAfterTaskCreation();
+    }
+    return HasReturnvaluesIF::RETURN_OK;
+
+}
+
+void LocalPoolOwnerBase::handleChangedPoolVariable(gp_id_t globPoolId, store_address_t storeId) {
+    this->changedPoolVariableGpid = globPoolId;
+    this->storeIdForChangedVariable = storeId;
+}

unittest/tests/datapoollocal/LocalPoolOwnerBase.h

@@ -82,13 +82,7 @@ public:
 
     ReturnValue_t initializeHkManager();
 
-    ReturnValue_t initializeHkManagerAfterTaskCreation() {
+    ReturnValue_t initializeHkManagerAfterTaskCreation();
-        if(not initializedAfterTaskCreation) {
-            initializedAfterTaskCreation = true;
-            return poolManager.initializeAfterTaskCreation();
-        }
-        return HasReturnvaluesIF::RETURN_OK;
-    }
 
     /** Command queue for housekeeping messages. */
     MessageQueueId_t getCommandQueue() const override {
@@ -158,17 +152,20 @@ public:
         poolManager.clearReceiversList();
     }
 
-    void handleChangedDataset(sid_t sid, store_address_t storeId) {
+    bool changedDataSetCallbackWasCalled(sid_t& sid, store_address_t& storeId);
-        this->thisSidHasChanged = sid;
+    bool changedVariableCallbackWasCalled(gp_id_t& gpid, store_address_t& storeId);
-        this->storeIdForChangedSid = storeId;
-    }
 
     LocalDataPoolManager poolManager;
     LocalPoolTestDataSet dataset;
 private:
 
-    sid_t thisSidHasChanged;
+    void handleChangedDataset(sid_t sid, store_address_t storeId) override;
-    store_address_t storeIdForChangedSid;
+    sid_t changedDatasetSid;
+    store_address_t storeIdForChangedSet;
+
+    void handleChangedPoolVariable(gp_id_t globPoolId, store_address_t storeId) override;
+    gp_id_t changedPoolVariableGpid;
+    store_address_t storeIdForChangedVariable;
 
     lp_var_t<uint8_t> testUint8 = lp_var_t<uint8_t>(this, lpool::uint8VarId);
     lp_var_t<float> testFloat = lp_var_t<float>(this, lpool::floatVarId);