runtime_view.hpp

#ifndef ENTT_ENTITY_RUNTIME_VIEW_HPP
#define ENTT_ENTITY_RUNTIME_VIEW_HPP
 
 
#include <iterator>
#include <vector>
#include <utility>
#include <algorithm>
#include <type_traits>
#include "../config/config.h"
#include "sparse_set.hpp"
#include "fwd.hpp"
 
 
namespace entt {
 
 
template<typename Entity>
class basic_runtime_view {
    friend class basic_registry<Entity>;
 
    using underlying_iterator = typename sparse_set<Entity>::iterator;
 
    class view_iterator final {
        friend class basic_runtime_view<Entity>;
 
        view_iterator(const std::vector<const sparse_set<Entity> *> &cpools, const std::vector<const sparse_set<Entity> *> &ignore, underlying_iterator curr) ENTT_NOEXCEPT
            : pools{&cpools},
              filter{&ignore},
              it{curr}
        {
            if(it != (*pools)[0]->end() && !valid()) {
                ++(*this);
            }
        }
 
        [[nodiscard]] bool valid() const {
            return 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 underlying_iterator::difference_type;
        using value_type = typename underlying_iterator::value_type;
        using pointer = typename underlying_iterator::pointer;
        using reference = typename underlying_iterator::reference;
        using iterator_category = std::bidirectional_iterator_tag;
 
        view_iterator() ENTT_NOEXCEPT = default;
 
        view_iterator & operator++() {
            while(++it != (*pools)[0]->end() && !valid());
            return *this;
        }
 
        view_iterator operator++(int) {
            view_iterator orig = *this;
            return ++(*this), orig;
        }
 
        view_iterator & operator--() ENTT_NOEXCEPT {
            while(--it != (*pools)[0]->begin() && !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.operator->();
        }
 
        [[nodiscard]] reference operator*() const {
            return *operator->();
        }
 
    private:
        const std::vector<const sparse_set<Entity> *> *pools;
        const std::vector<const sparse_set<Entity> *> *filter;
        underlying_iterator it;
    };
 
    basic_runtime_view(std::vector<const sparse_set<Entity> *> cpools, std::vector<const sparse_set<Entity> *> epools) ENTT_NOEXCEPT
        : pools{std::move(cpools)},
          filter{std::move(epools)}
    {
        const auto it = std::min_element(pools.begin(), pools.end(), [](const auto *lhs, const auto *rhs) {
            return (!lhs && rhs) || (lhs && rhs && lhs->size() < rhs->size());
        });
 
        // brings the best candidate (if any) on front of the vector
        std::rotate(pools.begin(), it, pools.end());
    }
 
    [[nodiscard]] bool valid() const {
        return !pools.empty() && pools.front();
    }
 
public:
    using entity_type = Entity;
    using size_type = std::size_t;
    using iterator = view_iterator;
 
    [[nodiscard]] size_type size() const {
        return valid() ? pools.front()->size() : size_type{};
    }
 
    [[nodiscard]] bool empty() const {
        return !valid() || pools.front()->empty();
    }
 
    [[nodiscard]] iterator begin() const {
        return valid() ? iterator{pools, filter, pools[0]->begin()} : iterator{};
    }
 
    [[nodiscard]] iterator end() const {
        return valid() ? iterator{pools, filter, pools[0]->end()} : iterator{};
    }
 
    [[nodiscard]] bool contains(const entity_type entt) const {
        return valid() && 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 sparse_set<Entity> *> pools;
    std::vector<const sparse_set<Entity> *> filter;
};
 
 
}
 
 
#endif