Merge feature/qt6-migration-basis-modules-services into feature/qt6-migration-basis-modules

Resolves 17 conflicts against legacy Qt5 semantics; validates with BUILD_RTI=ON BUILD_GRANTLEE=ON.
2026-09-24 10:10:25 +02:00
commit 5381c65fee
@@ -0,0 +1,130 @@
+
+
+#pragma once
+
+// Include Qt headers FIRST to prevent namespace pollution when RTI DDS headers include Qt
+#include <QtCore/QString>
+#include <QtCore/QUrl>
+#include <QtCore/QFlag>
+#include <LtsUtils/LtsUtilsCore/data_modification_enum.h>
+#include <dds/sub/LoanedSamples.hpp>
+
+namespace NGLLogger
+{
+class INGLLogger;
+}
+
+namespace DTC
+{
+class SubscriberListener;
+
+template <typename DRO_OBJECT, typename SC> class GenericDtcSC
+{
+  public:
+    using DataReaderObject = DRO_OBJECT;
+    using SubscriberCallback = SC;
+    using TopicType = typename DRO_OBJECT::TopicType;
+
+    GenericDtcSC() = default;
+    virtual ~GenericDtcSC() = default;
+
+    virtual bool setSubscriberCallback(const SubscriberCallback& subscriberCallback) = 0;
+    virtual dds::sub::LoanedSamples<TopicType> readAlive() const = 0;
+    virtual bool readAlive(TopicType& data) = 0;
+    virtual dds::sub::LoanedSamples<TopicType> takeAlive() const = 0;
+    virtual bool takeAlive(TopicType& data) = 0;
+    virtual dds::sub::LoanedSamples<TopicType> takeDisposed() const = 0;
+    virtual bool takeDisposed(TopicType& data) = 0;
+    virtual bool hasSamples() const = 0;
+    virtual DataReaderObject* dataReader() const = 0;
+    virtual bool waitForHistoricalData(int timeoutMSec) = 0;
+};
+
+template <typename DRO_OBJECT>
+class GenericDtc
+    : public GenericDtcSC<DRO_OBJECT, std::function<void(const typename DRO_OBJECT::TopicType&, DataModification)>>
+{
+  public:
+    using BaseClass = GenericDtcSC<DRO_OBJECT, std::function<void(const typename DRO_OBJECT::TopicType&, DataModification)>>;
+    using TopicType = typename BaseClass::TopicType;
+    
+    // Explicitly expose base class methods for accessibility through smart pointers
+    using BaseClass::readAlive;
+    using BaseClass::takeAlive;
+    using BaseClass::takeDisposed;
+    using BaseClass::SubscriberCallback;
+    bool setSubscriberCallback(const typename BaseClass::SubscriberCallback& callback) override { return BaseClass::setSubscriberCallback(callback); }
+    bool readAlive(TopicType& data) { return BaseClass::readAlive(data); }
+    bool takeAlive(TopicType& data) { return BaseClass::takeAlive(data); }
+    bool takeDisposed(TopicType& data) { return BaseClass::takeDisposed(data); }
+    bool hasSamples() const { return BaseClass::hasSamples(); }
+    std::shared_ptr<DRO_OBJECT> dataReader() { return BaseClass::dataReader(); }
+    bool waitForHistoricalData(int timeoutMSec) { return BaseClass::waitForHistoricalData(timeoutMSec); }
+};
+
+template <typename DRO_OBJECT>
+class GenericDtcSampleInfo
+    : public GenericDtcSC<DRO_OBJECT,
+                          std::function<void(const typename DRO_OBJECT::TopicType&, const dds::sub::SampleInfo&)>>
+{
+  public:
+    using BaseClass = GenericDtcSC<DRO_OBJECT, std::function<void(const typename DRO_OBJECT::TopicType&, const dds::sub::SampleInfo&)>>;
+    using TopicType = typename BaseClass::TopicType;
+    
+    // Explicitly expose base class methods for accessibility through smart pointers
+    using BaseClass::readAlive;
+    using BaseClass::takeAlive;
+    using BaseClass::takeDisposed;
+    void setSubscriberCallback(std::function<void(const TopicType&, const dds::sub::SampleInfo&)> callback) { BaseClass::setSubscriberCallback(callback); }
+    bool readAlive(TopicType& data) { return BaseClass::readAlive(data); }
+    bool takeAlive(TopicType& data) { return BaseClass::takeAlive(data); }
+    bool takeDisposed(TopicType& data) { return BaseClass::takeDisposed(data); }
+    bool hasSamples() const { return BaseClass::hasSamples(); }
+    std::shared_ptr<DRO_OBJECT> dataReader() { return BaseClass::dataReader(); }
+    bool waitForHistoricalData(int timeoutMSec) { return BaseClass::waitForHistoricalData(timeoutMSec); }
+};
+
+template <typename DRO_OBJECT>
+class Ddtc
+    : public GenericDtcSC<
+          DRO_OBJECT, std::function<void(const typename DRO_OBJECT::TopicType&, const std::string&, DataModification)>>
+{
+  public:
+    using BaseClass = GenericDtcSC<DRO_OBJECT, std::function<void(const typename DRO_OBJECT::TopicType&, const std::string&, DataModification)>>;
+    using TopicType = typename BaseClass::TopicType;
+    
+    // Explicitly expose base class methods for accessibility through smart pointers
+    using BaseClass::readAlive;
+    using BaseClass::takeAlive;
+    using BaseClass::takeDisposed;
+    void setSubscriberCallback(std::function<void(const TopicType&, const std::string&, DataModification)> callback) { BaseClass::setSubscriberCallback(callback); }
+    bool readAlive(TopicType& data) { return BaseClass::readAlive(data); }
+    bool takeAlive(TopicType& data) { return BaseClass::takeAlive(data); }
+    bool takeDisposed(TopicType& data) { return BaseClass::takeDisposed(data); }
+    bool hasSamples() const { return BaseClass::hasSamples(); }
+    std::shared_ptr<DRO_OBJECT> dataReader() { return BaseClass::dataReader(); }
+    bool waitForHistoricalData(int timeoutMSec) { return BaseClass::waitForHistoricalData(timeoutMSec); }
+};
+
+template <typename DRO_OBJECT>
+class DdtcSampleInfo
+    : public GenericDtcSC<DRO_OBJECT, std::function<void(const typename DRO_OBJECT::TopicType&, const std::string&,
+                                                         const dds::sub::SampleInfo&)>>
+{
+  public:
+    using BaseClass = GenericDtcSC<DRO_OBJECT, std::function<void(const typename DRO_OBJECT::TopicType&, const std::string&, const dds::sub::SampleInfo&)>>;
+    using TopicType = typename BaseClass::TopicType;
+    
+    // Explicitly expose base class methods for accessibility through smart pointers
+    using BaseClass::readAlive;
+    using BaseClass::takeAlive;
+    using BaseClass::takeDisposed;
+    void setSubscriberCallback(std::function<void(const TopicType&, const std::string&, const dds::sub::SampleInfo&)> callback) { BaseClass::setSubscriberCallback(callback); }
+    bool readAlive(TopicType& data) { return BaseClass::readAlive(data); }
+    bool takeAlive(TopicType& data) { return BaseClass::takeAlive(data); }
+    bool takeDisposed(TopicType& data) { return BaseClass::takeDisposed(data); }
+    bool hasSamples() const { return BaseClass::hasSamples(); }
+    std::shared_ptr<DRO_OBJECT> dataReader() { return BaseClass::dataReader(); }
+    bool waitForHistoricalData(int timeoutMSec) { return BaseClass::waitForHistoricalData(timeoutMSec); }
+};
+} // namespace DTC
@@ -0,0 +1,357 @@
+/**
+  * @RDE_HEADER@
+  * DataTopicClient (DTC) - Generic
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  */
+
+#pragma once
+
+// Include Qt headers FIRST to prevent namespace pollution when RTI DDS headers include Qt
+#include <QtCore/QString>
+#include <QtCore/QUrl>
+#include <QtCore/QFlag>
+#include <QtCore/QTimer>
+#include <DDS/Generic/generic_data_reader.h>
+#include <DDS/Generic/subscriber_listener.h>
+#include <DDS/Generic/generic_logger.h>
+
+#include <dds/core/cond/StatusCondition.hpp>
+#include <dds/core/cond/WaitSet.hpp>
+
+#include "generic_dtc.h"
+
+
+namespace DDSGeneric
+{
+class DynamicDataReader;
+} // namespace DDSGeneric
+
+namespace DTC
+{
+
+template<typename SuperClass>
+class GenericDtcImplSubscriberTemplate : public DDSGeneric::SubscriberListenerCallback, public SuperClass
+{
+public:
+  using DataReaderObject =   typename SuperClass::DataReaderObject;
+  using SubscriberCallback = typename SuperClass::SubscriberCallback;
+  using TopicTypeRead =      typename DataReaderObject::TopicType;
+  using TopicTypeSubscribe = typename DataReaderObject::TopicType;
+  using DataReader =         typename DataReaderObject::DataReader;
+
+  GenericDtcImplSubscriberTemplate(const dds::domain::DomainParticipant &domainParticipant,
+                                   const dds::sub::Subscriber &ddsSubscriber,
+                                   DDSGeneric::SubscriberListener *subscriberListener,
+                                   const std::string &topicName = DDS::Helper::getShortTopicName(DDS::topic_type_name<TopicTypeRead>::value()))
+    : m_subscriberListener(subscriberListener)
+    , m_dataReaderObject(new DataReaderObject)
+    , m_subscriberCallback(nullptr)
+    , m_writerState(0)
+    , m_logger(DDS::getLogger(DDS::topic_type_name<TopicTypeRead>::value(), DDS::DataType::DATA_TOPIC_CLIENT))
+  {
+    createInternal(m_dataReaderObject->create(domainParticipant, ddsSubscriber, topicName));
+  }
+
+  GenericDtcImplSubscriberTemplate(const dds::domain::DomainParticipant &domainParticipant,
+                                   const dds::sub::Subscriber &ddsSubscriber,
+                                   DDSGeneric::SubscriberListener *subscriberListener,
+                                   const dds::topic::Filter &filter,
+                                   const std::string &topicName)
+    : m_subscriberListener(subscriberListener)
+    , m_dataReaderObject(new DataReaderObject)
+    , m_subscriberCallback(nullptr)
+    , m_writerState(0)
+    , m_logger(DDS::getLogger(DDS::topic_type_name<TopicTypeRead>::value(), DDS::DataType::DATA_TOPIC_CLIENT))
+  {
+    createInternal(m_dataReaderObject->create(domainParticipant, ddsSubscriber, topicName, filter));
+  }
+
+  GenericDtcImplSubscriberTemplate(const dds::domain::DomainParticipant &domainParticipant,
+                                   const dds::sub::Subscriber &ddsSubscriber,
+                                   DDSGeneric::SubscriberListener *subscriberListener,
+                                   const dds::core::xtypes::StructType &structType,
+                                   const std::string &topicName)
+    : m_subscriberListener(subscriberListener)
+    , m_dataReaderObject(new DataReaderObject)
+    , m_subscriberCallback(nullptr)
+    , m_logger(DDS::getLogger(DDS::topic_type_name<TopicTypeRead>::value(), DDS::DataType::DATA_TOPIC_CLIENT))
+  {
+    createInternal(m_dataReaderObject->create(domainParticipant, ddsSubscriber, topicName, structType));
+  }
+
+  ~GenericDtcImplSubscriberTemplate()
+  {
+    if (m_dataReaderObject && m_subscriberCallback)
+      m_subscriberListener->removeCallback(m_dataReaderObject->getDataReader(), this);
+    delete m_dataReaderObject;
+  }
+
+  bool setSubscriberCallback(const SubscriberCallback &subscriberCallback) override final
+  {
+    if (m_subscriberCallback)
+    {
+      WARNING_LOG(m_logger) << "Can not set subscriber callback - already set ...";
+      return false;
+    }
+    if (!m_subscriberListener)
+    {
+      WARNING_LOG(m_logger) << "Can not set subscriber callback - no subscriber listener ...";
+      return false;
+    }
+
+    m_subscriberCallback = subscriberCallback;
+
+    if (!m_dataReaderObject)
+    {
+      WARNING_LOG(m_logger) << "Can not set subscriber callback - no data reader object ...";
+      return false;
+    }
+
+    m_dataReaderObject->setHaveSubscriberCallback(m_subscriberCallback != nullptr);
+
+    return true;
+  }
+
+  dds::sub::LoanedSamples<TopicTypeRead> readAlive() const override final
+  {
+    if (!m_dataReaderObject)
+      return dds::sub::LoanedSamples<TopicTypeRead>();
+
+    bool bSeenUnreadSamples = false;
+    auto ret = m_dataReaderObject->readAlive(bSeenUnreadSamples);
+    if (bSeenUnreadSamples)
+      QTimer::singleShot(0, this, &GenericDtcImplSubscriberTemplate::unreadSamplesDuringRead);
+
+    return ret;
+  }
+
+  bool readAlive(TopicTypeRead& data) override final
+  {
+    auto samples = readAlive();
+    if (samples.length() > 0)
+    {
+      data = samples[0].data();
+      return true;
+    }
+    return false;
+  }
+
+  dds::sub::LoanedSamples<TopicTypeRead> takeAlive() const override final
+  {
+    if (!m_dataReaderObject)
+      return dds::sub::LoanedSamples<TopicTypeRead>();
+
+    bool bSeenUnreadSamples = false;
+    auto ret = m_dataReaderObject->takeAlive(bSeenUnreadSamples);
+    if (bSeenUnreadSamples)
+      QTimer::singleShot(0, this, &GenericDtcImplSubscriberTemplate::unreadSamplesDuringRead);
+
+    return ret;
+  }
+
+  bool takeAlive(TopicTypeRead& data) override final
+  {
+    auto samples = takeAlive();
+    if (samples.length() > 0)
+    {
+      data = samples[0].data();
+      return true;
+    }
+    return false;
+  }
+
+  dds::sub::LoanedSamples<TopicTypeRead> takeDisposed() const override final
+  {
+    if (!m_dataReaderObject)
+      return dds::sub::LoanedSamples<TopicTypeRead>();
+
+    return m_dataReaderObject->takeDisposed();
+  }
+
+  bool takeDisposed(TopicTypeRead& data) override final
+  {
+    auto samples = takeDisposed();
+    if (samples.length() > 0)
+    {
+      data = samples[0].data();
+      return true;
+    }
+    return false;
+  }
+
+  bool hasSamples() const override final
+  {
+    if (!m_dataReaderObject)
+      return false;
+
+    return m_dataReaderObject->hasSamples();
+  }
+
+  DataReaderObject *dataReader() const override final
+  {
+    return m_dataReaderObject;
+  }
+
+  bool waitForHistoricalData(int timeoutMSec) override
+  {
+    if (m_dataReaderObject == nullptr ||
+        m_dataReaderObject->getDataReader() == nullptr)
+      return false;
+
+    const bool bWaitForever = (timeoutMSec < 0);
+    auto dr = m_dataReaderObject->getDataReader();
+    try
+    {
+      if (dr.subscription_matched_status().current_count() == 0)
+      {
+        dds::core::cond::WaitSet ws;
+        auto cond = dds::core::cond::StatusCondition(dr);
+        cond.enabled_statuses(dds::core::status::StatusMask::subscription_matched());
+        ws.attach_condition(cond);
+        const dds::core::Duration waitTimeout(bWaitForever ? dds::core::Duration::infinite() : dds::core::Duration::from_millisecs(timeoutMSec));
+        const dds::core::cond::WaitSet::ConditionSeq seq(ws.wait(waitTimeout));
+        // empty sequence -> timeout
+        if (seq.empty())
+          return false;
+      }
+      dr.wait_for_historical_data(dds::core::Duration(1));
+    }
+    catch (const dds::core::Exception &)
+    {
+      // timeout
+      return false;
+    }
+    return true;
+  }
+
+protected:
+  void unreadSamplesDuringRead()
+  {
+    droDataAvailable(DDS::topic_type_name<TopicTypeRead>::value(), m_dataReaderObject->topicName());
+  }
+
+  void droDataAvailable(const std::string &topicType, const std::string &topicName) override final
+  {
+    Q_UNUSED(topicType);
+    if (m_writerState.testAndSetRelaxed(1, 0))
+    {
+      DEBUG_LOG(m_logger) << "Recreate Reader for topic " << topicName
+                          << ", type name " << DDS::topic_type_name<TopicTypeRead>::value();
+      if (m_subscriberListener)
+        m_subscriberListener->removeCallback(m_dataReaderObject->getDataReader(), this);
+      m_dataReaderObject->recreateReader();
+      if (m_subscriberListener)
+        m_subscriberListener->addCallback(m_dataReaderObject->getDataReader(), this);
+    }
+
+    DEBUG_LOG(m_logger) << "IN droDataAvailable(), topic name: " << topicName
+                        << ", type name " << DDS::topic_type_name<TopicTypeRead>::value()
+                        << ", this: " << this
+                        << ", m_dataReaderObject: " << m_dataReaderObject
+                        << ", hasSamples: " << (m_dataReaderObject ? m_dataReaderObject->hasSamples() : -1);
+
+    if (m_subscriberListener)
+      m_subscriberListener->enableCallback(m_dataReaderObject->getDataReader(), this);
+
+    if (!m_dataReaderObject || !m_subscriberCallback)
+      return;
+
+    m_dataReaderObject->read(m_subscriberCallback);
+  }
+
+  void noWriterAnymore(const std::string &topicType, const std::string &topicName) override
+  {
+    Q_UNUSED(topicType);
+    Q_UNUSED(topicName);
+    m_writerState = -1;
+  }
+
+  void writerAvailable(const std::string &topicType, const std::string &topicName) override
+  {
+    Q_UNUSED(topicType);
+    Q_UNUSED(topicName);
+    m_writerState.testAndSetRelaxed(-1, 1);
+  }
+
+  bool createInternal(bool droInitOk)
+  {
+    if (!droInitOk)
+    {
+      ERROR_LOG(m_logger) << "Error initializing DRO for type " << DDS::topic_type_name<TopicTypeRead>::value();
+      delete m_dataReaderObject;
+      m_dataReaderObject  = nullptr;
+      return false;
+    }
+
+    if (m_subscriberListener)
+    {
+      DEBUG_LOG(m_logger) << "subscriberListener exists, adding type "
+                          << DDS::topic_type_name<TopicTypeRead>::value();
+      m_subscriberListener->addCallback(m_dataReaderObject->getDataReader(), this);
+    }
+    else
+    {
+      DEBUG_LOG(m_logger) << "Cannot add DTC to subscriberListener callback - type: "
+                          << DDS::topic_type_name<TopicTypeRead>::value();
+    }
+    m_dataReaderObject->setHaveSubscriberCallback(m_subscriberListener != nullptr);
+    return true;
+  }
+
+private:
+  DDSGeneric::SubscriberListener  *m_subscriberListener;
+
+  // DataReaderObjects (DROs)
+  DataReaderObject                *m_dataReaderObject;
+
+  // Callback for data processing
+  SubscriberCallback               m_subscriberCallback;
+
+  QAtomicInt m_writerState;
+
+  NGL::INGLLogger                 &m_logger;
+};
+
+// Typed topic callback (DataReader)
+template<typename DRO_OBJECT>
+class GenericDtcImpl final
+    : public GenericDtcImplSubscriberTemplate<GenericDtc<DRO_OBJECT>>
+{
+  using BaseClass = GenericDtcImplSubscriberTemplate<GenericDtc<DRO_OBJECT>>;
+public:
+  using BaseClass::BaseClass;
+};
+
+// Typed topic callback (DataReader) with SampleInfo
+template<typename DRO_OBJECT>
+class GenericDtcImplSampleInfo final
+    : public GenericDtcImplSubscriberTemplate<GenericDtcSampleInfo<DRO_OBJECT>>
+{
+  using BaseClass = GenericDtcImplSubscriberTemplate<GenericDtcSampleInfo<DRO_OBJECT>>;
+public:
+  using BaseClass::BaseClass;
+};
+
+// Dynamic topic callback (DynamicDataReader)
+template<typename DRO_OBJECT>
+class DdtcImpl final
+    : public GenericDtcImplSubscriberTemplate<Ddtc<DRO_OBJECT>>
+{
+  using BaseClass = GenericDtcImplSubscriberTemplate<Ddtc<DRO_OBJECT>>;
+public:
+  using BaseClass::BaseClass;
+};
+
+// Dynamic topic callback (DynamicDataReader) with SampleInfo
+template<typename DRO_OBJECT>
+class DdtcImplSampleInfo final
+    : public GenericDtcImplSubscriberTemplate<DdtcSampleInfo<DRO_OBJECT>>
+{
+  using BaseClass = GenericDtcImplSubscriberTemplate<DdtcSampleInfo<DRO_OBJECT>>;
+public:
+  using BaseClass::BaseClass;
+};
+
+}  // namespace DTC
@@ -0,0 +1,32 @@
+#pragma once
+
+// Stub header for BUILD_RTI=OFF
+// Original ddsconnector_export.h is generated by CMake when BUILD_RTI=ON
+
+// For BUILD_RTI=OFF, we don't need DLL export/import macros
+// Define DDSCONNECTOR_EXPORT as empty
+#ifndef DDSCONNECTOR_EXPORT
+#define DDSCONNECTOR_EXPORT
+#endif
+
+#ifndef DDSCONNECTOR_NO_EXPORT
+#define DDSCONNECTOR_NO_EXPORT
+#endif
+
+// Static library marker (not used for BUILD_RTI=OFF)
+#ifndef DDSCONNECTOR_STATIC_DEFINE
+#define DDSCONNECTOR_STATIC_DEFINE
+#endif
+
+// Deprecated marker (optional, can be empty)
+#ifndef DDSCONNECTOR_DEPRECATED
+#define DDSCONNECTOR_DEPRECATED
+#endif
+
+#ifndef DDSCONNECTOR_DEPRECATED_EXPORT
+#define DDSCONNECTOR_DEPRECATED_EXPORT DDSCONNECTOR_DEPRECATED DDSCONNECTOR_EXPORT
+#endif
+
+#ifndef DDSCONNECTOR_DEPRECATED_NO_EXPORT
+#define DDSCONNECTOR_DEPRECATED_NO_EXPORT DDSCONNECTOR_DEPRECATED DDSCONNECTOR_NO_EXPORT
+#endif
@@ -0,0 +1,32 @@
+#pragma once
+
+// Stub header for BUILD_RTI=OFF
+// Original ddsgen_export.h comes from RTI Connext DDS code generation
+
+// For BUILD_RTI=OFF, we don't need DLL export/import macros
+// Define DDSGEN_EXPORT as empty
+#ifndef DDSGEN_EXPORT
+#define DDSGEN_EXPORT
+#endif
+
+#ifndef DDSGEN_NO_EXPORT
+#define DDSGEN_NO_EXPORT
+#endif
+
+// Static library marker (not used for BUILD_RTI=OFF)
+#ifndef DDSGEN_STATIC_DEFINE
+#define DDSGEN_STATIC_DEFINE
+#endif
+
+// Deprecated marker (optional, can be empty)
+#ifndef DDSGEN_DEPRECATED
+#define DDSGEN_DEPRECATED
+#endif
+
+#ifndef DDSGEN_DEPRECATED_EXPORT
+#define DDSGEN_DEPRECATED_EXPORT DDSGEN_DEPRECATED DDSGEN_EXPORT
+#endif
+
+#ifndef DDSGEN_DEPRECATED_NO_EXPORT
+#define DDSGEN_DEPRECATED_NO_EXPORT DDSGEN_DEPRECATED DDSGEN_NO_EXPORT
+#endif
@@ -0,0 +1,51 @@
+#pragma once
+
+// Stub header for BUILD_RTI=OFF
+// Original generic_base.h uses RTI Connext DDS types
+
+#include <string>
+#include <ddsgen_export.h>
+#include <QMetaMethod>
+
+// Forward declarations for Qt types used in getMethod
+class QObject;
+
+// Forward declaration for NGL logger
+namespace NGL {
+class INGLLogger;
+}
+
+namespace DDS
+{
+
+// Template for topic type name - returns empty string for BUILD_RTI=OFF
+template<typename T>
+struct topic_type_name {
+    static std::string value() {
+        return "";
+    }
+};
+
+namespace Helper
+{
+// Stub implementations for BUILD_RTI=OFF
+DDSGEN_EXPORT inline std::string getFunctionTopicName(const std::string &fqName) {
+    return fqName;
+}
+
+DDSGEN_EXPORT inline std::string getShortTopicName(const std::string &fqName) {
+    return fqName;
+}
+
+// Stub for getMethod - returns default-constructed QMetaMethod
+DDSGEN_EXPORT inline QMetaMethod getMethod(NGL::INGLLogger & /*logger*/,
+                                           QObject * /*objectToInform*/,
+                                           const char * /*slotToExecute*/,
+                                           const char * /*signalSignature*/,
+                                           bool /*bWarnOnEmptySlot*/ = true) {
+    // Stub implementation - returns default QMetaMethod
+    return QMetaMethod();
+}
+}
+
+} // namespace DDS
@@ -0,0 +1,173 @@
+#pragma once
+
+/**
+ * @file generic_data_reader.h
+ * @brief Generic Data Reader wrapper for DDS
+ * 
+ * Provides GenericDataReader template class that wraps RTI DataReader
+ * when BUILD_RTI=ON, or provides stub implementation when BUILD_RTI=OFF.
+ */
+
+#include <functional>
+#include <string>
+
+#ifdef BUILD_RTI
+// RTI DDS is available - include full implementation from Lts
+// MUST be included BEFORE namespace DDSGeneric to avoid namespace pollution
+#include <Lts/DDS/Generic/dynamic_data_reader.h>
+#include <Lts/DDS/Generic/generic_data_reader.h>
+
+namespace DDSGeneric
+{
+// Full implementation is in Lts/DDS/Generic/generic_data_reader.h
+// This file just provides the include path redirection
+} // namespace DDSGeneric
+
+#else
+// BUILD_RTI=OFF: Provide minimal stub definitions for RTI types
+
+namespace dds {
+namespace sub {
+namespace detail {
+
+// Dummy delegate class to serve as default template parameter
+template<typename Q>
+class DataReaderImpl {
+    // Empty stub implementation
+};
+
+} // namespace detail
+
+// Forward declaration stub for DataReader
+// Must match RTI 7.7 signature for compatibility
+template<typename T, template <typename Q> class DELEGATE = detail::DataReaderImpl>
+class DataReader {
+public:
+    // Minimal stub interface - add methods as needed by the codebase
+    T read() { return T{}; }
+    void take() {}
+};
+
+} // namespace sub
+} // namespace dds
+
+namespace DDSGeneric
+{
+
+// GenericDataReader stub template (only when BUILD_RTI=OFF)
+template<typename T>
+class GenericDataReader {
+public:
+    using TopicType = T;
+    using TopicTypeRead = T;
+    using DataReader = void*;
+    using DataTopic = void*;
+    using DataReaderQos = void*;
+    using SubscriberCallback = std::function<void(const TopicTypeRead&, int)>;
+    using SubscriberCallbackWithSampleInfo = std::function<void(const TopicTypeRead&, const void*)>;
+    
+    GenericDataReader()
+        : m_dataReader(nullptr), m_ddsTopic(nullptr), m_bHaveSubscriberCallback(false)
+    {
+    }
+    
+    virtual ~GenericDataReader()
+    {
+        m_ddsTopic = nullptr;
+        m_dataReader = nullptr;
+    }
+    
+    DataReader getDataReader() const
+    {
+        return m_dataReader;
+    }
+    
+    bool create(const void* domainParticipant, const void* ddsSubscriber,
+                const std::string& topicName = std::string(),
+                bool bCreateDataReader = true)
+    {
+        return false;
+    }
+    
+    bool hasSamples() const
+    {
+        return false;
+    }
+    
+    void* readAlive(bool& bSeenNewSamples)
+    {
+        bSeenNewSamples = false;
+        return nullptr;
+    }
+    
+    void* takeAlive(bool& bSeenNewSamples)
+    {
+        bSeenNewSamples = false;
+        return nullptr;
+    }
+    
+    void* takeDisposed()
+    {
+        return nullptr;
+    }
+    
+    template <typename C> bool read(C callbackFunc)
+    {
+        return false;
+    }
+    
+    void setHaveSubscriberCallback(bool bHave)
+    {
+        m_bHaveSubscriberCallback = bHave;
+    }
+    
+    std::string topicName() const
+    {
+        return std::string();
+    }
+    
+    DataReader dataReader() const
+    {
+        return m_dataReader;
+    }
+    
+    virtual void recreateReader()
+    {
+    }
+    
+protected:
+    DataReader m_dataReader;
+    DataReaderQos m_dataReaderQos;
+    DataTopic m_ddsTopic;
+    bool m_bHaveSubscriberCallback;
+};
+
+template<typename T>
+class GenericDataReaderContentFilter {
+public:
+    using DataType = T;
+    // Minimal stub - extend as needed
+};
+
+// DynamicDataReader stub for BUILD_RTI=OFF
+class DynamicDataReader {
+public:
+    using TopicType = void*;
+    using DataReader = void*;
+    using DataTopic = void*;
+    
+    DynamicDataReader() {}
+    ~DynamicDataReader() {}
+    
+    bool create(const void* domainParticipant, const void* ddsSubscriber,
+                const std::string& specialTopicName, const void* structType)
+    {
+        return false;
+    }
+    
+    bool hasSamples() const { return false; }
+};
+
+} // namespace DDSGeneric
+
+#endif // BUILD_RTI
@@ -0,0 +1,84 @@
+#pragma once
+
+#ifdef BUILD_RTI
+// Real implementation with RTI NGL logger
+#include <NGLLogger/INGLLogger.h>
+#include <ddsgen_export.h>
+#include <string>
+
+namespace DDS
+{
+
+enum class DataType
+{
+  DATA_TYPE_UNKNOWN   = 0,
+
+  DATA_WRITER         = 1,
+  DATA_READER         = 2,
+
+  DYNAMIC_DATA_WRITER = 3,
+  DYNAMIC_DATA_READER = 4,
+
+  DATA_TOPIC_SERVER   = 8,
+  DATA_TOPIC_CLIENT   = 9,
+
+  FUNCTION_TOPIC_SERVER = 12,
+  FUNCTION_TOPIC_CLIENT = 13
+};
+
+using LOGGER_T = NGL::INGLLogger&;
+
+DDSGEN_EXPORT LOGGER_T getLogger(const char *name, DataType dt);
+inline LOGGER_T getLogger(const std::string &loggerName, DataType dt)
+{
+  return getLogger(loggerName.data(), dt);
+}
+
+} // namespace DDS
+#else
+// Stub header for BUILD_RTI=OFF
+#include <NGLLogger/INGLLogger.h>
+#include <ddsgen_export.h>
+#include <string>
+
+namespace DDS
+{
+
+// DataType enum - same as original, no RTI dependency
+enum class DataType
+{
+  DATA_TYPE_UNKNOWN   = 0,
+
+  DATA_WRITER         = 1,
+  DATA_READER         = 2,
+
+  DYNAMIC_DATA_WRITER = 3,
+  DYNAMIC_DATA_READER = 4,
+
+  DATA_TOPIC_SERVER   = 8,
+  DATA_TOPIC_CLIENT   = 9,
+
+  FUNCTION_TOPIC_SERVER = 12,
+  FUNCTION_TOPIC_CLIENT = 13
+};
+
+// Logger type alias
+using LOGGER_T = NGL::INGLLogger&;
+
+// Stub implementation for getLogger
+// Returns a dummy logger reference - in real usage, this would need proper initialization
+DDSGEN_EXPORT inline LOGGER_T getLogger(const char *name, DataType dt) {
+    // Stub: return a static dummy logger
+    // In production code with BUILD_RTI=OFF, this should be replaced with actual logger
+    static NGL::INGLLogger* dummy_logger = nullptr;
+    return *dummy_logger;
+}
+
+// Inline overload for std::string
+inline LOGGER_T getLogger(const std::string &loggerName, DataType dt)
+{
+  return getLogger(loggerName.data(), dt);
+}
+
+} // namespace DDS
+#endif