ComponentPtr.h

#pragma once
 
#include "Entity.h"
 
namespace Cogs {
  namespace ComponentModel
  {
    template<typename ComponentType>
    class ComponentPtr
    {
      static_assert(std::is_base_of<Component, ComponentType>::value, "<ComponentType> not derived from Component");
    public:
      typedef ComponentType value_type;
 
      ComponentPtr() = default;
 
      ComponentPtr(const std::shared_ptr<Entity> & owner)
        : owner(owner)
      {
      }
 
      ComponentPtr(std::shared_ptr<Entity> && owner) noexcept
        : owner(std::move(owner))
      {
      }
 
      ComponentPtr(const ComponentPtr<ComponentType> & source)
        : owner(source.owner)
      {
      }
 
      ComponentPtr(ComponentPtr<ComponentType> && source) noexcept
        : owner(std::move(source.owner))
      {
      }
 
      constexpr ComponentPtr(std::nullptr_t)
      {
      }
 
 
      ComponentPtr<ComponentType> & operator=(const ComponentPtr<ComponentType> & rhs)
      {
        owner = rhs.owner;
        return *this;
      }
 
      ComponentPtr<ComponentType> & operator=(ComponentPtr<ComponentType> && rhs) noexcept
      {
        owner = std::move(rhs.owner);
        return *this;
      }
 
      ComponentType * get() const
      {
        return owner->getComponent<ComponentType>();
      }
 
      ComponentType * operator ->() const
      {
        return get();
      }
 
      operator bool() const { return owner != nullptr && operator->() != nullptr; }
 
      [[nodiscard]] constexpr bool operator==(const ComponentPtr<ComponentType> & other) const { return owner == other.owner; }
 
      void reset()
      {
        owner.reset();
      }
 
      std::shared_ptr<Entity> getEntity() const { return owner; }
 
    private:
      std::shared_ptr<Entity> owner;
    };
  }
}