Variables.cpp

#include "Variables.h"
 
#include "Serialization/JsonParser.h"
#include "Serialization/VariableReader.h"
 
#include "Resources/ResourceStore.h"
 
#include "Foundation/Logging/Logger.h"
#include "Foundation/Reflection/TypeDatabase.h"
 
#include <algorithm>
#include <cstdlib>
#include <cctype>
 
namespace
{
  std::string toLower(const Cogs::StringView & input)
  {
    std::string lowerCase;
    lowerCase.resize(input.size());
    std::transform(input.begin(), input.end(), lowerCase.begin(),
                   [](unsigned char c) -> unsigned char { return (unsigned char)std::tolower(c); });
    return lowerCase;
  }
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("Variables");
}
 
Cogs::Core::Variable & Cogs::Core::Variable::setValue(const StringView & newValue)
{
  this->stringValue = newValue.to_string();
 
  auto lowerCase = toLower(newValue);
 
  if (lowerCase == "true" || lowerCase == "false") {
    value = ValueVariant((lowerCase == "true") ? true : false);
  } else {
    value = ValueVariant(newValue);
  }
 
  setValid();
 
  return *this;
}
 
const Cogs::StringView Cogs::Core::Variables::get(const StringView & name, StringView defaultValue) const
{
  auto variable = get(name);
 
  if(variable->getType() == ParsedDataType::Bool)
  {
    return variable->getBool() ? "true" : "false";
  }
 
  return variable->getValue(defaultValue);
}
 
Cogs::Core::Variables::Variables(const char ** variables, int count)
{
  empty.setStatic();
 
  if (variables && count) {
    assert(count % 2 == 0 && "Variable string array size must be even.");
 
    const int variableCount = count / 2;
 
    for (int i = 0; i < variableCount; ++i) {
      LOG_DEBUG(logger, "Registering variable %s: %s", variables[i * 2], variables[i * 2 + 1]);
      set(variables[i * 2], variables[i * 2 + 1]);
    }
  }
 
#ifdef EMSCRIPTEN
  // Force async preloading on Emscripten.
  set("resources.effects.preLoad", true);
#endif
}
 
void Cogs::Core::Variables::initialize(const ResourceStore& resourceStore)
{
  auto defaultConfigSetting = get("variables.defaultConfig", "Default.config");
  ResourceBuffer content = resourceStore.getResourceContents(defaultConfigSetting);
 
  if (!content.size()) {
    LOG_ERROR(logger, "Could not open default configuration file.");
 
    return;
  }
 
  auto document = parseJson(content.toStringView(), JsonParseFlags::None);
 
  if (!document.IsObject()) {
    LOG_ERROR(logger, "Could not load default configuration.");
 
    return;
  }
 
  readVariables(*this, document, "", true);
}
 
bool Cogs::Core::Variables::erase(const StringView & name)
{
  if (auto it = variables.find(name.hash()); it != variables.end()) {
    variables.erase(it);
    return true;
  }
  return false;
}
 
const Cogs::Core::Variable * Cogs::Core::Variables::get(const StringView & name) const
{
  auto it = variables.find(name.hash());
 
  return it != variables.end() ? &it->second : &empty;
}
 
Cogs::Core::Variable* Cogs::Core::Variables::getIfExists(const StringView& name)
{
  if (auto it = variables.find(name.hash()); it != variables.end()) {
    return &it->second;
  }
  return nullptr;
}
 
Cogs::Core::Variable * Cogs::Core::Variables::get(const StringView & name)
{
  auto v = &variables[name.hash()];
 
  if (v->getName().empty()) {
    v->setName(name);
  }
 
  return v;
}
 
Cogs::Core::Variable & Cogs::Core::Variables::operator[](const StringView & key)
{
  return *get(key);
}
 
void Cogs::Core::Variables::getMatchingVariables(std::vector<const Variable*>& vars, const StringView& keyPrefix)
{
  vars.clear();
  for (auto & it : variables) {
    auto & name = it.second.getName();
    if (keyPrefix.length() <= name.length()) {
       if (keyPrefix == StringView(name.data(), keyPrefix.length())) {
         vars.push_back(&(it.second));
       }
    }
  }
}