Config system v1

Roughly inspired by what I've learned from my work on Space Station 14, without some of the unnecessary cruft and complexity.

Implementation is relatively simple once I figured out all the template order shenanigans.

src/dusk/config.cpp

@@ -0,0 +1,230 @@
+#include "dusk/config.hpp"
+#include "SDL3/SDL_filesystem.h"
+#include "SDL3/SDL_iostream.h"
+#include "dusk/appname.hpp"
+#include "dusk/scope.hpp"
+#include "fmt/format.h"
+#include "nlohmann/json.hpp"
+#include "absl/container/flat_hash_map.h"
+
+#include "aurora/lib/logging.hpp"
+#include "dusk/io.hpp"
+
+#include <limits>
+#include <string>
+
+using namespace dusk::config;
+
+constexpr auto ConfigFileName = "config.json";
+
+using json = nlohmann::json;
+
+aurora::Module DuskConfigLog("dusk::config");
+
+static absl::flat_hash_map<std::string_view, ConfigVarBase*> RegisteredConfigVars;
+static bool RegistrationDone;
+
+static std::string GetConfigJsonPath() {
+    dusk::ScopeValue folder(SDL_GetPrefPath(dusk::OrgName, dusk::AppName), SDL_free);
+    if (folder.value == nullptr) {
+        DuskConfigLog.error("Failed to get user preference path: %s", SDL_GetError());
+        return "";
+    }
+
+    return fmt::format("{}{}", folder.value, ConfigFileName);
+}
+
+ConfigVarBase::ConfigVarBase(const char* name, const ConfigImplBase* impl) : name(name), registered(false), layer(ConfigVarLayer::Default), impl(impl) {
+}
+
+const char* ConfigVarBase::getName() const noexcept {
+    return name;
+}
+
+const ConfigImplBase* ConfigVarBase::getImpl() const noexcept {
+    return impl;
+}
+
+template<ConfigValue T>
+void ConfigImpl<T>::loadFromJson(ConfigVar<T>& cVar, const json& jsonValue) {
+    cVar.setValue(jsonValue.get<T>(), false);
+}
+
+template<ConfigValue T>
+nlohmann::json ConfigImpl<T>::dumpToJson(const ConfigVar<T>& cVar) {
+    return cVar.getValue();
+}
+
+template<ConfigValue T> requires std::is_integral_v<T> && std::is_signed_v<T>
+static void loadFromArgImpl(ConfigVar<T>& cVar, const std::string_view stringValue) {
+    const std::string str(stringValue);
+    const auto result = std::stoll(str);
+    if (result >= std::numeric_limits<T>::min() && result <= std::numeric_limits<T>::max()) {
+        cVar.setOverrideValue(result);
+    } else {
+        throw std::out_of_range("Value is too large");
+    }
+}
+
+template<ConfigValue T> requires std::is_integral_v<T> && std::is_unsigned_v<T>
+static void loadFromArgImpl(ConfigVar<T>& cVar, const std::string_view stringValue) {
+    const std::string str(stringValue);
+    const auto result = std::stoull(str);
+    if (result <= std::numeric_limits<T>::max()) {
+        cVar.setOverrideValue(result);
+    } else {
+        throw std::out_of_range("Value is too large");
+    }
+}
+
+static void loadFromArgImpl(ConfigVar<f32>& cVar, const std::string_view stringValue) {
+    const std::string str(stringValue);
+    const auto result = std::stof(str);
+    cVar.setOverrideValue(result);
+}
+
+static void loadFromArgImpl(ConfigVar<f64>& cVar, const std::string_view stringValue) {
+    const std::string str(stringValue);
+    const auto result = std::stod(str);
+    cVar.setOverrideValue(result);
+}
+
+static void loadFromArgImpl(ConfigVar<std::string>& cVar, const std::string_view stringValue) {
+    cVar.setOverrideValue(std::string(stringValue));
+}
+
+template<ConfigValue T>
+void ConfigImpl<T>::loadFromArg(ConfigVar<T>& cVar, const std::string_view stringValue) {
+    loadFromArgImpl(cVar, stringValue);
+}
+
+template<>
+void ConfigImpl<bool>::loadFromArg(ConfigVar<bool>& cVar, const std::string_view stringValue) {
+    if (stringValue == "1" || stringValue == "TRUE" || stringValue == "true" || stringValue == "True") {
+        cVar.setOverrideValue(true);
+    } else if (stringValue == "0" || stringValue == "FALSE" || stringValue == "false" || stringValue == "False") {
+        cVar.setOverrideValue(false);
+    } else {
+        throw InvalidConfigError("Value cannot be parsed as boolean");
+    }
+}
+
+// My IDE is convinced this namespace is necessary. It shouldn't be AFAICT?
+namespace dusk::config {
+    template class ConfigImpl<bool>;
+    template class ConfigImpl<s8>;
+    template class ConfigImpl<u8>;
+    template class ConfigImpl<s16>;
+    template class ConfigImpl<u16>;
+    template class ConfigImpl<s32>;
+    template class ConfigImpl<u32>;
+    template class ConfigImpl<s64>;
+    template class ConfigImpl<u64>;
+    template class ConfigImpl<f32>;
+    template class ConfigImpl<f64>;
+    template class ConfigImpl<std::string>;
+}
+
+void dusk::config::Register(ConfigVarBase& configVar) {
+    const auto& name = configVar.getName();
+    if (RegistrationDone) {
+        DuskConfigLog.fatal("Tried to register CVar {} after registrations closed!", name);
+    }
+
+    if (RegisteredConfigVars.contains(name)) {
+        DuskConfigLog.fatal("Tried to register CVar {} twice!", name);
+    }
+
+    RegisteredConfigVars[name] = &configVar;
+    configVar.markRegistered();
+}
+
+void ConfigVarBase::markRegistered() {
+    if (registered)
+        abort();
+
+    registered = true;
+}
+
+void dusk::config::FinishRegistration() {
+    RegistrationDone = true;
+}
+
+void dusk::config::LoadFromUserPreferences() {
+    const auto configPath = GetConfigJsonPath();
+    if (configPath.empty()) {
+        return;
+    }
+    LoadFromFileName(configPath.c_str());
+}
+
+static void LoadFromPath(const char* path) {
+    auto data = dusk::io::FileStream::ReadAllBytes(path);
+
+    json j = json::parse(data);
+    if (!j.is_object()) {
+        DuskConfigLog.error("Config JSON is not an object!");
+        return;
+    }
+
+    for (const auto& el : j.items()) {
+        const auto& key = el.key();
+        auto configVar = RegisteredConfigVars.find(key);
+        if (configVar == RegisteredConfigVars.end()) {
+            DuskConfigLog.error("Unknown key '{}' found in config!", key);
+            continue;
+        }
+
+        try {
+            configVar->second->getImpl()->loadFromJson(*configVar->second, el.value());
+        } catch (std::exception& e) {
+            DuskConfigLog.error("Failed to load key '{}' from config: {}", key, e.what());
+        }
+    }
+}
+
+void dusk::config::LoadFromFileName(const char* path) {
+    if (!RegistrationDone) {
+        DuskConfigLog.fatal("Registration not finished yet!");
+    }
+
+    DuskConfigLog.info("Loading config from '{}'", path);
+
+    try {
+        LoadFromPath(path);
+    } catch (const std::system_error& e) {
+        if (e.code() == std::errc::no_such_file_or_directory) {
+            DuskConfigLog.info("Config file did not exist, staying with defaults");
+        } else {
+            DuskConfigLog.error("Failed to load from config! {}", e.what());
+        }
+    }
+}
+
+void dusk::config::Save() {
+    const auto configPath = GetConfigJsonPath();
+    if (configPath.empty()) {
+        return;
+    }
+
+    DuskConfigLog.info("Saving config to '{}'", configPath);
+
+    json j;
+
+    for (const auto& pair : RegisteredConfigVars) {
+        if (pair.second->getLayer() == ConfigVarLayer::Value) {
+            j[pair.first] = pair.second->getImpl()->dumpToJson(*pair.second);
+        }
+    }
+
+    io::FileStream::WriteAllText(configPath.c_str(), j.dump(4));
+}
+
+ConfigVarBase* dusk::config::GetConfigVar(std::string_view name) {
+    const auto configVar = RegisteredConfigVars.find(name);
+    if (configVar != RegisteredConfigVars.end()) {
+        return configVar->second;
+    }
+
+    return nullptr;
+}