move retvals

src/fsfw/container/FixedMap.h

@@ -7,6 +7,13 @@
 #include "../returnvalues/returnvalue.h"
 #include "ArrayList.h"
 
+namespace mapdefs {
+static const uint8_t INTERFACE_ID = CLASS_ID::FIXED_MAP;
+static const ReturnValue_t KEY_ALREADY_EXISTS = MAKE_RETURN_CODE(0x01);
+static const ReturnValue_t MAP_FULL = MAKE_RETURN_CODE(0x02);
+static const ReturnValue_t KEY_DOES_NOT_EXIST = MAKE_RETURN_CODE(0x03);
+}  // namespace mapdefs
+
 /**
  * @brief    Map implementation for maps with a pre-defined size.
  * @details
@@ -24,11 +31,6 @@ class FixedMap : public SerializeIF {
                 "derived class from SerializeIF to be serialize-able");
 
  public:
-  static const uint8_t INTERFACE_ID = CLASS_ID::FIXED_MAP;
-  static const ReturnValue_t KEY_ALREADY_EXISTS = MAKE_RETURN_CODE(0x01);
-  static const ReturnValue_t MAP_FULL = MAKE_RETURN_CODE(0x02);
-  static const ReturnValue_t KEY_DOES_NOT_EXIST = MAKE_RETURN_CODE(0x03);
-
  private:
   static const key_t EMPTY_SLOT = -1;
   ArrayList<std::pair<key_t, T>, uint32_t> theMap;
@@ -76,10 +78,10 @@ class FixedMap : public SerializeIF {
 
   ReturnValue_t insert(key_t key, T value, Iterator* storedValue = nullptr) {
     if (exists(key) == returnvalue::OK) {
-      return KEY_ALREADY_EXISTS;
+      return mapdefs::KEY_ALREADY_EXISTS;
     }
     if (_size == theMap.maxSize()) {
-      return MAP_FULL;
+      return mapdefs::MAP_FULL;
     }
     theMap[_size].first = key;
     theMap[_size].second = value;
@@ -93,7 +95,7 @@ class FixedMap : public SerializeIF {
   ReturnValue_t insert(std::pair<key_t, T> pair) { return insert(pair.first, pair.second); }
 
   ReturnValue_t exists(key_t key) const {
-    ReturnValue_t result = KEY_DOES_NOT_EXIST;
+    ReturnValue_t result = mapdefs::KEY_DOES_NOT_EXIST;
     if (findIndex(key) < _size) {
       result = returnvalue::OK;
     }
@@ -103,7 +105,7 @@ class FixedMap : public SerializeIF {
   ReturnValue_t erase(Iterator* iter) {
     uint32_t i;
     if ((i = findIndex((*iter).value->first)) >= _size) {
-      return KEY_DOES_NOT_EXIST;
+      return mapdefs::KEY_DOES_NOT_EXIST;
     }
     theMap[i] = theMap[_size - 1];
     --_size;
@@ -114,7 +116,7 @@ class FixedMap : public SerializeIF {
   ReturnValue_t erase(key_t key) {
     uint32_t i;
     if ((i = findIndex(key)) >= _size) {
-      return KEY_DOES_NOT_EXIST;
+      return mapdefs::KEY_DOES_NOT_EXIST;
     }
     theMap[i] = theMap[_size - 1];
     --_size;

src/fsfw/controller/ControllerBase.cpp

@@ -106,9 +106,7 @@ const HasHealthIF* ControllerBase::getOptHealthIF() const { return this; }
 
 const HasModesIF& ControllerBase::getModeIF() const { return *this; }
 
-ModeTreeChildIF& ControllerBase::getModeTreeChildIF() {
+ModeTreeChildIF& ControllerBase::getModeTreeChildIF() { return *this; }
-  return *this;
-}
 
 ReturnValue_t ControllerBase::connectModeTreeParent(HasModeTreeChildrenIF& parent) {
   return modetree::connectModeTreeParent(parent, *this, healthHelper, modeHelper);

src/fsfw/devicehandlers/ChildHandlerBase.h

@@ -2,14 +2,15 @@
 #define FSFW_DEVICEHANDLER_CHILDHANDLERBASE_H_
 
 #include <fsfw/subsystem/HasModeTreeChildrenIF.h>
+
 #include "ChildHandlerFDIR.h"
 #include "DeviceHandlerBase.h"
 
 class ChildHandlerBase : public DeviceHandlerBase {
  public:
   ChildHandlerBase(object_id_t setObjectId, object_id_t deviceCommunication, CookieIF* cookie,
-                   HasModeTreeChildrenIF& parent,
+                   HasModeTreeChildrenIF& parent, FailureIsolationBase* customFdir = nullptr,
-                   FailureIsolationBase* customFdir = nullptr, size_t cmdQueueSize = 20);
+                   size_t cmdQueueSize = 20);
 
   virtual ~ChildHandlerBase();
 

src/fsfw/devicehandlers/DeviceHandlerBase.cpp

@@ -1,6 +1,5 @@
 #include "DeviceHandlerBase.h"
 
-#include "fsfw/subsystem/helper.h"
 #include "fsfw/datapoollocal/LocalPoolVariable.h"
 #include "fsfw/devicehandlers/AcceptsDeviceResponsesIF.h"
 #include "fsfw/devicehandlers/DeviceTmReportingWrapper.h"
@@ -13,6 +12,7 @@
 #include "fsfw/serviceinterface/ServiceInterface.h"
 #include "fsfw/storagemanager/StorageManagerIF.h"
 #include "fsfw/subsystem/SubsystemBase.h"
+#include "fsfw/subsystem/helper.h"
 #include "fsfw/thermal/ThermalComponentIF.h"
 
 object_id_t DeviceHandlerBase::powerSwitcherId = objects::NO_OBJECT;
@@ -1597,14 +1597,8 @@ ReturnValue_t DeviceHandlerBase::connectModeTreeParent(HasModeTreeChildrenIF &pa
   return modetree::connectModeTreeParent(parent, *this, healthHelper, modeHelper);
 }
 
-const HasHealthIF* DeviceHandlerBase::getOptHealthIF() const {
+const HasHealthIF* DeviceHandlerBase::getOptHealthIF() const { return this; }
-  return this;
-}
 
-const HasModesIF& DeviceHandlerBase::getModeIF() const {
+const HasModesIF& DeviceHandlerBase::getModeIF() const { return *this; }
-  return *this;
-}
 
-ModeTreeChildIF& DeviceHandlerBase::getModeTreeChildIF() {
+ModeTreeChildIF& DeviceHandlerBase::getModeTreeChildIF() { return *this; }
-  return *this;
-}

src/fsfw/devicehandlers/DeviceHandlerBase.h

@@ -11,7 +11,6 @@
 #include "fsfw/action/HasActionsIF.h"
 #include "fsfw/datapool/PoolVariableIF.h"
 #include "fsfw/datapoollocal/HasLocalDataPoolIF.h"
-#include "fsfw/subsystem/ModeTreeConnectionIF.h"
 #include "fsfw/datapoollocal/LocalDataPoolManager.h"
 #include "fsfw/health/HealthHelper.h"
 #include "fsfw/ipc/MessageQueueIF.h"
@@ -22,6 +21,7 @@
 #include "fsfw/returnvalues/returnvalue.h"
 #include "fsfw/serviceinterface/ServiceInterface.h"
 #include "fsfw/serviceinterface/serviceInterfaceDefintions.h"
+#include "fsfw/subsystem/ModeTreeConnectionIF.h"
 #include "fsfw/tasks/ExecutableObjectIF.h"
 #include "fsfw/tasks/PeriodicTaskIF.h"
 #include "fsfw/util/dataWrapper.h"

src/fsfw/subsystem/Subsystem.cpp

@@ -36,6 +36,13 @@ ReturnValue_t Subsystem::checkSequence(HybridIterator<ModeListEntry> iter,
 
   for (; iter.value != nullptr; ++iter) {
     if (!existsModeTable(iter->getTableId())) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+      using namespace std;
+      sif::warning << "Subsystem::checkSequence: "
+                   << "Object " << setfill('0') << hex << "0x" << setw(8) << getObjectId()
+                   << setw(0) << ": Mode table for mode ID "
+                   << "0x" << setw(8) << iter->getTableId() << " does not exist" << dec << endl;
+#endif
       return TABLE_DOES_NOT_EXIST;
     } else {
       ReturnValue_t result = checkTable(getTable(iter->getTableId()));

src/fsfw/subsystem/SubsystemBase.cpp

@@ -310,10 +310,6 @@ ReturnValue_t SubsystemBase::registerChild(const ModeTreeChildIF& child) {
 
 const HasHealthIF* SubsystemBase::getOptHealthIF() const { return this; }
 
-const HasModesIF& SubsystemBase::getModeIF() const {
+const HasModesIF& SubsystemBase::getModeIF() const { return *this; }
-  return *this;
-}
 
-ModeTreeChildIF& SubsystemBase::getModeTreeChildIF() {
+ModeTreeChildIF& SubsystemBase::getModeTreeChildIF() { return *this; }
-  return *this;
-}

src/fsfw/subsystem/SubsystemBase.h

@@ -6,12 +6,12 @@
 #include "fsfw/container/HybridIterator.h"
 #include "fsfw/health/HasHealthIF.h"
 #include "fsfw/health/HealthHelper.h"
-#include "fsfw/subsystem/ModeTreeConnectionIF.h"
 #include "fsfw/ipc/MessageQueueIF.h"
 #include "fsfw/modes/HasModesIF.h"
 #include "fsfw/objectmanager/SystemObject.h"
 #include "fsfw/returnvalues/returnvalue.h"
 #include "fsfw/subsystem/HasModeTreeChildrenIF.h"
+#include "fsfw/subsystem/ModeTreeConnectionIF.h"
 #include "fsfw/tasks/ExecutableObjectIF.h"
 #include "modes/HasModeSequenceIF.h"
 

src/fsfw_tests/integration/assemblies/TestAssembly.cpp

@@ -4,9 +4,7 @@
 
 TestAssembly::TestAssembly(object_id_t objectId, object_id_t parentId, ModeTreeChildIF& testDevice0,
                            ModeTreeChildIF& testDevice1)
-    : AssemblyBase(objectId, parentId),
+    : AssemblyBase(objectId, parentId), deviceHandler0(testDevice0), deviceHandler1(testDevice1) {
-      deviceHandler0(testDevice0),
-      deviceHandler1(testDevice1) {
   ModeListEntry newModeListEntry;
   newModeListEntry.setObject(testDevice0.getObjectId());
   newModeListEntry.setMode(MODE_OFF);