...

net/adc_device_netmsg.h

@@ -174,18 +174,26 @@ public:
         }
     }
 
-    template <typename KeyT, typename... ValuePartTs>
+    template <typename KeyT>
         requires traits::adc_output_char_range<ByteSeqT>
-    AdcKeyValueMessage& setKeyValue(KeyT&& key, ValuePartTs&&... values)
+    AdcKeyValueMessage& setKey(const KeyT& key)
     {
         if (std::ranges::size(_byteSequence)) {
             _byteSequence = ByteSeqT();
         }
 
-        std::ranges::copy(utils::AdcDefaultValueConverter<COMPOSITE_VALUE_DELIM>::template serialize<ByteSeqT>(
-                              std::forward<KeyT>(key)),
+        std::ranges::copy(utils::AdcDefaultValueConverter<COMPOSITE_VALUE_DELIM>::template serialize<ByteSeqT>(key),
                           std::back_inserter(_byteSequence));
 
+        return *this;
+    }
+
+    template <typename KeyT, typename... ValuePartTs>
+        requires traits::adc_output_char_range<ByteSeqT>
+    AdcKeyValueMessage& setKeyValue(const KeyT& key, ValuePartTs&&... values)
+    {
+        setKey(key);
+
         if constexpr (sizeof...(ValuePartTs)) {
             std::ranges::copy(keyValueDelimiter, std::back_inserter(_byteSequence));
             setValueHelper(std::forward<ValuePartTs>(values)...);
@@ -194,6 +202,36 @@ public:
         return *this;
     }
 
+
+    template <typename KeyT, std::ranges::input_range ValuePartRangeT>
+        requires traits::adc_output_char_range<ByteSeqT>
+    AdcKeyValueMessage& setKeyValue(const KeyT& key, const ValuePartRangeT& values)
+    {
+        setKey(key);
+
+        for (auto const& el : values) {
+            std::ranges::copy(keyValueDelimiter, std::back_inserter(_byteSequence));
+            setValueHelper(el);
+        }
+
+        return *this;
+    }
+
+
+    template <typename KeyT, traits::adc_tuple_like ValuePartTupleT>
+        requires traits::adc_output_char_range<ByteSeqT>
+    AdcKeyValueMessage& setKeyValue(const KeyT& key, const ValuePartTupleT& values)
+    {
+        setKey(key);
+
+        if constexpr (std::tuple_size_v<ValuePartTupleT>) {
+            std::apply([this]<typename... Ts>(Ts&&... args) { setValueHelper(std::forward<Ts>(args)...); }, values);
+        }
+
+        return *this;
+    }
+
+
     template <typename... ValuePartTs>
         requires traits::adc_output_char_range<ByteSeqT>
     AdcKeyValueMessage& setValue(ValuePartTs&&... values)
@@ -201,9 +239,32 @@ public:
         std::vector<char> kw;
         std::ranges::copy(key<std::span<const char>>(), std::back_inserter(kw));
 
-        return setValue(kw, std::forward<ValuePartTs>(values)...);
+        return setKeyValue(kw, std::forward<ValuePartTs>(values)...);
     }
 
+
+    template <typename KeyT, std::ranges::input_range ValuePartRangeT>
+        requires traits::adc_output_char_range<ByteSeqT> &&
+                 (!traits::adc_input_char_range<std::ranges::range_value_t<ValuePartRangeT>>)
+    AdcKeyValueMessage& setValue(const ValuePartRangeT& values)
+    {
+        std::vector<char> kw;
+        std::ranges::copy(key<std::span<const char>>(), std::back_inserter(kw));
+
+        return setKeyValue(kw, values);
+    }
+
+    template <typename KeyT, traits::adc_tuple_like ValuePartTupleT>
+        requires traits::adc_output_char_range<ByteSeqT>
+    AdcKeyValueMessage& setValue(const ValuePartTupleT& values)
+    {
+        std::vector<char> kw;
+        std::ranges::copy(key<std::span<const char>>(), std::back_inserter(kw));
+
+        return setKeyValue(kw, values);
+    }
+
+
 protected:
     ByteSeqT& _byteSequence;
 
@@ -374,11 +435,40 @@ public:
 
     void ack()
     {
-        base_t::setKeyValue(ACK_KEY);
+        base_t::setKey(ACK_KEY);
 
         keyHash();
     }
 
+
+    template <typename ParT, typename... ParTs>
+    void ack(const ParT& param, const ParTs&... params)
+    {
+        base_t::setKeyValue(ACK_KEY, param, params...);
+
+        keyHash();
+    }
+
+
+    template <std::ranges::range ParT>
+        requires(!traits::adc_input_char_range<std::ranges::range_value_t<ParT>>)
+    void ack(const ParT& param)
+    {
+        base_t::setKeyValue(ACK_KEY, param);
+
+        keyHash();
+    }
+
+
+    template <traits::adc_tuple_like ParT>
+    void ack(const ParT& param)
+    {
+        base_t::setKeyValue(ACK_KEY, param);
+
+        keyHash();
+    }
+
+
     template <traits::adc_input_char_range AttrNameT, typename ValueT, typename... ValueTs>
     void set(AttrNameT&& attr_name, ValueT&& value, ValueTs&&... values)
     {
@@ -429,7 +519,32 @@ public:
 
     void names()
     {
-        base_t::setKeyValue(NAMES_KEY);
+        base_t::setKey(NAMES_KEY);
+
+        keyHash();
+    }
+
+    template <typename DevNameT, typename... DevNameTs>
+    void names(const DevNameT& dev_name, const DevNameTs&... dev_names)
+    {
+        base_t::setKeyValue(NAMES_KEY, dev_name, dev_names...);
+
+        keyHash();
+    }
+
+    template <std::ranges::input_range R>
+        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);
+
+        keyHash();
+    }
+
+    template <traits::adc_tuple_like T>
+    void names(const T& dev_names)
+    {
+        base_t::setKeyValue(NAMES_KEY, dev_names);
 
         keyHash();
     }