net/adc_netproto.h: add AdcStartStopSeqSessionProto class

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

CMakeLists.txt

@@ -167,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)

common/adc_spdlog.h

@@ -83,6 +83,12 @@ public:
         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)
     {
@@ -133,7 +139,7 @@ protected:
 
         ptrn += " [";
         std::ranges::copy(mark, std::back_inserter(ptrn));
-        ptrn += "] ";
+        ptrn += "]";
 
         std::ranges::copy(_currentLogPattern | std::views::drop(pos), std::back_inserter(ptrn));
 

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_netserver.h

@@ -155,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);
@@ -344,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));
                         }
@@ -356,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));
                     }
@@ -372,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));
@@ -385,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));
                     }

net/adc_endpoint.h

@@ -304,6 +304,36 @@ 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, _portView;

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/asio/adc_device_netserver_asio.h

@@ -196,6 +196,13 @@ public:
                        _sessionSendTimeout.count());
     }
 
+    void daemonize()
+    {
+        this->logInfo("Daemonize server process (server addr: {})", (void*)this);
+
+        base_t::daemonize();
+    }
+
 protected:
     asio::io_context& _ioContext;
 
@@ -204,13 +211,6 @@ protected:
     std::chrono::milliseconds _sessionRecvTimeout = std::chrono::hours(12);
     std::chrono::milliseconds _sessionSendTimeout = std::chrono::seconds(5);
 
-    void daemonize()
-    {
-        this->logInfo("Daemonize server process (server addr: {})", (void*)this);
-
-        base_t::daemonize();
-    }
-
     // demonizing ASIO-related methods
     virtual void daemonizePrepare()
     {

net/asio/adc_netservice_asio.h

@@ -159,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
 
 
@@ -830,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;

tests/adc_asio_netserver_test.cpp

@@ -162,13 +162,14 @@ 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 << "' ...";
 

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;
+}