...

net/adc_netmsg.h

@@ -13,6 +13,15 @@
 namespace adc
 {
 
+namespace traits
+{
+
+template <typename T>
+concept adc_has_clear_c = requires(T t) { t.clear(); };
+
+}  // namespace traits
+
+
 namespace utils
 {
 
@@ -535,9 +544,80 @@ public:
 
 
 
+template <traits::adc_output_char_range R, const char* DELIM = constants::ADC_DEFAULT_TOKEN_DELIMITER>
+class AdcTokenMessage
+{
+public:
+    static constexpr std::span tokenDelimiter{DELIM, sizeof(DELIM) - 1};  // "-1" to remove trailing '\0'
+
+    AdcTokenMessage(R& byte_seq) : _byteSequence(byte_seq) {}
+
+    auto parts(size_t start_idx = 0, size_t N = std::numeric_limits<size_t>::max())
+    {
+        return tokens(start_idx, N);
+    }
+
+    template <typename T, typename... Ts>
+    auto addParts(T&& part, Ts&&... parts)
+    {
+        return addToken(std::forward<T>(part), std::forward<Ts>(parts)...);
+    }
+
+    auto tokens(size_t start_idx = 0, size_t N = std::numeric_limits<size_t>::max())
+    {
+        return std::views::split(_byteSequence, tokenDelimiter) | std::views::drop(start_idx) | std::views::take(N);
+    }
+
+    template <typename TokT, typename... TokTs>
+    AdcTokenMessage& addTokens(TokT&& token, TokTs&&... tokens)
+    {
+        if (std::ranges::size(_byteSequence)) {
+            std::ranges::copy(tokenDelimiter, std::back_inserter(_byteSequence));
+        }
+
+        utils::convertToBytes(_byteSequence, std::forward<TokT>(token));
+
+        if constexpr (sizeof...(TokTs)) {
+            addTokens(std::forward<TokTs>(tokens)...);
+        }
+
+        return *this;
+    }
+
+    template <typename TokT, typename... TokTs>
+    AdcTokenMessage& setTokens(TokT&& token, TokTs&&... tokens)
+    {
+        if (std::ranges::size(_byteSequence)) {
+            if constexpr (traits::adc_has_clear_c<R>) {
+                _byteSequence.clear();
+            } else {
+                _byteSequence = R();
+            }
+        }
+
+        return addTokens(std::forward<TokT>(token), std::forward<TokTs>(tokens)...);
+    }
+
+protected:
+    R& _byteSequence;
+};
+
+
+template <traits::adc_output_char_range R,
+          const char* KEY_TOKEN_DELIM = constants::ADC_DEFAULT_KEY_TOKEN_DELIMITER,
+          const char* TOKEN_DELIM = constants::ADC_DEFAULT_TOKEN_DELIMITER>
+class AdcKeyValueMessage
+{
+public:
+    AdcKeyValueMessage(R& byte_seq) : _byteSequence(byte_seq) {}
+
+protected:
+    R& _byteSequence;
+};
+
+
 namespace traits
 {
-
 template <typename T>
 concept adc_netmessage_c = requires {
     typename T::byte_storage_t;

net/asio/adc_netservice_asio.h

@@ -303,24 +303,24 @@ public:
 
     AdcNetServiceASIOBase& operator=(const AdcNetServiceASIOBase&) = delete;
 
-    AdcNetServiceASIOBase& operator=(AdcNetServiceASIOBase&& other)
-    {
-        if (this != &other) {
-            close();
-            _streamBuffer.consume(_streamBuffer.size());
+    AdcNetServiceASIOBase& operator=(AdcNetServiceASIOBase&& other) = delete;
+    // {
+    //     if (this != &other) {
+    //         close();
+    //         _streamBuffer.consume(_streamBuffer.size());
 
-            auto bytes =
-                asio::buffer_copy(_streamBuffer.prepare(other._streamBuffer.size()), other._streamBuffer.data());
-            _streamBuffer.commit(bytes);
+    //         auto bytes =
+    //             asio::buffer_copy(_streamBuffer.prepare(other._streamBuffer.size()), other._streamBuffer.data());
+    //         _streamBuffer.commit(bytes);
 
-            _ioContext = other._ioContext;
-            _receiveStrand = std::move(other._receiveStrand), _socket = std::move(other._socket);
+    //         _ioContext = other._ioContext;
+    //         _receiveStrand = std::move(other._receiveStrand), _socket = std::move(other._socket);
 
-            _receiveQueue = other._receiveQueue;
-        }
+    //         _receiveQueue = other._receiveQueue;
+    //     }
 
-        return *this;
-    }
+    //     return *this;
+    // }
 
 
     constexpr netservice_ident_t ident() const