...

cxx/mcc_mount_concepts.h

@@ -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_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_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