helper.hpp

#ifndef ENTT_ENTITY_HELPER_HPP
#define ENTT_ENTITY_HELPER_HPP
 
 
#include <type_traits>
#include "../config/config.h"
#include "../core/type_traits.hpp"
#include "../signal/delegate.hpp"
#include "registry.hpp"
#include "fwd.hpp"
 
 
namespace entt {
 
 
template<typename Entity>
struct as_view {
    using entity_type = std::remove_const_t<Entity>;
    using registry_type = constness_as_t<basic_registry<entity_type>, Entity>;
 
    as_view(registry_type &source) ENTT_NOEXCEPT: reg{source} {}
 
    template<typename Exclude, typename... Component>
    operator basic_view<entity_type, Exclude, Component...>() const {
        return reg.template view<Component...>(Exclude{});
    }
 
private:
    registry_type &reg;
};
 
 
template<typename Entity>
as_view(basic_registry<Entity> &) ENTT_NOEXCEPT -> as_view<Entity>;
 
 
template<typename Entity>
as_view(const basic_registry<Entity> &) ENTT_NOEXCEPT -> as_view<const Entity>;
 
 
template<typename Entity>
struct as_group {
    using entity_type = std::remove_const_t<Entity>;
    using registry_type = constness_as_t<basic_registry<entity_type>, Entity>;
 
    as_group(registry_type &source) ENTT_NOEXCEPT: reg{source} {}
 
    template<typename Exclude, typename Get, typename... Owned>
    operator basic_group<entity_type, Exclude, Get, Owned...>() const {
        if constexpr(std::is_const_v<registry_type>) {
            return reg.template group_if_exists<Owned...>(Get{}, Exclude{});
        } else {
            return reg.template group<Owned...>(Get{}, Exclude{});
        }
    }
 
private:
    registry_type &reg;
};
 
 
template<typename Entity>
as_group(basic_registry<Entity> &) ENTT_NOEXCEPT -> as_group<Entity>;
 
 
template<typename Entity>
as_group(const basic_registry<Entity> &) ENTT_NOEXCEPT -> as_group<const Entity>;
 
 
 
template<auto Member, typename Entity = entity>
void invoke(basic_registry<Entity> &reg, const Entity entt) {
    static_assert(std::is_member_function_pointer_v<decltype(Member)>, "Invalid pointer to non-static member function");
    delegate<void(basic_registry<Entity> &, const Entity)> func;
    func.template connect<Member>(reg.template get<member_class_t<decltype(Member)>>(entt));
    func(reg, entt);
}
 
 
template<typename Entity, typename Component>
Entity to_entity(const basic_registry<Entity> &reg, const Component &component) {
    return *(reg.template data<Component>() + (&component - reg.template raw<Component>()));
}
 
 
}
 
 
#endif