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

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

@@ -0,0 +1,137 @@
+#pragma once
+
+#include "ddkit/access/TopicPool.hpp"
+#include "ddkit/access/Topic.hpp"
+#include "ddkit/access/Writer.hpp"
+
+#include "ddkit/utils/system.hpp"
+
+namespace ddkit {
+namespace access {
+
+class TopicPoolWrite final {
+
+public:
+    TopicPoolWrite(
+        Participant& participant, const IQosStrategyPtr& qosStrategy, const ITopicStrategyPtr& topicStrategy);
+    ~TopicPoolWrite();
+
+    // create or get writer
+    template <typename T>
+    std::shared_ptr<Writer<T>> writer() {
+        DDKIT_LOG_TRACE;
+        std::unique_lock<std::recursive_mutex> lock(m_mutex);
+
+        createTopicWriteIf<T>(); // must be done here and not in Topic (because TopicPool and qos access needed)
+
+        std::shared_ptr<Topic<T>> topic = m_topicPool.topic<T>();
+        if(topic) {
+            auto writer = topic->writer();
+            if(!writer){
+                ddkit::log::error() << "TopicPoolWrite::writer: no writer in topic";
+            }
+            return writer;
+        } else {
+            ddkit::log::error() << "TopicPoolWrite::writer: no topic in topic pool";
+        }
+        return nullptr;    
+    }
+
+    // shortcut, no interface+virtual possible (templates)
+    template <class T>
+    void write(T const& t) {
+        bool isOkUnconnected    = false;
+        bool isThrowUnconnected = false;
+        writeIntern(t, isOkUnconnected, isThrowUnconnected);
+    }
+
+    template <class T>
+    void writeUnconnectedOk(T const& t) {
+        bool isOkUnconnected    = true;
+        bool isThrowUnconnected = false;
+        writeIntern(t, isOkUnconnected, isThrowUnconnected);
+    }
+
+    template <class T>
+    void writeUnconnectedThrow(T const& t) {
+        bool isOkUnconnected    = false;
+        bool isThrowUnconnected = false;
+        writeIntern(t, isOkUnconnected, isThrowUnconnected);
+    }
+
+private:
+    template <typename T>
+    void writeIntern(T const& t, bool isOkUnconnected, bool isThrowUnconnected) {
+        ddkit::log::trace() << "writing " << dds::topic::topic_type_name<T>::value() << ":" << t;
+
+        createTopicWriteIf<T>();
+
+        std::unique_lock<std::recursive_mutex> lock(m_mutex);
+
+        auto currentWriter = writer<T>();
+        if(currentWriter){
+            currentWriter->send(t, isOkUnconnected, isThrowUnconnected);
+        } else {
+            ddkit::log::error() << "TopicPoolWrite::writeIntern: no writer in topic pool";
+        }
+    }
+
+    template <typename T>
+    void createTopicWrite() {
+        std::unique_lock<std::recursive_mutex> lock(m_mutex);
+        std::string topicName = m_topicPool.getTopicName<T>();
+        std::shared_ptr<Topic<T>>   topic     = m_topicPool.topic<T>();
+        std::string typeName  = topic->typeName();
+
+        if(!topic) {
+            ddkit::log::error() << "TopicPoolWrite::createTopicWrite: no topic in topic pool.";
+            return;
+        }
+        if(topic->hasWriter()) {
+            ddkit::log::error() << "TopicPoolWrite::createTopicWrite: Writer (" << topicName << ") already exists.";
+            return;
+        }
+
+
+        QosPattern                   qosPattern    = m_topicPool.qosPattern(typeName);
+        dds::pub::qos::DataWriterQos dataWriterQos = qosPattern.qosWrite();
+        dds::pub::qos::PublisherQos pubQos = qosPattern.qosPub();
+
+        auto writer = std::make_shared<Writer<T>>(topic, dataWriterQos, pubQos);
+        topic->setWriter(writer);
+    }
+
+    template <class T>
+    void createTopicWriteIf() {
+        std::unique_lock<std::recursive_mutex> lock(m_mutex);
+        std::shared_ptr<Topic<T>> topic = m_topicPool.topic<T>();
+        if (topic && !topic->hasWriter()) {
+            createTopicWrite<T>();
+        }
+    }
+
+public:
+    template <class T>
+    void dispose(T const& t) {
+        std::unique_lock<std::recursive_mutex> lock(m_mutex);
+
+        auto currentWriter = writer<T>();
+        if(currentWriter){
+            currentWriter->dispose(t);
+        } else {
+            ddkit::log::error() << "TopicPoolWrite::dispose: no writer in topic pool";
+        }
+    }
+
+    void closeWriters();
+
+private:
+    std::recursive_mutex m_mutex;
+    TopicPool m_topicPool;
+
+    TopicPoolWrite(TopicPoolWrite const&) = delete;
+    void operator=(TopicPoolWrite const&) = delete;
+};
+
+} // namespace access
+} // namespace ddkit