system.hpp

Go to the documentation of this file.

#pragma once
 
#include <co_ecs/command.hpp>
#include <co_ecs/registry.hpp>
#include <co_ecs/thread_pool/thread_pool.hpp>
#include <co_ecs/view.hpp>
 
#include <co_ecs/system/access.hpp>
 
namespace co_ecs {
 
class system_executor_interface {
public:
    virtual ~system_executor_interface() = default;
 
    virtual void run() = 0;
 
    virtual auto name() const -> std::string_view = 0;
 
    virtual auto type_name() const -> std::string_view = 0;
 
    virtual auto access_pattern() const -> access_pattern_t = 0;
};
 
class system_interface {
public:
    virtual ~system_interface() = default;
 
    virtual std::unique_ptr<system_executor_interface> create_executor(registry& registry, void* user_context) = 0;
};
 
 
template<typename T>
class system_argument_state_trait;
 
template<typename... Args>
class system_state {
public:
    using system_state_tuple = std::tuple<typename system_argument_state_trait<Args>::state_type...>;
 
    explicit system_state(registry& registry, void* user_context) :
        _state(typename system_argument_state_trait<Args>::state_type(registry, user_context)...){};
 
    [[nodiscard]] system_state_tuple& get() noexcept {
        return _state;
    }
 
    auto access_pattern() const -> access_pattern_t {
        access_pattern_t pattern;
        if constexpr (0 < std::tuple_size_v<system_state_tuple>) {
            pattern &= std::apply([](auto&&... args) { return (args.access_pattern() & ...); }, _state);
        }
        return pattern;
    }
 
private:
    system_state_tuple _state;
};
 
template<typename T>
struct system_state_trait;
 
template<typename... Ts>
struct system_state_trait<std::tuple<Ts...>> {
    using type = system_state<Ts...>;
};
 
template<typename F>
class system_executor : public system_executor_interface {
public:
    using system_arguments = typename detail::function_traits<F>::arguments_tuple_type;
 
    explicit system_executor(registry& registry, void* user_context, F func, std::string_view name = {}) :
        _func(std::move(func)), _state(registry, user_context), _name(name) {
    }
 
    void run() override {
        std::apply([this](auto&&... args) { _func(args.get()...); }, _state.get());
    }
 
    auto name() const -> std::string_view override {
        return _name;
    }
 
    auto type_name() const -> std::string_view override {
        return co_ecs::type_name<F>();
    }
 
    auto access_pattern() const -> access_pattern_t override {
        return _state.access_pattern();
    }
 
private:
    F _func;
    typename system_state_trait<system_arguments>::type _state;
    std::string_view _name;
};
 
template<typename F>
class system : public system_interface {
public:
    explicit system(F func) : _func(std::move(func)) {
    }
 
    std::unique_ptr<system_executor_interface> create_executor(registry& registry, void* user_context) override {
        return std::make_unique<system_executor<F>>(registry, user_context, _func);
    }
 
private:
    F _func;
};
 
class system_registry_state {
public:
    explicit system_registry_state(registry& registry, void* user_context) noexcept : _registry(registry) {
    }
 
    [[nodiscard]] registry& get() noexcept {
        return _registry;
    }
 
    auto access_pattern() const -> access_pattern_t {
        return access_pattern_t(access_type::write);
    }
 
private:
    registry& _registry;
};
 
template<>
class system_argument_state_trait<registry&> {
public:
    using state_type = system_registry_state;
};
 
class system_const_registry_state {
public:
    explicit system_const_registry_state(registry& registry, void* user_context) noexcept : _registry(registry) {
    }
 
    [[nodiscard]] const registry& get() noexcept {
        return _registry;
    }
 
    auto access_pattern() const -> access_pattern_t {
        return access_pattern_t(access_type::read);
    }
 
private:
    const registry& _registry;
};
 
template<>
class system_argument_state_trait<const registry&> {
public:
    using state_type = system_registry_state;
};
 
class system_command_writer_state {
public:
    explicit system_command_writer_state(registry& registry, void* user_context) noexcept : _registry(registry) {
    }
 
    [[nodiscard]] command_writer get() noexcept {
        return command_writer(_registry);
    }
 
    auto access_pattern() const -> access_pattern_t {
        return access_pattern_t{};
    }
 
private:
    registry& _registry;
};
 
template<>
class system_argument_state_trait<command_writer> {
public:
    using state_type = system_command_writer_state;
};
 
template<typename view_t>
class system_view_state {
public:
    explicit system_view_state(registry& registry, void* user_context) noexcept : _view(registry) {
    }
 
    [[nodiscard]] view_t& get() noexcept {
        return _view;
    }
 
private:
    template<typename T>
    struct access_pattern_helper {};
 
    template<component_reference... Args>
    struct access_pattern_helper<view<Args...>> {
        static auto access_pattern() -> access_pattern_t {
            return (access_pattern_t(
                        std::is_const_v<std::remove_reference_t<Args>> ? access_type::read : access_type::write,
                        component_meta::of<decay_component_t<Args>>())
                    & ...);
        }
    };
 
public:
    auto access_pattern() const -> access_pattern_t {
        return access_pattern_helper<view_t>::access_pattern();
    }
 
private:
    view_t _view;
};
 
template<component_reference... Args>
class system_argument_state_trait<view<Args...>> {
public:
    using state_type = system_view_state<view<Args...>>;
};
 
 
} // namespace co_ecs