...

asibfm700/CMakeLists.txt

@@ -40,6 +40,7 @@ set(ASIBFM700_LIB asibfm700mount)
 add_library(${ASIBFM700_LIB} STATIC ${ASIBFM700_LIB_SRC}
     asibfm700_mount.h asibfm700_mount.cpp
     asibfm700_configfile.h)
+target_include_directories(${ASIBFM700_LIB} PRIVATE mcc spdlog)
 target_link_libraries(${ASIBFM700_LIB} PRIVATE mcc spdlog)
 
 option(WITH_TESTS "Build tests" ON)

mcc/CMakeLists.txt

@@ -92,5 +92,9 @@ if (WITH_TESTS)
      target_include_directories(${CTTE_TEST_APP} PRIVATE ${ERFA_INCLUDE_DIR})
      target_link_libraries(${CTTE_TEST_APP} ERFA_LIB bsplines)
 
+     set(NETMSG_TESTS_APP netmsg_test)
+     add_executable(${NETMSG_TESTS_APP} tests/netmsg_test.cpp)
+     target_link_libraries(${NETMSG_TESTS_APP} mcc)
+
      enable_testing()
 endif()

mcc/mcc_netserver_proto.h

@@ -471,124 +471,392 @@ struct MccNetMessageValidKeywords {
         return std::array{mcc::utils::FNV1aHash(NETMSG_VALID_KEYWORDS[Is])...};
     }(std::make_index_sequence<NETMSG_VALID_KEYWORDS.size()>());
 
-    static std::expected<size_t, std::error_code> isKeywordValid(std::string_view key)
+    constexpr static const size_t* isKeywordValid(std::string_view key)
     {
         const auto hash = utils::FNV1aHash(key);
 
         for (auto const& h : NETMSG_VALID_KEYWORD_HASHES) {
             if (h == hash) {
-                return h;
+                return &h;
             }
         }
 
-        return std::unexpected(std::make_error_code(std::errc::invalid_argument));
+        return nullptr;
     }
 };
 
 static_assert(mcc_netmsg_valid_keys_c<MccNetMessageValidKeywords>, "");
 
 
-template <mcc_netmsg_valid_keys_c BASE_T, traits::mcc_output_char_range BYTEREPR_T>
+template <mcc_netmsg_valid_keys_c BASE_T, traits::mcc_char_range BYTEREPR_T>
 class MccNetMessage
 {
+    static inline utils::MccSimpleDeserializer defaultDeserilizer{MCC_COMMPROTO_RANGEPARAM_DELIM_SEQ};
+
 public:
     typedef BASE_T valid_keys_t;
     typedef BYTEREPR_T byte_repr_t;
 
+    enum MccNetMessageError { ERROR_OK, ERROR_EMPTY_MESSAGE, ERROR_INVALID_KEYWORD, ERROR_EMPTY_KEYWORD };
+
+    MccNetMessage() = default;
+
     template <traits::mcc_input_char_range KT, typename... PTs>
     MccNetMessage(KT&& key, PTs&&... params)
+        requires traits::mcc_output_char_range<BYTEREPR_T>
     {
         construct(std::forward<KT>(key), std::forward<PTs>(params)...);
     }
 
-    template <traits::mcc_input_char_range KT>
+    template <traits::mcc_input_char_range R>
-    bool withKey(const KT& key)
+    constexpr MccNetMessage(const R& msg)
+        requires traits::mcc_input_char_range<BYTEREPR_T>
     {
+        fromCharRange(msg);
+    }
+
+    template <traits::mcc_input_char_range KT>
+    constexpr bool withKey(const KT& key)
+    {
+        if constexpr (std::is_pointer_v<std::decay_t<KT>>) {
+            return withKey(std::string_view{key});
+        }
+
         return utils::FNV1aHash(key) == _keywordHash;
     }
 
-    template <typename T, typename DeserFuncT>
+
-    std::expected<T, std::error_code> params(DeserFuncT&& deser_func)
+    template <traits::mcc_view_or_output_char_range R>
+    R keyword() const
     {
+        if constexpr (traits::mcc_char_view<R>) {
+            return R{_keyword.begin(), _keyword.end()};
+        } else {
+            R r;
+            std::ranges::copy(_keyword, std::back_inserter(r));
+
+            return r;
+        }
+    }
+
+    std::string_view keyword() const
+    {
+        return _keyword;
+    }
+
+    // template <traits::mcc_view_or_output_char_range R>
+    // R params(size_t start_idx, size_t Nelemes = std::numeric_limits<size_t>::max())
+    // {
+    //     if (start_idx >= _params.size()) {
+    //         return R{};
+    //     }
+
+    //     auto stop_idx = start_idx + Nelemes - 1;
+    //     if (stop_idx >= _params.size()) {
+    //         stop_idx = _params.size() - 1;
+    //     }
+
+    //     if constexpr (traits::mcc_char_view<R>) {
+    //         return R{_params[start_idx].begin(), _params[stop_idx].end()};
+    //     } else {
+    //         R r;
+    //         std::ranges::copy(std::string_view{_params[start_idx].begin(), _params[stop_idx].end()},
+    //                           std::back_inserter(r));
+
+    //         return r;
+    //     }
+    // }
+
+    template <std::ranges::range R>
+    R params(size_t start_idx, size_t Nelemes = std::numeric_limits<size_t>::max())
+        requires(traits::mcc_view_or_output_char_range<R> || traits::mcc_range_of_char_range<R>)
+    {
+        if (start_idx >= _params.size()) {
+            return R{};
+        }
+
+        auto stop_idx = start_idx + Nelemes - 1;
+        if (stop_idx >= _params.size()) {
+            stop_idx = _params.size() - 1;
+        }
+
+        if constexpr (traits::mcc_range_of_char_range<R>) {  // returm parameters as array
+            using el_t = std::ranges::range_value_t<R>;
+
+            R r;
+            if constexpr (traits::mcc_char_view<el_t> || traits::mcc_output_char_range<el_t>) {
+                for (size_t i = start_idx; i <= stop_idx; ++i) {
+                    auto& el = _params[i];
+                    std::back_inserter(r) = el_t{el.begin(), el.end()};
+                }
+            } else {
+                static_assert(false, "UNSUPPORTED RANGE ELEMENT TYPE!!!");
+            }
+
+            return r;
+        } else {
+            if constexpr (traits::mcc_char_view<R>) {  // return joined parameters as a single char-range
+                return R{_params[start_idx].begin(), _params[stop_idx].end()};
+            } else {
+                R r;
+                std::ranges::copy(std::string_view{_params[start_idx].begin(), _params[stop_idx].end()},
+                                  std::back_inserter(r));
+
+                return r;
+            }
+        }
+    }
+
+    std::string_view params(size_t start_idx, size_t Nelemes = std::numeric_limits<size_t>::max())
+    {
+        return params<std::string_view>(start_idx, Nelemes);
+    }
+
+    template <traits::mcc_view_or_output_char_range R>
+    R param(size_t idx)
+    {
+        if (idx >= _params.size()) {
+            return {};
+        }
+
+        if constexpr (traits::mcc_char_view<R>) {
+            return R{_params[idx].begin(), _params[idx].end()};
+        } else {
+            R r;
+            std::ranges::copy(_params[idx], std::back_inserter(r));
+
+            return r;
+        }
+    }
+
+    std::string_view param(size_t idx)
+    {
+        if (idx >= _params.size()) {
+            return {};
+        }
+
+        return _params[idx];
+    }
+
+
+    template <typename T, typename DeserFuncT>
+    std::expected<T, std::error_code> paramValue(size_t idx, DeserFuncT&& deser_func)
+    {
+        if (idx >= _params.size()) {
+            return std::unexpected{std::make_error_code(std::errc::argument_out_of_domain)};
+        }
+
         T val;
 
-        auto ec = deser_func(_params, val);
+        auto ec = std::forward<DeserFuncT>(deser_func)(_params[idx], val);
         if (ec) {
-            return std::unexpect(ec);
+            return std::unexpected(ec);
         } else {
             return val;
         }
     }
 
     template <typename T>
-    std::expected<T, std::error_code> params()
+    std::expected<T, std::error_code> paramValue(size_t idx)
     {
-        return params<T>(utils::MccSimpleDeserializer{}.setRangeDelim(MCC_COMMPROTO_RANGEPARAM_DELIM_SEQ));
+        return paramValue<T>(idx, defaultDeserilizer);
+    }
+
+
+    template <traits::mcc_view_or_output_char_range R>
+    R byteRepr() const
+    {
+        if constexpr (traits::mcc_char_view<R>) {
+            return R{_msgBuffer.begin(), _msgBuffer.end()};
+        } else {
+            R r;
+            std::ranges::copy(_msgBuffer, std::back_inserter(r));
+
+            return r;
+        }
+    }
+
+    std::string_view byteRepr() const
+    {
+        return byteRepr<std::string_view>();
     }
 
     template <traits::mcc_input_char_range KT, typename... PTs>
     std::error_code construct(KT&& key, PTs&&... params)
+        requires traits::mcc_output_char_range<BYTEREPR_T>
     {
+        if constexpr (std::is_pointer_v<std::decay_t<KT>>) {
+            return construct(std::string_view(key), std::forward<PTs>(params)...);
+        }
+
+
         if (!std::ranges::size(key)) {
             return std::make_error_code(std::errc::invalid_argument);
         }
 
         auto r = valid_keys_t::isKeywordValid(key);
         if (!r) {
-            return r.error();
+            return std::make_error_code(std::errc::argument_out_of_domain);
         }
 
-        _keywordHash = r.value();
+        _keywordHash = *r;
 
         _msgBuffer = BYTEREPR_T{};
 
-        std::ranges::copy(key, std::back_inserter(_msgBuffer));
+        std::ranges::copy(std::forward<KT>(key), std::back_inserter(_msgBuffer));
-        _keyword = {_msgBuffer.begin(), _msgBuffer.end()};
+        // _keyword = {_msgBuffer.begin(), _msgBuffer.end()};
+        size_t key_idx = std::distance(_msgBuffer.begin(), _msgBuffer.end());
+        std::vector<size_t> par_idx;
 
-        _params = std::string_view{};
+        _params.clear();
 
         if constexpr (sizeof...(PTs)) {
             std::ranges::copy(MCC_COMMPROTO_KEYPARAM_DELIM_SEQ, std::back_inserter(_msgBuffer));
 
-            [this]<typename T, typename... Ts>(this auto&& self, const T& par, const Ts&... pars) {
+            convertFunc(par_idx, std::forward<PTs>(params)...);
-                if constexpr (std::is_arithmetic_v<T>) {
-                    std::ranges::copy(std::to_string(par), std::back_inserter(_msgBuffer));
-                } else if constexpr (std::convertible_to<T, std::string>) {
-                    std::ranges::copy(static_cast<std::string>(par), std::back_inserter(_msgBuffer));
-                } else if constexpr (std::constructible_from<std::string, T>) {
-                    std::ranges::copy(std::string(par), std::back_inserter(_msgBuffer));
-                } else if constexpr (traits::mcc_char_range<T>) {
-                    std::ranges::copy(std::string(par.begin(), par.end()), std::back_inserter(_msgBuffer));
-                } else if constexpr (std::same_as<T, MccCoordPairKind>) {
-                    std::ranges::copy(mcc_pairkind2str(par), std::back_inserter(_msgBuffer));
-                } else if constexpr (traits::mcc_time_duration_c<T>) {
-                    std::forward<decltype(self)>(self)(par.count());
-                } else {
-                    static_assert(false, "UNSUPPORTED TYPE!!!");
-                }
 
-                if constexpr (sizeof...(Ts)) {
+            for (size_t i = 0; i < par_idx.size(); i += 2) {
-                    std::ranges::copy(MCC_COMMPROTO_PARAMPARAM_DELIM_SEQ, std::back_inserter(_msgBuffer));
+                _params.emplace_back(_msgBuffer.begin() + par_idx[i], _msgBuffer.begin() + par_idx[i + 1]);
-
+            }
-                    std::forward<decltype(self)>(self)(pars...);
-                }
-            }(std::forward<PTs>(params)...);
-
-            _params = {_msgBuffer.begin() + _keyword.size() + MCC_COMMPROTO_KEYPARAM_DELIM_SEQ.size(),
-                       _msgBuffer.end()};
         }
 
+        _keyword = std::string_view{_msgBuffer.begin(), _msgBuffer.begin() + key_idx};
+
         return {};
     }
 
+
+    template <traits::mcc_input_char_range R>
+    constexpr MccNetMessageError fromCharRange(const R& r)
+    {
+        if constexpr (std::is_pointer_v<std::decay_t<R>>) {
+            return fromCharRange(std::string_view(r));
+        }
+
+
+        if (std::ranges::size(r) == 0) {
+            return ERROR_EMPTY_MESSAGE;
+        }
+
+        std::string_view key, val;
+
+        auto prev_msg_buff = _msgBuffer;
+
+        if constexpr (traits::mcc_output_char_range<BYTEREPR_T>) {
+            _msgBuffer = BYTEREPR_T{};
+            std::ranges::copy(r, std::back_inserter(_msgBuffer));
+        } else {
+            _msgBuffer = {std::begin(r), std::end(r)};
+        }
+
+        auto found = std::ranges::search(_msgBuffer, MCC_COMMPROTO_KEYPARAM_DELIM_SEQ);
+
+        if (found.empty()) {  // only keyword
+            key = utils::trimSpaces(std::string_view{_msgBuffer.begin(), _msgBuffer.end()});
+        } else {
+            key = utils::trimSpaces(std::string_view{_msgBuffer.begin(), found.begin()});
+        }
+
+        auto kv = valid_keys_t::isKeywordValid(key);
+        if (!kv) {
+            // _msgBuffer = prev_msg_buff;  // restore previous netmessage state
+            return ERROR_INVALID_KEYWORD;
+        }
+
+        _keywordHash = *kv;
+        _keyword = key;
+
+        if (!found.empty()) {  // params ...
+            _params.clear();
+            auto pr =
+                std::views::split(std::string_view{found.end(), _msgBuffer.end()}, MCC_COMMPROTO_PARAMPARAM_DELIM_SEQ);
+            for (auto const& p : pr) {
+                _params.emplace_back(p.begin(), p.end());
+            }
+        }
+
+        return ERROR_OK;
+    }
+
 protected:
     size_t _keywordHash{};
     std::string_view _keyword{};
-    std::string_view _params{};
+    std::vector<std::string_view> _params{};
 
     BYTEREPR_T _msgBuffer{};
+
+    template <typename T, typename... Ts>
+    void convertFunc(std::vector<size_t>& idx, const T& par, const Ts&... pars)
+    {
+        idx.emplace_back(std::distance(_msgBuffer.begin(), _msgBuffer.end()));
+
+        // if constexpr (std::is_arithmetic_v<T>) {
+        //     std::format_to(std::back_inserter(_msgBuffer), "{}", par);
+        // } else if constexpr (std::convertible_to<T, std::string>) {
+        //     std::ranges::copy(static_cast<std::string>(par), std::back_inserter(_msgBuffer));
+        // } else if constexpr (std::constructible_from<std::string, T>) {
+        //     std::ranges::copy(std::string(par), std::back_inserter(_msgBuffer));
+        // } else if constexpr (traits::mcc_char_range<T>) {
+        //     std::ranges::copy(std::string(par.begin(), par.end()), std::back_inserter(_msgBuffer));
+        // } else if constexpr (std::same_as<T, MccCoordPairKind>) {
+        //     std::ranges::copy(mcc_pairkind2str(par), std::back_inserter(_msgBuffer));
+        // } else if constexpr (traits::mcc_time_duration_c<T>) {
+        //     idx.resize(idx.size() - 1);
+        //     convertFunc(idx, par.count());
+        //     idx.resize(idx.size() - 1);
+        // } else if constexpr (std::formattable<T, char>) {
+        //     std::format_to(std::back_inserter(_msgBuffer), "{}", par);
+        // } else {
+        //     static_assert(false, "UNSUPPORTED TYPE!!!");
+        // }
+
+        // use the lambda here to enable recursive calling with no special handling of 'idx'
+        [](this auto const& self, auto& buff, auto const& p) {
+            using p_t = std::decay_t<decltype(p)>;
+
+            if constexpr (std::is_arithmetic_v<p_t>) {
+                std::format_to(std::back_inserter(buff), "{}", p);
+            } else if constexpr (std::convertible_to<p_t, std::string>) {
+                std::ranges::copy(static_cast<std::string>(p), std::back_inserter(buff));
+            } else if constexpr (std::constructible_from<std::string, p_t>) {
+                std::ranges::copy(std::string(p), std::back_inserter(buff));
+            } else if constexpr (traits::mcc_char_range<p_t>) {
+                std::ranges::copy(std::string(p.begin(), p.end()), std::back_inserter(buff));
+            } else if constexpr (std::same_as<p_t, MccCoordPairKind>) {
+                std::ranges::copy(mcc_pairkind2str(p), std::back_inserter(buff));
+            } else if constexpr (traits::mcc_time_duration_c<p_t>) {
+                self(buff, p.count());
+            } else if constexpr (std::ranges::range<p_t>) {
+                auto sz = std::ranges::size(p);
+                if (sz == 0) {
+                    return;
+                }
+
+                self(buff, *p.begin());  // the first element
+
+                if (sz > 1) {
+                    for (auto const& el : p | std::views::drop(1)) {
+                        std::ranges::copy(MCC_COMMPROTO_RANGEPARAM_DELIM_SEQ, std::back_inserter(buff));
+                        self(buff, el);
+                    }
+                }
+            } else if constexpr (std::formattable<p_t, char>) {
+                std::format_to(std::back_inserter(buff), "{}", p);
+            } else {
+                static_assert(false, "UNSUPPORTED TYPE!!!");
+            }
+        }(_msgBuffer, par);
+
+        idx.emplace_back(std::distance(_msgBuffer.begin(), _msgBuffer.end()));
+
+        if constexpr (sizeof...(Ts)) {
+            std::ranges::copy(MCC_COMMPROTO_PARAMPARAM_DELIM_SEQ, std::back_inserter(_msgBuffer));
+
+            convertFunc(idx, pars...);
+        }
+    };
 };
 
-
+static_assert(MccNetMessage<MccNetMessageValidKeywords, std::string_view>{"ACK"}.withKey("ACK"));
 
 }  // namespace mcc::network

mcc/mcc_utils.h

@@ -16,7 +16,7 @@ namespace mcc::utils
 static const std::regex decimalNumberRx{" *[-+]?([0-9]*[.])?[0-9]+([eE][-+]?[0-9]+)? *"};
 static const std::regex sexagesimalReprRx{" *[-+]?[0-9]{1,2}:[0-9]{1,2}:([0-9]{0,2}[.])?[0-9]+ *"};
 
-static bool isEqual(std::floating_point auto const& v1, std::floating_point auto const& v2)
+constexpr static bool isEqual(std::floating_point auto const& v1, std::floating_point auto const& v2)
 {
     constexpr auto eps = std::numeric_limits<std::common_type_t<decltype(v1), decltype(v2)>>::epsilon();
 
@@ -26,7 +26,7 @@ static bool isEqual(std::floating_point auto const& v1, std::floating_point auto
 enum class TrimType { TRIM_LEFT, TRIM_RIGHT, TRIM_BOTH };
 
 template <std::ranges::contiguous_range R>
-static std::string_view trimSpaces(R&& r, TrimType type = TrimType::TRIM_BOTH)
+constexpr static std::string_view trimSpaces(R&& r, TrimType type = TrimType::TRIM_BOTH)
     requires std::same_as<char, std::remove_cvref_t<std::ranges::range_value_t<R>>>
 {
     auto is_space = [](const auto& ch) { return ch == ' '; };
@@ -59,7 +59,7 @@ static std::string_view trimSpaces(R&& r, TrimType type = TrimType::TRIM_BOTH)
     return std::string_view(f1, f2);
 }
 
-static std::string_view trimSpaces(const char* r, TrimType type = TrimType::TRIM_BOTH)
+constexpr static std::string_view trimSpaces(const char* r, TrimType type = TrimType::TRIM_BOTH)
 {
     return trimSpaces(std::string_view(r), type);
 }
@@ -404,7 +404,15 @@ static constexpr size_t FNV1aHash(std::forward_iterator auto begin, std::sentine
 class MccSimpleDeserializer
 {
 public:
-    static constexpr std::string RANGE_DELIM_SEQ = ",";
+    static constexpr std::string_view RANGE_DELIM_SEQ = ",";
+
+    MccSimpleDeserializer() : _rangeDelim(RANGE_DELIM_SEQ) {}
+
+    template <traits::mcc_input_char_range R>
+    MccSimpleDeserializer(R&& r) : MccSimpleDeserializer()
+    {
+        setRangeDelim(std::forward<R>(r));
+    }
 
     template <traits::mcc_input_char_range R>
     MccSimpleDeserializer& setRangeDelim(R&& r)
@@ -485,7 +493,7 @@ public:
     }
 
 protected:
-    std::string _rangeDelim{RANGE_DELIM_SEQ};
+    std::string _rangeDelim;
 };
 
 

mcc/tests/netmsg_test.cpp

@@ -0,0 +1,54 @@
+#include <iostream>
+#include <list>
+
+
+#include "../mcc_netserver_proto.h"
+
+
+int main()
+{
+    using msg1_t = mcc::network::MccNetMessage<mcc::network::MccNetMessageValidKeywords, std::string_view>;
+    using msg2_t = mcc::network::MccNetMessage<mcc::network::MccNetMessageValidKeywords, std::string>;
+
+    std::string_view sv{"TARGET 11:22:33.212; -0.23876984;    RADEC   "};
+    std::vector<char> arr{sv.begin(), sv.end()};
+
+    msg1_t msg1;
+
+    msg1.fromCharRange(arr);
+
+    std::cout << "msg.key = <" << msg1.keyword() << ">\n";
+    std::cout << "msg.par[1] = <" << msg1.param(1) << ">\n";
+
+    std::vector<double> vd{1.1, 2.2, 3.3};
+    msg2_t msg2("ACK", 12.43298042, "EEE", std::chrono::seconds(10), vd);
+
+    std::cout << "msg.bytes = <" << msg2.byteRepr() << ">\n";
+    std::cout << "msg.key = <" << msg2.keyword() << ">\n";
+    std::cout << "msg.par[1] = <" << msg2.param(1) << ">\n";
+    std::cout << "msg.par[2] = <" << msg2.param(2) << ">\n";
+
+    auto p2 = msg2.paramValue<std::chrono::seconds>(2);
+    std::cout << "msg.par[2] = <" << p2.value_or({}) << ">\n";
+
+    std::cout << "msg.par[3] = <";
+    auto p3 = msg2.paramValue<decltype(vd)>(3);
+    if (p3.has_value()) {
+        for (auto const& el : p3.value()) {
+            std::cout << el << " ";
+        }
+    }
+    std::cout << ">\n";
+
+    std::cout << "msg.par[1-2] joined = <" << msg2.params(1, 2) << ">\n";
+
+    auto vv = msg2.params<std::list<std::string_view>>(1, 3);
+    std::cout << "msg.par[1-3] array = <";
+    for (auto const& el : vv) {
+        std::cout << el << " ";
+    }
+    std::cout << ">\n";
+
+
+    return 0;
+}