cpp-useful-iterators/include/iterator/recursive_iterator_meta.hpp

//
//  recursive_iterator_meta.hpp
//  iterator
//
//  Created by Sam Jaffe on 2/21/17.
//

#pragma once

namespace iterator { namespace detail {

  /**
   * @class recursive_iterator_impl
   * @brief The default (terminal) implementation of an unbounded recursive
   * iterator.
   *
   * @see recursive_iterator_base
   * @param Iterator The iterator type being processed, such as
   * std::vector<int>::iterator
   */
  template <typename Iterator, typename = void>
  class recursive_iterator_impl : public recursive_iterator_base<Iterator> {
  public:
    using super = recursive_iterator_base<Iterator>;

  public:
    using super::super;
    recursive_iterator_impl() = default;
    template <typename OIter>
    recursive_iterator_impl(in_place_t, OIter && iter)
        : super(std::forward<OIter>(iter)) {}

  protected:
    void next() { super::operator++(); }
    void assign(super eat) { static_cast<super &>(*this) = eat; }
  };

  /**
   * @class recursive_iterator_impl
   *
   * An SFINAE specialization of bounded_recursive_iterator_impl for
   * non-associative container types.
   * @see recursive_iterator_layer
   */
  template <typename Iterator>
  class recursive_iterator_impl<Iterator,
                                typename void_t<value_iterator<Iterator>>::type>
      : public recursive_iterator_layer<
            Iterator, recursive_iterator_impl<value_iterator<Iterator>>> {
  public:
    using next_layer = recursive_iterator_impl<value_iterator<Iterator>>;
    using super = recursive_iterator_layer<Iterator, next_layer>;

  public:
    /**
     * A special override of operator* that allows collections like
     * std::vector<std::vector<std::map<K, V>>> still use the value/reference
     * type of the map. Works only for nested collections with one associative
     * container at the bottom level.
     */
    auto operator*() const -> decltype(*(next_layer &)(*this)) {
      return next_layer::operator*();
    }
    using super::super;
    recursive_iterator_impl() = default;
    template <typename... Iterators>
    recursive_iterator_impl(in_place_t, Iterators &&... iter)
        : super(in_place, std::forward<Iterators>(iter)...) {}
  };

  /**
   * @class recursive_iterator_impl
   *
   * An SFINAE specialization of bounded_recursive_iterator_impl for
   * associative container types.
   * @see flatten_iterator_layer
   */
  template <typename Iterator>
  class recursive_iterator_impl<
      Iterator, typename void_t<mapped_iterator<Iterator>>::type>
      : public flatten_iterator_layer<
            Iterator, recursive_iterator_impl<mapped_iterator<Iterator>>> {
  public:
    using next_layer = recursive_iterator_impl<mapped_iterator<Iterator>>;
    using super = flatten_iterator_layer<Iterator, next_layer>;

  public:
    using super::super;
    recursive_iterator_impl() = default;
    template <typename... Iterators>
    recursive_iterator_impl(in_place_t, Iterators &&... iter)
        : super(in_place, std::forward<Iterators>(iter)...) {}
  };

  /**
   * @class bounded_recursive_iterator_impl
   * @brief The default (terminal) implementation of a recursive iterator up to
   * Max levels deep.
   *
   * @see recursive_iterator_base
   * @param Iterator The iterator type being processed, such as
   * std::vector<int>::iterator
   * @param N The current layer of depth, starts at 1.
   * @param Max The maximum recursive depth to dive down, in case you need to
   * process some sub-collection in a specific manner.
   */
  template <typename Iterator, std::size_t N, std::size_t Max, typename = void>
  class bounded_recursive_iterator_impl
      : public recursive_iterator_base<Iterator> {
  public:
    using super = recursive_iterator_base<Iterator>;

  public:
    using super::super;
    bounded_recursive_iterator_impl() = default;
    template <typename OIter>
    bounded_recursive_iterator_impl(in_place_t, OIter && iter)
        : super(std::forward<OIter>(iter)) {}

  protected:
    void next() { super::operator++(); }
    void assign(super eat) { static_cast<super &>(*this) = eat; }
  };

  /**
   * @class bounded_recursive_iterator_impl
   *
   * An SFINAE specialization of bounded_recursive_iterator_impl for
   * non-associative container types.
   * @see recursive_iterator_layer
   */
  template <typename Iterator, std::size_t N, std::size_t Max>
      class bounded_recursive_iterator_impl < Iterator,
      N, Max,
      typename std::enable_if<
          N<Max, typename void_t<value_iterator<Iterator>>::type>::type>
      : public recursive_iterator_layer<
            Iterator, bounded_recursive_iterator_impl<value_iterator<Iterator>,
                                                      N + 1, Max>> {
  public:
    using next_layer =
        bounded_recursive_iterator_impl<value_iterator<Iterator>, N + 1, Max>;
    using super = recursive_iterator_layer<Iterator, next_layer>;

  public:
    /**
     * A special override of operator* that allows collections like
     * std::vector<std::vector<std::map<K, V>>> still use the value/reference
     * type of the map. Works only for nested collections with one associative
     * container at the bottom/Max level.
     */
    auto operator*() const -> decltype(*(next_layer &)(*this)) {
      return next_layer::operator*();
    }
    using super::super;
    bounded_recursive_iterator_impl() = default;
    template <typename... Iterators>
    bounded_recursive_iterator_impl(in_place_t, Iterators &&... iter)
        : super(in_place, std::forward<Iterators>(iter)...) {}
  };

  /**
   * @class bounded_recursive_iterator_impl
   *
   * An SFINAE specialization of bounded_recursive_iterator_impl for
   * associative container types.
   * @see flatten_iterator_layer
   */
  template <typename Iterator, std::size_t N, std::size_t Max>
      class bounded_recursive_iterator_impl < Iterator,
      N, Max,
      typename std::enable_if<
          N<Max, typename void_t<mapped_iterator<Iterator>>::type>::type>
      : public flatten_iterator_layer<
            Iterator, bounded_recursive_iterator_impl<mapped_iterator<Iterator>,
                                                      N + 1, Max>> {
  public:
    using next_layer =
        bounded_recursive_iterator_impl<mapped_iterator<Iterator>, N + 1, Max>;
    using super = flatten_iterator_layer<Iterator, next_layer>;

  public:
    using super::super;
    bounded_recursive_iterator_impl() = default;
    template <typename... Iterators>
    bounded_recursive_iterator_impl(in_place_t, Iterators &&... iter)
        : super(in_place, std::forward<Iterators>(iter)...) {}
  };
}}

namespace iterator { namespace detail {
  template <std::size_t I, typename It, typename = void> struct accessor;

  template <typename It> struct accessor<0, end_aware_iterator<It>> {
    using type = end_aware_iterator<It>;
  };

  template <typename It, typename Rec>
  struct accessor<0, recursive_iterator_layer<It, Rec>> {
    using type = end_aware_iterator<It>;
  };

  template <typename It, typename Rec>
  struct accessor<0, flatten_iterator_layer<It, Rec>> {
    using type = end_aware_iterator<It>;
  };

  template <typename It> struct accessor<0, It> {
    using type = typename accessor<0, typename It::super>::type;
  };

  template <std::size_t I, typename It>
  struct accessor<I, It, typename std::enable_if<I != 0>::type> {
    using type = typename accessor<I, typename It::super>::type;
  };

  template <std::size_t I, typename It, typename Rec>
  struct accessor<I, recursive_iterator_layer<It, Rec>,
                  typename std::enable_if<I != 0>::type> {
    using type = typename accessor<I - 1, Rec>::type;
  };

  template <std::size_t I, typename It, typename Rec>
  struct accessor<I, flatten_iterator_layer<It, Rec>,
                  typename std::enable_if<I != 0>::type> {
    using type = typename accessor<I - 1, Rec>::type;
  };
}}