ecs/include/ecs/core/system/data_proxy/single.inl

#pragma once

#include <ecs/core/system/data_proxy/single.h>

namespace ecs {
namespace core {
namespace system {
namespace data_proxy {

    /* single */

    template<typename T_context, typename T_instance>
    template<typename T_func>
    inline void single<T_context, T_instance>
        ::for_entities(T_func&& func) const
    {
        for (auto& e : this->instance.subscribed())
        {
            std::forward<T_func>(func)(e);
        }
    }

    template<typename T_context, typename T_instance>
    template<typename T_func>
    inline void single<T_context, T_instance>
        ::for_other_entities(T_func&& func) const
        { }

    template<typename T_context, typename T_instance>
    template<typename T_func>
    inline void single<T_context, T_instance>
        ::for_all_entities(T_func&& func) const
    {
        for_entities(std::forward<T_func>(func));
    }

    template<typename T_context, typename T_instance>
    inline size_t single<T_context, T_instance>
        ::entity_count() const
    {
        return this->instance.subscribed_count();
    }

    template<typename T_context, typename T_instance>
    inline size_t single<T_context, T_instance>
        ::other_entity_count() const
    {
        return 0;
    }

    template<typename T_context, typename T_instance>
    inline size_t single<T_context, T_instance>
        ::all_entity_count() const
    {
        return entity_count();
    }

    /* make_single */

    template<typename T_context, typename T_instance>
    constexpr decltype(auto) make_single(T_context&& context, T_instance&& instance)
    {
        using context_type  = mp::decay_t<T_context>;
        using instance_type = mp::decay_t<T_instance>;
        return single<context_type, instance_type>(
            std::forward<T_context>(context),
            std::forward<T_instance>(instance));
    }

} } } }