view.hpp

#ifndef ENTT_ENTITY_VIEW_HPP
#define ENTT_ENTITY_VIEW_HPP
 
 
#include <iterator>
#include <array>
#include <tuple>
#include <utility>
#include <algorithm>
#include <type_traits>
#include "../config/config.h"
#include "../core/type_traits.hpp"
#include "entity.hpp"
#include "fwd.hpp"
#include "pool.hpp"
#include "sparse_set.hpp"
#include "utility.hpp"
 
 
namespace entt {
 
 
template<typename...>
class basic_view;
 
 
template<typename Entity, typename... Exclude, typename... Component>
class basic_view<Entity, exclude_t<Exclude...>, Component...> {
    friend class basic_registry<Entity>;
 
    template<typename Comp>
    using pool_type = pool_t<Entity, Comp>;
 
    template<typename Comp>
    using component_iterator = decltype(std::declval<pool_type<Comp>>().begin());
 
    using unchecked_type = std::array<const sparse_set<Entity> *, (sizeof...(Component) - 1)>;
    using filter_type = std::array<const sparse_set<Entity> *, sizeof...(Exclude)>;
 
    template<typename It>
    class view_iterator final {
        friend class basic_view<Entity, exclude_t<Exclude...>, Component...>;
 
        view_iterator(It from, It to, It curr, unchecked_type other, filter_type ignore) ENTT_NOEXCEPT
            : first{from},
              last{to},
              it{curr},
              unchecked{other},
              filter{ignore}
        {
            if(it != last && !valid()) {
                ++(*this);
            }
        }
 
        [[nodiscard]] bool valid() const {
            return std::all_of(unchecked.cbegin(), unchecked.cend(), [entt = *it](const sparse_set<Entity> *curr) { return curr->contains(entt); })
                    && (sizeof...(Exclude) == 0 || std::none_of(filter.cbegin(), filter.cend(), [entt = *it](const sparse_set<Entity> *cpool) { return cpool->contains(entt); }));
        }
 
    public:
        using difference_type = typename std::iterator_traits<It>::difference_type;
        using value_type = typename std::iterator_traits<It>::value_type;
        using pointer = typename std::iterator_traits<It>::pointer;
        using reference = typename std::iterator_traits<It>::reference;
        using iterator_category = std::bidirectional_iterator_tag;
 
        view_iterator() ENTT_NOEXCEPT = default;
 
        view_iterator & operator++() {
            while(++it != last && !valid());
            return *this;
        }
 
        view_iterator operator++(int) {
            view_iterator orig = *this;
            return ++(*this), orig;
        }
 
        view_iterator & operator--() ENTT_NOEXCEPT {
            while(--it != first && !valid());
            return *this;
        }
 
        view_iterator operator--(int) ENTT_NOEXCEPT {
            view_iterator orig = *this;
            return operator--(), orig;
        }
 
        [[nodiscard]] bool operator==(const view_iterator &other) const ENTT_NOEXCEPT {
            return other.it == it;
        }
 
        [[nodiscard]] bool operator!=(const view_iterator &other) const ENTT_NOEXCEPT {
            return !(*this == other);
        }
 
        [[nodiscard]] pointer operator->() const {
            return &*it;
        }
 
        [[nodiscard]] reference operator*() const {
            return *operator->();
        }
 
    private:
        It first;
        It last;
        It it;
        unchecked_type unchecked;
        filter_type filter;
    };
 
    class view_proxy {
        friend class basic_view<Entity, exclude_t<Exclude...>, Component...>;
 
        using proxy_view_iterator = view_iterator<typename sparse_set<Entity>::iterator>;
 
        class proxy_iterator {
            friend class view_proxy;
 
            using ref_type = decltype(std::tuple_cat(std::declval<std::conditional_t<is_eto_eligible_v<Component>, std::tuple<>, std::tuple<pool_type<Component> *>>>()...));
 
            proxy_iterator(proxy_view_iterator from, ref_type ref) ENTT_NOEXCEPT
                : it{from},
                  pools{ref}
            {}
 
        public:
            using difference_type = std::ptrdiff_t;
            using value_type = decltype(std::tuple_cat(
                std::declval<std::tuple<Entity>>(),
                std::declval<std::conditional_t<is_eto_eligible_v<Component>, std::tuple<>, std::tuple<Component>>>()...
            ));
            using pointer = void;
            using reference = decltype(std::tuple_cat(
                std::declval<std::tuple<Entity>>(),
                std::declval<std::conditional_t<is_eto_eligible_v<Component>, std::tuple<>, std::tuple<Component &>>>()...
            ));
            using iterator_category = std::input_iterator_tag;
 
            proxy_iterator & operator++() ENTT_NOEXCEPT {
                return ++it, *this;
            }
 
            proxy_iterator operator++(int) ENTT_NOEXCEPT {
                proxy_iterator orig = *this;
                return ++(*this), orig;
            }
 
            [[nodiscard]] reference operator*() const ENTT_NOEXCEPT {
                return std::apply([entt = *it](auto *... cpool) { return reference{entt, cpool->get(entt)...}; }, pools);
            }
 
            [[nodiscard]] bool operator==(const proxy_iterator &other) const ENTT_NOEXCEPT {
                return other.it == it;
            }
 
            [[nodiscard]] bool operator!=(const proxy_iterator &other) const ENTT_NOEXCEPT {
                return !(*this == other);
            }
 
        private:
            proxy_view_iterator it{};
            const ref_type pools{};
        };
 
        view_proxy(proxy_view_iterator from, proxy_view_iterator to, std::tuple<pool_type<Component> *...> ref)
            : first{from},
              last{to},
              pools{ref}
        {}
 
    public:
        using iterator = proxy_iterator;
 
        [[nodiscard]] iterator begin() const ENTT_NOEXCEPT {
            return proxy_iterator{first, std::tuple_cat([](auto *cpool) {
                if constexpr(is_eto_eligible_v<typename std::decay_t<decltype(*cpool)>::object_type>) {
                    return std::make_tuple();
                } else {
                    return std::make_tuple(cpool);
                }
            }(std::get<pool_type<Component> *>(pools))...)};
        }
 
        [[nodiscard]] iterator end() const ENTT_NOEXCEPT {
            return proxy_iterator{last, std::tuple_cat([](auto *cpool) {
                if constexpr(is_eto_eligible_v<typename std::decay_t<decltype(*cpool)>::object_type>) {
                    return std::make_tuple();
                } else {
                    return std::make_tuple(cpool);
                }
            }(std::get<pool_type<Component> *>(pools))...)};
        }
 
    private:
        proxy_view_iterator first;
        proxy_view_iterator last;
        const std::tuple<pool_type<Component> *...> pools;
    };
 
    basic_view(pool_type<Component> &... component, unpack_as_t<const sparse_set<Entity>, Exclude> &... epool) ENTT_NOEXCEPT
        : pools{&component...},
          view{candidate()},
          filter{&epool...}
    {}
 
    [[nodiscard]] const sparse_set<Entity> * candidate() const ENTT_NOEXCEPT {
        return (std::min)({ static_cast<const sparse_set<Entity> *>(std::get<pool_type<Component> *>(pools))... }, [](const auto *lhs, const auto *rhs) {
            return lhs->size() < rhs->size();
        });
    }
 
    [[nodiscard]] unchecked_type unchecked(const sparse_set<Entity> *cpool) const {
        std::size_t pos{};
        unchecked_type other{};
        ((std::get<pool_type<Component> *>(pools) == cpool ? nullptr : (other[pos] = std::get<pool_type<Component> *>(pools), other[pos++])), ...);
        return other;
    }
 
    template<typename Comp, typename Other>
    [[nodiscard]] decltype(auto) get([[maybe_unused]] component_iterator<Comp> &it, [[maybe_unused]] pool_type<Other> *cpool, [[maybe_unused]] const Entity entt) const {
        if constexpr(std::is_same_v<Comp, Other>) {
            return *it;
        } else {
            return cpool->get(entt);
        }
    }
 
    template<typename Comp, typename Func, typename... Type>
    void traverse(Func func, type_list<Type...>) const {
        if constexpr(std::disjunction_v<std::is_same<Comp, Type>...>) {
            auto it = std::get<pool_type<Comp> *>(pools)->begin();
 
            for(const auto entt: static_cast<const sparse_set<entity_type> &>(*std::get<pool_type<Comp> *>(pools))) {
                if(((std::is_same_v<Comp, Component> || std::get<pool_type<Component> *>(pools)->contains(entt)) && ...)
                        && (sizeof...(Exclude) == 0 || std::none_of(filter.cbegin(), filter.cend(), [entt](const sparse_set<Entity> *cpool) { return cpool->contains(entt); })))
                {
                    if constexpr(std::is_invocable_v<Func, decltype(get<Type>({}))...>) {
                        func(get<Comp, Type>(it, std::get<pool_type<Type> *>(pools), entt)...);
                    } else {
                        func(entt, get<Comp, Type>(it, std::get<pool_type<Type> *>(pools), entt)...);
                    }
                }
 
                ++it;
            }
        } else {
            for(const auto entt: static_cast<const sparse_set<entity_type> &>(*std::get<pool_type<Comp> *>(pools))) {
                if(((std::is_same_v<Comp, Component> || std::get<pool_type<Component> *>(pools)->contains(entt)) && ...)
                        && (sizeof...(Exclude) == 0 || std::none_of(filter.cbegin(), filter.cend(), [entt](const sparse_set<Entity> *cpool) { return cpool->contains(entt); })))
                {
                    if constexpr(std::is_invocable_v<Func, decltype(get<Type>({}))...>) {
                        func(std::get<pool_type<Type> *>(pools)->get(entt)...);
                    } else {
                        func(entt, std::get<pool_type<Type> *>(pools)->get(entt)...);
                    }
                }
            }
        }
    }
 
    template<typename Func, typename... Type>
    void iterate(Func func, type_list<Type...>) const {
        const auto last = view->data() + view->size();
        auto first = view->data();
 
        while(first != last) {
            if((std::get<pool_type<Component> *>(pools)->contains(*first) && ...)
                    && (sizeof...(Exclude) == 0 || std::none_of(filter.cbegin(), filter.cend(), [entt = *first](const sparse_set<Entity> *cpool) { return cpool->contains(entt); })))
            {
                const auto base = *(first++);
                const auto chunk = (std::min)({ (std::get<pool_type<Component> *>(pools)->size() - std::get<pool_type<Component> *>(pools)->index(base))... });
                size_type length{};
 
                for(++length;
                    length < chunk
                        && ((*(std::get<pool_type<Component> *>(pools)->data() + std::get<pool_type<Component> *>(pools)->index(base) + length) == *first) && ...)
                        && (sizeof...(Exclude) == 0 || std::none_of(filter.cbegin(), filter.cend(), [entt = *first](const sparse_set<Entity> *cpool) { return cpool->contains(entt); }));
                    ++length, ++first);
 
                func(view->data() + view->index(base), (std::get<pool_type<Type> *>(pools)->raw() + std::get<pool_type<Type> *>(pools)->index(base))..., length);
            } else {
                ++first;
            }
        }
    }
 
public:
    using entity_type = Entity;
    using size_type = std::size_t;
    using iterator = view_iterator<typename sparse_set<entity_type>::iterator>;
    using reverse_iterator = view_iterator<typename sparse_set<entity_type>::reverse_iterator>;
 
    template<typename Comp>
    [[nodiscard]] size_type size() const ENTT_NOEXCEPT {
        return std::get<pool_type<Comp> *>(pools)->size();
    }
 
    [[nodiscard]] size_type size() const ENTT_NOEXCEPT {
        return (std::min)({ std::get<pool_type<Component> *>(pools)->size()... });
    }
 
    template<typename... Comp>
    [[nodiscard]] bool empty() const ENTT_NOEXCEPT {
        if constexpr(sizeof...(Comp) == 0) {
            return (std::get<pool_type<Component> *>(pools)->empty() || ...);
        } else {
            return (std::get<pool_type<Comp> *>(pools)->empty() && ...);
        }
    }
 
    template<typename Comp>
    [[nodiscard]] Comp * raw() const ENTT_NOEXCEPT {
        return std::get<pool_type<Comp> *>(pools)->raw();
    }
 
    template<typename Comp>
    [[nodiscard]] const entity_type * data() const ENTT_NOEXCEPT {
        return std::get<pool_type<Comp> *>(pools)->data();
    }
 
    [[nodiscard]] iterator begin() const {
        return iterator{view->begin(), view->end(), view->begin(), unchecked(view), filter};
    }
 
    [[nodiscard]] iterator end() const {
        return iterator{view->begin(), view->end(), view->end(), unchecked(view), filter};
    }
 
    [[nodiscard]] reverse_iterator rbegin() const {
        return reverse_iterator{view->rbegin(), view->rend(), view->rbegin(), unchecked(view), filter};
    }
 
    [[nodiscard]] reverse_iterator rend() const {
        return reverse_iterator{view->rbegin(), view->rend(), view->rend(), unchecked(view), filter};
    }
 
    [[nodiscard]] entity_type front() const {
        const auto it = begin();
        return it != end() ? *it : null;
    }
 
    [[nodiscard]] entity_type back() const {
        const auto it = rbegin();
        return it != rend() ? *it : null;
    }
 
    [[nodiscard]] iterator find(const entity_type entt) const {
        iterator it{view->begin(), view->end(), view->find(entt), unchecked(view), filter};
        return (it != end() && *it == entt) ? it : end();
    }
 
    [[nodiscard]] bool contains(const entity_type entt) const {
        return (std::get<pool_type<Component> *>(pools)->contains(entt) && ...)
                && (sizeof...(Exclude) == 0 || std::none_of(filter.begin(), filter.end(), [entt](const auto *cpool) { return cpool->contains(entt); }));
    }
 
    template<typename... Comp>
    [[nodiscard]] decltype(auto) get([[maybe_unused]] const entity_type entt) const {
        ENTT_ASSERT(contains(entt));
 
        if constexpr(sizeof...(Comp) == 0) {
            static_assert(sizeof...(Component) == 1, "Invalid component type");
            return (std::get<pool_type<Component> *>(pools)->get(entt), ...);
        } else if constexpr(sizeof...(Comp) == 1) {
            return (std::get<pool_type<Comp> *>(pools)->get(entt), ...);
        } else {
            return std::tuple<decltype(get<Comp>({}))...>{get<Comp>(entt)...};
        }
    }
 
    template<typename Func>
    void each(Func func) const {
        view = candidate();
        ((std::get<pool_type<Component> *>(pools) == view ? each<Component>(std::move(func)) : void()), ...);
    }
 
    template<typename Comp, typename Func>
    void each(Func func) const {
        using non_empty_type = type_list_cat_t<std::conditional_t<is_eto_eligible_v<Component>, type_list<>, type_list<Component>>...>;
        traverse<Comp>(std::move(func), non_empty_type{});
    }
 
    [[nodiscard]] auto proxy() const ENTT_NOEXCEPT {
        view = candidate();
        return view_proxy{begin(), end(), pools};
    }
 
    template<typename Comp>
    [[nodiscard]] auto proxy() const ENTT_NOEXCEPT {
        const sparse_set<entity_type> *cpool = std::get<pool_type<Comp> *>(pools);
        iterator first{cpool->begin(), cpool->end(), cpool->begin(), unchecked(cpool), filter};
        iterator last{cpool->begin(), cpool->end(), cpool->end(), unchecked(cpool), filter};
        return view_proxy{std::move(first), std::move(last), pools};
    }
 
    template<typename Func>
    void chunked(Func func) const {
        using non_empty_type = type_list_cat_t<std::conditional_t<is_eto_eligible_v<Component>, type_list<>, type_list<Component>>...>;
        view = candidate();
        iterate(std::move(func), non_empty_type{});
    }
 
private:
    const std::tuple<pool_type<Component> *...> pools;
    mutable const sparse_set<entity_type>* view;
    filter_type filter;
};
 
 
template<typename Entity, typename Component>
class basic_view<Entity, exclude_t<>, Component> {
    friend class basic_registry<Entity>;
 
    using pool_type = pool_t<Entity, Component>;
 
    class view_proxy {
        friend class basic_view<Entity, exclude_t<>, Component>;
 
        class proxy_iterator {
            friend class view_proxy;
 
            using it_type = std::conditional_t<
                is_eto_eligible_v<Component>,
                std::tuple<typename sparse_set<Entity>::iterator>,
                std::tuple<typename sparse_set<Entity>::iterator, decltype(std::declval<pool_type>().begin())>
            >;
 
            proxy_iterator(it_type from) ENTT_NOEXCEPT
                : it{from}
            {}
 
        public:
            using difference_type = std::ptrdiff_t;
            using value_type = std::conditional_t<is_eto_eligible_v<Component>, std::tuple<Entity>, std::tuple<Entity, Component>>;
            using pointer = void;
            using reference = std::conditional_t<is_eto_eligible_v<Component>, std::tuple<Entity>, std::tuple<Entity, Component &>>;
            using iterator_category = std::input_iterator_tag;
 
            proxy_iterator & operator++() ENTT_NOEXCEPT {
                return std::apply([](auto &&... curr) { (++curr, ...); }, it), *this;
            }
 
            proxy_iterator operator++(int) ENTT_NOEXCEPT {
                proxy_iterator orig = *this;
                return ++(*this), orig;
            }
 
            [[nodiscard]] reference operator*() const ENTT_NOEXCEPT {
                return std::apply([](auto &&... curr) { return reference{*curr...}; }, it);
            }
 
            [[nodiscard]] bool operator==(const proxy_iterator &other) const ENTT_NOEXCEPT {
                return std::get<0>(other.it) == std::get<0>(it);
            }
 
            [[nodiscard]] bool operator!=(const proxy_iterator &other) const ENTT_NOEXCEPT {
                return !(*this == other);
            }
 
        private:
            it_type it{};
        };
 
        view_proxy(pool_type &ref)
            : pool{&ref}
        {}
 
    public:
        using iterator = proxy_iterator;
 
        [[nodiscard]] iterator begin() const ENTT_NOEXCEPT {
            if constexpr(is_eto_eligible_v<Component>) {
                return proxy_iterator{std::make_tuple(pool->sparse_set<entity_type>::begin())};
            } else {
                return proxy_iterator{std::make_tuple(pool->sparse_set<entity_type>::begin(), pool->begin())};
            }
        }
 
        [[nodiscard]] iterator end() const ENTT_NOEXCEPT {
            if constexpr(is_eto_eligible_v<Component>) {
                return proxy_iterator{std::make_tuple(pool->sparse_set<entity_type>::end())};
            } else {
                return proxy_iterator{std::make_tuple(pool->sparse_set<entity_type>::end(), pool->end())};
            }
        }
 
    private:
        pool_type *pool;
    };
 
    basic_view(pool_type &ref) ENTT_NOEXCEPT
        : pool{&ref}
    {}
 
public:
    using raw_type = Component;
    using entity_type = Entity;
    using size_type = std::size_t;
    using iterator = typename sparse_set<Entity>::iterator;
    using reverse_iterator = typename sparse_set<Entity>::reverse_iterator;
 
    [[nodiscard]] size_type size() const ENTT_NOEXCEPT {
        return pool->size();
    }
 
    [[nodiscard]] bool empty() const ENTT_NOEXCEPT {
        return pool->empty();
    }
 
    [[nodiscard]] raw_type * raw() const ENTT_NOEXCEPT {
        return pool->raw();
    }
 
    [[nodiscard]] const entity_type * data() const ENTT_NOEXCEPT {
        return pool->data();
    }
 
    [[nodiscard]] iterator begin() const ENTT_NOEXCEPT {
        return pool->sparse_set<Entity>::begin();
    }
 
    [[nodiscard]] iterator end() const ENTT_NOEXCEPT {
        return pool->sparse_set<Entity>::end();
    }
 
    [[nodiscard]] reverse_iterator rbegin() const ENTT_NOEXCEPT {
        return pool->sparse_set<Entity>::rbegin();
    }
 
    [[nodiscard]] reverse_iterator rend() const ENTT_NOEXCEPT {
        return pool->sparse_set<Entity>::rend();
    }
 
    [[nodiscard]] entity_type front() const {
        const auto it = begin();
        return it != end() ? *it : null;
    }
 
    [[nodiscard]] entity_type back() const {
        const auto it = rbegin();
        return it != rend() ? *it : null;
    }
 
    [[nodiscard]] iterator find(const entity_type entt) const {
        const auto it = pool->find(entt);
        return it != end() && *it == entt ? it : end();
    }
 
    [[nodiscard]] entity_type operator[](const size_type pos) const {
        return begin()[pos];
    }
 
    [[nodiscard]] bool contains(const entity_type entt) const {
        return pool->contains(entt);
    }
 
    template<typename Comp = Component>
    [[nodiscard]] decltype(auto) get(const entity_type entt) const {
        static_assert(std::is_same_v<Comp, Component>, "Invalid component type");
        ENTT_ASSERT(contains(entt));
        return pool->get(entt);
    }
 
    template<typename Func>
    void each(Func func) const {
        if constexpr(is_eto_eligible_v<Component>) {
            if constexpr(std::is_invocable_v<Func>) {
                for(auto pos = pool->size(); pos; --pos) {
                    func();
                }
            } else {
                for(const auto entt: *this) {
                    func(entt);
                }
            }
        } else {
            if constexpr(std::is_invocable_v<Func, decltype(get({}))>) {
                for(auto &&component: *pool) {
                    func(component);
                }
            } else {
                auto raw = pool->begin();
 
                for(const auto entt: *this) {
                    func(entt, *(raw++));
                }
            }
        }
    }
 
    [[nodiscard]] auto proxy() const ENTT_NOEXCEPT {
        return view_proxy{*pool};
    }
 
private:
    pool_type *pool;
};
 
 
}
 
 
#endif