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

external/tmsif/include/ddkit/actors/SimpleActor.hpp

@@ -0,0 +1,213 @@
+#pragma once
+
+#include "ddkit/utils/assert.hpp"
+#include "ddkit/access/TopicPoolRead.hpp"
+#include "ddkit/access/TopicPoolWrite.hpp"
+#include "ddkit/actors/CallbackInfo.hpp"
+#include "ddkit/actors/IActor.hpp"
+#include "ddkit/actors/SessionImpl.hpp"
+#include "ddkit/idls/ActorInfo.hpp"
+#include "ddkit/actors/Key.hpp"
+#include "ddkit/utils/CallbackWrapper.hpp"
+
+#include <string>
+#include <map>
+
+
+namespace ddkit {
+namespace actors {
+
+class SimpleActor : public IActor {
+
+public:
+    SimpleActor(const SessionImplPtr& sessionImpl,
+                const std::string& serviceName,
+                bool isService,
+                const std::string& module);
+
+    ~SimpleActor();
+
+    bool hasObserver();
+    bool hasSender();
+
+    access::TopicPoolRead& topicPoolRead();
+    access::TopicPoolWrite& topicPoolWrite();
+
+    std::string moduleName() const;
+    bool isService() const;
+    int domain() const;
+    std::string serviceName() const;
+    ActorConfiguration config() const;
+
+    std::string actorId() const;
+
+    bool operator==(const SimpleActor& other) const;
+
+    void setClientName(const std::string& clientName);
+
+    void waitUntilConnected();
+
+    void addConnectCheck(access::IConnectCheckPtr connectCheck);
+
+    // template-class-parameters Observer and Sender in the following methods must be the 'reader-class'
+    // respectively the 'writer-class' of one of the rmodel-modules. They are called Observer and Sender
+    // in the corresponding namespace and inherit the interface IObserver/ISender. They define a typedef TypeUser
+    // to refer to the API-Interface-Type IClient/IService. Sender also inherits its TypeUser-Type
+
+    /// @brief  - needed for access from generated Service/Client, to call write-stuff
+    template <typename Sender>
+    ISenderPtr sender() {
+        DDKIT_LOG_TRACE;
+        checkSenderType<Sender>();
+
+        if (hasSender()) {
+            std::shared_ptr<Sender> sender = std::dynamic_pointer_cast<Sender>(m_sender); // Sender inherits ISender
+            if (sender) {
+                checkTypeOfSender(sender.get());
+                return sender;
+            }
+        }
+
+        return nullptr;
+    }
+    
+    ISenderPtr sender() {
+        return m_sender;
+    }
+
+    IObserverPtr observer() {
+        return m_observer;
+    }
+
+    bool hasSession() {
+        return !m_sessionImplWeak.expired();
+    }
+
+    template <typename Observer>
+    IObserverPtr createObserver(typename Observer::TypeUser& callbacks, const std::vector<std::string>& methods) {
+
+        ddkit::log::info() << "Create observer";
+
+        SessionImplPtr sessionImpl = m_sessionImplWeak.lock();
+        if (!sessionImpl) {
+            throw std::runtime_error("Failure locking std::weak_ptr<SessionImpl> in ActorImpl");
+        }
+
+        checkObserverType<Observer>();
+
+        typename Observer::TypeUser* userCallback = &callbacks; // (keep * inside ... else problems with capturing)
+
+        // insert observer
+        DDKIT_THROW_ON_FALSE_INFO(
+            !hasObserver(),
+            "Inserting an observer to an actor already containing one."
+            "Called ObsFactory::add() twice? (same serviceName + domain)");
+        m_observer = std::make_shared<Observer>(*this, m_topicPoolRead, methods, userCallback);
+        DDKIT_THROW_ON_FALSE_INFO(hasObserver(), "creation of observer failed");
+
+        // update actorInfo
+        if (m_actorInfo.isReading()) {
+            ddkit::log::warn() << "SimpleActor::createObserver: " << "actor is already reading";
+        }
+        m_actorInfo.isReading() = true;
+        m_actorInfo.openReaders() = methods; // only vectors on dds
+
+        sessionImpl->publishActorInfo(m_actorInfo);
+
+        return m_observer;
+    }
+
+    template <typename Observer>
+    IObserverPtr createObserver(std::map<std::string, std::vector<ddkit::callback::Base*>> callbacks, const std::vector<std::string> methods) {
+
+        ddkit::log::info() << "Create observer";
+
+        SessionImplPtr sessionImpl = m_sessionImplWeak.lock();
+        if (!sessionImpl) {
+            throw std::runtime_error("Failure locking std::weak_ptr<SessionImpl> in ActorImpl");
+        }
+
+        checkObserverType<Observer>();
+
+        // insert observer
+        DDKIT_THROW_ON_FALSE_INFO(
+            !hasObserver(),
+            "Inserting an observer to an actor already containing one."
+            "Called ObsFactory::add() twice? (same serviceName + domain)");
+        m_observer = std::make_shared<Observer>(*this, m_topicPoolRead, methods, callbacks);
+        DDKIT_THROW_ON_FALSE_INFO(hasObserver(), "creation of observer failed");
+
+        // update actorInfo
+        if(m_actorInfo.isReading()) {
+            ddkit::log::warn() << "SimpleActor::createObserver: actor is already reading";
+        }
+        m_actorInfo.isReading()   = true;
+        m_actorInfo.openReaders() = methods; // only vectors on dds
+
+        sessionImpl->publishActorInfo(m_actorInfo);
+
+        return m_observer;
+    }
+
+    template <typename Sender>
+    ISenderPtr createSender(const std::vector<std::string>& methods) {
+
+        ddkit::log::info() << "Create sender";
+
+        SessionImplPtr sessionImpl = m_sessionImplWeak.lock();
+        if (!sessionImpl) {
+            throw std::runtime_error("Failure locking std::weak_ptr<SessionImpl> in ActorImpl");
+        }
+
+        checkSenderType<Sender>();
+
+        DDKIT_THROW_ON_FALSE_INFO(
+            !hasSender(),
+            "Inserting a sender to an actor already containing one. "
+            "Called Factory::create() twice? (same serviceName + domain)");
+        m_sender = std::make_shared<Sender>(*this, m_topicPoolWrite);
+        Sender* sender2 = dynamic_cast<Sender*>(m_sender.get());
+        checkTypeOfSender(sender2);
+        DDKIT_THROW_ON_FALSE(sender2);
+        DDKIT_THROW_ON_FALSE(hasSender());
+
+        // update actorInfo
+        if (m_actorInfo.isWriting()) {
+            ddkit::log::warn() << "SimpleActor::createSender: " << "actor is already writing";
+        }
+        m_actorInfo.isWriting()   = true;
+        m_actorInfo.openWriters() = methods; // only vectors on dds
+        sessionImpl->publishActorInfo(m_actorInfo);
+        return m_sender;
+    }
+
+    void discardSender();
+    void discardObserver();
+    bool isValid() override;
+    void shutdown() override;
+    bool shutdownRequested();
+
+    CallbackInfo callbackInfoBase();
+    CallbackInfo callbackInfo();
+    void setCallbackInfo(CallbackInfo callbackInfo);
+    void resetCallbackInfo();
+
+private:
+    ddkit_intern::ActorInfo m_actorInfo;
+
+    access::IQosStrategyPtr m_qosStrategy;
+    access::ITopicStrategyPtr m_topicStrategy;
+    access::TopicPoolRead m_topicPoolRead;
+    access::TopicPoolWrite m_topicPoolWrite;
+    std::vector<access::IConnectCheckPtr> m_connectCheckSet;
+
+    IObserverPtr m_observer; // or nullptr, if none
+    ISenderPtr m_sender;   // or nullptr, if none
+
+    CallbackInfo m_callbackInfoBase;
+
+    std::atomic<bool> m_shutdownRequested;
+};
+
+} // namespace actors
+} // namespace ddkit