type_traits.hpp

/* SPDX-License-Identifier: MIT */
/* Copyright © 2020 Max Bachmann */
 
#pragma once
#include <rapidfuzz/details/types.hpp>
 
#include <iterator>
#include <utility>
 
namespace rapidfuzz {
 
namespace detail {
template <typename T>
auto inner_type(T const*) -> T;
 
template <typename T>
auto inner_type(T const&) -> typename T::value_type;
} // namespace detail
 
template <typename T>
using char_type = decltype(detail::inner_type(std::declval<T const&>()));
 
/* backport of std::iter_value_t from C++20
 * This does not cover the complete functionality, but should be enough for
 * the use cases in this library
 */
template <typename T>
using iter_value_t = typename std::iterator_traits<T>::value_type;
 
// taken from
// https://stackoverflow.com/questions/16893992/check-if-type-can-be-explicitly-converted
template <typename From, typename To>
struct is_explicitly_convertible {
    template <typename T>
    static void f(T);
 
    template <typename F, typename T>
    static constexpr auto test(int /*unused*/) -> decltype(f(static_cast<T>(std::declval<F>())), true)
    {
        return true;
    }
 
    template <typename F, typename T>
    static constexpr auto test(...) -> bool
    {
        return false;
    }
 
    static bool const value = test<From, To>(0);
};
 
template <bool B, class T = void>
using rf_enable_if_t = typename std::enable_if<B, T>::type;
 
} // namespace rapidfuzz