From 7556539084f7dc08025b2c28dd5e9effc24d2049 Mon Sep 17 00:00:00 2001
From: "Timur A. Fatkhullin" <timur@sao.ru>
Date: Tue, 26 Aug 2025 13:38:33 +0300
Subject: [PATCH] ...

---
 mcc/mcc_generic_mount.h |  57 +++++++++++++++++++++++
 mcc/mcc_generics.h      | 100 +++++++++++++++++++++++++---------------
 2 files changed, 121 insertions(+), 36 deletions(-)
 create mode 100644 mcc/mcc_generic_mount.h

diff --git a/mcc/mcc_generic_mount.h b/mcc/mcc_generic_mount.h
new file mode 100644
index 0000000..187c34f
--- /dev/null
+++ b/mcc/mcc_generic_mount.h
@@ -0,0 +1,57 @@
+#pragma once
+
+/*                          MOUNT CONTROL COMPONENTS LIBRARY                            */
+
+
+/*                          GENERIC MOUNT REFERENCE IMPLEMENTATION                          */
+
+
+#include "mcc_generics.h"
+
+namespace mcc
+{
+
+template <mcc_telemetry_c TelemetryT, mcc_pzone_container_c PZoneContT, mcc_logger_c LoggerT>
+class MccGenericMount : public TelemetryT, public PZoneContT, public LoggerT
+{
+public:
+    MccGenericMount(TelemetryT telemetry, PZoneContT pzone_cont, LoggerT logger)
+        : TelemetryT(std::move(telemetry)), PZoneContT(std::move(pzone_cont)), LoggerT(std::move(logger))
+    {
+    }
+
+    virtual ~MccGenericMount() = default;
+
+
+    template <std::derived_from<MccGenericMount> SelfT>
+    auto slewToTarget(this SelfT&& self)
+    {
+        return std::forward<SelfT>(self).slewToTarget();
+    }
+
+    template <std::derived_from<MccGenericMount> SelfT>
+    auto trackTarget(this SelfT&& self)
+    {
+        return std::forward<SelfT>(self).trackTarget();
+    }
+
+    template <std::derived_from<MccGenericMount> SelfT>
+    auto startGuidingTarget(this SelfT&& self)
+    {
+        return std::forward<SelfT>(self).startGuidingTarget();
+    }
+
+    template <std::derived_from<MccGenericMount> SelfT>
+    auto stopGuidingTarget(this SelfT&& self)
+    {
+        return std::forward<SelfT>(self).stopGuidingTarget();
+    }
+
+    template <std::derived_from<MccGenericMount> SelfT>
+    auto stopMount(this SelfT&& self)
+    {
+        return std::forward<SelfT>(self).stopMount();
+    }
+};
+
+}  // namespace mcc
diff --git a/mcc/mcc_generics.h b/mcc/mcc_generics.h
index d82886b..6a1a109 100644
--- a/mcc/mcc_generics.h
+++ b/mcc/mcc_generics.h
@@ -698,6 +698,9 @@ concept mcc_slewing_model_c = requires(T t, const T t_const) {
 
     { t.slewToTarget() } -> std::same_as<typename T::error_t>;
     { t.stopSlewing() } -> std::same_as<typename T::error_t>;
+
+    { t.setSlewingParams(std::declval<typename T::slewing_params_t>()) } -> std::same_as<typename T::error_t>;
+    { t.getSlewingParams() } -> std::same_as<typename T::slewing_params_t>;
 };
 
 
@@ -715,6 +718,9 @@ concept mcc_tracking_model_c = requires(T t, const T t_const) {
 
     { t.trackTarget() } -> std::same_as<typename T::error_t>;
     { t.stopTracking() } -> std::same_as<typename T::error_t>;
+
+    { t.setTrackingParams(std::declval<typename T::tracking_params_t>()) } -> std::same_as<typename T::error_t>;
+    { t.getTrackingParams() } -> std::same_as<typename T::tracking_params_t>;
 };
 
 template <typename T>
@@ -731,6 +737,9 @@ concept mcc_guiding_model_c = requires(T t, const T t_const) {
 
     { t.startGuidingTarget() } -> std::same_as<typename T::error_t>;
     { t.stopGuidingTarget() } -> std::same_as<typename T::error_t>;
+
+    { t.setGuidingParams(std::declval<typename T::guiding_params_t>()) } -> std::same_as<typename T::error_t>;
+    { t.getGuidingParams() } -> std::same_as<typename T::guiding_params_t>;
 };
 
 
@@ -738,51 +747,70 @@ concept mcc_guiding_model_c = requires(T t, const T t_const) {
 
 
 
-template <mcc_error_c RetT, typename StopReasonT>
-struct mcc_generic_mount_interface_t {
-    virtual ~mcc_generic_mount_interface_t() = default;
+// template <mcc_error_c RetT, typename StopReasonT>
+// struct mcc_generic_mount_interface_t {
+//     virtual ~mcc_generic_mount_interface_t() = default;
 
-    // slew mount to target (target coordinates were defined in telemetry data)
-    template <std::derived_from<mcc_generic_mount_interface_t> SelfT>
-    RetT slewToTarget(this SelfT&& self, mcc_slewing_model_c auto model)
-    {
-        return std::forward<SelfT>(self).slewToTarget(std::move(model));
-    }
+//     // slew mount to target (target coordinates were defined in telemetry data)
+//     template <std::derived_from<mcc_generic_mount_interface_t> SelfT>
+//     RetT slewToTarget(this SelfT&& self, mcc_slewing_model_c auto model)
+//     {
+//         return std::forward<SelfT>(self).slewToTarget(std::move(model));
+//     }
 
-    // track target, i.e., the mount moves with celestial speed
-    template <std::derived_from<mcc_generic_mount_interface_t> SelfT>
-    RetT trackTarget(this SelfT&& self, mcc_tracking_model_c auto model)
-    {
-        return std::forward<SelfT>(self).trackTarget(std::move(model));
-    }
+//     // track target, i.e., the mount moves with celestial speed
+//     template <std::derived_from<mcc_generic_mount_interface_t> SelfT>
+//     RetT trackTarget(this SelfT&& self, mcc_tracking_model_c auto model)
+//     {
+//         return std::forward<SelfT>(self).trackTarget(std::move(model));
+//     }
 
-    template <std::derived_from<mcc_generic_mount_interface_t> SelfT>
-    RetT startGuidingTarget(this SelfT&& self, mcc_guiding_model_c auto model)
-    {
-        return std::forward<SelfT>(self).startGuidingTarget(std::move(model));
-    }
+//     template <std::derived_from<mcc_generic_mount_interface_t> SelfT>
+//     RetT startGuidingTarget(this SelfT&& self, mcc_guiding_model_c auto model)
+//     {
+//         return std::forward<SelfT>(self).startGuidingTarget(std::move(model));
+//     }
 
-    template <std::derived_from<mcc_generic_mount_interface_t> SelfT>
-    RetT stopGuidingTarget(this SelfT&& self)
-    {
-        return std::forward<SelfT>(self).stopGuidingTarget();
-    }
+//     template <std::derived_from<mcc_generic_mount_interface_t> SelfT>
+//     RetT stopGuidingTarget(this SelfT&& self)
+//     {
+//         return std::forward<SelfT>(self).stopGuidingTarget();
+//     }
 
-    template <std::derived_from<mcc_generic_mount_interface_t> SelfT>
-    RetT stopMount(this SelfT&& self, StopReasonT reason)
-    {
-        return std::forward<SelfT>(self).stopMount(std::move(reason));
-    }
+//     template <std::derived_from<mcc_generic_mount_interface_t> SelfT>
+//     RetT stopMount(this SelfT&& self, StopReasonT reason)
+//     {
+//         return std::forward<SelfT>(self).stopMount(std::move(reason));
+//     }
 
-protected:
-    mcc_generic_mount_interface_t() = default;
-};
+// protected:
+//     mcc_generic_mount_interface_t() = default;
+// };
 
 
+// template<typename T>
+// concept mcc_generic_mount_c
+//     = std::derived_from<T, mcc_generic_mount_interface_t<typename T::error_t, typename T::stop_reason_t>>
+//       && mcc_telemetry_c<T> && mcc_pzone_container_c<T>;
+
 template <typename T>
-concept mcc_generic_mount_c =
-    std::derived_from<T, mcc_generic_mount_interface_t<typename T::error_t, typename T::stop_reason_t>> &&
-    mcc_telemetry_c<T> && mcc_pzone_container_c<T>;
+concept mcc_generic_mount_c = mcc_telemetry_c<T> && mcc_pzone_container_c<T> && requires(T t) {
+    requires mcc_error_c<typename T::error_t>;
+    typename T::stop_reason_t;
+
+    // slew mount to target (target coordinates were defined in telemetry data)
+    { t.slewToTarget() } -> std::same_as<typename T::error_t>;
+
+    // track target, i.e., the mount moves with celestial speed
+    { t.trackTarget() } -> std::same_as<typename T::error_t>;
+
+
+    { t.startGuidingTarget() } -> std::same_as<typename T::error_t>;
+    { t.stopGuidingTarget() } -> std::same_as<typename T::error_t>;
+
+    // stop any movement
+    { t.stopMount(std::declval<typename T::stop_reason_t>()) } -> std::same_as<typename T::error_t>;
+};
 
 
 // with logging methods