PropertiesManager.cpp

#include "PropertiesManager.h"
 
Cogs::Core::PropertyStore::PropertyStore(MemBlockType memType)
  : headers(memType),
    data(memType)
{
 
}
 
Cogs::Core::PropertyStore::PropertyStore(const PropertyStore & other)
{
  headers.copy(other.headers);
  data.copy(other.data);
  dataSize = other.dataSize;
}
 
Cogs::Core::PropertyStore::PropertyStore(PropertyStore&& other) noexcept
{
  headers = std::move(other.headers);
  data = std::move(other.data);
  dataSize = other.dataSize;
}
 
Cogs::Core::PropertyStore & Cogs::Core::PropertyStore::operator=(const PropertyStore & other)
{
  headers.copy(other.headers);
  data.copy(other.data);
  dataSize = other.dataSize;
  return *this;
}
 
Cogs::Core::PropertyStore& Cogs::Core::PropertyStore::operator=(PropertyStore&& other) noexcept
{
  headers = std::move(other.headers);
  data = std::move(other.data);
  dataSize = other.dataSize;
  return *this;
}
 
uint32_t Cogs::Core::PropertyStore::addProperty(StringView key, bool value)
{
  auto & p = addProperty(key, PropertyType::Bool);
  p.boolValue = value;
  return p.index;
}
 
uint32_t Cogs::Core::PropertyStore::addProperty(StringView key, float value)
{
  auto & p = addProperty(key, PropertyType::Float);
  p.floatValue = value;
  return p.index;
}
 
uint32_t Cogs::Core::PropertyStore::addProperty(StringView key, double value)
{
  auto& p = addProperty(key, PropertyType::Double);
  p.doubleValue = value;
  return p.index;
}
 
uint32_t Cogs::Core::PropertyStore::addProperty(StringView key, int32_t value)
{
  auto & p = addProperty(key, PropertyType::Integer);
  p.intValue = value;
  return p.index;
}
 
uint32_t Cogs::Core::PropertyStore::addProperty(StringView key, uint32_t value)
{
  auto& p = addProperty(key, PropertyType::UnsignedInteger);
  p.uintValue = value;
  return p.index;
}
 
uint32_t Cogs::Core::PropertyStore::addProperty(StringView key, std::span<const float> values)
{
  size_t n = values.size();
  if (n == 0) {
    PropertyInfo& p = addProperty(key, PropertyType::FloatArray);
    p.data.offset = 0;
    p.data.size = 0;
    return p.index;
  }
 
  if (n == 1) {
    PropertyInfo& p = addProperty(key, PropertyType::Float);
    p.floatValue = values[0];
    return p.index;
  }
 
  if (n == 2) {
    PropertyInfo& p = addProperty(key, PropertyType::Float2);
    p.float2Value[0] = values[0];
    p.float2Value[1] = values[1];
    return p.index;
  }
 
  PropertyInfo& p = addProperty(key, PropertyType::FloatArray);
  addPropertyData(p, values.data(), values.size_bytes());
  return p.index;
}
 
uint32_t Cogs::Core::PropertyStore::addProperty(StringView key, std::span<const double> values)
{
  size_t n = values.size();
  if (n == 0) {
    PropertyInfo& p = addProperty(key, PropertyType::DoubleArray);
    p.data.offset = 0;
    p.data.size = 0;
    return p.index;
  }
 
  if (n == 1) {
    PropertyInfo& p = addProperty(key, PropertyType::Double);
    p.doubleValue = values[0];
    return p.index;
  }
 
  PropertyInfo& p = addProperty(key, PropertyType::DoubleArray);
  addPropertyData(p, values.data(), values.size_bytes());
  return p.index;
}
 
uint32_t Cogs::Core::PropertyStore::addProperty(StringView key, std::span<const int32_t> values)
{
  size_t n = values.size();
  if (n == 0) {
    PropertyInfo& p = addProperty(key, PropertyType::IntArray);
    p.data.offset = 0;
    p.data.size = 0;
    return p.index;
  }
 
  if (n == 1) {
    PropertyInfo& p = addProperty(key, PropertyType::Integer);
    p.intValue = values[0];
    return p.index;
  }
 
  if (n == 2) {
    PropertyInfo& p = addProperty(key, PropertyType::Int2);
    p.int2Value[0] = values[0];
    p.int2Value[1] = values[1];
    return p.index;
  }
 
  PropertyInfo& p = addProperty(key, PropertyType::IntArray);
  addPropertyData(p, values.data(), values.size_bytes());
  return p.index;
}
 
uint32_t Cogs::Core::PropertyStore::addProperty(StringView key, std::span<const uint32_t> values)
{
  size_t n = values.size();
  if (n == 0) {
    PropertyInfo& p = addProperty(key, PropertyType::UIntArray);
    p.data.offset = 0;
    p.data.size = 0;
    return p.index;
  }
 
  if (n == 1) {
    PropertyInfo& p = addProperty(key, PropertyType::UnsignedInteger);
    p.uintValue = values[0];
    return p.index;
  }
 
  if (n == 2) {
    PropertyInfo& p = addProperty(key, PropertyType::UInt2);
    p.uint2Value[0] = values[0];
    p.uint2Value[1] = values[1];
    return p.index;
  }
 
  PropertyInfo& p = addProperty(key, PropertyType::UIntArray);
  addPropertyData(p, values.data(), values.size_bytes());
  return p.index;
}
 
uint32_t Cogs::Core::PropertyStore::addProperty(StringView key, const glm::vec3& values)
{
  return addProperty(key, std::span(&values[0], 3));
}
 
bool Cogs::Core::PropertyStore::getProperty(StringView key, bool defaultValue)
{
  auto & p = getProperty(key);
 
  if (p.type == PropertyType::Bool) return p.boolValue;
 
  return defaultValue;
}
 
float Cogs::Core::PropertyStore::getProperty(StringView key, float defaultValue)
{
  auto & p = getProperty(key);
 
  if (p.type == PropertyType::Float) return p.floatValue;
  else if (p.type == PropertyType::Integer) return (float)p.intValue;
 
  return defaultValue;
}
 
int Cogs::Core::PropertyStore::getProperty(StringView key, int defaultValue)
{
  auto & p = getProperty(key);
 
  if (p.type == PropertyType::Integer) return p.intValue;
  else if (p.type == PropertyType::Float) return static_cast<int>(p.floatValue);
 
  return defaultValue;
}
 
uint32_t Cogs::Core::PropertyStore::getProperty(StringView key, uint32_t defaultValue)
{
  const PropertyInfo& p = getProperty(key);
  if (p.type == PropertyType::UnsignedInteger) return p.uintValue;
  else if (p.type == PropertyType::Integer && 0 <= p.intValue) return p.intValue;
  else if (p.type == PropertyType::Float && 0.f <= p.floatValue) return static_cast<int>(p.floatValue);
  return defaultValue;
}
 
uint32_t Cogs::Core::PropertyStore::addProperty(StringView key, StringRef value)
{
  PropertyInfo& p = addProperty(key, PropertyType::StringRef);
  p.stringRefValue = value;
  return p.index;
}
 
uint32_t Cogs::Core::PropertyStore::addProperty(StringView key, StringView value)
{  
  auto & p = addProperty(key, PropertyType::String);
  
  if (!value.empty()) {
    // Allocate enough space for string + null termination.
    addPropertyData(p, value.data(), value.size() + 1);
    // Null terminate string data as additional safety measure.
    getPropertyData(p)[value.size()] = 0;
  } else {
    p.data.size = 0;
    p.data.offset = 0;
  }
 
  return p.index;
}
 
Cogs::StringView Cogs::Core::PropertyStore::getProperty(StringView key, StringView defaultValue)
{
  PropertyInfo& p = getProperty(key);
  return p.type != PropertyType::Unknown ? getString(p) : defaultValue;
}
 
std::span<const float> Cogs::Core::PropertyStore::getProperty(StringView key, std::span<const float> defaultValue)
{
  PropertyInfo& p = getProperty(key);
  switch (p.type) {
  case PropertyType::Float:
  case PropertyType::Float2:
  case PropertyType::FloatArray:
    return getFloatArray(p.index);
  default:
    return defaultValue;
  }
}
 
glm::vec3 Cogs::Core::PropertyStore::getProperty(StringView key, glm::vec3 defaultValue)
{
  auto& p = getProperty(key);
 
  if (p.type == PropertyType::FloatArray) {
    const auto array = getFloatArray(p.index);
    if (array.size() == 3 || array.size() == 4) {
      // Consistent with Variables access.
      return glm::vec3(array[0], array[1], array[2]);
    }
  }
 
  return defaultValue;
}
 
Cogs::Core::PropertyInfo & Cogs::Core::PropertyStore::getProperty(StringView key)
{
  return getProperty(Strings::add(key));
}
 
Cogs::Core::PropertyInfo & Cogs::Core::PropertyStore::getProperty(StringRef key)
{
  static PropertyInfo unknown = {};
 
  for (auto & p : headers) {
    if (key == p.key) {
      return p;
    }
  }
 
  return unknown;
}
 
Cogs::Core::PropertyInfo & Cogs::Core::PropertyStore::getPropertyByIndex(uint32_t index)
{
  return headers[index];
}
 
const Cogs::Core::PropertyInfo & Cogs::Core::PropertyStore::getPropertyByIndex(uint32_t index) const
{
  return headers[index];
}
 
uint32_t Cogs::Core::PropertyStore::findProperty(StringView key) const
{
  return findProperty(0, size(), Strings::add(key));
}
 
uint32_t Cogs::Core::PropertyStore::findProperty(uint32_t first, uint32_t count, StringRef key) const
{
  uint32_t last = first + count;
  for (uint32_t i = first; i < last; ++i) {
    auto & p = headers[i];
    if (p.key == key) return i;
  }
 
  return PropertyStore::NoProperty;
}
 
Cogs::StringView Cogs::Core::PropertyStore::getKey(const PropertyInfo & p) const
{
  return Strings::get(headers[p.index].key);
}
 
Cogs::StringView Cogs::Core::PropertyStore::getString(const PropertyInfo & p) const
{
  if (p.type == PropertyType::StringRef) {
    return Strings::get(p.stringRefValue);
  }
 
  if (p.type == PropertyType::String) {
    if (p.data.size) {
      return StringView{static_cast<const char *>(data.data()) + p.data.offset, p.data.size - 1 };
    } else {
      return StringView{};
    }
  }
 
  //TODO: Log warning (?)
 
  return {};
}
 
Cogs::StringView Cogs::Core::PropertyStore::getString(uint32_t index) const
{
  return getString(getPropertyByIndex(index));
}
 
std::span<float> Cogs::Core::PropertyStore::getFloatArray(uint32_t index)
{
  PropertyInfo& p = getPropertyByIndex(index);
  if (p.type == PropertyType::Float) {
    return std::span(&p.floatValue, &p.floatValue + 1);
  }
  if (p.type == PropertyType::Float2) {
    return std::span(p.float2Value);
  }
  if (p.type == PropertyType::FloatArray) {
    void* data = getPropertyData(p);
    size_t size = p.data.size / sizeof(float);
    return std::span(static_cast<float*>(data), size);
  }
  return {};
}
 
std::span<const float> Cogs::Core::PropertyStore::getFloatArray(uint32_t index) const
{
  if (index != PropertyStore::NoProperty) {
    return getFloatArray(getPropertyByIndex(index));
  }
  return {};
}
 
std::span<const double> Cogs::Core::PropertyStore::getDoubleArray(const PropertyInfo& p) const
{
  if (p.type == PropertyType::Double) {
    return std::span(&p.doubleValue, &p.doubleValue + 1);
  }
  if (p.type == PropertyType::DoubleArray) {
    const void* data = getPropertyData(p);
    size_t size = p.data.size / sizeof(double);
    return std::span(static_cast<const double*>(data), size);
  }
  return {};
}
 
std::span<const double> Cogs::Core::PropertyStore::getDoubleArray(uint32_t index) const
{
  if (index != PropertyStore::NoProperty) {
    return getDoubleArray(getPropertyByIndex(index));
  }
  return {};
}
 
std::span<const float> Cogs::Core::PropertyStore::getFloatArray(const PropertyInfo& p) const
{
  if (p.type == PropertyType::Float) {
    return std::span(&p.floatValue, &p.floatValue + 1);
  }
  if (p.type == PropertyType::Float2) {
    return std::span(p.float2Value);
  }
  if (p.type == PropertyType::FloatArray) {
    const void* data = getPropertyData(p);
    size_t size = p.data.size / sizeof(float);
    return std::span(static_cast<const float*>(data), size);
  }
  return {};
}
 
std::span<const int32_t> Cogs::Core::PropertyStore::getIntArray(const PropertyInfo& p) const
{
  if (p.type == PropertyType::Integer) {
    return std::span(&p.intValue, 1);
  }
  else if (p.type == PropertyType::Int2) {
    return std::span(p.int2Value);
  }
  else if (p.type == PropertyType::IntArray) {
    const void* data = getPropertyData(p);
    size_t size = p.data.size / sizeof(int32_t);
    return std::span(static_cast<const int32_t*>(data), size);
  }
  return {};
}
 
std::span<const int32_t> Cogs::Core::PropertyStore::getIntArray(uint32_t index) const
{
  if (index != PropertyStore::NoProperty) {
    return getIntArray(getPropertyByIndex(index));
  }
  return {};
}
 
std::span<const uint32_t> Cogs::Core::PropertyStore::getUIntArray(const PropertyInfo& p) const
{
  if (p.type == PropertyType::UnsignedInteger) {
    return std::span(&p.uintValue, 1);
  }
  else if (p.type == PropertyType::UInt2) {
    return std::span(p.uint2Value);
  }
  else if (p.type == PropertyType::UIntArray) {
    const void* data = getPropertyData(p);
    size_t size = p.data.size / sizeof(uint32_t);
    return std::span(static_cast<const uint32_t*>(data), size);
  }
  return {};
}
 
std::span<const uint32_t> Cogs::Core::PropertyStore::getUIntArray(uint32_t index) const
{
  if (index != PropertyStore::NoProperty) {
    return getUIntArray(getPropertyByIndex(index));
  }
  return {};
}
 
Cogs::Core::PropertyInfo & Cogs::Core::PropertyStore::addProperty(StringView key, PropertyType type)
{
  uint32_t index = static_cast<uint32_t>(headers.size());
 
  PropertyInfo& p = headers.grow();
  p.index = index;
  p.key = Strings::add(key);
  p.type = type;
 
  return p;
}
 
void Cogs::Core::PropertyStore::addPropertyData(PropertyInfo & p, const void * data, size_t size)
{
  auto[ptr, offset] = allocate(size);
  std::memcpy(ptr, data, size);
  p.data.offset = offset;
  p.data.size = static_cast<uint32_t>(size);
}
 
uint8_t * Cogs::Core::PropertyStore::getPropertyData(const PropertyInfo & p)
{
  return static_cast<uint8_t *>(data.data()) + p.data.offset;
}
 
const uint8_t * Cogs::Core::PropertyStore::getPropertyData(const PropertyInfo & p) const
{
  return static_cast<const uint8_t*>(data.data()) + p.data.offset;
}
 
uint32_t Cogs::Core::PropertyStore::addProperty(const PropertyStore& other, uint32_t otherIndex)
{
  if (otherIndex == NoProperty) {
    return NoProperty;
  }
  const PropertyInfo& otherInfo = other.getPropertyByIndex(otherIndex);
  PropertyInfo& pInfo = addProperty(other.getKey(otherInfo), otherInfo.type);
  if (otherInfo.type == PropertyType::Unknown) {
    //Error
  }
  else if (PropertyType::FirstInlineType <= otherInfo.type && otherInfo.type < PropertyType::LastInlineType) {
    // 2 x uint32, large enough for all inline types
    pInfo.data = otherInfo.data;
  }
  else {
    addPropertyData(pInfo, other.getData() + otherInfo.data.offset, otherInfo.data.size);
  }
  return pInfo.index;
}
 
 
void Cogs::Core::PropertyStore::copyProperties(const PropertyStore & other, uint32_t offset, uint32_t count)
{
  for (uint32_t i = 0; i < count; ++i) {
    auto & otherP = other.getPropertyByIndex(offset + i);
 
    if (PropertyInfo& existing = getProperty(otherP.key); existing.key == otherP.key) {
 
      // Overwrite existing data, update type making sure it matches
      existing.type = otherP.type;
      if (PropertyType::FirstInlineType <= otherP.type && otherP.type < PropertyType::LastInlineType) {
        // 2 x uint32, large enough for all inline types
        existing.data = otherP.data;
      }
      else {
        //NOTE: The existing property data is left untouched in the data storage for the sake of simplicity at the
        // cost of some additional memory.
        addPropertyData(existing, other.getData() + otherP.data.offset, otherP.data.size);
      }
      continue;
    }
 
    PropertyInfo& p = addProperty(other.getKey(otherP), otherP.type);
    if (otherP.type == PropertyType::Unknown) {
      //Error
      continue;
    }
 
    if (PropertyType::FirstInlineType <= otherP.type && otherP.type < PropertyType::LastInlineType) {
      // 2 x uint32, large enough for all inline types
      p.data = otherP.data;
    } else {
      addPropertyData(p, other.getData() + otherP.data.offset, otherP.data.size);
    }
  }
}
 
Cogs::Core::PropertyStore::PropertyAlloc Cogs::Core::PropertyStore::allocate(size_t propertySize)
{
  const size_t currentCapacity = data.size();
  const size_t requiredCapacity = dataSize + propertySize;
 
  if (currentCapacity < requiredCapacity) {
    constexpr size_t alignment = 0x1f;
    size_t newCapacity = (((requiredCapacity * 3) / 2) + alignment) & ~alignment;
    data.resize(newCapacity, true);
  }
  assert(requiredCapacity <= data.size());
 
  const uint32_t offset = static_cast<uint32_t>(dataSize);
  auto ptr = static_cast<uint8_t *>(data.data()) + offset;
 
  dataSize += propertySize;
 
#ifdef EMSCRIPTEN
  // avoid alignment error in getFloatArray with -s SAFE_HEAP
  dataSize = 4 * ((dataSize + 3) / 4);
#endif
 
  return { ptr, offset };
}
 
uint32_t Cogs::Core::PropertyRange::getPropertyIndex(StringRef key) const
{
  return store->findProperty(firstProperty, numProperties, key);
}
 
float Cogs::Core::PropertyRange::getProperty(StringRef key, float defaultValue) const
{
  auto index = store->findProperty(firstProperty, numProperties, key);
  if (index == PropertyStore::NoProperty) return defaultValue;
  auto & p = store->getPropertyByIndex(index);
 
  if (p.type == PropertyType::Float) return p.floatValue;
 
  return defaultValue;
}
 
int Cogs::Core::PropertyRange::getProperty(StringRef key, int defaultValue) const
{
  auto index = store->findProperty(firstProperty, numProperties, key);
  if (index == PropertyStore::NoProperty) return defaultValue;
  auto & p = store->getPropertyByIndex(index);
 
  if (p.type == PropertyType::Integer) return p.intValue;
 
  return defaultValue;
}
 
Cogs::StringView Cogs::Core::PropertyRange::getProperty(StringRef key, StringView defaultValue) const
{
  auto index = store->findProperty(firstProperty, numProperties, key);
  if (index == PropertyStore::NoProperty) return defaultValue;
  auto & p = store->getPropertyByIndex(index);
 
  if (p.type == PropertyType::String) return store->getString(index);
 
  return defaultValue;
}
 
std::span<const float> Cogs::Core::PropertyRange::getProperty(StringRef key, std::span<const float> defaultValue) const
{
  auto index = store->findProperty(firstProperty, numProperties, key);
  if (index != PropertyStore::NoProperty) return store->getFloatArray(index);
  else return defaultValue;
}
 
std::span<const uint32_t> Cogs::Core::PropertyRange::getProperty(StringRef key, std::span<const uint32_t> defaultValue) const
{
  if (uint32_t index = store->findProperty(firstProperty, numProperties, key); index != PropertyStore::NoProperty) {
    return store->getUIntArray(index);
  }
  return defaultValue;
}