type_traits.hpp

#ifndef HALCHECK_LIB_TYPE_TRAITS_HPP
#define HALCHECK_LIB_TYPE_TRAITS_HPP
 
#include <cstddef>
#include <functional>
#include <istream>
#include <ostream>
#include <string>
#include <tuple>
#include <type_traits> // IWYU pragma: export
 
#ifdef HALCHECK_DOXYGEN
#define HALCHECK_REQUIRE(...)
#define HALCHECK_REQUIRE_(...)
#else
#define HALCHECK_REQUIRE(...) ::halcheck::lib::enable_if_t<(__VA_ARGS__), int> = 0
#define HALCHECK_REQUIRE_(...) ::halcheck::lib::enable_if_t<(__VA_ARGS__), int>
#endif
 
namespace halcheck { namespace lib {
 
template<typename...>
using void_t = void;
 
template<bool Cond, typename T, typename F>
using conditional_t = typename std::conditional<Cond, T, F>::type;
 
template<typename... Args>
struct conjunction;
 
template<>
struct conjunction<> : std::true_type {};
 
template<typename T>
struct conjunction<T> : T {};
 
template<typename T, typename... Args>
struct conjunction<T, Args...> : lib::conditional_t<bool(T::value), conjunction<Args...>, T> {};
 
template<typename... Args>
struct disjunction;
 
template<>
struct disjunction<> : std::false_type {};
 
template<typename T>
struct disjunction<T> : T {};
 
template<typename T, typename... Args>
struct disjunction<T, Args...> : lib::conditional_t<bool(T::value), T, disjunction<Args...>> {};
 
template<bool Cond, typename T = void>
using enable_if_t = typename std::enable_if<Cond, T>::type;
 
template<typename T>
using decay_t = typename std::decay<T>::type;
 
template<typename T>
using remove_cv_t = typename std::remove_cv<T>::type;
 
template<typename T>
using remove_extent_t = typename std::remove_extent<T>::type;
 
template<typename T>
using make_unsigned_t = typename std::make_unsigned<T>::type;
 
template<typename... Args>
using common_type_t = typename std::common_type<Args...>::type;
 
template<typename T>
using remove_cvref_t = typename std::remove_cv<typename std::remove_reference<T>::type>::type;
 
template<typename T, typename...>
struct type_identity {
  using type = T;
};
 
template<typename T, typename...>
using type_identity_t = T;
 
template<std::size_t I, typename T>
using tuple_element_t = typename std::tuple_element<I, T>::type;
 
template<typename T>
using remove_reference_t = typename std::remove_reference<T>::type;
 
template<typename T>
using remove_const_t = typename std::remove_const<T>::type;
 
template<typename T>
using make_signed_t = typename std::make_signed<T>::type;
 
template<typename T>
using add_lvalue_reference_t = typename std::add_lvalue_reference<T>::type;
 
template<typename T>
using add_rvalue_reference_t = typename std::add_rvalue_reference<T>::type;
 
template<typename T>
using add_const_t = typename std::add_const<T>::type;
 
template<typename T>
using add_pointer_t = typename std::add_pointer<T>::type;
 
template<typename T>
using remove_pointer_t = typename std::remove_pointer<T>::type;
 
namespace detail {
template<typename, template<typename...> class Op, typename... Args>
struct is_detected_helper : std::false_type {};
 
template<template<typename...> class Op, typename... Args>
struct is_detected_helper<lib::void_t<Op<Args...>>, Op, Args...> : std::true_type {};
} // namespace detail
 
template<template<typename...> class Op, typename... Args>
struct is_detected : detail::is_detected_helper<void, Op, Args...> {};
 
template<typename From, typename To>
using convertible = lib::enable_if_t<std::is_convertible<From, To>{}>;
 
template<typename T, typename U>
using same = lib::enable_if_t<std::is_same<T, U>{}>;
 
template<typename T, typename U>
using base_of = lib::enable_if_t<std::is_base_of<T, U>{}>;
 
template<typename T>
using tuple_like = decltype(std::tuple_size<T>::value);
 
template<typename T>
struct is_tuple_like : lib::is_detected<lib::tuple_like, T> {};
 
template<class T, typename... Args>
using brace_constructible = decltype(T{std::declval<Args>()...});
 
template<class T, typename... Args>
struct is_brace_constructible : lib::is_detected<lib::brace_constructible, T, Args...> {};
 
namespace detail {
using std::swap;
 
template<typename T>
using swappable = decltype(swap(std::declval<T &>(), std::declval<T &>()));
 
template<typename T>
using nothrow_swappable = lib::enable_if_t<noexcept(swap(std::declval<T &>(), std::declval<T &>()))>;
} // namespace detail
 
using detail::nothrow_swappable;
using detail::swappable;
 
template<typename T>
struct is_swappable : lib::is_detected<lib::swappable, T> {};
 
template<typename T>
struct is_nothrow_swappable : lib::is_detected<lib::nothrow_swappable, T> {};
 
template<typename T>
using destructible = lib::enable_if_t<std::is_destructible<T>{}>;
 
template<typename T>
using default_constructible = lib::enable_if_t<std::is_default_constructible<T>{}>;
 
template<typename T>
using move_constructible = lib::enable_if_t<std::is_move_constructible<T>{}>;
 
template<typename T>
using move_assignable = lib::enable_if_t<std::is_move_assignable<T>{}>;
 
template<typename T>
using movable = lib::void_t<lib::move_constructible<T>, lib::move_assignable<T>>;
 
template<typename T>
struct is_movable : lib::is_detected<lib::movable, T> {};
 
template<typename T>
using copy_constructible = lib::enable_if_t<std::is_copy_constructible<T>{}>;
 
template<typename T>
using copy_assignable = lib::enable_if_t<std::is_copy_assignable<T>{}>;
 
template<typename T>
using copyable = lib::void_t<lib::copy_constructible<T>, lib::copy_assignable<T>>;
 
template<typename T>
struct is_copyable : lib::is_detected<lib::copyable, T> {};
 
template<typename B>
using boolean_testable =
    lib::void_t<lib::convertible<B, bool>, lib::convertible<decltype(!std::forward<B>(std::declval<B &>())), bool>>;
 
template<typename B>
struct is_boolean_testable : lib::is_detected<lib::boolean_testable, B> {};
 
template<typename T>
using equality_comparable = lib::void_t<
    lib::boolean_testable<decltype(std::declval<const T &>() == std::declval<const T &>())>,
    lib::boolean_testable<decltype(std::declval<const T &>() != std::declval<const T &>())>>;
 
template<typename T>
struct is_equality_comparable : lib::is_detected<lib::equality_comparable, T> {};
 
template<typename T>
using hashable = lib::same<decltype(std::declval<std::hash<T>>()(std::declval<T &>())), std::size_t>;
 
template<typename T>
struct is_hashable : lib::is_detected<lib::hashable, T> {};
 
template<typename T, typename Stream>
using printable = lib::same<decltype(std::declval<Stream &>() << std::declval<const T &>()), Stream &>;
 
template<typename T, typename CharT = char, typename Traits = std::char_traits<CharT>>
struct is_printable : lib::is_detected<lib::printable, T, std::basic_ostream<CharT, Traits>> {};
 
template<typename T, typename Stream>
using parsable = lib::same<decltype(std::declval<Stream &>() >> std::declval<T &>()), Stream &>;
 
template<typename T, typename CharT = char, typename Traits = std::char_traits<CharT>>
struct is_parsable : lib::is_detected<lib::parsable, T, std::basic_istream<CharT, Traits>> {};
 
template<typename T, template<typename...> class F>
struct is_specialization_of : std::false_type {};
 
template<typename... Args, template<typename...> class F>
struct is_specialization_of<F<Args...>, F> : std::true_type {};
 
template<typename T, template<typename...> class F>
using specialization_of = lib::enable_if_t<lib::is_specialization_of<T, F>{}>;
 
}} // namespace halcheck::lib
 
#endif