view.hpp

Go to the documentation of this file.

#pragma once
 
#include <co_ecs/detail/views.hpp>
#include <co_ecs/registry.hpp>
#include <co_ecs/thread_pool/parallel_for.hpp>
 
#include <type_traits>
 
namespace co_ecs {
 
template<component_reference... Args>
class view {
private:
    static constexpr bool is_const = detail::view_arguments<Args...>::is_const;
 
    using value_type = std::tuple<Args...>;
 
    using registry_type = std::conditional_t<is_const, const registry&, registry&>;
 
public:
    explicit view(registry_type registry) noexcept : _registry(registry) {
    }
 
    auto single() -> std::optional<std::tuple<Args...>>
        requires(!is_const)
    {
        for (auto chunk : chunks(_registry.archetypes())) {
            for (auto entry : chunk) {
                return entry;
            }
        }
        return {};
    }
 
    auto single() const -> std::optional<std::tuple<Args...>>
        requires(is_const)
    {
        for (auto chunk : chunks(_registry.archetypes())) {
            for (auto entry : chunk) {
                return entry;
            }
        }
        return {};
    }
 
    auto each() -> decltype(auto)
        requires(!is_const)
    {
        return chunks(_registry.archetypes()) | detail::views::join; // join all chunks together
    }
 
    auto each() const -> decltype(auto)
        requires(is_const)
    {
        return chunks(_registry.archetypes()) | detail::views::join; // join all chunks together
    }
 
    void each(auto&& func)
        requires(!is_const)
    {
        for (auto chunk : chunks(_registry.archetypes())) {
            for (auto entry : chunk) {
                std::apply(func, entry);
            }
        }
    }
 
    void each(auto&& func) const
        requires(is_const)
    {
        for (auto chunk : chunks(_registry.archetypes())) {
            for (auto entry : chunk) {
                std::apply(func, entry);
            }
        }
    }
 
    void par_each(auto&& func)
        requires(!is_const)
    {
        co_ecs::parallel_for(chunks(),
            [&func](auto chunk) { std::ranges::for_each(chunk, [&](auto&& elem) { std::apply(func, elem); }); });
    }
 
    void par_each(auto&& func) const
        requires(is_const)
    {
        co_ecs::parallel_for(chunks(),
            [&func](auto chunk) { std::ranges::for_each(chunk, [&](auto&& elem) { std::apply(func, elem); }); });
    }
 
    auto chunks() -> decltype(auto) {
        return chunks(_registry.archetypes());
    }
 
    auto chunks() const -> decltype(auto) {
        return chunks(_registry.archetypes());
    }
 
private:
    template<component C>
    constexpr static bool match(auto& archetype) {
        if constexpr (std::is_same_v<C, entity>) {
            return true;
        } else {
            return archetype->template contains<C>();
        }
    }
 
    constexpr static auto chunks(auto&& archetypes) -> decltype(auto) {
        auto filter_archetypes = [](auto& archetype) -> bool {
            return (match<decay_component_t<Args>>(archetype) && ...);
        };
        auto into_chunks = [](auto& archetype) -> decltype(auto) { return archetype->chunks(); };
        auto as_typed_chunk = [](auto& chunk) -> decltype(auto) { return chunk_view<Args...>(chunk); };
 
        return archetypes                                  // for each archetype entry in archetype map
               | detail::views::values                     // for each value, a pointer to archetype
               | detail::views::filter(filter_archetypes)  // filter archetype by requested components
               | detail::views::transform(into_chunks)     // fetch chunks vector
               | detail::views::join                       // join chunks together
               | detail::views::transform(as_typed_chunk); // each chunk casted to a typed chunk view range-like type
    }
 
    registry_type _registry; 
};
 
 
} // namespace co_ecs