fix(node-opal-orchestra): Use shared pointers for DDF items

Signed-off-by: Steffen Vogel <steffen.vogel@opal-rt.com>

Author: stv0g

include/villas/nodes/opal_orchestra/ddf.hpp

@@ -48,25 +48,27 @@ class DataItem : public Item {
 
 class BusItem : public Item {
 public:
-  std::map<std::string, Item *> items;
+  std::map<std::string, std::shared_ptr<Item>> items;
   std::string name;
 
   BusItem(const std::string &name) : items(), name(name) {}
 
-  DataItem *upsertItem(std::vector<std::string> pathComponents, bool &inserted);
+  std::shared_ptr<DataItem> upsertItem(std::vector<std::string> pathComponents,
+                                       bool &inserted);
 
   void toXml(xmlNode *parent, bool withDefault) const override;
 };
 
 class DataSet {
 public:
-  std::map<std::string, Item *> items;
+  std::map<std::string, std::shared_ptr<Item>> items;
   std::string name;
 
   DataSet(const std::string &name) : items(), name(name) {}
 
-  DataItem *upsertItem(const std::string &path, bool &inserted);
-  DataItem *upsertItem(std::vector<std::string> pathComponents, bool &inserted);
+  std::shared_ptr<DataItem> upsertItem(const std::string &path, bool &inserted);
+  std::shared_ptr<DataItem> upsertItem(std::vector<std::string> pathComponents,
+                                       bool &inserted);
 
   void toXml(xmlNode *parent, bool withDefault) const;
 };
@@ -77,7 +79,7 @@ class Connection {
   virtual std::string getDetails() const = 0;
   virtual void parse(json_t *json) = 0;
 
-  static Connection *fromJson(json_t *json);
+  static std::shared_ptr<Connection> fromJson(json_t *json);
 };
 
 class ConnectionLocal : public Connection {
@@ -124,7 +126,7 @@ class ConnectionDolphin : public Connection {
 class Domain {
 public:
   std::string name;
-  Connection *connection;
+  std::shared_ptr<Connection> connection;
   bool synchronous;
   bool states;
   bool multiplePublishAllowed;

lib/nodes/opal_orchestra.cpp

@@ -38,7 +38,7 @@ using namespace villas::node::orchestra;
 // An OpalOrchestraMapping maps one or more VILLASnode signals to an Orchestra data item.
 class OpalOrchestraMapping {
 public:
-  DataItem *item;
+  std::shared_ptr<DataItem> item;
   std::string path;
   std::vector<Signal::Ptr> signals;
 
@@ -53,7 +53,7 @@ class OpalOrchestraMapping {
   unsigned int typeSize; // sizeof() of the signal type. See RTSignalType.
   unsigned short length;
 
-  OpalOrchestraMapping(DataItem *item, const std::string &path)
+  OpalOrchestraMapping(std::shared_ptr<DataItem> item, const std::string &path)
       : item(item), path(path), signals(), signalList(), indices() {}
 
   void addSignal(Signal::Ptr signal, std::optional<unsigned> orchestraIdx) {
@@ -237,8 +237,8 @@ class OpalOrchestraNode : public Node {
 
   Domain domain; // The domain to which the node belongs.
 
-  std::map<DataItem *, OpalOrchestraMapping> subscribeMappings;
-  std::map<DataItem *, OpalOrchestraMapping> publishMappings;
+  std::map<std::shared_ptr<DataItem>, OpalOrchestraMapping> subscribeMappings;
+  std::map<std::shared_ptr<DataItem>, OpalOrchestraMapping> publishMappings;
 
   double rate;
   std::optional<std::filesystem::path> dataDefinitionFilename;
@@ -332,8 +332,9 @@ class OpalOrchestraNode : public Node {
         skipWaitToGo(false), dataDefinitionFileOverwrite(false),
         dataDefinitionFileWriteOnly(false) {}
 
-  void parseSignals(json_t *json, SignalList::Ptr signals, DataSet &dataSet,
-                    std::map<DataItem *, OpalOrchestraMapping> &mappings) {
+  void parseSignals(
+      json_t *json, SignalList::Ptr signals, DataSet &dataSet,
+      std::map<std::shared_ptr<DataItem>, OpalOrchestraMapping> &mappings) {
     if (!json_is_array(json)) {
       throw ConfigError(json, "node-config-node-opal-orchestra-signals",
                         "Signals must be an array");
@@ -373,7 +374,7 @@ class OpalOrchestraNode : public Node {
       auto orchestraName = nme ? nme : signal->name;
 
       bool inserted = false;
-      auto *item = dataSet.upsertItem(orchestraName, inserted);
+      auto item = dataSet.upsertItem(orchestraName, inserted);
 
       if (inserted) {
         item->type = orchestraType;
@@ -552,7 +553,8 @@ class OpalOrchestraNode : public Node {
       throw RTError(ret, "Failed to check ready to go");
     }
 
-    if (auto *c = dynamic_cast<ConnectionRemote *>(domain.connection)) {
+    if (std::shared_ptr<ConnectionRemote> c =
+            std::dynamic_pointer_cast<ConnectionRemote>(domain.connection)) {
       ret = RTSetupRefMemRemoteConnection(c->name.c_str(), c->pciIndex);
       if (ret != RTAPI_SUCCESS) {
         throw RTError(ret,

lib/nodes/opal_orchestra/ddf.cpp

@@ -6,6 +6,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+#include <memory>
 extern "C" {
 #include <RTAPI.h>
 }
@@ -71,27 +72,27 @@ void BusItem::toXml(xmlNode *parent, bool withDefault) const {
   }
 }
 
-DataItem *BusItem::upsertItem(std::vector<std::string> pathComponents,
-                              bool &inserted) {
+std::shared_ptr<DataItem>
+BusItem::upsertItem(std::vector<std::string> pathComponents, bool &inserted) {
   auto &name = pathComponents.front();
 
   auto it = items.find(name);
   if (it == items.end()) { // No item with this name exists. Create a new one.
     if (pathComponents.size() == 1) { // No bus, just a signal.
-      auto *item = new DataItem(name);
+      auto item = std::make_shared<DataItem>(name);
       items.emplace(name, item);
       inserted = true;
       return item;
     } else {
-      auto *bus = new BusItem(name);
+      auto bus = std::make_shared<BusItem>(name);
       items.emplace(name, bus);
 
       pathComponents.erase(pathComponents.begin());
       return bus->upsertItem(pathComponents, inserted);
     }
   } else {
     if (pathComponents.size() == 1) {
-      auto *item = dynamic_cast<DataItem *>(it->second);
+      auto item = std::dynamic_pointer_cast<DataItem>(it->second);
       if (!item) {
         throw RuntimeError("Item with name '{}' is not a data item",
                            pathComponents.front());
@@ -100,7 +101,7 @@ DataItem *BusItem::upsertItem(std::vector<std::string> pathComponents,
       inserted = false;
       return item;
     } else {
-      auto *bus = dynamic_cast<BusItem *>(it->second);
+      auto bus = std::dynamic_pointer_cast<BusItem>(it->second);
       if (!bus) {
         throw RuntimeError("Item with name '{}' is not a bus",
                            pathComponents.front());
@@ -112,31 +113,32 @@ DataItem *BusItem::upsertItem(std::vector<std::string> pathComponents,
   }
 }
 
-DataItem *DataSet::upsertItem(const std::string &path, bool &inserted) {
+std::shared_ptr<DataItem> DataSet::upsertItem(const std::string &path,
+                                              bool &inserted) {
   return upsertItem(split(path), inserted);
 }
 
-DataItem *DataSet::upsertItem(std::vector<std::string> pathComponents,
-                              bool &inserted) {
+std::shared_ptr<DataItem>
+DataSet::upsertItem(std::vector<std::string> pathComponents, bool &inserted) {
   auto &name = pathComponents.front();
 
   auto it = items.find(name);
   if (it == items.end()) { // No item with this name exists. Create a new one.
     if (pathComponents.size() == 1) { // No bus, just a signal.
-      auto *item = new DataItem(name);
+      auto item = std::make_shared<DataItem>(name);
       items.emplace(name, item);
       inserted = true;
       return item;
     } else {
-      auto *bus = new BusItem(name);
+      auto bus = std::make_shared<BusItem>(name);
       items.emplace(name, bus);
 
       pathComponents.erase(pathComponents.begin());
       return bus->upsertItem(pathComponents, inserted);
     }
   } else {
     if (pathComponents.size() == 1) {
-      auto *item = dynamic_cast<DataItem *>(it->second);
+      auto item = std::dynamic_pointer_cast<DataItem>(it->second);
       if (!item) {
         throw RuntimeError("Item with name '{}' is not a data item",
                            pathComponents.front());
@@ -146,7 +148,7 @@ DataItem *DataSet::upsertItem(std::vector<std::string> pathComponents,
       return item;
     } else {
       // Item with this name exists. Check if it is a bus.
-      auto *bus = dynamic_cast<BusItem *>(it->second);
+      auto bus = std::dynamic_pointer_cast<BusItem>(it->second);
       if (!bus) {
         throw RuntimeError("Item with name '{}' is not a bus",
                            pathComponents.front());
@@ -333,7 +335,7 @@ void ConnectionDolphin::parse(json_t *json) {
   }
 }
 
-Connection *Connection::fromJson(json_t *json) {
+std::shared_ptr<Connection> Connection::fromJson(json_t *json) {
   const char *type = nullptr;
   json_error_t err;
 
@@ -343,16 +345,16 @@ Connection *Connection::fromJson(json_t *json) {
                       "Failed to parse connection type");
   }
 
-  Connection *c = nullptr;
+  std::shared_ptr<Connection> c;
 
   if (strcmp(type, "local") == 0) {
-    c = new ConnectionLocal();
+    c = std::make_shared<ConnectionLocal>();
     c->parse(json);
   } else if (strcmp(type, "remote") == 0) {
-    c = new ConnectionRemote();
+    c = std::make_shared<ConnectionRemote>();
     c->parse(json);
   } else if (strcmp(type, "dolphin") == 0) {
-    c = new ConnectionDolphin();
+    c = std::make_shared<ConnectionDolphin>();
     c->parse(json);
   } else {
     throw ConfigError(json, err, "node-config-node-opal-orchestra-connection",