...

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