TypeDatabase.cpp

#include "TypeDatabase.h"
 
#include "Type.h"
 
#include "../ComponentModel/Attributes.h"
 
#include <unordered_map>
 
namespace Cogs
{
  namespace Reflection
  {
    class TypeStore
    {
    public:
      std::vector<Type> types;
 
      std::unordered_map<size_t, TypeId> typesByName;
    };
 
    std::unique_ptr<TypeStore> TypeDatabase::typeStore = std::make_unique<TypeStore>();
  }
}
 
Cogs::Reflection::TypeDatabase::~TypeDatabase()
{
 
}
 
void Cogs::Reflection::TypeDatabase::initializeBaseTypes()
{
  // Insert invalid type at index zero.
  typeStore->types.emplace_back();
 
  TypeDatabase::createType<bool>();
  TypeDatabase::createType<std::string>();
 
  TypeDatabase::createType<int8_t>();
  TypeDatabase::createType<int16_t>();
  TypeDatabase::createType<int32_t>();
  TypeDatabase::createType<int64_t>();
 
  TypeDatabase::createType<uint8_t>();
  TypeDatabase::createType<uint16_t>();
  TypeDatabase::createType<uint32_t>();
  TypeDatabase::createType<uint64_t>();
 
#if defined(EMSCRIPTEN) || defined(__APPLE__)
  TypeDatabase::createType<size_t>();
#endif
 
  TypeDatabase::createType<float>();
  TypeDatabase::createType<double>();
  
  TypeDatabase::createType<std::vector<std::string>>();
 
  TypeDatabase::createType<std::vector<int8_t>>();
  TypeDatabase::createType<std::vector<int16_t>>();
  TypeDatabase::createType<std::vector<int32_t>>();
  TypeDatabase::createType<std::vector<int64_t>>();
 
  TypeDatabase::createType<std::vector<uint8_t>>();
  TypeDatabase::createType<std::vector<uint16_t>>();
  TypeDatabase::createType<std::vector<uint32_t>>();
  TypeDatabase::createType<std::vector<uint64_t>>();
 
  TypeDatabase::createType<std::vector<float>>();
  TypeDatabase::createType<std::vector<double>>();
 
  TypeDatabase::createType<ComponentModel::DescriptionAttribute>();
  TypeDatabase::createType<ComponentModel::RangeAttribute<float>>();
  TypeDatabase::createType<ComponentModel::DefaultValueAttribute<float>>();
  TypeDatabase::createType<ComponentModel::StepSizeAttribute<float>>();
  TypeDatabase::createType<ComponentModel::SerializableAttribute>();
  TypeDatabase::createType<ComponentModel::ColorAttribute>();
}
 
void Cogs::Reflection::TypeDatabase::clear()
{
  typeStore->types.clear();
  typeStore->typesByName.clear();
}
 
const Cogs::Reflection::Type & Cogs::Reflection::TypeDatabase::getType(const TypeId typeId)
{
  debug_assert(typeId != NoType && typeId < typeStore->types.size() && "Type with the given name is not registered in database.");
 
  // Fall back to invalid type if index is out of bounds.
  const auto index = typeId < typeStore->types.size() ? typeId : 0;
 
  return typeStore->types[index];
}
 
const Cogs::Reflection::Type & Cogs::Reflection::TypeDatabase::getType(const Name & name)
{
  auto foundIt = typeStore->typesByName.find(name.getId());
  
  if (foundIt != typeStore->typesByName.end()) {
    return getType(foundIt->second);
  } else {
    return getType(0);
  }
}
 
void Cogs::Reflection::TypeDatabase::constructInstance(const Type & type, void * data, const size_t dataSize)
{
  assert(type.isValid() && "Invalid type cannot be used to construct instance.");
  assert(type.getSize() <= dataSize && "Placement target too small to construct in.");
 
  type.constructInstance(data);
}
 
void Cogs::Reflection::TypeDatabase::destructInstance(const Type & type, void * data)
{
  type.destructInstance(data);
}
 
void * Cogs::Reflection::TypeDatabase::createInstance(const Type & type)
{
  return type.createInstance();
}
 
const Cogs::Reflection::Type * Cogs::Reflection::TypeDatabase::getTypes(size_t & count)
{
  count = typeStore->types.size();
 
  return typeStore->types.data();
}
 
Cogs::Reflection::Type & Cogs::Reflection::TypeDatabase::createType(const StringView & name,
                                                                    size_t size,
                                                                    CreateInstance createInstance,
                                                                    DestroyInstance destroyInstance,
                                                                    ConstructInstance constructInstance,
                                                                    DestructInstance destructInstance,
                                                                    bool isAbstract)
{
  typeStore->types.emplace_back();
  auto & t = typeStore->types.back();
 
  debug_assert(typeStore->types.size() < std::numeric_limits<TypeId>::max() && "Type store over size limit.");
  debug_assert(!name.empty() && "Missing name registration getName<> specialization");
 
  t.typeId = static_cast<TypeId>(typeStore->types.size() - 1);
  t.name = Name(name);
  t.size = size;
 
  if (!isAbstract) {
    t.createInstance = createInstance;
    t.destroyInstance = destroyInstance;
    t.constructInstance = constructInstance;
    t.destructInstance = destructInstance;
  }
 
  debug_assert(typeStore->typesByName.find(t.name.getId()) == typeStore->typesByName.end() && "Type name already in use.");
 
  typeStore->typesByName[t.name.getId()] = t.typeId;
 
  return t;
}