Adds further ext deps as-is binaries copies from customers env.

external/tmsif/include/ddkit/access/Reader.hpp

@@ -0,0 +1,171 @@
+#pragma once
+
+#include "ddkit/access/DdsWrap.hpp"
+#include "ddkit/access/Dispatcher.hpp"
+#include "ddkit/access/Topic.hpp"
+#include "ddkit/access/Listener.hpp"
+#include "ddkit/access/ConnectState.hpp"
+
+namespace ddkit {
+namespace access {
+
+#if defined(DDS_VENDOR_CONNEXT)
+#define DDKIT_USE_KEY_VALUE ON
+#ifdef _WIN32
+#define DDKIT_COND_TYPE_UNUSED
+#else
+#define DDKIT_COND_TYPE_UNUSED dds::core::cond::Condition
+#endif
+#elif defined(DDS_VENDOR_CYCLONE)
+#define DDKIT_COND_TYPE_UNUSED dds::core::cond::Condition
+#elif defined(DDS_VENDOR_OPENSPLICE)
+#define DDKIT_COND_TYPE_UNUSED dds::core::cond::Condition
+#else
+#error "DDS_VENDOR not set"
+#endif
+
+
+template <typename T>
+class Reader final {
+public:
+    Reader(
+        std::shared_ptr<access::Dispatcher> dispatcher,
+        std::shared_ptr<Topic<T>> topic,
+        dds::sub::qos::DataReaderQos dataReaderQos,
+        dds::sub::qos::SubscriberQos subQos,
+        std::function<void(T const&)> funcWrite,
+        std::function<void(T const&)> funcDispose)
+        : m_dispatcher(dispatcher)
+        , m_connectState(std::make_shared<ConnectState>(topic->topicName(), topic->topicNameModule(), topic->topicNameTopic()))
+        , m_listener(std::make_shared<ListenerRead<T> >(m_connectState))
+        , m_ddsReader(dataReader(topic, m_listener.get(), dataReaderQos, subQos))
+        , m_dataState(dds::sub::status::DataState::any())
+        , m_shutdownRequest(false)
+        , m_funcWrite(funcWrite)
+        , m_funcDispose(funcDispose)
+        , m_func([this](DDKIT_COND_TYPE_UNUSED) {
+
+            DDKIT_LOG_TRACE;
+
+            const dds::sub::LoanedSamples<T> samples = m_ddsReader.select().state(m_dataState).take();
+            for (const auto& sample : samples) {
+                if (m_shutdownRequest) return; // fast exit
+
+                const auto& sampleInfo = sample.info();
+#ifdef DDKIT_USE_KEY_VALUE
+                const auto& instanceHandle = sampleInfo.instance_handle();
+#endif
+                const auto& dataState = sampleInfo.state();
+                const auto& instanceState = dataState.instance_state();
+
+                using namespace dds::sub::status;
+                ddkit::log::trace() << "Sample alive:" << (instanceState == InstanceState::alive());
+                ddkit::log::trace() << "Sample disposed:" << (instanceState == InstanceState::not_alive_disposed());
+                ddkit::log::trace() << "Sample no_writers:" << (instanceState == InstanceState::not_alive_no_writers());
+
+                // How to get partition of sending writer
+                // only connext and cyclone > 0.10
+                // auto pubData = dds::sub::matched_publication_data(m_ddsReader, sampleInfo.publication_handle());
+                // for (auto& n : pubData.partition()->name()) {
+                //     std::cout << "Partition: " << n << std::endl;
+                // }
+
+                if (sampleInfo.valid() && instanceState == InstanceState::alive()) {
+                    const T& t = sample.data();
+
+                    // callback
+                    if (m_funcWrite) {
+                        ddkit::log::debug() << "received: " << t << ". Callbacking user ...";
+                        m_funcWrite(t);
+                        ddkit::log::trace() << "... usercallback called.";
+                    }
+                } else {
+
+                    if (m_funcDispose) {
+#ifdef DDKIT_USE_KEY_VALUE
+                        // - 'key_value()' works perfectly for connext
+                        //   (and for cyclone+opensplice while explicitly disposing)
+                        // - no (positive) effect on cross-vendor (see top of file)
+                        // - so it is best to stay with native sample.data() for cyclone+opensplice but
+                        //   use simple key_value for connext
+                        T t;
+                        m_ddsReader.key_value(t, instanceHandle);
+#else
+                        // - vendors, that are able to fetch the key even on dispose-calls via sample.data()
+                        //   (they fill in default-ctor-data in the other attrs, because only the key has
+                        //    to be transferred via DDS for dispose - same definition on our API - fine).
+                        const T& t = sample.data();
+#endif
+                        ddkit::log::debug() << "received for disposing: " << t << ". Callbacking user ...";
+                        m_funcDispose(t);
+                        ddkit::log::trace() << "... usercallback called.";
+                    }
+                }
+            }
+        })
+        , m_readCondition(m_ddsReader, m_dataState, m_func) {
+        DDKIT_LOG_TRACE;
+        m_dispatcher->addReadCondition(m_readCondition);
+    }
+
+    ~Reader() {
+        DDKIT_LOG_TRACE;
+
+        unload();
+        m_ddsReader.close();
+    }
+
+    void unload() {
+        if (!m_shutdownRequest) {
+            m_shutdownRequest = true;
+            m_dispatcher->removeReadCondition(m_readCondition);
+        }
+    }
+
+    IConnectCheckPtr getConnectCheck() {
+        return m_connectState;
+    }
+
+private:
+    std::shared_ptr<Dispatcher> m_dispatcher;
+    ConnectStatePtr m_connectState;
+    std::shared_ptr<ListenerRead<T>> m_listener;
+    dds::sub::DataReader<T> m_ddsReader;
+    dds::sub::status::DataState m_dataState;
+
+    std::atomic<bool> m_shutdownRequest;
+    std::function<void(T const&)> m_funcWrite;
+    std::function<void(T const&)> m_funcDispose;
+    std::function<void(DDKIT_COND_TYPE_UNUSED)> m_func;
+    dds::sub::cond::ReadCondition m_readCondition;
+
+    /// Note on reader-listeners: see writer-listeners in Writer.hpp
+    static dds::sub::DataReader<T> dataReader(
+        std::shared_ptr<Topic<T>> topic,
+        ListenerRead<T>* listener,
+        dds::sub::qos::DataReaderQos dataReaderQos,
+        dds::sub::qos::SubscriberQos subQos) {
+
+        DDKIT_LOG_TRACE;
+
+        dds::sub::DataReader<T> ddsReader = dds::sub::DataReader<T>(
+            dds::sub::Subscriber(topic->domainParticipant(), subQos),
+            topic->ddsTopic(),
+            dataReaderQos,
+            listener,
+            dds::core::status::StatusMask::all());
+
+        return ddsReader;
+    }
+
+    // no copying
+    Reader(Reader const&) = delete;
+    Reader(Reader&&)      = delete;
+    void operator=(Reader const&) = delete;
+};
+
+#undef DDKIT_USE_KEY_VALUE
+#undef DDKIT_COND_TYPE_UNUSED
+
+} // namespace access
+} // namespace ddkit