Merge pull request #11492 from lat9nq/c-numeric-conversions

general: Remove uncaught usages of C++ string number conversions

src/common/settings_common.h

@@ -225,6 +225,16 @@ public:
      */
     [[nodiscard]] virtual constexpr u32 EnumIndex() const = 0;
 
+    /**
+     * @returns True if the underlying type is a floating point storage
+     */
+    [[nodiscard]] virtual constexpr bool IsFloatingPoint() const = 0;
+
+    /**
+     * @returns True if the underlying type is an integer storage
+     */
+    [[nodiscard]] virtual constexpr bool IsIntegral() const = 0;
+
     /*
      * Switchable settings
      */

src/common/settings_setting.h

@@ -10,6 +10,7 @@
 #include <string>
 #include <typeindex>
 #include <typeinfo>
+#include <fmt/core.h>
 #include "common/common_types.h"
 #include "common/settings_common.h"
 #include "common/settings_enums.h"
@@ -115,8 +116,12 @@ protected:
         } else if constexpr (std::is_same_v<Type, AudioEngine>) {
             // Compatibility with old AudioEngine setting being a string
             return CanonicalizeEnum(value_);
+        } else if constexpr (std::is_floating_point_v<Type>) {
+            return fmt::format("{:f}", value_);
+        } else if constexpr (std::is_enum_v<Type>) {
+            return std::to_string(static_cast<u32>(value_));
         } else {
-            return std::to_string(static_cast<u64>(value_));
+            return std::to_string(value_);
         }
     }
 
@@ -180,13 +185,15 @@ public:
                 this->SetValue(static_cast<u32>(std::stoul(input)));
             } else if constexpr (std::is_same_v<Type, bool>) {
                 this->SetValue(input == "true");
-            } else if constexpr (std::is_same_v<Type, AudioEngine>) {
-                this->SetValue(ToEnum<Type>(input));
+            } else if constexpr (std::is_same_v<Type, float>) {
+                this->SetValue(std::stof(input));
             } else {
                 this->SetValue(static_cast<Type>(std::stoll(input)));
             }
         } catch (std::invalid_argument&) {
             this->SetValue(this->GetDefault());
+        } catch (std::out_of_range&) {
+            this->SetValue(this->GetDefault());
         }
     }
 
@@ -215,11 +222,27 @@ public:
         }
     }
 
+    [[nodiscard]] constexpr bool IsFloatingPoint() const final {
+        return std::is_floating_point_v<Type>;
+    }
+
+    [[nodiscard]] constexpr bool IsIntegral() const final {
+        return std::is_integral_v<Type>;
+    }
+
     [[nodiscard]] std::string MinVal() const override final {
-        return this->ToString(minimum);
+        if constexpr (std::is_arithmetic_v<Type> && !ranged) {
+            return this->ToString(std::numeric_limits<Type>::min());
+        } else {
+            return this->ToString(minimum);
+        }
     }
     [[nodiscard]] std::string MaxVal() const override final {
-        return this->ToString(maximum);
+        if constexpr (std::is_arithmetic_v<Type> && !ranged) {
+            return this->ToString(std::numeric_limits<Type>::max());
+        } else {
+            return this->ToString(maximum);
+        }
     }
 
     [[nodiscard]] constexpr bool Ranged() const override {