...

cxx/asibfm700_mount.cpp

@@ -7,12 +7,12 @@ template <mcc::traits::mcc_range_of_input_char_range R>
 AsibFM700Mount::AsibFM700Mount(AsibFM700Config config, std::shared_ptr<spdlog::logger> logger, const R& pattern_range)
     : mcc::utils::MccSpdlogLogger(std::move(logger), pattern_range),
       _currentConfig(std::move(config)),
-      base_gm_t(std::make_tuple(_currentConfig.astromEngineState),
+      base_gm_t({_currentConfig.astromEngineState},
-                std::make_tuple(_currentConfig.hardwareConfig),
+                {_currentConfig.hardwareConfig},
-                std::make_tuple(_currentConfig.pecData),
+                {_currentConfig.pecData},
-                std::make_tuple(std::ref(_astromEngine), std::ref(_pec), std::ref(_hardware)),
+                AsibFM700Telemetry{_astromEngine, _pec, _hardware},
-                std::make_tuple(std::ref(_telemetry), std::ref(_hardware), std::ref(_pzFuncs)),
+                slew_model_t{_telemetry, _hardware, _pzFuncs},
-                std::make_tuple(std::ref(_telemetry), std::ref(_hardware), std::ref(_pzFuncs)))
+                guiding_model_t{_telemetry, _hardware, _pzFuncs})
 {
 }
 

cxx/asibfm700_mount.h

@@ -29,6 +29,9 @@ class AsibFM700Mount : public mcc::utils::MccSpdlogLogger,
                                            AsibFM700GuidingModel<mcc::utils::MccSpdlogLogger>>;
 
 public:
+    typedef AsibFM700SlewModel<mcc::utils::MccSpdlogLogger> slew_model_t;
+    typedef AsibFM700GuidingModel<mcc::utils::MccSpdlogLogger> guiding_model_t;
+
     template <mcc::traits::mcc_range_of_input_char_range R = decltype(LOGGER_DEFAULT_FORMAT)>
     AsibFM700Mount(AsibFM700Config config,
                    std::shared_ptr<spdlog::logger> logger,

cxx/mcc_generic_mount.h

@@ -32,6 +32,22 @@ struct MccPZoneWrapper {
     pz_inzone_func_t inZone;
     pz_timeto_func_t timeTo;
     pz_timefrom_func_t timeFrom;
+
+    MccPZoneWrapper(MccPZoneWrapper&& other)
+        : inZone(std::move(other.inZone)), timeTo(std::move(other.timeTo)), timeFrom(std::move(other.timeFrom)) {};
+
+    MccPZoneWrapper& operator=(MccPZoneWrapper&& other)
+    {
+        if (this != &other) {
+            inZone = std::move(other.inZone);
+            timeTo = std::move(other.timeTo);
+            timeFrom = std::move(other.timeFrom);
+        }
+
+        return *this;
+    };
+
+    MccPZoneWrapper() = default;
 };
 
 
@@ -56,24 +72,18 @@ public:
 
     static constexpr MccMountType mountType = pec_t::mountType;
 
-    template <traits::mcc_tuple_c ASTROM_ENGINE_CTOR_T,
+    MccGenericMount(ASTROM_ENGINE_T aengine,
-              traits::mcc_tuple_c HARDWARE_CTOR_T,
+                    HARDWARE_T hw,
-              traits::mcc_tuple_c PEC_CTOR_T,
+                    PEC_T pec,
-              traits::mcc_tuple_c TELEMETRY_CTOR_T,
+                    TELEMETRY_T tmtry,
-              traits::mcc_tuple_c SLEWMODEL_CTOR_T,
+                    SLEWMODEL_T smodel,
-              traits::mcc_tuple_c GUIDINGMODEL_CTOR_T>
+                    GUIDINGMODEL_T gmodel)
-    MccGenericMount(ASTROM_ENGINE_CTOR_T aengine_ctor_args,
+        : _astromEngine(std::move(aengine)),
-                    HARDWARE_CTOR_T hw_ctor_args,
+          _hardware(std::move(hw)),
-                    PEC_CTOR_T pec_ctor_args,
+          _pec(std::move(pec)),
-                    TELEMETRY_CTOR_T t_ctor_args,
+          _telemetry(std::move(tmtry)),
-                    SLEWMODEL_CTOR_T smodel_ctor_args,
+          _slewModel(std::move(smodel)),
-                    GUIDINGMODEL_CTOR_T gmodel_ctor_args)
+          _guidingModel(std::move(gmodel))
-        : _astromEngine(std::make_from_tuple<ASTROM_ENGINE_T>(std::move(aengine_ctor_args))),
-          _hardware(std::make_from_tuple<HARDWARE_T>(std::move(hw_ctor_args))),
-          _pec(std::make_from_tuple<PEC_T>(std::move(pec_ctor_args))),
-          _telemetry(std::make_from_tuple<TELEMETRY_T>(std::move(t_ctor_args))),
-          _slewModel(std::make_from_tuple<SLEWMODEL_T>(std::move(smodel_ctor_args))),
-          _guidingModel(std::make_from_tuple<GUIDINGMODEL_T>(std::move(gmodel_ctor_args)))
     {
     }
 

cxx/mcc_guiding_model.h

@@ -116,7 +116,8 @@ public:
 
     template <traits::mcc_mount_telemetry_c TELEMETRY_T,
               traits::mcc_mount_hardware_c HARDWARE_T,
-              traits::mcc_tuple_c PZ_T,
+              traits::mcc_irange_of_pzones_c<typename TELEMETRY_T::mount_telemetry_data_t> PZ_T,
+              // traits::mcc_tuple_c PZ_T,
               typename... LoggerCtorArgTs>
     MccSimpleGuidingModel(TELEMETRY_T& telemetry,
                           HARDWARE_T& hardware,
@@ -132,7 +133,9 @@ public:
 
     template <traits::mcc_mount_telemetry_c TELEMETRY_T,
               traits::mcc_mount_hardware_c HARDWARE_T,
-              traits::mcc_tuple_c PZ_T>
+              traits::mcc_irange_of_pzones_c<typename TELEMETRY_T::mount_telemetry_data_t> PZ_T
+              // traits::mcc_tuple_c PZ_T
+              >
     MccSimpleGuidingModel(TELEMETRY_T& telemetry, HARDWARE_T& hardware, PZ_T& prohibited_zone)
         requires(std::same_as<LoggerT, MccNullLogger>)
     {

cxx/mcc_mount_concepts.h

@@ -429,7 +429,7 @@ concept mcc_prohibited_zone_c =
 
         // static constexpr member to represent inifite duration
         requires requires {
-            requires std::same_as<decltype(T::infiniteDuration), typename T::duration_t>;
+            requires std::same_as<decltype(T::infiniteDuration), typename T::duration_t const>;
             []() {
                 constexpr auto val = T::infiniteDuration;
                 return val;
@@ -438,7 +438,7 @@ concept mcc_prohibited_zone_c =
 
         // static constexpr member to represent zero duration
         requires requires {
-            requires std::same_as<decltype(T::zeroDuration), typename T::duration_t>;
+            requires std::same_as<decltype(T::zeroDuration), typename T::duration_t const>;
             []() {
                 constexpr auto val = T::zeroDuration;
                 return val;
@@ -449,13 +449,13 @@ concept mcc_prohibited_zone_c =
         // the type 'T' must define a static constexpr member of type MccCoordPairKind
         // to declarate type of coordinate pair used to describe the zone.
         // This coordinate pair must be used as input in the 'inZone' class method.
-        requires requires {
+        // requires requires {
-            requires std::same_as<decltype(T::zoneCoordPairKind), const MccCoordPairKind>;
+        //     requires std::same_as<decltype(T::zoneCoordPairKind), const MccCoordPairKind>;
-            []() {
+        //     []() {
-                constexpr MccCoordPairKind val = T::zoneCoordPairKind;
+        //         constexpr MccCoordPairKind val = T::zoneCoordPairKind;
-                return val;
+        //         return val;
-            }();  // to ensure that 'zoneCoordPairKind' can be used at compile-time context
+        //     }();  // to ensure that 'zoneCoordPairKind' can be used at compile-time context
-        };
+        // };
 
         // return a name of the zone
         { t_const.name() } -> mcc_formattable;
@@ -506,7 +506,6 @@ concept mcc_irange_of_pzones_c = mcc_mount_telemetry_data_c<TelemetryDataT> && s
                                  mcc_prohibited_zone_c<std::ranges::range_value_t<T>, TelemetryDataT>;
 
 
-
 /*  MOUNT GENERIC CONTROLS  */
 
 

cxx/mcc_mount_pz.h

@@ -243,4 +243,6 @@ private:
 typedef MccAltLimitPZ<MccAltLimitKind::MIN_ALT_LIMIT> MccMinAltPZ;
 typedef MccAltLimitPZ<MccAltLimitKind::MAX_ALT_LIMIT> MccMaxAltPZ;
 
+static_assert(std::movable<MccMinAltPZ>);
+
 }  // namespace mcc

cxx/mcc_mount_pz_holder.h

@@ -0,0 +1,165 @@
+#pragma once
+
+/*                          MOUNT CONTROL COMPONENTS LIBRARY                            */
+
+
+/*                          AN DEFAULT IMPLEMENTATION OF PROHIBITED ZONES HOLDER        */
+
+#include "mcc_mount_concepts.h"
+
+namespace mcc
+{
+
+template <traits::mcc_mount_telemetry_data_c TelemetryDataT>
+class MccPZoneHolder
+{
+public:
+    typedef TelemetryDataT telemetry_data_t;
+
+    // a type to which the result of calling prohibited zone class methods 'timeTo' and 'timeFrom' will be converted
+    typedef std::chrono::duration<double> duration_t;  // seconds as floating-point number
+
+    // adaptor class for prohibited zones
+    struct MccPZoneWrapper {
+        using duration_t = MccPZoneHolder::duration_t;
+
+        static constexpr duration_t infiniteDuration{std::numeric_limits<double>::infinity()};
+        static constexpr duration_t zeroDuration{0.0};
+
+        typedef std::function<bool(const TelemetryDataT&)> pz_inzone_func_t;
+        typedef std::function<duration_t(const TelemetryDataT&)> pz_timeto_func_t;
+        typedef std::function<duration_t(const TelemetryDataT&)> pz_timefrom_func_t;
+
+        MccCoordPairKind coordPairKind;
+        const std::function<std::string()> name;
+        pz_inzone_func_t inZone;
+        pz_timeto_func_t timeTo;
+        pz_timefrom_func_t timeFrom;
+
+        MccPZoneWrapper(MccPZoneWrapper&& other)
+            : inZone(std::move(other.inZone)), timeTo(std::move(other.timeTo)), timeFrom(std::move(other.timeFrom)) {};
+
+        MccPZoneWrapper& operator=(MccPZoneWrapper&& other)
+        {
+            if (this != &other) {
+                inZone = std::move(other.inZone);
+                timeTo = std::move(other.timeTo);
+                timeFrom = std::move(other.timeFrom);
+            }
+
+            return *this;
+        };
+
+        MccPZoneWrapper() = default;
+    };
+
+    size_t pzNumberOfZones() const { return _pzWrapperVec.size(); }
+
+    // add zone/zones
+    template <traits::mcc_prohibited_zone_c<telemetry_data_t> ZT,
+              traits::mcc_prohibited_zone_c<telemetry_data_t>... ZTs>
+    size_t pzAddZone(ZT zone, ZTs... zones)
+    {
+        auto zone_ptr = std::make_shared<ZT>(std::move(zone));
+
+        using d_t = typename MccPZoneWrapper::duration_t;
+
+        _pzWrapperVec.emplace_back(
+            {.coordPairKind = ZT::zoneCoordPairKind,
+             .name = [zone_ptr]() { return std::format("{}", zone_ptr->name()); },
+             .inZone = [zone_ptr](const telemetry_data_t& tmry_data) { return zone_ptr->inZone(tmry_data); },
+             .timeTo =
+                 [zone_ptr](const telemetry_data_t& tmry_data) {
+                     auto d = zone_ptr->timeTo(tmry_data);
+
+                     if constexpr (std::same_as<typename ZT::duration_t, d_t>) {
+                         return d;
+                     } else {
+                         if (d == ZT::infiniteDuration) {
+                             return MccPZoneWrapper::infiniteDuration;
+                         } else if (d == ZT::zeroDuration) {
+                             return MccPZoneWrapper::zeroDuration;
+                         }
+                         return std::chrono::duration_cast<d_t>(d);
+                     }
+                 },
+             .timeFrom =
+                 [zone_ptr](const telemetry_data_t& tmry_data) {
+                     auto d = zone_ptr->timeFrom(tmry_data);
+
+                     if constexpr (std::same_as<typename ZT::duration_t, d_t>) {
+                         return d;
+                     } else {
+                         if (d == ZT::infiniteDuration) {
+                             return MccPZoneWrapper::infiniteDuration;
+                         } else if (d == ZT::zeroDuration) {
+                             return MccPZoneWrapper::zeroDuration;
+                         }
+                         return std::chrono::duration_cast<d_t>(d);
+                     }
+                 }});
+
+
+        if constexpr (sizeof...(ZTs)) {
+            pzAddZone(std::move(zones)...);
+        }
+
+        return _pzWrapperVec.size();
+    }
+
+    void pzClearZones()
+    {
+        // stop mount here?!!
+        _pzWrapperVec.clear();
+    }
+
+
+    // visitors
+    template <std::invocable<MccPZoneWrapper> FT>
+    auto pzForeachZone(FT&& func)
+        requires std::same_as<std::invoke_result_t<FT, MccPZoneWrapper>, void>
+    {
+        for (auto& wr : _pzWrapperVec) {
+            std::forward<FT>(func)(wr);
+        }
+    }
+
+    template <std::invocable<MccPZoneWrapper> FT,
+              std::ranges::output_range<std::invoke_result_t<FT, MccPZoneWrapper>> ResT =
+                  std::vector<std::invoke_result_t<FT, MccPZoneWrapper>>>
+    auto pzForeachZone(FT&& func)
+        requires(!std::same_as<std::invoke_result_t<FT, MccPZoneWrapper>, void>)
+    {
+        ResT result;
+
+        for (auto& wr : _pzWrapperVec) {
+            std::back_inserter(result) = std::forward<FT>(func)(wr);
+        }
+
+        return result;
+    }
+
+    template <std::ranges::output_range<bool> RT>
+    bool pzInZone(const telemetry_data_t& tdata, RT& result)
+    {
+        bool in_zone = false;
+
+        auto const p_tdata = &tdata;
+
+        result = pzForeachZone<RT>([&in_zone, p_tdata](auto& wr) {
+            bool r = wr.inZone(*p_tdata);
+            in_zone |= r;
+
+            return r;
+        });
+
+        return in_zone;
+    }
+
+protected:
+    std::vector<MccPZoneWrapper> _pzWrapperVec{};
+};
+
+
+
+}  // namespace mcc

cxx/mcc_slew_model.h

@@ -126,7 +126,8 @@ public:
 
     template <traits::mcc_mount_telemetry_c TELEMETRY_T,
               traits::mcc_mount_hardware_c HARDWARE_T,
-              traits::mcc_tuple_c PZ_T,  // std::tuple of prohibited zones
+              traits::mcc_irange_of_pzones_c<typename TELEMETRY_T::mount_telemetry_data_t> PZ_T,
+              // traits::mcc_tuple_c PZ_T,  // std::tuple of prohibited zones
               typename... LoggerCtorArgTs>
     MccSimpleSlewModel(TELEMETRY_T& telemetry,
                        HARDWARE_T& hardware,
@@ -142,7 +143,8 @@ public:
 
     template <traits::mcc_mount_telemetry_c TELEMETRY_T,
               traits::mcc_mount_hardware_c HARDWARE_T,
-              traits::mcc_tuple_c PZ_T  // std::tuple of prohibited zones
+              traits::mcc_irange_of_pzones_c<typename TELEMETRY_T::mount_telemetry_data_t> PZ_T
+              // traits::mcc_tuple_c PZ_T  // std::tuple of prohibited zones
               >
     MccSimpleSlewModel(TELEMETRY_T& telemetry, HARDWARE_T& hardware, PZ_T& prohibited_zone)
         requires(std::same_as<LoggerT, MccNullLogger>)

cxx/mcc_spdlog.h

@@ -46,52 +46,25 @@ public:
     virtual ~MccSpdlogLogger() = default;
 
 
-    void setLogLevel(loglevel_t log_level)
+    void setLogLevel(loglevel_t log_level) { _loggerSPtr->set_level(log_level); }
-    {
-        _loggerSPtr->set_level(log_level);
-    }
 
-    loglevel_t getLogLevel() const
+    loglevel_t getLogLevel() const { return _loggerSPtr->level(); }
-    {
-        return _loggerSPtr->level();
-    }
 
-    void logMessage(loglevel_t level, const std::string& msg)
+    void logMessage(loglevel_t level, const std::string& msg) { _loggerSPtr->log(level, msg); }
-    {
-        _loggerSPtr->log(level, msg);
-    }
 
     // specialized for given level methods
 
-    void logCritical(const std::string& msg)
+    void logCritical(const std::string& msg) { logMessage(spdlog::level::critical, msg); }
-    {
-        logMessage(spdlog::level::critical, msg);
-    }
 
-    void logError(const std::string& msg)
+    void logError(const std::string& msg) { logMessage(spdlog::level::err, msg); }
-    {
-        logMessage(spdlog::level::err, msg);
-    }
 
-    void logWarn(const std::string& msg)
+    void logWarn(const std::string& msg) { logMessage(spdlog::level::warn, msg); }
-    {
-        logMessage(spdlog::level::warn, msg);
-    }
 
-    void logInfo(const std::string& msg)
+    void logInfo(const std::string& msg) { logMessage(spdlog::level::info, msg); }
-    {
-        logMessage(spdlog::level::info, msg);
-    }
 
-    void logDebug(const std::string& msg)
+    void logDebug(const std::string& msg) { logMessage(spdlog::level::debug, msg); }
-    {
-        logMessage(spdlog::level::debug, msg);
-    }
 
-    void logTrace(const std::string& msg)
+    void logTrace(const std::string& msg) { logMessage(spdlog::level::trace, msg); }
-    {
-        logMessage(spdlog::level::trace, msg);
-    }
 
     template <traits::mcc_formattable... ArgTs>
     void logMessage(spdlog::level::level_enum level, spdlog::format_string_t<ArgTs...> fmt, ArgTs&&... args)
@@ -176,12 +149,7 @@ protected:
         _loggerSPtr->set_pattern(_currentLogPattern);
     }
 
-    void addMarkToPatternIdx(const char* mark, size_t after_idx = 1)
+    void addMarkToPatternIdx(const char* mark, size_t after_idx = 1) { addMarkToPatternIdx(std::string_view{mark}); }
-    {
-        addMarkToPatternIdx(std::string_view{mark});
-    }
 };
 
-
-
 }  // namespace mcc::utils