cpp-useful-iterators/include/iterator/detail/recursive_traits.h

#pragma once

#include <iterator>

#include "traits.h"

namespace iterator::recursive {
  // Type deduction guides for constructing recursive iterators.
  enum class recursion_type { END, THRU, ASSOC };

  // Helpers for condensing type deductions
  template <typename It>
  using value = decltype(std::begin(*std::declval<It>()));

  template <typename It>
  using mapped = decltype(std::begin(std::declval<It>()->second));

  template <typename T> using val_key_t = typename T::value_type::first_type;

  // Type trait to identify value_type ~~ std::pair<K const, V>, which is
  // a safe bet towards 'this is an associative container type'
  template <typename T, typename = void>
  struct is_associative : std::false_type {};
  template <typename T>
  struct is_associative<T, std::enable_if_t<std::is_const_v<val_key_t<T>>>>
      : std::true_type {};

  template <typename T, typename = void> struct typeclass_t {
    static constexpr recursion_type const value{recursion_type::END};
  };

  template <typename T> struct is_string_iter : std::false_type {};
  template <> struct is_string_iter<std::string::iterator> : std::true_type {};
  template <>
  struct is_string_iter<std::string::const_iterator> : std::true_type {};

  template <typename T> constexpr bool is_string_iter_v = is_string_iter<T>{};

  template <typename T>
  struct typeclass_t<T, std::enable_if_t<!is_string_iter_v<value<T>>>> {
    constexpr static recursion_type value{recursion_type::THRU};
  };

  template <typename T>
  struct typeclass_t<T, std::enable_if_t<is_string_iter_v<value<T>>>> {
    constexpr static recursion_type value{recursion_type::END};
  };

  template <typename T> struct typeclass_t<T, detail::void_t<mapped<T>>> {
    constexpr static recursion_type value{recursion_type::ASSOC};
  };
}