ConfigManager.h

#pragma once
 
// Standard.
#include <variant>
#include <optional>
#include <set>
#include <filesystem>
 
// Custom.
#include "misc/Error.h"
 
// External.
#include "toml11/single_include/toml.hpp"
 
namespace ne {
    enum class ConfigCategory {
        PROGRESS, // used to store player's game progress (uses backup files under the hood)
        SETTINGS  // used to store player's game specific settings (no backup files)
    };
 
    class ConfigManager {
    public:
        ConfigManager() = default;
 
        ConfigManager(const ConfigManager&) = delete;
        ConfigManager& operator=(const ConfigManager&) = delete;
 
        static std::string getConfigFormatExtension();
 
        static std::string getBackupFileExtension();
 
        static std::set<std::string> getAllFileNames(ConfigCategory category);
 
        static std::string getFreeProgressProfileName();
 
        static std::filesystem::path getCategoryDirectory(ConfigCategory category);
 
        [[nodiscard]] static std::optional<Error>
        removeFile(ConfigCategory category, std::string_view sFileName);
 
        static void removeFile(std::filesystem::path pathToConfigFile);
 
        [[nodiscard]] std::optional<Error> loadFile(ConfigCategory category, std::string_view sFileName);
 
        [[nodiscard]] std::optional<Error> loadFile(std::filesystem::path pathToConfigFile);
 
        template <typename T>
        T getValue(std::string_view sSection, std::string_view sKey, T defaultValue) const;
 
        template <typename T>
        std::optional<T> getValueOrFail(std::string_view sSection, std::string_view sKey) const;
 
        std::vector<std::string> getAllSections();
 
        std::variant<std::vector<std::string>, Error> getAllKeysOfSection(std::string_view sSection) const;
 
        template <typename T>
        void
        setValue(std::string_view sSection, std::string_view sKey, T value, std::string_view sComment = "");
 
        [[nodiscard]] std::optional<Error> saveFile(ConfigCategory category, std::string_view sFileName);
 
        [[nodiscard]] std::optional<Error>
        saveFile(std::filesystem::path pathToConfigFile, bool bEnableBackup);
 
        std::filesystem::path getFilePath() const;
 
    private:
        static std::variant<std::filesystem::path, Error>
        constructFilePath(ConfigCategory category, std::string_view sFileName);
 
        static std::string generateFreeFileName(
            const std::set<std::string>& usedFileNames, const std::string& sFileNamePrefix = "");
 
        toml::value tomlData;
 
        std::filesystem::path filePath;
 
        inline static const char* sBackupFileExtension = ".old";
    };
 
    template <typename T>
    T ConfigManager::getValue(std::string_view sSection, std::string_view sKey, T defaultValue) const {
        if (sSection.empty()) {
            return toml::find_or(tomlData, sKey.data(), defaultValue);
        } else {
            return toml::find_or(tomlData, sSection.data(), sKey.data(), defaultValue);
        }
    }
 
    template <typename T>
    void ConfigManager::setValue(
        std::string_view sSection, std::string_view sKey, T value, std::string_view sComment) {
        if (sSection.empty()) {
            if (sComment.empty()) {
                tomlData[sKey.data()] = toml::value(value);
            } else {
                tomlData[sKey.data()] = toml::value(value, {sComment.data()});
            }
        } else {
            if (sComment.empty()) {
                tomlData[sSection.data()][sKey.data()] = toml::value(value);
            } else {
                tomlData[sSection.data()][sKey.data()] = toml::value(value, {sComment.data()});
            }
        }
    }
 
    template <typename T>
    std::optional<T> ConfigManager::getValueOrFail(std::string_view sSection, std::string_view sKey) const {
        try {
            if (sSection.empty()) {
                return toml::find<T>(tomlData, sKey.data());
            } else {
                return toml::find<T>(tomlData, sSection.data(), sKey.data());
            }
        } catch (...) {
            return {};
        }
    }
} // namespace ne