iterator.hpp

#ifndef ENTT_ENTITY_ITERATOR_HPP
#define ENTT_ENTITY_ITERATOR_HPP
 
 
#include <array>
#include <cstddef>
#include <iterator>
#include <tuple>
#include <utility>
#include "../config/config.h"
#include "entity.hpp"
#include "sparse_set.hpp"
 
 
namespace entt {
 
 
struct stable_storage_policy {
    template<typename Entity>
    [[nodiscard]] static constexpr bool accept(const Entity entity) ENTT_NOEXCEPT {
        return entity != tombstone;
    }
};
 
 
struct packed_storage_policy {
    template<typename Entity>
    [[nodiscard]] static constexpr bool accept(const Entity) ENTT_NOEXCEPT {
        return true;
    }
};
 
 
template<typename Policy, typename It, std::size_t AllOf, std::size_t NoneOf>
class view_iterator final {
    using basic_common_type = basic_sparse_set<typename std::iterator_traits<It>::value_type>;
 
    [[nodiscard]] bool valid() const {
        const auto entt = *it;
        return Policy::accept(entt)
            && std::apply([entt](const auto *... curr) { return (curr->contains(entt) && ...); }, pools)
            && std::apply([entt](const auto *... curr) { return (!curr->contains(entt) && ...); }, filter);
    }
 
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
        : first{},
          last{},
          it{},
          pools{},
          filter{}
    {}
 
    view_iterator(It from, It to, It curr, std::array<const basic_common_type *, AllOf> all_of, std::array<const basic_common_type *, NoneOf> none_of) ENTT_NOEXCEPT
        : first{std::move(from)},
          last{std::move(to)},
          it{std::move(curr)},
          pools{all_of},
          filter{none_of}
    {
        if(it != last && !valid()) {
            ++(*this);
        }
    }
 
    view_iterator & operator++() ENTT_NOEXCEPT {
        while(++it != last && !valid());
        return *this;
    }
 
    view_iterator operator++(int) ENTT_NOEXCEPT {
        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;
    std::array<const basic_common_type *, AllOf> pools;
    std::array<const basic_common_type *, NoneOf> filter;
};
 
 
template<typename It>
class view_iterator<packed_storage_policy, It, 0u, 0u> final: public It {
public:
    using It::It;
 
    view_iterator(It it)
        : It{std::move(it)}
    {}
};
 
 
}
 
 
#endif