...

asibfm700/CMakeLists.txt

@@ -41,7 +41,8 @@ add_library(${ASIBFM700_LIB} STATIC ${ASIBFM700_LIB_SRC}
     asibfm700_mount.h asibfm700_mount.cpp
     asibfm700_configfile.h
     asibfm700_netserver.cpp
-    asibfm700_netserver.h)
+    asibfm700_netserver.h
+)
 
 target_include_directories(${ASIBFM700_LIB} PRIVATE mcc spdlog ${ERFA_INCLUDE_DIR})
 target_link_libraries(${ASIBFM700_LIB} PRIVATE mcc spdlog)

asibfm700/asibfm700_netserver.h

@@ -8,9 +8,9 @@
 namespace asibfm700
 {
 
-class Asibfm700MountNetserver : public mcc::network::MccNetworkServer<Asibfm700Logger>
+class Asibfm700MountNetserver : public mcc::network::MccGenericNetworkServer<Asibfm700Logger>
 {
-    using _base_t = mcc::network::MccNetworkServer<Asibfm700Logger>;
+    using _base_t = mcc::network::MccGenericNetworkServer<Asibfm700Logger>;
 
 public:
     template <mcc::traits::mcc_range_of_input_char_range R = decltype(Asibfm700Logger::LOGGER_DEFAULT_FORMAT)>

mcc/CMakeLists.txt

@@ -73,7 +73,8 @@ include_directories(${BSPLINES_INCLUDE_DIR})
 set(MCC_LIBRARY_SRC mcc_generics.h mcc_defaults.h mcc_traits.h mcc_utils.h
     mcc_ccte_iers.h mcc_ccte_iers_default.h mcc_ccte_erfa.h mcc_pcm.h mcc_telemetry.h
     mcc_angle.h mcc_pzone.h mcc_pzone_container.h mcc_finite_state_machine.h
-    mcc_generic_mount.h mcc_tracking_model.h mcc_slewing_model.h mcc_moving_model_common.h)
+    mcc_generic_mount.h mcc_tracking_model.h mcc_slewing_model.h mcc_moving_model_common.h
+    mcc_netserver_endpoint.h mcc_netserver.h mcc_netserver_proto.h)
 
 list(APPEND MCC_LIBRARY_SRC mcc_spdlog.h)
 

mcc/mcc_netserver.h

@@ -72,8 +72,11 @@ static constexpr bool is_local_seqpack_proto = std::derived_from<T, asio::local:
 }  // namespace traits
 
 
+
+/*                          A GENERIC NETWORK SERVER IMPLEMENTATION                         */
+
 template <mcc_logger_c LoggerT = MccNullLogger>
-class MccNetworkServer : public LoggerT
+class MccGenericNetworkServer : public LoggerT
 {
 public:
     using LoggerT::logDebug;
@@ -89,8 +92,8 @@ public:
     typedef std::function<std::vector<char>(std::string_view)> handle_message_func_t;
 
 
-    MccNetworkServer(asio::io_context& ctx, const handle_message_func_t& func)
+    MccGenericNetworkServer(asio::io_context& ctx, const handle_message_func_t& func)
-        requires std::same_as<LoggerT, MccNullLogger>
+        requires std::is_default_constructible_v<LoggerT>
         : _asioContext(ctx), _handleMessageFunc(func), _stopSignal(ctx), _restartSignal(ctx)
     {
         std::stringstream st;
@@ -100,8 +103,8 @@ public:
     }
 
     template <typename... LoggerCtorArgsTs>
-    MccNetworkServer(asio::io_context& ctx, const handle_message_func_t& func, LoggerCtorArgsTs&&... log_args)
+    MccGenericNetworkServer(asio::io_context& ctx, const handle_message_func_t& func, LoggerCtorArgsTs&&... log_args)
-        requires(not std::same_as<LoggerT, MccNullLogger>)
+        requires(not std::is_default_constructible_v<LoggerT>)
         : LoggerT(std::forward<LoggerCtorArgsTs>(log_args)...),
           _asioContext(ctx),
           _handleMessageFunc(func),
@@ -123,7 +126,7 @@ public:
     //     logInfo(std::format("Create mount server instance (thread ID = {})", st.str()));
     // }
 
-    ~MccNetworkServer()
+    virtual ~MccGenericNetworkServer()
     {
         std::stringstream st;
         st << std::this_thread::get_id();
@@ -522,7 +525,7 @@ public:
         });
     }
 
-private:
+protected:
     asio::io_context& _asioContext;
 
     handle_message_func_t _handleMessageFunc;
@@ -811,4 +814,54 @@ private:
     }
 };
 
+
+template <mcc_logger_c LoggerT = MccNullLogger>
+class MccGenericMountNetworkServer : public MccGenericNetworkServer<LoggerT>
+{
+    using base_t = MccGenericNetworkServer<LoggerT>;
+
+public:
+    template <mcc_generic_mount_c MountT, typename... LoggerCtorArgsTs>
+    MccGenericMountNetworkServer(asio::io_context& ctx, MountT& mount, LoggerCtorArgsTs&&... log_args)
+        : base_t(ctx, {}, std::forward<LoggerCtorArgsTs>(log_args)...)
+    {
+        base_t::_handleMessageFunc = [mount = std::move(mount), this](std::string_view command) {
+            MccNetMessage input_msg;
+            MccNetMessage<std::vector<char>> output_msg;
+
+            if (auto ec = parseMessage(command, input_msg)) {
+                output_msg.construct(MCC_COMMPROTO_KEYWORD_SERVER_ERROR_STR, ec);
+            } else {
+                bool imsg_ok = true;
+                if (input_msg.withKey(MCC_COMMPROTO_KEYWORD_SERVER_ACK_STR)) {  // strange!
+                    output_msg.construct(MCC_COMMPROTO_KEYWORD_SERVER_ACK_STR, MCC_COMMPROTO_KEYWORD_SERVER_ACK_STR);
+                } else if (input_msg.withKey(MCC_COMMPROTO_KEYWORD_SERVER_ERROR_STR)) {  // ??!!!
+                    output_msg.construct(MCC_COMMPROTO_KEYWORD_SERVER_ACK_STR, MCC_COMMPROTO_KEYWORD_SERVER_ERROR_STR);
+                } else if (input_msg.withKey(MCC_COMMPROTO_KEYWORD_RESTART_SERVER_STR)) {
+                    this->restart();
+                    output_msg.construct(MCC_COMMPROTO_KEYWORD_SERVER_ACK_STR,
+                                         MCC_COMMPROTO_KEYWORD_RESTART_SERVER_STR);
+                }
+
+                if (imsg_ok) {  // send ACK
+                    // output_msg.construct(MCC_COMMPROTO_KEYWORD_SERVER_ACK_STR, input_msg);
+                }
+            }
+
+            return output_msg;
+        };
+    }
+
+    virtual ~MccGenericMountNetworkServer() {}
+
+protected:
+    template <typename MSG_T>
+    std::error_code parseMessage(std::string_view msg_bytes, MSG_T& msg)
+    {
+        auto ec = msg.fromCharRange(msg_bytes);
+
+        return ec;
+    }
+};
+
 }  // namespace mcc::network

mcc/mcc_netserver_proto.h

@@ -489,7 +489,11 @@ struct MccNetMessageValidKeywords {
 static_assert(mcc_netmsg_valid_keys_c<MccNetMessageValidKeywords>, "");
 
 
-template <mcc_netmsg_valid_keys_c BASE_T, traits::mcc_char_range BYTEREPR_T>
+template <typename T>
+concept mcc_netmessage_c = requires(T t) { T(); };
+
+template <mcc::traits::mcc_char_range BYTEREPR_T = std::string_view,
+          mcc_netmsg_valid_keys_c BASE_T = MccNetMessageValidKeywords>
 class MccNetMessage
 {
 public:
@@ -675,6 +679,11 @@ protected:
                         (*this)(el, bytes);
                     }
                 }
+            } else if constexpr (std::same_as<T, std::error_code>) {
+                std::format_to(std::back_inserter(bytes), "{}{}{}{}{}", value.value(),
+                               MCC_COMMPROTO_RANGEPARAM_DELIM_SEQ, value.message(), MCC_COMMPROTO_RANGEPARAM_DELIM_SEQ,
+                               value.category().name());
+            } else if constexpr (std::same_as<T, MccNetMessage>) {
             } else if constexpr (std::formattable<T, char>) {
                 std::format_to(std::back_inserter(bytes), "{}", value);
             } else {
@@ -706,6 +715,12 @@ public:
         fromCharRange(msg);
     }
 
+    // constexpr MccNetMessage(const BYTEREPR_T& msg)
+    //     requires traits::mcc_input_char_range<BYTEREPR_T>
+    // {
+    //     fromCharRange(msg);
+    // }
+
     template <traits::mcc_input_char_range KT>
     constexpr bool withKey(const KT& key)
     {
@@ -987,6 +1002,7 @@ protected:
     };
 };
 
-static_assert(MccNetMessage<MccNetMessageValidKeywords, std::string_view>{"ACK"}.withKey("ACK"));
+static_assert(MccNetMessage<std::string, MccNetMessageValidKeywords>{"ACK"}.withKey("ACK"));
+static_assert(MccNetMessage{"ACK"}.withKey("ACK"));
 
 }  // namespace mcc::network

mcc/tests/netmsg_test.cpp

@@ -7,8 +7,12 @@
 
 int main()
 {
-    using msg1_t = mcc::network::MccNetMessage<mcc::network::MccNetMessageValidKeywords, std::string_view>;
+    // using msg1_t = mcc::network::MccNetMessage<mcc::network::MccNetMessageValidKeywords, std::string_view>;
-    using msg2_t = mcc::network::MccNetMessage<mcc::network::MccNetMessageValidKeywords, std::string>;
+    // using msg2_t = mcc::network::MccNetMessage<mcc::network::MccNetMessageValidKeywords, std::string>;
+    using msg1_t = mcc::network::MccNetMessage<std::string_view>;
+    using msg2_t = mcc::network::MccNetMessage<std::string>;
+
+    mcc::network::MccNetMessage msg3("ACK");
 
     std::string_view sv{"TARGET 11:22:33.212; -0.23876984;    RADEC   "};
     std::vector<char> arr{sv.begin(), sv.end()};
@@ -22,6 +26,7 @@ int main()
 
     std::vector<double> vd{1.1, 2.2, 3.3};
     msg2_t msg2("ACK", 12.43298042, "EEE", std::chrono::seconds(10), vd);
+    // msg2_t msg2("ACK");
 
     std::cout << "msg.bytes = <" << msg2.byteRepr() << ">\n";
     std::cout << "msg.key = <" << msg2.keyword() << ">\n";