....

net/adc_netmsg.h

@@ -8,6 +8,7 @@
 
 
 #include "../common/adc_traits.h"
+#include "../common/adc_utils.h"
 
 namespace adc
 {
@@ -15,6 +16,9 @@ namespace adc
 template <traits::adc_output_char_range ByteStorageT = std::string, traits::adc_char_view ByteViewT = std::string_view>
 class AdcGenericNetMessage
 {
+    virtual bool empty() const { return std::ranges::distance(_bytes.begin(), _bytes.end()) == 0; }
+
+
     // get a copy of message bytes
     template <traits::adc_output_char_range R>
     R bytes() const
@@ -29,13 +33,19 @@ class AdcGenericNetMessage
     virtual ByteStorageT bytes() const { return bytes<ByteStorageT>(); }
 
     // get a view of message bytes
-    template <traits::adc_char_view R>
+    // template <std::ranges::range R>
+    //     requires std::ranges::view<std::ranges::range_value_t<R>>
+    template<traits::adc_range_of_view_char_range R>
     R bytesView() const
     {
-        return R{_bytes.begin(), _bytes.end()};
+        R r;
+
+        r.emplace_back(_bytes.begin(), _bytes.end());
+
+        return r;
     }
 
-    virtual ByteViewT bytesView() const { return bytesView<ByteViewT>(); }
+    virtual std::vector<ByteViewT>  bytesView() const { return bytesView<std::vector<ByteViewT>>(); }
 
 protected:
     ByteStorageT _bytes;
@@ -47,8 +57,7 @@ namespace constants
 {
 
 static constexpr char ADC_DEFAULT_TOKEN_DELIMITER[] = " ";
-static constexpr char ADC_DEFAULT_KEY_PARAM_DELIMITER[] = " ";
-static constexpr char ADC_DEFAULT_PARAM_PARAM_DELIMITER[] = " ";
+static constexpr char ADC_DEFAULT_KEY_TOKEN_DELIMITER[] = " ";
 
 }  // namespace constants
 
@@ -63,6 +72,9 @@ class AdcTokenNetMessage : public AdcGenericNetMessage<ByteStorageT, ByteViewT>
 public:
     static constexpr std::string_view tokenDelimiter{TOKEN_DELIM};
 
+
+    virtual bool empty() const { return _tokens.empty(); }
+
     template <traits::adc_output_char_range R>
     R bytes() const
     {
@@ -73,37 +85,166 @@ public:
         }
 
 
-        std::ranges::for_each(_tokens | std::views::take(_tokens.size()), [&r](const auto& el) {
-            std::ranges::copy(el, std::back_inserter(r));
-            std::ranges::copy(tokenDelimiter, std::back_inserter(r));
-        });
+        // std::ranges::for_each(_tokens | std::views::take(_tokens.size()-1), [&r](const auto& el) {
+        //     std::ranges::copy(el, std::back_inserter(r));
+        //     std::ranges::copy(tokenDelimiter, std::back_inserter(r));
+        // });
 
-        std::ranges::copy(_tokens.back(), std::back_inserter(r));
+        // std::ranges::copy(_tokens.back(), std::back_inserter(r));
+
+        utils::AdcJoinRange(_tokens, tokenDelimiter, r);
 
         return r;
     }
 
 
-    template <std::ranges::range R>
-        requires std::ranges::view<std::ranges::range_value_t<R>>
+    // template <std::ranges::range R>
+    //     requires std::ranges::view<std::ranges::range_value_t<R>>
+    template<traits::adc_range_of_view_char_range R>
     R bytesView() const
     {
         R r;
 
-        std::ranges::for_each(_tokens | std::views::take(_tokens.size()), [&r](const auto& el) {
-            std::ranges::range_value_t<R> v{el.begin(), el.end()};
-            std::back_inserter(r) = {el.begin(), el.end()};
-            std::back_inserter(r) = {tokenDelimiter.begin(), tokenDelimiter.end()};
-        });
+        if (_tokens.empty()) {
+            return r;
+        }
 
-        std::back_inserter(r) = {_tokens.back().begin(), _tokens.back().end()};
+        // std::ranges::for_each(_tokens | std::views::take(_tokens.size()-1), [&r](const auto& el) {
+        //     // std::ranges::range_value_t<R> v{el.begin(), el.end()};
+        //     std::back_inserter(r) = {el.begin(), el.end()};
+        //     std::back_inserter(r) = {tokenDelimiter.begin(), tokenDelimiter.end()};
+        // });
+
+        // std::back_inserter(r) = {_tokens.back().begin(), _tokens.back().end()};
+
+        utils::AdcReturnRangeElementsView(_tokens, tokenDelimiter, r);
 
         return r;
     }
 
+
+    template<std::ranges::output_range<ByteStorageT> R>
+    R tokens() const
+    {
+        R r;
+
+        if (_tokens.empty()) {
+            return r;
+        }
+
+        std::ranges::copy(_tokens, std::back_inserter(r));
+
+        return r;
+    }
+
+    std::vector<ByteStorageT> tokens() const
+    {
+        //
+        return tokens<std::vector<ByteStorageT>>();
+    }
+
 protected:
     std::vector<ByteStorageT> _tokens;
 };
 
 
+// special type of tokenized message:
+//    the first token is keyword
+//    the other - just tokens
+// delimiter between keyword and other tokens may differ from token-to-token one
+template<const char *KEY_TOKEN_DELIM = constants::ADC_DEFAULT_KEY_TOKEN_DELIMITER,
+         const char *TOKEN_DELIM = constants::ADC_DEFAULT_TOKEN_DELIMITER,
+         traits::adc_output_char_range ByteStorageT = std::string,
+         traits::adc_char_view ByteViewT = std::string_view>
+class AdcKeyTokenNetMessage : public AdcTokenNetMessage<TOKEN_DELIM, ByteStorageT, ByteViewT>
+{
+    using base_t = AdcTokenNetMessage<TOKEN_DELIM, ByteStorageT, ByteViewT>;
+
+public:
+    static constexpr std::string_view keytokenDelim{KEY_TOKEN_DELIM};
+
+    using base_t::tokens;
+
+    virtual bool empty() const
+    {
+        auto N = std::distance(this->_bytes.begin(), this->_bytes.end());
+
+        return (N == 0) && this->_tokens.empty();
+    }
+
+    template<traits::adc_output_char_range R>
+    R keyBytes() const
+    {
+        R r;
+
+        std::ranges::copy(this->_bytes, r);
+
+        return r;
+    }
+
+
+    ByteStorageT keyBytes() const
+    {
+        //
+        return this->_bytes;
+    }
+
+
+    template<traits::adc_char_view R>
+    R keyView() const
+    {
+        //
+        return R{this->_bytes.begin(), this->_bytes.end()};
+    }
+
+
+    ByteViewT keyView() const {
+        //
+        return ByteViewT{this->_bytes.begin(), this->_bytes.end()};
+    }
+
+
+    template<traits::adc_output_char_range R>
+    R bytes() const
+    {
+        R r;
+
+        if (this->_bytes.empty() && this->_tokens.empty()) {
+            return r;
+        }
+
+        std::ranges::copy(this->_bytes, std::back_inserter(r)); // keyword
+
+        if (!this->_tokens.empty()) {
+            std::ranges::copy(keytokenDelim, std::back_inserter(r)); // keyword-to-tokens delimiter
+            utils::AdcJoinRange(this->_tokens, base_t::tokenDelimiter, r);
+        }
+
+        return r;
+    }
+
+    template<traits::adc_range_of_view_char_range R>
+    R bytesView() const
+    {
+        R r;
+
+        if (this->_bytes.empty() && this->_tokens.empty()) {
+            return r;
+        }
+
+        std::back_inserter(r) = {this->_bytes.begin(), this->_bytes.end()}; // keyword
+
+        if (!this->_tokens.empty()) {
+            std::back_inserter(r) = {keytokenDelim.begin(), keytokenDelim.end()}; // keyword-to-tokens delimiter
+            utils::AdcReturnRangeElementsView(this->_tokens, base_t::tokenDelimiter, r);
+        }
+
+        return r;
+    }
+
+protected:
+    // _bytes: keyword
+    // _tokens: tokens
+};
+
 }  // namespace adc