type_traits

/*	Copyright (C) 2005 Garrett A. Kajmowicz

	This file is part of the uClibc++ Library.
	This library is free software; you can redistribute it and/or
	modify it under the terms of the GNU Lesser General Public
	License as published by the Free Software Foundation; either
	version 2.1 of the License, or (at your option) any later version.

	This library is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
	Lesser General Public License for more details.

	You should have received a copy of the GNU Lesser General Public
	License along with this library; if not, write to the Free Software
	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#ifndef __HEADER_TYPE_TRAITS
#define __HEADER_TYPE_TRAITS 1

#include <basic_definitions>
#include <char_traits>
#include <cstddef>
#include <exception>
#include <memory>
#include <string.h>
#include <utility>

#include <bits/reference_transformations.hpp>
#include <bits/type_traits_impl.hpp>

#pragma GCC visibility push(default)

namespace std
{

template <class T>
class reference_wrapper; // defined in <functional>

template <typename, unsigned = 0>
struct extent;

template <typename>
struct remove_all_extents;

template <bool _Cond, typename _Iftrue, typename _Iffalse>
struct conditional;

template<bool Bool, class TrueType, class FalseType>
using conditional_t = typename conditional<Bool,TrueType,FalseType>::type;

template <typename T>
struct add_rvalue_reference;

template <typename T>
struct add_lvalue_reference;

template< class T >
struct add_pointer;

template< class T >
struct remove_extent;

template <typename>
struct is_function;

template <typename T>
struct is_member_object_pointer;

template <typename T>
struct is_member_function_pointer;

template< class T >
struct is_member_pointer;

template <typename T>
struct is_default_constructible;

template <typename T>
struct is_array;

template<class Base, class Derived>
struct is_base_of;

struct __sfinae_types
{
	typedef char __one;
	typedef struct
	{
		char __arr[2];
	} __two;
};

// Define a nested type if some predicate holds.
// Primary template.
/// enable_if
template <bool, typename _Tp = void>
struct enable_if
{
};

// Partial specialization for true.
template <typename _Tp>
struct enable_if<true, _Tp>
{
	typedef _Tp type;
};

template <bool Cond, typename T = void>
using enable_if_t = enable_if<Cond, T>;

/// add_const
template <typename _Tp>
struct add_const
{
	typedef _Tp const type;
};

/// add_volatile
template <typename _Tp>
struct add_volatile
{
	typedef _Tp volatile type;
};

/// add_cv
template <typename _Tp>
struct add_cv
{
	typedef typename add_const<typename add_volatile<_Tp>::type>::type type;
};

/// remove extent
template<class T>
struct remove_extent { typedef T type; };
 
template<class T>
struct remove_extent<T[]> { typedef T type; };
 
template<class T, size_t N>
struct remove_extent<T[N]> { typedef T type; };

/// decay
template< class T >
struct decay {
private:
    typedef typename remove_reference<T>::type U;
public:
    typedef typename conditional< 
        is_array<U>::value,
        typename remove_extent<U>::type*,
        typename conditional< 
            is_function<U>::value,
            typename add_pointer<U>::type,
            typename remove_cv<U>::type
        >::type
    >::type type;
};

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

/// declval
template <typename _Tp>
struct __declval_protector
{
	static const bool __stop = false;
	static typename add_rvalue_reference<_Tp>::type __delegate();
};

template <typename _Tp>
inline typename add_rvalue_reference<_Tp>::type
declval() noexcept
{
	static_assert(__declval_protector<_Tp>::__stop,
								"declval() must not be used!");
	return __declval_protector<_Tp>::__delegate();
}

/// result_of
template <typename _Signature>
class result_of;

namespace detail {
template <class T>
struct is_reference_wrapper : false_type {};
template <class U>
struct is_reference_wrapper<reference_wrapper<U>> : true_type {};
 
template <class Base, class T, class Derived, class... Args>
auto INVOKE(T Base::*pmf, Derived&& ref, Args&&... args)
 -> typename enable_if<is_function<T>::value &&
                     is_base_of<Base, typename decay<Derived>::type>::value,
    decltype((forward<Derived>(ref).*pmf)(forward<Args>(args)...))>::type;
 
template <class Base, class T, class RefWrap, class... Args>
auto INVOKE(T Base::*pmf, RefWrap&& ref, Args&&... args)
 -> typename enable_if<is_function<T>::value &&
                     is_reference_wrapper<typename decay<RefWrap>::type>::value,
    decltype((ref.get().*pmf)(forward<Args>(args)...))>::type;
 
template <class Base, class T, class Pointer, class... Args>
auto INVOKE(T Base::*pmf, Pointer&& ptr, Args&&... args)
 -> typename enable_if<is_function<T>::value &&
                     !is_reference_wrapper<typename decay<Pointer>::type>::value &&
                     !is_base_of<Base, typename decay<Pointer>::type>::value,
    decltype(((*forward<Pointer>(ptr)).*pmf)(forward<Args>(args)...))>::type;
 
template <class Base, class T, class Derived>
auto INVOKE(T Base::*pmd, Derived&& ref)
 -> typename enable_if<!is_function<T>::value &&
                     is_base_of<Base, typename decay<Derived>::type>::value,
    decltype(forward<Derived>(ref).*pmd)>::type;
 
template <class Base, class T, class RefWrap>
auto INVOKE(T Base::*pmd, RefWrap&& ref)
 -> typename enable_if<!is_function<T>::value &&
                     is_reference_wrapper<typename decay<RefWrap>::type>::value,
    decltype(ref.get().*pmd)>::type;
 
template <class Base, class T, class Pointer>
auto INVOKE(T Base::*pmd, Pointer&& ptr)
 -> typename enable_if<!is_function<T>::value &&
                     !is_reference_wrapper<typename decay<Pointer>::type>::value &&
                     !is_base_of<Base, typename decay<Pointer>::type>::value,
    decltype((*forward<Pointer>(ptr)).*pmd)>::type;
 
template <class Func, class... Args>
auto INVOKE(Func&& f, Args&&... args)
 -> typename enable_if<!is_member_pointer<typename decay<Func>::type>::value,
    decltype(forward<Func>(f)(forward<Args>(args)...))>::type;
} // namespace detail
 
// Minimal C++11 implementation:
template <class> struct result_of;
template <class Func, class... ArgTypes>
struct result_of<Func(ArgTypes...)> {
    using type = decltype(detail::INVOKE(declval<Func>(), declval<ArgTypes>()...));
};

template< class T >
using result_of_t = typename result_of<T>::type;

///Invoke result

// Conforming C++14 implementation (is also a valid C++11 implementation):
namespace detail {
	template <typename AlwaysVoid, typename, typename...>
	struct invoke_result { };
	template <typename Func, typename...Args>
	struct invoke_result<decltype(void(detail::INVOKE(declval<Func>(), declval<Args>()...))),
	                 Func, Args...> {
	    using type = decltype(detail::INVOKE(declval<Func>(), declval<Args>()...));
	};
}

template <class Func, class... ArgTypes>
struct invoke_result : detail::invoke_result<void, Func, ArgTypes...> {};

template< class Func, class... ArgTypes>
using invoke_result_t = typename invoke_result<Func, ArgTypes...>::type;

template <typename>
struct __is_void_helper
		: public false_type
{
};

template <>
struct __is_void_helper<void>
		: public true_type
{
};

/// is_void
template <typename _Tp>
struct is_void
		: public integral_constant<bool, (__is_void_helper<typename remove_cv<_Tp>::type>::value)>
{
};

/// OR / AND / NOT helpers for std::conditional

template <typename, typename, typename...>
struct __or_;

template <typename _B1, typename _B2>
struct __or_<_B1, _B2>
		: public conditional<_B1::value, _B1, _B2>::type
{
};

template <typename _B1, typename _B2, typename _B3, typename... _Bn>
struct __or_<_B1, _B2, _B3, _Bn...>
		: public conditional<_B1::value, _B1, __or_<_B2, _B3, _Bn...>>::type
{
};

template <typename, typename, typename...>
struct __and_;

template <typename _B1, typename _B2>
struct __and_<_B1, _B2>
		: public conditional<_B1::value, _B2, _B1>::type
{
};

template <typename _B1, typename _B2, typename _B3, typename... _Bn>
struct __and_<_B1, _B2, _B3, _Bn...>
		: public conditional<_B1::value, __and_<_B2, _B3, _Bn...>, _B1>::type
{
};

template <typename _Pp>
struct __not_
		: public integral_constant<bool, !_Pp::value>
{
};

/// is_array
template <typename>
struct is_array
		: public false_type
{
};

template <typename _Tp, size_t _Size>
struct is_array<_Tp[_Size]>
		: public true_type
{
};

template <typename _Tp>
struct is_array<_Tp[]>
		: public true_type
{
};

template <typename _Tp>
struct __is_array_known_bounds
		: public integral_constant<bool, (extent<_Tp>::value > 0)>
{
};

template <typename _Tp>
struct __is_array_unknown_bounds
		: public __and_<is_array<_Tp>, __not_<extent<_Tp>>>::type
{
};

/// extent
template <typename, unsigned _Uint>
struct extent
		: public integral_constant<size_t, 0>
{
};

template <typename _Tp, unsigned _Uint, size_t _Size>
struct extent<_Tp[_Size], _Uint>
		: public integral_constant<size_t,
															 _Uint == 0 ? _Size : extent<_Tp, _Uint - 1>::value>
{
};

template <typename _Tp, unsigned _Uint>
struct extent<_Tp[], _Uint>
		: public integral_constant<size_t,
															 _Uint == 0 ? 0 : extent<_Tp, _Uint - 1>::value>
{
};

/// remove_all_extents
template <typename _Tp>
struct remove_all_extents
{
	typedef _Tp type;
};

template <typename _Tp, size_t _Size>
struct remove_all_extents<_Tp[_Size]>
{
	typedef typename remove_all_extents<_Tp>::type type;
};

template <typename _Tp>
struct remove_all_extents<_Tp[]>
{
	typedef typename remove_all_extents<_Tp>::type type;
};

/// __is_nt_default_constructible
template <typename T>
struct __is_nt_default_constructible_atom
		: public integral_constant<bool, noexcept(T())>
{
};

template <typename T, bool = is_array<T>::value>
struct __is_nt_default_constructible_impl;

template <typename T>
struct __is_nt_default_constructible_impl<T, true>
		: public __and_<__is_array_known_bounds<T>,
										__is_nt_default_constructible_atom<typename remove_all_extents<T>::type>>::type
{
};

template <typename T>
struct __is_nt_default_constructible_impl<T, false>
		: public __is_nt_default_constructible_atom<T>
{
};

template <typename T>
struct is_union : public integral_constant<bool, __is_union(T)>
{
};

template <typename T>
struct is_class : public integral_constant<bool, __is_class(T)>
{
};

template <typename T>
struct is_empty : public integral_constant<bool, __is_empty(T)>
{
};

template <typename>
struct __is_pointer_helper
		: public false_type
{
};

template <typename _Tp>
struct __is_pointer_helper<_Tp *>
		: public true_type
{
};

/// is_pointer
template <typename _Tp>
struct is_pointer
		: public integral_constant<bool, (__is_pointer_helper<typename remove_cv<_Tp>::type>::value)>
{
};

/// is_function
template <typename>
struct is_function
		: public false_type
{
};

template <typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes...)>
		: public true_type
{
};

template <typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes......)>
		: public true_type
{
};

template <typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes...) const>
		: public true_type
{
};

template <typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes......) const>
		: public true_type
{
};

template <typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes...) volatile>
		: public true_type
{
};

template <typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes......) volatile>
		: public true_type
{
};

template <typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes...) const volatile>
		: public true_type
{
};

template <typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes......) const volatile>
		: public true_type
{
};

template <typename>
struct __is_nullptr_t_helper
		: public false_type
{
};

template <>
struct __is_nullptr_t_helper<nullptr_t>
		: public true_type
{
};

// __is_nullptr_t (extension).
template <typename _Tp>
struct __is_nullptr_t
		: public integral_constant<bool, (__is_nullptr_t_helper<typename remove_cv<_Tp>::type>::value)>
{
};

/// is_member_object_pointer

template <typename>
struct __is_member_object_pointer_helper
		: public false_type
{
};

template <typename _Tp, typename _Cp>
struct __is_member_object_pointer_helper<_Tp _Cp::*>
		: public integral_constant<bool, !is_function<_Tp>::value>
{
};

template <typename _Tp>
struct is_member_object_pointer
		: public integral_constant<bool, (__is_member_object_pointer_helper<
																				 typename remove_cv<_Tp>::type>::value)>
{
};

/// is_reference
template <typename _Tp>
struct is_reference
		: public __or_<is_lvalue_reference<_Tp>,
									 is_rvalue_reference<_Tp>>::type
{
};

template <typename _Tp,
					bool = __and_<__not_<is_reference<_Tp>>,
												__not_<is_void<_Tp>>>::value,
					bool = is_rvalue_reference<_Tp>::value>
struct __add_lvalue_reference_helper
{
	typedef _Tp type;
};

template <typename _Tp>
struct __add_lvalue_reference_helper<_Tp, true, false>
{
	typedef _Tp &type;
};

template <typename _Tp>
struct __add_lvalue_reference_helper<_Tp, false, true>
{
	typedef typename remove_reference<_Tp>::type &type;
};

/// add_lvalue_reference
template <typename _Tp>
struct add_lvalue_reference
		: public __add_lvalue_reference_helper<_Tp>
{
};

template <typename _Tp,
					bool = __and_<__not_<is_reference<_Tp>>,
												__not_<is_void<_Tp>>>::value>
struct __add_rvalue_reference_helper
{
	typedef _Tp type;
};

template <typename _Tp>
struct __add_rvalue_reference_helper<_Tp, true>
{
	typedef _Tp &&type;
};

/// add_rvalue_reference
template <typename _Tp>
struct add_rvalue_reference
		: public __add_rvalue_reference_helper<_Tp>
{
};

template <typename>
struct __is_member_function_pointer_helper
		: public false_type
{
};

template <typename _Tp, typename _Cp>
struct __is_member_function_pointer_helper<_Tp _Cp::*>
		: public integral_constant<bool, is_function<_Tp>::value>
{
};

/// is_member_pointer
template< class T >
struct is_member_pointer_helper         : false_type {};
 
template< class T, class U >
struct is_member_pointer_helper<T U::*> : true_type {};
 
template< class T >
struct is_member_pointer : 
    is_member_pointer_helper<typename remove_cv<T>::type> {};

/// add_pointer
namespace detail {
template< class T, bool is_function_type = false >
struct add_pointer {
    using type = typename remove_reference<T>::type*;
};
 
template< class T >
struct add_pointer<T, true> {
    using type = T;
};
 
template< class T, class... Args >
struct add_pointer<T(Args...), true> {
    using type = T(*)(Args...);
};
 
template< class T, class... Args >
struct add_pointer<T(Args..., ...), true> {
    using type = T(*)(Args..., ...);
};
 
} // namespace detail
 
template< class T >
struct add_pointer : detail::add_pointer<T, is_function<T>::value> {};

/// is_member_function_pointer
template <typename _Tp>
struct is_member_function_pointer
		: public integral_constant<bool, (__is_member_function_pointer_helper<
																				 typename remove_cv<_Tp>::type>::value)>
{
};

/// is_base_of
namespace details {
    template <typename Base> true_type is_base_of_test_func(const volatile Base*);
    template <typename Base> false_type is_base_of_test_func(const volatile void*);
    template <typename Base, typename Derived>
    using pre_is_base_of = decltype(is_base_of_test_func<Base>(declval<Derived*>()));
 
    // with <experimental/type_traits>:
    // template <typename Base, typename Derived>
    // using pre_is_base_of2 = experimental::detected_or_t<true_type, pre_is_base_of, Base, Derived>;
    template <typename Base, typename Derived, typename = void>
    struct pre_is_base_of2 : public true_type { };
    // note void_t is a C++17 feature
    template <typename Base, typename Derived>
    struct pre_is_base_of2<Base, Derived, void_t<pre_is_base_of<Base, Derived>>> :
        public pre_is_base_of<Base, Derived> { };
}
 
template <typename Base, typename Derived>
struct is_base_of :
    public conditional_t<
        is_class<Base>::value && is_class<Derived>::value,
        details::pre_is_base_of2<Base, Derived>,
        false_type
    > { };

/// is_abstract
template <typename _Tp>
struct is_abstract
		: public integral_constant<bool, __is_abstract(_Tp)>
{
};

// In N3290 is_destructible does not say anything about function
// types and abstract types, see LWG 2049. This implementation
// describes function types as trivially nothrow destructible and
// abstract types as destructible, iff the  explicit destructor
// call expression is wellformed.
struct __do_is_destructible_impl_1
{
	template <typename _Up>
	struct __w
	{
		_Up __u;
	};

	template <typename _Tp, typename = decltype(declval<__w<_Tp> &>().~__w<_Tp>())>
	static true_type __test(int);

	template <typename>
	static false_type __test(...);
};

template <typename _Tp>
struct __is_destructible_impl_1
		: public __do_is_destructible_impl_1
{
	typedef decltype(__test<_Tp>(0)) type;
};

// Special implementation for abstract types
struct __do_is_destructible_impl_2
{
	template <typename _Tp, typename = decltype(declval<_Tp &>().~_Tp())>
	static true_type __test(int);

	template <typename>
	static false_type __test(...);
};

template <typename _Tp>
struct __is_destructible_impl_2
		: public __do_is_destructible_impl_2
{
	typedef decltype(__test<_Tp>(0)) type;
};

template <typename _Tp,
					bool = __or_<is_void<_Tp>,
											 __is_array_unknown_bounds<_Tp>>::value,
					bool = __or_<is_reference<_Tp>, is_function<_Tp>>::value>
struct __is_destructible_safe;

template <typename _Tp>
struct __is_destructible_safe<_Tp, false, false>
		: public conditional<is_abstract<_Tp>::value,
												 __is_destructible_impl_2<_Tp>,
												 __is_destructible_impl_1<_Tp>>::type::type
{
};

template <typename _Tp>
struct __is_destructible_safe<_Tp, true, false>
		: public false_type
{
};

template <typename _Tp>
struct __is_destructible_safe<_Tp, false, true>
		: public true_type
{
};

/// is_destructible
template <typename _Tp>
struct is_destructible
		: public integral_constant<bool, (__is_destructible_safe<_Tp>::value)>
{
};

/// is_default_constructible

struct __do_is_default_constructible_impl
{
	template <typename _Tp, typename = decltype(_Tp())>
	static true_type __test(int);

	template <typename>
	static false_type __test(...);
};

template <typename _Tp>
struct __is_default_constructible_impl
		: public __do_is_default_constructible_impl
{
	typedef decltype(__test<_Tp>(0)) type;
};

template <typename _Tp>
struct __is_default_constructible_atom
		: public __and_<__not_<is_void<_Tp>>,
										__is_default_constructible_impl<_Tp>>::type
{
};

template <typename _Tp, bool = is_array<_Tp>::value>
struct __is_default_constructible_safe;

// The following technique is a workaround for a current core language
// restriction, which does not allow for array types to occur in
// functional casts of the form T().  Complete arrays can be default-
// constructed, if the element type is default-constructible, but
// arrays with unknown bounds are not.
template <typename _Tp>
struct __is_default_constructible_safe<_Tp, true>
		: public __and_<__is_array_known_bounds<_Tp>,
										__is_default_constructible_atom<typename remove_all_extents<_Tp>::type>>::type
{
};

template <typename _Tp>
struct __is_default_constructible_safe<_Tp, false>
		: public __is_default_constructible_atom<_Tp>::type
{
};

// Implementation of is_constructible.

// The hardest part of this trait is the binary direct-initialization
// case, because we hit into a functional cast of the form T(arg).
// This implementation uses different strategies depending on the
// target type to reduce the test overhead as much as possible:
//
// a) For a reference target type, we use a static_cast expression
//    modulo its extra cases.
//
// b) For a non-reference target type we use a ::new expression.
struct __do_is_static_castable_impl
{
	template <typename _From, typename _To, typename = decltype(static_cast<_To>(declval<_From>()))>
	static true_type __test(int);

	template <typename, typename>
	static false_type __test(...);
};

template <typename _From, typename _To>
struct __is_static_castable_impl
		: public __do_is_static_castable_impl
{
	typedef decltype(__test<_From, _To>(0)) type;
};

template <typename _From, typename _To>
struct __is_static_castable_safe
		: public __is_static_castable_impl<_From, _To>::type
{
};

// __is_static_castable
template <typename _From, typename _To>
struct __is_static_castable
		: public integral_constant<bool, (__is_static_castable_safe<
																				 _From, _To>::value)>
{
};

// Implementation for non-reference types. To meet the proper
// variable definition semantics, we also need to test for
// is_destructible in this case.
struct __do_is_direct_constructible_impl
{
	template <typename _Tp, typename _Arg, typename = decltype(::new _Tp(declval<_Arg>()))>
	static true_type __test(int);

	template <typename, typename>
	static false_type __test(...);
};

template <typename _Tp, typename _Arg>
struct __is_direct_constructible_impl
		: public __do_is_direct_constructible_impl
{
	typedef decltype(__test<_Tp, _Arg>(0)) type;
};

template <typename _Tp, typename _Arg>
struct __is_direct_constructible_new_safe
		: public __and_<is_destructible<_Tp>,
										__is_direct_constructible_impl<_Tp, _Arg>>::type
{
};

template <typename, typename>
struct is_same;

template< class T, class U >
inline constexpr bool is_same_v = is_same<T, U>::value;

template <typename, typename>
struct is_base_of;

template <typename>
struct remove_reference;

template <typename _From, typename _To, bool = is_reference<_From>::value>
struct __is_base_to_derived_ref;

template <typename _From, typename _To>
struct __is_base_to_derived_ref<_From, _To, true>
{
	typedef typename remove_cv<typename remove_reference<_From>::type>::type __src_t;
	typedef typename remove_cv<typename remove_reference<_To>::type>::type __dst_t;
	typedef __and_<__not_<is_same<__src_t, __dst_t>>,
								 is_base_of<__src_t, __dst_t>>
			type;
	static constexpr bool value = type::value;
};

template <typename _From, typename _To>
struct __is_base_to_derived_ref<_From, _To, false>
		: public false_type
{
};

template <typename _From, typename _To, bool = __and_<is_lvalue_reference<_From>, is_rvalue_reference<_To>>::value>
struct __is_lvalue_to_rvalue_ref;

template <typename _From, typename _To>
struct __is_lvalue_to_rvalue_ref<_From, _To, true>
{
	typedef typename remove_cv<typename remove_reference<
			_From>::type>::type __src_t;
	typedef typename remove_cv<typename remove_reference<
			_To>::type>::type __dst_t;
	typedef __or_<is_same<__src_t, __dst_t>,
								is_base_of<__dst_t, __src_t>>
			type;
	static constexpr bool value = type::value;
};

template <typename _From, typename _To>
struct __is_lvalue_to_rvalue_ref<_From, _To, false>
		: public false_type
{
};

// Here we handle direct-initialization to a reference type as
// equivalent to a static_cast modulo overshooting conversions.
// These are restricted to the following conversions:
//    a) A glvalue of a base class to a derived class reference
//    b) An lvalue to an rvalue-reference of reference-compatible
//       types
template <typename _Tp, typename _Arg>
struct __is_direct_constructible_ref_cast
		: public __and_<__is_static_castable<_Arg, _Tp>,
										__not_<__or_<__is_base_to_derived_ref<_Arg, _Tp>,
																 __is_lvalue_to_rvalue_ref<_Arg, _Tp>>>>::type
{
};

template <typename _Tp, typename _Arg>
struct __is_direct_constructible_new
		: public conditional<is_reference<_Tp>::value,
												 __is_direct_constructible_ref_cast<_Tp, _Arg>,
												 __is_direct_constructible_new_safe<_Tp, _Arg>>::type
{
};

template <typename _Tp, typename _Arg>
struct __is_direct_constructible
		: public integral_constant<bool, (__is_direct_constructible_new<
																				 _Tp, _Arg>::value)>
{
};

// Since default-construction and binary direct-initialization have
// been handled separately, the implementation of the remaining
// n-ary construction cases is rather straightforward.
struct __do_is_nary_constructible_impl
{
	template <typename _Tp, typename... _Args, typename = decltype(_Tp(declval<_Args>()...))>
	static true_type __test(int);

	template <typename, typename...>
	static false_type __test(...);
};

template <typename _Tp, typename... _Args>
struct __is_nary_constructible_impl
		: public __do_is_nary_constructible_impl
{
	typedef decltype(__test<_Tp, _Args...>(0)) type;
};

template <typename _Tp, typename... _Args>
struct __is_nary_constructible
		: public __is_nary_constructible_impl<_Tp, _Args...>::type
{
	static_assert(sizeof...(_Args) > 1,
								"Only useful for > 1 arguments");
};

template <typename _Tp, typename... _Args>
struct __is_constructible_impl
		: public __is_nary_constructible<_Tp, _Args...>
{
};

template <typename _Tp, typename _Arg>
struct __is_constructible_impl<_Tp, _Arg>
		: public __is_direct_constructible<_Tp, _Arg>
{
};

template <typename _Tp>
struct __is_constructible_impl<_Tp>
		: public is_default_constructible<_Tp>
{
};

/// is_constructible
template <typename _Tp, typename... _Args>
struct is_constructible
		: public integral_constant<bool, (__is_constructible_impl<_Tp,
																															_Args...>::value)>
{
};

/// is_default_constructible
template <typename _Tp>
struct is_default_constructible
		: public integral_constant<bool, (__is_default_constructible_safe<
																				 _Tp>::value)>
{
};

/// is_enum
template <typename _Tp>
struct is_enum
		: public integral_constant<bool, __is_enum(_Tp)>
{
};

template <typename T>
struct is_nothrow_default_constructible
		: public __and_<is_default_constructible<T>,
										__is_nt_default_constructible_impl<T>>::type
{
};

/// is_nothrow_constructible

template <typename _Tp, typename... _Args>
struct __is_nt_constructible_impl
		: public integral_constant<bool, noexcept(_Tp(declval<_Args>()...))>
{
};

template <typename _Tp, typename _Arg>
struct __is_nt_constructible_impl<_Tp, _Arg>
		: public integral_constant<bool,
															 noexcept(static_cast<_Tp>(declval<_Arg>()))>
{
};

template <typename _Tp>
struct __is_nt_constructible_impl<_Tp>
		: public is_nothrow_default_constructible<_Tp>
{
};

template <typename _Tp, typename... _Args>
struct is_nothrow_constructible
		: public __and_<is_constructible<_Tp, _Args...>,
										__is_nt_constructible_impl<_Tp, _Args...>>::type
{
};

/// is_nothrow_move_constructible

template <typename _Tp, bool = is_void<_Tp>::value>
struct __is_nothrow_move_constructible_impl;

template <typename _Tp>
struct __is_nothrow_move_constructible_impl<_Tp, true>
		: public false_type
{
};

template <typename _Tp>
struct __is_nothrow_move_constructible_impl<_Tp, false>
		: public is_nothrow_constructible<_Tp, _Tp &&>
{
};

template <typename _Tp>
struct is_nothrow_move_constructible
		: public __is_nothrow_move_constructible_impl<_Tp>
{
};

template <typename _Tp, typename _Up>
class __is_assignable_helper
		: public __sfinae_types
{
	template <typename _Tp1, typename _Up1>
	static decltype(declval<_Tp1>() = declval<_Up1>(), __one())
	__test(int);

	template <typename, typename>
	static __two __test(...);

public:
	static constexpr bool value = sizeof(__test<_Tp, _Up>(0)) == 1;
};

/// is_assignable
template <typename _Tp, typename _Up>
struct is_assignable
		: public integral_constant<bool,
															 __is_assignable_helper<_Tp, _Up>::value>
{
};

template <typename _Tp, bool = is_void<_Tp>::value>
struct __is_copy_assignable_impl;

template <typename _Tp>
struct __is_copy_assignable_impl<_Tp, true>
		: public false_type
{
};

template <typename _Tp>
struct __is_copy_assignable_impl<_Tp, false>
		: public is_assignable<_Tp &, const _Tp &&>
{
};

/// is_copy_assignable
template <typename _Tp>
struct is_copy_assignable
		: public __is_copy_assignable_impl<_Tp>
{
};

template <typename _Tp, bool = is_void<_Tp>::value>
struct __is_move_assignable_impl;

template <typename _Tp>
struct __is_move_assignable_impl<_Tp, true>
		: public false_type
{
};

template <typename _Tp>
struct __is_move_assignable_impl<_Tp, false>
		: public is_assignable<_Tp &, _Tp &&>
{
};

/// is_move_assignable
template <typename _Tp>
struct is_move_assignable
		: public __is_move_assignable_impl<_Tp>
{
};

template <typename _Tp, typename _Up>
struct __is_nt_assignable_impl
		: public integral_constant<bool, noexcept(declval<_Tp>() = declval<_Up>())>
{
};

/// is_nothrow_assignable
template <typename _Tp, typename _Up>
struct is_nothrow_assignable
		: public __and_<is_assignable<_Tp, _Up>,
										__is_nt_assignable_impl<_Tp, _Up>>::type
{
};

template <typename _Tp, bool = is_void<_Tp>::value>
struct __is_nt_copy_assignable_impl;

template <typename _Tp>
struct __is_nt_copy_assignable_impl<_Tp, true>
		: public false_type
{
};

template <typename _Tp>
struct __is_nt_copy_assignable_impl<_Tp, false>
		: public is_nothrow_assignable<_Tp &, const _Tp &&>
{
};

/// is_nothrow_copy_assignable
template <typename _Tp>
struct is_nothrow_copy_assignable
		: public __is_nt_copy_assignable_impl<_Tp>
{
};

template <typename _Tp, bool = is_void<_Tp>::value>
struct __is_nt_move_assignable_impl;

template <typename _Tp>
struct __is_nt_move_assignable_impl<_Tp, true>
		: public false_type
{
};

template <typename _Tp>
struct __is_nt_move_assignable_impl<_Tp, false>
		: public is_nothrow_assignable<_Tp &, _Tp &&>
{
};

/// is_nothrow_move_assignable
template <typename _Tp>
struct is_nothrow_move_assignable
		: public __is_nt_move_assignable_impl<_Tp>
{
};

/// is_convertible
template <typename _From, typename _To,
					bool = __or_<is_void<_From>, is_function<_To>,
											 is_array<_To>>::value>
struct __is_convertible_helper
{
	static constexpr bool value = is_void<_To>::value;
};

template <typename _From, typename _To>
class __is_convertible_helper<_From, _To, false>
		: public __sfinae_types
{
	template <typename _To1>
	static void __test_aux(_To1);

	template <typename _From1, typename _To1>
	static decltype(__test_aux<_To1>(declval<_From1>()), __one())
	__test(int);

	template <typename, typename>
	static __two __test(...);

public:
	static constexpr bool value = sizeof(__test<_From, _To>(0)) == 1;
};

/// is_convertible
template <typename _From, typename _To>
struct is_convertible
		: public integral_constant<bool,
															 __is_convertible_helper<_From, _To>::value>
{
};

/// is_explicitly_convertible
template <typename _From, typename _To>
struct is_explicitly_convertible
		: public is_constructible<_To, _From>
{
};

/// has_trivial_default_constructor
template <typename _Tp>
struct has_trivial_default_constructor
		: public integral_constant<bool, __has_trivial_constructor(_Tp)>
{
};

/// has_trivial_copy_constructor
template <typename _Tp>
struct has_trivial_copy_constructor
		: public integral_constant<bool, __has_trivial_copy(_Tp)>
{
};

/// has_trivial_copy_assign
template <typename _Tp>
struct has_trivial_copy_assign
		: public integral_constant<bool, __has_trivial_assign(_Tp)>
{
};

/// has_trivial_destructor
template <typename _Tp>
struct has_trivial_destructor
		: public integral_constant<bool, __has_trivial_destructor(_Tp)>
{
};

/// has_virtual_destructor
template <typename _Tp>
struct has_virtual_destructor
		: public integral_constant<bool, __has_virtual_destructor(_Tp)>
{
};

template <typename T>
using is_trivially_destructible = has_trivial_destructor<T>;

template <typename T>
using is_trivially_destructible_v = typename is_trivially_destructible<T>::value;

/// common_type
template <typename... _Tp>
struct common_type;

template <typename _Tp>
struct common_type<_Tp>
{
	typedef _Tp type;
};

template <typename _Tp, typename _Up>
struct common_type<_Tp, _Up>
{
	typedef decltype(true ? declval<_Tp>() : declval<_Up>()) type;
};

template <typename _Tp, typename _Up, typename... _Vp>
struct common_type<_Tp, _Up, _Vp...>
{
	typedef typename common_type<typename common_type<_Tp, _Up>::type, _Vp...>::type type;
};

template <class T>
struct type_identity {
	using type = T;
};

template <class T>
using type_identity_t = typename type_identity<T>::type;

} // namespace std

#pragma GCC visibility pop

#endif