Type.h

#pragma once
 
 
#include "Field.h"
#include "Method.h"
 
namespace Cogs
{
  namespace Reflection
  {
    struct TypeFlags
    {
      enum ETypeFlags
      {
        None = 0,
        EnumFlags,
      };
    };
 
    struct EnumeratorDef {
      template<typename T>
      constexpr EnumeratorDef(Cogs::StringView name, T value) : name(name), value(static_cast<int>(value))
      {
        // See also Field.inl
        static_assert(sizeof(T) <= 4, "64bit enums not supported.");
      }
 
      constexpr Cogs::StringView getName() const { return name; }
 
      constexpr int getValue() const { return value; }
 
    private:
 
      Cogs::StringView name;
 
      int value = 0;
 
    };
 
    struct COGSFOUNDATION_API Enumerator
    {
      template<typename T>
      Enumerator(const Name& name, T value) : name(name), value(static_cast<int>(value))
      {
        // See also Field.inl
        static_assert(sizeof(T) <= 4, "64bit enums not supported.");
      }
 
      const Name& getName() const { return name; }
 
      int getValue() const { return value; }
 
    private:
 
      Name name;
 
      int value = 0;
 
    };
 
    class COGSFOUNDATION_API Type
    {
    public:
      Type() = default;
 
      Type(const Type & other) = delete;
 
      Type(Type && other) noexcept = default;
 
      Type & operator=(const Type & other) = delete;
 
      Type & operator=(Type && other) noexcept = delete;
 
      template<size_t count>
      Type & setFields(Field(&fields)[count]);
 
      template<size_t count>
      Type & setMethods(Method(&functions)[count]);
 
      Type & setMethods(Method * functions, size_t count);
 
      template<size_t count>
      Type& setEnumerators(const EnumeratorDef(&enumerators)[count])
      {
        return setEnumerators(enumerators, count);
      }
 
      Type& setEnumerators(const EnumeratorDef* enumerators, size_t count);
 
      Type & setBase(const Type * base)
      {
        this->base = base ? base->typeId : NoType;
 
        return *this;
      }
 
      template<typename BaseType>
      Type & setBase();
 
      [[nodiscard]] const Type * getBase() const;
 
      template<typename DestinationType>
      [[nodiscard]] bool canCastTo() const;
 
      [[nodiscard]] bool canCastTo(const Type& destination) const
      {
        return canCastTo(destination.getTypeId());
      }
 
      [[nodiscard]] bool canCastTo(const TypeId& destinationId) const;
 
      [[nodiscard]] constexpr bool operator==(const Type & other) const
      {
        return this->typeId == other.typeId;
      }
 
      [[nodiscard]] constexpr const Name & getName() const { return name; }
 
      [[nodiscard]] constexpr size_t getSize() const { return size; }
 
      [[nodiscard]] const Field * getField(const Name & name) const;
 
      [[nodiscard]] FieldId getFieldId(const Field * field) const;
 
      [[nodiscard]] static FieldId getFieldId(TypeId componentTypeId, const Name& name);
 
      [[nodiscard]] size_t getNumFields() const { return fields.size(); }
 
      [[nodiscard]] size_t getNumHierarchyFields() const;
 
      [[nodiscard]] const Field * getField(const FieldId id) const;
 
      [[nodiscard]] FieldId getFieldId(size_t offset) const;
 
      template<typename ClassType, typename FieldType>
      [[nodiscard]] FieldId getFieldId(FieldType ClassType::* field) const
      {
        const size_t offset = memberOffset(field);
 
        return getFieldId(offset);
      }
 
      [[nodiscard]] const Method * getMethod(const Name & name) const;
 
      [[nodiscard]] MethodId getMethodId(const Method * method) const
      {
        return static_cast<MethodId>(method - methods.data());
      }
 
      [[nodiscard]] const Method * getMethod(const MethodId id) const
      {
        return &methods[id];
      }
 
      [[nodiscard]] const Enumerator * getEnumerator(const Name & name) const;
 
      [[nodiscard]] const Enumerator * getEnumerator(const size_t index) const
      {
        if (index >= enumerators.size()) return nullptr;
 
        return &enumerators[index];
      }
 
      [[nodiscard]] bool isEnum() const { return !enumerators.empty(); }
 
      [[nodiscard]] size_t getNumEnumerators() const { return enumerators.size(); }
 
      [[nodiscard]] constexpr TypeId getTypeId() const { return typeId; }
 
      [[nodiscard]] constexpr bool isValid() const { return typeId != NoType; }
      
      constexpr void setFlags(uint32_t flags) { this->flags = flags; }
 
      [[nodiscard]] bool isEnumFlags() const { return isEnum() && (flags & TypeFlags::EnumFlags) != 0; }
 
      constexpr Type & setEnumFlags() { setFlags(flags | TypeFlags::EnumFlags); return *this; }
 
    private:
      Type& setFields(Field* fields, size_t count);
 
    private:
      Name name;
 
      size_t size = 0;
 
      uint32_t flags = TypeFlags::None;
 
      TypeId typeId = NoType;
 
      TypeId base = NoType;
 
      std::vector<Field> fields;
 
      std::vector<Method> methods;
 
      std::vector<Enumerator> enumerators;
 
      CreateInstance createInstance = nullptr;
 
      DestroyInstance destroyInstance = nullptr;
 
      ConstructInstance constructInstance = nullptr;
 
      DestructInstance destructInstance = nullptr;
 
      StringView description;
 
    private:
      friend class TypeDatabase;
    };
 
    template<size_t count>
    Type & Cogs::Reflection::Type::setFields(Field(&fields)[count])
    {
      return setFields(fields, count);
    }
 
    template<size_t count>
    Type & Cogs::Reflection::Type::setMethods(Method(&functions)[count])
    {
      return setMethods(functions, count);
    }
  }
}
 
namespace std
{
  template<>
  struct hash<Cogs::Reflection::Type>
  {
    size_t operator()(const Cogs::Reflection::Type & type) const noexcept
    {
      return type.getName().getId();
    }
  };
}
 
#include "Type.inl"
#include "Attributes.inl"