summaryrefslogtreecommitdiffstats
path: root/src/common/settings_setting.h
diff options
context:
space:
mode:
Diffstat (limited to 'src/common/settings_setting.h')
-rw-r--r--src/common/settings_setting.h413
1 files changed, 413 insertions, 0 deletions
diff --git a/src/common/settings_setting.h b/src/common/settings_setting.h
new file mode 100644
index 000000000..f226e38d4
--- /dev/null
+++ b/src/common/settings_setting.h
@@ -0,0 +1,413 @@
+#pragma once
+
+#include <map>
+#include <optional>
+#include <string>
+#include <typeindex>
+#include <typeinfo>
+#include "common/common_types.h"
+#include "common/settings_common.h"
+#include "common/settings_enums.h"
+
+namespace Settings {
+
+/** The Setting class is a simple resource manager. It defines a label and default value
+ * alongside the actual value of the setting for simpler and less-error prone use with frontend
+ * configurations. Specifying a default value and label is required. A minimum and maximum range
+ * can be specified for sanitization.
+ */
+template <typename Type, bool ranged = false>
+class Setting : public BasicSetting {
+protected:
+ Setting() = default;
+
+ /**
+ * Only sets the setting to the given initializer, leaving the other members to their default
+ * initializers.
+ *
+ * @param global_val Initial value of the setting
+ */
+ explicit Setting(const Type& val)
+ : value{val},
+ default_value{}, maximum{}, minimum{}, label{}, category{Category::Miscellaneous}, id{} {}
+
+public:
+ /**
+ * Sets a default value, label, and setting value.
+ *
+ * @param linkage Setting registry
+ * @param default_val Initial value of the setting, and default value of the setting
+ * @param name Label for the setting
+ * @param category_ Category of the setting AKA INI group
+ */
+ explicit Setting(Linkage& linkage, const Type& default_val, const std::string& name,
+ enum Category category_, bool save_ = true, bool runtime_modifiable_ = false)
+ requires(!ranged)
+ : value{default_val}, default_value{default_val}, label{name}, category{category_},
+ id{linkage.count}, save{save_}, runtime_modifiable{runtime_modifiable_} {
+ linkage.by_category[category].push_front(this);
+ linkage.count++;
+ }
+ virtual ~Setting() = default;
+
+ /**
+ * Sets a default value, minimum value, maximum value, and label.
+ *
+ * @param linkage Setting registry
+ * @param default_val Initial value of the setting, and default value of the setting
+ * @param min_val Sets the minimum allowed value of the setting
+ * @param max_val Sets the maximum allowed value of the setting
+ * @param name Label for the setting
+ * @param category_ Category of the setting AKA INI group
+ */
+ explicit Setting(Linkage& linkage, const Type& default_val, const Type& min_val,
+ const Type& max_val, const std::string& name, enum Category category_,
+ bool save_ = true, bool runtime_modifiable_ = false)
+ requires(ranged)
+ : value{default_val}, default_value{default_val}, maximum{max_val}, minimum{min_val},
+ label{name}, category{category_}, id{linkage.count}, save{save_},
+ runtime_modifiable{runtime_modifiable_} {
+ linkage.by_category[category].push_front(this);
+ linkage.count++;
+ }
+
+ /**
+ * Returns a reference to the setting's value.
+ *
+ * @returns A reference to the setting
+ */
+ [[nodiscard]] virtual const Type& GetValue() const {
+ return value;
+ }
+
+ /**
+ * Sets the setting to the given value.
+ *
+ * @param val The desired value
+ */
+ virtual void SetValue(const Type& val) {
+ Type temp{ranged ? std::clamp(val, minimum, maximum) : val};
+ std::swap(value, temp);
+ }
+
+ /**
+ * Returns the value that this setting was created with.
+ *
+ * @returns A reference to the default value
+ */
+ [[nodiscard]] const Type& GetDefault() const {
+ return default_value;
+ }
+
+ /**
+ * Returns the label this setting was created with.
+ *
+ * @returns A reference to the label
+ */
+ [[nodiscard]] const std::string& GetLabel() const override {
+ return label;
+ }
+
+ /**
+ * Returns the setting's category AKA INI group.
+ *
+ * @returns The setting's category
+ */
+ [[nodiscard]] enum Category Category() const override {
+ return category;
+ }
+
+ [[nodiscard]] bool RuntimeModfiable() const override {
+ return runtime_modifiable;
+ }
+
+ [[nodiscard]] constexpr bool IsEnum() const override {
+ return std::is_enum<Type>::value;
+ }
+
+ /**
+ * Returns whether the current setting is Switchable.
+ *
+ * @returns If the setting is a SwitchableSetting
+ */
+ [[nodiscard]] virtual constexpr bool Switchable() const override {
+ return false;
+ }
+
+protected:
+ std::string ToString(const Type& value_) const {
+ if constexpr (std::is_same<Type, std::string>()) {
+ return value_;
+ } else if constexpr (std::is_same<Type, std::optional<u32>>()) {
+ return value_.has_value() ? std::to_string(*value_) : "none";
+ } else if constexpr (std::is_same<Type, bool>()) {
+ return value_ ? "true" : "false";
+ } else if (std::is_same<Type, AudioEngine>()) {
+ return CanonicalizeEnum(value_);
+ } else {
+ return std::to_string(static_cast<u64>(value_));
+ }
+ }
+
+public:
+ /**
+ * Converts the value of the setting to a std::string. Respects the global state if the setting
+ * has one.
+ *
+ * @returns The current setting as a std::string
+ */
+ std::string ToString() const override {
+ return ToString(this->GetValue());
+ }
+
+ /**
+ * Returns the default value of the setting as a std::string.
+ *
+ * @returns The default value as a string.
+ */
+ std::string DefaultToString() const override {
+ return ToString(default_value);
+ }
+
+ /**
+ * Assigns a value to the setting.
+ *
+ * @param val The desired setting value
+ *
+ * @returns A reference to the setting
+ */
+ virtual const Type& operator=(const Type& val) {
+ Type temp{ranged ? std::clamp(val, minimum, maximum) : val};
+ std::swap(value, temp);
+ return value;
+ }
+
+ /**
+ * Returns a reference to the setting.
+ *
+ * @returns A reference to the setting
+ */
+ explicit virtual operator const Type&() const {
+ return value;
+ }
+
+ /**
+ * Converts the given value to the Setting's type of value. Uses SetValue to enter the setting,
+ * thus respecting its constraints.
+ *
+ * @param input The desired value
+ */
+ void LoadString(const std::string& input) override {
+ if (input.empty()) {
+ this->SetValue(this->GetDefault());
+ return;
+ }
+ try {
+ if constexpr (std::is_same<Type, std::string>()) {
+ this->SetValue(input);
+ } else if constexpr (std::is_same<Type, std::optional<u32>>()) {
+ this->SetValue(static_cast<u32>(std::stoul(input)));
+ } else if constexpr (std::is_same<Type, bool>()) {
+ this->SetValue(input == "true");
+ } else if constexpr (std::is_same<Type, AudioEngine>()) {
+ this->SetValue(ToEnum<Type>(input));
+ } else {
+ this->SetValue(static_cast<Type>(std::stoll(input)));
+ }
+ } catch (std::invalid_argument) {
+ this->SetValue(this->GetDefault());
+ }
+ }
+
+ [[nodiscard]] std::string constexpr Canonicalize() const override {
+ if constexpr (std::is_enum<Type>::value) {
+ return CanonicalizeEnum(this->GetValue());
+ }
+ return ToString(this->GetValue());
+ }
+
+ /**
+ * Returns the save preference of the setting i.e. when saving or reading the setting from a
+ * frontend, whether this setting should be skipped.
+ *
+ * @returns The save preference
+ */
+ virtual bool Save() const override {
+ return save;
+ }
+
+ /**
+ * Gives us another way to identify the setting without having to go through a string.
+ *
+ * @returns the type_index of the setting's type
+ */
+ virtual std::type_index TypeId() const override {
+ return std::type_index(typeid(Type));
+ }
+
+ virtual constexpr u32 Id() const override {
+ return id;
+ }
+
+ virtual std::string MinVal() const override {
+ return this->ToString(minimum);
+ }
+ virtual std::string MaxVal() const override {
+ return this->ToString(maximum);
+ }
+
+protected:
+ Type value{}; ///< The setting
+ const Type default_value{}; ///< The default value
+ const Type maximum{}; ///< Maximum allowed value of the setting
+ const Type minimum{}; ///< Minimum allowed value of the setting
+ const std::string label{}; ///< The setting's label
+ const enum Category category; ///< The setting's category AKA INI group
+ const u32 id;
+ bool save;
+ bool runtime_modifiable;
+};
+
+/**
+ * The SwitchableSetting class is a slightly more complex version of the Setting class. This adds a
+ * custom setting to switch to when a guest application specifically requires it. The effect is that
+ * other components of the emulator can access the setting's intended value without any need for the
+ * component to ask whether the custom or global setting is needed at the moment.
+ *
+ * By default, the global setting is used.
+ */
+template <typename Type, bool ranged = false>
+class SwitchableSetting : virtual public Setting<Type, ranged> {
+public:
+ /**
+ * Sets a default value, label, and setting value.
+ *
+ * @param linkage Setting registry
+ * @param default_val Initial value of the setting, and default value of the setting
+ * @param name Label for the setting
+ * @param category_ Category of the setting AKA INI group
+ */
+ explicit SwitchableSetting(Linkage& linkage, const Type& default_val, const std::string& name,
+ Category category, bool save = true, bool runtime_modifiable = false)
+ requires(!ranged)
+ : Setting<Type, false>{linkage, default_val, name, category, save, runtime_modifiable} {
+ linkage.restore_functions.emplace_back([this]() { this->SetGlobal(true); });
+ }
+ virtual ~SwitchableSetting() = default;
+
+ /**
+ * Sets a default value, minimum value, maximum value, and label.
+ *
+ * @param linkage Setting registry
+ * @param default_val Initial value of the setting, and default value of the setting
+ * @param min_val Sets the minimum allowed value of the setting
+ * @param max_val Sets the maximum allowed value of the setting
+ * @param name Label for the setting
+ * @param category_ Category of the setting AKA INI group
+ */
+ explicit SwitchableSetting(Linkage& linkage, const Type& default_val, const Type& min_val,
+ const Type& max_val, const std::string& name, Category category,
+ bool save = true, bool runtime_modifiable = false)
+ requires(ranged)
+ : Setting<Type, true>{linkage, default_val, min_val, max_val,
+ name, category, save, runtime_modifiable} {
+ linkage.restore_functions.emplace_back([this]() { this->SetGlobal(true); });
+ }
+
+ /**
+ * Tells this setting to represent either the global or custom setting when other member
+ * functions are used.
+ *
+ * @param to_global Whether to use the global or custom setting.
+ */
+ void SetGlobal(bool to_global) override {
+ use_global = to_global;
+ }
+
+ /**
+ * Returns whether this setting is using the global setting or not.
+ *
+ * @returns The global state
+ */
+ [[nodiscard]] bool UsingGlobal() const override {
+ return use_global;
+ }
+
+ /**
+ * Returns either the global or custom setting depending on the values of this setting's global
+ * state or if the global value was specifically requested.
+ *
+ * @param need_global Request global value regardless of setting's state; defaults to false
+ *
+ * @returns The required value of the setting
+ */
+ [[nodiscard]] virtual const Type& GetValue() const override {
+ if (use_global) {
+ return this->value;
+ }
+ return custom;
+ }
+ [[nodiscard]] virtual const Type& GetValue(bool need_global) const {
+ if (use_global || need_global) {
+ return this->value;
+ }
+ return custom;
+ }
+
+ /**
+ * Sets the current setting value depending on the global state.
+ *
+ * @param val The new value
+ */
+ void SetValue(const Type& val) override {
+ Type temp{ranged ? std::clamp(val, this->minimum, this->maximum) : val};
+ if (use_global) {
+ std::swap(this->value, temp);
+ } else {
+ std::swap(custom, temp);
+ }
+ }
+
+ [[nodiscard]] virtual constexpr bool Switchable() const override {
+ return true;
+ }
+
+ [[nodiscard]] virtual std::string ToStringGlobal() const override {
+ return this->ToString(this->value);
+ }
+
+ /**
+ * Assigns the current setting value depending on the global state.
+ *
+ * @param val The new value
+ *
+ * @returns A reference to the current setting value
+ */
+ const Type& operator=(const Type& val) override {
+ Type temp{ranged ? std::clamp(val, this->minimum, this->maximum) : val};
+ if (use_global) {
+ std::swap(this->value, temp);
+ return this->value;
+ }
+ std::swap(custom, temp);
+ return custom;
+ }
+
+ /**
+ * Returns the current setting value depending on the global state.
+ *
+ * @returns A reference to the current setting value
+ */
+ virtual explicit operator const Type&() const override {
+ if (use_global) {
+ return this->value;
+ }
+ return custom;
+ }
+
+protected:
+ bool use_global{true}; ///< The setting's global state
+ Type custom{}; ///< The custom value of the setting
+};
+
+} // namespace Settings