Variables.h

#pragma once
 
#include "Utilities/ValueVariant.h"
 
#include "Foundation/Reflection/Type.h"
 
#include <unordered_map>
 
namespace Cogs::Core
{
  class ResourceStore;
 
  enum class VariableFlags
  {
    None = 0,
    Empty = 1 << 0,
    Static = 1 << 1
  };
 
  ENABLE_ENUM_FLAGS(VariableFlags);
 
  struct COGSCORE_DLL_API Variable
  {
    Variable() = default;
 
    Variable(StringView name, StringView value) : name(name.to_string())
    {
      setValue(value);
    }
 
    void operator=(const StringView & value) { setValue(value); }
 
    Variable & setValue(const StringView & value);
 
    Variable & setBool(bool value) { this->value = ValueVariant(value); setValid(); return *this; }
    Variable & setFloat(float value) { this->value = ValueVariant(value); setValid(); return *this; }
    Variable & setDouble(double value) { this->value = ValueVariant(value); setValid(); return *this; }
    Variable & setInt(int value) { this->value = ValueVariant(value); setValid(); return *this; }
    Variable & setVec2(glm::vec2 value) { this->value = ValueVariant(value); setValid(); return *this; }
    Variable & setVec3(glm::vec3 value) { this->value = ValueVariant(value); setValid(); return *this; }
    Variable & setVec4(glm::vec4 value) { this->value = ValueVariant(value); setValid(); return *this; }
 
    const StringView getName() const { return name; }
    void setName(const StringView & str) { name = str.to_string(); }
 
    void setStatic() { variableFlags |= VariableFlags::Static; }
 
    const StringView getValue(StringView defaultValue = "") const { return value.getString(defaultValue); }
    const char * getCString() const { return getValue().data(); }
    bool getBool(bool defaultValue = false) const { return value.getBool(defaultValue); }
    float getFloat(float defaultValue = 0.0f) const { return value.getFloat(defaultValue); }
    double getDouble(double defaultValue = 0.0) const { return value.getDouble(defaultValue); }
    int getInt(int defaultValue = 0) const { return value.getInt(defaultValue); }
    glm::vec2 getVec2(glm::vec2 defaultValue = {}) const { return value.getVec2(defaultValue); }
    glm::vec3 getVec3(glm::vec3 defaultValue = {}) const { return value.getVec3(defaultValue); }
    glm::vec4 getVec4(glm::vec4 defaultValue = {}) const { return value.getVec4(defaultValue); }
 
    bool isEmpty() const { return (variableFlags & VariableFlags::Empty) != VariableFlags::None; }
    bool isStatic() const { return (variableFlags & VariableFlags::Static) != VariableFlags::None; }
 
    explicit operator bool() const { return !isEmpty(); }
 
    ParsedDataType getType() const { return value.getType(); }
 
  private:
    void setValid() { variableFlags &= ~VariableFlags::Empty; }
 
    std::string name;
    ValueVariant value;
    std::string stringValue;
    VariableFlags variableFlags = VariableFlags::Empty;
  };
 
  class COGSCORE_DLL_API Variables
  {
  public:
    Variables(const char ** variables, int count);
 
    void initialize(const ResourceStore & resourceStore);
 
    Variable * set(const StringView & name, const StringView & value) { return &get(name)->setValue(value); }
    Variable * set(const StringView & name, const char * value) { return &get(name)->setValue(value); }
    Variable * set(const StringView & name, int value) { return &get(name)->setInt(value); }
    Variable * set(const StringView & name, float value) { return &get(name)->setFloat(value); }
    Variable * set(const StringView & name, double value) { return &get(name)->setDouble(value); }
    Variable * set(const StringView & name, bool value) { return &get(name)->setBool(value); }
    Variable * set(const StringView & name, glm::vec2 value) { return &get(name)->setVec2(value); }
    Variable * set(const StringView & name, glm::vec3 value) { return &get(name)->setVec3(value); }
    Variable * set(const StringView & name, glm::vec4 value) { return &get(name)->setVec4(value); }
 
    const Variable * get(const StringView & name) const;
 
    Variable* getIfExists(const StringView& name);
 
    Variable * get(const StringView & name);
 
    bool erase(const StringView & name);
 
    bool exist(const StringView & name) { return variables.count(name.hash()); }
 
    const StringView get(const StringView & name, StringView defaultValue) const;
    const char * get(const StringView & name, const char * defaultValue) const { return get(name, StringView(defaultValue)).data(); }
    bool get(const StringView & name, bool defaultValue) const { return get(name)->getBool(defaultValue); }
    float get(const StringView & name, float defaultValue) const { return get(name)->getFloat(defaultValue); }
    double get(const StringView & name, double defaultValue) const { return get(name)->getDouble(defaultValue); }
    int get(const StringView & name, int defaultValue) const { return get(name)->getInt(defaultValue); }
    glm::vec2 get(const StringView & name, glm::vec2 defaultValue) const { return get(name)->getVec2(defaultValue); }
    glm::vec3 get(const StringView & name, glm::vec3 defaultValue) const { return get(name)->getVec3(defaultValue); }
    glm::vec4 get(const StringView & name, glm::vec4 defaultValue) const { return get(name)->getVec4(defaultValue); }
 
    bool getOrAdd(const StringView & name, bool defaultValue)
    {
      auto v = get(name);
 
      if (v->isEmpty()) v->setBool(defaultValue);
 
      return v->getBool(defaultValue);
    }
 
    void getMatchingVariables(std::vector<const Variable*>& vars, const StringView& keyPrefix);
 
    Variable & operator[](const StringView & key);
 
    std::unordered_map<size_t, Variable> & getVariables() { return variables; }
 
  private:
    std::unordered_map<size_t, Variable> variables;
 
    Variable empty;
  };
}