ecs/include/ecs/signature_list/system.h

#pragma once

#include <ecs/config.h>
#include <ecs/tag/system.h>
#include <ecs/signature/system.h>

beg_namespace_ecs_signature_list_system
{

    namespace __impl
    {
        template<typename... T_system_signatures>
        struct signature_list_t
        {
        public:
            core::mp::list::type<T_system_signatures...> items;

        public: /* misc */
            constexpr decltype(auto) size() const noexcept
                { return hana::size(items); }

        public: /* get */
            constexpr decltype(auto) tags() const noexcept
            {
                return hana::unpack(
                    hana::transform(items, [](auto& ssig){
                        return core::mp::unwrap(ssig).tag();
                    }),
                    core::mp::list::make);
            }

            template<typename T_system_tag>
            constexpr decltype(auto) get_by_tag(T_system_tag st) const noexcept
            {
                static_assert(decltype(tag::system::is_valid(st)) { });
                using namespace ::ecs::core::mp;
                return *hana::find_if(items, [](auto ssig){
                    using is_same_type = std::is_same<
                        decay_t<decltype(unwrapped(ssig).tag())>,
                        decay_t<decltype(st)>>;
                    return is_same_type { };
                });
            }

            template<typename T_system>
            constexpr decltype(auto) get_by_type(T_system) const noexcept
            {
                using system_type = typename core::mp::decay_t<T_system>::type;
                return get_by_tag(tag::system::value<system_type>);
            }

            template<typename T_system>
            constexpr decltype(auto) get_by_type() const noexcept
                { return get_by_tag(tag::system::value<T_system>); }

            template<typename T_index>
            constexpr decltype(auto) get_by_index(T_index index) const noexcept
                { return hana::at(items, index); }

        public: /* id */
            template<typename T_system_signature>
            constexpr decltype(auto) id_by_signature(T_system_signature ssig) const noexcept
                { return core::mp::list::index_of(items, ssig); }

            template<typename T_system>
            constexpr decltype(auto) id_by_type() const noexcept
                { return id_by_signature(get_by_type<T_system>()); }

            template<typename T_system_tag>
            constexpr decltype(auto) id_by_tag(T_system_tag st) const noexcept
                { return id_by_signature(signature_by_tag(st)); }
        };

        struct make_t
        {
            template<typename... T_system_signatures>
            constexpr decltype(auto) operator()(T_system_signatures... sss) const noexcept
            {
                using namespace ::ecs::core::mp;
                static_assert(
                    decltype(signature::system::is_valid(sss...)) { },
                    "system::signature_list::make() needs a list of system signatures");
                return signature_list_t<hana::type<core::mp::decay_t<T_system_signatures>>...> { };
            }
        };

        struct is_valid_t
        {
            template<typename T_system_signature_list>
            constexpr decltype(auto) operator()(T_system_signature_list&& ssl) const noexcept
            {
                return hana::all_of(
                    hana::transform(
                        std::forward<T_system_signature_list>(ssl).items, core::mp::unwrap),
                        signature::system::is_valid);
            }
        };
    }

    constexpr decltype(auto) make = __impl::make_t { };

    constexpr decltype(auto) is_valid = __impl::is_valid_t { };

}
end_namespace_ecs_signature_list_system