...

net/adc_device_netserver.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include "adc_device_netmsg.h"
 #include "adc_netserver.h"
 
 namespace adc
@@ -9,13 +10,94 @@ namespace adc
 class AdcDeviceNetServer : public AdcGenericNetServer
 {
 public:
-    class Session
+    template <interfaces::adc_netservice_c NetServiceT>
+    class Session : std::enable_shared_from_this<Session<NetServiceT>>
     {
     public:
-        void start() {}
+        typedef std::string netsession_ident_t;
-        void stop() {}
+        typedef NetServiceT netservice_t;
+        typedef AdcDeviceNetServer* netsession_ctx_t;
+
+        template <traits::adc_input_char_range R>
+        Session(R&& id, netservice_t srv, netsession_ctx_t ctx) : _ident(), _netService(std::move(srv)), _context(ctx)
+        {
+            if constexpr (std::is_array_v<std::remove_cvref_t<R>>) {
+                _ident = id;
+            } else {
+                _ident = netsession_ident_t(id.begin(), id.end());
+            }
+        }
+
+        netsession_ident_t ident() const
+        {
+            return _ident;
+        }
+
+        void start()
+        {
+            _netService.asyncReceive(
+                [this](std::error_code ec, std::vector<char> msg) {
+                    if (ec) {
+                        stop();
+                    } else {
+                        auto msg_sptr = std::make_shared<std::vector<char>>(std::move(msg));
+
+                        AdcDeviceProtoMessage dev_msg(*msg_sptr);
+
+                        handleMessage(dev_msg);
+
+                        _netService.asyncSend(
+                            *msg_sptr,
+                            [msg_sptr, this](std::error_code ec) {
+                                if (ec) {
+                                    stop();
+                                } else {
+                                    start();
+                                }
+                            },
+                            _sendTimeout);
+                    }
+                },
+                _recvTimeout);
+        }
+
+        void stop()
+        {
+            _netService.close();
+        }
+
+    protected:
+        netsession_ident_t _ident;
+        netservice_t _netService;
+        netsession_ctx_t _context;
+
+        std::chrono::duration<size_t> _recvTimeout = std::chrono::seconds(3600);
+        std::chrono::duration<size_t> _sendTimeout = std::chrono::seconds(5);
+
+        void handleMessage(auto& msg)
+        {
+            if (msg.isACK()) {
+                msg.ack();
+            } else if (msg.isNAMES()) {
+            } else if (msg.isHELLO()) {
+            } else if (msg.isGET()) {
+            } else if (msg.isSET()) {
+            } else if (msg.isCMD()) {
+                msg.ack();
+            } else {
+                msg.err(std::error_code{});  // !!!!!!!!!!!!
+            }
+        }
     };
 
+
+    using AdcGenericNetServer::AdcGenericNetServer;
+
+    template <typename DeviceT>
+    AdcDeviceNetServer& addDevice(DeviceT* dev_ptr)
+    {
+    }
+
 protected:
 };
 

net/adc_netserver.h

@@ -176,6 +176,15 @@ protected:
 public:
     typedef std::string server_ident_t;
 
+    template <traits::adc_input_char_range R>
+    AdcGenericNetServer(R&& id) : _serverIdent()
+    {
+        if constexpr (std::is_array_v<std::remove_cvref_t<R>>) {
+            _serverIdent = id;
+        } else {
+            _serverIdent = server_ident_t{id.begin(), id.end()};
+        }
+    }
 
     virtual ~AdcGenericNetServer() = default;
 
@@ -192,7 +201,7 @@ public:
                const typename SessionT::netsession_ctx_t& sess_ctx,
                AcceptorCtorArgTs&&... ctor_args)
     {
-        if (!_isListening<SessionT>[this]) {
+        if (!_isListening<SessionT>[this][id]) {
             auto acceptor = std::make_shared<typename SessionT::netservice_t::acceptor_t>(
                 std::forward<AcceptorCtorArgTs>(ctor_args)...);
 
@@ -259,29 +268,33 @@ protected:
 };
 
 
-template <typename SocketT>
+template <interfaces::adc_netservice_c NetServiceT>
 class AdcAbstractNetServer
 {
 public:
-    struct ServerControls {
+    struct ServerEvents {
-        std::function<void(SocketT*)> onOpen;
+        std::function<void(NetServiceT*)> onOpen;
-        std::function<void(SocketT*, std::error_code)> onClose;
+        std::function<void(NetServiceT*, std::error_code)> onClose;
-        std::function<void(SocketT*, std::span<const char>)> onData;
+        std::function<void(NetServiceT*, std::span<const char>)> onData;
-        std::function<void(SocketT*, std::error_code)> onError;
+        std::function<void(NetServiceT*, std::error_code)> onError;
     };
 
 
-    AdcAbstractNetServer(ServerControls&& ctls) : _serverControls(std::move(ctls)) {}
+    AdcAbstractNetServer(ServerEvents&& events) : _serverEvents(std::move(events)) {}
 
-    template <typename EnptT>
+    template <typename... AcceptorCtorArgTs>
-    void listen(const EnptT& endpoint)
+    void listen(const typename NetServiceT::endpoint_t& endpoint, AcceptorCtorArgTs&&... ctor_args)
     {
+        auto acceptor =
+            std::make_shared<typename NetServiceT::acceptor_t>(endpoint, std::forward<AcceptorCtorArgTs>(ctor_args)...);
     }
 
     void stop() {}
 
 protected:
-    ServerControls _serverControls;
+    ServerEvents _serverEvents;
+
+    typename NetServiceT::acceptor_t _acceptor;
 };