iterator.hpp

#ifndef ENTT_CORE_ITERATOR_HPP
#define ENTT_CORE_ITERATOR_HPP
 
#include "../stl/concepts.hpp"
#include "../stl/cstddef.hpp"
#include "../stl/iterator.hpp"
#include "../stl/memory.hpp"
#include "../stl/type_traits.hpp"
#include "../stl/utility.hpp"
 
namespace entt {

template<typename Type>
struct input_iterator_pointer final {
    using value_type = Type;
    using pointer = Type *;
    using reference = Type &;

    constexpr input_iterator_pointer(value_type &&val) noexcept(stl::is_nothrow_move_constructible_v<value_type>)
        : value{stl::move(val)} {}

    [[nodiscard]] constexpr pointer operator->() noexcept {
        return stl::addressof(value);
    }

    [[nodiscard]] constexpr reference operator*() noexcept {
        return value;
    }
 
private:
    Type value;
};

template<stl::integral Type>
struct iota_iterator final {
    using value_type = Type;
    using pointer = void;
    using reference = value_type;
    using difference_type = stl::ptrdiff_t;
    using iterator_category = stl::input_iterator_tag;

    constexpr iota_iterator() noexcept
        : current{} {}

    constexpr iota_iterator(const value_type init) noexcept
        : current{init} {}

    constexpr iota_iterator &operator++() noexcept {
        return ++current, *this;
    }

    constexpr iota_iterator operator++(int) noexcept {
        const iota_iterator orig = *this;
        return ++(*this), orig;
    }

    [[nodiscard]] constexpr reference operator*() const noexcept {
        return current;
    }

    [[nodiscard]] constexpr bool operator==(const iota_iterator &other) const noexcept {
        return current == other.current;
    }
 
private:
    value_type current;
};

template<stl::input_or_output_iterator It, stl::sentinel_for<It> Sentinel = It>
struct iterable_adaptor final {
    using value_type = stl::iterator_traits<It>::value_type;
    using iterator = It;
    using sentinel = Sentinel;

    constexpr iterable_adaptor() noexcept(stl::is_nothrow_default_constructible_v<iterator> && stl::is_nothrow_default_constructible_v<sentinel>)
        : first{},
          last{} {}

    constexpr iterable_adaptor(iterator from, sentinel to) noexcept(stl::is_nothrow_move_constructible_v<iterator> && stl::is_nothrow_move_constructible_v<sentinel>)
        : first{stl::move(from)},
          last{stl::move(to)} {}

    [[nodiscard]] constexpr iterator begin() const noexcept {
        return first;
    }

    [[nodiscard]] constexpr sentinel end() const noexcept {
        return last;
    }

    [[nodiscard]] constexpr iterator cbegin() const noexcept {
        return begin();
    }

    [[nodiscard]] constexpr sentinel cend() const noexcept {
        return end();
    }
 
private:
    It first;
    Sentinel last;
};
 
} // namespace entt
 
#endif