Refactor AppSettingValue into Variant (#789)

ComputationalBiomechanicsLab · Jun 27, 2024 · 54f70ea · 54f70ea
1 parent 008984d
commit 54f70ea
Show file tree

Hide file tree

Showing 22 changed files with 128 additions and 340 deletions.
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -27,6 +27,7 @@ on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
   plugin code sourced from the internet (e.g. SimTK.org)
 - Internal: Third-party dependencies were updated to their latest versions, where applicable
 - Internal: `AppConfig` was dropped and all uses of it were converted to `AppSettings` (#893)
+- Internal: `AppSettingValue` was refactored into a `Variant` (#789)
 
 
 ## [0.5.12] - 2024/04/29

diff --git a/src/OpenSimCreator/Graphics/CustomRenderingOptions.cpp b/src/OpenSimCreator/Graphics/CustomRenderingOptions.cpp
@@ -6,6 +6,8 @@
 #include <oscar/Utils/Algorithms.h>
 #include <oscar/Utils/CStringView.h>
 #include <oscar/Utils/EnumHelpers.h>
+#include <oscar/Variant/Variant.h>
+#include <oscar/Variant/VariantType.h>
 
 #include <cstddef>
 #include <cstdint>
@@ -72,21 +74,21 @@ void osc::CustomRenderingOptions::setDrawSelectionRims(bool v)
     SetOption(m_Flags, CustomRenderingOptionFlags::DrawSelectionRims, v);
 }
 
-void osc::CustomRenderingOptions::forEachOptionAsAppSettingValue(const std::function<void(std::string_view, const AppSettingValue&)>& callback) const
+void osc::CustomRenderingOptions::forEachOptionAsAppSettingValue(const std::function<void(std::string_view, const Variant&)>& callback) const
 {
     for (const auto& metadata : GetAllCustomRenderingOptionFlagsMetadata())
     {
-        callback(metadata.id, AppSettingValue{m_Flags & metadata.value});
+        callback(metadata.id, static_cast<bool>(m_Flags & metadata.value));
     }
 }
 
-void osc::CustomRenderingOptions::tryUpdFromValues(std::string_view keyPrefix, const std::unordered_map<std::string, AppSettingValue>& lut)
+void osc::CustomRenderingOptions::tryUpdFromValues(std::string_view keyPrefix, const std::unordered_map<std::string, Variant>& lut)
 {
     for (const auto& metadata : GetAllCustomRenderingOptionFlagsMetadata()) {
 
         std::string key = std::string{keyPrefix} + metadata.id;
-        if (const auto* v = lookup_or_nullptr(lut, key); v->type() == AppSettingValueType::Bool) {
-            SetOption(m_Flags, metadata.value, v->to_bool());
+        if (const auto* v = lookup_or_nullptr(lut, key); v->type() == VariantType::Bool) {
+            SetOption(m_Flags, metadata.value, v->to<bool>());
         }
     }
 }

diff --git a/src/OpenSimCreator/Graphics/CustomRenderingOptions.h b/src/OpenSimCreator/Graphics/CustomRenderingOptions.h
@@ -2,8 +2,8 @@
 
 #include <OpenSimCreator/Graphics/CustomRenderingOptionFlags.h>
 
-#include <oscar/Platform/AppSettingValue.h>
 #include <oscar/Utils/CStringView.h>
+#include <oscar/Variant/Variant.h>
 
 #include <cstddef>
 #include <cstdint>
@@ -34,8 +34,8 @@ namespace osc
         bool getDrawSelectionRims() const;
         void setDrawSelectionRims(bool);
 
-        void forEachOptionAsAppSettingValue(const std::function<void(std::string_view, const AppSettingValue&)>&) const;
-        void tryUpdFromValues(std::string_view keyPrefix, const std::unordered_map<std::string, AppSettingValue>&);
+        void forEachOptionAsAppSettingValue(const std::function<void(std::string_view, const Variant&)>&) const;
+        void tryUpdFromValues(std::string_view keyPrefix, const std::unordered_map<std::string, Variant>&);
 
         void applyTo(SceneRendererParams&) const;
 

diff --git a/src/OpenSimCreator/Graphics/ModelRendererParams.cpp b/src/OpenSimCreator/Graphics/ModelRendererParams.cpp
@@ -8,8 +8,8 @@
 #include <oscar/Graphics/Scene/SceneRendererParams.h>
 #include <oscar/Maths/PolarPerspectiveCamera.h>
 #include <oscar/Platform/AppSettings.h>
-#include <oscar/Platform/AppSettingValue.h>
 #include <oscar/Utils/Algorithms.h>
+#include <oscar/Variant/Variant.h>
 
 #include <string>
 #include <string_view>
@@ -19,13 +19,13 @@ using namespace osc;
 
 namespace
 {
-    std::unordered_map<std::string, AppSettingValue> ToValues(
+    std::unordered_map<std::string, Variant> ToValues(
         std::string_view prefix,
         const ModelRendererParams& params)
     {
-        std::unordered_map<std::string, AppSettingValue> rv;
+        std::unordered_map<std::string, Variant> rv;
         std::string subPrefix;
-        const auto callback = [&subPrefix, &rv](std::string_view subkey, AppSettingValue value)
+        const auto callback = [&subPrefix, &rv](std::string_view subkey, Variant value)
         {
             rv.insert_or_assign(subPrefix + std::string{subkey}, std::move(value));
         };
@@ -36,26 +36,26 @@ namespace
         params.overlayOptions.forEachOptionAsAppSettingValue(callback);
         subPrefix = std::string{prefix} + std::string{"graphics/"};
         params.renderingOptions.forEachOptionAsAppSettingValue(callback);
-        rv.insert_or_assign(std::string{prefix} + "light_color", AppSettingValue{params.lightColor});
-        rv.insert_or_assign(std::string{prefix} + "background_color", AppSettingValue{params.backgroundColor});
+        rv.insert_or_assign(std::string{prefix} + "light_color", params.lightColor);
+        rv.insert_or_assign(std::string{prefix} + "background_color", params.backgroundColor);
         // TODO: floorLocation
 
         return rv;
     }
 
     void UpdFromValues(
         std::string_view prefix,
-        const std::unordered_map<std::string, AppSettingValue>& values,
+        const std::unordered_map<std::string, Variant>& values,
         ModelRendererParams& params)
     {
         params.decorationOptions.tryUpdFromValues(std::string{prefix} + "decorations/", values);
         params.overlayOptions.tryUpdFromValues(std::string{prefix} + "overlays/", values);
         params.renderingOptions.tryUpdFromValues(std::string{prefix} + "graphics/", values);
         if (const auto* v = lookup_or_nullptr(values, std::string{prefix} + "light_color")) {
-            params.lightColor = v->to_color();
+            params.lightColor = v->to<Color>();
         }
         if (const auto* v = lookup_or_nullptr(values,std::string{prefix} + "background_color")) {
-            params.backgroundColor = v->to_color();
+            params.backgroundColor = v->to<Color>();
         }
         // TODO: floorLocation
     }
@@ -66,8 +66,7 @@ osc::ModelRendererParams::ModelRendererParams() :
     backgroundColor{SceneRendererParams::default_background_color()},
     floorLocation{SceneRendererParams::default_floor_location()},
     camera{create_camera_with_radius(5.0f)}
-{
-}
+{}
 
 void osc::UpdModelRendererParamsFrom(
     const AppSettings& settings,

diff --git a/src/OpenSimCreator/Graphics/OpenSimDecorationOptions.cpp b/src/OpenSimCreator/Graphics/OpenSimDecorationOptions.cpp
@@ -1,10 +1,10 @@
 #include "OpenSimDecorationOptions.h"
 
-#include <oscar/Platform/AppSettingValue.h>
-#include <oscar/Platform/AppSettingValueType.h>
 #include <oscar/Utils/Algorithms.h>
 #include <oscar/Utils/CStringView.h>
 #include <oscar/Utils/EnumHelpers.h>
+#include <oscar/Variant/Variant.h>
+#include <oscar/Variant/VariantType.h>
 
 #include <optional>
 #include <ranges>
@@ -154,22 +154,20 @@ void osc::OpenSimDecorationOptions::setShouldShowContactForces(bool v)
     SetOption(m_Flags, OpenSimDecorationOptionFlags::ShouldShowContactForces, v);
 }
 
-void osc::OpenSimDecorationOptions::forEachOptionAsAppSettingValue(const std::function<void(std::string_view, const AppSettingValue&)>& callback) const
+void osc::OpenSimDecorationOptions::forEachOptionAsAppSettingValue(const std::function<void(std::string_view, const Variant&)>& callback) const
 {
-    callback("muscle_decoration_style", AppSettingValue{GetMuscleDecorationStyleMetadata(m_MuscleDecorationStyle).id});
-    callback("muscle_coloring_style", AppSettingValue{GetMuscleColoringStyleMetadata(m_MuscleColoringStyle).id});
-    callback("muscle_sizing_style", AppSettingValue{GetMuscleSizingStyleMetadata(m_MuscleSizingStyle).id});
-    for (size_t i = 0; i < num_flags<OpenSimDecorationOptionFlags>(); ++i)
-    {
+    callback("muscle_decoration_style", GetMuscleDecorationStyleMetadata(m_MuscleDecorationStyle).id);
+    callback("muscle_coloring_style", GetMuscleColoringStyleMetadata(m_MuscleColoringStyle).id);
+    callback("muscle_sizing_style", GetMuscleSizingStyleMetadata(m_MuscleSizingStyle).id);
+    for (size_t i = 0; i < num_flags<OpenSimDecorationOptionFlags>(); ++i) {
         const auto& meta = GetIthOptionMetadata(i);
-        const bool v = m_Flags & GetIthOption(i);
-        callback(meta.id, AppSettingValue{v});
+        callback(meta.id, static_cast<bool>(m_Flags & GetIthOption(i)));
     }
 }
 
 void osc::OpenSimDecorationOptions::tryUpdFromValues(
     std::string_view prefix,
-    const std::unordered_map<std::string, AppSettingValue>& lut)
+    const std::unordered_map<std::string, Variant>& lut)
 {
     // looks up a single element in the lut
     auto lookup = [
@@ -183,39 +181,38 @@ void osc::OpenSimDecorationOptions::tryUpdFromValues(
         return lookup_or_nullptr(lut, buf);
     };
 
-    if (auto* appVal = lookup("muscle_decoration_style"); appVal->type() == AppSettingValueType::String)
+    if (auto* appVal = lookup("muscle_decoration_style"); appVal->type() == VariantType::String)
     {
         const auto metadata = GetAllMuscleDecorationStyleMetadata();
-        const auto it = rgs::find(metadata, appVal->to_string(), [](const auto& m) { return m.id; });
+        const auto it = rgs::find(metadata, appVal->to<std::string>(), [](const auto& m) { return m.id; });
         if (it != metadata.end()) {
             m_MuscleDecorationStyle = it->value;
         }
     }
 
-    if (auto* appVal = lookup("muscle_coloring_style"); appVal->type() == AppSettingValueType::String)
+    if (auto* appVal = lookup("muscle_coloring_style"); appVal->type() == VariantType::String)
     {
         const auto metadata = GetAllMuscleColoringStyleMetadata();
-        const auto it = rgs::find(metadata, appVal->to_string(), [](const auto& m) { return m.id; });
+        const auto it = rgs::find(metadata, appVal->to<std::string>(), [](const auto& m) { return m.id; });
         if (it != metadata.end()) {
             m_MuscleColoringStyle = it->value;
         }
     }
 
-    if (auto* appVal = lookup("muscle_sizing_style"); appVal->type() == AppSettingValueType::String)
+    if (auto* appVal = lookup("muscle_sizing_style"); appVal->type() == VariantType::String)
     {
         const auto metadata = GetAllMuscleSizingStyleMetadata();
-        const auto it = rgs::find(metadata, appVal->to_string(), [](const auto& m) { return m.id; });
+        const auto it = rgs::find(metadata, appVal->to<std::string>(), [](const auto& m) { return m.id; });
         if (it != metadata.end()) {
             m_MuscleSizingStyle = it->value;
         }
     }
 
-    for (size_t i = 0; i < num_flags<OpenSimDecorationOptionFlags>(); ++i)
-    {
+    for (size_t i = 0; i < num_flags<OpenSimDecorationOptionFlags>(); ++i) {
         const auto& metadata = GetIthOptionMetadata(i);
-        if (auto* appVal = lookup(metadata.id); appVal->type() == AppSettingValueType::Bool)
+        if (auto* appVal = lookup(metadata.id); appVal->type() == VariantType::Bool)
         {
-            const bool v = appVal->to_bool();
+            const bool v = appVal->to<bool>();
             SetOption(m_Flags, GetIthOption(i), v);
         }
     }

diff --git a/src/OpenSimCreator/Graphics/OpenSimDecorationOptions.h b/src/OpenSimCreator/Graphics/OpenSimDecorationOptions.h
@@ -6,6 +6,7 @@
 #include <OpenSimCreator/Graphics/OpenSimDecorationOptionFlags.h>
 
 #include <oscar/Utils/CStringView.h>
+#include <oscar/Variant/Variant.h>
 
 #include <cstddef>
 #include <functional>
@@ -62,8 +63,8 @@ namespace osc
         bool getShouldShowContactForces() const;
         void setShouldShowContactForces(bool);
 
-        void forEachOptionAsAppSettingValue(const std::function<void(std::string_view, const AppSettingValue&)>&) const;
-        void tryUpdFromValues(std::string_view keyPrefix, const std::unordered_map<std::string, AppSettingValue>&);
+        void forEachOptionAsAppSettingValue(const std::function<void(std::string_view, const Variant&)>&) const;
+        void tryUpdFromValues(std::string_view keyPrefix, const std::unordered_map<std::string, Variant>&);
 
         friend bool operator==(const OpenSimDecorationOptions&, const OpenSimDecorationOptions&) = default;
 

diff --git a/src/OpenSimCreator/Graphics/OverlayDecorationOptions.cpp b/src/OpenSimCreator/Graphics/OverlayDecorationOptions.cpp
@@ -1,10 +1,10 @@
 #include "OverlayDecorationOptions.h"
 
-#include <oscar/Platform/AppSettingValue.h>
-#include <oscar/Platform/AppSettingValueType.h>
 #include <oscar/Utils/Algorithms.h>
 #include <oscar/Utils/CStringView.h>
 #include <oscar/Utils/EnumHelpers.h>
+#include <oscar/Variant/Variant.h>
+#include <oscar/Variant/VariantType.h>
 
 #include <cstddef>
 
@@ -95,23 +95,22 @@ void osc::OverlayDecorationOptions::setDrawBVH(bool v)
     SetOption(m_Flags, OverlayDecorationOptionFlags::DrawBVH, v);
 }
 
-void osc::OverlayDecorationOptions::forEachOptionAsAppSettingValue(const std::function<void(std::string_view, const AppSettingValue&)>& callback) const
+void osc::OverlayDecorationOptions::forEachOptionAsAppSettingValue(const std::function<void(std::string_view, const Variant&)>& callback) const
 {
-    for (const auto& metadata : GetAllOverlayDecorationOptionFlagsMetadata())
-    {
-        callback(metadata.id, AppSettingValue{m_Flags & metadata.value});
+    for (const auto& metadata : GetAllOverlayDecorationOptionFlagsMetadata()) {
+        callback(metadata.id, static_cast<bool>(m_Flags & metadata.value));
     }
 }
 
-void osc::OverlayDecorationOptions::tryUpdFromValues(std::string_view keyPrefix, const std::unordered_map<std::string, AppSettingValue>& lut)
+void osc::OverlayDecorationOptions::tryUpdFromValues(std::string_view keyPrefix, const std::unordered_map<std::string, Variant>& lut)
 {
     for (size_t i = 0; i < num_flags<OverlayDecorationOptionFlags>(); ++i)
     {
         const auto& metadata = at(GetAllOverlayDecorationOptionFlagsMetadata(), i);
 
         const std::string key = std::string{keyPrefix}+metadata.id;
-        if (const auto* v = lookup_or_nullptr(lut, key); v and v->type() == osc::AppSettingValueType::Bool) {
-            SetOption(m_Flags, metadata.value, v->to_bool());
+        if (const auto* v = lookup_or_nullptr(lut, key); v and v->type() == VariantType::Bool) {
+            SetOption(m_Flags, metadata.value, v->to<bool>());
         }
     }
 }
diff --git a/src/OpenSimCreator/Graphics/OverlayDecorationOptions.h b/src/OpenSimCreator/Graphics/OverlayDecorationOptions.h
@@ -2,8 +2,8 @@
 
 #include <OpenSimCreator/Graphics/OverlayDecorationOptionFlags.h>
 
-#include <oscar/Platform/AppSettingValue.h>
 #include <oscar/Utils/CStringView.h>
+#include <oscar/Variant/Variant.h>
 
 #include <cstddef>
 #include <cstdint>
@@ -39,8 +39,8 @@ namespace osc
         bool getDrawBVH() const;
         void setDrawBVH(bool);
 
-        void forEachOptionAsAppSettingValue(const std::function<void(std::string_view, const AppSettingValue&)>&) const;
-        void tryUpdFromValues(std::string_view keyPrefix, const std::unordered_map<std::string, AppSettingValue>&);
+        void forEachOptionAsAppSettingValue(const std::function<void(std::string_view, const Variant&)>&) const;
+        void tryUpdFromValues(std::string_view keyPrefix, const std::unordered_map<std::string, Variant>&);
 
         friend bool operator==(const OverlayDecorationOptions&, const OverlayDecorationOptions&) = default;
 

diff --git a/src/OpenSimCreator/Platform/OpenSimCreatorApp.cpp b/src/OpenSimCreator/Platform/OpenSimCreatorApp.cpp
@@ -27,11 +27,13 @@
 #include <oscar_demos/OscarDemosTabRegistry.h>
 #include <oscar_learnopengl/LearnOpenGLTabRegistry.h>
 
+#include <array>
 #include <clocale>
 #include <filesystem>
 #include <locale>
 #include <memory>
 #include <string>
+#include <utility>
 
 using namespace osc::fd;
 using namespace osc;
@@ -40,6 +42,20 @@ namespace
 {
     OpenSimCreatorApp* g_opensimcreator_app_global = nullptr;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
 
+    constexpr auto c_default_panel_states = std::to_array<std::pair<const char*, bool>>({
+        {"panels/Actions/enabled", true},
+        {"panels/Navigator/enabled", true},
+        {"panels/Log/enabled", true},
+        {"panels/Properties/enabled", true},
+        {"panels/Selection Details/enabled", true},
+        {"panels/Simulation Details/enabled", false},
+        {"panels/Coordinates/enabled", true},
+        {"panels/Performance/enabled", false},
+        {"panels/Muscle Plot/enabled", false},
+        {"panels/Output Watches/enabled", false},
+        {"panels/Output Plots/enabled", false},
+    });
+
     // minor alias for setlocale so that any linter complaints about MT unsafety
     // are all deduped to this one source location
     //
@@ -198,17 +214,9 @@ namespace
 
     void InitializeOpenSimCreatorSpecificSettingDefaults(AppSettings& settings)
     {
-        settings.set_value("panels/Actions/enabled", AppSettingValue{true}, AppSettingScope::System);
-        settings.set_value("panels/Navigator/enabled", AppSettingValue{true}, AppSettingScope::System);
-        settings.set_value("panels/Log/enabled", AppSettingValue{true}, AppSettingScope::System);
-        settings.set_value("panels/Properties/enabled", AppSettingValue{true}, AppSettingScope::System);
-        settings.set_value("panels/Selection Details/enabled", AppSettingValue{true}, AppSettingScope::System);
-        settings.set_value("panels/Simulation Details/enabled", AppSettingValue{false}, AppSettingScope::System);
-        settings.set_value("panels/Coordinates/enabled", AppSettingValue{true}, AppSettingScope::System);
-        settings.set_value("panels/Performance/enabled", AppSettingValue{false}, AppSettingScope::System);
-        settings.set_value("panels/Muscle Plot/enabled", AppSettingValue{false}, AppSettingScope::System);
-        settings.set_value("panels/Output Watches/enabled", AppSettingValue{false}, AppSettingScope::System);
-        settings.set_value("panels/Output Plots/enabled", AppSettingValue{false}, AppSettingScope::System);
+        for (const auto& [setting_id, default_state] : c_default_panel_states) {
+            settings.set_value(setting_id, default_state, AppSettingScope::System);
+        }
     }
 }
 
@@ -267,7 +275,7 @@ osc::OpenSimCreatorApp::~OpenSimCreatorApp() noexcept
 std::string osc::OpenSimCreatorApp::docs_url() const
 {
     if (const auto runtime_url = settings().find_value("docs_url")) {
-        return runtime_url->to_string();
+        return runtime_url->to<std::string>();
     }
     else {
         return "https://docs.opensimcreator.com";

diff --git a/src/OpenSimCreator/UI/MainUIScreen.cpp b/src/OpenSimCreator/UI/MainUIScreen.cpp
@@ -59,11 +59,11 @@ namespace
         const ParentPtr<ITabHost>& api)
     {
         if (auto maybeRequestedTab = settings.find_value("initial_tab")) {
-            if (std::optional<TabRegistryEntry> maybeEntry = tabRegistry.find_by_name(maybeRequestedTab->to_string())) {
+            if (std::optional<TabRegistryEntry> maybeEntry = tabRegistry.find_by_name(maybeRequestedTab->to<std::string>())) {
                 return maybeEntry->construct_tab(api);
             }
 
-            log_warn("%s: cannot find a tab with this name in the tab registry: ignoring", maybeRequestedTab->to_string().c_str());
+            log_warn("%s: cannot find a tab with this name in the tab registry: ignoring", maybeRequestedTab->to<std::string>().c_str());
             log_warn("available tabs are:");
             for (auto&& tabRegistryEntry : tabRegistry) {
                 log_warn("    %s", tabRegistryEntry.name().c_str());
@@ -386,7 +386,7 @@ class osc::MainUIScreen::Impl final :
     void implAddUserOutputExtractor(const OutputExtractor& output) final
     {
         m_UserOutputExtractors.push_back(output);
-        App::upd().upd_settings().set_value("panels/Output Watches/enabled", AppSettingValue{true});
+        App::upd().upd_settings().set_value("panels/Output Watches/enabled", true);
     }
 
     void implRemoveUserOutputExtractor(int idx) final