fixes

CMakeLists.txt

@@ -68,7 +68,6 @@ if (ASIO_LIBRARY)
 
     set(ADC_NETWORK_HEADERS ${ADC_NETWORK_HEADERS}
         net/asio/adc_netservice_asio.h
-        net/asio/adc_netsession_asio.h
         net/asio/adc_device_netserver_asio.h
     )
 

common/adc_spdlog.h

@@ -84,37 +84,37 @@ public:
     }
 
     template <traits::formattable... ArgTs>
-    void logCritical(std::format_string<ArgTs...> fmt, ArgTs&&... args)
+    void logCritical(spdlog::format_string_t<ArgTs...> fmt, ArgTs&&... args)
     {
         _loggerSPtr->log(spdlog::level::critical, fmt, std::forward<ArgTs>(args)...);
     }
 
-    template <traits::formattable... ArgTs>
-    void logError(std::format_string<ArgTs...> fmt, ArgTs&&... args)
+    template <typename... ArgTs>
+    void logError(spdlog::format_string_t<ArgTs...> fmt, ArgTs&&... args)
     {
         _loggerSPtr->log(spdlog::level::err, fmt, std::forward<ArgTs>(args)...);
     }
 
     template <traits::formattable... ArgTs>
-    void logWarn(std::format_string<ArgTs...> fmt, ArgTs&&... args)
+    void logWarn(spdlog::format_string_t<ArgTs...> fmt, ArgTs&&... args)
     {
         _loggerSPtr->log(spdlog::level::warn, fmt, std::forward<ArgTs>(args)...);
     }
 
     template <traits::formattable... ArgTs>
-    void logInfo(std::format_string<ArgTs...> fmt, ArgTs&&... args)
+    void logInfo(spdlog::format_string_t<ArgTs...> fmt, ArgTs&&... args)
     {
         _loggerSPtr->log(spdlog::level::info, fmt, std::forward<ArgTs>(args)...);
     }
 
     template <traits::formattable... ArgTs>
-    void logDebug(std::format_string<ArgTs...> fmt, ArgTs&&... args)
+    void logDebug(spdlog::format_string_t<ArgTs...> fmt, ArgTs&&... args)
     {
         _loggerSPtr->log(spdlog::level::debug, fmt, std::forward<ArgTs>(args)...);
     }
 
     template <traits::formattable... ArgTs>
-    void logTrace(std::format_string<ArgTs...> fmt, ArgTs&&... args)
+    void logTrace(spdlog::format_string_t<ArgTs...> fmt, ArgTs&&... args)
     {
         _loggerSPtr->log(spdlog::level::trace, fmt, std::forward<ArgTs>(args)...);
     }

device/adc_device.h

@@ -157,7 +157,7 @@ public:
     template <typename... CtorArgTs>
     AdcGenericDevice& addAttribute(CtorArgTs&&... ctor_args)
     {
-        return addAttribute({std::forward<CtorArgTs>(ctor_args)...});
+        return addAttribute(AttributeT(std::forward<CtorArgTs>(ctor_args)...));
     }
 
 

net/adc_device_netclient.h

@@ -112,7 +112,6 @@ public:
 
         typedef std::vector<char> message_t;
 
-        // Session(const netsession_ident_t& id, netservice_t srv, AdcDeviceNetServer* srv_ptr)
         Session(const netsession_ident_t& id, netservice_t srv, netsession_ctx_t ctx)
             : _ident(id),
               _netService(std::move(srv)),
@@ -151,8 +150,77 @@ public:
         }
 
 
+        // general-purpose server communication methods
+
+        // blocking
+        template <traits::adc_range_of_output_char_range R, typename... ArgTs>
+        R serverCall(ServerResponseType& rtype, std::string_view key, ArgTs&&... args)
+        {
+            typename netservice_t::send_msg_t bytes;
+
+            AdcDeviceProtoMessage msg(bytes);
+            msg.setKeyValue(key, std::forward<ArgTs>(args)...);
+
+            return getFromServer<R>(key, bytes, rtype);
+        }
+
+        template <typename... ArgTs>
+        default_server_resp_t serverCall(ServerResponseType& rtype, std::string_view key, ArgTs&&... args)
+        {
+            return serverCall<default_server_resp_t>(rtype, key, std::forward<ArgTs>(args)...);
+        }
+
+
+        // asynchronous
+        template <std::convertible_to<async_callback_func_t> CallbackT, typename... ArgTs>
+        auto asyncServerCall(std::string_view key, CallbackT&& callback_func, ArgTs&&... args)
+        {
+            auto bytes = std::shared_ptr<typename netservice_t::send_msg_t>();
+
+            AdcDeviceProtoMessage msg(*bytes);
+            msg.setKeyValue(key, std::forward<ArgTs>(args)...);
+
+            asyncSendRecv(*bytes, [bytes, key, wrapper = traits::adc_pf_wrapper(std::forward<CallbackT>(callback_func)),
+                                   this](auto err, auto rmsg) mutable {
+                if (err) {
+                    _clientPtr->logError("An error occured while receiving server respond: {}",
+                                         netservice_t::formattableError(err));
+                } else {
+                    try {
+                        ServerResponseType type;
+                        auto attrs = checkServerCall<default_server_resp_t>(key, rmsg, type);
+
+                        std::forward<CallbackT>(std::get<0>(wrapper))(type, attrs);
+
+                    } catch (const std::system_error& err) {
+                        _clientPtr->logError("An error occured while getting server respond: {}", err.what());
+                    }
+                }
+            });
+        }
+
+
         // ADC device helper methods (blocking)
 
+        // send client HELLO-message
+        template <traits::adc_range_of_output_char_range R,
+                  traits::adc_input_char_range SenderNameT,
+                  typename... ParamTs>
+        R clientHello(ServerResponseType& rtype, SenderNameT&& name, ParamTs&&... params)
+        {
+            // expected respond: ACK HELLO ...
+            // return HELLO ... (or error description 'code category what')
+            return serverCall<R>(rtype, constants::ADC_DEVICE_NETPROTO_KEY_HELLO, std::forward<SenderNameT>(name),
+                                 std::forward<ParamTs>(params)...);
+        }
+
+        template <traits::adc_input_char_range SenderNameT, typename... ParamTs>
+        default_server_resp_t clientHello(ServerResponseType& rtype, SenderNameT&& name, ParamTs&&... params)
+        {
+            return clientHello<default_server_resp_t>(rtype, std::forward<SenderNameT>(name),
+                                                      std::forward<ParamTs>(params)...);
+        }
+
 
         // get names of devices
         template <traits::adc_range_of_output_char_range R>
@@ -160,7 +228,7 @@ public:
         {
             // expected respond: ACK NAMES DEV1 DEV2 ...
             // return DEV1 DEV2 ... (or error description 'code category what')
-            return deviceFuncHelper<R>(constants::ADC_DEVICE_NETPROTO_KEY_NAMES, rtype);
+            return serverCall<R>(rtype, constants::ADC_DEVICE_NETPROTO_KEY_NAMES);
         }
 
         default_server_resp_t deviceNames(ServerResponseType& rtype)
@@ -170,51 +238,49 @@ public:
 
         // bind device to the client
         template <traits::adc_range_of_output_char_range R, traits::adc_input_char_range DevNameT>
-        R bindDevice(DevNameT&& dev_name, ServerResponseType& rtype)
+        R bindDevice(ServerResponseType& rtype, DevNameT&& dev_name)
         {
             // expected respond: ACK DEVICE DEV_NAME
             // return DEV_NAME (or error description 'code category what')
-            return deviceFuncHelper<R>(constants::ADC_DEVICE_NETPROTO_KEY_DEVICE, rtype,
-                                       std::forward<DevNameT>(dev_name));
+            return serverCall<R>(rtype, constants::ADC_DEVICE_NETPROTO_KEY_DEVICE, std::forward<DevNameT>(dev_name));
         }
 
         template <traits::adc_input_char_range DevNameT>
-        default_server_resp_t bindDevice(DevNameT&& dev_name, ServerResponseType& rtype)
+        default_server_resp_t bindDevice(ServerResponseType& rtype, DevNameT&& dev_name)
         {
-            return bindDevice<default_server_resp_t>(std::forward<DevNameT>(dev_name), rtype);
+            return bindDevice<default_server_resp_t>(rtype, std::forward<DevNameT>(dev_name));
         }
 
 
         // execute a command
         template <traits::adc_range_of_output_char_range R, traits::adc_input_char_range CmdNameT>
-        R exec(CmdNameT&& cmd_name, ServerResponseType& rtype)
+        R exec(ServerResponseType& rtype, CmdNameT&& cmd_name)
         {
             // expected respond: ACK CMD CMD_NAME
             // return CMD_NAME ... (or error description 'code category what')
-            return deviceFuncHelper<R>(constants::ADC_DEVICE_NETPROTO_KEY_CMD, rtype, std::forward<CmdNameT>(cmd_name));
+            return serverCall<R>(rtype, constants::ADC_DEVICE_NETPROTO_KEY_CMD, std::forward<CmdNameT>(cmd_name));
         }
 
         template <traits::adc_input_char_range CmdNameT>
-        default_server_resp_t exec(CmdNameT&& cmd_name, ServerResponseType& rtype)
+        default_server_resp_t exec(ServerResponseType& rtype, CmdNameT&& cmd_name)
         {
-            return exec<default_server_resp_t>(std::forward<CmdNameT>(cmd_name), rtype);
+            return exec<default_server_resp_t>(rtype, std::forward<CmdNameT>(cmd_name));
         }
 
 
         // get an attribute value
         template <traits::adc_range_of_output_char_range R, traits::adc_input_char_range AttrNameT>
-        R getAttr(AttrNameT&& attr_name, ServerResponseType& rtype)
+        R getAttr(ServerResponseType& rtype, AttrNameT&& attr_name)
         {
             // expected respond: ACK GET ATTR_NAME ATTR_VALUE
             // return ATTR_NAME ATTR_VALUE (or error description 'code category what')
-            return deviceFuncHelper<R>(constants::ADC_DEVICE_NETPROTO_KEY_GET, rtype,
-                                       std::forward<AttrNameT>(attr_name));
+            return serverCall<R>(rtype, constants::ADC_DEVICE_NETPROTO_KEY_GET, std::forward<AttrNameT>(attr_name));
         }
 
         template <traits::adc_input_char_range AttrNameT>
-        default_server_resp_t getAttr(AttrNameT&& attr_name, ServerResponseType& rtype)
+        default_server_resp_t getAttr(ServerResponseType& rtype, AttrNameT&& attr_name)
         {
-            return getAttr<default_server_resp_t>(std::forward<AttrNameT>(attr_name), rtype);
+            return getAttr<default_server_resp_t>(rtype, std::forward<AttrNameT>(attr_name));
         }
 
 
@@ -227,8 +293,8 @@ public:
         {
             // expected respond: ACK SET ATTR_NAME ATTR_VALUE
             // return ATTR_NAME ATTR_VALUE (or error description 'code category what')
-            return deviceFuncHelper<R>(constants::ADC_DEVICE_NETPROTO_KEY_SET, rtype, std::forward<ValueT>(value),
-                                       std::forward<ValueTs>(values)...);
+            return serverCall<R>(constants::ADC_DEVICE_NETPROTO_KEY_SET, rtype, std::forward<AttrNameT>(attr_name),
+                                 std::forward<ValueT>(value), std::forward<ValueTs>(values)...);
         }
 
         template <traits::adc_input_char_range AttrNameT, typename ValueT, typename... ValueTs>
@@ -243,32 +309,40 @@ public:
 
         // ADC device helper methods (asynchronous)
 
+        template <std::convertible_to<async_callback_func_t> CallbackT,
+                  traits::adc_input_char_range SenderNameT,
+                  typename... ParamTs>
+        auto asyncClientHello(CallbackT&& callback_func, SenderNameT&& name, ParamTs&&... params)
+        {
+            return asyncServerCall(constants::ADC_DEVICE_NETPROTO_KEY_HELLO, std::forward<CallbackT>(callback_func),
+                                   std::forward<SenderNameT>(name), std::forward<ParamTs>(params)...);
+        }
+
         template <std::convertible_to<async_callback_func_t> CallbackT>
         auto asyncDeviceNames(CallbackT&& callback_func)
         {
-            return asyncDeviceFuncHelper(constants::ADC_DEVICE_NETPROTO_KEY_NAMES,
-                                         std::forward<CallbackT>(callback_func));
+            return asyncServerCall(constants::ADC_DEVICE_NETPROTO_KEY_NAMES, std::forward<CallbackT>(callback_func));
         }
 
         template <std::convertible_to<async_callback_func_t> CallbackT, traits::adc_input_char_range DevNameT>
         auto asyncBindDevice(CallbackT&& callback_func, DevNameT&& dev_name)
         {
-            return asyncDeviceFuncHelper(constants::ADC_DEVICE_NETPROTO_KEY_DEVICE,
-                                         std::forward<CallbackT>(callback_func), std::forward<DevNameT>(dev_name));
+            return asyncServerCall(constants::ADC_DEVICE_NETPROTO_KEY_DEVICE, std::forward<CallbackT>(callback_func),
+                                   std::forward<DevNameT>(dev_name));
         }
 
         template <std::convertible_to<async_callback_func_t> CallbackT, traits::adc_input_char_range CmdNameT>
         auto asyncExec(CallbackT&& callback_func, CmdNameT&& cmd_name)
         {
-            return asyncDeviceFuncHelper(constants::ADC_DEVICE_NETPROTO_KEY_CMD, std::forward<CallbackT>(callback_func),
-                                         std::forward<CmdNameT>(cmd_name));
+            return asyncServerCall(constants::ADC_DEVICE_NETPROTO_KEY_CMD, std::forward<CallbackT>(callback_func),
+                                   std::forward<CmdNameT>(cmd_name));
         }
 
         template <std::convertible_to<async_callback_func_t> CallbackT, traits::adc_input_char_range AttrNameT>
         auto asyncGetAttr(CallbackT&& callback_func, AttrNameT&& attr_name)
         {
-            return asyncDeviceFuncHelper(constants::ADC_DEVICE_NETPROTO_KEY_GET, std::forward<CallbackT>(callback_func),
-                                         std::forward<AttrNameT>(attr_name));
+            return asyncServerCall(constants::ADC_DEVICE_NETPROTO_KEY_GET, std::forward<CallbackT>(callback_func),
+                                   std::forward<AttrNameT>(attr_name));
         }
 
         template <std::convertible_to<async_callback_func_t> CallbackT,
@@ -277,9 +351,9 @@ public:
                   typename... ValueTs>
         auto asyncSetAttr(CallbackT&& callback_func, AttrNameT&& attr_name, ValueT&& value, ValueTs&&... values)
         {
-            return asyncDeviceFuncHelper(constants::ADC_DEVICE_NETPROTO_KEY_SET, std::forward<CallbackT>(callback_func),
-                                         std::forward<AttrNameT>(attr_name), std::forward<ValueT>(value),
-                                         std::forward<ValueTs>(values)...);
+            return asyncServerCall(constants::ADC_DEVICE_NETPROTO_KEY_SET, std::forward<CallbackT>(callback_func),
+                                   std::forward<AttrNameT>(attr_name), std::forward<ValueT>(value),
+                                   std::forward<ValueTs>(values)...);
         }
 
     protected:
@@ -297,7 +371,7 @@ public:
         // helper methods
 
         template <traits::adc_range_of_output_char_range R>
-        R checkServerRespond(std::string_view key, const auto& bytes, ServerResponseType& type) const
+        R checkServerCall(std::string_view key, const auto& bytes, ServerResponseType& type) const
         {
             AdcDeviceProtoMessage dev_msg(bytes);
 
@@ -321,47 +395,9 @@ public:
         {
             auto rbytes = sendRecv(bytes);
 
-            return checkServerRespond<R>(key, rbytes, type);
+            return checkServerCall<R>(key, rbytes, type);
         }
 
-        template <traits::adc_range_of_output_char_range R, typename... ArgTs>
-        R deviceFuncHelper(std::string_view key, ServerResponseType& rtype, ArgTs&&... args)
-        {
-            typename netservice_t::send_msg_t bytes;
-
-            AdcDeviceProtoMessage msg(bytes);
-            msg.setKeyValue(key, std::forward<ArgTs>(args)...);
-
-            return getFromServer<R>(key, bytes, rtype);
-        }
-
-
-        template <std::convertible_to<async_callback_func_t> CallbackT, typename... ArgTs>
-        auto asyncDeviceFuncHelper(std::string_view key, CallbackT&& callback_func, ArgTs&&... args)
-        {
-            auto bytes = std::shared_ptr<typename netservice_t::send_msg_t>();
-
-            AdcDeviceProtoMessage msg(*bytes);
-            msg.setKeyValue(key, std::forward<ArgTs>(args)...);
-
-            asyncSendRecv(*bytes, [bytes, key, wrapper = traits::adc_pf_wrapper(std::forward<CallbackT>(callback_func)),
-                                   this](auto err, auto rmsg) mutable {
-                if (err) {
-                    _clientPtr->logError("An error occured while receiving server respond: {}",
-                                         netservice_t::formattableError(err));
-                } else {
-                    try {
-                        ServerResponseType type;
-                        auto attrs = checkServerRespond<default_server_resp_t>(key, rmsg, type);
-
-                        std::forward<CallbackT>(std::get<0>(wrapper))(type, attrs);
-
-                    } catch (const std::system_error& err) {
-                        _clientPtr->logError("An error occured while getting server respond: {}", err.what());
-                    }
-                }
-            });
-        }
 
         template <traits::adc_input_char_range SendMsgT>
         auto sendRecv(const SendMsgT& send_msg)
@@ -394,6 +430,8 @@ public:
 };
 
 
+/*  A HELPER CLASS TO IMPLEMENT AN SIMPLE QUEUE FOR DEVICE ATTRIBUTE GET/SET OPERATIONS AND COMMAND EXECUTION  */
+
 template <traits::adc_range_of_input_char_range ArgRangeT = std::vector<std::string>>
 class AdcNetClientSendQueue
 {
@@ -415,13 +453,13 @@ public:
         return *this;
     }
 
-    template <traits::adc_input_char_range... ElemTs>
-    AdcNetClientSendQueue& addToQueue(std::string key, ElemTs&&... elems)
+    template <traits::adc_input_char_range... ArgTs>
+    AdcNetClientSendQueue& addToQueue(std::string key, ArgTs&&... elems)
     {
-        if constexpr (sizeof...(ElemTs)) {
+        if constexpr (sizeof...(ArgTs)) {
             _queue.push({key, ArgRangeT()});
 
-            addToQueueHelper(std::get<1>(_queue.back()), std::forward<ElemTs>(elems)...);
+            addToQueueHelper(std::get<1>(_queue.back()), std::forward<ArgTs>(elems)...);
         }
 
         return *this;
@@ -463,17 +501,17 @@ public:
 protected:
     std::queue<queue_elem_t> _queue;
 
-    template <traits::adc_input_char_range ElemT, traits::adc_input_char_range... ElemTs>
-    void addToQueueHelper(ArgRangeT& args, ElemT&& elem, ElemTs&&... elems)
+    template <traits::adc_input_char_range ArgT, traits::adc_input_char_range... ArgTs>
+    void addToQueueHelper(ArgRangeT& args, ArgT&& elem, ArgTs&&... elems)
     {
         using el_t = std::ranges::range_value_t<ArgRangeT>;
 
-        if constexpr (std::same_as<el_t, std::remove_cvref_t<ElemT>>) {
+        if constexpr (std::same_as<el_t, std::remove_cvref_t<ArgT>>) {
             std::ranges::copy(std::ranges::single_view(elem), std::back_inserter(args));
         } else {
             std::span<const char> sp;
 
-            if constexpr (std::is_array_v<std::remove_cvref_t<ElemT>>) {
+            if constexpr (std::is_array_v<std::remove_cvref_t<ArgT>>) {
                 sp = std::string_view(elem);
             } else {
                 sp = std::span<const char>(elem);
@@ -488,8 +526,8 @@ protected:
                               std::back_inserter(args));
         }
 
-        if constexpr (sizeof...(ElemTs)) {
-            addToQueue(args, std::forward<ElemTs>(elems)...);
+        if constexpr (sizeof...(ArgTs)) {
+            addToQueue(args, std::forward<ArgTs>(elems)...);
         }
     }
 };

net/asio/adc_netservice_asio.h

@@ -6,6 +6,7 @@
 #include <asio/basic_stream_socket.hpp>
 #include <asio/bind_executor.hpp>
 #include <asio/compose.hpp>
+#include <asio/connect.hpp>
 #include <asio/deferred.hpp>
 #include <asio/ip/tcp.hpp>
 #include <asio/ip/udp.hpp>
@@ -124,6 +125,10 @@ public:
     static constexpr bool isTLS = false;
 #endif
 
+    typedef TRANSPORT_PROTOT transport_proto_t;
+    typedef SESSION_PROTOT session_proto_t;
+    typedef RMSGT receive_msg_t;
+
     // typedefs to satisfy 'adc_netservice_c' concept
     typedef std::string_view netservice_ident_t;
 
@@ -793,6 +798,17 @@ public:
         return s;
     }
 
+
+    template <std::derived_from<AdcBaseNetServiceASIO> ST,
+              typename EptRangeT,
+              asio::completion_token_for<std::error_code, endpoint_t> CallbackT>
+    friend auto async_connect(ST& service, const EptRangeT& ept_range, CallbackT&& token)
+        requires std::ranges::range<EptRangeT> &&
+                 std::same_as<std::ranges::range_value_t<EptRangeT>, AdcBaseNetServiceASIO::endpoint_t>
+    {
+        return asio::async_connect(service._socket, ept_range, token);
+    };
+
 protected:
     static constexpr netservice_ident_t _ident =
         std::derived_from<socket_t, asio::basic_stream_socket<typename socket_t::protocol_type>>
@@ -931,7 +947,8 @@ protected:
 
 
 
-/*  */
+/*   PARTIAL AdcBaseNetServiceASIO-CLASS SPECIALIZATIONS  */
+
 template <
     adc_asio_transport_proto_c TRANSPORT_PROTOT,                          // transport-level proto (e.g. asio::ip::tcp)
     interfaces::adc_netsession_proto_c<std::string_view> SESSION_PROTOT,  // session-level proto (see ../adc_netproto.h)

net/asio/adc_netsession_asio.h

@@ -1,198 +0,0 @@
-#pragma once
-
-#include "adc_netservice_asio.h"
-
-namespace adc::impl
-{
-
-template <typename SessionContextT,
-          adc_asio_transport_proto_c TRANSPORT_PROTOT,
-          interfaces::adc_netsession_proto_c<std::string_view> SESSION_PROTOT,
-          traits::adc_output_char_range RMSGT = std::vector<char>>
-class AdcGenericNetSessionASIO : public std::enable_shared_from_this<
-                                     AdcGenericNetSessionASIO<SessionContextT, TRANSPORT_PROTOT, SESSION_PROTOT, RMSGT>>
-{
-public:
-    typedef std::string netsession_ident_t;
-
-    typedef SessionContextT netsession_ctx_t;
-
-    typedef AdcNetServiceASIOBase<TRANSPORT_PROTOT, SESSION_PROTOT, RMSGT> netservice_t;
-    typedef std::shared_ptr<netservice_t> netservice_sptr_t;
-
-    template <traits::adc_input_char_range R>
-    AdcGenericNetSessionASIO(const R& id, netservice_sptr_t netservice, netsession_ctx_t&& context)
-        : _ident(), _netservice(std::move(netservice)), _sessionContext(std::forward<netsession_ctx_t>(context))
-    {
-        if constexpr (std::is_array_v<R>) {
-            _ident = id;
-        } else {
-            _ident = std::string(id.begin(), id.end());
-        }
-    }
-
-    AdcGenericNetSessionASIO(netservice_sptr_t netservice, netsession_ctx_t&& context)
-        : AdcGenericNetSessionASIO(
-              std::derived_from<TRANSPORT_PROTOT, asio::ip::tcp>                      ? "ASIO TCP SESSION"
-              : std::derived_from<TRANSPORT_PROTOT, asio::ip::udp>                    ? "ASIO UDP SESSION"
-              : std::derived_from<TRANSPORT_PROTOT, asio::local::seq_packet_protocol> ? "ASIO UNIX SEQPACKET SESSION"
-              : std::derived_from<TRANSPORT_PROTOT, asio::local::stream_protocol>     ? "ASIO UNIX STREAM SESSION"
-              : std::derived_from<TRANSPORT_PROTOT, asio::local::datagram_protocol>   ? "ASIO UNIX DATAGRAM SESSION"
-                                                                                      : "ASIO UNKNOWN",
-              std::move(netservice),
-              std::forward<netsession_ctx_t>(context))
-    {
-    }
-
-
-    virtual ~AdcGenericNetSessionASIO()
-    {
-        stop();
-    }
-
-
-    netsession_ident_t ident() const
-    {
-        return _ident;
-    }
-
-
-    virtual void start() = 0;
-
-    virtual void stop()
-    {
-        _netservice->close();
-    }
-
-
-    template <traits::adc_time_duration_c TimeoutT>
-    AdcGenericNetSessionASIO& setDefaultTimeouts(const TimeoutT& send_timeout, const TimeoutT& recv_timeout)
-    {
-        _sendTimeout = send_timeout;
-        _recvTimeout = recv_timeout;
-
-        return *this;
-    }
-
-protected:
-    netsession_ident_t _ident;
-
-    netservice_sptr_t _netservice;
-
-    netsession_ctx_t _sessionContext;
-
-    std::chrono::duration<std::chrono::seconds::rep, std::chrono::seconds::period> _recvTimeout =
-        std::chrono::seconds::max();
-
-    std::chrono::duration<std::chrono::seconds::rep, std::chrono::seconds::period> _sendTimeout =
-        std::chrono::seconds(5);
-};
-
-/*
-class AdcGenericNetSessionASIO
-{
-public:
-    typedef std::string netsession_ident_t;
-
-    template <traits::adc_input_char_range R,
-              adc_asio_transport_proto_c TRANSPORT_PROTOT,
-              interfaces::adc_netsession_proto_c<std::string_view> SESSION_PROTOT,
-              traits::adc_output_char_range RMSGT = std::vector<char>,
-              traits::adc_is_callable RECV_MSG_TOKENT>
-    AdcGenericNetSessionASIO(const R& id,
-                      std::shared_ptr<AdcNetServiceASIOBase<TRANSPORT_PROTOT, SESSION_PROTOT, RMSGT>> netservice,
-                      RECV_MSG_TOKENT&& recv_msg_token)
-        : _ident(id.begin(), id.end())
-    {
-        // check receive message completion token signature and deduce message type
-        if constexpr (!adc_asio_special_comp_token_c<RECV_MSG_TOKENT>) {
-            static_assert(traits::adc_func_traits<RECV_MSG_TOKENT>::arity == 2, "INVALID COMPLETION TOKEN SIGNATURE!");
-            static_assert(
-                std::is_same_v<std::remove_cvref_t<traits::adc_func_arg1_t<RECV_MSG_TOKENT>>, std::error_code>,
-                "INVALID COMPLETION TOKEN SIGNATURE!");
-            static_assert(traits::adc_output_char_range<
-                              std::tuple_element_t<1, typename traits::adc_func_traits<RECV_MSG_TOKENT>::args_t>>,
-                          "INVALID COMPLETION TOKEN SIGNATURE!");
-        }
-
-        using msg_t = std::conditional_t<
-            adc_asio_special_comp_token_c<RECV_MSG_TOKENT>, RMSGT,
-            std::remove_cvref_t<std::tuple_element_t<1, typename traits::adc_func_traits<RECV_MSG_TOKENT>::args_t>>>;
-
-
-        _startFunc = [netservice, wrapper = traits::adc_pf_wrapper(std::forward<RECV_MSG_TOKENT>(recv_msg_token)),
-                      this]() {
-            //
-            netservice->asyncReceive(std::get<0>(wrapper), _recvTimeout);
-        };
-
-        _stopFunc = [netservice]() {
-            // stop
-            netservice->close();
-        };
-    }
-
-    template <adc_asio_transport_proto_c TRANSPORT_PROTOT,
-              interfaces::adc_netsession_proto_c<std::string_view> SESSION_PROTOT,
-              traits::adc_output_char_range RMSGT = std::vector<char>,
-              traits::adc_is_callable RECV_MSG_TOKENT>
-    AdcGenericNetSessionASIO(std::shared_ptr<AdcNetServiceASIOBase<TRANSPORT_PROTOT, SESSION_PROTOT, RMSGT>> netservice,
-                      RECV_MSG_TOKENT&& recv_msg_token)
-        : AdcGenericNetSessionASIO(std::derived_from<TRANSPORT_PROTOT, asio::ip::tcp>   ? "TCP SESSION"
-                            : std::derived_from<TRANSPORT_PROTOT, asio::ip::udp> ? "UDP SESSION"
-                            : std::derived_from<TRANSPORT_PROTOT, asio::local::seq_packet_protocol>
-                                ? "UNIX SEQPACKET SESSION"
-                                : std::derived_from<TRANSPORT_PROTOT, asio::local::stream_protocol> ? "UNIX STREAM
-SESSION" : "UNKNOWN", std::move(netservice), std::forward<RECV_MSG_TOKENT>(recv_msg_token))
-    {
-    }
-
-
-    virtual ~AdcGenericNetSessionASIO()
-    {
-        stop();
-    }
-
-
-    netsession_ident_t ident() const
-    {
-        return _ident;
-    }
-
-
-    void start()
-    {
-        _startFunc();
-    }
-
-    void stop()
-    {
-        _stopFunc();
-    }
-
-
-    template <traits::adc_time_duration_c TimeoutT>
-    AdcGenericNetSessionASIO& setDefaultTimeouts(const TimeoutT& send_timeout, const TimeoutT& recv_timeout)
-    {
-        _sendTimeout = send_timeout;
-        _recvTimeout = recv_timeout;
-
-        return *this;
-    }
-
-protected:
-    netsession_ident_t _ident;
-
-    std::function<void()> _startFunc;
-    std::function<void()> _stopFunc;
-
-    std::chrono::duration<std::chrono::seconds::rep, std::chrono::seconds::period> _recvTimeout =
-        std::chrono::seconds::max();
-
-    std::chrono::duration<std::chrono::seconds::rep, std::chrono::seconds::period> _sendTimeout =
-        std::chrono::seconds(5);
-};
-
-*/
-
-}  // namespace adc::impl