...

net/adc_netserver.h

@@ -21,17 +21,40 @@ namespace adc
 {
 
 
-/*  Server session and its abstract decorator  */
+namespace traits
+{
 
-template <typename ImplT>
+// network server session implementation concept
+template <typename T>
+concept adc_netserver_session_impl_c = requires(T t, const T t_const) {
+    typename T::session_ident_t;
+
+    { t_const.sessionIdent() } -> std::same_as<typename T::session_ident_t>;
+    { t.start() } -> std::same_as<void>;
+    { t.stop() } -> std::same_as<void>;
+};
+
+}  // namespace traits
+
+
+
+/*  Server session  */
+
+template <traits::adc_netserver_session_impl_c ImplT>
 class AdcNetServerSession : std::enable_shared_from_this<AdcNetServerSession<ImplT>>
 {
+protected:
+    ImplT _impl;
+
 public:
-    using shared_ptr_t = std::shared_ptr<AdcNetServerSession>;
-    using weak_ptr_t = std::weak_ptr<AdcNetServerSession>;
+    typedef ImplT session_impl_t;
+    typedef std::shared_ptr<AdcNetServerSession> shared_ptr_t;
+    typedef std::weak_ptr<AdcNetServerSession> weak_ptr_t;
+
+    using typename ImplT::session_ident_t;
 
     template <typename... ImplCtorArgTs>
-    AdcNetServerSession(ImplCtorArgTs&&... ctor_args) : _implUptr(std::forward<ImplCtorArgTs>(ctor_args)...)
+    AdcNetServerSession(ImplCtorArgTs&&... ctor_args) : _impl(std::forward<ImplCtorArgTs>(ctor_args)...)
     {
     }
 
@@ -39,63 +62,72 @@ public:
     virtual ~AdcNetServerSession() = default;
 
 
-    auto sessionIdent() const
+    virtual session_ident_t sessionIdent() const
     {
         //
-        return _implUptr->_sessionIdent();
+        return _impl._sessionIdent();
     }
 
 
     virtual void start()
     {
         //
-        _implUptr->start();
+        _impl.start();
     }
 
     virtual void stop()
     {
         //
-        _implUptr->stop();
+        _impl.stop();
     }
-
-protected:
-    std::unique_ptr<ImplT> _implUptr;
 };
 
 
-template <typename ImplT, std::derived_from<AdcNetServerSession<ImplT>> SessionT>
-class AdcNetServerSessionDecorator : public SessionT
+
+namespace traits
 {
-public:
-    using SessionT::sessionIdent;
 
-    template <typename... ImplCtorArgTs>
-    AdcNetServerSessionDecorator(ImplCtorArgTs&&... ctor_args) : SessionT(std::forward<ImplCtorArgTs>(ctor_args)...)
-    {
-    }
+// network server session concept
+template <typename T>
+concept adc_netserver_session_c = requires {
+    typename T::session_impl_t;
 
-    virtual ~AdcNetServerSessionDecorator() = default;
-
-    virtual std::invoke_result_t<decltype(sessionIdent)> sessionIdent() const = 0;
-
-    virtual void start() = 0;
-
-    virtual void stop() = 0;
+    std::derived_from<T, AdcNetServerSession<typename T::session_impl_t>>;
 };
 
+}  // namespace traits
 
 
-/*  Server  */
+/*  network server   */
 
-template <typename ImplT>
+namespace traits
+{
+
+template <typename T>
+concept adc_netserver_impl_c = requires(T t, const T t_const) {
+    typename T::server_ident_t;
+
+    { t_const.serverIdent() } -> std::same_as<typename T::server_ident_t>;
+    { t.start() } -> std::same_as<void>;
+    { t.stop() } -> std::same_as<void>;
+    { t.daemonizePrepare() } -> std::same_as<void>;
+    { t.daemonizeFinalize() } -> std::same_as<void>;
+};
+
+}  // namespace traits
+
+template <traits::adc_netserver_impl_c ImplT>
 class AdcNetServer
 {
 protected:
-    std::unique_ptr<ImplT> _implUptr;
+    ImplT _impl;
 
 public:
+    typedef ImplT server_impl_t;
+    using typename ImplT::server_ident_t;
+
     template <typename... ImplCtorArgTs>
-    AdcNetServer(ImplCtorArgTs&&... ctor_args) : _implUptr(std::make_unique<ImplT>(ctor_args)...)
+    AdcNetServer(ImplCtorArgTs&&... ctor_args) : _impl(std::make_unique<ImplT>(ctor_args)...)
     {
     }
 
@@ -103,18 +135,27 @@ public:
     virtual ~AdcNetServer() = default;
 
 
-    virtual void start() = 0;
+    virtual server_ident_t serverIdent() const
+    {
+        //
+        return _impl.serverIdent();
+    }
 
-    virtual void stop() = 0;
+    virtual void start()
+    {
+        //
+        _impl.start();
+    };
 
-    template <typename SessionT>
-    void start() {};
+    virtual void stop()
+    {
+        //
+        _impl.stop();
+    };
 
-    template <typename SessionT>
-    void stop() {};
 
     // run server as daemon (still only on POSIX OSes)
-    void daemonize()
+    virtual void daemonize()
     {
         daemonizePrepare();
 
@@ -161,9 +202,34 @@ public:
         daemonizeFinalize();
     }
 
-    virtual void daemonizePrepare() = 0;
 
-    virtual void daemonizeFinalize() = 0;
+protected:
+    virtual void daemonizePrepare()
+    {
+        //
+        _impl.daemonizePrepare();
+    };
+
+    virtual void daemonizeFinalize()
+    {
+        //
+        _impl.daemonizeFinalize();
+    };
 };
 
+
+namespace traits
+{
+
+// network server concept
+template <typename T>
+concept adc_netserver_c = requires {
+    typename T::server_impl_t;
+    std::derived_from<T, AdcNetServer<typename T::server_impl_t>>;
+};
+
+}  // namespace traits
+
+
+
 }  // namespace adc

net/adc_netserver_spdlog.h

@@ -0,0 +1,151 @@
+#pragma once
+
+/*
+
+ABSTRACT DEVICE COMPONENTS LIBRARY
+
+    spdlog-library extensions
+
+*/
+
+
+#ifdef USE_SPDLOG_LIBRARY
+
+#include <spdlog/logger.h>
+
+#include "../common/adc_traits.h"
+#include "adc_netserver.h"
+
+namespace adc
+{
+
+template <traits::adc_netserver_session_c SessionT>
+class AdcNetServerSessionSpdlogDecorator : public SessionT
+{
+protected:
+    std::shared_ptr<spdlog::logger> _logger;
+
+    void* _thisAddress;
+    std::string _sessionID;
+
+public:
+    // using SessionT::sessionIdent;
+    using typename SessionT::session_ident_t;
+
+    static_assert(traits::formattable<session_ident_t>, "NETWORK SESSION IDENT TYPE MUST BE A FORMATTABLE ONE!!!");
+
+    template <typename... ImplCtorArgTs>
+    AdcNetServerSessionSpdlogDecorator(std::shared_ptr<spdlog::logger> logger, ImplCtorArgTs&&... ctor_args)
+        : SessionT(std::forward<ImplCtorArgTs>(ctor_args)...),
+          _logger(logger),
+          _thisAddress((void*)std::addressof(this))
+    {
+        fmt::format_to(std::back_inserter(_sessionID), "{}", SessionT::sessionIdent());
+
+        _logger->trace("Call AdcNetServerSessionSpdlogDecorator::AdcNetServerSessionSpdlogDecorator (this: {})",
+                       _thisAddress);
+
+        _logger->debug("Creating network server session with ID = [{}] (ADDR = {})", _sessionID, _thisAddress);
+        _logger->debug("use logger with name [{}] and level [{}]", _logger->name(),
+                       spdlog::level::to_string_view(_logger->level()));
+    }
+
+    virtual ~AdcNetServerSessionSpdlogDecorator()
+    {
+        _logger->trace("Call AdcNetServerSessionSpdlogDecorator::~AdcNetServerSessionSpdlogDecorator (this: {})",
+                       _thisAddress);
+
+        _logger->debug("Deleting network server session with ID = [{}] (ADDR = {})", _sessionID, _thisAddress);
+
+        _logger->flush();
+    };
+
+    virtual session_ident_t sessionIdent() const override
+    {
+        _logger->trace("Call AdcNetServerSessionSpdlogDecorator::sessionIdent (this: {})", _thisAddress);
+
+        return SessionT::sessionIdent();
+    };
+
+    virtual void start() override
+    {
+        _logger->trace("Call AdcNetServerSessionSpdlogDecorator::start (this: {})", _thisAddress);
+
+        _logger->info("Starting network server session with ID = [{}] (ADDR = {})", _sessionID, _thisAddress);
+
+        SessionT::start();
+    };
+
+    virtual void stop() override
+    {
+        _logger->trace("Call AdcNetServerSessionSpdlogDecorator::stop (this: {})", _thisAddress);
+
+        _logger->info("Stopping network server session with ID = [{}] (ADDR = {})", _sessionID, _thisAddress);
+
+        SessionT::stop();
+    };
+};
+
+
+
+template <traits::adc_netserver_c ServerT>
+class AdcNetServerSpdlogDecorator : public ServerT
+{
+protected:
+    std::shared_ptr<spdlog::logger> _logger;
+
+    void* _thisAddress;
+    std::string _serverID;
+
+public:
+    using typename ServerT::server_ident_t;
+
+    template <typename... ImplCtorArgTs>
+    AdcNetServerSpdlogDecorator(std::shared_ptr<spdlog::logger> logger, ImplCtorArgTs&&... ctor_args)
+        : ServerT(std::forward<ImplCtorArgTs>(ctor_args)...), _logger(logger), _thisAddress((void*)std::addressof(this))
+    {
+        fmt::format_to(std::back_inserter(_serverID), "{}", ServerT::serverIdent());
+
+        _logger->trace("Call AdcNetServerSpdlogDecorator::AdcNetServerSpdlogDecorator (this: {})", _thisAddress);
+
+        _logger->debug("Creating network server session with ID = [{}] (ADDR = {})", _serverID, _thisAddress);
+        _logger->debug("use logger with name [{}] and level [{}]", _logger->name(),
+                       spdlog::level::to_string_view(_logger->level()));
+    }
+
+
+    virtual ~AdcNetServerSpdlogDecorator()
+    {
+        _logger->trace("Call AdcNetServerSpdlogDecorator::~AdcNetServerSpdlogDecorator (this: {})", _thisAddress);
+
+        _logger->debug("Deleting network server with ID = [{}] (ADDR = {})", _serverID, _thisAddress);
+
+        _logger->flush();
+    }
+
+
+    virtual server_ident_t serverIdent() const
+    {
+        //
+        return ServerT::serverIdent();
+    }
+
+    virtual void start()
+    {
+        _logger->trace("Call AdcNetServerSpdlogDecorator::start (this: {})", _thisAddress);
+
+        _logger->info("Starting network server with ID = [{}] (ADDR = {})", _serverID, _thisAddress);
+
+        ServerT::start();
+    };
+
+    virtual void stop()
+    {
+        //
+        ServerT::stop();
+    };
+};
+
+}  // namespace adc
+
+#endif