runtime_view.hpp

#ifndef ENTT_ENTITY_RUNTIME_VIEW_HPP
#define ENTT_ENTITY_RUNTIME_VIEW_HPP
 
#include <algorithm>
#include <iterator>
#include <type_traits>
#include <utility>
#include <vector>
#include "../config/config.h"
#include "entity.hpp"
#include "fwd.hpp"
#include "sparse_set.hpp"
 
namespace entt {
 
namespace internal {
 
template<typename Set>
class runtime_view_iterator final {
    using iterator_type = typename Set::iterator;
 
    [[nodiscard]] bool valid() const {
        return (!tombstone_check || *it != tombstone)
               && std::all_of(++pools->begin(), pools->end(), [entt = *it](const auto *curr) { return curr->contains(entt); })
               && std::none_of(filter->cbegin(), filter->cend(), [entt = *it](const auto *curr) { return curr && curr->contains(entt); });
    }
 
public:
    using difference_type = typename iterator_type::difference_type;
    using value_type = typename iterator_type::value_type;
    using pointer = typename iterator_type::pointer;
    using reference = typename iterator_type::reference;
    using iterator_category = std::bidirectional_iterator_tag;
 
    runtime_view_iterator() ENTT_NOEXCEPT
        : pools{},
          filter{},
          it{},
          tombstone_check{} {}
 
    runtime_view_iterator(const std::vector<const Set *> &cpools, const std::vector<const Set *> &ignore, iterator_type curr) ENTT_NOEXCEPT
        : pools{&cpools},
          filter{&ignore},
          it{curr},
          tombstone_check{pools->size() == 1u && (*pools)[0u]->policy() == deletion_policy::in_place} {
        if(it != (*pools)[0]->end() && !valid()) {
            ++(*this);
        }
    }
 
    runtime_view_iterator &operator++() {
        while(++it != (*pools)[0]->end() && !valid()) {}
        return *this;
    }
 
    runtime_view_iterator operator++(int) {
        runtime_view_iterator orig = *this;
        return ++(*this), orig;
    }
 
    runtime_view_iterator &operator--() {
        while(--it != (*pools)[0]->begin() && !valid()) {}
        return *this;
    }
 
    runtime_view_iterator operator--(int) {
        runtime_view_iterator orig = *this;
        return operator--(), orig;
    }
 
    [[nodiscard]] pointer operator->() const ENTT_NOEXCEPT {
        return it.operator->();
    }
 
    [[nodiscard]] reference operator*() const ENTT_NOEXCEPT {
        return *operator->();
    }
 
    [[nodiscard]] bool operator==(const runtime_view_iterator &other) const ENTT_NOEXCEPT {
        return it == other.it;
    }
 
    [[nodiscard]] bool operator!=(const runtime_view_iterator &other) const ENTT_NOEXCEPT {
        return !(*this == other);
    }
 
private:
    const std::vector<const Set *> *pools;
    const std::vector<const Set *> *filter;
    iterator_type it;
    bool tombstone_check;
};
 
} // namespace internal
 
template<typename>
struct basic_runtime_view;
 
template<typename Entity, typename Allocator>
struct basic_runtime_view<basic_sparse_set<Entity, Allocator>> {
    using entity_type = Entity;
    using size_type = std::size_t;
    using base_type = basic_sparse_set<Entity, Allocator>;
    using iterator = internal::runtime_view_iterator<base_type>;
 
    basic_runtime_view() ENTT_NOEXCEPT
        : pools{},
          filter{} {}
 
    basic_runtime_view &iterate(const base_type &base) {
        if(pools.empty() || !(base.size() < pools[0u]->size())) {
            pools.push_back(&base);
        } else {
            pools.push_back(std::exchange(pools[0u], &base));
        }
 
        return *this;
    }
 
    basic_runtime_view &exclude(const base_type &base) {
        filter.push_back(&base);
        return *this;
    }
 
    [[nodiscard]] size_type size_hint() const {
        return pools.empty() ? size_type{} : pools.front()->size();
    }
 
    [[nodiscard]] iterator begin() const {
        return pools.empty() ? iterator{} : iterator{pools, filter, pools[0]->begin()};
    }
 
    [[nodiscard]] iterator end() const {
        return pools.empty() ? iterator{} : iterator{pools, filter, pools[0]->end()};
    }
 
    [[nodiscard]] bool contains(const entity_type entt) const {
        return !pools.empty()
               && std::all_of(pools.cbegin(), pools.cend(), [entt](const auto *curr) { return curr->contains(entt); })
               && std::none_of(filter.cbegin(), filter.cend(), [entt](const auto *curr) { return curr && curr->contains(entt); });
    }
 
    template<typename Func>
    void each(Func func) const {
        for(const auto entity: *this) {
            func(entity);
        }
    }
 
private:
    std::vector<const base_type *> pools;
    std::vector<const base_type *> filter;
};
 
} // namespace entt
 
#endif