range.hpp

#ifndef ENTT_META_RANGE_HPP
#define ENTT_META_RANGE_HPP
 
#include <cstddef>
#include <iterator>
#include "../core/iterator.hpp"
 
namespace entt {
 
namespace internal {
 
template<typename Type, typename Node>
struct meta_range_iterator final {
    using difference_type = std::ptrdiff_t;
    using value_type = Type;
    using pointer = input_iterator_pointer<value_type>;
    using reference = value_type;
    using iterator_category = std::input_iterator_tag;
    using node_type = Node;
 
    meta_range_iterator() ENTT_NOEXCEPT
        : it{} {}
 
    meta_range_iterator(node_type *head) ENTT_NOEXCEPT
        : it{head} {}
 
    meta_range_iterator &operator++() ENTT_NOEXCEPT {
        return (it = it->next), *this;
    }
 
    meta_range_iterator operator++(int) ENTT_NOEXCEPT {
        meta_range_iterator orig = *this;
        return ++(*this), orig;
    }
 
    [[nodiscard]] reference operator*() const ENTT_NOEXCEPT {
        return it;
    }
 
    [[nodiscard]] pointer operator->() const ENTT_NOEXCEPT {
        return operator*();
    }
 
    [[nodiscard]] bool operator==(const meta_range_iterator &other) const ENTT_NOEXCEPT {
        return it == other.it;
    }
 
    [[nodiscard]] bool operator!=(const meta_range_iterator &other) const ENTT_NOEXCEPT {
        return !(*this == other);
    }
 
private:
    node_type *it;
};
 
} // namespace internal
 
template<typename Type, typename Node = typename Type::node_type>
struct meta_range final {
    using node_type = Node;
    using iterator = internal::meta_range_iterator<Type, Node>;
    using const_iterator = iterator;
 
    meta_range() ENTT_NOEXCEPT = default;
 
    meta_range(node_type *head) ENTT_NOEXCEPT
        : node{head} {}
 
    [[nodiscard]] const_iterator cbegin() const ENTT_NOEXCEPT {
        return iterator{node};
    }
 
    [[nodiscard]] iterator begin() const ENTT_NOEXCEPT {
        return cbegin();
    }
 
    [[nodiscard]] const_iterator cend() const ENTT_NOEXCEPT {
        return iterator{};
    }
 
    [[nodiscard]] iterator end() const ENTT_NOEXCEPT {
        return cend();
    }
 
private:
    node_type *node{nullptr};
};
 
} // namespace entt
 
#endif