Entity.hpp

Go to the documentation of this file.

 
 
#ifndef ECSTASY_RESOURCE_ENTITY_ENTITY_HPP_
#define ECSTASY_RESOURCE_ENTITY_ENTITY_HPP_
 
#include <compare>
#include <stddef.h>
#include <stdexcept>
 
#include "ecstasy/storages/IStorage.hpp"
#include "ecstasy/storages/StorageConcepts.hpp"
 
namespace ecstasy
{
    class Entities;
 
    class Entity {
      public:
        using Index = size_t;
        using Generation = size_t;
 
        [[nodiscard]] constexpr Index getIndex() const noexcept
        {
            return _index;
        }
 
        [[nodiscard]] constexpr Generation getGeneration() const noexcept
        {
            return _generation;
        }
 
        [[nodiscard]] constexpr auto operator<=>(Entity const &other) const noexcept
        {
            return this->_index <=> other._index;
        }
 
        [[nodiscard]] constexpr bool operator==(Entity const &other) const noexcept
        {
            return this->_index == other._index;
        }
 
        template <IsStorage S, typename... Args>
        typename S::Component &add(S &storage, Args &&...args)
        {
            if (storage.contains(_index)) [[unlikely]]
                throw std::logic_error(std::string("Trying to add twice the component ")
                    + typeid(typename S::Component).name() + " on the same entity.");
            return storage.emplace(_index, std::forward<Args>(args)...);
        }
 
        template <IsStorage S>
        typename S::Component &operator[](S &storage)
        {
            if (!storage.contains(_index)) [[unlikely]]
                return storage.emplace(_index);
            return storage[_index];
        }
 
        template <IsStorage S>
        const typename S::Component &operator[](S &storage) const
        {
            return storage[_index];
        }
 
        template <IsStorage S>
        [[nodiscard]] const typename S::Component &get(S &storage) const
        {
            return storage[_index];
        }
 
        template <IsStorage S>
        [[nodiscard]] typename S::Component &get(S &storage)
        {
            return storage[_index];
        }
 
        template <IsStorage S>
        [[nodiscard]] bool has(S &storage) const
        {
            return storage.contains(_index);
        }
 
      protected:
        Index _index;
        Generation _generation;
 
        constexpr Entity(Index index, Generation generation) noexcept : _index(index), _generation(generation){};
 
        friend class ::ecstasy::Entities;
    };
} // namespace ecstasy
 
#endif /* !ECSTASY_RESOURCE_ENTITY_ENTITY_HPP_ */