desktop/layerRule: use variants for storage internally

Improves storage: less dynamic parsing, immediate config errors, faster.

1 files changed, 71 insertions, 3 deletions

diff --git a/src/desktop/rule/layerRule/LayerRule.cpp b/src/desktop/rule/layerRule/LayerRule.cpp
index d1c472b0..10120d7f 100644
--- a/src/desktop/rule/layerRule/LayerRule.cpp
+++ b/src/desktop/rule/layerRule/LayerRule.cpp
@@ -1,10 +1,72 @@
 #include "LayerRule.hpp"
 #include "../../../debug/log/Logger.hpp"
+#include "../../../helpers/MiscFunctions.hpp"
 #include "../../view/LayerSurface.hpp"
 
+#include <algorithm>
+#include <format>
+
 using namespace Desktop;
 using namespace Desktop::Rule;
 
+static std::expected<int64_t, std::string> parseInt(std::string_view effectName, const std::string& raw) {
+    try {
+        return std::stoll(raw);
+    } catch (std::exception& e) { return std::unexpected(std::format("{} rule \"{}\" failed with: {}", effectName, raw, e.what())); }
+}
+
+static std::expected<float, std::string> parseFloat(std::string_view effectName, const std::string& raw) {
+    try {
+        return std::stof(raw);
+    } catch (std::exception& e) { return std::unexpected(std::format("{} rule \"{}\" failed with: {}", effectName, raw, e.what())); }
+}
+
+static std::expected<int64_t, std::string> parseAboveLock(const std::string& raw) {
+    try {
+        return sc<int64_t>(std::clamp(std::stoull(raw), 0ULL, 2ULL));
+    } catch (std::exception& e) { return std::unexpected(std::format("above_lock rule \"{}\" failed with: {}", raw, e.what())); }
+}
+
+static std::expected<LayerRuleEffectValue, std::string> parseLayerRuleEffect(CLayerRuleEffectContainer::storageType e, const std::string& raw) {
+    if (layerEffects()->isEffectDynamic(e))
+        return std::string{raw};
+
+    const auto EFFECT_NAME = layerEffects()->get(e);
+
+    switch (e) {
+        default: return std::unexpected(std::format("unknown layer rule effect {}", e));
+
+        case LAYER_RULE_EFFECT_NONE: return std::monostate{};
+
+        case LAYER_RULE_EFFECT_NO_ANIM:
+        case LAYER_RULE_EFFECT_BLUR:
+        case LAYER_RULE_EFFECT_BLUR_POPUPS:
+        case LAYER_RULE_EFFECT_DIM_AROUND:
+        case LAYER_RULE_EFFECT_XRAY:
+        case LAYER_RULE_EFFECT_NO_SCREEN_SHARE: return truthy(raw);
+
+        case LAYER_RULE_EFFECT_ORDER: {
+            auto parsed = parseInt(EFFECT_NAME, raw);
+            if (!parsed)
+                return std::unexpected(parsed.error());
+            return *parsed;
+        }
+        case LAYER_RULE_EFFECT_ABOVE_LOCK: {
+            auto parsed = parseAboveLock(raw);
+            if (!parsed)
+                return std::unexpected(parsed.error());
+            return *parsed;
+        }
+        case LAYER_RULE_EFFECT_IGNORE_ALPHA: {
+            auto parsed = parseFloat(EFFECT_NAME, raw);
+            if (!parsed)
+                return std::unexpected(parsed.error());
+            return std::clamp(*parsed, 0.F, 1.F);
+        }
+        case LAYER_RULE_EFFECT_ANIMATION: return std::string{raw};
+    }
+}
+
 CLayerRule::CLayerRule(const std::string& name) : IRule(name) {
     ;
 }
@@ -13,11 +75,17 @@ eRuleType CLayerRule::type() {
     return RULE_TYPE_LAYER;
 }
 
-void CLayerRule::addEffect(CLayerRule::storageType e, const std::string& result) {
-    m_effects.emplace_back(std::make_pair<>(e, result));
+std::expected<void, std::string> CLayerRule::addEffect(CLayerRule::storageType e, const std::string& result) {
+    auto parsed = parseLayerRuleEffect(e, result);
+    if (!parsed)
+        return std::unexpected(parsed.error());
+
+    m_effects.emplace_back(SLayerRuleEffect{.key = e, .raw = result, .value = std::move(*parsed)});
+
+    return {};
 }
 
-const std::vector<std::pair<CLayerRule::storageType, std::string>>& CLayerRule::effects() {
+const std::vector<SLayerRuleEffect>& CLayerRule::effects() {
     return m_effects;
 }