Entity.h

#pragma once
 
#include "ComponentCollection.h"
 
namespace Cogs
{
  namespace Reflection
  {
    class Type;
  }
 
  namespace ComponentModel
  {
    class COGSFOUNDATION_API Entity
    {
    public:
      static void registerType();
 
      void addComponent(ComponentHandle component);
 
      void removeComponent(ComponentHandle component);
 
      template<typename T>
      [[nodiscard]] T * getComponent() const
      {
        static_assert(std::is_base_of<Component, T>::value, "<T> not derived from Component");
        static Reflection::TypeId typeId = Component::getComponentTypeId(::getName<T>());
 
        return static_cast<T *>(getComponent(typeId));
      }
 
      template<typename T>
      void getComponents(ComponentCollection<T> & collection) const
      {
        static_assert(std::is_base_of<Component, T>::value, "<T> not derived from Component");
        getComponents(Reflection::Name(::getName<T>()), collection);
      }
 
      [[nodiscard]] Component * getComponent(const Reflection::Name & typeName) const;
 
      [[nodiscard]] Component * getComponent(const Reflection::TypeId & id) const;
 
      void getComponents(const Reflection::Name & typeName, ComponentCollectionBase& collection) const;
 
      template<typename T>
      [[nodiscard]] T * getComponent(const Reflection::Type & type) const
      {
        static_assert(std::is_base_of<Component, T>::value, "<T> not derived from Component");
        return static_cast<T *>(getComponentPtr(type));
      }
 
      [[nodiscard]] Component * getComponentPtr(const Reflection::Type & type) const;
 
      template<typename T>
      [[nodiscard]] ComponentHandle getComponentHandle() const
      {
        return getComponentHandle(Reflection::Name(::getName<T>()));
      }
 
      [[nodiscard]] ComponentHandle getComponentHandle(const Reflection::Name & componentName) const;
 
      [[nodiscard]] ComponentHandle getComponentHandle(const Reflection::Type & type) const;
 
      [[nodiscard]] ComponentHandle getComponentHandle(const Reflection::TypeId & id) const;
 
      [[nodiscard]] constexpr size_t getId() const noexcept { return id; }
 
      constexpr void setId(const size_t id) noexcept { this->id = id; }
 
      [[nodiscard]] const std::string & getName() const noexcept { return name; }
 
      void setName(const StringView& name);
 
      [[nodiscard]] const ComponentCollectionBase & getComponents() const { return components; }
 
      constexpr void setUserData(void* userData) noexcept { this->userData = userData; }
 
      [[deprecated]] void setUserData(intptr_t userData) { this->userData = reinterpret_cast<void*>(userData); }
 
      [[nodiscard]] constexpr void* getUserData() const noexcept { return this->userData; }
 
    private:
      ComponentCollectionBase components;
 
      std::string name;
 
      size_t id = static_cast<size_t>(-1);
 
      void* userData = nullptr;
    };
  }
}
 
template<> inline Cogs::StringView getName<Cogs::ComponentModel::Entity>() { return "Entity"; }