component.hpp

Go to the documentation of this file.

#pragma once
 
#include <algorithm>
#include <bitset>
#include <cstdint>
#include <functional>
#include <numeric>
#include <stdexcept>
 
#include <co_ecs/detail/dynamic_bitset.hpp>
#include <co_ecs/detail/hash_map.hpp>
#include <co_ecs/detail/type_traits.hpp>
#include <co_ecs/type_meta.hpp>
 
namespace co_ecs {
 
namespace detail {
 
template<typename = void, typename _id_type = std::uint64_t>
class type_registry {
public:
    using id_type = _id_type;
 
    CO_ECS_API static auto id(std::string_view type_string) -> id_type {
        auto [iter, inserted] = get_id_map().emplace(type_string, get_next_id());
        if (inserted) {
            get_next_id()++;
        }
        auto type_id = iter->second;
        return type_id;
    }
 
    CO_ECS_API static auto get_id_map() -> hash_map<std::string_view, id_type>& {
        static hash_map<std::string_view, id_type> id_map{};
        return id_map;
    }
 
    CO_ECS_API static auto get_next_id() -> id_type& {
        static id_type next_id{};
        return next_id;
    }
};
 
template<typename Base = void, typename _id_type = std::uint64_t>
struct type_id {
    using id_type = _id_type;
 
    template<typename T>
    inline static const id_type value = type_registry<Base, id_type>::id(type_name<T>());
};
 
} // namespace detail
 
using component_id_t = std::uint32_t;
 
constexpr auto invalid_component_id = std::numeric_limits<component_id_t>::max();
 
using component_id = detail::type_id<struct _component_family_t, component_id_t>;
 
template<typename T>
concept component =
    std::is_class_v<T> && std::is_nothrow_move_constructible_v<T> && std::is_nothrow_move_assignable_v<T>;
 
template<typename T>
concept component_reference = std::is_reference_v<T> && component<std::remove_cvref_t<T>>;
 
template<component_reference T>
using decay_component_t = std::decay_t<T>;
 
template<component_reference T>
struct const_component_reference {
    constexpr static bool value = std::is_const_v<std::remove_reference_t<T>>;
};
 
template<component_reference T>
constexpr bool const_component_reference_v = const_component_reference<T>::value;
 
template<component_reference T>
struct mutable_component_reference {
    constexpr static bool value = !std::is_const_v<std::remove_reference_t<T>>;
};
 
template<component_reference T>
constexpr bool mutable_component_reference_v = mutable_component_reference<T>::value;
 
template<component_reference... Args>
struct const_component_references {
    constexpr static bool value = std::conjunction_v<const_component_reference<Args>...>;
};
 
template<component_reference... Args>
constexpr bool const_component_references_v = const_component_references<Args...>::value;
 
struct component_meta {
public:
    template<component T>
    static auto of() noexcept -> component_meta {
        return component_meta{
            component_id::value<T>,
            type_meta::of<T>(),
        };
    }
 
    constexpr auto operator<=>(const component_meta& rhs) const noexcept {
        return id <=> rhs.id;
    }
 
    constexpr auto operator==(const component_meta& rhs) const noexcept -> bool {
        return id == rhs.id;
    }
 
    component_id_t id;
    const type_meta* type;
};
 
class component_set {
public:
    using storage_type = detail::dynamic_bitset<>;
 
    template<component... Args>
    static auto create() -> component_set {
        component_set s;
        (..., s.insert<Args>());
        return s;
    }
 
    template<component T>
    void insert() {
        insert(component_id::value<T>);
    }
 
    template<component T>
    void erase() {
        erase(component_id::value<T>);
    }
 
    template<component T>
    [[nodiscard]] auto contains() const -> bool {
        return contains(component_id::value<T>);
    }
 
    void insert(component_id_t id) {
        _bitset.set(id);
    }
 
    void erase(component_id_t id) {
        _bitset.set(id, false);
    }
 
    [[nodiscard]] auto contains(component_id_t id) const -> bool {
        return _bitset.test(id);
    }
 
    void clear() noexcept {
        _bitset.clear();
    }
 
    auto operator==(const component_set& rhs) const noexcept -> bool {
        return _bitset == rhs._bitset;
    }
 
private:
    friend class component_set_hasher;
    storage_type _bitset{};
};
 
class component_set_hasher {
public:
    auto operator()(const component_set& set) const -> std::size_t {
        return std::hash<typename component_set::storage_type>()(set._bitset);
    }
};
 
class component_meta_set {
public:
    using size_type = std::size_t;
    using storage_type = std::vector<component_meta>;
    using value_type = typename storage_type::value_type;
    using const_iterator = typename storage_type::const_iterator;
 
    template<component... Args>
    static auto create() -> component_meta_set {
        component_meta_set s;
        s._components_meta.reserve(sizeof...(Args));
        (..., s.insert<Args>());
        return s;
    }
 
    template<component T>
    constexpr void insert() {
        insert(component_meta::of<T>());
    }
 
    template<component T>
    constexpr void erase() {
        erase(component_id::value<T>);
    }
 
    template<component T>
    [[nodiscard]] auto contains() const -> bool {
        return contains(component_id::value<T>);
    }
 
    void insert(const value_type& meta) {
        if (contains(meta.id)) {
            return;
        }
        _component_set.insert(meta.id);
        _components_meta.emplace_back(meta);
    }
 
    void erase(component_id_t id) {
        if (!contains(id)) {
            return;
        }
        _component_set.erase(id);
        std::erase_if(_components_meta, [id](const auto& meta) { return meta.id == id; });
    }
 
    [[nodiscard]] auto contains(component_id_t id) const -> bool {
        return _component_set.contains(id);
    }
 
    [[nodiscard]] auto size() const noexcept -> size_type {
        return _components_meta.size();
    }
 
    [[nodiscard]] auto begin() const noexcept -> const_iterator {
        return _components_meta.begin();
    }
 
    [[nodiscard]] auto end() const noexcept -> const_iterator {
        return _components_meta.end();
    }
 
    [[nodiscard]] auto cbegin() const noexcept -> const_iterator {
        return begin();
    }
 
    [[nodiscard]] auto cend() const noexcept -> const_iterator {
        return end();
    }
 
    auto operator==(const component_meta_set& rhs) const noexcept -> bool {
        return _component_set == rhs._component_set;
    }
 
    [[nodiscard]] auto ids() const noexcept -> const component_set& {
        return _component_set;
    }
 
private:
    component_set _component_set;
    storage_type _components_meta;
};
 
} // namespace co_ecs