Continues migration with DDS, Common

2026-07-17 12:41:42 +02:00
1 parent 9b15cee841
commit fa48db111e
@@ -0,0 +1,389 @@
+
+
+
+#include "lts_session_data_dds.h"
+#include <DDS/DDSConnector/dds_connector.h>
+#include <DDS/DTC/generic_dtc_impl.h>
+#include <NGLLogger/NGLLoggerBootstrap.h>
+#include <QSet>
+#include <QVector>
+#include <DDS/QosProfile/DDS_DefaultQos.h>
+#include <QDebug>
+
+namespace LtsSession
+{
+
+
+
+
+
+
+class DdsConnectionContainer
+{
+  struct DdsConnection : public DdsConnectionParams
+  {
+    std::weak_ptr<DDSConnector::DdsConnector> ddsConnector = std::weak_ptr<DDSConnector::DdsConnector>();
+
+    DdsConnection() = default;
+    explicit DdsConnection(const DdsConnectionParams &p)
+      : DdsConnectionParams(p)
+    {}
+  };
+  QVector<DdsConnection> ddsConnections;
+public:
+
+  std::shared_ptr<DDSConnector::DdsConnector> findGlobalConnection()
+  {
+    for (int i = ddsConnections.size() - 1; i >= 0; --i)
+    {
+      const DdsConnection &conn = ddsConnections.at(i);
+      if (conn.partitionType != IDL::PartitionType::Global)
+        continue;
+      auto ret = conn.ddsConnector.lock();
+      if (ret != nullptr)
+        return ret;
+      
+      ddsConnections.removeAt(i);
+    }
+    Q_ASSERT(false);
+    return std::shared_ptr<DDSConnector::DdsConnector>();
+  }
+
+  std::shared_ptr<DDSConnector::DdsConnector> findConnection(const DdsConnectionParams &connParams)
+  {
+    for (int i = ddsConnections.size() - 1; i >= 0; --i)
+    {
+      const DdsConnection &conn = ddsConnections.at(i);
+      if (conn != connParams)
+        continue;
+      auto ret = conn.ddsConnector.lock();
+      if (ret != nullptr)
+        return ret;
+      
+      ddsConnections.removeAt(i);
+    }
+    return std::shared_ptr<DDSConnector::DdsConnector>();
+  }
+
+  dds::domain::DomainParticipant findMatchingDomainParticipant(const DdsConnectionParams &connParams)
+  {
+    for (int i = ddsConnections.size() - 1; i >= 0; --i)
+    {
+      const DdsConnection &conn = ddsConnections.at(i);
+      if (!connParams.hasSameDomainParams(conn))
+        continue;
+      auto ret = conn.ddsConnector.lock();
+      if (ret != nullptr)
+        return ret->getDomainParticipant();
+      
+      ddsConnections.removeAt(i);
+    }
+    return nullptr;
+  }
+
+  void insertConnection(const DdsConnectionParams &connParams,
+                        const std::shared_ptr<DDSConnector::DdsConnector> &ddsConnector)
+  {
+    DdsConnection val(connParams);
+    val.ddsConnector = ddsConnector;
+
+    ddsConnections += val;
+  }
+};
+Q_GLOBAL_STATIC(DdsConnectionContainer, s_ddsConnections)
+
+
+
+class DataPluginContainer
+{
+public:
+  struct DataPluginValue
+  {
+    QString identifier;
+    std::weak_ptr<DataPluginBase::Interface> weakIfc;
+
+    bool operator==(const DataPluginValue &o) const
+    {
+      return identifier == o.identifier && weakIfc.lock().get() == o.weakIfc.lock().get();
+    }
+  };
+
+  QMap<DdsConnectionParams, QSet<DataPluginValue>> m_dataPlugins;
+public:
+  QMap<QString, std::shared_ptr<DataPluginBase::Interface>> findDataPlugins(const DdsConnectionParams &connParams);
+  void insertDataPlugins(const DdsConnectionParams &connParams,
+                         const QMap<QString, std::shared_ptr<DataPluginBase::Interface>> &dataPlugins);
+};
+
+uint qHash(const DataPluginContainer::DataPluginValue &val)
+{
+  qint64 ptr = reinterpret_cast<qint64>(val.weakIfc.lock().get());
+  return ::qHash(val.identifier) ^ ::qHash(ptr);
+}
+
+QMap<QString, std::shared_ptr<DataPluginBase::Interface>> DataPluginContainer::findDataPlugins(const DdsConnectionParams &connParams)
+{
+  QMap<QString, std::shared_ptr<DataPluginBase::Interface>> ret;
+  DdsConnectionParams key(connParams);
+  key.exerciseId = 0;
+
+  auto it = m_dataPlugins.find(key);
+  if (it != m_dataPlugins.end())
+  {
+    QSet<DataPluginValue> &cont = it.value();
+    auto itCont = cont.begin();
+    while (itCont != cont.end())
+    {
+      auto spPlugin = itCont->weakIfc.lock();
+      if (spPlugin)
+      {
+        ret[itCont->identifier] = spPlugin;
+        ++itCont;
+      }
+      else
+      {
+        itCont = cont.erase(itCont);
+      }
+    }
+  }
+  return ret;
+}
+
+void DataPluginContainer::insertDataPlugins(const DdsConnectionParams &connParams,
+                                            const QMap<QString, std::shared_ptr<DataPluginBase::Interface>> &dataPlugins)
+{
+  DdsConnectionParams key(connParams);
+  key.exerciseId = 0;
+
+  QSet<DataPluginValue> cont;
+  cont.reserve(dataPlugins.size());
+  for (auto it = dataPlugins.begin(); it != dataPlugins.end(); ++it)
+  {
+    DataPluginValue val;
+    val.identifier = it.key();
+    val.weakIfc = it.value();
+    cont += val;
+  }
+
+  m_dataPlugins[key].unite(cont);
+}
+
+Q_GLOBAL_STATIC(DataPluginContainer, s_dataPlugins)
+
+
+
+
+
+
+
+LtsSessionDataDds::LtsSessionDataDds(QObject *parent)
+  : QObject(parent)
+  , m_exerciseId(-1)
+  , m_emittedTime(0)
+  , m_curMSecSinceEpoch(0)
+  , m_active(true)
+  , m_fetcher(nullptr)
+  , m_logger(NGL::NGLLoggerBootstrap::getNGLRootLogger().getNGLLogger("LtsSession.Session"))
+{}
+
+LtsSessionDataDds::~LtsSessionDataDds()
+{
+  m_dtcPartitionTime = nullptr;
+  m_ddsConnector = nullptr;
+  delete m_fetcher;
+}
+
+bool LtsSessionDataDds::init(const DdsConnectionParams &connParams)
+{
+
+  m_ddsConnector = s_ddsConnections->findConnection(connParams);
+  m_exerciseId = connParams.exerciseId;
+  m_qosFileList = QStringList(connParams.qos_file);
+  if (m_ddsConnector == nullptr)
+  {
+    
+    dds::domain::DomainParticipant dp = s_ddsConnections->findMatchingDomainParticipant(connParams);
+    if (dp != nullptr)
+      return init(dp, connParams);
+   #ifdef WIN_32
+    DDS::QosProfile::ConnectionType type = DDS::QosProfile::ConnectionType::Tablet;
+   #else
+    DDS::QosProfile::ConnectionType type = DDS::QosProfile::ConnectionType::Client;
+   #endif
+
+    m_ddsConnector = std::make_shared<DDSConnector::DdsConnector>(connParams.domainId,
+                                                                  connParams.partitionType,
+                                                                  connParams.partitionId,
+                                                                  connParams.exerciseId, 
+                                                                  type);
+    s_ddsConnections()->insertConnection(connParams, m_ddsConnector);
+  }
+  return initInternal();
+}
+
+bool LtsSessionDataDds::init(const dds::domain::DomainParticipant &dp, const DdsConnectionParams &connParams)
+{
+  Q_ASSERT(dp.domain_id() == connParams.domainId);
+
+  m_ddsConnector = s_ddsConnections->findConnection(connParams);
+  m_exerciseId = connParams.exerciseId;
+
+
+
+  QStringList qosList;
+  if (!connParams.qos_file.isEmpty())
+  {
+    qosList.append(connParams.qos_file);
+  }
+
+  if (!qosList.isEmpty())
+    m_qosFileList = qosList;
+  else
+    m_qosFileList.clear();
+
+#ifdef WIN_32
+ DDS::QosProfile::ConnectionType type = DDS::QosProfile::ConnectionType::Tablet;
+#else
+ DDS::QosProfile::ConnectionType type = DDS::QosProfile::ConnectionType::Client;
+#endif
+
+  if (m_ddsConnector == nullptr)
+  {
+    m_ddsConnector = std::make_shared<DDSConnector::DdsConnector>(dp,
+                                                                  connParams.partitionType,
+                                                                  type,
+                                                                  connParams.partitionId
+                                                                  );
+
+
+
+    s_ddsConnections()->insertConnection(connParams, m_ddsConnector);
+  }
+  return initInternal();
+}
+
+Fetcher *LtsSessionDataDds::fetcher(const QString &yourPluginsName)
+{
+  if (m_fetcher == nullptr)
+    m_fetcher = new Fetcher(this, yourPluginsName);
+
+  return m_fetcher;
+}
+
+QString LtsSessionDataDds::partitionTypeString(IDL::PartitionType partitionType)
+{
+  switch (partitionType)
+  {
+    case IDL::PartitionType::AllExercises:
+      return QStringLiteral("AllExercises");
+    case IDL::PartitionType::Any:
+      return QStringLiteral("Any");
+    case IDL::PartitionType::Exercise:
+      return QStringLiteral("Exercise");
+    case IDL::PartitionType::Global:
+      return QStringLiteral("Global");
+    case IDL::PartitionType::Replay:
+      return QStringLiteral("Replay");
+  }
+
+  return QStringLiteral("Invalid (%1)").arg(int(partitionType));
+}
+
+QString LtsSessionDataDds::toString() const
+{
+  return QStringLiteral("(LtsSessionDataDds: id=%1, partitionId=%2, partitionType=%3(%4), exerciseId=%5)").arg((qulonglong)this).arg(partitionId()).arg(static_cast<int>(partitionType())).arg(partitionTypeString(partitionType())).arg(exerciseId());
+}
+
+int LtsSessionDataDds::domainId() const
+{
+  return m_ddsConnector ? m_ddsConnector->getDomainId() : -1;
+}
+
+int LtsSessionDataDds::exerciseId() const
+{
+  return m_exerciseId;
+}
+
+int LtsSessionDataDds::partitionId() const
+{
+  return m_ddsConnector ? m_ddsConnector->getPartitionId() : -1;
+}
+
+IDL::PartitionType LtsSessionDataDds::partitionType() const
+{
+  return m_ddsConnector ? m_ddsConnector->getPartitionType() : IDL::PartitionType::Global;
+}
+
+QStringList LtsSessionDataDds::qosFile() const
+{
+  return m_ddsConnector ? m_qosFileList : QStringList();
+}
+
+QUrl LtsSessionDataDds::tcpConnectionUrl() const
+{
+  return m_ddsConnector ? m_ddsConnector->getTcpConnectionUrl() : QUrl();
+}
+
+DdsConnectionParams LtsSessionDataDds::connParams() const
+{
+  DdsConnectionParams connParams;
+  connParams.domainId = domainId();
+  connParams.exerciseId = exerciseId();
+  connParams.partitionId = partitionId();
+  connParams.partitionType = partitionType();
+  connParams.qos_file = qosFile();
+  connParams.tcpConnectionUrl = tcpConnectionUrl();
+  return connParams;
+}
+
+
+bool LtsSessionDataDds::initInternal()
+{
+  if (!m_ddsConnector || !m_ddsConnector->init(m_qosFileList))
+  {
+    ERROR_LOG(m_logger) << "DDS connector could not be initialized - session aborted!";
+    m_ddsConnector = nullptr;
+    return false;
+  }
+
+  m_ddsConnector->initPublisherSubscriber();
+  m_ddsConnectorGlobal = s_ddsConnections->findGlobalConnection();
+  if (!m_ddsConnectorGlobal)
+    m_ddsConnectorGlobal = m_ddsConnector;
+
+  m_dtcPartitionTime.reset(m_ddsConnector->createDTC<DTC::PartitionTimeImpl>());
+  assert(m_dtcPartitionTime.get());
+
+  m_dtcPartitionTime->setSubscriberCallback([this](const Core::PartitionTime & data, DataModification)
+  {
+    m_curMSecSinceEpoch = data.timeStamp();
+    emit partitionTimeChangedInternal();
+  });
+  connect(this, &LtsSessionDataDds::partitionTimeChangedInternal,
+          this, &LtsSessionDataDds::onPartitionTimeChangedInternal, Qt::QueuedConnection);
+  return true;
+}
+
+void LtsSessionDataDds::onPartitionTimeChangedInternal()
+{
+  if (!m_active)
+    return;
+  if (m_emittedTime == m_curMSecSinceEpoch)
+    return;
+  m_emittedTime = m_curMSecSinceEpoch;
+  emit partitionTimeChanged(m_curMSecSinceEpoch);
+}
+
+QMap<QString, std::shared_ptr<DataPluginBase::Interface>> LtsSessionDataDds::availableDataPluginInterfaces() const
+{
+  return s_dataPlugins->findDataPlugins(connParams());
+
+}
+
+void LtsSessionDataDds::addAvailablaeDataPluginInterfaces(const QMap<QString, std::shared_ptr<DataPluginBase::Interface>> &dataPlugins)
+{
+  s_dataPlugins->insertDataPlugins(connParams(),
+                                   dataPlugins);
+}
+
+}