settings.hpp

Go to the documentation of this file.

 
#pragma once
#include <array>
#include <cstdint>
#include <deque>
#include <filesystem>
#include <functional>
#include <mutex>
#include <optional>
#include <string>
#include <string_view>
#include <toast/export.hpp>
#include <unordered_map>
#include <variant>
#include <vector>
 
namespace toast::settings {

enum class Type : uint8_t {
  boolean,
  integer,
  floating,
  string
};

enum class Layer : uint8_t {
  code,
  project,
  user
};
 
inline constexpr size_t k_layer_count = 2;    
 
using Value = std::variant<bool, int64_t, double, std::string>;

struct Meta {
  std::string label;                   
  std::string category;                
  std::string description;             
  double min = 0.0;                    
  double max = 0.0;
  double step = 0.0;                   
  std::vector<std::string> options;    
  bool requires_restart = false;       
  bool hidden = false;                 
};

struct Entry {
  std::string key;
  Type type = Type::boolean;
  Meta meta;
  Value default_value;
  std::array<std::optional<Value>, k_layer_count> overrides;    
  Value resolved;
  std::vector<std::function<void(const Value&)>> on_change;
};

class TOAST_API Settings {
public:
  static auto get() -> Settings&;
 
  auto declareBool(std::string_view key, bool default_value, Meta meta = {}) -> Entry*;
  auto declareInt(std::string_view key, int64_t default_value, Meta meta = {}) -> Entry*;
  auto declareFloat(std::string_view key, double default_value, Meta meta = {}) -> Entry*;
  auto declareString(std::string_view key, std::string default_value, Meta meta = {}) -> Entry*;

  [[nodiscard]]
  auto find(std::string_view key) -> Entry*;

  [[nodiscard]]
  auto entries() -> std::vector<Entry*>;

  [[nodiscard]]
  auto value(std::string_view key) -> std::optional<Value>;

  [[nodiscard]]
  auto resolved(const Entry* entry) -> Value;

  auto setValue(std::string_view key, const Value& value) -> bool;

  auto reset(std::string_view key) -> bool;

  void resetAll();

  void setPaths(std::filesystem::path project_file, std::filesystem::path user_file);

  void setActiveLayer(Layer layer);
 
  [[nodiscard]]
  auto activeLayer() const -> Layer {
    return m_active_layer;
  }

  [[nodiscard]]
  auto activeFilePath() const -> const std::filesystem::path& {
    return m_active_layer == Layer::project ? m_project_path : m_user_path;
  }

  void load();

  auto save() -> bool;
 
  [[nodiscard]]
  auto dirty() const -> bool {
    return m_dirty;
  }

  auto saveIfDirty() -> bool;
 
private:
  auto declare(std::string_view key, Type type, Value default_value, Meta meta) -> Entry*;
  void resolveEntry(Entry& entry);
  auto loadFile(const std::filesystem::path& path, Layer layer) -> bool;

  struct TransparentHash {
    using is_transparent = void;
 
    auto operator()(std::string_view key) const -> size_t { return std::hash<std::string_view> {}(key); }
  };
 
  std::recursive_mutex m_mutex;
  std::deque<Entry> m_entries;
  std::unordered_map<std::string, Entry*, TransparentHash, std::equal_to<>> m_by_key;

  std::array<std::unordered_map<std::string, Value>, k_layer_count> m_pending;
 
  std::filesystem::path m_project_path;
  std::filesystem::path m_user_path;
  Layer m_active_layer = Layer::user;
  bool m_dirty = false;
};

template<typename T>
class Setting {
public:
  Setting() = default;
 
  explicit Setting(Entry* entry) : m_entry(entry) { }
 
  [[nodiscard]]
  auto valid() const -> bool {
    return m_entry != nullptr;
  }
 
  [[nodiscard]]
  auto value() const -> T {
    if (m_entry == nullptr) {
      return T {};
    }
    // Reads the entry directly. Going back through value(key) hashed the key and built a std::string to
    // look up the entry this handle is already holding
    const Value resolved = Settings::get().resolved(m_entry);
    if (const auto* typed = std::get_if<T>(&resolved)) {
      return *typed;
    }
    return T {};
  }
 
  operator T() const {    // NOLINT(google-explicit-constructor) - the whole point is reading it like a T
    return value();
  }
 
  void set(T v) {
    if (m_entry != nullptr) {
      Settings::get().setValue(m_entry->key, Value {std::move(v)});
    }
  }

  void onChange(std::function<void(T)> callback) {
    if (m_entry == nullptr) {
      return;
    }
    auto wrapper = [callback = std::move(callback)](const Value& v) {
      if (const auto* typed = std::get_if<T>(&v)) {
        callback(*typed);
      }
    };
    wrapper(Value {value()});
    m_entry->on_change.emplace_back(std::move(wrapper));
  }
 
  [[nodiscard]]
  auto entry() const -> Entry* {
    return m_entry;
  }
 
private:
  Entry* m_entry = nullptr;
};

inline auto declareBool(std::string_view key, bool default_value, Meta meta = {}) -> Setting<bool> {
  return Setting<bool> {Settings::get().declareBool(key, default_value, std::move(meta))};
}
 
inline auto declareInt(std::string_view key, int64_t default_value, Meta meta = {}) -> Setting<int64_t> {
  return Setting<int64_t> {Settings::get().declareInt(key, default_value, std::move(meta))};
}
 
inline auto declareFloat(std::string_view key, double default_value, Meta meta = {}) -> Setting<double> {
  return Setting<double> {Settings::get().declareFloat(key, default_value, std::move(meta))};
}
 
inline auto declareString(std::string_view key, std::string default_value, Meta meta = {}) -> Setting<std::string> {
  return Setting<std::string> {Settings::get().declareString(key, std::move(default_value), std::move(meta))};
}
 
}