...

asibfm700/asibfm700_netserver.cpp

@@ -6,10 +6,47 @@ namespace asibfm700
 
 template <mcc::traits::mcc_range_of_input_char_range R>
 Asibfm700MountNetServer::Asibfm700MountNetServer(asio::io_context& ctx,
+                                                 Asibfm700Mount& mount,
                                                  std::shared_ptr<spdlog::logger> logger,
                                                  const R& pattern_range)
-    : _base_t(ctx, [this](std::string_view msg) { return handleMessage(msg); }, std::move(logger), pattern_range)
+    : base_t(ctx, mount, std::move(logger), pattern_range)
 {
+    // to avoid possible compiler optimization (one needs to catch 'mount' strictly by reference)
+    auto* mount_ptr = &mount;
+
+    base_t::_handleMessageFunc = [base_hndl_func = std::move(base_t::_handleMessageFunc), mount_ptr,
+                                  this](std::string_view command) {
+        using mount_error_t = typename Asibfm700Mount::error_t;
+        std::error_code err{};
+
+        Asibfm700NetMessage input_msg;
+        Asibfm700NetMessage<handle_message_func_result_t> output_msg;
+
+        auto ec = parseMessage(command, input_msg);
+
+        if (ec) {
+            output_msg.construct(mcc::network::MCC_COMMPROTO_KEYWORD_SERVER_ERROR_STR, ec);
+        } else {
+            if (input_msg.withKey(ASIBFM700_COMMPROTO_KEYWORD_METEO_STR)) {
+                // what is operation type (set or get)?
+                if (input_msg.paramSize()) {  // set operation
+                    auto vp = input_msg.paramValue<Asibfm700CCTE::meteo_t>(0);
+                    if (vp) {
+                        mount_ptr->updateMeteoERFA(vp.value());
+                    } else {
+                        output_msg.construct(mcc::network::MCC_COMMPROTO_KEYWORD_SERVER_ERROR_STR, vp.error());
+                    }
+                } else {  // get operation
+                    output_msg.construct(mcc::network::MCC_COMMPROTO_KEYWORD_SERVER_ACK_STR,
+                                         ASIBFM700_COMMPROTO_KEYWORD_METEO_STR, mount_ptr->getStateERFA().meteo);
+                }
+            } else {
+                output_msg = base_t::handleMessage<decltype(output_msg)>(input_msg, mount_ptr);
+            }
+        }
+
+        return output_msg.byteRepr();
+    };
 }
 
 }  // namespace asibfm700

asibfm700/asibfm700_netserver.h

@@ -4,6 +4,7 @@
 #include <mcc_netserver_proto.h>
 
 #include "asibfm700_common.h"
+#include "asibfm700_mount.h"
 
 namespace asibfm700
 {
@@ -57,11 +58,59 @@ struct Asibfm700NetMessageValidKeywords {
 };
 
 template <mcc::traits::mcc_char_range BYTEREPR_T = std::string_view>
-class Asibfm700MountNetMessage : public mcc::network::MccNetMessage<BYTEREPR_T, Asibfm700NetMessageValidKeywords>
+class Asibfm700NetMessage : public mcc::network::MccNetMessage<BYTEREPR_T, Asibfm700NetMessageValidKeywords>
 {
 protected:
     using base_t = mcc::network::MccNetMessage<BYTEREPR_T, Asibfm700NetMessageValidKeywords>;
 
+    class serializer_t : public base_t::DefaultSerializer
+    {
+    public:
+        template <typename T, mcc::traits::mcc_output_char_range OR>
+        void operator()(const T& value, OR& bytes)
+        {
+            if constexpr (std::same_as<T, Asibfm700CCTE::meteo_t>) {
+                // serialize just like a vector
+                std::vector<double> meteo{value.temperature, value.humidity, value.pressure};
+                base_t::operator()(meteo, bytes);
+            } else {
+                base_t::operator()(value, bytes);
+            }
+        }
+    } _serializer;
+
+
+    class deserializer_t : public base_t::DefaultDeserializer
+    {
+    public:
+        template <mcc::traits::mcc_input_char_range IR, typename VT>
+        std::error_code operator()(IR&& bytes, VT& value)
+        {
+            if constexpr (std::same_as<VT, Asibfm700CCTE::meteo_t>) {
+                // deserialize just like a vector
+
+                std::vector<double> v;
+                auto ec = base_t::operator()(std::forward<IR>(bytes), v);
+                if (ec) {
+                    return ec;
+                }
+
+                if (v.size() < 3) {
+                    return std::make_error_code(std::errc::invalid_argument);
+                }
+
+                value.temperature = v[0];
+                value.humidity = v[1];
+                value.pressure = v[2];
+
+                return {};
+            } else {
+                return base_t::operator()(std::forward<IR>(bytes), value);
+            }
+        }
+    } _deserializer;
+
+
 
 public:
     using base_t::base_t;
@@ -69,7 +118,7 @@ public:
     template <typename T>
     std::expected<T, std::error_code> paramValue(size_t idx)
     {
-        return paramValue<T>(idx, _defaultDeserilizer);
+        return paramValue<T>(idx, _deserializer);
     }
 
 
@@ -78,19 +127,20 @@ public:
     std::error_code construct(KT&& key, PTs&&... params)
         requires mcc::traits::mcc_output_char_range<BYTEREPR_T>
     {
-        return construct(_defaultSerializer, std::forward<KT>(key), std::forward<PTs>(params)...);
+        return construct(_serializer, std::forward<KT>(key), std::forward<PTs>(params)...);
     }
 };
 
 
 
-class Asibfm700MountNetServer : public mcc::network::MccGenericNetworkServer<Asibfm700Logger>
+class Asibfm700MountNetServer : public mcc::network::MccGenericMountNetworkServer<Asibfm700Logger>
 {
-    using _base_t = mcc::network::MccGenericNetworkServer<Asibfm700Logger>;
+    using base_t = mcc::network::MccGenericMountNetworkServer<Asibfm700Logger>;
 
 public:
     template <mcc::traits::mcc_range_of_input_char_range R = decltype(Asibfm700Logger::LOGGER_DEFAULT_FORMAT)>
     Asibfm700MountNetServer(asio::io_context& ctx,
+                            Asibfm700Mount& mount,
                             std::shared_ptr<spdlog::logger> logger,
                             const R& pattern_range = Asibfm700Logger::LOGGER_DEFAULT_FORMAT);