type_traits.h

Go to the documentation of this file.

#pragma once
namespace bmb {
 
template <typename T>
T&& declval() {
    static_assert(false, "declval isn't implemented to call it");
}
 
// This type forces non-deduced context.
// It works because compiler's not able to deduce "qualifed name"
// like "type_identity<MyType>::value".
//
// It useful for forcing a client to call a function with
// explicitly given template types.
// For more explanation see https://stackoverflow.com/a/25245676
 
template <typename T>
struct type_identity {
    using type = T;
};
 
template <typename T>
using type_identity_t = type_identity<T>::type;
 
template <auto val>
struct integral_constant {
    using value_type            = decltype(val);
    static constexpr auto value = val;
};
 
template <bool val>
using bool_constant = integral_constant<val>;
 
using true_type  = bool_constant<true>;
using false_type = bool_constant<false>;
 
template <typename... Types>
struct conjunction {
    static constexpr bool value = (Types::value && ...);
};
 
template <typename... Types>
constexpr bool conjunction_v = conjunction<Types...>::value;
 
template <typename... Types>
struct disjunction {
    static constexpr bool value = (Types::value || ...);
};
 
template <typename... Types>
constexpr bool disjunction_v = disjunction<Types...>::value;
 
template <typename T, typename U>
struct is_same : false_type {};
 
template <typename T>
struct is_same<T, T> : true_type {};
 
template <typename T, typename U>
constexpr bool is_same_v = is_same<T, U>::value;
 
template <typename T>
struct is_lvalue_ref : false_type {};
 
template <typename T>
struct is_lvalue_ref<T&> : true_type {};
 
template <typename T>
constexpr bool is_lvalue_ref_v = is_lvalue_ref<T>::value;
 
template <typename T>
struct is_rvalue_ref : false_type {};
 
template <typename T>
struct is_rvalue_ref<T&&> : true_type {};
 
template <typename T>
constexpr bool is_rvalue_ref_v = is_rvalue_ref<T>::value;
 
template <typename T>
struct is_const : false_type {};
 
template <typename T>
struct is_const<const T> : true_type {};
 
template <typename T>
constexpr bool is_const_v = is_const<T>::value;
 
namespace detail {
 
// Only classes and unions can have pointers to members, even if
// there is no such member in the class.
template <typename T>
true_type test_is_class(int T::*);
 
template <typename>
false_type test_is_class(...);
 
}  // namespace detail
 
// WARNING: this implementation of is_class detects unions as classes
// because union is the same as struct/class but fields size.
// Also it's impossible to differentiate class and union without
// using compiler internal information.
 
template <typename T>
struct is_class : decltype(detail::test_is_class<T>(nullptr)) {};
 
template <typename T>
constexpr bool is_class_v = is_class<T>::value;
 
template <typename T>
struct is_pointer : false_type {};
 
template <typename T>
struct is_pointer<T*> : true_type {};
 
template <typename T>
constexpr bool is_pointer_v = is_pointer<T>::value;
 
template <typename T>
struct remove_const {
    using type = T;
};
 
template <typename T>
struct remove_const<const T> {
    using type = T;
};
 
template <typename T>
using remove_const_t = remove_const<T>::type;
 
template <typename T>
struct remove_ref {
    using type = T;
};
 
template <typename T>
struct remove_ref<T&> {
    using type = T;
};
 
template <typename T>
struct remove_ref<T&&> {
    using type = T;
};
 
template <typename T>
using remove_ref_t = remove_ref<T>::type;
 
template <bool Cond, typename IfTrue, typename IfFalse>
struct conditional {
    using type = IfTrue;
};
 
template <typename IfTrue, typename IfFalse>
struct conditional<false, IfTrue, IfFalse> {
    using type = IfFalse;
};
 
template <bool Cond, typename IfTrue, typename IfFalse>
using conditional_t = conditional<Cond, IfTrue, IfFalse>::type;
 
template <bool Cond, typename T = void>
struct enable_if {};
 
template <typename T>
struct enable_if<true, T> {
    using type = T;
};
 
template <bool Cond, typename T = void>
using enable_if_t = enable_if<Cond, T>::type;
 
namespace detail {
 
// NOTE: here we need another one level of redirection,
// because without it SFINAE won't work: test_ptr_cast(const B*) is
// a valid declaration, thefore, the compiler choose it over others overloads,
// and only then it checks avalability/accessibility, which causes CE in case of
// private/disambiguous inheritance. However the 'decltype' below enables SFINAE.
 
template <typename B>
true_type test_ptr_cast(const B*);
 
template <typename>
false_type test_ptr_cast(const void*);
 
template <typename B, typename D>
auto test_is_base_of(int) -> decltype(test_ptr_cast<B>(static_cast<D*>(nullptr)));
 
template <typename, typename>
auto test_is_base_of(...) -> true_type;  // private/disambiguous base
 
}  // namespace detail
 
template <typename Base, typename Derived>
struct is_base_of : conjunction<
                        is_class<Base>,
                        is_class<Derived>,
                        decltype(detail::test_is_base_of<Base, Derived>(0))> {};
 
template <typename Base, typename Derived>
constexpr bool is_base_of_v = is_base_of<Base, Derived>::value;
 
template <typename...> using void_t = void;
 
namespace detail {
// TODO: add pointers to members support
 
template <typename F, typename... Args>
auto invoke() -> decltype(declval<F>()(declval<Args>()...));
 
template <typename F, typename... Args>
true_type test_is_invocable(decltype(invoke<F, Args...>(), 0));
 
template <typename...>
false_type test_is_invocable(...);
 
// can't use void_t as default parameter
template <typename AlwaysVoid, typename F, typename... Args>
struct invoke_result_impl {};
 
template <typename F, typename... Args>
struct invoke_result_impl<decltype(void(invoke<F, Args...>())),  // just try to call 'invoke'
                          F,
                          Args...> {
    using type = decltype(invoke<F, Args...>());
};
 
}  // namespace detail
 
template <typename F, typename... Args>
struct is_invocable : decltype(detail::test_is_invocable<F, Args...>(0)) {};
 
template <typename F, typename... Args>
constexpr bool is_invocable_v = is_invocable<F, Args...>::value;
 
template <typename F, typename... Args>
struct invoke_result : detail::invoke_result_impl<void, F, Args...> {};
 
template <typename F, typename... Args>
using invoke_result_t = invoke_result<F, Args...>::type;
 
}  // namespace bmb