darlinghq/darling-libcxx
1
0
Fork 0
mirror of https://github.com/darlinghq/darling-libcxx.git synced 2024-11-24 12:29:57 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
1387038988
darling-libcxx/include/type_traits

1639 lines
54 KiB
C++
Raw Blame History

// -*- C++ -*-
//===------------------------ type_traits ---------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP_TYPE_TRAITS
#define _LIBCPP_TYPE_TRAITS
/*
type_traits synopsis
namespace std
{
// helper class:
template <class T, T v> struct integral_constant;
typedef integral_constant<bool, true> true_type;
typedef integral_constant<bool, false> false_type;
// helper traits
template <bool, class T = void> struct enable_if;
template <bool, class T, class F> struct conditional;
// Primary classification traits:
template <class T> struct is_void;
template <class T> struct is_integral;
template <class T> struct is_floating_point;
template <class T> struct is_array;
template <class T> struct is_pointer;
template <class T> struct is_lvalue_reference;
template <class T> struct is_rvalue_reference;
template <class T> struct is_member_object_pointer;
template <class T> struct is_member_function_pointer;
template <class T> struct is_enum;
template <class T> struct is_union;
template <class T> struct is_class;
template <class T> struct is_function;
// Secondary classification traits:
template <class T> struct is_reference;
template <class T> struct is_arithmetic;
template <class T> struct is_fundamental;
template <class T> struct is_member_pointer;
template <class T> struct is_scalar;
template <class T> struct is_object;
template <class T> struct is_compound;
// Const-volatile properties and transformations:
template <class T> struct is_const;
template <class T> struct is_volatile;
template <class T> struct remove_const;
template <class T> struct remove_volatile;
template <class T> struct remove_cv;
template <class T> struct add_const;
template <class T> struct add_volatile;
template <class T> struct add_cv;
// Reference transformations:
template <class T> struct remove_reference;
template <class T> struct add_lvalue_reference;
template <class T> struct add_rvalue_reference;
// Pointer transformations:
template <class T> struct remove_pointer;
template <class T> struct add_pointer;
// Integral properties:
template <class T> struct is_signed;
template <class T> struct is_unsigned;
template <class T> struct make_signed;
template <class T> struct make_unsigned;
// Array properties and transformations:
template <class T> struct rank;
template <class T, unsigned I = 0> struct extent;
template <class T> struct remove_extent;
template <class T> struct remove_all_extents;
// Member introspection:
template <class T> struct is_pod;
template <class T> struct is_trivial;
template <class T> struct is_trivially_copyable;
template <class T> struct is_standard_layout;
template <class T> struct is_literal_type;
template <class T> struct is_empty;
template <class T> struct is_polymorphic;
template <class T> struct is_abstract;
template <class T, class... Args> struct is_constructible;
template <class T, class... Args> struct is_nothrow_constructible;
template <class T> struct has_default_constructor;
template <class T> struct has_copy_constructor;
template <class T> struct has_move_constructor;
template <class T> struct has_copy_assign;
template <class T> struct has_move_assign;
template <class T> struct has_trivial_default_constructor
template <class T> struct has_trivial_copy_constructor;
template <class T> struct has_trivial_move_constructor;
template <class T> struct has_trivial_copy_assign;
template <class T> struct has_trivial_move_assign;
template <class T> struct has_trivial_destructor;
template <class T> struct has_nothrow_default_constructor;
template <class T> struct has_nothrow_copy_constructor;
template <class T> struct has_nothrow_move_constructor;
template <class T> struct has_nothrow_copy_assign;
template <class T> struct has_nothrow_move_assign;
template <class T> struct has_virtual_destructor;
// Relationships between types:
template <class T, class U> struct is_same;
template <class Base, class Derived> struct is_base_of;
template <class From, class To> struct is_convertible;
template <class T> struct underlying_type;
// Alignment properties and transformations:
template <class T> struct alignment_of;
template <size_t Len, size_t Align = most_stringent_alignment_requirement>
struct aligned_storage;
template <std::size_t Len, class... Types> struct aligned_union;
template <class T> struct decay;
template <class... T> struct common_type;
template <class T> struct underlying_type;
template <class> class result_of; // undefined
template <class Fn, class... ArgTypes> class result_of<Fn(ArgTypes...)>;
} // std
*/
#include <__config>
#include <cstddef>
#pragma GCC system_header
_LIBCPP_BEGIN_NAMESPACE_STD
template <bool _B, class _If, class _Then> struct conditional {typedef _If type;};
template <class _If, class _Then> struct conditional<false, _If, _Then> {typedef _Then type;};
template <bool, class _Tp = void> struct enable_if {};
template <class _Tp> struct enable_if<true, _Tp> {typedef _Tp type;};
struct __two {char _[2];};
// helper class:
template <class _Tp, _Tp __v>
struct integral_constant
{
static constexpr _Tp value = __v;
typedef _Tp value_type;
typedef integral_constant type;
#ifndef _LIBCPP_HAS_NO_CONSTEXPR
constexpr operator value_type() {return value;}
#endif
};
template <class _Tp, _Tp __v>
const _Tp integral_constant<_Tp, __v>::value;
typedef integral_constant<bool, true> true_type;
typedef integral_constant<bool, false> false_type;
// is_const
template <class _Tp> struct is_const : public false_type {};
template <class _Tp> struct is_const<_Tp const> : public true_type {};
// is_volatile
template <class _Tp> struct is_volatile : public false_type {};
template <class _Tp> struct is_volatile<_Tp volatile> : public true_type {};
// remove_const
template <class _Tp> struct remove_const {typedef _Tp type;};
template <class _Tp> struct remove_const<const _Tp> {typedef _Tp type;};
// remove_volatile
template <class _Tp> struct remove_volatile {typedef _Tp type;};
template <class _Tp> struct remove_volatile<volatile _Tp> {typedef _Tp type;};
// remove_cv
template <class _Tp> struct remove_cv
{typedef typename remove_volatile<typename remove_const<_Tp>::type>::type type;};
// is_void
template <class _Tp> struct __is_void : public false_type {};
template <> struct __is_void<void> : public true_type {};
template <class _Tp> struct is_void : public __is_void<typename remove_cv<_Tp>::type> {};
// is_integral
template <class _Tp> struct __is_integral : public false_type {};
template <> struct __is_integral<bool> : public true_type {};
template <> struct __is_integral<char> : public true_type {};
template <> struct __is_integral<signed char> : public true_type {};
template <> struct __is_integral<unsigned char> : public true_type {};
template <> struct __is_integral<wchar_t> : public true_type {};
#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
template <> struct __is_integral<char16_t> : public true_type {};
template <> struct __is_integral<char32_t> : public true_type {};
#endif // _LIBCPP_HAS_NO_UNICODE_CHARS
template <> struct __is_integral<short> : public true_type {};
template <> struct __is_integral<unsigned short> : public true_type {};
template <> struct __is_integral<int> : public true_type {};
template <> struct __is_integral<unsigned int> : public true_type {};
template <> struct __is_integral<long> : public true_type {};
template <> struct __is_integral<unsigned long> : public true_type {};
template <> struct __is_integral<long long> : public true_type {};
template <> struct __is_integral<unsigned long long> : public true_type {};
template <class _Tp> struct is_integral : public __is_integral<typename remove_cv<_Tp>::type> {};
// is_floating_point
template <class _Tp> struct __is_floating_point : public false_type {};
template <> struct __is_floating_point<float> : public true_type {};
template <> struct __is_floating_point<double> : public true_type {};
template <> struct __is_floating_point<long double> : public true_type {};
template <class _Tp> struct is_floating_point : public __is_floating_point<typename remove_cv<_Tp>::type> {};
// is_array
template <class _Tp> struct is_array : public false_type {};
template <class _Tp> struct is_array<_Tp[]> : public true_type {};
template <class _Tp, size_t _Np> struct is_array<_Tp[_Np]> : public true_type {};
// is_pointer
template <class _Tp> struct __is_pointer : public false_type {};
template <class _Tp> struct __is_pointer<_Tp*> : public true_type {};
template <class _Tp> struct is_pointer : public __is_pointer<typename remove_cv<_Tp>::type> {};
// is_reference
template <class _Tp> struct is_lvalue_reference : public false_type {};
template <class _Tp> struct is_lvalue_reference<_Tp&> : public true_type {};
template <class _Tp> struct is_rvalue_reference : public false_type {};
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
template <class _Tp> struct is_rvalue_reference<_Tp&&> : public true_type {};
#endif
template <class _Tp> struct is_reference : public false_type {};
template <class _Tp> struct is_reference<_Tp&> : public true_type {};
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
template <class _Tp> struct is_reference<_Tp&&> : public true_type {};
#endif
// is_union
#if __GNUC__ >= 4 && __GNUC_MINOR__ >= 3 || defined(__clang__)
template <class _Tp> struct is_union : public integral_constant<bool, __is_union(_Tp)> {};
#else // __GNUC__ >= 4 && __GNUC_MINOR__ >= 3
template <class _Tp> struct __libcpp_union : public false_type {};
template <class _Tp> struct is_union : public __libcpp_union<typename remove_cv<_Tp>::type> {};
#endif // __GNUC__ >= 4 && __GNUC_MINOR__ >= 3
// is_class
namespace __is_class_imp
{
template <class _Tp> char __test(int _Tp::*);
template <class _Tp> __two __test(...);
}
template <class _Tp> struct is_class
: public integral_constant<bool, sizeof(__is_class_imp::__test<_Tp>(0)) == 1 && !is_union<_Tp>::value> {};
// is_function
namespace __is_function_imp
{
template <class _Tp> char __test(_Tp*);
template <class _Tp> __two __test(...);
template <class _Tp> _Tp& __source();
}
template <class _Tp, bool = is_class<_Tp>::value ||
is_union<_Tp>::value ||
is_void<_Tp>::value ||
is_reference<_Tp>::value>
struct __is_function
: public integral_constant<bool, sizeof(__is_function_imp::__test<_Tp>(__is_function_imp::__source<_Tp>())) == 1>
{};
template <class _Tp> struct __is_function<_Tp, true> : public false_type {};
template <class _Tp> struct is_function : public __is_function<_Tp> {};
// is_member_function_pointer
template <class _Tp> struct __is_member_function_pointer : public false_type {};
template <class _Tp, class _Up> struct __is_member_function_pointer<_Tp _Up::*> : public is_function<_Tp> {};
template <class _Tp> struct is_member_function_pointer
: public __is_member_function_pointer<typename remove_cv<_Tp>::type> {};
// is_member_pointer
template <class _Tp> struct __is_member_pointer : public false_type {};
template <class _Tp, class _Up> struct __is_member_pointer<_Tp _Up::*> : public true_type {};
template <class _Tp> struct is_member_pointer
: public __is_member_pointer<typename remove_cv<_Tp>::type> {};
// is_member_object_pointer
template <class _Tp> struct is_member_object_pointer
: public integral_constant<bool, is_member_pointer<_Tp>::value &&
!is_member_function_pointer<_Tp>::value> {};
// is_enum
template <class _Tp> struct is_enum
: public integral_constant<bool, !is_void<_Tp>::value &&
!is_integral<_Tp>::value &&
!is_floating_point<_Tp>::value &&
!is_array<_Tp>::value &&
!is_pointer<_Tp>::value &&
!is_reference<_Tp>::value &&
!is_member_pointer<_Tp>::value &&
!is_union<_Tp>::value &&
!is_class<_Tp>::value &&
!is_function<_Tp>::value > {};
// is_arithmetic
template <class _Tp> struct is_arithmetic
: public integral_constant<bool, is_integral<_Tp>::value ||
is_floating_point<_Tp>::value> {};
// is_fundamental
template <class _Tp> struct is_fundamental
: public integral_constant<bool, is_void<_Tp>::value ||
is_arithmetic<_Tp>::value> {};
// is_scalar
template <class _Tp> struct is_scalar
: public integral_constant<bool, is_arithmetic<_Tp>::value ||
is_member_pointer<_Tp>::value ||
is_pointer<_Tp>::value ||
is_enum<_Tp>::value > {};
// is_object
template <class _Tp> struct is_object
: public integral_constant<bool, is_scalar<_Tp>::value ||
is_array<_Tp>::value ||
is_union<_Tp>::value ||
is_class<_Tp>::value > {};
// is_compound
template <class _Tp> struct is_compound : public integral_constant<bool, !is_fundamental<_Tp>::value> {};
// add_const
template <class _Tp, bool = is_reference<_Tp>::value ||
is_function<_Tp>::value ||
is_const<_Tp>::value >
struct __add_const {typedef _Tp type;};
template <class _Tp>
struct __add_const<_Tp, false> {typedef const _Tp type;};
template <class _Tp> struct add_const {typedef typename __add_const<_Tp>::type type;};
// add_volatile
template <class _Tp, bool = is_reference<_Tp>::value ||
is_function<_Tp>::value ||
is_volatile<_Tp>::value >
struct __add_volatile {typedef _Tp type;};
template <class _Tp>
struct __add_volatile<_Tp, false> {typedef volatile _Tp type;};
template <class _Tp> struct add_volatile {typedef typename __add_volatile<_Tp>::type type;};
// add_cv
template <class _Tp> struct add_cv {typedef typename add_const<typename add_volatile<_Tp>::type>::type type;};
// remove_reference
template <class _Tp> struct remove_reference {typedef _Tp type;};
template <class _Tp> struct remove_reference<_Tp&> {typedef _Tp type;};
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
template <class _Tp> struct remove_reference<_Tp&&> {typedef _Tp type;};
#endif
// add_lvalue_reference
template <class _Tp> struct add_lvalue_reference {typedef _Tp& type;};
template <class _Tp> struct add_lvalue_reference<_Tp&> {typedef _Tp& type;}; // for older compiler
template <> struct add_lvalue_reference<void> {typedef void type;};
template <> struct add_lvalue_reference<const void> {typedef const void type;};
template <> struct add_lvalue_reference<volatile void> {typedef volatile void type;};
template <> struct add_lvalue_reference<const volatile void> {typedef const volatile void type;};
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
template <class _Tp> struct add_rvalue_reference {typedef _Tp&& type;};
template <> struct add_rvalue_reference<void> {typedef void type;};
template <> struct add_rvalue_reference<const void> {typedef const void type;};
template <> struct add_rvalue_reference<volatile void> {typedef volatile void type;};
template <> struct add_rvalue_reference<const volatile void> {typedef const volatile void type;};
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
// remove_pointer
template <class _Tp> struct remove_pointer {typedef _Tp type;};
template <class _Tp> struct remove_pointer<_Tp*> {typedef _Tp type;};
template <class _Tp> struct remove_pointer<_Tp* const> {typedef _Tp type;};
template <class _Tp> struct remove_pointer<_Tp* volatile> {typedef _Tp type;};
template <class _Tp> struct remove_pointer<_Tp* const volatile> {typedef _Tp type;};
// add_pointer
template <class _Tp> struct add_pointer {typedef typename remove_reference<_Tp>::type* type;};
// is_signed
template <class _Tp, bool = is_integral<_Tp>::value>
struct ___is_signed : public integral_constant<bool, _Tp(-1) < _Tp(0)> {};
template <class _Tp>
struct ___is_signed<_Tp, false> : public true_type {}; // floating point
template <class _Tp, bool = is_arithmetic<_Tp>::value>
struct __is_signed : public ___is_signed<_Tp> {};
template <class _Tp> struct __is_signed<_Tp, false> : public false_type {};
template <class _Tp> struct is_signed : public __is_signed<_Tp> {};
// is_unsigned
template <class _Tp, bool = is_integral<_Tp>::value>
struct ___is_unsigned : public integral_constant<bool, _Tp(0) < _Tp(-1)> {};
template <class _Tp>
struct ___is_unsigned<_Tp, false> : public false_type {}; // floating point
template <class _Tp, bool = is_arithmetic<_Tp>::value>
struct __is_unsigned : public ___is_unsigned<_Tp> {};
template <class _Tp> struct __is_unsigned<_Tp, false> : public false_type {};
template <class _Tp> struct is_unsigned : public __is_unsigned<_Tp> {};
// rank
template <class _Tp> struct rank : public integral_constant<size_t, 0> {};
template <class _Tp> struct rank<_Tp[]> : public integral_constant<size_t, rank<_Tp>::value + 1> {};
template <class _Tp, size_t _Np> struct rank<_Tp[_Np]> : public integral_constant<size_t, rank<_Tp>::value + 1> {};
// extent
template <class _Tp, unsigned _Ip = 0> struct extent : public integral_constant<size_t, 0> {};
template <class _Tp> struct extent<_Tp[], 0> : public integral_constant<size_t, 0> {};
template <class _Tp, unsigned _Ip> struct extent<_Tp[], _Ip> : public integral_constant<size_t, extent<_Tp, _Ip-1>::value> {};
template <class _Tp, size_t _Np> struct extent<_Tp[_Np], 0> : public integral_constant<size_t, _Np> {};
template <class _Tp, size_t _Np, unsigned _Ip> struct extent<_Tp[_Np], _Ip> : public integral_constant<size_t, extent<_Tp, _Ip-1>::value> {};
// remove_extent
template <class _Tp> struct remove_extent {typedef _Tp type;};
template <class _Tp> struct remove_extent<_Tp[]> {typedef _Tp type;};
template <class _Tp, size_t _Np> struct remove_extent<_Tp[_Np]> {typedef _Tp type;};
// remove_all_extents
template <class _Tp> struct remove_all_extents {typedef _Tp type;};
template <class _Tp> struct remove_all_extents<_Tp[]> {typedef typename remove_all_extents<_Tp>::type type;};
template <class _Tp, size_t _Np> struct remove_all_extents<_Tp[_Np]> {typedef typename remove_all_extents<_Tp>::type type;};
// is_same
template <class _Tp, class _Up> struct is_same : public false_type {};
template <class _Tp> struct is_same<_Tp, _Tp> : public true_type {};
// is_abstract
namespace __is_abstract_imp
{
template <class _Tp> char __test(_Tp (*)[1]);
template <class _Tp> __two __test(...);
}
template <class _Tp, bool = is_class<_Tp>::value>
struct __libcpp_abstract : public integral_constant<bool, sizeof(__is_abstract_imp::__test<_Tp>(0)) != 1> {};
template <class _Tp> struct __libcpp_abstract<_Tp, false> : public false_type {};
template <class _Tp> struct is_abstract : public __libcpp_abstract<_Tp> {};
// is_convertible
namespace __is_convertible_imp
{
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
template <class _Tp> char __test(const volatile typename remove_reference<_Tp>::type&&);
#else
template <class _Tp> char __test(_Tp);
#endif
template <class _Tp> __two __test(...);
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
template <class _Tp> _Tp&& __source();
#else
template <class _Tp> typename remove_reference<_Tp>::type& __source();
#endif
template <class _Tp, bool _IsArray = is_array<_Tp>::value,
bool _IsFunction = is_function<_Tp>::value,
bool _IsVoid = is_void<_Tp>::value>
struct __is_array_function_or_void {enum {value = 0};};
template <class _Tp> struct __is_array_function_or_void<_Tp, true, false, false> {enum {value = 1};};
template <class _Tp> struct __is_array_function_or_void<_Tp, false, true, false> {enum {value = 2};};
template <class _Tp> struct __is_array_function_or_void<_Tp, false, false, true> {enum {value = 3};};
}
template <class _Tp,
unsigned = __is_convertible_imp::__is_array_function_or_void<typename remove_reference<_Tp>::type>::value>
struct __is_convertible_check
{
static const size_t __v = 0;
};
template <class _Tp>
struct __is_convertible_check<_Tp, 0>
{
static const size_t __v = sizeof(_Tp);
};
template <class _T1, class _T2,
unsigned _T1_is_array_function_or_void = __is_convertible_imp::__is_array_function_or_void<_T1>::value,
unsigned _T2_is_array_function_or_void = __is_convertible_imp::__is_array_function_or_void<_T2>::value>
struct __is_convertible
: public integral_constant<bool,
sizeof(__is_convertible_imp::__test<_T2>(__is_convertible_imp::__source<_T1>())) == 1
>
{};
template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 1, 0> : false_type {};
template <class _T1> struct __is_convertible<_T1, const _T1&, 1, 0> : true_type {};
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
template <class _T1> struct __is_convertible<_T1, _T1&&, 1, 0> : true_type {};
template <class _T1> struct __is_convertible<_T1, const _T1&&, 1, 0> : true_type {};
template <class _T1> struct __is_convertible<_T1, volatile _T1&&, 1, 0> : true_type {};
template <class _T1> struct __is_convertible<_T1, const volatile _T1&&, 1, 0> : true_type {};
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
template <class _T1, class _T2> struct __is_convertible<_T1, _T2*, 1, 0>
: public integral_constant<bool, __is_convertible<typename remove_all_extents<_T1>::type*, _T2*>::value> {};
template <class _T1, class _T2> struct __is_convertible<_T1, _T2* const, 1, 0>
: public integral_constant<bool, __is_convertible<typename remove_all_extents<_T1>::type*, _T2*const>::value> {};
template <class _T1, class _T2> struct __is_convertible<_T1, _T2* volatile, 1, 0>
: public integral_constant<bool, __is_convertible<typename remove_all_extents<_T1>::type*, _T2*volatile>::value> {};
template <class _T1, class _T2> struct __is_convertible<_T1, _T2* const volatile, 1, 0>
: public integral_constant<bool, __is_convertible<typename remove_all_extents<_T1>::type*, _T2*const volatile>::value> {};
template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 2, 0> : public false_type {};
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
template <class _T1> struct __is_convertible<_T1, _T1&&, 2, 0> : public true_type {};
#endif
template <class _T1> struct __is_convertible<_T1, _T1*, 2, 0> : public true_type {};
template <class _T1> struct __is_convertible<_T1, _T1*const, 2, 0> : public true_type {};
template <class _T1> struct __is_convertible<_T1, _T1*volatile, 2, 0> : public true_type {};
template <class _T1> struct __is_convertible<_T1, _T1*const volatile, 2, 0> : public true_type {};
template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 3, 0> : public false_type {};
template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 0, 1> : public false_type {};
template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 1, 1> : public false_type {};
template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 2, 1> : public false_type {};
template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 3, 1> : public false_type {};
template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 0, 2> : public false_type {};
template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 1, 2> : public false_type {};
template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 2, 2> : public false_type {};
template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 3, 2> : public false_type {};
template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 0, 3> : public false_type {};
template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 1, 3> : public false_type {};
template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 2, 3> : public false_type {};
template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 3, 3> : public true_type {};
template <class _T1, class _T2> struct is_convertible : public __is_convertible<_T1, _T2>
{
static const size_t __complete_check1 = __is_convertible_check<_T1>::__v;
static const size_t __complete_check2 = __is_convertible_check<_T2>::__v;
};
// is_base_of
// (C) Copyright Rani Sharoni 2003.
// Use, modification and distribution are subject to the Boost Software License,
// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt).
//
// See http://www.boost.org/libs/type_traits for most recent version including documentation.
template <class _Bp, class _Dp>
struct __is_base_of_tests
{
template <class _Tp>
static char __test(const volatile _Dp*, _Tp);
static __two __test(const volatile _Bp*, int);
};
template <class _Bp, class _Dp>
struct __is_base_of_imp
{
struct __host
{
operator const volatile _Bp*() const;
operator const volatile _Dp*();
};
static const size_t __complete_check = sizeof(_Dp);
static const bool value = sizeof(__is_base_of_tests<_Bp, _Dp>::__test(__host(), 0)) == 1;
};
template <class _Bp, class _Dp, bool = is_class<_Bp>::value,
bool = is_class<_Dp>::value,
bool = is_same<_Bp, _Dp>::value>
struct __libcpp_base_of : public false_type {};
template <class _Bp, class _Dp>
struct __libcpp_base_of<_Bp, _Dp, true, true, true> : public true_type {};
template <class _Bp, class _Dp>
struct __libcpp_base_of<_Bp, _Dp, true, true, false>
: public integral_constant<bool, __is_base_of_imp<_Bp, _Dp>::value> {};
template <class _Bp, class _Dp>
struct is_base_of
: public __libcpp_base_of<typename remove_cv<_Bp>::type, typename remove_cv<_Dp>::type>
{
};
// is_empty
template <class _Tp>
struct __is_empty1
: public _Tp
{
double _;
};
struct __is_empty2
{
double _;
};
template <class _Tp, bool = is_class<_Tp>::value>
struct __libcpp_empty : public integral_constant<bool, sizeof(__is_empty1<_Tp>) == sizeof(__is_empty2)> {};
template <class _Tp> struct __libcpp_empty<_Tp, false> : public false_type {};
template <class _Tp> struct is_empty : public __libcpp_empty<_Tp> {};
// is_polymorphic
template <class _Tp> struct __is_polymorphic1 : public _Tp {};
template <class _Tp> struct __is_polymorphic2 : public _Tp {virtual ~__is_polymorphic2() throw();};
template <class _Tp, bool = is_class<_Tp>::value>
struct __libcpp_polymorphic
: public integral_constant<bool, sizeof(__is_polymorphic1<_Tp>) == sizeof(__is_polymorphic2<_Tp>)> {};
template <class _Tp> struct __libcpp_polymorphic<_Tp, false> : public false_type {};
template <class _Tp> struct is_polymorphic : public __libcpp_polymorphic<_Tp> {};
// has_trivial_default_constructor
template <class _Tp> struct __has_trivial_default_constructor : public integral_constant<bool, is_scalar<_Tp>::value> {};
template <class _Tp> struct has_trivial_default_constructor
: public __has_trivial_default_constructor<typename remove_all_extents<_Tp>::type> {};
// has_nothrow_default_constructor
template <class _Tp> struct has_nothrow_default_constructor : public has_trivial_default_constructor<_Tp> {};
// has_trivial_copy_constructor
template <class _Tp> struct __has_trivial_copy_constructor : public integral_constant<bool, is_scalar<_Tp>::value ||
is_reference<_Tp>::value> {};
template <class _Tp> struct has_trivial_copy_constructor
: public __has_trivial_copy_constructor<typename remove_all_extents<_Tp>::type> {};
// has_nothrow_copy_constructor
template <class _Tp> struct has_nothrow_copy_constructor : public has_trivial_copy_constructor<_Tp> {};
// has_nothrow_move_constructor
template <class _Tp> struct has_nothrow_move_constructor : public has_nothrow_copy_constructor<_Tp> {};
// has_copy_constructor
template <class _Tp> struct has_copy_constructor : public true_type {};
// has_copy_assign
template <class _Tp> struct has_copy_assign;
// has_trivial_copy_assign
#if defined(__clang__) || (__GNUC__ >= 4 && __GNUC_MINOR__ >= 3)
template <class _Tp, bool = is_void<_Tp>::value>
struct __has_trivial_copy_assign
: public integral_constant<bool, __has_trivial_assign(_Tp)> {};
template <class _Tp> struct __has_trivial_copy_assign<_Tp, true>
: public false_type {};
template <class _Tp> struct has_trivial_copy_assign
: __has_trivial_copy_assign<_Tp> {};
#else
template <class _Tp> struct has_trivial_copy_assign
: public integral_constant<bool, is_scalar<_Tp>::value && !is_const<_Tp>::value> {};
#endif // defined(__clang__) || (__GNUC__ >= 4 && __GNUC_MINOR__ >= 3)
// has_nothrow_copy_assign
template <class _Tp> struct has_nothrow_copy_assign: public has_trivial_copy_assign<_Tp> {};
// has_trivial_destructor
template <class _Tp> struct __libcpp_trivial_destructor : public integral_constant<bool, is_scalar<_Tp>::value ||
is_reference<_Tp>::value> {};
template <class _Tp> struct has_trivial_destructor
: public __libcpp_trivial_destructor<typename remove_all_extents<_Tp>::type> {};
// has_virtual_destructor
template <class _Tp> struct has_virtual_destructor : public false_type {};
// is_pod
template <class _Tp> struct is_pod : public integral_constant<bool, has_trivial_default_constructor<_Tp>::value &&
has_trivial_copy_constructor<_Tp>::value &&
has_trivial_copy_assign<_Tp>::value &&
has_trivial_destructor<_Tp>::value> {};
// alignment_of
template <class _Tp> struct __alignment_of {_Tp _;};
template <class _Tp> struct alignment_of
: public integral_constant<size_t, __alignof__(__alignment_of<typename remove_all_extents<_Tp>::type>)> {};
// aligned_storage
template <class _Hp, class _Tp>
struct __type_list
{
typedef _Hp _Head;
typedef _Tp _Tail;
};
struct __nat {};
template <class _Tp>
struct __align_type
{
static const size_t value = alignment_of<_Tp>::value;
typedef _Tp type;
};
struct __struct_double {long double _;};
struct __struct_double4 {double _[4];};
typedef
__type_list<__align_type<unsigned char>,
__type_list<__align_type<unsigned short>,
__type_list<__align_type<unsigned int>,
__type_list<__align_type<unsigned long>,
__type_list<__align_type<unsigned long long>,
__type_list<__align_type<double>,
__type_list<__align_type<long double>,
__type_list<__align_type<__struct_double>,
__type_list<__align_type<__struct_double4>,
__type_list<__align_type<int*>,
__nat
> > > > > > > > > > __all_types;
template <class _TL, size_t _Align> struct __find_pod;
template <class _Hp, size_t _Align>
struct __find_pod<__type_list<_Hp, __nat>, _Align>
{
typedef typename conditional<
_Align == _Hp::value,
typename _Hp::type,
void
>::type type;
};
template <class _Hp, class _Tp, size_t _Align>
struct __find_pod<__type_list<_Hp, _Tp>, _Align>
{
typedef typename conditional<
_Align == _Hp::value,
typename _Hp::type,
typename __find_pod<_Tp, _Align>::type
>::type type;
};
template <class _TL, size_t _Len> struct __find_max_align;
template <class _Hp, size_t _Len>
struct __find_max_align<__type_list<_Hp, __nat>, _Len> : public integral_constant<size_t, _Hp::value> {};
template <size_t _Len, size_t _A1, size_t _A2>
struct __select_align
{
private:
static const size_t __min = _A2 < _A1 ? _A2 : _A1;
static const size_t __max = _A1 < _A2 ? _A2 : _A1;
public:
static const size_t value = _Len < __max ? __min : __max;
};
template <class _Hp, class _Tp, size_t _Len>
struct __find_max_align<__type_list<_Hp, _Tp>, _Len>
: public integral_constant<size_t, __select_align<_Len, _Hp::value, __find_max_align<_Tp, _Len>::value>::value> {};
template <size_t _Len, const size_t _Align = __find_max_align<__all_types, _Len>::value>
struct aligned_storage
{
typedef typename __find_pod<__all_types, _Align>::type _Aligner;
static_assert(!is_void<_Aligner>::value, "");
union type
{
_Aligner __align;
unsigned char __data[_Len];
};
};
#define _CREATE_ALIGNED_STORAGE_SPECIALIZATION(n) \
template <size_t _Len>\
struct aligned_storage<_Len, n>\
{\
struct type\
{\
unsigned char _[_Len];\
} __attribute__((__aligned__(n)));\
}
_CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x1);
_CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x2);
_CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x4);
_CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x8);
_CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x10);
_CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x20);
_CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x40);
_CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x80);
_CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x100);
_CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x200);
_CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x400);
_CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x800);
_CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x1000);
_CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x2000);
_CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x4000);
#undef _CREATE_ALIGNED_STORAGE_SPECIALIZATION
// __promote
template <class _A1, class _A2 = void, class _A3 = void,
bool = (is_arithmetic<_A1>::value || is_void<_A1>::value) &&
(is_arithmetic<_A2>::value || is_void<_A2>::value) &&
(is_arithmetic<_A3>::value || is_void<_A3>::value)>
class __promote {};
template <class _A1, class _A2, class _A3>
class __promote<_A1, _A2, _A3, true>
{
private:
typedef typename __promote<_A1>::type __type1;
typedef typename __promote<_A2>::type __type2;
typedef typename __promote<_A3>::type __type3;
public:
typedef __typeof__(__type1() + __type2() + __type3()) type;
};
template <class _A1, class _A2>
class __promote<_A1, _A2, void, true>
{
private:
typedef typename __promote<_A1>::type __type1;
typedef typename __promote<_A2>::type __type2;
public:
typedef __typeof__(__type1() + __type2()) type;
};
template <class _A1>
class __promote<_A1, void, void, true>
{
public:
typedef typename conditional<is_arithmetic<_A1>::value,
typename conditional<is_integral<_A1>::value, double, _A1>::type,
void
>::type type;
};
#ifdef _LIBCPP_STORE_AS_OPTIMIZATION
// __transform
template <class _Tp, size_t = sizeof(_Tp), bool = is_scalar<_Tp>::value> struct __transform {typedef _Tp type;};
template <class _Tp> struct __transform<_Tp, 1, true> {typedef unsigned char type;};
template <class _Tp> struct __transform<_Tp, 2, true> {typedef unsigned short type;};
template <class _Tp> struct __transform<_Tp, 4, true> {typedef unsigned int type;};
template <class _Tp> struct __transform<_Tp, 8, true> {typedef unsigned long long type;};
#endif // _LIBCPP_STORE_AS_OPTIMIZATION
// make_signed / make_unsigned
typedef
__type_list<signed char,
__type_list<signed short,
__type_list<signed int,
__type_list<signed long,
__type_list<signed long long,
__nat
> > > > > __signed_types;
typedef
__type_list<unsigned char,
__type_list<unsigned short,
__type_list<unsigned int,
__type_list<unsigned long,
__type_list<unsigned long long,
__nat
> > > > > __unsigned_types;
template <class _TypeList, size_t _Size, bool = _Size <= sizeof(typename _TypeList::_Head)> struct __find_first;
template <class _Hp, class _Tp, size_t _Size>
struct __find_first<__type_list<_Hp, _Tp>, _Size, true>
{
typedef _Hp type;
};
template <class _Hp, class _Tp, size_t _Size>
struct __find_first<__type_list<_Hp, _Tp>, _Size, false>
{
typedef typename __find_first<_Tp, _Size>::type type;
};
template <class _Tp, class _Up, bool = is_const<typename remove_reference<_Tp>::type>::value,
bool = is_volatile<typename remove_reference<_Tp>::type>::value>
struct __apply_cv
{
typedef _Up type;
};
template <class _Tp, class _Up>
struct __apply_cv<_Tp, _Up, true, false>
{
typedef const _Up type;
};
template <class _Tp, class _Up>
struct __apply_cv<_Tp, _Up, false, true>
{
typedef volatile _Up type;
};
template <class _Tp, class _Up>
struct __apply_cv<_Tp, _Up, true, true>
{
typedef const volatile _Up type;
};
template <class _Tp, class _Up>
struct __apply_cv<_Tp&, _Up, false, false>
{
typedef _Up& type;
};
template <class _Tp, class _Up>
struct __apply_cv<_Tp&, _Up, true, false>
{
typedef const _Up& type;
};
template <class _Tp, class _Up>
struct __apply_cv<_Tp&, _Up, false, true>
{
typedef volatile _Up& type;
};
template <class _Tp, class _Up>
struct __apply_cv<_Tp&, _Up, true, true>
{
typedef const volatile _Up& type;
};
template <class _Tp, bool = is_integral<_Tp>::value || is_enum<_Tp>::value>
struct __make_signed {};
template <class _Tp>
struct __make_signed<_Tp, true>
{
typedef typename __find_first<__signed_types, sizeof(_Tp)>::type type;
};
template <> struct __make_signed<bool, true> {};
template <> struct __make_signed< signed short, true> {typedef short type;};
template <> struct __make_signed<unsigned short, true> {typedef short type;};
template <> struct __make_signed< signed int, true> {typedef int type;};
template <> struct __make_signed<unsigned int, true> {typedef int type;};
template <> struct __make_signed< signed long, true> {typedef long type;};
template <> struct __make_signed<unsigned long, true> {typedef long type;};
template <> struct __make_signed< signed long long, true> {typedef long long type;};
template <> struct __make_signed<unsigned long long, true> {typedef long long type;};
template <class _Tp>
struct make_signed
{
typedef typename __apply_cv<_Tp, typename __make_signed<typename remove_cv<_Tp>::type>::type>::type type;
};
template <class _Tp, bool = is_integral<_Tp>::value || is_enum<_Tp>::value>
struct __make_unsigned {};
template <class _Tp>
struct __make_unsigned<_Tp, true>
{
typedef typename __find_first<__unsigned_types, sizeof(_Tp)>::type type;
};
template <> struct __make_unsigned<bool, true> {};
template <> struct __make_unsigned< signed short, true> {typedef unsigned short type;};
template <> struct __make_unsigned<unsigned short, true> {typedef unsigned short type;};
template <> struct __make_unsigned< signed int, true> {typedef unsigned int type;};
template <> struct __make_unsigned<unsigned int, true> {typedef unsigned int type;};
template <> struct __make_unsigned< signed long, true> {typedef unsigned long type;};
template <> struct __make_unsigned<unsigned long, true> {typedef unsigned long type;};
template <> struct __make_unsigned< signed long long, true> {typedef unsigned long long type;};
template <> struct __make_unsigned<unsigned long long, true> {typedef unsigned long long type;};
template <class _Tp>
struct make_unsigned
{
typedef typename __apply_cv<_Tp, typename __make_unsigned<typename remove_cv<_Tp>::type>::type>::type type;
};
#ifdef _LIBCPP_HAS_NO_VARIADICS
template <class _Tp, class _Up = void, class V = void>
struct common_type
{
public:
typedef typename common_type<typename common_type<_Tp, _Up>::type, V>::type type;
};
template <class _Tp>
struct common_type<_Tp, void, void>
{
public:
typedef _Tp type;
};
template <class _Tp, class _Up>
struct common_type<_Tp, _Up, void>
{
private:
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
static _Tp&& __t();
static _Up&& __u();
#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES
static _Tp __t();
static _Up __u();
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
static bool __f();
public:
typedef decltype(__f() ? __t() : __u()) type;
};
#else // _LIBCPP_HAS_NO_VARIADICS
template <class ..._Tp> struct common_type;
template <class _Tp>
struct common_type<_Tp>
{
typedef _Tp type;
};
template <class _Tp, class _Up>
struct common_type<_Tp, _Up>
{
private:
static _Tp&& __t();
static _Up&& __u();
static bool __f();
public:
typedef decltype(__f() ? __t() : __u()) type;
};
template <class _Tp, class _Up, class ..._Vp>
struct common_type<_Tp, _Up, _Vp...>
{
typedef typename common_type<typename common_type<_Tp, _Up>::type, _Vp...>::type type;
};
#endif // _LIBCPP_HAS_NO_VARIADICS
// move
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
typename remove_reference<_Tp>::type&&
move(_Tp&& __t)
{
return static_cast<typename remove_reference<_Tp>::type&&>(__t);
}
template <class _Tp,
class = typename enable_if<
!is_lvalue_reference<_Tp>::value
>::type
>
inline _LIBCPP_INLINE_VISIBILITY
_Tp&&
forward(typename common_type<_Tp>::type& __t)
{
return static_cast<_Tp&&>(__t);
}
template <class _Tp,
class = typename enable_if<
!is_lvalue_reference<_Tp>::value
>::type
>
inline _LIBCPP_INLINE_VISIBILITY
_Tp&&
forward(typename common_type<_Tp>::type&& __t)
{
return static_cast<_Tp&&>(__t);
}
template <class _Tp,
class = typename enable_if<
is_lvalue_reference<_Tp>::value
>::type
>
inline _LIBCPP_INLINE_VISIBILITY
_Tp
forward(typename common_type<_Tp>::type __t)
{
return __t;
}
template <class _Tp,
class = typename enable_if<
is_lvalue_reference<_Tp>::value
>::type
>
_Tp
forward(typename remove_reference<_Tp>::type&& __t) = delete;
#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES
template <class _Tp>
class __rv
{
typedef typename remove_reference<_Tp>::type _Trr;
_Trr& t_;
public:
_Trr* operator->() {return &t_;}
explicit __rv(_Trr& __t) : t_(__t) {}
};
template <class _Tp>
inline
typename enable_if
<
!is_convertible<_Tp, __rv<_Tp> >::value,
_Tp&
>::type
move(_Tp& __t)
{
return __t;
}
template <class _Tp>
inline
typename enable_if
<
is_convertible<_Tp, __rv<_Tp> >::value,
_Tp
>::type
move(_Tp& __t)
{
return _Tp(__rv<_Tp>(__t));
}
template <class _Tp, class _Up>
inline
typename enable_if
<
!is_convertible<_Tp, __rv<_Tp> >::value,
typename add_lvalue_reference<_Tp>::type
>::type
forward(_Up& __t)
{
return __t;
}
template <class _Tp, class _Up>
inline
typename enable_if
<
!is_convertible<_Tp, __rv<_Tp> >::value,
typename add_lvalue_reference<_Tp>::type
>::type
forward(const _Up& __t)
{
return __t;
}
template <class _Tp, class _Up>
inline
typename enable_if
<
is_convertible<_Tp, __rv<_Tp> >::value,
_Tp
>::type
forward(_Up& __t)
{
return _Tp(__rv<_Tp>(__t));
}
template <class _Tp, class _Up>
inline
typename enable_if
<
is_convertible<_Tp, __rv<_Tp> >::value,
_Tp
>::type
forward(const _Up& __t)
{
return _Tp(__rv<_Tp>(__t));
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
template <class _Tp>
typename add_rvalue_reference<_Tp>::type
declval();
#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES
template <class _Tp>
typename add_lvalue_reference<_Tp>::type
declval();
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
template <class _Tp>
struct decay
{
private:
typedef typename remove_reference<_Tp>::type _Up;
public:
typedef typename conditional
<
is_array<_Up>::value,
typename remove_extent<_Up>::type*,
typename conditional
<
is_function<_Up>::value,
typename add_pointer<_Up>::type,
typename remove_cv<_Up>::type
>::type
>::type type;
};
// result_of
template <class> class result_of;
template <class _Fn, bool>
class __result_of
{
};
#ifndef _LIBCPP_HAS_NO_VARIADICS
template <class _Fn, class ..._ArgTypes>
class __result_of<_Fn(_ArgTypes...), true>
{
public:
typedef decltype(declval<_Fn>()(declval<_ArgTypes>()...)) type;
};
#if 0
template <class _MP, class _Tp, class ..._Args>
struct __result_of_mp;
// member function pointer
template <class _R, class _Class, class _Tp, class ..._Params, class ..._Args>
struct __result_of_mp<_R (_Class::*)(_Params...), _Tp, _Args...>
{
typedef _R type;
};
template <class _R, class _Class, class _Tp, class ..._Params, class ..._Args>
struct __result_of_mp<_R (_Class::*)(_Params...) const, _Tp, _Args...>
{
typedef _R type;
};
template <class _R, class _Class, class _Tp, class ..._Params, class ..._Args>
struct __result_of_mp<_R (_Class::*)(_Params...) volatile, _Tp, _Args...>
{
typedef _R type;
};
template <class _R, class _Class, class _Tp, class ..._Params, class ..._Args>
struct __result_of_mp<_R (_Class::*)(_Params...) const volatile, _Tp, _Args...>
{
typedef _R type;
};
// member data pointer
template <class _MP, class _Tp, bool>
struct __result_of_mdp;
template <class _R, class _Class, class _Tp>
struct __result_of_mdp<_R _Class::*, _Tp, false>
{
typedef typename __apply_cv<decltype(*_STD::declval<_Tp>()), _R>::type type;
};
template <class _R, class _Class, class _Tp>
struct __result_of_mdp<_R _Class::*, _Tp, true>
{
typedef typename __apply_cv<_Tp, _R>::type&& type;
};
template <class _R, class _Class, class _Tp>
struct __result_of_mp<_R _Class::*, _Tp>
: public __result_of_mdp<_R _Class::*, _Tp,
is_base_of<_Class, typename remove_reference<_Tp>::type>::value>
{
};
template <class _Fn, class _Tp, class ..._ArgTypes>
class __result_of<_Fn(_Tp, _ArgTypes...), false> // _Fn must be member pointer
: public __result_of_mp<_Fn, _Tp, _ArgTypes...>
{
};
#endif // 0
// result_of
template <class _Fn, class ..._ArgTypes>
class result_of<_Fn(_ArgTypes...)>
: public __result_of<_Fn(_ArgTypes...),
is_class<typename remove_reference<_Fn>::type>::value ||
is_function<typename remove_pointer<
typename remove_reference<_Fn>::type
>::type
>::value
>
{
};
#else // _LIBCPP_HAS_NO_VARIADICS
template <class _Fn>
class __result_of<_Fn(), true>
{
public:
typedef decltype(declval<_Fn>()()) type;
};
template <class _Fn, class _A0>
class __result_of<_Fn(_A0), true>
{
public:
typedef decltype(declval<_Fn>()(declval<_A0>())) type;
};
template <class _Fn, class _A0, class _A1>
class __result_of<_Fn(_A0, _A1), true>
{
public:
typedef decltype(declval<_Fn>()(declval<_A0>(), declval<_A1>())) type;
};
template <class _Fn, class _A0, class _A1, class _A2>
class __result_of<_Fn(_A0, _A1, _A2), true>
{
public:
typedef decltype(declval<_Fn>()(declval<_A0>(), declval<_A1>(), declval<_A2>())) type;
};
template <class _Fn>
class result_of<_Fn()>
: public __result_of<_Fn(),
is_class<typename remove_reference<_Fn>::type>::value ||
is_function<typename remove_pointer<
typename remove_reference<_Fn>::type
>::type
>::value
>
{
};
template <class _Fn, class _A0>
class result_of<_Fn(_A0)>
: public __result_of<_Fn(_A0),
is_class<typename remove_reference<_Fn>::type>::value ||
is_function<typename remove_pointer<
typename remove_reference<_Fn>::type
>::type
>::value
>
{
};
template <class _Fn, class _A0, class _A1>
class result_of<_Fn(_A0, _A1)>
: public __result_of<_Fn(_A0, _A1),
is_class<typename remove_reference<_Fn>::type>::value ||
is_function<typename remove_pointer<
typename remove_reference<_Fn>::type
>::type
>::value
>
{
};
template <class _Fn, class _A0, class _A1, class _A2>
class result_of<_Fn(_A0, _A1, _A2)>
: public __result_of<_Fn(_A0, _A1, _A2),
is_class<typename remove_reference<_Fn>::type>::value ||
is_function<typename remove_pointer<
typename remove_reference<_Fn>::type
>::type
>::value
>
{
};
#endif // _LIBCPP_HAS_NO_VARIADICS
#ifndef _LIBCPP_HAS_NO_ADVANCED_SFINAE
// template <class T, class... Args> struct is_constructible;
// main is_constructible test
template <class _Tp, class ..._Args>
decltype(_STD::move(_Tp(_STD::declval<_Args>()...)), true_type())
__is_constructible_test(_Tp&&, _Args&& ...);
struct __any
{
__any(...);
};
template <class ..._Args>
false_type
__is_constructible_test(__any, _Args&& ...);
template <bool, class _Tp, class... _Args>
struct __is_constructible // false, _Tp is not a scalar
: public common_type
<
decltype(__is_constructible_test(declval<_Tp>(), declval<_Args>()...))
>::type
{};
// function types are not constructible
template <class _R, class... _A1, class... _A2>
struct __is_constructible<false, _R(_A1...), _A2...>
: public false_type
{};
// handle scalars and reference types
// Scalars are default constructible, references are not
template <class _Tp>
struct __is_constructible<true, _Tp>
: public is_scalar<_Tp>
{};
// Scalars and references are constructible from one arg if that arg is
// implicitly convertible to the scalar or reference.
template <class _Tp>
struct __is_constructible_ref
{
true_type static __(_Tp);
false_type static __(...);
};
template <class _Tp, class _A0>
struct __is_constructible<true, _Tp, _A0>
: public common_type
<
decltype(__is_constructible_ref<_Tp>::__(declval<_A0>()))
>::type
{};
// Scalars and references are not constructible from multiple args.
template <class _Tp, class _A0, class ..._Args>
struct __is_constructible<true, _Tp, _A0, _Args...>
: public false_type
{};
// Treat scalars and reference types separately
template <bool, class _Tp, class... _Args>
struct __is_constructible_void_check
: public __is_constructible<is_scalar<_Tp>::value || is_reference<_Tp>::value,
_Tp, _Args...>
{};
// If any of T or Args is void, is_constructible should be false
template <class _Tp, class... _Args>
struct __is_constructible_void_check<true, _Tp, _Args...>
: public false_type
{};
template <class ..._Args> struct __contains_void;
template <> struct __contains_void<> : false_type {};
template <class _A0, class ..._Args>
struct __contains_void<_A0, _Args...>
{
static const bool value = is_void<_A0>::value ||
__contains_void<_Args...>::value;
};
// is_constructible entry point
template <class _Tp, class... _Args>
struct is_constructible
: public __is_constructible_void_check<__contains_void<_Tp, _Args...>::value
|| is_abstract<_Tp>::value,
_Tp, _Args...>
{};
// Array types are default constructible if their element type
// is default constructible
template <class _A, size_t _N>
struct __is_constructible<false, _A[_N]>
: public is_constructible<typename remove_all_extents<_A>::type>
{};
// Otherwise array types are not constructible by this syntax
template <class _A, size_t _N, class ..._Args>
struct __is_constructible<false, _A[_N], _Args...>
: public false_type
{};
// Incomplete array types are not constructible
template <class _A, class ..._Args>
struct __is_constructible<false, _A[], _Args...>
: public false_type
{};
#endif // _LIBCPP_HAS_NO_ADVANCED_SFINAE
template <class _Tp> struct __is_zero_default_constructible
: public integral_constant<bool, is_scalar<_Tp>::value || is_empty<_Tp>::value> {};
template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
void
swap(_Tp& __x, _Tp& __y)
{
_Tp __t(_STD::move(__x));
__x = _STD::move(__y);
__y = _STD::move(__t);
}
_LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_TYPE_TRAITS
Reference in New Issue View Git Blame Copy Permalink