net/adc_netproto.h: add AdcStartStopSeqSessionProto class

spdlog::format_string_t<ArgTs...> fmt, ArgTs&&... args) method

CMakeLists.txt

@@ -4,7 +4,7 @@ project(ADC LANGUAGES CXX)
 
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}")
 
-set(CMAKE_CXX_STANDARD 23)
+set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 # set(CMAKE_BUILD_TYPE Release)
 
@@ -12,21 +12,21 @@ set(CMAKE_CXX_STANDARD_REQUIRED ON)
 # check compiler version to ensure supporting of
 # 'deducing this' C++23 feature
 #
-if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
+# if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
-    if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 14.0)
+#     if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 14.0)
-        message(FATAL_ERROR "GCC version must be at least 14.0!")
+#         message(FATAL_ERROR "GCC version must be at least 14.0!")
-    endif()
+#     endif()
-elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
+# elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
-    if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 18.0)
+#     if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 18.0)
-        message(FATAL_ERROR "Clang version must be at least 18.0!")
+#         message(FATAL_ERROR "Clang version must be at least 18.0!")
-    endif()
+#     endif()
-elseif(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
+# elseif(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
-    if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "19.32")
+#     if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "19.32")
-         message(FATAL_ERROR "MSVC version must be at least 19.32")
+#          message(FATAL_ERROR "MSVC version must be at least 19.32")
-    endif()
+#     endif()
-else()
+# else()
-    message(WARNING "You are using an unsupported compiler! Compilation has only been tested with Clang and GCC.")
+#     message(WARNING "You are using an unsupported compiler! Compilation has only been tested with Clang and GCC.")
-endif()
+# endif()
 
 
 
@@ -53,9 +53,11 @@ set(ADC_NETWORK_HEADERS
     # net/adc_netservice.h
     net/adc_endpoint.h
     net/adc_netserver.h
+    net/adc_netclient.h
     net/adc_net_concepts.h
     net/adc_device_netmsg.h
     net/adc_device_netserver.h
+    net/adc_device_netclient.h
 )
 
 
@@ -66,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
     )
 
@@ -85,6 +86,7 @@ option(SPDLOG_LIBRARY "Use of SPDLOG library for logging" ON)
 
 if (SPDLOG_LIBRARY)
     find_package(spdlog REQUIRED)
+    find_package(fmt REQUIRED)
 
     set(ADC_COMMON_HEADERS ${ADC_COMMON_HEADERS}
         common/adc_spdlog.h
@@ -165,12 +167,17 @@ if (BUILD_TESTS)
     set(DEVATTR_TEST_APP adc_devattr_test)
     add_executable(${DEVATTR_TEST_APP} tests/adc_devattr_test.cpp)
 
+    set(DEV_TEST_APP adc_dev_test)
+    add_executable(${DEV_TEST_APP} tests/adc_dev_test.cpp)
+
     set(NETMSG_TEST_APP adc_netmsg_test)
     add_executable(${NETMSG_TEST_APP} tests/adc_netmsg_test.cpp)
 
     set(NETSERVICE_TEST_APP adc_netservice_test)
     add_executable(${NETSERVICE_TEST_APP} tests/adc_netservice_test.cpp)
+    if (OPENSSL_LIBRARY)
         target_link_libraries(${NETSERVICE_TEST_APP} OpenSSL::SSL OpenSSL::Crypto)
+    endif()
 
     if (ASIO_LIBRARY)
         find_package(cxxopts CONFIG)
@@ -198,7 +205,12 @@ if (BUILD_TESTS)
     # add_test(VALUE_HOLDER ${VALUEHOLDER_TEST_APP})
     add_test(VALUE_HOLDER ${DEVATTR_TEST_APP})
     add_test(NETMSG_TEST ${NETMSG_TEST_APP})
+
     add_test(ASIO_NETSRV_TEST ${ASIO_NETSERVER_TEST_APP})
+    if (SPDLOG_LIBRARY)
+        target_link_libraries(${ASIO_NETSERVER_TEST_APP} PRIVATE fmt::fmt)
+    endif()
+
     enable_testing()
 endif(BUILD_TESTS)
 

common/adc_spdlog.h

@@ -13,6 +13,145 @@
 namespace adc
 {
 
+
+/*  SPDLOG-library based advanced single/multithreaded logger  */
+
+class AdcSpdlogLogger
+{
+public:
+    // [year-month-day time.millisecs][log-level]: log-message
+    constexpr static std::string_view LOGGER_DEFAULT_FORMAT = "[%Y-%m-%d %T.%e][%l]: %v";
+
+    typedef spdlog::level::level_enum loglevel_t;
+
+    template <traits::adc_input_char_range R = decltype(LOGGER_DEFAULT_FORMAT)>
+    AdcSpdlogLogger(std::shared_ptr<spdlog::logger> logger, const R& pattern = LOGGER_DEFAULT_FORMAT)
+        : _loggerSPtr(logger), _currentLogPattern()
+    {
+        std::ranges::copy(pattern, std::back_inserter(_currentLogPattern));
+        _loggerSPtr->set_pattern(_currentLogPattern);
+    }
+
+
+    virtual ~AdcSpdlogLogger() = default;
+
+
+    void setLogLevel(loglevel_t log_level)
+    {
+        _loggerSPtr->set_level(log_level);
+    }
+
+    loglevel_t getLogLevel() const
+    {
+        return _loggerSPtr->level();
+    }
+
+    void logMessage(loglevel_t level, const std::string& msg)
+    {
+        _loggerSPtr->log(level, msg);
+    }
+
+    // specialized for given level methods
+
+    void logCritical(const std::string& msg)
+    {
+        logMessage(spdlog::level::critical, msg);
+    }
+
+    void logError(const std::string& msg)
+    {
+        logMessage(spdlog::level::err, msg);
+    }
+
+    void logWarn(const std::string& msg)
+    {
+        logMessage(spdlog::level::warn, msg);
+    }
+
+    void logInfo(const std::string& msg)
+    {
+        logMessage(spdlog::level::info, msg);
+    }
+
+    void logDebug(const std::string& msg)
+    {
+        logMessage(spdlog::level::debug, msg);
+    }
+
+    void logTrace(const std::string& msg)
+    {
+        logMessage(spdlog::level::trace, msg);
+    }
+
+    template <traits::formattable... ArgTs>
+    void logMessage(spdlog::level::level_enum level, spdlog::format_string_t<ArgTs...> fmt, ArgTs&&... args)
+    {
+        _loggerSPtr->log(level, fmt, std::forward<ArgTs>(args)...);
+    }
+
+    template <traits::formattable... ArgTs>
+    void logCritical(spdlog::format_string_t<ArgTs...> fmt, ArgTs&&... args)
+    {
+        _loggerSPtr->log(spdlog::level::critical, fmt, std::forward<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(spdlog::format_string_t<ArgTs...> fmt, ArgTs&&... args)
+    {
+        _loggerSPtr->log(spdlog::level::warn, fmt, std::forward<ArgTs>(args)...);
+    }
+
+    template <traits::formattable... ArgTs>
+    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(spdlog::format_string_t<ArgTs...> fmt, ArgTs&&... args)
+    {
+        _loggerSPtr->log(spdlog::level::debug, fmt, std::forward<ArgTs>(args)...);
+    }
+
+    template <traits::formattable... ArgTs>
+    void logTrace(spdlog::format_string_t<ArgTs...> fmt, ArgTs&&... args)
+    {
+        _loggerSPtr->log(spdlog::level::trace, fmt, std::forward<ArgTs>(args)...);
+    }
+
+protected:
+    static constexpr size_t LOGGER_DEFAULT_FORMAT_MARK_POS = 20;
+
+    std::string _currentLogPattern;
+    std::shared_ptr<spdlog::logger> _loggerSPtr;
+
+
+    // helper method
+    void addMarkToPattern(traits::adc_input_char_range auto& mark, size_t pos = LOGGER_DEFAULT_FORMAT_MARK_POS)
+    {
+        std::string ptrn = _currentLogPattern.substr(0, pos);
+
+        ptrn += " [";
+        std::ranges::copy(mark, std::back_inserter(ptrn));
+        ptrn += "]";
+
+        std::ranges::copy(_currentLogPattern | std::views::drop(pos), std::back_inserter(ptrn));
+
+        _currentLogPattern = ptrn;
+
+        _loggerSPtr->set_pattern(_currentLogPattern);
+    }
+};
+
+
+/*
+
 template <typename BaseT>
 class AdcSpdlogGenericDecorator : public BaseT
 {
@@ -77,7 +216,7 @@ public:
     }
 
     template <traits::formattable... ArgTs>
-    void logMsg(spdlog::level::level_enum level, std::string_view fmt, ArgTs&&... args)
+    void logMessage(spdlog::level::level_enum level, std::string_view fmt, ArgTs&&... args)
     {
         _logger->log(level, fmt, std::forward<ArgTs>(args)...);
     }
@@ -153,7 +292,6 @@ protected:
     }
 };
 
-
 template <typename BaseT>
 class AdcSpdlogGenericMarkDecorator : public AdcSpdlogGenericDecorator<BaseT>
 {
@@ -185,7 +323,7 @@ public:
     }
 };
 
-
+*/
 }  // namespace adc
 
 #endif

common/adc_utils.h

@@ -2,9 +2,12 @@
 
 #include <algorithm>
 #include <charconv>
+#include <iostream>
 #include <limits>
+#include <mutex>
 #include <ranges>
 #include <regex>
+#include <thread>
 #include <utility>
 
 #include "../common/adc_traits.h"
@@ -451,6 +454,7 @@ namespace constants
 {
 
 static constexpr char DEFAULT_CONVERTER_DELIMITER[] = " ";
+static constexpr char DEFAULT_CONVERTER_DELIMITER_COMA[] = ", ";
 
 }  // namespace constants
 
@@ -675,4 +679,89 @@ static constexpr size_t AdcFNV1aHash(const R& r)
 }
 
 
+/*  current thread ID std::string representation  */
+
+static std::string AdcThisThreadId()
+{
+    std::stringstream st;
+    st << std::this_thread::get_id();
+
+    return st.str();
+}
+
+/*  std::basic_ostream based multithread-safe simple logger  */
+
+template <typename CharT = char, typename CharTraitsT = std::char_traits<CharT>>
+class AdcOstreamLogger
+{
+public:
+    typedef CharT char_t;
+    typedef CharTraitsT char_traits_t;
+
+    enum loglevel_t { NULL_LEVEL, ERROR_LEVEL, INFO_LEVEL, DEBUG_LEVEL };
+    static constexpr std::array LOGLEVEL_MARK{"null", "error", "info", "debug"};
+
+    AdcOstreamLogger(std::basic_ostream<CharT, CharTraitsT>& stream = std::cout, loglevel_t log_level = INFO_LEVEL)
+        : _logStream(stream), _currentLogLevel(log_level)
+    {
+    }
+
+    AdcOstreamLogger(loglevel_t log_level) : _logStream(std::cout), _currentLogLevel(log_level) {}
+
+    virtual ~AdcOstreamLogger() = default;
+
+    void setLogLevel(loglevel_t log_level)
+    {
+        std::lock_guard<std::mutex> lock(_logMutex);
+
+        _currentLogLevel = log_level;
+    }
+
+    loglevel_t getLogLevel() const
+    {
+        return _currentLogLevel;
+    }
+
+    void logMessage(loglevel_t level, const std::string& msg)
+    {
+        std::lock_guard<std::mutex> lock(_logMutex);
+
+        if (_currentLogLevel < level)
+            return;
+
+        const std::time_t now = std::chrono::system_clock::to_time_t(std::chrono::system_clock::now());
+
+        // format log-message in form:
+        //    [YYYY-MM-DD HH:MM:SS][level] log-message
+        //
+        _logStream << std::put_time(std::localtime(&now), "[%F %T]") << "[" << LOGLEVEL_MARK[level] << "] " << msg
+                   << "\n"
+                   << std::flush;
+    }
+
+
+    void logError(const std::string& msg)
+    {
+        logMessage(ERROR_LEVEL, msg);
+    }
+
+    void logInfo(const std::string& msg)
+    {
+        logMessage(INFO_LEVEL, msg);
+    }
+
+    void logDebug(const std::string& msg)
+    {
+        logMessage(DEBUG_LEVEL, msg);
+    }
+
+
+protected:
+    std::basic_ostream<CharT, CharTraitsT>& _logStream;
+    loglevel_t _currentLogLevel;
+
+    std::mutex _logMutex;
+};
+
+
 }  // namespace adc::utils

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)...));
     }
 
 

device/adc_device_attribute.h

@@ -202,9 +202,22 @@ protected:
     template <typename VT>
     inline static std::unordered_map<const AdcDeviceAttribute*, std::function<void(const VT&)>> _setterFunc{};
 
-    std::function<SerializedT()> _serializerFunc;
+    // from user to inner type converter
+    template <typename UT>
+    inline static std::unordered_map<const AdcDeviceAttribute*,
+                                     std::function<void(const UT&, const AdcDeviceAttribute*)>>
+        _convFuncTo{};
 
-    std::function<void(const SerializedT&)> _deserializerFunc;
+    // from innner to user type converter
+    template <typename UT>
+    inline static std::unordered_map<const AdcDeviceAttribute*, std::function<UT(const AdcDeviceAttribute*)>>
+        _convFuncFrom{};
+
+    // std::function<SerializedT()> _serializerFunc;
+    std::function<SerializedT(const AdcDeviceAttribute*)> _serializerFunc;
+
+    // std::function<void(const SerializedT&)> _deserializerFunc;
+    std::function<void(const SerializedT&, const AdcDeviceAttribute*)> _deserializerFunc;
 
     // static inline std::vector<std::function<void(AdcDeviceAttribute*)>> _clearFunc{};
     std::vector<std::function<void(AdcDeviceAttribute*)>> _clearFunc{};
@@ -254,12 +267,16 @@ public:
         }
 
         if constexpr (!std::is_null_pointer_v<GT> && !std::is_null_pointer_v<SRT>) {
-            auto& getter_func = _getterFunc<ValueT>[this];
+            // auto& getter_func = _getterFunc<ValueT>[this];
-            _serializerFunc = [getter_func, wrapper = traits::adc_pf_wrapper(std::forward<SRT>(serializer)), this]() {
+            // _serializerFunc = [getter_func, wrapper = traits::adc_pf_wrapper(std::forward<SRT>(serializer)), this]()
+            // {
+            _serializerFunc =
+                [wrapper = traits::adc_pf_wrapper(std::forward<SRT>(serializer))](const AdcDeviceAttribute* inst) {
                     auto& serializer = std::get<0>(wrapper);
 
                     // auto val = _getterFunc<ValueT>[this]();
-                auto val = getter_func();
+                    auto val = _getterFunc<ValueT>[inst]();
+                    // auto val = getter_func();
 
                     return serializer(val);
                 };
@@ -267,21 +284,33 @@ public:
 
 
         if constexpr (!std::is_null_pointer_v<ST> && !std::is_null_pointer_v<DSRT>) {
-            auto& setter_func = _setterFunc<ValueT>[this];
+            // auto& setter_func = _setterFunc<ValueT>[this];
-            _deserializerFunc = [setter_func, wrapper = traits::adc_pf_wrapper(std::forward<DSRT>(deserializer)),
+            // _deserializerFunc = [setter_func, wrapper = traits::adc_pf_wrapper(std::forward<DSRT>(deserializer)),
-                                 this](const SerializedT& sval) {
+            //                      this](const SerializedT& sval) {
+            _deserializerFunc = [wrapper = traits::adc_pf_wrapper(std::forward<DSRT>(deserializer))](
+                                    const SerializedT& sval, const AdcDeviceAttribute* inst) {
                 auto& deserializer = std::get<0>(wrapper);
 
                 ValueT val = deserializer(sval);
 
                 // _setterFunc<ValueT>[this](val);
-                setter_func(val);
+                _setterFunc<ValueT>[inst](val);
+                // setter_func(val);
             };
         }
 
+        _convFuncTo<ValueT>[this] = [](const ValueT& v, const AdcDeviceAttribute* inst) {
+            _setterFunc<ValueT>[inst](v);
+        };
+
+        _convFuncFrom<ValueT>[this] = [](const AdcDeviceAttribute* inst) { return _getterFunc<ValueT>[inst](); };
+
         _clearFunc.emplace_back([](AdcDeviceAttribute* inst) {
             _getterFunc<ValueT>.erase(inst);
             _setterFunc<ValueT>.erase(inst);
+
+            _convFuncFrom<ValueT>.erase(inst);
+            _convFuncTo<ValueT>.erase(inst);
         });
 
 
@@ -289,12 +318,18 @@ public:
         _copyFunc.emplace_back([](const AdcDeviceAttribute* from, AdcDeviceAttribute* to) {
             _getterFunc<ValueT>.emplace(to, _getterFunc<ValueT>[from]);
             _setterFunc<ValueT>.emplace(to, _setterFunc<ValueT>[from]);
+
+            _convFuncFrom<ValueT>.emplace(to, _convFuncFrom<ValueT>[from]);
+            _convFuncTo<ValueT>.emplace(to, _convFuncTo<ValueT>[from]);
         });
 
         // move instance function
         _moveFunc.emplace_back([](AdcDeviceAttribute* from, AdcDeviceAttribute* to) {
             _getterFunc<ValueT>.emplace(to, std::move(_getterFunc<ValueT>[from]));
             _setterFunc<ValueT>.emplace(to, std::move(_setterFunc<ValueT>[from]));
+
+            _convFuncFrom<ValueT>.emplace(to, std::move(_convFuncFrom<ValueT>[from]));
+            _convFuncTo<ValueT>.emplace(to, std::move(_convFuncTo<ValueT>[from]));
         });
     }
 
@@ -409,9 +444,13 @@ public:
                 fn(&other, this);
             }
 
-            _copyFunc = std::move(other._copyFunc);
+            // _copyFunc = std::move(other._copyFunc);
-            _moveFunc = std::move(other._moveFunc);
+            // _moveFunc = std::move(other._moveFunc);
-            _clearFunc = std::move(other._clearFunc);
+            // _clearFunc = std::move(other._clearFunc);
+
+            _copyFunc = other._copyFunc;
+            _moveFunc = other._moveFunc;
+            _clearFunc = other._clearFunc;
 
             _ident = std::move(other._ident);
             _accessType = std::move(other._accessType);
@@ -457,54 +496,86 @@ public:
                       "Deduced attribute internal type must not be std::nullptr_t!!!");
         static_assert(!std::is_null_pointer_v<user_t>, "Deduced user-defined type must not be std::nullptr_t!!!");
 
+        // return *this;
         try {
             if (_accessType != AdcDeviceAttribute::WriteOnly) {
-                auto& getter = _getterFunc<value_t>.at(this);  // throw out_of_range if value_t is invalid
+                // auto& getter = _getterFunc<value_t>.at(this);  // throw out_of_range if value_t is invalid
 
-                _getterFunc<user_t>[this] =
+                _convFuncFrom<user_t>[this] = [wrapper = traits::adc_pf_wrapper(std::forward<FromFuncT>(
-                    [getter, wrapper = traits::adc_pf_wrapper(std::forward<FromFuncT>(func_from_internal)), this]() {
+                                                   func_from_internal))](const AdcDeviceAttribute* inst) {
-                        // auto val = _getterFunc<value_t>.at(this)();  // throw out_of_range if value_t is invalid
+                    auto val = _getterFunc<value_t>[inst]();
-                        auto val = getter();
                     return std::get<0>(wrapper)(val);  // convert from internal type
                 };
+                // _getterFunc<user_t>.try_emplace(
+                //     this, [getter = _getterFunc<value_t>.at(this),
+                //            wrapper = traits::adc_pf_wrapper(std::forward<FromFuncT>(func_from_internal))]() {
+                //         auto val = getter();
+                //         return std::get<0>(wrapper)(val);  // convert from internal type
+                //     });
+                // _getterFunc<user_t>[this] =
+                //     [getter = _getterFunc<value_t>.at(this),
+                //      wrapper = traits::adc_pf_wrapper(std::forward<FromFuncT>(func_from_internal))]() {
+                //         auto val = getter();
+                //         return std::get<0>(wrapper)(val);  // convert from internal type
+                //     };
+
+                // _getterFunc<user_t>[this] =
+                //     [getter, wrapper = traits::adc_pf_wrapper(std::forward<FromFuncT>(func_from_internal)), this]() {
+                //         // auto val = _getterFunc<value_t>.at(this)();  // throw out_of_range if value_t is invalid
+                //         auto val = getter();
+                //         return std::get<0>(wrapper)(val);  // convert from internal type
+                //     };
             }  // ignore "from_internal" conversional function for write-only attribute
 
 
 
             if (_accessType != AdcDeviceAttribute::ReadOnly) {
-                auto& setter = _setterFunc<value_t>.at(this);  // throw out_of_range if value_t is invalid
+                _convFuncTo<user_t>[this] = [wrapper = traits::adc_pf_wrapper(std::forward<ToFuncT>(func_to_internal))](
-
+                                                const user_t& val, const AdcDeviceAttribute* inst) {
-                _setterFunc<user_t>[this] = [setter,
-                                             wrapper = traits::adc_pf_wrapper(std::forward<ToFuncT>(func_to_internal)),
-                                             this](const user_t& val) {
                     value_t value = std::get<0>(wrapper)(val);  // convert to internal type
-
+                    _setterFunc<value_t>[inst](value);
-                    // throw out_of_range if value_t is invalid
-                    // _setterFunc<value_t>.at(this)(value);
-                    setter(value);
                 };
+                // auto& setter = _setterFunc<value_t>.at(this);  // throw out_of_range if value_t is invalid
+
+                // _setterFunc<user_t>[this] = [setter,
+                //                              wrapper =
+                //                              traits::adc_pf_wrapper(std::forward<ToFuncT>(func_to_internal)),
+                //                              this](const user_t& val) {
+                //     value_t value = std::get<0>(wrapper)(val);  // convert to internal type
+
+                //     // throw out_of_range if value_t is invalid
+                //     // _setterFunc<value_t>.at(this)(value);
+                //     setter(value);
+                // };
             }  // ignore "to_internal" conversional function for read-only attribute
         } catch (const std::out_of_range&) {
             throw std::system_error(AdcDeviceAttributeErrorCode::ERROR_INTERNAL_TYPE_MISMATCH);
         }
 
+        // return *this;
         _clearFunc.emplace_back([](AdcDeviceAttribute* inst) {
-            _getterFunc<user_t>.erase(inst);
+            // _getterFunc<user_t>.erase(inst);
-            _setterFunc<user_t>.erase(inst);
+            // _setterFunc<user_t>.erase(inst);
+            _convFuncFrom<user_t>.erase(inst);
+            _convFuncTo<user_t>.erase(inst);
         });
 
 
         // copy instance functions
         _copyFunc.emplace_back([](const AdcDeviceAttribute* from, AdcDeviceAttribute* to) {
-            _getterFunc<user_t>.emplace(to, _getterFunc<user_t>[from]);
+            // _getterFunc<user_t>.emplace(to, _getterFunc<user_t>[from]);
-            _setterFunc<user_t>.emplace(to, _setterFunc<user_t>[from]);
+            // _setterFunc<user_t>.emplace(to, _setterFunc<user_t>[from]);
+            _convFuncFrom<user_t>.emplace(to, _convFuncFrom<user_t>[from]);
+            _convFuncTo<user_t>.emplace(to, _convFuncTo<user_t>[from]);
         });
 
 
         // move instance functions
         _moveFunc.emplace_back([](AdcDeviceAttribute* from, AdcDeviceAttribute* to) {
-            _getterFunc<user_t>.emplace(to, std::move(_getterFunc<user_t>[from]));
+            // _getterFunc<user_t>.emplace(to, std::move(_getterFunc<user_t>[from]));
-            _setterFunc<user_t>.emplace(to, std::move(_setterFunc<user_t>[from]));
+            // _setterFunc<user_t>.emplace(to, std::move(_setterFunc<user_t>[from]));
+            _convFuncFrom<user_t>.emplace(to, std::move(_convFuncFrom<user_t>[from]));
+            _convFuncTo<user_t>.emplace(to, std::move(_convFuncTo<user_t>[from]));
         });
 
         return *this;
@@ -520,7 +591,8 @@ public:
         using val_t = std::decay_t<UT>;
 
         try {
-            return _getterFunc<val_t>.at(this)();
+            // return _getterFunc<val_t>.at(this)();
+            return _convFuncFrom<val_t>.at(this)(this);
         } catch (const std::out_of_range&) {
             throw std::system_error(AdcDeviceAttributeErrorCode::ERROR_NO_CONV_FUNC);
         }
@@ -537,7 +609,8 @@ public:
         using val_t = std::decay_t<UT>;
 
         try {
-            _setterFunc<val_t>.at(this)(std::forward<UT>(val));
+            // _setterFunc<val_t>.at(this)(std::forward<UT>(val));
+            _convFuncTo<val_t>.at(this)(std::forward<UT>(val), this);
         } catch (const std::out_of_range&) {
             throw std::system_error(AdcDeviceAttributeErrorCode::ERROR_NO_CONV_FUNC);
         }
@@ -574,9 +647,13 @@ public:
                 fn(&other, this);
             }
 
-            _copyFunc = std::move(other._copyFunc);
+            // _copyFunc = std::move(other._copyFunc);
-            _moveFunc = std::move(other._moveFunc);
+            // _moveFunc = std::move(other._moveFunc);
-            _clearFunc = std::move(other._clearFunc);
+            // _clearFunc = std::move(other._clearFunc);
+
+            _copyFunc = other._copyFunc;
+            _moveFunc = other._moveFunc;
+            _clearFunc = other._clearFunc;
 
             _ident = std::move(other._ident);
             _accessType = std::move(other._accessType);
@@ -593,7 +670,8 @@ public:
             throw std::system_error(AdcDeviceAttributeErrorCode::ERROR_WRITE_ONLY);
         }
 
-        return _serializerFunc();
+        // return _serializerFunc();
+        return _serializerFunc(this);
     }
 
     template <typename ST>
@@ -616,7 +694,8 @@ public:
             throw std::system_error(AdcDeviceAttributeErrorCode::ERROR_READ_ONLY);
         }
 
-        _deserializerFunc(sval);
+        // _deserializerFunc(sval);
+        _deserializerFunc(sval, this);
 
         return *this;
     }
@@ -628,7 +707,8 @@ public:
         using s_t = std::decay_t<ST>;
 
         if constexpr (traits::adc_input_char_range<s_t> && traits::adc_input_char_range<serialized_t>) {
-            _deserializerFunc(serialized_t(sval.begin(), sval.end()));
+            // _deserializerFunc(serialized_t(sval.begin(), sval.end()));
+            _deserializerFunc(serialized_t(sval.begin(), sval.end()), this);
         } else {
             static_assert(false, "INVALID USER SERIALIZATION TYPE!");
         }

net/adc_device_netclient.h

@@ -0,0 +1,535 @@
+#pragma once
+
+#include <queue>
+#include "../common/adc_utils.h"
+#include "adc_device_netmsg.h"
+#include "adc_netclient.h"
+
+
+namespace adc
+{
+
+enum class AdcDeviceNetClientSessionError : int {
+    ERROR_OK,
+    ERROR_INVALID_SERVER_RESPOND,
+    ERROR_UNEXPECTED_SERVER_RESPOND,
+    ERROR_UNKNOWN_ERROR
+};
+
+}
+
+
+// place here to allow clang compilation
+namespace std
+{
+template <>
+class is_error_code_enum<adc::AdcDeviceNetClientSessionError> : public true_type
+{
+};
+
+
+}  // namespace std
+
+namespace adc
+{
+
+
+struct AdcDeviceNetClientSessionErrorCategory : std::error_category {
+    AdcDeviceNetClientSessionErrorCategory() : std::error_category() {}
+
+    const char* name() const noexcept
+    {
+        return "ADC_DEVICE_NESERVER_SESSION";
+    }
+
+    std::string message(int ec) const
+    {
+        AdcDeviceNetClientSessionError err = static_cast<AdcDeviceNetClientSessionError>(ec);
+
+        switch (err) {
+            case AdcDeviceNetClientSessionError::ERROR_OK:
+                return "OK";
+            case AdcDeviceNetClientSessionError::ERROR_INVALID_SERVER_RESPOND:
+                return "invalid server respond message";
+            case AdcDeviceNetClientSessionError::ERROR_UNEXPECTED_SERVER_RESPOND:
+                return "unexpected server respond message";
+            case AdcDeviceNetClientSessionError::ERROR_UNKNOWN_ERROR:
+                return "catch unhandled exception";
+            default:
+                return "UNKNOWN";
+        }
+    }
+
+    static const AdcDeviceNetClientSessionErrorCategory& get()
+    {
+        static const AdcDeviceNetClientSessionErrorCategory constInst;
+        return constInst;
+    }
+};
+
+}  // namespace adc
+
+namespace std
+{
+
+inline std::error_code make_error_code(adc::AdcDeviceNetClientSessionError ec)
+{
+    return std::error_code(static_cast<int>(ec), adc::AdcDeviceNetClientSessionErrorCategory::get());
+}
+
+}  // namespace std
+
+
+
+namespace adc
+{
+
+template <typename IdentT = std::string, interfaces::adc_logger_c LoggerT = utils::AdcOstreamLogger<char>>
+class AdcDeviceNetClient : public AdcGenericNetClient<IdentT, LoggerT>
+{
+    typedef AdcGenericNetClient<IdentT, LoggerT> base_t;
+
+public:
+    template <interfaces::adc_netservice_c NetServiceT, traits::adc_hashable_c SessionIdentT = std::string>
+    class Session : public std::enable_shared_from_this<Session<NetServiceT, SessionIdentT>>
+    {
+    public:
+        enum ServerResponseType { RESP_INVALID, RESP_ACK, RESP_ERROR, RESP_UNEXPECTED };
+
+        typedef SessionIdentT netsession_ident_t;
+        typedef NetServiceT netservice_t;
+
+        // default server respond type
+        typedef std::vector<std::string> default_server_resp_t;
+        // asynchronous callback callable type for ADC device getter/setter/executor
+        typedef std::function<void(ServerResponseType, default_server_resp_t)> async_callback_func_t;
+
+        struct netsession_ctx_t {
+            AdcDeviceNetClient* clientPtr;
+            std::chrono::milliseconds recvTimeout;
+            std::chrono::milliseconds sendTimeout;
+        };
+
+        typedef std::vector<char> message_t;
+
+        Session(const netsession_ident_t& id, netservice_t srv, netsession_ctx_t ctx)
+            : _ident(id),
+              _netService(std::move(srv)),
+              _clientPtr(ctx.clientPtr),
+              _recvTimeout(ctx.recvTimeout),
+              _sendTimeout(ctx.sendTimeout)
+        {
+            _clientPtr->logInfo("Create client-to-server session with ID = {} (addr = {}, thread = {})", _ident,
+                                (void*)this, utils::AdcThisThreadId());
+        }
+
+
+        virtual ~Session()
+        {
+            _clientPtr->logInfo("Delete client-to-server session with ID = {} (addr = {}, thread = {})", _ident,
+                                (void*)this, utils::AdcThisThreadId());
+        }
+
+        netsession_ident_t ident() const
+        {
+            return _ident;
+        }
+
+        void start()
+        {
+            _clientPtr->logInfo("Start client-to-server session with ID = {} (addr = {}, thread = {})", _ident,
+                                (void*)this, utils::AdcThisThreadId());
+        }
+
+        void stop()
+        {
+            _clientPtr->logInfo("Stop client-to-server session with ID = {} (addr = {}, thread = {})", _ident,
+                                (void*)this, utils::AdcThisThreadId());
+
+            _netService.close();
+        }
+
+
+        // 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>
+        R deviceNames(ServerResponseType& rtype)
+        {
+            // expected respond: ACK NAMES DEV1 DEV2 ...
+            // return DEV1 DEV2 ... (or error description 'code category what')
+            return serverCall<R>(rtype, constants::ADC_DEVICE_NETPROTO_KEY_NAMES);
+        }
+
+        default_server_resp_t deviceNames(ServerResponseType& rtype)
+        {
+            return deviceNames<default_server_resp_t>(rtype);
+        }
+
+        // bind device to the client
+        template <traits::adc_range_of_output_char_range R, traits::adc_input_char_range DevNameT>
+        R bindDevice(ServerResponseType& rtype, DevNameT&& dev_name)
+        {
+            // expected respond: ACK DEVICE DEV_NAME
+            // return DEV_NAME (or error description 'code category what')
+            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(ServerResponseType& rtype, DevNameT&& dev_name)
+        {
+            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(ServerResponseType& rtype, CmdNameT&& cmd_name)
+        {
+            // expected respond: ACK CMD CMD_NAME
+            // return CMD_NAME ... (or error description 'code category what')
+            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(ServerResponseType& rtype, CmdNameT&& cmd_name)
+        {
+            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(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 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(ServerResponseType& rtype, AttrNameT&& attr_name)
+        {
+            return getAttr<default_server_resp_t>(rtype, std::forward<AttrNameT>(attr_name));
+        }
+
+
+        // set an attribute value
+        template <traits::adc_range_of_output_char_range R,
+                  traits::adc_input_char_range AttrNameT,
+                  typename ValueT,
+                  typename... ValueTs>
+        R setAttr(AttrNameT&& attr_name, ServerResponseType& rtype, ValueT&& value, ValueTs&&... values)
+        {
+            // expected respond: ACK SET ATTR_NAME ATTR_VALUE
+            // return ATTR_NAME ATTR_VALUE (or error description 'code category what')
+            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>
+        default_server_resp_t setAttr(AttrNameT&& attr_name,
+                                      ServerResponseType& rtype,
+                                      ValueT&& value,
+                                      ValueTs&&... values)
+        {
+            return setAttr<default_server_resp_t>(std::forward<AttrNameT>(attr_name), rtype,
+                                                  std::forward<ValueT>(value), std::forward<ValueTs>(values)...);
+        }
+
+        // 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 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 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 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 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,
+                  traits::adc_input_char_range AttrNameT,
+                  typename ValueT,
+                  typename... ValueTs>
+        auto asyncSetAttr(CallbackT&& callback_func, AttrNameT&& attr_name, ValueT&& value, 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:
+        netsession_ident_t _ident;
+        netservice_t _netService;
+        AdcDeviceNetClient* _clientPtr;
+
+        std::chrono::milliseconds _recvTimeout = std::chrono::seconds(5);
+        std::chrono::milliseconds _sendTimeout = std::chrono::seconds(5);
+
+        // main 'run' method
+
+        virtual void run() = 0;
+
+        // helper methods
+
+        template <traits::adc_range_of_output_char_range R>
+        R checkServerCall(std::string_view key, const auto& bytes, ServerResponseType& type) const
+        {
+            AdcDeviceProtoMessage dev_msg(bytes);
+
+            if (!dev_msg.isValid()) {
+                throw std::system_error(AdcDeviceNetClientSessionError::ERROR_INVALID_SERVER_RESPOND);
+            }
+
+            if (dev_msg.isACK(key)) {
+                type = RESP_ACK;
+                return dev_msg.template attrs<R>(1);
+            } else if (dev_msg.isERROR()) {
+                type = RESP_ERROR;
+                return dev_msg.template attrs<R>();
+            } else {
+                throw std::system_error(AdcDeviceNetClientSessionError::ERROR_UNEXPECTED_SERVER_RESPOND);
+            }
+        }
+
+        template <traits::adc_range_of_output_char_range R>
+        R getFromServer(std::string_view key, const typename netservice_t::send_msg_t& bytes, ServerResponseType& type)
+        {
+            auto rbytes = sendRecv(bytes);
+
+            return checkServerCall<R>(key, rbytes, type);
+        }
+
+
+        template <traits::adc_input_char_range SendMsgT>
+        auto sendRecv(const SendMsgT& send_msg)
+        {
+            _netService.send(send_msg, _sendTimeout);
+            return _netService.receive(_recvTimeout);
+        }
+
+        template <traits::adc_input_char_range SendMsgT, typename TokenT>
+        auto asyncSendRecv(const SendMsgT& send_msg, TokenT&& token)
+        {
+            return _netService.asyncSend(
+                send_msg,
+                [wrapper = traits::adc_pf_wrapper(std::forward<TokenT>(token)), this](auto err) {
+                    if (err) {
+                        this->logError("An error occured while sending the message: {}",
+                                       netservice_t::formattableError(err));
+                    } else {
+                        _netService.asyncReceive(std::get<0>(wrapper), _recvTimeout);
+                    }
+                },
+                _sendTimeout);
+        }
+
+    };  // end of 'Session' class declaration
+
+    using base_t::base_t;
+
+    virtual ~AdcDeviceNetClient() {}
+};
+
+
+/*  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
+{
+public:
+    // <netproto-key, args ...>
+    typedef std::tuple<std::string_view, ArgRangeT> queue_elem_t;
+
+    AdcNetClientSendQueue() = default;
+
+    size_t queueSize() const
+    {
+        return _queue.size();
+    }
+
+    AdcNetClientSendQueue& addToQueue(std::string_view key, const ArgRangeT& args)
+    {
+        _queue.push({key, args});
+
+        return *this;
+    }
+
+    template <traits::adc_input_char_range... ArgTs>
+    AdcNetClientSendQueue& addToQueue(std::string key, ArgTs&&... elems)
+    {
+        if constexpr (sizeof...(ArgTs)) {
+            _queue.push({key, ArgRangeT()});
+
+            addToQueueHelper(std::get<1>(_queue.back()), std::forward<ArgTs>(elems)...);
+        }
+
+        return *this;
+    }
+
+
+    template <traits::adc_input_char_range CmdNameT>
+    AdcNetClientSendQueue& addCmdToQueue(CmdNameT&& cmd_name)
+    {
+        return addToQueue(constants::ADC_DEVICE_NETPROTO_KEY_CMD, std::forward<CmdNameT>(cmd_name));
+    }
+
+    template <traits::adc_input_char_range AttrNameT>
+    AdcNetClientSendQueue& addGetAttrToQueue(AttrNameT&& attr_name)
+    {
+        return addToQueue(constants::ADC_DEVICE_NETPROTO_KEY_GET, std::forward<AttrNameT>(attr_name));
+    }
+
+    template <traits::adc_input_char_range AttrNameT,
+              traits::adc_input_char_range ValueT,
+              traits::adc_input_char_range... ValueTs>
+    AdcNetClientSendQueue& addSetAttrToQueue(AttrNameT&& attr_name, ValueT&& value, ValueTs&&... values)
+    {
+        return addToQueue(constants::ADC_DEVICE_NETPROTO_KEY_SET, std::forward<AttrNameT>(attr_name),
+                          std::forward<ValueT>(value), std::forward<ValueTs>(values)...);
+    }
+
+    AdcNetClientSendQueue& addGetNamesToQueue()
+    {
+        return addToQueue(constants::ADC_DEVICE_NETPROTO_KEY_NAMES);
+    }
+
+    template <traits::adc_input_char_range DeviceNameT>
+    AdcNetClientSendQueue& addBindDevToQueue(DeviceNameT&& dev_name)
+    {
+        return addToQueue(constants::ADC_DEVICE_NETPROTO_KEY_DEVICE, std::forward<DeviceNameT>(dev_name));
+    }
+
+protected:
+    std::queue<queue_elem_t> _queue;
+
+    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<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<ArgT>>) {
+                sp = std::string_view(elem);
+            } else {
+                sp = std::span<const char>(elem);
+            }
+
+            std::ranges::copy(std::views::transform(std::ranges::single_view(sp),
+                                                    [](const auto& val) {
+                                                        el_t el;
+                                                        std::ranges::copy(val, std::back_inserter(el));
+                                                        return el;
+                                                    }),
+                              std::back_inserter(args));
+        }
+
+        if constexpr (sizeof...(ArgTs)) {
+            addToQueue(args, std::forward<ArgTs>(elems)...);
+        }
+    }
+};
+
+}  // namespace adc

net/adc_device_netmsg.h

@@ -291,6 +291,27 @@ protected:
 };
 
 
+/* ADC client-server network protocol definitions  */
+
+namespace constants
+{
+
+static constexpr std::string_view ADC_DEVICE_NETPROTO_KEY_ACK{"ACK"};
+static constexpr std::string_view ADC_DEVICE_NETPROTO_KEY_SET{"SET"};
+static constexpr std::string_view ADC_DEVICE_NETPROTO_KEY_GET{"GET"};
+static constexpr std::string_view ADC_DEVICE_NETPROTO_KEY_CMD{"CMD"};
+static constexpr std::string_view ADC_DEVICE_NETPROTO_KEY_ERR{"ERR"};
+static constexpr std::string_view ADC_DEVICE_NETPROTO_KEY_HELLO{"HELLO"};
+static constexpr std::string_view ADC_DEVICE_NETPROTO_KEY_DEVICE{"DEVICE"};
+static constexpr std::string_view ADC_DEVICE_NETPROTO_KEY_NAMES{"NAMES"};
+
+static constexpr std::array ADC_DEVICE_NETPROTO_VALID_KEY{
+    ADC_DEVICE_NETPROTO_KEY_ACK,    ADC_DEVICE_NETPROTO_KEY_SET,  ADC_DEVICE_NETPROTO_KEY_GET,
+    ADC_DEVICE_NETPROTO_KEY_CMD,    ADC_DEVICE_NETPROTO_KEY_ERR,  ADC_DEVICE_NETPROTO_KEY_HELLO,
+    ADC_DEVICE_NETPROTO_KEY_DEVICE, ADC_DEVICE_NETPROTO_KEY_NAMES};
+
+}  // namespace constants
+
 template <traits::adc_char_range ByteSeqT,
           const char KEY_VALUE_DELIM[] = constants::ADC_DEFAULT_KEY_VALUE_DELIMITER1,
           const char VALUE_DELIM[] = constants::ADC_DEFAULT_VALUE_DELIMITER,
@@ -301,20 +322,7 @@ class AdcDeviceProtoMessage
     using base_t = AdcKeyValueMessage<ByteSeqT, KEY_VALUE_DELIM, VALUE_DELIM, COMPOSITE_VALUE_DELIM>;
 
 public:
-    static constexpr std::string_view ACK_KEY{"ACK"};
+    typedef std::array<size_t, constants::ADC_DEVICE_NETPROTO_VALID_KEY.size()> keyword_hash_array_t;
-    static constexpr std::string_view SET_KEY{"SET"};
-    static constexpr std::string_view GET_KEY{"GET"};
-    static constexpr std::string_view CMD_KEY{"CMD"};
-    static constexpr std::string_view ERR_KEY{"ERR"};
-    static constexpr std::string_view HELLO_KEY{"HELLO"};
-    static constexpr std::string_view DEVICE_KEY{"DEVICE"};
-    static constexpr std::string_view NAMES_KEY{"NAMES"};
-
-    static constexpr std::array VALID_KEY{ACK_KEY, SET_KEY,   GET_KEY,    CMD_KEY,
-                                          ERR_KEY, HELLO_KEY, DEVICE_KEY, NAMES_KEY};
-
-
-    typedef std::array<size_t, VALID_KEY.size()> keyword_hash_array_t;
 
     enum KEY_IDX : size_t {
         ACK_KEY_IDX,
@@ -324,7 +332,8 @@ public:
         ERR_KEY_IDX,
         HELLO_KEY_IDX,
         DEVICE_KEY_IDX,
-        NAMES_KEY_IDX
+        NAMES_KEY_IDX,
+        INVALID_KEY_IDX
     };
 
 private:  // include here to allow clang compilation
@@ -333,9 +342,9 @@ private:  // include here to allow clang compilation
     template <size_t... I>
     static constexpr auto computeKeywordHashesImpl(std::index_sequence<I...>)
     {
-        return keyword_hash_array_t{utils::AdcFNV1aHash(VALID_KEY[I])...};
+        return keyword_hash_array_t{utils::AdcFNV1aHash(constants::ADC_DEVICE_NETPROTO_VALID_KEY[I])...};
     }
-    template <typename Indices = std::make_index_sequence<VALID_KEY.size()>>
+    template <typename Indices = std::make_index_sequence<constants::ADC_DEVICE_NETPROTO_VALID_KEY.size()>>
     static constexpr auto computeKeywordHashes()
     {
         return computeKeywordHashesImpl(Indices{});
@@ -350,6 +359,9 @@ private:  // include here to allow clang compilation
 
     bool isKey(size_t idx) const
     {
+        if (idx >= INVALID_KEY_IDX)
+            return false;
+
         return _keyHash == KEY_HASHES[idx];
     }
 
@@ -369,6 +381,17 @@ public:
         return isKey(ACK_KEY_IDX);
     }
 
+    // ACK KEY_NAME ...
+    bool isACK(std::string_view key) const
+    {
+        auto ats = attrs();
+        if (std::ranges::size(ats)) {
+            return isKey(ACK_KEY_IDX) && (key == *ats.begin());
+        } else {
+            return false;
+        }
+    }
+
     bool isSET() const
     {
         return isKey(SET_KEY_IDX);
@@ -441,9 +464,11 @@ public:
     }
 
 
+    using base_t::setKeyValue;  // import to public area
+
     void ack()
     {
-        base_t::setKey(ACK_KEY);
+        base_t::setKey(constants::ADC_DEVICE_NETPROTO_KEY_ACK);
 
         keyHash();
     }
@@ -452,7 +477,7 @@ public:
     template <typename ParT, typename... ParTs>
     void ack(const ParT& param, const ParTs&... params)
     {
-        base_t::setKeyValue(ACK_KEY, param, params...);
+        base_t::setKeyValue(constants::ADC_DEVICE_NETPROTO_KEY_ACK, param, params...);
 
         keyHash();
     }
@@ -463,7 +488,7 @@ public:
         requires(!traits::adc_input_char_range<ParT>)
     void ack(const ParT& param)
     {
-        base_t::setKeyValue(ACK_KEY, param);
+        base_t::setKeyValue(constants::ADC_DEVICE_NETPROTO_KEY_ACK, param);
 
         keyHash();
     }
@@ -472,7 +497,7 @@ public:
     template <traits::adc_tuple_like ParT>
     void ack(const ParT& param)
     {
-        base_t::setKeyValue(ACK_KEY, param);
+        base_t::setKeyValue(constants::ADC_DEVICE_NETPROTO_KEY_ACK, param);
 
         keyHash();
     }
@@ -481,8 +506,8 @@ public:
     template <traits::adc_input_char_range AttrNameT, typename ValueT, typename... ValueTs>
     void set(AttrNameT&& attr_name, ValueT&& value, ValueTs&&... values)
     {
-        base_t::setKeyValue(SET_KEY, std::forward<AttrNameT>(attr_name), std::forward<ValueT>(value),
+        base_t::setKeyValue(constants::ADC_DEVICE_NETPROTO_KEY_SET, std::forward<AttrNameT>(attr_name),
-                            std::forward<ValueTs>(values)...);
+                            std::forward<ValueT>(value), std::forward<ValueTs>(values)...);
 
         keyHash();
     }
@@ -490,7 +515,7 @@ public:
     template <traits::adc_input_char_range AttrNameT>
     void get(AttrNameT&& attr_name)
     {
-        base_t::setKeyValue(GET_KEY, std::forward<AttrNameT>(attr_name));
+        base_t::setKeyValue(constants::ADC_DEVICE_NETPROTO_KEY_GET, std::forward<AttrNameT>(attr_name));
 
         keyHash();
     }
@@ -498,14 +523,14 @@ public:
     template <traits::adc_input_char_range CmdNameT>
     void cmd(CmdNameT&& cmd_name)
     {
-        base_t::setKeyValue(CMD_KEY, std::forward<CmdNameT>(cmd_name));
+        base_t::setKeyValue(constants::ADC_DEVICE_NETPROTO_KEY_CMD, std::forward<CmdNameT>(cmd_name));
 
         keyHash();
     }
 
     void err(const std::error_code& ec)
     {
-        base_t::setKeyValue(ERR_KEY, ec.value(), ec.category().name(), ec.message());
+        base_t::setKeyValue(constants::ADC_DEVICE_NETPROTO_KEY_ERR, ec.value(), ec.category().name(), ec.message());
 
         keyHash();
     }
@@ -513,7 +538,8 @@ public:
     template <traits::adc_input_char_range SenderNameT, typename... ParamTs>
     void hello(SenderNameT&& name, ParamTs&&... params)
     {
-        base_t::setKeyValue(HELLO_KEY, std::forward<SenderNameT>(name), std::forward<ParamTs>(params)...);
+        base_t::setKeyValue(constants::ADC_DEVICE_NETPROTO_KEY_HELLO, std::forward<SenderNameT>(name),
+                            std::forward<ParamTs>(params)...);
 
         keyHash();
     }
@@ -521,14 +547,14 @@ public:
     template <traits::adc_input_char_range DevNameT>
     void device(DevNameT&& dev_name)
     {
-        base_t::setKeyValue(DEVICE_KEY, std::forward<DevNameT>(dev_name));
+        base_t::setKeyValue(constants::ADC_DEVICE_NETPROTO_KEY_DEVICE, std::forward<DevNameT>(dev_name));
 
         keyHash();
     }
 
     void names()
     {
-        base_t::setKey(NAMES_KEY);
+        base_t::setKey(constants::ADC_DEVICE_NETPROTO_KEY_NAMES);
 
         keyHash();
     }
@@ -536,7 +562,7 @@ public:
     template <typename DevNameT, typename... DevNameTs>
     void names(const DevNameT& dev_name, const DevNameTs&... dev_names)
     {
-        base_t::setKeyValue(NAMES_KEY, dev_name, dev_names...);
+        base_t::setKeyValue(constants::ADC_DEVICE_NETPROTO_KEY_NAMES, dev_name, dev_names...);
 
         keyHash();
     }
@@ -545,7 +571,7 @@ public:
         requires(!traits::adc_input_char_range<std::ranges::range_value_t<R>>)
     void names(const R& dev_names)
     {
-        base_t::setKeyValue(NAMES_KEY, dev_names);
+        base_t::setKeyValue(constants::ADC_DEVICE_NETPROTO_KEY_NAMES, dev_names);
 
         keyHash();
     }
@@ -553,7 +579,7 @@ public:
     template <traits::adc_tuple_like T>
     void names(const T& dev_names)
     {
-        base_t::setKeyValue(NAMES_KEY, dev_names);
+        base_t::setKeyValue(constants::ADC_DEVICE_NETPROTO_KEY_NAMES, dev_names);
 
         keyHash();
     }

net/adc_device_netserver.h

@@ -2,6 +2,7 @@
 
 #include <memory>
 #include <system_error>
+#include <thread>
 
 #include "adc_device_netmsg.h"
 #include "adc_netserver.h"
@@ -105,11 +106,12 @@ namespace adc
 {
 
 
-template <typename IdentT = std::string>
+template <typename IdentT = std::string, interfaces::adc_logger_c LoggerT = utils::AdcOstreamLogger<char>>
-class AdcDeviceNetServer : public AdcGenericNetServer<IdentT>
+class AdcDeviceNetServer : public AdcGenericNetServer<IdentT, LoggerT>
 {
 public:
-    using typename AdcGenericNetServer<IdentT>::server_ident_t;
+    using typename AdcGenericNetServer<IdentT, LoggerT>::server_ident_t;
+    using typename AdcGenericNetServer<IdentT, LoggerT>::logger_t;
 
     // type for serialized data (attr/command ID, attr values etc...)
     typedef std::vector<char> serialized_t;
@@ -153,8 +155,8 @@ protected:
                       CmdIdDeserialT&& cmd_id_deser_func = {})
             : _id(id)
         {
-            _get_attr = [dev_ptr, wrapper = traits::adc_pf_wrapper(std::forward<AttrIdDeserialT>(attr_id_deser_func)),
+            _get_attr = [dev_ptr, wrapper = traits::adc_pf_wrapper(std::forward<AttrIdDeserialT>(attr_id_deser_func))](
-                         this](const auto& attr_name) mutable {
+                            const auto& attr_name) mutable {
                 auto attr_id = std::get<0>(wrapper)(attr_name);
                 auto& attr = (*dev_ptr)[attr_id];
                 // auto& attr = dev_ptr->operator[](attr_id);
@@ -232,13 +234,15 @@ public:
               _recvTimeout(ctx.recvTimeout),
               _sendTimeout(ctx.sendTimeout)
         {
-            _serverPtr->logInfo("Create client session with ID = {} (addr = {})", _ident, (void*)this);
+            _serverPtr->logInfo("Create client session with ID = {} (addr = {}, thread = {})", _ident, (void*)this,
+                                utils::AdcThisThreadId());
         }
 
 
         virtual ~Session()
         {
-            _serverPtr->logInfo("Delete client session with ID = {} (addr = {})", _ident, (void*)this);
+            _serverPtr->logInfo("Delete client session with ID = {} (addr = {}, thread = {})", _ident, (void*)this,
+                                utils::AdcThisThreadId());
         }
 
         netsession_ident_t ident() const
@@ -248,49 +252,16 @@ public:
 
         void start()
         {
-            _serverPtr->logInfo("Start client session with ID = {} (addr = {})", _ident, (void*)this);
+            _serverPtr->logInfo("Start client session with ID = {} (addr = {}, thread = {})", _ident, (void*)this,
+                                utils::AdcThisThreadId());
 
-            auto self(this->shared_from_this());
+            do_start();
-
-            _netService.asyncReceive(
-                [self, this](netservice_t::async_callback_err_t ec, message_t msg) {
-                    if (ec) {
-                        // std::string str("asyncReceive operation completed with error: ");
-                        // netservice_t::formatError(ec, str);
-                        // _serverPtr->errorMessage(str);
-                        _serverPtr->logError("asyncReceive operation completed with error: {}",
-                                             netservice_t::formattableError(ec));
-                        stop();
-                    } else {
-                        auto msg_sptr = std::make_shared<message_t>(std::move(msg));
-
-                        AdcDeviceProtoMessage dev_msg(*msg_sptr);
-
-                        processMessage(dev_msg);
-
-                        _netService.asyncSend(
-                            *msg_sptr,
-                            [self, msg_sptr, this](netservice_t::async_callback_err_t ec) {
-                                if (ec) {
-                                    // std::string str("asyncSend operation completed with error: ");
-                                    // netservice_t::formatError(ec, str);
-                                    // _serverPtr->errorMessage(str);
-                                    _serverPtr->logError("asyncSend operation completed with error: {}",
-                                                         netservice_t::formattableError(ec));
-                                    stop();
-                                } else {
-                                    start();
-                                }
-                            },
-                            _sendTimeout);
-                    }
-                },
-                _recvTimeout);
         }
 
         void stop()
         {
-            _serverPtr->logInfo("Stop client session with ID = {} (addr = {})", _ident, (void*)this);
+            _serverPtr->logInfo("Stop client session with ID = {} (addr = {}, thread = {})", _ident, (void*)this,
+                                utils::AdcThisThreadId());
 
             _netService.close();
         }
@@ -304,6 +275,43 @@ public:
         std::chrono::milliseconds _recvTimeout = std::chrono::hours(12);
         std::chrono::milliseconds _sendTimeout = std::chrono::seconds(5);
 
+
+        void do_start()
+        {
+            auto self(this->shared_from_this());
+
+            _netService.asyncReceive(
+                [self, this](netservice_t::async_callback_err_t ec, message_t msg) {
+                    if (ec) {
+                        _serverPtr->logError(
+                            "asyncReceive operation completed with error: {} (session addr = {}, thread = {})",
+                            netservice_t::formattableError(ec), (void*)this, utils::AdcThisThreadId());
+                        stop();
+                    } else {
+                        auto msg_sptr = std::make_shared<message_t>(std::move(msg));
+
+                        AdcDeviceProtoMessage dev_msg(*msg_sptr);
+
+                        processMessage(dev_msg);
+
+                        _netService.asyncSend(
+                            *msg_sptr,
+                            [self, msg_sptr, this](netservice_t::async_callback_err_t ec) {
+                                if (ec) {
+                                    _serverPtr->logError(
+                                        "asyncSend operation completed with error: {} (session addr = {}, thread = {})",
+                                        netservice_t::formattableError(ec), (void*)this, utils::AdcThisThreadId());
+                                    stop();
+                                } else {
+                                    do_start();
+                                }
+                            },
+                            _sendTimeout);
+                    }
+                },
+                _recvTimeout);
+        }
+
         void processMessage(auto& msg)
         {
             typedef std::decay_t<decltype(msg)> msg_t;
@@ -336,7 +344,8 @@ public:
                             }
                         }
                         if (found) {
-                            msg.ack(msg_t::DEVICE_KEY, attrs);
+                            // msg.ack(msg_t::DEVICE_KEY, attrs);
+                            msg.ack(constants::ADC_DEVICE_NETPROTO_KEY_DEVICE, attrs);
                         } else {
                             msg.err(std::make_error_code(AdcDeviceNetServerSessionError::ERROR_UNKNOWN_DEVICE_ID));
                         }
@@ -348,14 +357,17 @@ public:
                     for (auto& [ptr, dev_wr] : _serverPtr->_devices) {
                         names.emplace_back(dev_wr.ident());
                     }
-                    msg.ack(msg_t::NAMES_KEY, names);
+                    // msg.ack(msg_t::NAMES_KEY, names);
+                    msg.ack(constants::ADC_DEVICE_NETPROTO_KEY_NAMES, names);
                 } else if (msg.isHELLO()) {
-                    msg.ack(msg_t::HELLO_KEY, _serverPtr->_serverIdent);
+                    // msg.ack(msg_t::HELLO_KEY, _serverPtr->_serverIdent);
+                    msg.ack(constants::ADC_DEVICE_NETPROTO_KEY_HELLO, _serverPtr->_serverIdent);
                 } else if (msg.isGET()) {  // get attribute value
                     attrs = msg.template attrs<attr_vec_t>(0, 1);
                     if (attrs.size()) {
                         auto val = _bindDevice->getAttr(get_elem(0));
-                        msg.ack(msg_t::GET_KEY, get_elem(0), val);
+                        // msg.ack(msg_t::GET_KEY, get_elem(0), val);
+                        msg.ack(constants::ADC_DEVICE_NETPROTO_KEY_GET, get_elem(0), val);
                     } else {  // no attr name!
                         msg.err(std::make_error_code(AdcDeviceNetServerSessionError::ERROR_NO_PROTO_ATTRNAME));
                     }
@@ -364,7 +376,8 @@ public:
                     if (attrs.size() >= 2) {
                         auto val = msg.template joinAttrs<serialized_t>(1);
                         _bindDevice->setAttr(get_elem(0), val);
-                        msg.ack(msg_t::SET_KEY, get_elem(0), val);
+                        // msg.ack(msg_t::SET_KEY, get_elem(0), val);
+                        msg.ack(constants::ADC_DEVICE_NETPROTO_KEY_SET, get_elem(0), val);
                     } else {  // no attr name or its value!
                         if (attrs.size() == 1) {
                             msg.err(std::make_error_code(AdcDeviceNetServerSessionError::ERROR_NO_PROTO_ATTRVALUE));
@@ -377,7 +390,8 @@ public:
                     if (attrs.size()) {
                         auto cmd_name = get_elem(0);
                         _bindDevice->exec(cmd_name);
-                        msg.ack(msg_t::CMD_KEY, cmd_name);
+                        // msg.ack(msg_t::CMD_KEY, cmd_name);
+                        msg.ack(constants::ADC_DEVICE_NETPROTO_KEY_CMD, cmd_name);
                     } else {  // no cmd name!
                         msg.err(std::make_error_code(AdcDeviceNetServerSessionError::ERROR_NO_PROTO_CMDNAME));
                     }
@@ -391,8 +405,8 @@ public:
     };
 
 
-    // using AdcGenericNetServer::AdcGenericNetServer;
+    using AdcGenericNetServer<IdentT, LoggerT>::AdcGenericNetServer;
-    AdcDeviceNetServer(const server_ident_t& id) : AdcGenericNetServer<IdentT>(id), _devices() {}
+    // AdcDeviceNetServer(const server_ident_t& id) : AdcGenericNetServer<IdentT>(id), _devices() {}
 
     virtual ~AdcDeviceNetServer() = default;
 
@@ -406,6 +420,18 @@ public:
                                   CmdIdDeserialT&& cmd_id_deser_func = {})    // deserializer of command ID
     {
         auto id = std::forward<IdSerialT>(id_ser_func)(dev_ptr->ident());
+
+        if constexpr (traits::formattable<serialized_t>) {
+            this->logInfo("Add ADC device with ID: {} (addr = {}, thread = {})", id, (void*)dev_ptr,
+                          utils::AdcThisThreadId());
+        } else {
+            std::string s;
+            std::ranges::copy(id, std::back_inserter(s));
+
+            this->logInfo("Add ADC device with ID: {} (addr = {}, thread = {})", s, (void*)dev_ptr,
+                          utils::AdcThisThreadId());
+        }
+
         _devices.try_emplace(dev_ptr, dev_ptr, id, std::forward<AttrIdDeserialT>(attr_id_deser_func),
                              std::forward<CmdIdDeserialT>(cmd_id_deser_func));
 
@@ -415,7 +441,25 @@ public:
     template <interfaces::adc_device_c DeviceT>
     AdcDeviceNetServer& delDevice(DeviceT* dev_ptr)
     {
-        _devices.erase(dev_ptr);
+        auto it = _devices.find(dev_ptr);
+        if (it == _devices.end()) {
+            this->logError("Invalid ADC device pointer ({})! It seems the device was not added!", (void*)dev_ptr);
+            return *this;
+        }
+
+        if constexpr (traits::formattable<serialized_t>) {
+            this->logInfo("Delete ADC device with ID: {} (addr = {}, thread = {})", it->ident(), (void*)dev_ptr,
+                          utils::AdcThisThreadId());
+        } else {
+            std::string s;
+            std::ranges::copy(it->ident(), std::back_inserter(s));
+
+            this->logInfo("Delete ADC device with ID: {} (addr = {}, thread = {})", s, (void*)dev_ptr,
+                          utils::AdcThisThreadId());
+        }
+
+        _devices.erase(it);
+        // _devices.erase(dev_ptr);
 
         return *this;
     }

net/adc_endpoint.h

@@ -143,7 +143,7 @@ public:
         _host = std::string_view{found.end(), _endpoint.end()};
 
         auto f1 = std::ranges::search(_host, portPathDelim);
-        std::string_view port_sv;
+        // std::string_view port_sv;
         if (f1.empty() && isLocal()) {  // no path, but it is mandatory for 'local'!
             return _isValid;
         } else {
@@ -156,15 +156,15 @@ public:
                 return _isValid;
             }
 
-            port_sv = std::string_view(f1.end(), _host.end());
+            _portView = std::string_view(f1.end(), _host.end());
-            if (port_sv.size()) {
+            if (_portView.size()) {
                 _host = std::string_view(_host.begin(), f1.begin());
 
                 if (!isLocal()) {
                     // convert port string to int
-                    auto end_ptr = port_sv.data() + port_sv.size();
+                    auto end_ptr = _portView.data() + _portView.size();
 
-                    auto [ptr, ec] = std::from_chars(port_sv.data(), end_ptr, _port);
+                    auto [ptr, ec] = std::from_chars(_portView.data(), end_ptr, _port);
                     if (ec != std::errc() || ptr != end_ptr) {
                         return _isValid;
                     }
@@ -202,6 +202,12 @@ public:
         return _isValid;
     }
 
+
+    auto endpoint() const
+    {
+        return _endpoint;
+    }
+
     template <traits::adc_view_or_output_char_range R>
     R proto() const
     {
@@ -229,6 +235,17 @@ public:
         return _port;
     }
 
+    template <traits::adc_view_or_output_char_range R>
+    R portView() const
+    {
+        return part<R>(PORT_PART);
+    }
+
+    std::string_view portView() const
+    {
+        return portView<std::string_view>();
+    }
+
     template <traits::adc_view_or_output_char_range R>
     R path() const
     {
@@ -287,9 +304,39 @@ public:
         return proto() == protoMarkWSS;
     }
 
+    // add '\0' char (or replace special-meaning char/char-sequence) to construct UNIX abstract namespace
+    // endpoint path
+    template <typename T = std::nullptr_t>
+    AdcEndpoint& makeAbstract(const T& mark = nullptr)
+        requires(traits::adc_input_char_range<T> || std::same_as<std::remove_cv_t<T>, char> ||
+                 std::is_null_pointer_v<std::remove_cv_t<T>>)
+    {
+        if (!(isLocalStream() || isLocalSeqpacket())) {  // only local proto is valid!
+            return *this;
+        }
+
+        if constexpr (std::is_null_pointer_v<T>) {  // just insert '\0'
+            auto it = _endpoint.insert(std::string::const_iterator(_path.begin()), '\0');
+            _path = std::string_view(it, _endpoint.end());
+        } else if constexpr (std::same_as<std::remove_cv_t<T>, char>) {  // replace a character (mark)
+            auto pos = std::distance(_endpoint.cbegin(), std::string::const_iterator(_path.begin()));
+            if (_endpoint[pos] == mark) {
+                _endpoint[pos] = '\0';
+            }
+        } else {  // replace a character range (mark)
+            if (std::ranges::equal(_path | std::views::take(std::ranges::size(mark), mark))) {
+                auto pos = std::distance(_endpoint.cbegin(), std::string::const_iterator(_path.begin()));
+                _endpoint.replace(pos, std::ranges::size(mark), 1, '\0');
+                _path = std::string_view(_endpoint.begin() + pos, _endpoint.end());
+            }
+        }
+
+        return *this;
+    }
+
 protected:
     std::string _endpoint;
-    std::string_view _proto, _host, _path;
+    std::string_view _proto, _host, _path, _portView;
     int _port;
     bool _isValid;
 
@@ -312,7 +359,7 @@ protected:
         return found ? idx : -1;
     }
 
-    enum EndpointPart { PROTO_PART, HOST_PART, PATH_PART };
+    enum EndpointPart { PROTO_PART, HOST_PART, PATH_PART, PORT_PART };
 
     template <traits::adc_view_or_output_char_range R>
     R part(EndpointPart what) const
@@ -335,6 +382,9 @@ protected:
             case PATH_PART:
                 part = _path;
                 break;
+            case PORT_PART:
+                part = _portView;
+                break;
             default:
                 break;
         }

net/adc_net_concepts.h

@@ -52,15 +52,15 @@ using adc_common_duration_t = adc_duration_common_type_t<std::chrono::nanosecond
 //         a) true - asynchronous operation completed without errors
 //         b) false - an error occured
 template <typename ERRT>
-concept adc_async_callback_err_t = std::convertible_to<std::remove_cvref_t<ERRT>, bool> ||
+concept adc_async_callback_err_c = std::convertible_to<std::remove_cvref_t<ERRT>, bool> ||
                                    requires(const std::remove_cvref_t<ERRT> err) { err.operator bool(); };
 
 // concepts for asynchronous opereration callback callable
 //      1) the type must be a callable with at least 1 input argument
-//      2) the first argument type must satisfy the concept adc_async_callback_err_t
+//      2) the first argument type must satisfy the concept adc_async_callback_err_c
 template <typename T>
-concept adc_async_callback_t = traits::adc_is_callable<T> && (traits::adc_func_traits<T>::arity >= 1) &&
+concept adc_async_callback_c = traits::adc_is_callable<T> && (traits::adc_func_traits<T>::arity >= 1) &&
-                               adc_async_callback_err_t<traits::adc_func_arg1_t<T>>;
+                               adc_async_callback_err_c<traits::adc_func_arg1_t<T>>;
 
 /*
     struct NetService {
@@ -107,23 +107,25 @@ concept adc_netservice_c = requires(SRVT srv, const SRVT srv_const) {
                                 // underlying protocol
 
     // asynchronous operation error
-    requires adc_async_callback_err_t<typename SRVT::async_callback_err_t>;
+    requires adc_async_callback_err_c<typename SRVT::async_callback_err_t>;
 
     // callback callables for asynchronous operations
-    requires adc_async_callback_t<typename SRVT::async_connect_callback_t>;
+    requires adc_async_callback_c<typename SRVT::async_connect_callback_t>;
-    requires adc_async_callback_t<typename SRVT::async_send_callback_t>;
+    requires adc_async_callback_c<typename SRVT::async_send_callback_t>;
-    requires adc_async_callback_t<typename SRVT::async_receive_callback_t>;
+    requires adc_async_callback_c<typename SRVT::async_receive_callback_t>;
 
 
     // acceptor type
     requires std::is_class_v<typename SRVT::acceptor_t>;
-    requires adc_async_callback_t<typename SRVT::acceptor_t::async_accept_callback_t>;
+    requires adc_async_callback_c<typename SRVT::acceptor_t::async_accept_callback_t>;
-    requires requires(typename SRVT::acceptor_t acc) {
+    requires requires(typename SRVT::acceptor_t acc, const typename SRVT::acceptor_t acc_const) {
         acc.asyncAccept(std::declval<typename SRVT::acceptor_t::async_accept_callback_t>(),
                         std::declval<const typename SRVT::timeout_t&>());
 
         // { acc.accept(std::declval<const typename SRVT::timeout_t&>()) } -> std::same_as<SRVT>;
         acc.accept(std::declval<const typename SRVT::timeout_t&>());
+
+        { acc_const.localEndpoint() } -> traits::formattable;
     };
 
 
@@ -134,9 +136,6 @@ concept adc_netservice_c = requires(SRVT srv, const SRVT srv_const) {
 
 
     // asynchronous (non-blocking) operations
-    // srv.asyncAccept(std::declval<const typename SRVT::endpoint_t&>(), std::declval<typename
-    // SRVT::async_call_ctx_t&>(),
-    //                 std::declval<const typename SRVT::timeout_t&>());
 
     srv.asyncConnect(std::declval<const typename SRVT::endpoint_t&>(),
                      std::declval<typename SRVT::async_connect_callback_t>(),
@@ -150,7 +149,7 @@ concept adc_netservice_c = requires(SRVT srv, const SRVT srv_const) {
                      std::declval<const typename SRVT::timeout_t&>());
 
     // synchronous (blocking) operations
-    // srv.accept(std::declval<const typename SRVT::endpoint_t&>(), std::declval<const typename SRVT::timeout_t&>());
+    // it is assumed these methods throw an exception if error occures
 
     srv.connect(std::declval<const typename SRVT::endpoint_t&>(), std::declval<const typename SRVT::timeout_t&>());
 
@@ -160,6 +159,8 @@ concept adc_netservice_c = requires(SRVT srv, const SRVT srv_const) {
 
     srv.close();
 
+    { srv_const.remoteEndpoint() } -> traits::formattable;
+
     // // static method
     // SRVT::formatError(std::declval<typename SRVT::async_callback_err_t>(), std::declval<std::string&>());
 
@@ -177,7 +178,7 @@ concept adc_netsession_c =
         requires adc_netservice_c<typename SESST::netservice_t>;
         typename SESST::netsession_ctx_t;
 
-        requires std::constructible_from<SESST, const typename SESST::netsession_ident_t,
+        requires std::constructible_from<SESST, typename SESST::netsession_ident_t,
                                          // std::shared_ptr<typename SESST::netservice_t>,
                                          typename SESST::netservice_t, typename SESST::netsession_ctx_t>;
 
@@ -224,16 +225,28 @@ concept adc_netsession_proto_c =
 
 
 
-/*  LOGGER  */
+/*  LOGGER:
+ *
+ *
+ */
 
 template <typename LOGGERT>
-concept adc_logger_c = requires(LOGGERT log) {
+concept adc_logger_c = requires(LOGGERT log, const LOGGERT log_const) {
-    // logging method must accept at least the single argument - formating string
+    typename LOGGERT::loglevel_t;
-    log.logInfo(std::declval<std::string_view>());
-    log.logInfo(std::declval<std::string_view>(), std::declval<std::string>());
 
-    log.logWarn(std::declval<std::string_view>(), std::declval<std::string>());
+    log.setLogLevel(std::declval<typename LOGGERT::loglevel_t>());
-    log.logError(std::declval<std::string_view>(), std::declval<std::string>());
+    { log_const.getLogLevel() } -> std::same_as<typename LOGGERT::loglevel_t>;
+
+    // logging method signature:
+    //     void method(loglevel_t level, traits::formattable auto&& args...)
+
+    log.logMessage(std::declval<typename LOGGERT::loglevel_t>(), std::declval<std::string>());
+
+    // specialized logging methods signature:
+
+    log.logInfo(std::declval<std::string>());
+    log.logDebug(std::declval<std::string>());
+    log.logError(std::declval<std::string>());
 };
 
 

net/adc_netclient.h

@@ -0,0 +1,122 @@
+#pragma once
+
+#include "../common/adc_utils.h"
+#include "adc_net_concepts.h"
+#include "adc_netserver.h"
+
+namespace adc
+{
+
+
+/*  A VERY GENERIC NETWORK CLIENT  */
+
+
+template <typename IdentT = std::string, interfaces::adc_logger_c LoggerT = utils::AdcOstreamLogger<char>>
+class AdcGenericNetClient : public LoggerT, public AdcNetSessionManager
+{
+public:
+    typedef IdentT client_ident_t;
+    typedef LoggerT logger_t;
+
+    template <typename... LoggerCtorArgTs>
+    AdcGenericNetClient(const IdentT& ident, LoggerCtorArgTs&&... args)
+        : _clientIdent(ident), LoggerT(std::forward<LoggerCtorArgTs>(args)...)
+    {
+    }
+
+
+    virtual ~AdcGenericNetClient()
+    {
+        stopAllSessions();
+    }
+
+
+    // start the client: connect to server and start session
+    template <interfaces::adc_netsession_c SessionT, typename... NetServiceCtorArgTs>
+    void start(const SessionT::netservice_t::endpoint_t& endpoint,
+               SessionT::netsession_ident_t id,
+               SessionT::netsession_ctx_t sess_ctx,
+               NetServiceCtorArgTs&&... ctor_args)
+    {
+        auto srv_sptr =
+            std::make_shared<typename SessionT::netservice_t>(std::forward<NetServiceCtorArgTs>(ctor_args)...);
+
+        srv_sptr->asyncConnect(
+            endpoint,
+            [id = std::move(id), sess_ctx = std::move(sess_ctx), srv_sptr, this](auto ec) {
+                if (ec) {
+                    this->logError("Cannot connect to server: {}", SessionT::netservice_t::formattableError(ec));
+                } else {
+                    auto sess = std::make_shared<SessionT>(id, std::move(*srv_sptr), sess_ctx);
+                    startSession(sess);
+                }
+            },
+            _connectTimeout);
+    }
+
+
+    template <interfaces::adc_netsession_c SessionT,
+              std::invocable<typename SessionT::netservice_t::async_callback_err_t, SessionT> TokenT,
+              typename... NetServiceCtorArgTs>
+    void start(const SessionT::netservice_t::endpoint_t& endpoint,
+               SessionT::netsession_ident_t id,
+               SessionT::netsession_ctx_t sess_ctx,
+               TokenT&& token,
+               NetServiceCtorArgTs&&... ctor_args)
+    {
+        auto srv_sptr =
+            std::make_shared<typename SessionT::netservice_t>(std::forward<NetServiceCtorArgTs>(ctor_args)...);
+
+        // try to connect to server and create session
+        srv_sptr->asyncConnect(
+            endpoint,
+            [id = std::move(id), sess_ctx = std::move(sess_ctx), srv_sptr,
+             wrapper = traits::adc_pf_wrapper(std::forward<TokenT>(token))](auto ec) mutable {
+                // create session
+                std::get<0>(wrapper)(ec, {std::move(id), std::move(*srv_sptr), std::move(sess_ctx)});
+            },
+            _connectTimeout);
+    }
+
+
+    template <traits::adc_time_duration_c DT>
+    void setConnectTimeout(const DT& timeout)
+    {
+        _connectTimeout = std::chrono::duration_cast<decltype(_connectTimeout)>(timeout);
+    }
+
+    auto getConnectionTimeout() const
+    {
+        return _connectTimeout;
+    }
+
+protected:
+    client_ident_t _clientIdent;
+
+    std::chrono::milliseconds _connectTimeout = std::chrono::milliseconds(5000);
+
+    template <interfaces::adc_netservice_c ServiceT,
+              traits::adc_input_char_range SendMsgT,
+              typename TokenT,
+              traits::adc_time_duration_c SendTimeoutT = std::chrono::milliseconds,
+              traits::adc_time_duration_c RecvTimeoutT = std::chrono::milliseconds>
+    auto asyncSendRecv(ServiceT& netservice,
+                       const SendMsgT& send_msg,
+                       TokenT&& token,
+                       const SendTimeoutT& send_timeout = std::chrono::milliseconds(5000),
+                       const RecvTimeoutT& recv_timeout = std::chrono::milliseconds(5000))
+    {
+        return netservice.asyncSend(
+            send_msg,
+            [&netservice, recv_timeout, wrapper = traits::adc_pf_wrapper(std::forward<TokenT>(token)), this](auto err) {
+                if (err) {
+                    this->logError("An error occured while sending the message: {}", ServiceT::formattableError(err));
+                } else {
+                    netservice.asyncReceive(std::get<0>(wrapper), recv_timeout);
+                }
+            },
+            send_timeout);
+    }
+};
+
+}  // namespace adc

net/adc_netproto.h

@@ -21,6 +21,7 @@ concept adc_netproto_c = adc_range_of_view_char_range<R> && requires(T t, const
 namespace constants
 {
 
+static constexpr char ADC_DEFAULT_NETPROTO_STARTSEQ[] = "\v";
 static constexpr char ADC_DEFAULT_NETPROTO_STOPSEQ[] = "\n";
 
 static constexpr char ADC_DEFAULT_NETPROTO_STARTMARK[] = "\n\t\r\v\r\t\n";
@@ -39,7 +40,10 @@ struct AdcStopSeqSessionProto {
 
     typedef std::string proto_ident_t;
 
-    proto_ident_t ident() const { return "STOP SEQUENCE PROTO"; }
+    proto_ident_t ident() const
+    {
+        return "STOP SEQUENCE PROTO";
+    }
 
     // template <traits::adc_input_char_range R>
     // auto search(const R& r)
@@ -142,6 +146,105 @@ struct AdcStopSeqSessionProto {
 };
 
 
+template <const char* STARTSEQ = constants::ADC_DEFAULT_NETPROTO_STARTSEQ,
+          const char* STOPSEQ = constants::ADC_DEFAULT_NETPROTO_STOPSEQ>
+struct AdcStartStopSeqSessionProto {
+    static constexpr std::string_view START_SEQ{STARTSEQ};
+    static constexpr size_t START_SEQ_SIZE = START_SEQ.size();
+    static constexpr std::string_view STOP_SEQ{STOPSEQ};
+    static constexpr size_t STOP_SEQ_SIZE = STOP_SEQ.size();
+
+    static_assert(START_SEQ_SIZE, "START BYTE SEQUENCE MUST NOT BE AN EMPTY ONE!!!");
+    static_assert(STOP_SEQ_SIZE, "STOP BYTE SEQUENCE MUST NOT BE AN EMPTY ONE!!!");
+
+    typedef std::string proto_ident_t;
+
+    proto_ident_t ident() const
+    {
+        return "STOP SEQUENCE PROTO";
+    }
+
+    template <traits::adc_input_char_range R>
+    auto search(const R& r)
+    {
+        auto func = [&r](auto& result) {
+            if (std::ranges::size(r) < (START_SEQ_SIZE + STOP_SEQ_SIZE)) {
+                return;
+            }
+
+            auto found_start = std::ranges::search(r, START_SEQ);
+            if (found_start.empty()) {
+                return;
+            }
+
+            auto found_stop = std::ranges::search(r, STOP_SEQ);
+            if (found_stop.empty()) {
+                return;
+            }
+
+            if (found_start.begin() > found_stop.begin()) {
+                return;
+            }
+
+            if constexpr (std::ranges::viewable_range<R>) {
+                result = std::span(found_start.begin(), found_stop.end());
+            } else {
+                std::ranges::copy(found_start.begin(), found_stop.end(), std::back_inserter(result));
+            }
+        };
+
+        if constexpr (std::ranges::viewable_range<R>) {
+            auto res = std::span(r.begin(), r.begin());  // empty std::span
+            func(res);
+            return res;
+        } else {
+            auto res = std::vector<char>();
+            func(res);
+            return res;
+        }
+    }
+
+
+    template <traits::adc_input_char_range R>
+    auto toProto(const R& r)
+    {
+        // return 3-element array with the first element - a view of the start sequence, the second one - as a view of
+        // the input range and the third one - a view of the stop sequence
+
+        if constexpr (std::ranges::viewable_range<R>) {
+            auto res = std::array{std::span(std::span(START_SEQ.begin(), START_SEQ.end()), r.begin(), r.end()),
+                                  std::span(STOP_SEQ.begin(), STOP_SEQ.end())};
+
+            return res;
+        } else {  // return a copy of input range with added to the fron start sequence and appended stop sequence
+            std::decay_t<decltype(r)> res;
+            std::ranges::copy(START_SEQ, std::back_inserter(res));
+            std::ranges::copy(r, std::back_inserter(res));
+            std::ranges::copy(STOP_SEQ, std::back_inserter(res));
+            return res;
+        }
+    }
+
+    template <traits::adc_input_char_range R>
+    auto fromProto(const R& r)
+    {
+        size_t N = std::distance(r.begin(), r.end());
+
+        if (N < (START_SEQ_SIZE + STOP_SEQ_SIZE)) {  // one must ensure for input range size correctness
+            return std::span(r.begin(), r.begin());
+        }
+
+        if constexpr (std::ranges::viewable_range<R>) {
+            return std::span(r.begin() + START_SEQ_SIZE, r.end() - STOP_SEQ_SIZE);
+        } else {
+            R res;
+            std::ranges::copy(r | std::views::drop(START_SEQ_SIZE) | std::views::take(N - STOP_SEQ_SIZE),
+                              std::back_inserter(res));
+            return res;
+        }
+    }
+};
+
 // session protocol for datagram-kind message (e.g. UDP, seqpacket)
 // The protocol does not contain any special characters, so to/fromProto methods
 // return just a copy/one-element-array-of-vew/view of input byte
@@ -149,7 +252,10 @@ struct AdcStopSeqSessionProto {
 struct AdcDatagramSessionProto {
     typedef std::string proto_ident_t;
 
-    proto_ident_t ident() const { return "DATAGRAM PROTO"; }
+    proto_ident_t ident() const
+    {
+        return "DATAGRAM PROTO";
+    }
 
     template <traits::adc_input_char_range R>
     auto search(const R& r)
@@ -201,7 +307,10 @@ struct AdcBinaryBlobSessionProto {
 
     typedef std::string proto_ident_t;
 
-    proto_ident_t ident() const { return "BINARY BLOB PROTO"; }
+    proto_ident_t ident() const
+    {
+        return "BINARY BLOB PROTO";
+    }
 
     template <traits::adc_input_char_range R>
     auto search(const R& r)

net/adc_netserver.h

@@ -8,7 +8,6 @@ ABSTRACT DEVICE COMPONENTS LIBRARY
 
 #include <filesystem>
 #include <functional>
-#include <iostream>
 #include <list>
 #include <set>
 #include <unordered_map>
@@ -21,8 +20,10 @@ ABSTRACT DEVICE COMPONENTS LIBRARY
 #endif
 
 
+#include "../common/adc_utils.h"
 #include "adc_net_concepts.h"
 
+
 namespace adc
 {
 
@@ -30,87 +31,6 @@ namespace adc
 /*  SOME USEFULL PRIVITIVES  */
 
 
-// A simple std::ostream logger
-class AdcTrivialLogger
-{
-public:
-    virtual ~AdcTrivialLogger() = default;
-
-    // protected:
-    static constexpr std::string_view errorLevelMark{"error"};
-    static constexpr std::string_view warnLevelMark{"warning"};
-    static constexpr std::string_view infoLevelMark{"info"};
-
-    std::basic_ostream<char>& _stream;
-
-    AdcTrivialLogger(std::basic_ostream<char>& stream = std::cout) : _stream(stream) {}
-
-    template <traits::formattable... ArgTs>
-    std::string logMsgFormat(std::string_view level_mark, std::string_view fmt, ArgTs&&... args)
-    {
-        std::string s;
-        std::format_to(std::back_inserter(s), fmt, std::forward<ArgTs>(args)...);
-
-        std::stringstream st;
-
-        const std::time_t now = std::chrono::system_clock::to_time_t(std::chrono::system_clock::now());
-
-        // format log-message in form:
-        //    [YYYY-MM-DD HH:MM:SS][level] log-message
-        //
-        st << std::put_time(std::localtime(&now), "[%F %T]") << "[" << level_mark << "] " << s;
-
-        return st.str();
-    }
-
-
-    // define default logging function of ERROR, WARNING and INFO levels
-    template <traits::formattable... ArgTs>
-    void logError(this auto&& self, std::string_view fmt, ArgTs&&... args)
-    {
-        using obj_t = decltype(self);
-
-        if constexpr (std::same_as<std::remove_cvref_t<obj_t>, AdcTrivialLogger>) {
-            std::forward<obj_t>(self)._stream
-                << std::forward<obj_t>(self).logMsgFormat(errorLevelMark, fmt, std::forward<ArgTs>(args)...) << "\n"
-                << std::flush;
-        } else {
-            std::forward<obj_t>(self).logError(fmt, std::forward<ArgTs>(args)...);
-        }
-    }
-
-    template <traits::formattable... ArgTs>
-    void logWarn(this auto&& self, std::string_view fmt, ArgTs&&... args)
-    {
-        using obj_t = decltype(self);
-
-        if constexpr (std::same_as<obj_t, AdcTrivialLogger>) {
-            std::forward<obj_t>(self)._stream
-                << std::forward<obj_t>(self).logMsgFormat(warnLevelMark, fmt, std::forward<ArgTs>(args)...) << "\n"
-                << std::flush;
-        } else {
-            std::forward<obj_t>(self).logWarn(fmt, std::forward<ArgTs>(args)...);
-        }
-    }
-
-    template <traits::formattable... ArgTs>
-    void logInfo(this auto&& self, std::string_view fmt, ArgTs&&... args)
-    {
-        using obj_t = decltype(self);
-
-        if constexpr (std::same_as<obj_t, AdcTrivialLogger>) {
-            std::forward<obj_t>(self)._stream
-                << std::forward<obj_t>(self).logMsgFormat(infoLevelMark, fmt, std::forward<ArgTs>(args)...) << "\n"
-                << std::flush;
-        } else {
-            std::forward<obj_t>(self).logInfo(fmt, std::forward<ArgTs>(args)...);
-        }
-    }
-};
-
-
-static_assert(interfaces::adc_logger_c<AdcTrivialLogger>, "!!!!!!!!!!!");
-
 // A generic implementation of POSIX OS daemon
 class AdcPosixGenericDaemon
 {
@@ -131,8 +51,6 @@ public:
             tmp_path = std::filesystem::current_path().root_path();
         }
 
-        // _ioContext.notify_fork(asio::execution_context::fork_prepare);
-
         if (pid_t pid = fork()) {
             if (pid > 0) {
                 exit(0);
@@ -161,7 +79,6 @@ public:
         close(1);
         close(2);
 
-// _ioContext.notify_fork(asio::io_context::fork_child);
 #endif
         daemonizeFinalize();
     }
@@ -303,25 +220,39 @@ protected:
 };
 
 
+static_assert(interfaces::adc_logger_c<utils::AdcOstreamLogger<>>, "!!!!!");
+
+
 
 /*  very generic network server  */
 
-template <typename IdentT = std::string>
+template <typename IdentT = std::string, interfaces::adc_logger_c LoggerT = utils::AdcOstreamLogger<char>>
-class AdcGenericNetServer : public AdcPosixGenericDaemon, public AdcNetSessionManager, public AdcTrivialLogger
+class AdcGenericNetServer : public AdcPosixGenericDaemon, public AdcNetSessionManager, public LoggerT
 {
 public:
     typedef IdentT server_ident_t;
+    typedef LoggerT logger_t;
 
-    AdcGenericNetServer(const server_ident_t& id, std::basic_ostream<char>& log_stream = std::cout)
+    template <typename... LoggerCtorArgTs>
-        : AdcTrivialLogger(log_stream), _serverIdent(id)
+    AdcGenericNetServer(const server_ident_t& id, LoggerCtorArgTs&&... ctor_args)
+        : _serverIdent(id), LoggerT(std::forward<LoggerCtorArgTs>(ctor_args)...)
     {
+        if constexpr (traits::formattable<IdentT>) {
+            logInfo("Create ADC generic network server with ID: {} (addr = {}, thread = {})", id, (void*)this,
+                    utils::AdcThisThreadId());
+        } else {
+            logInfo("Create ADC generic network server (addr = {}, thread = {})", (void*)this,
+                    utils::AdcThisThreadId());
+        }
     }
 
 
     AdcGenericNetServer(const AdcGenericNetServer&) = delete;
     AdcGenericNetServer(AdcGenericNetServer&& other)
-        : AdcPosixGenericDaemon(std::move(other)), AdcNetSessionManager(std::move(other))
+        : AdcPosixGenericDaemon(std::move(other)), AdcNetSessionManager(std::move(other)), LoggerT(std::move(other))
     {
+        logDebug("Move ADC server class: this = {}, target = {}", (void*)this, (void*)&other);
+
         if (this == &other) {
             return;
         }
@@ -336,11 +267,22 @@ public:
         _moveCtorFunc = std::move(other._moveCtorFunc);
     }
 
-    virtual ~AdcGenericNetServer() = default;
+    virtual ~AdcGenericNetServer()
+    {
+        if constexpr (traits::formattable<IdentT>) {
+            logInfo("Delete ADC generic network server with ID: {} (addr = {}, thread = {})", _serverIdent, (void*)this,
+                    utils::AdcThisThreadId());
+        } else {
+            logInfo("Delete ADC generic network server (addr = {}, thread = {})", (void*)this,
+                    utils::AdcThisThreadId());
+        }
+    };
 
     AdcGenericNetServer& operator=(const AdcGenericNetServer&) = delete;
     AdcGenericNetServer& operator=(AdcGenericNetServer&& other)
     {
+        logDebug("Assign-move ADC server class: this = {}, target = {}", (void*)this, (void*)&other);
+
         if (this != &other) {
             AdcPosixGenericDaemon::operator=(std::move(other));
             AdcNetSessionManager::operator=(std::move(other));
@@ -369,6 +311,8 @@ public:
     void start(SessionT::netsession_ident_t id, SessionT::netsession_ctx_t sess_ctx, AcceptorCtorArgTs&&... ctor_args)
         requires traits::adc_hashable_c<typename SessionT::netsession_ident_t>
     {
+        logDebug("Call {}", __PRETTY_FUNCTION__);
+
         if (!_isListening<SessionT>[this][id]) {
             auto acceptor = std::make_shared<typename SessionT::netservice_t::acceptor_t>(
                 std::forward<AcceptorCtorArgTs>(ctor_args)...);
@@ -380,6 +324,16 @@ public:
                 _isListening<SessionT>[inst][id] = false;
             });
 
+            if constexpr (traits::formattable<typename SessionT::netsession_ident_t>) {
+                logInfo(
+                    "Start listening for client connections at <{}> endpoint (session ID: {}, server addr = {}, thread "
+                    "= {})",
+                    acceptor->localEndpoint(), id, (void*)this, utils::AdcThisThreadId());
+            } else {
+                logInfo("Start listening for client connections at <{}> endpoint (server addr = {}, thread = {})",
+                        acceptor->localEndpoint(), (void*)this, utils::AdcThisThreadId());
+            }
+
             doAccept<SessionT>(acceptor, std::move(id), std::move(sess_ctx));
         }
 
@@ -413,8 +367,47 @@ public:
     };
 
 
+    void setAcceptTimeout(const traits::adc_time_duration_c auto& timeout)
+    {
+        _acceptTimeout = std::chrono::duration_cast<decltype(_acceptTimeout)>(timeout);
+    }
+
+
+    auto getAcceptTimeout() const
+    {
+        return _acceptTimeout;
+    }
+
+
+    // helper methods for logging
+
+    template <traits::formattable... Ts>
+    void logMessage(LoggerT::loglevel_t level, std::format_string<Ts...> fmt, Ts&&... args)
+    {
+        LoggerT::logMessage(level, std::format(fmt, std::forward<Ts>(args)...));
+    }
+
+    template <traits::formattable... Ts>
+    void logInfo(std::format_string<Ts...> fmt, Ts&&... args)
+    {
+        LoggerT::logInfo(std::format(fmt, std::forward<Ts>(args)...));
+    }
+
+    template <traits::formattable... Ts>
+    void logDebug(std::format_string<Ts...> fmt, Ts&&... args)
+    {
+        LoggerT::logDebug(std::format(fmt, std::forward<Ts>(args)...));
+    }
+
+    template <traits::formattable... Ts>
+    void logError(std::format_string<Ts...> fmt, Ts&&... args)
+    {
+        LoggerT::logError(std::format(fmt, std::forward<Ts>(args)...));
+    }
 
 protected:
+    std::chrono::seconds _acceptTimeout = std::chrono::seconds::max();
+
     // template <interfaces::adc_netsession_c SessionT>
     // inline static std::unordered_map<const AdcGenericNetServer*, bool> _isListening{};
     template <interfaces::adc_netsession_c SessionT>
@@ -430,27 +423,29 @@ protected:
     template <typename SessionT, typename AT, typename IDT, typename CTXT>
     void doAccept(std::shared_ptr<AT> acceptor, IDT id, CTXT sess_ctx)
     {
-        acceptor->asyncAccept([acceptor, id = std::move(id), sess_ctx = std::move(sess_ctx), this](
+        acceptor->asyncAccept(
+            [acceptor, id = std::move(id), sess_ctx = std::move(sess_ctx), this](
                 auto ec, typename SessionT::netservice_t srv) mutable {
                 if (!ec) {
+                    logInfo(
+                        "Client connection is succesfully accepted! Client endpoint: {} (server addr = {}, thread = "
+                        "{})",
+                        srv.remoteEndpoint(), (void*)this, utils::AdcThisThreadId());
+
                     auto sess = std::make_shared<SessionT>(id, std::move(srv), sess_ctx);
                     startSession(sess);
 
                     _isListening<SessionT>[this][id] = true;
                     doAccept<SessionT>(acceptor, std::move(id), std::move(sess_ctx));
                 } else {
-                // std::string str{"Cannot start accepting connection: "};
+                    this->logError("Cannot start accepting connection: {}",
-                // SessionT::netservice_t::formatError(ec, str);
+                                   SessionT::netservice_t::formattableError(ec));
-                // errorMessage(str);
-
-                this->logError("Cannot start accepting connection: {}", SessionT::netservice_t::formattableError(ec));
 
                     _isListening<SessionT>[this][id] = false;
                 }
-        });
+            },
+            _acceptTimeout);
     }
-
-    // virtual void errorMessage(const std::string&) {};
 };
 
 

net/asio/adc_device_netserver_asio.h

@@ -14,20 +14,26 @@
 namespace adc::impl
 {
 
-template <typename IdentT = std::string>
+template <typename IdentT = std::string, interfaces::adc_logger_c LoggerT = utils::AdcOstreamLogger<char>>
-class AdcDeviceNetServerASIO : public AdcDeviceNetServer<IdentT>
+class AdcDeviceNetServerASIO : public AdcDeviceNetServer<IdentT, LoggerT>
 {
-    typedef AdcDeviceNetServer<IdentT> base_t;
+    typedef AdcDeviceNetServer<IdentT, LoggerT> base_t;
 
 public:
+    using typename base_t::logger_t;
     using typename base_t::server_ident_t;
+
     typedef std::string session_ident_t;
 
     template <typename ServiceT>
     using Session = typename base_t::template Session<ServiceT, session_ident_t>;
 
-    AdcDeviceNetServerASIO(const server_ident_t& id, asio::io_context& io_context)
+    template <typename... LoggerCtorArgTs>
-        : base_t(id), _ioContext(io_context), _stopSignal(io_context), _restartSignal(io_context)
+    AdcDeviceNetServerASIO(const server_ident_t& id, asio::io_context& io_context, LoggerCtorArgTs&&... ctor_args)
+        : base_t(id, std::forward<LoggerCtorArgTs>(ctor_args)...),
+          _ioContext(io_context),
+          _stopSignal(io_context),
+          _restartSignal(io_context)
     {
     }
 
@@ -42,25 +48,71 @@ public:
 #endif
     {
         if (!endpoint.isValid()) {
+            this->logError("Invalid given endpoint: <{}>", endpoint.endpoint());
             return;
         }
 
 
+
         // may throw here!
         if (endpoint.isTCP()) {
-            asio::ip::tcp::endpoint ept(asio::ip::make_address(endpoint.host()), endpoint.port());
+            // asio::ip::tcp::endpoint ept(asio::ip::make_address(endpoint.host()), endpoint.port());
             using srv_t = AdcNetServiceASIO<asio::ip::tcp, SessProtoT>;
-            // base_t::template start<Session<srv_t>>("TCP", this, _ioContext, ept);
+
-            base_t::template start<Session<srv_t>>("TCP", {this, _sessionRecvTimeout, _sessionSendTimeout}, _ioContext,
+            // base_t::template start<Session<srv_t>>("TCP", {this, _sessionRecvTimeout, _sessionSendTimeout},
-                                                   ept);
+            // _ioContext,
+            //                                        ept);
+            auto res = std::make_shared<asio::ip::tcp::resolver>(_ioContext);
+            res->async_resolve(
+                endpoint.host(), endpoint.portView(), [endpoint, res, this](std::error_code ec, auto results) {
+                    if (ec) {
+                        this->logError(
+                            "An error occured while resolve hostname ('{}') of the given endpoint! (ec = {})",
+                            endpoint.host(), ec.message());
+                        this->logError("Cannot start listening at endpoint '{}'!", endpoint.endpoint());
+                    } else {
+                        if (results.size() == 1) {
+                            this->logDebug("Resolved the single IP-address for the hostname '{}'", endpoint.host());
+                        } else {
+                            this->logDebug("Resolved {} IP-addresses for the hostname '{}'! Use of the first one!",
+                                           results.size(), endpoint.host());
+                        }
+                        base_t::template start<Session<srv_t>>("TCP", {this, _sessionRecvTimeout, _sessionSendTimeout},
+                                                               _ioContext, *results.begin());
+                    }
+                });
+
 #ifdef USE_OPENSSL_WITH_ASIO
         } else if (endpoint.isTLS()) {
-            asio::ip::tcp::endpoint ept(asio::ip::make_address(endpoint.host()), endpoint.port());
+            // asio::ip::tcp::endpoint ept(asio::ip::make_address(endpoint.host()), endpoint.port());
             using srv_t = AdcNetServiceASIOTLS<asio::ip::tcp, SessProtoT>;
-            // base_t::template start<Session<srv_t>>("TLS", this, _ioContext, ept, std::move(tls_context),
+            // base_t::template start<Session<srv_t>>("TLS", {this, _sessionRecvTimeout, _sessionSendTimeout},
-            //                                        tls_verify_mode);
+            // _ioContext,
-            base_t::template start<Session<srv_t>>("TLS", {this, _sessionRecvTimeout, _sessionSendTimeout}, _ioContext,
+            //                                        ept, std::move(tls_context), tls_verify_mode);
-                                                   ept, std::move(tls_context), tls_verify_mode);
+
+            auto res = std::make_shared<asio::ip::tcp::resolver>(_ioContext);
+            res->async_resolve(
+                endpoint.host(), endpoint.portView(),
+                [endpoint, res, tls_context = std::move(tls_context), tls_verify_mode, this](std::error_code ec,
+                                                                                             auto results) mutable {
+                    if (ec) {
+                        this->logError(
+                            "An error occured while resolve hostname ('{}') of the given endpoint! (ec = {})",
+                            endpoint.host(), ec.message());
+                        this->logError("Cannot start listening at endpoint '{}'!", endpoint.endpoint());
+                    } else {
+                        if (results.size() == 1) {
+                            this->logDebug("Resolved the single IP-address for the hostname '{}'", endpoint.host());
+                        } else {
+                            this->logDebug("Resolved {} IP-addresses for the hostname '{}'! Use of the first one!",
+                                           results.size(), endpoint.host());
+                        }
+                        base_t::template start<Session<srv_t>>("TLS", {this, _sessionRecvTimeout, _sessionSendTimeout},
+                                                               _ioContext, *results.begin(), std::move(tls_context),
+                                                               tls_verify_mode);
+                    }
+                });
+
 #endif
         } else if (endpoint.isLocal()) {
             if (endpoint.isLocalStream()) {
@@ -93,6 +145,26 @@ public:
         requires(std::convertible_to<std::ranges::range_value_t<RST>, int> &&
                  std::convertible_to<std::ranges::range_value_t<RRT>, int>)
     {
+        auto sig_list = [](const auto& sig_range) {
+            std::string sgs;
+#ifdef _GNU_SOURCE
+            std::vector<std::string> vsg;
+
+            std::ranges::transform(sig_range, std::back_inserter(vsg),
+                                   [](auto s) { return std::format("'{}' (No = {})", sigdescr_np(s), s); });
+
+            utils::AdcJoinRange(vsg, std::string_view(", "), sgs);
+#else
+            sgs = utils::AdcDefaultValueConverter<utils::constants::DEFAULT_CONVERTER_DELIMITER_COMA>::serialize<
+                std::string>(sig_range);
+#endif
+            return sgs;
+        };
+
+        this->logDebug("Setup 'stop-server' signal to: {}", sig_list(stop_sig_num));
+        this->logDebug("Setup 'restart-server' signal to: {}", sig_list(restart_sig_num));
+
+
         for (const int sig : stop_sig_num) {
             _stopSignal.add(sig);
         }
@@ -119,6 +191,16 @@ public:
     {
         _sessionRecvTimeout = recv_timeout;
         _sessionSendTimeout = send_timeout;
+
+        this->logDebug("Set session timeouts: recv = {} msec, send = {} msec", _sessionRecvTimeout.count(),
+                       _sessionSendTimeout.count());
+    }
+
+    void daemonize()
+    {
+        this->logInfo("Daemonize server process (server addr: {})", (void*)this);
+
+        base_t::daemonize();
     }
 
 protected:
@@ -129,25 +211,35 @@ protected:
     std::chrono::milliseconds _sessionRecvTimeout = std::chrono::hours(12);
     std::chrono::milliseconds _sessionSendTimeout = std::chrono::seconds(5);
 
-
     // demonizing ASIO-related methods
     virtual void daemonizePrepare()
     {
+        this->logDebug("ASIO-related call of daemonizePrepare()");
+
         _ioContext.notify_fork(asio::execution_context::fork_prepare);
     }
 
     virtual void daemonizeFinalize()
     {
+        this->logDebug("ASIO-related call of daemonizeFinalize()");
+
         _ioContext.notify_fork(asio::io_context::fork_child);
     }
 
-    virtual void signalReceived(std::error_code, int signo)
+    virtual void signalReceived(std::error_code ec, int signo)
     {
-        std::cout << "SIGNAL: " << signo << "\n";
+#ifdef _GNU_SOURCE
+        this->logInfo("The server received the signal: '{}' (No = {}, ec = {})", sigdescr_np(signo), signo,
+                      ec.message());
+#else
+        this->logInfo("The server received the signal: {} (ec = {})", signo, ec.message());
+#endif
     };
 
     virtual void restart()
     {
+        this->logInfo("Restart server (server addr: {})", (void*)this);
+
         this->stopAllSessions();
 
         _restartSignal.async_wait([this](std::error_code ec, int signo) {

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;
 
@@ -154,7 +159,8 @@ public:
     typedef std::function<int(const std::string& serial, const std::vector<unsigned char>& fingerprint, int depth)>
         cert_comp_func_t;
 #else
-    using session_level_socket_t = socket_t;
+    // using session_level_socket_t = socket_t;
+    using session_level_socket_t = std::nullptr_t;
 #endif
 
 
@@ -259,6 +265,8 @@ public:
                         timer->cancel();
                     }
 
+                    srv->_socket.set_option(asio::socket_base::keep_alive(true));
+
                     self.complete(ec, std::move(*srv));
 
                     srv.reset();
@@ -296,6 +304,15 @@ public:
             _acceptor.close(ec);
         }
 
+
+        std::string localEndpoint() const
+        {
+            std::stringstream st;
+            st << _acceptor.local_endpoint();
+
+            return st.str();
+        }
+
     private:
         asio::io_context& _ioContext;
         srv_acceptor_t _acceptor;
@@ -565,7 +582,7 @@ public:
 
                 if (!ec) {
                     if (do_read) {
-                        do_read = false;
+                        // do_read = false;
                         if (_receiveQueue.size()) {  // return message from queue
                             timer->cancel();
                             auto imsg = _receiveQueue.front();
@@ -579,11 +596,13 @@ public:
                         }
 
                         auto n_avail = _socket.available();
-                        if (!n_avail) {
+                        // if (!n_avail) {
-                            return _socket.async_wait(asio::ip::tcp::socket::wait_read, std::move(self));
+                        //     return _socket.async_wait(asio::ip::tcp::socket::wait_read, std::move(self));
-                        }
+                        // }
                         auto buff = _streamBuffer.prepare(n_avail ? n_avail : 1);
 
+                        do_read = false;
+
                         if constexpr (isTLS) {
                             return asio::async_read(_sessSocket, std::move(buff), asio::transfer_at_least(1),
                                                     std::move(self));
@@ -629,8 +648,9 @@ public:
                     auto net_pack = this->search(std::span(start_ptr, _streamBuffer.size()));
                     if (net_pack.empty()) {
                         do_read = true;
-                        asio::post(std::move(self));  // initiate consequence socket's read operation
+                        return _socket.async_wait(asio::ip::tcp::socket::wait_read, std::move(self));
-                        return;
+                        // asio::post(std::move(self));  // initiate consequence socket's read operation
+                        // return;
                     }
 
                     timer->cancel();  // there were no errors in the asynchronous read-operation, so stop timer
@@ -758,11 +778,17 @@ public:
     }
 
 
-    // static void formatError(std::error_code err, std::string& result_str)
+    std::string remoteEndpoint() const
-    // {
+    {
-    //     std::format_to(std::back_inserter(result_str), "{} (Err category: {}) (Err msg: {})", err.value(),
+        std::stringstream st;
-    //                    err.category().name(), err.message());
+        st << _socket.remote_endpoint();
-    // }
+
+        if (st.str().empty()) {
+            return "<local>";
+        }
+
+        return st.str();
+    }
 
     static std::string formattableError(std::error_code ec)
     {
@@ -773,6 +799,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>>
@@ -794,8 +831,8 @@ protected:
 
     asio::socket_base::shutdown_type _shutdownType = asio::socket_base::shutdown_both;
 
-#ifdef USE_OPENSSL_WITH_ASIO
     session_level_socket_t _sessSocket;
+#ifdef USE_OPENSSL_WITH_ASIO
     std::conditional_t<isTLS, asio::ssl::context, std::nullptr_t> _tlsContext;
     asio::ssl::verify_mode _tlsPeerVerifyMode;
     cert_comp_func_t _tlsCertCompFunc;
@@ -911,7 +948,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

tests/adc_asio_netserver_test.cpp

@@ -8,6 +8,11 @@
 #include "../net/adc_netproto.h"
 #include "../net/asio/adc_device_netserver_asio.h"
 
+#ifdef USE_SPDLOG_LIBRARY
+#include <spdlog/sinks/stdout_color_sinks.h>
+#include "../common/adc_spdlog.h"
+#endif
+
 typedef adc::impl::AdcDeviceNetServerASIO<std::string_view> server_t;
 typedef adc::AdcDeviceAttribute<std::string, server_t::serialized_t> attr_t;
 
@@ -132,7 +137,18 @@ int main(int argc, char* argv[])
         asio::signal_set signals(io_ctx, SIGINT, SIGTERM);
         signals.async_wait([&](std::error_code, int) { io_ctx.stop(); });
 
-        adc::impl::AdcDeviceNetServerASIO server("TEST SRV", io_ctx);
+        using server_t = adc::impl::AdcDeviceNetServerASIO<std::string, adc::AdcSpdlogLogger>;
+        std::shared_ptr<spdlog::logger> logger = spdlog::stdout_color_mt("console");
+        logger->set_level(spdlog::level::debug);
+        // server_t server("TEST SRV", io_ctx, logger, "[%Y-%m-%d %T.%e][%l]: %v");
+        server_t server("TEST SRV", io_ctx, logger);
+        // server.setAcceptTimeout(std::chrono::seconds(5));
+
+        // using server_t = adc::impl::AdcDeviceNetServerASIO<>;
+        // server_t server("TEST SRV", io_ctx);
+        // server.setLogLevel(server_t::logger_t::DEBUG_LEVEL);
+
+
         server.setupSignals();
 
         server.addDevice(&dev1);
@@ -146,19 +162,20 @@ int main(int argc, char* argv[])
         for (auto& ep : epnt) {
             adc::AdcEndpoint epn(ep);
             if (epn.isValid()) {
-                if (epn.isLocalSeqpacket() || epn.isLocalStream()) {
+                epn.makeAbstract('@');
-                    if (epn.path()[0] == '@') {  // replace '@' to '\0' (use of UNIX abstract namespace)
+                // if (epn.isLocalSeqpacket() || epn.isLocalStream()) {
-                        auto it = std::ranges::find(ep, '@');
+                //     if (epn.path()[0] == '@') {  // replace '@' to '\0' (use of UNIX abstract namespace)
-                        *it = '\0';
+                //         auto it = std::ranges::find(ep, '@');
-                        epn = adc::AdcEndpoint(ep);
+                //         *it = '\0';
-                    }
+                //         epn = adc::AdcEndpoint(ep);
-                }
+                //     }
+                // }
 
-                std::cout << "try to start listenning at '" << ep << "' ...";
+                // std::cout << "try to start listenning at '" << ep << "' ...";
 
                 server.start<adc::AdcStopSeqSessionProto<>>(epn);
 
-                std::cout << "\tOK\n";
+                // std::cout << "\tOK\n";
             } else {
                 std::cerr << "Unrecognized endpoint: '" << ep << "'! Ignore!\n";
             }

tests/adc_dev_test.cpp

@@ -0,0 +1,176 @@
+#include <iostream>
+
+#include "../common/adc_traits.h"
+#include "../device/adc_device.h"
+#include "../device/adc_device_attribute.h"
+#include "../device/adc_device_command.h"
+
+using namespace adc;
+
+typedef std::vector<char> serialized_t;
+
+class DeviceWrapper
+{
+public:
+    // using char_range_t = std::span<const char>;
+    using char_range_t = std::span<char>;
+
+private:
+    serialized_t _id;
+
+    std::function<serialized_t(const serialized_t&)> _get_attr = [](auto) -> serialized_t {
+        throw std::invalid_argument("BAD _get_attr");
+    };
+    std::function<void(const serialized_t&, const serialized_t&)> _set_attr = [](auto, auto) {
+        throw std::invalid_argument("BAD _set_attr");
+    };
+    std::function<void(const serialized_t&)> _exec_cmd = [](auto) { throw std::invalid_argument("BAD _exec_cmd"); };
+
+public:
+    DeviceWrapper() : _id()
+    {
+        // null device
+        std::string_view id{"NULL-DEVICE"};
+        std::ranges::copy(id, std::back_inserter(_id));
+    };
+
+    template <typename DeviceT,
+              typename AttrIdDeserialT = traits::adc_char_identity<typename DeviceT::attr_ident_t>,
+              typename CmdIdDeserialT = traits::adc_char_identity<typename DeviceT::cmd_ident_t>>
+    DeviceWrapper(DeviceT* dev_ptr,
+                  const serialized_t& id,
+                  AttrIdDeserialT&& attr_id_deser_func = {},
+                  CmdIdDeserialT&& cmd_id_deser_func = {})
+        : _id(id)
+    {
+        _get_attr = [dev_ptr, wrapper = traits::adc_pf_wrapper(std::forward<AttrIdDeserialT>(attr_id_deser_func))](
+                        const auto& attr_name) mutable {
+            auto attr_id = std::get<0>(wrapper)(attr_name);
+            auto& attr = (*dev_ptr)[attr_id];
+            // auto& attr = dev_ptr->operator[](attr_id);
+            auto val = attr.serialize();
+            return val;
+        };
+
+        _set_attr = [dev_ptr, wrapper = traits::adc_pf_wrapper(std::forward<AttrIdDeserialT>(attr_id_deser_func))](
+                        const auto& attr_name, const auto& val) mutable {
+            auto attr_id = std::get<0>(wrapper)(attr_name);
+            (*dev_ptr)[attr_id].deserialize(val);
+        };
+
+        _exec_cmd = [dev_ptr, wrapper = traits::adc_pf_wrapper(std::forward<CmdIdDeserialT>(cmd_id_deser_func))](
+                        const auto& cmd_name) mutable {
+            auto cmd_id = std::get<0>(wrapper)(cmd_name);
+            (*dev_ptr)(cmd_id);
+        };
+    }
+
+
+    serialized_t ident() const
+    {
+        // return _get_id();
+        return _id;
+    }
+
+    serialized_t getAttr(const serialized_t& attr_name)
+    {
+        return _get_attr(attr_name);
+    }
+
+    void setAttr(const serialized_t& attr_name, const serialized_t& val)
+    {
+        _set_attr(attr_name, val);
+    }
+
+    void exec(const serialized_t& cmd_name)
+    {
+        _exec_cmd(cmd_name);
+    }
+};
+
+
+static std::vector<DeviceWrapper> devs;
+
+
+auto getAttr(size_t dev_idx, const serialized_t& name)
+{
+    DeviceWrapper& dev = devs[dev_idx];
+
+    return dev.getAttr(name);
+}
+
+int main()
+{
+    typedef AdcGenericDevice<std::string_view, AdcDeviceAttribute<std::string_view, serialized_t>, AdcDeviceCommand<>>
+        dev_t;
+
+    dev_t dev1("DEV1");
+
+    int attr1_val = 10;
+    // dev1.addAttribute(
+    //     "ATTR1",
+    //     [&attr1_val]() {
+    //         std::cout << "ATTR1 getter\n";
+    //         return attr1_val;
+    //     },
+    //     [&attr1_val](const int& v) {
+    //         std::cout << "ATTR1 setter\n";
+    //         attr1_val = v;
+    //     });
+    // dev1.addAttribute(
+    //     "ATTR2",
+    //     [&attr1_val]() {
+    //         std::cout << "ATTR2 getter\n";
+    //         return attr1_val + 10;
+    //     },
+    //     [&attr1_val](const int& v) {
+    //         std::cout << "ATTR2 setter\n";
+    //         attr1_val = v;
+    //     },
+    //     utils::AdcDefaultValueConverter<>::serialize<dev_t::attribute_t::serialized_t, int>);
+    dev1.addAttribute(dev_t::attribute_t::makeArithAttr(
+        "ATTR1",
+        [&attr1_val]() {
+            std::cout << "ATTR1 getter\n";
+            return attr1_val;
+        },
+        [&attr1_val](const int& v) {
+            std::cout << "ATTR1 setter\n";
+            attr1_val = v;
+        }));
+    dev1.addAttribute(dev_t::attribute_t::makeArithAttr(
+        "ATTR2",
+        [&attr1_val]() {
+            std::cout << "ATTR2 getter\n";
+            return (long)attr1_val + 10;
+        },
+        [&attr1_val](const long& v) {
+            std::cout << "ATTR2 setter\n";
+            attr1_val = v;
+        },
+        utils::AdcDefaultValueConverter<>::serialize<dev_t::attribute_t::serialized_t, long>));
+
+    devs.push_back({&dev1, {'D', '1'}});
+
+    serialized_t sn1, sn2;
+    std::ranges::copy(std::string_view("ATTR1"), std::back_inserter(sn1));
+    std::ranges::copy(std::string_view("ATTR2"), std::back_inserter(sn2));
+
+    devs[0].setAttr(sn1, {'7', '7'});
+    auto r = getAttr(0, sn1);
+
+    std::string rs;
+    std::ranges::copy(r, std::back_inserter(rs));
+
+    std::cout << "ATTR1 = " << rs << "\n";
+
+    devs[0].setAttr(sn2, {'7', '7'});
+    r = getAttr(0, sn2);
+
+    rs.clear();
+    std::ranges::copy(r, std::back_inserter(rs));
+
+    std::cout << "ATTR2 = " << rs << "\n";
+
+    return 0;
+}