TypeDatabase.h

#pragma once
 
#include "Name.h"
 
#include <memory>
 
template<> inline Cogs::StringView getNameImpl(bool *) { return "bool"; }
template<> inline Cogs::StringView getNameImpl(std::string *) { return "string"; }
 
template<> inline Cogs::StringView getNameImpl(int8_t *) { return "int8_t"; }
template<> inline Cogs::StringView getNameImpl(int16_t *) { return "int16_t"; }
template<> inline Cogs::StringView getNameImpl(int32_t *) { return "int32_t"; }
template<> inline Cogs::StringView getNameImpl(int64_t *) { return "int64_t"; }
 
template<> inline Cogs::StringView getNameImpl(uint8_t *) { return "uint8_t"; }
template<> inline Cogs::StringView getNameImpl(uint16_t *) { return "uint16_t"; }
template<> inline Cogs::StringView getNameImpl(uint32_t *) { return "uint32_t"; }
template<> inline Cogs::StringView getNameImpl(uint64_t *) { return "uint64_t"; }
 
#if defined(__EMSCRIPTEN__) or defined(__APPLE__)
// __APPLE__: size_t is unsigned long, while uint64_t is unsigned long long
template<> inline Cogs::StringView getNameImpl(size_t *) { return "size_t"; }
#endif
 
template<> inline Cogs::StringView getNameImpl(float *) { return "float"; }
template<> inline Cogs::StringView getNameImpl(double *) { return "double"; }
 
template<> inline Cogs::StringView getNameImpl(std::vector<std::string> *) { return "vector<string>"; }
 
template<> inline Cogs::StringView getNameImpl(std::vector<int8_t> *) { return "vector<int8_t>"; }
template<> inline Cogs::StringView getNameImpl(std::vector<int16_t> *) { return "vector<int16_t>"; }
template<> inline Cogs::StringView getNameImpl(std::vector<int32_t> *) { return "vector<int32_t>"; }
template<> inline Cogs::StringView getNameImpl(std::vector<int64_t> *) { return "vector<int64_t>"; }
 
template<> inline Cogs::StringView getNameImpl(std::vector<uint8_t> *) { return "vector<uint8_t>"; }
template<> inline Cogs::StringView getNameImpl(std::vector<uint16_t> *) { return "vector<uint16_t>"; }
template<> inline Cogs::StringView getNameImpl(std::vector<uint32_t> *) { return "vector<uint32_t>"; }
template<> inline Cogs::StringView getNameImpl(std::vector<uint64_t> *) { return "vector<uint64_t>"; }
 
template<> inline Cogs::StringView getNameImpl(std::vector<float> *) { return "vector<float>"; }
template<> inline Cogs::StringView getNameImpl(std::vector<double> *) { return "vector<double>"; }
 
namespace Cogs
{
  namespace Reflection
  {
    class Type;
 
    namespace Construction
    {
      template<typename T>
      void * createInstanceImpl(std::false_type)
      {
        return nullptr;
      }
 
      template<typename T>
      void * createInstanceImpl(std::true_type)
      {
        return new T();
      }
 
      template<typename T>
      void * createInstance()
      {
        return createInstanceImpl<T>(std::is_constructible<T>());
      }
 
      template<typename T>
      void destroyInstance(void * t)
      {
        delete reinterpret_cast<T *>(t);
      }
 
      template<typename T>
      void * constructInstanceImpl(void * memory, std::true_type)
      {
        return new (memory) T();
      }
 
      template<typename T>
      void * constructInstanceImpl(void *, std::false_type)
      {
        return nullptr;
      }
 
      template<typename T>
      void * constructInstance(void * memory)
      {
        return constructInstanceImpl<T>(memory, std::is_constructible<T>());
      }
 
      template<typename T>
      void destructInstance(void * t)
      {
        (void)t;
        reinterpret_cast<T *>(t)->~T();
      }
    }
 
    class COGSFOUNDATION_API TypeDatabase
    {
    public:
      ~TypeDatabase();
 
      static void initializeBaseTypes();
 
      static void clear();
 
      template<typename T>
      static Type & createType(bool isAbstract = false)
      {
        return createType(getName<T>(),
                          sizeof(T),
                          &Construction::createInstance<T>,
                          &Construction::destroyInstance<T>,
                          &Construction::constructInstance<T>,
                          &Construction::destructInstance<T>,
                          isAbstract || std::is_enum<T>::value);
      }
 
      template<typename T>
      static Type & createAbstractType()
      {
        return createType(getName<T>(),
                          sizeof(T),
                          nullptr,
                          nullptr,
                          nullptr,
                          nullptr,
                          true);
      }
 
      static const Type & getType(const TypeId typeId);
 
      static const Type & getType(const Name & name);
 
      template<typename T>
      static const Type & getType()
      {
        static auto typeId = getType(getName<T>()).typeId;
 
        auto & type = getType(typeId);
 
        return type;
      }
 
      static void constructInstance(const Type & type, void * data, const size_t dataSize);
 
      static void destructInstance(const Type & type, void * data);
 
      template<typename T>
      static T * createInstance(const StringView & name)
      {
        auto & type = getType(name);
 
        auto object = reinterpret_cast<T *>(createInstance(type));
 
        return object;
      }
 
      static void * createInstance(const Type & type);
 
      static const Type * getTypes(size_t & count);
 
      static Type & createType(const StringView & name,
                               size_t size,
                               CreateInstance createInstance,
                               DestroyInstance destroyInstance,
                               ConstructInstance constructInstance,
                               DestructInstance destructInstance,
                               bool isAbstract = false);
 
    private:
      static std::unique_ptr<class TypeStore> typeStore;
    };
 
  }
}
 
#include "Type.h"