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

#pragma once

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

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

    /* multi */

    template<typename T_context, typename T_instance>
    inline multi<T_context, T_instance>
        ::multi(context_type& p_context, instance_type& p_instance, size_t p_index, size_t p_begin, size_t p_end)
            : base_type (p_context, p_instance)
            , _index    (p_index)
            , _begin    (p_begin)
            , _end      (p_end)
        { }

    template<typename T_context, typename T_instance>
    template<typename T_func>
    inline void multi<T_context, T_instance>
        ::for_entities(T_func&& func) const
    {
        for (size_t i = _begin; i < _end; ++i)
        {
            std::forward<T_func>(func)(this->instance.subscribed()[i]);
        }
    }

    template<typename T_context, typename T_instance>
    template<typename T_func>
    inline void multi<T_context, T_instance>
        ::for_other_entities(T_func&& func) const
    {
        auto& subscribed  = this->instance.subscribed();
        auto  total_count = this->instance.subscribed_count();
        for (size_t i = 0; i < _begin; ++i)
        {
            std::forward<T_func>(func)(subscribed()[i]);
        }
        for (size_t i = _end; i < total_count; ++i)
        {
            std::forward<T_func>(func)(subscribed()[i]);
        }
    }

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

    template<typename T_context, typename T_instance>
    inline size_t multi<T_context, T_instance>
        ::entity_count() const
    {
        return _end - _begin;
    }

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

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

    /* make_multi */

    template<typename T_context, typename T_instance>
    constexpr decltype(auto) make_multi(T_context&& context, T_instance&& instance, size_t index, size_t begin, size_t end)
    {
        using context_type  = mp::decay_t<T_context>;
        using instance_type = mp::decay_t<T_instance>;
        return multi<context_type, instance_type>(
            std::forward<T_context>(context),
            std::forward<T_instance>(instance),
            index,
            begin,
            end);
    }

} } } }