range.hpp

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