range.hpp

#ifndef ENTT_META_RANGE_HPP
#define ENTT_META_RANGE_HPP
 
#include <compare>
#include "../core/fwd.hpp"
#include "../core/iterator.hpp"
#include "../stl/concepts.hpp"
#include "../stl/cstddef.hpp"
#include "../stl/iterator.hpp"
#include "../stl/utility.hpp"
#include "context.hpp"
 
namespace entt {

namespace internal {
 
struct meta_base_node;
 
template<typename Type, typename It>
struct meta_range_iterator final {
    using value_type = stl::pair<id_type, Type>;
    using pointer = input_iterator_pointer<value_type>;
    using reference = value_type;
    using difference_type = stl::ptrdiff_t;
    using iterator_category = stl::input_iterator_tag;
    using iterator_concept = stl::random_access_iterator_tag;
 
    constexpr meta_range_iterator() noexcept
        : it{},
          ctx{} {}
 
    constexpr meta_range_iterator(const meta_ctx &area, const It iter) noexcept
        : it{iter},
          ctx{&area} {}
 
    constexpr meta_range_iterator &operator++() noexcept {
        return ++it, *this;
    }
 
    constexpr meta_range_iterator operator++(int) noexcept {
        const meta_range_iterator orig = *this;
        return ++(*this), orig;
    }
 
    constexpr meta_range_iterator &operator--() noexcept {
        return --it, *this;
    }
 
    constexpr meta_range_iterator operator--(int) noexcept {
        const meta_range_iterator orig = *this;
        return operator--(), orig;
    }
 
    constexpr meta_range_iterator &operator+=(const difference_type value) noexcept {
        it += value;
        return *this;
    }
 
    constexpr meta_range_iterator operator+(const difference_type value) const noexcept {
        meta_range_iterator copy = *this;
        return (copy += value);
    }
 
    constexpr meta_range_iterator &operator-=(const difference_type value) noexcept {
        return (*this += -value);
    }
 
    constexpr meta_range_iterator operator-(const difference_type value) const noexcept {
        return (*this + -value);
    }
 
    [[nodiscard]] constexpr reference operator[](const difference_type value) const noexcept {
        if constexpr(stl::is_same_v<It, typename meta_context::bucket_type::const_iterator>) {
            return {it[value].first, Type{*ctx, *it[value].second}};
        } else {
            return {it[value].id, Type{*ctx, it[value]}};
        }
    }
 
    [[nodiscard]] constexpr pointer operator->() const noexcept {
        return operator*();
    }
 
    [[nodiscard]] constexpr reference operator*() const noexcept {
        return operator[](0);
    }
 
    [[nodiscard]] constexpr stl::ptrdiff_t operator-(const meta_range_iterator &other) const noexcept {
        return it - other.it;
    }
 
    [[nodiscard]] constexpr bool operator==(const meta_range_iterator &other) const noexcept {
        return it == other.it;
    }
 
    [[nodiscard]] constexpr auto operator<=>(const meta_range_iterator &other) const noexcept {
        return it <=> other.it;
    }
 
private:
    It it;
    const meta_ctx *ctx;
};
 
} // namespace internal

template<typename Type, stl::forward_iterator It>
using meta_range = iterable_adaptor<internal::meta_range_iterator<Type, It>>;
 
} // namespace entt
 
#endif