//
//  traits.h
//  string-utils
//
//  Created by Sam Jaffe on 6/12/22.
//  Copyright © 2022 Sam Jaffe. All rights reserved.
//

#pragma once

#include <tuple>
#include <type_traits>

namespace string_utils::detail {
template <typename, typename = void> struct has_result : std::false_type {};
template <typename F>
struct has_result<F, std::void_t<std::invoke_result_t<F>>> : std::true_type {};

template <typename, typename = void> struct is_tuple : std::false_type {};
template <typename T>
struct is_tuple<T, std::void_t<typename std::tuple_size<T>::type>>
    : std::true_type {};

template <typename, typename = void> struct is_associative : std::false_type {};
template <typename T>
struct is_associative<T, std::void_t<typename T::mapped_type>>
    : std::true_type {};

template <typename C>
using insert_t =
    decltype(std::declval<C>().insert(std::declval<typename C::iterator>(),
                                      std::declval<typename C::value_type>()));
template <typename, typename = void> struct is_container : std::false_type {};
template <typename T>
struct is_container<T, std::void_t<typename T::value_type, insert_t<T>>>
    : std::true_type {};

template <typename T> struct decay { using type = std::decay_t<T>; };
template <template <typename...> class C, typename... Ts>
struct decay<C<Ts...>> {
  using type = C<std::decay_t<Ts>...>;
};
}

namespace string_utils::detail {
template <typename> struct always_false : std::false_type {};

template <typename T> constexpr bool has_result_v = has_result<T>::value;
template <typename T> constexpr bool is_tuple_v = is_tuple<T>::value;
template <typename T>
constexpr bool is_associative_v = is_associative<T>::value;
template <typename T> constexpr bool is_container_v = is_container<T>::value;

template <typename T> using decay_t = typename decay<std::decay_t<T>>::type;
}