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

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

@@ -0,0 +1,90 @@
+#pragma once
+
+#include "ddkit/utils/Logger.hpp"
+
+
+namespace ddkit {
+namespace actors {
+
+//
+// IComponent, IObserver, ISender
+//
+
+// IObserver or ISender
+class IComponent {
+
+public:
+    virtual std::string module()     = 0;
+    virtual bool        isService()  = 0; // caution: these method-names refer to Service and Client (Actor),
+    virtual bool        isObserver() = 0; //          in which the Sender/Observer live, not to IService/IClient!
+
+    // exceptionally we have (very lightweight) convenience-methods in the interface as well
+    inline bool isClient() { return !isService(); }
+    inline bool isSender() { return !isObserver(); }
+
+    virtual ~IComponent() = default;
+};
+
+class IObserver : public IComponent {
+
+public:
+    // IComponent
+    std::string module() override    = 0;
+    bool        isService() override = 0;
+    bool        isObserver() override { return true; }
+
+    virtual void clearCallbacks() {}
+
+    virtual ~IObserver() = default;
+};
+typedef std::shared_ptr<IObserver> IObserverPtr;
+
+class ISender : public IComponent {
+
+public:
+    // IComponent
+    std::string module() override    = 0;
+    bool        isService() override = 0;
+    bool        isObserver() override { return false; }
+
+    virtual ~ISender() = default;
+};
+typedef std::shared_ptr<ISender> ISenderPtr;
+
+
+//
+// static_asserts to be included in every template-function
+//
+// observer w/o object - call checkTypeOfObserver<Observer>();
+template <typename Observer>
+void checkObserverType() {
+    DDKIT_LOG_TRACE;
+    static_assert(std::is_base_of<IObserver, Observer>::value, "Observer not derived from IObserver");
+    static_assert(!std::is_same<IObserver, Observer>::value, "Observer same class as IObserver");
+}
+
+// observer with object - simply call checkTypeOfObserver(observer);
+template <typename Observer>
+void checkTypeOfObserver(Observer* observer) {
+    DDKIT_LOG_TRACE << DDKIT_LOG_VAR_VALUE(observer);
+    checkObserverType<Observer>();
+}
+
+// sender w/o object - call checkSenderType<Sender>();
+template <typename Sender>
+void checkSenderType() {
+    DDKIT_LOG_TRACE;
+    static_assert(std::is_base_of<ISender, Sender>::value, "Sender not derived from ISender");
+    static_assert(!std::is_same<ISender, Sender>::value, "Sender same class as ISender");
+    static_assert(std::is_base_of<typename Sender::TypeUser, Sender>::value, "Sender not derived from TypeUser");
+}
+
+// sender with object - simply call checkTypeOfSender(sender);
+template <typename Sender>
+void checkTypeOfSender(Sender* sender) {
+    DDKIT_LOG_TRACE << DDKIT_LOG_VAR_VALUE(sender);
+    checkSenderType<Sender>();
+}
+
+} // namespace actors
+} // namespace ddkit