iterator.h

#pragma once
#include "gaia/config/config.h"
 
#include <cstddef>
#include <type_traits>
#include <utility>
 
namespace gaia {
  namespace core {
    struct input_iterator_tag {};
    struct output_iterator_tag {};
 
    struct forward_iterator_tag: input_iterator_tag {};
    struct reverse_iterator_tag: input_iterator_tag {};
    struct bidirectional_iterator_tag: forward_iterator_tag {};
    struct random_access_iterator_tag: bidirectional_iterator_tag {};
    struct contiguous_iterator_tag: random_access_iterator_tag {};
 
    template <typename It, typename Diff>
    class reverse_iterator {
    public:
      using iterator_type = It;
      using value_type = std::remove_cv_t<std::remove_reference_t<decltype(*std::declval<It&>())>>;
      using pointer = std::conditional_t<std::is_pointer_v<It>, It, void>;
      using reference = decltype(*std::declval<It&>());
      using difference_type = Diff;
      using iterator_category = random_access_iterator_tag;
 
    private:
      It m_current{};
 
    public:
      constexpr reverse_iterator() = default;
 
      constexpr explicit reverse_iterator(It current): m_current(current) {}
 
      GAIA_NODISCARD constexpr It base() const {
        return m_current;
      }
 
      GAIA_NODISCARD constexpr decltype(auto) operator*() const {
        auto current = m_current;
        --current;
        return *current;
      }
 
      GAIA_NODISCARD constexpr decltype(auto) operator->() const {
        auto current = m_current;
        --current;
        if constexpr (std::is_pointer_v<It>)
          return current;
        else
          return current.operator->();
      }
 
      GAIA_NODISCARD constexpr decltype(auto) operator[](difference_type offset) const {
        return *(*this + offset);
      }
 
      constexpr reverse_iterator& operator++() {
        --m_current;
        return *this;
      }
 
      constexpr reverse_iterator operator++(int) {
        auto tmp = *this;
        ++*this;
        return tmp;
      }
 
      constexpr reverse_iterator& operator--() {
        ++m_current;
        return *this;
      }
 
      constexpr reverse_iterator operator--(int) {
        auto tmp = *this;
        --*this;
        return tmp;
      }
 
      constexpr reverse_iterator& operator+=(difference_type offset) {
        m_current -= offset;
        return *this;
      }
 
      constexpr reverse_iterator& operator-=(difference_type offset) {
        m_current += offset;
        return *this;
      }
 
      GAIA_NODISCARD constexpr reverse_iterator operator+(difference_type offset) const {
        auto tmp = *this;
        tmp += offset;
        return tmp;
      }
 
      GAIA_NODISCARD constexpr reverse_iterator operator-(difference_type offset) const {
        auto tmp = *this;
        tmp -= offset;
        return tmp;
      }
 
      GAIA_NODISCARD constexpr difference_type operator-(const reverse_iterator& other) const {
        return (difference_type)(other.m_current - m_current);
      }
 
      GAIA_NODISCARD constexpr bool operator==(const reverse_iterator& other) const {
        return m_current == other.m_current;
      }
 
      GAIA_NODISCARD constexpr bool operator!=(const reverse_iterator& other) const {
        return !(*this == other);
      }
 
      GAIA_NODISCARD constexpr bool operator<(const reverse_iterator& other) const {
        return other.m_current < m_current;
      }
 
      GAIA_NODISCARD constexpr bool operator>(const reverse_iterator& other) const {
        return other < *this;
      }
 
      GAIA_NODISCARD constexpr bool operator<=(const reverse_iterator& other) const {
        return !(other < *this);
      }
 
      GAIA_NODISCARD constexpr bool operator>=(const reverse_iterator& other) const {
        return !(*this < other);
      }
    };
 
    template <typename It, typename Diff>
    GAIA_NODISCARD constexpr reverse_iterator<It, Diff> operator+(
        Diff offset, const reverse_iterator<It, Diff>& it) {
      return it + offset;
    }
 
    namespace detail {
      template <typename, typename = void>
      struct iterator_traits_base {}; // empty for non-iterators
 
      template <typename It>
      struct iterator_traits_base<
          It, std::void_t<
                  typename It::iterator_category, typename It::value_type, typename It::difference_type,
                  typename It::pointer, typename It::reference>> {
        using iterator_category = typename It::iterator_category;
        using value_type = typename It::value_type;
        using difference_type = typename It::difference_type;
        using pointer = typename It::pointer;
        using reference = typename It::reference;
      };
 
      template <typename T, bool = std::is_object_v<T>>
      struct iterator_traits_pointer_base {
        using iterator_category = random_access_iterator_tag;
        using value_type = std::remove_cv_t<T>;
        using difference_type = std::ptrdiff_t;
        using pointer = T*;
        using reference = T&;
      };
 
      template <typename T>
      struct iterator_traits_pointer_base<T, false> {};
 
      template <typename It>
      struct iterator_traits: iterator_traits_base<It> {};
 
      // Iterator traits for pointers
      template <typename T>
      struct iterator_traits<T*>: iterator_traits_pointer_base<T> {};
 
      template <typename It>
      using iterator_cat_t = typename iterator_traits<It>::iterator_category;
    } // namespace detail
 
    template <typename T, typename = void>
    [[maybe_unused]] constexpr bool is_iterator_v = false;
 
    template <typename T>
    [[maybe_unused]] constexpr bool is_iterator_v<T, std::void_t<detail::iterator_cat_t<T>>> = true;
 
    template <typename T>
    struct is_iterator: std::bool_constant<is_iterator_v<T>> {};
 
    template <typename It>
    [[maybe_unused]] constexpr bool is_input_iter_v =
        std::is_convertible_v<detail::iterator_cat_t<It>, input_iterator_tag>;
 
    template <typename It>
    [[maybe_unused]] constexpr bool is_fwd_iter_v =
        std::is_convertible_v<detail::iterator_cat_t<It>, forward_iterator_tag>;
 
    template <typename It>
    [[maybe_unused]] constexpr bool is_rev_iter_v =
        std::is_convertible_v<detail::iterator_cat_t<It>, reverse_iterator_tag>;
 
    template <typename It>
    [[maybe_unused]] constexpr bool is_bidi_iter_v =
        std::is_convertible_v<detail::iterator_cat_t<It>, bidirectional_iterator_tag>;
 
    template <typename It>
    [[maybe_unused]] constexpr bool is_random_iter_v =
        std::is_convertible_v<detail::iterator_cat_t<It>, random_access_iterator_tag>;
 
    template <typename It>
    using iterator_ref_t = typename detail::iterator_traits<It>::reference;
 
    template <typename It>
    using iterator_value_t = typename detail::iterator_traits<It>::value_type;
 
    template <typename It>
    using iterator_diff_t = typename detail::iterator_traits<It>::difference_type;
 
    template <typename... It>
    using common_diff_t = std::common_type_t<iterator_diff_t<It>...>;
 
    template <typename It>
    constexpr iterator_diff_t<It> distance(It first, It last) {
      if constexpr (std::is_pointer_v<It> || is_random_iter_v<It>)
        return last - first;
      else {
        iterator_diff_t<It> offset{};
        while (first != last) {
          ++first;
          ++offset;
        }
        return offset;
      }
    }
  } // namespace core
} // namespace gaia