observer.hpp

#ifndef ENTT_ENTITY_OBSERVER_HPP
#define ENTT_ENTITY_OBSERVER_HPP
 
#include <cstddef>
#include <cstdint>
#include <limits>
#include <type_traits>
#include <utility>
#include "../core/type_traits.hpp"
#include "fwd.hpp"
#include "storage.hpp"
 
namespace entt {
 
template<typename...>
struct matcher {};
 
template<typename...>
struct basic_collector;
 
template<>
struct basic_collector<> {
    template<typename... AllOf, typename... NoneOf>
    static constexpr auto group(exclude_t<NoneOf...> = exclude_t{}) noexcept {
        return basic_collector<matcher<type_list<>, type_list<>, type_list<NoneOf...>, AllOf...>>{};
    }
 
    template<typename AnyOf>
    static constexpr auto update() noexcept {
        return basic_collector<matcher<type_list<>, type_list<>, AnyOf>>{};
    }
};
 
template<typename... Reject, typename... Require, typename... Rule, typename... Other>
struct [[deprecated("use reactive mixin instead")]] basic_collector<matcher<type_list<Reject...>, type_list<Require...>, Rule...>, Other...> {
    using current_type = matcher<type_list<Reject...>, type_list<Require...>, Rule...>;
 
    template<typename... AllOf, typename... NoneOf>
    static constexpr auto group(exclude_t<NoneOf...> = exclude_t{}) noexcept {
        return basic_collector<matcher<type_list<>, type_list<>, type_list<NoneOf...>, AllOf...>, current_type, Other...>{};
    }
 
    template<typename AnyOf>
    static constexpr auto update() noexcept {
        return basic_collector<matcher<type_list<>, type_list<>, AnyOf>, current_type, Other...>{};
    }
 
    template<typename... AllOf, typename... NoneOf>
    static constexpr auto where(exclude_t<NoneOf...> = exclude_t{}) noexcept {
        using extended_type = matcher<type_list<Reject..., NoneOf...>, type_list<Require..., AllOf...>, Rule...>;
        return basic_collector<extended_type, Other...>{};
    }
};
 
inline constexpr basic_collector<> collector{};
 
template<typename Registry, typename Allocator>
class basic_observer {
    using mask_type = std::uint64_t;
    using storage_type = basic_storage<mask_type, typename Registry::entity_type, typename std::allocator_traits<Allocator>::template rebind_alloc<mask_type>>;
 
    template<std::size_t Index>
    static void discard_if(storage_type &storage, Registry &, const typename Registry::entity_type entt) {
        if(storage.contains(entt) && !(storage.get(entt) &= (~(1 << Index)))) {
            storage.erase(entt);
        }
    }
 
    template<typename>
    struct matcher_handler;
 
    template<typename... Reject, typename... Require, typename AnyOf>
    struct matcher_handler<matcher<type_list<Reject...>, type_list<Require...>, AnyOf>> {
        template<std::size_t Index>
        static void maybe_valid_if(storage_type &storage, Registry &parent, const typename Registry::entity_type entt) {
            if(parent.template all_of<Require...>(entt) && !parent.template any_of<Reject...>(entt)) {
                if(!storage.contains(entt)) {
                    storage.emplace(entt);
                }
 
                storage.get(entt) |= (1 << Index);
            }
        }
 
        template<std::size_t Index>
        static void connect(storage_type &storage, Registry &parent) {
            (parent.template on_destroy<Require>().template connect<&discard_if<Index>>(storage), ...);
            (parent.template on_construct<Reject>().template connect<&discard_if<Index>>(storage), ...);
            parent.template on_update<AnyOf>().template connect<&maybe_valid_if<Index>>(storage);
            parent.template on_destroy<AnyOf>().template connect<&discard_if<Index>>(storage);
        }
 
        static void disconnect(storage_type &storage, Registry &parent) {
            (parent.template on_destroy<Require>().disconnect(&storage), ...);
            (parent.template on_construct<Reject>().disconnect(&storage), ...);
            parent.template on_update<AnyOf>().disconnect(&storage);
            parent.template on_destroy<AnyOf>().disconnect(&storage);
        }
    };
 
    template<typename... Reject, typename... Require, typename... NoneOf, typename... AllOf>
    struct matcher_handler<matcher<type_list<Reject...>, type_list<Require...>, type_list<NoneOf...>, AllOf...>> {
        template<std::size_t Index, typename... Ignore>
        static void maybe_valid_if(storage_type &storage, Registry &parent, const typename Registry::entity_type entt) {
            bool guard{};
 
            if constexpr(sizeof...(Ignore) == 0) {
                guard = parent.template all_of<AllOf..., Require...>(entt) && !parent.template any_of<NoneOf..., Reject...>(entt);
            } else {
                guard = parent.template all_of<AllOf..., Require...>(entt) && ((std::is_same_v<Ignore..., NoneOf> || !parent.template any_of<NoneOf>(entt)) && ...) && !parent.template any_of<Reject...>(entt);
            }
 
            if(guard) {
                if(!storage.contains(entt)) {
                    storage.emplace(entt);
                }
 
                storage.get(entt) |= (1 << Index);
            }
        }
 
        template<std::size_t Index>
        static void connect(storage_type &storage, Registry &parent) {
            (parent.template on_destroy<Require>().template connect<&discard_if<Index>>(storage), ...);
            (parent.template on_construct<Reject>().template connect<&discard_if<Index>>(storage), ...);
            (parent.template on_construct<AllOf>().template connect<&maybe_valid_if<Index>>(storage), ...);
            (parent.template on_destroy<NoneOf>().template connect<&maybe_valid_if<Index, NoneOf>>(storage), ...);
            (parent.template on_destroy<AllOf>().template connect<&discard_if<Index>>(storage), ...);
            (parent.template on_construct<NoneOf>().template connect<&discard_if<Index>>(storage), ...);
        }
 
        static void disconnect(storage_type &storage, Registry &parent) {
            (parent.template on_destroy<Require>().disconnect(&storage), ...);
            (parent.template on_construct<Reject>().disconnect(&storage), ...);
            (parent.template on_construct<AllOf>().disconnect(&storage), ...);
            (parent.template on_destroy<NoneOf>().disconnect(&storage), ...);
            (parent.template on_destroy<AllOf>().disconnect(&storage), ...);
            (parent.template on_construct<NoneOf>().disconnect(&storage), ...);
        }
    };
 
    template<typename... Matcher>
    static void disconnect(Registry &parent, storage_type &storage) {
        (matcher_handler<Matcher>::disconnect(storage, parent), ...);
    }
 
    template<typename... Matcher, std::size_t... Index>
    static void connect(Registry &parent, storage_type &storage, std::index_sequence<Index...>) {
        static_assert(sizeof...(Matcher) < std::numeric_limits<mask_type>::digits, "Too many matchers");
        (matcher_handler<Matcher>::template connect<Index>(storage, parent), ...);
    }
 
public:
    using allocator_type = Allocator;
    using registry_type = Registry;
    using entity_type = typename registry_type::entity_type;
    using size_type = std::size_t;
    using iterator = typename registry_type::common_type::iterator;
 
    basic_observer()
        : basic_observer{allocator_type{}} {}
 
    explicit basic_observer(const allocator_type &allocator)
        : release{},
          parent{},
          storage{allocator} {}
 
    basic_observer(const basic_observer &) = delete;
 
    basic_observer(basic_observer &&) = delete;
 
    template<typename... Matcher>
    basic_observer(registry_type &reg, basic_collector<Matcher...>, const allocator_type &allocator = allocator_type{})
        : release{&basic_observer::disconnect<Matcher...>},
          parent{&reg},
          storage{allocator} {
        connect<Matcher...>(reg, storage, std::index_sequence_for<Matcher...>{});
    }
 
    ~basic_observer() = default;
 
    basic_observer &operator=(const basic_observer &) = delete;
 
    basic_observer &operator=(basic_observer &&) = delete;
 
    template<typename... Matcher>
    void connect(registry_type &reg, basic_collector<Matcher...>) {
        disconnect();
        storage.clear();
 
        parent = &reg;
        release = &basic_observer::disconnect<Matcher...>;
        connect<Matcher...>(reg, storage, std::index_sequence_for<Matcher...>{});
    }
 
    void disconnect() {
        if(release) {
            release(*parent, storage);
            release = nullptr;
        }
    }
 
    [[nodiscard]] size_type size() const noexcept {
        return storage.size();
    }
 
    [[nodiscard]] bool empty() const noexcept {
        return storage.empty();
    }
 
    [[nodiscard]] const entity_type *data() const noexcept {
        return storage.data();
    }
 
    [[nodiscard]] iterator begin() const noexcept {
        return storage.storage_type::base_type::begin();
    }
 
    [[nodiscard]] iterator end() const noexcept {
        return storage.storage_type::base_type::end();
    }
 
    void clear() noexcept {
        storage.clear();
    }
 
    template<typename Func>
    void each(Func func) const {
        for(const auto entity: *this) {
            func(entity);
        }
    }
 
    template<typename Func>
    void each(Func func) {
        std::as_const(*this).each(std::move(func));
        clear();
    }
 
private:
    void (*release)(registry_type &, storage_type &);
    registry_type *parent;
    storage_type storage;
};
 
} // namespace entt
 
#endif