01afa5c6e4
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@189772 91177308-0d34-0410-b5e6-96231b3b80d8
3285 lines
103 KiB
C++
3285 lines
103 KiB
C++
// -*- C++ -*-
|
|
//===------------------------ type_traits ---------------------------------===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is dual licensed under the MIT and the University of Illinois Open
|
|
// Source Licenses. 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> struct is_default_constructible;
|
|
template <class T> struct is_copy_constructible;
|
|
template <class T> struct is_move_constructible;
|
|
template <class T, class U> struct is_assignable;
|
|
template <class T> struct is_copy_assignable;
|
|
template <class T> struct is_move_assignable;
|
|
template <class T> struct is_destructible;
|
|
|
|
template <class T, class... Args> struct is_trivially_constructible;
|
|
template <class T> struct is_trivially_default_constructible;
|
|
template <class T> struct is_trivially_copy_constructible;
|
|
template <class T> struct is_trivially_move_constructible;
|
|
template <class T, class U> struct is_trivially_assignable;
|
|
template <class T> struct is_trivially_copy_assignable;
|
|
template <class T> struct is_trivially_move_assignable;
|
|
template <class T> struct is_trivially_destructible;
|
|
|
|
template <class T, class... Args> struct is_nothrow_constructible;
|
|
template <class T> struct is_nothrow_default_constructible;
|
|
template <class T> struct is_nothrow_copy_constructible;
|
|
template <class T> struct is_nothrow_move_constructible;
|
|
template <class T, class U> struct is_nothrow_assignable;
|
|
template <class T> struct is_nothrow_copy_assignable;
|
|
template <class T> struct is_nothrow_move_assignable;
|
|
template <class T> struct is_nothrow_destructible;
|
|
|
|
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;
|
|
|
|
// 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 <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...)>;
|
|
|
|
// const-volatile modifications:
|
|
template <class T>
|
|
using remove_const_t = typename remove_const<T>::type; // C++14
|
|
template <class T>
|
|
using remove_volatile_t = typename remove_volatile<T>::type; // C++14
|
|
template <class T>
|
|
using remove_cv_t = typename remove_cv<T>::type; // C++14
|
|
template <class T>
|
|
using add_const_t = typename add_const<T>::type; // C++14
|
|
template <class T>
|
|
using add_volatile_t = typename add_volatile<T>::type; // C++14
|
|
template <class T>
|
|
using add_cv_t = typename add_cv<T>::type; // C++14
|
|
|
|
// reference modifications:
|
|
template <class T>
|
|
using remove_reference_t = typename remove_reference<T>::type; // C++14
|
|
template <class T>
|
|
using add_lvalue_reference_t = typename add_lvalue_reference<T>::type; // C++14
|
|
template <class T>
|
|
using add_rvalue_reference_t = typename add_rvalue_reference<T>::type; // C++14
|
|
|
|
// sign modifications:
|
|
template <class T>
|
|
using make_signed_t = typename make_signed<T>::type; // C++14
|
|
template <class T>
|
|
using make_unsigned_t = typename make_unsigned<T>::type; // C++14
|
|
|
|
// array modifications:
|
|
template <class T>
|
|
using remove_extent_t = typename remove_extent<T>::type; // C++14
|
|
template <class T>
|
|
using remove_all_extents_t = typename remove_all_extents<T>::type; // C++14
|
|
|
|
// pointer modifications:
|
|
template <class T>
|
|
using remove_pointer_t = typename remove_pointer<T>::type; // C++14
|
|
template <class T>
|
|
using add_pointer_t = typename add_pointer<T>::type; // C++14
|
|
|
|
// other transformations:
|
|
template <size_t Len, std::size_t Align=default-alignment>
|
|
using aligned_storage_t = typename aligned_storage<Len,Align>::type; // C++14
|
|
template <std::size_t Len, class... Types>
|
|
using aligned_union_t = typename aligned_union<Len,Types...>::type; // C++14
|
|
template <class T>
|
|
using decay_t = typename decay<T>::type; // C++14
|
|
template <bool b, class T=void>
|
|
using enable_if_t = typename enable_if<b,T>::type; // C++14
|
|
template <bool b, class T, class F>
|
|
using conditional_t = typename conditional<b,T,F>::type; // C++14
|
|
template <class... T>
|
|
using common_type_t = typename common_type<T...>::type; // C++14
|
|
template <class T>
|
|
using underlying_type_t = typename underlying_type<T>::type; // C++14
|
|
template <class F, class... ArgTypes>
|
|
using result_of_t = typename result_of<F(ArgTypes...)>::type; // C++14
|
|
|
|
} // std
|
|
|
|
*/
|
|
#include <__config>
|
|
#include <cstddef>
|
|
|
|
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
|
#pragma GCC system_header
|
|
#endif
|
|
|
|
_LIBCPP_BEGIN_NAMESPACE_STD
|
|
|
|
template <bool _Bp, class _If, class _Then>
|
|
struct _LIBCPP_TYPE_VIS_ONLY conditional {typedef _If type;};
|
|
template <class _If, class _Then>
|
|
struct _LIBCPP_TYPE_VIS_ONLY conditional<false, _If, _Then> {typedef _Then type;};
|
|
|
|
#if _LIBCPP_STD_VER > 11
|
|
template <bool _Bp, class _If, class _Then> using conditional_t = typename conditional<_Bp, _If, _Then>::type;
|
|
#endif
|
|
|
|
template <bool, class _Tp = void> struct _LIBCPP_TYPE_VIS_ONLY enable_if {};
|
|
template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY enable_if<true, _Tp> {typedef _Tp type;};
|
|
|
|
#if _LIBCPP_STD_VER > 11
|
|
template <bool _Bp, class _Tp = void> using enable_if_t = typename enable_if<_Bp, _Tp>::type;
|
|
#endif
|
|
|
|
|
|
struct __two {char __lx[2];};
|
|
|
|
// helper class:
|
|
|
|
template <class _Tp, _Tp __v>
|
|
struct _LIBCPP_TYPE_VIS_ONLY integral_constant
|
|
{
|
|
static _LIBCPP_CONSTEXPR const _Tp value = __v;
|
|
typedef _Tp value_type;
|
|
typedef integral_constant type;
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
_LIBCPP_CONSTEXPR operator value_type() const {return value;}
|
|
#if _LIBCPP_STD_VER > 11
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
constexpr value_type operator ()() const {return value;}
|
|
#endif
|
|
};
|
|
|
|
template <class _Tp, _Tp __v>
|
|
_LIBCPP_CONSTEXPR 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 _LIBCPP_TYPE_VIS_ONLY is_const : public false_type {};
|
|
template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_const<_Tp const> : public true_type {};
|
|
|
|
// is_volatile
|
|
|
|
template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_volatile : public false_type {};
|
|
template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_volatile<_Tp volatile> : public true_type {};
|
|
|
|
// remove_const
|
|
|
|
template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY remove_const {typedef _Tp type;};
|
|
template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY remove_const<const _Tp> {typedef _Tp type;};
|
|
#if _LIBCPP_STD_VER > 11
|
|
template <class _Tp> using remove_const_t = typename remove_const<_Tp>::type;
|
|
#endif
|
|
|
|
// remove_volatile
|
|
|
|
template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY remove_volatile {typedef _Tp type;};
|
|
template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY remove_volatile<volatile _Tp> {typedef _Tp type;};
|
|
#if _LIBCPP_STD_VER > 11
|
|
template <class _Tp> using remove_volatile_t = typename remove_volatile<_Tp>::type;
|
|
#endif
|
|
|
|
// remove_cv
|
|
|
|
template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY remove_cv
|
|
{typedef typename remove_volatile<typename remove_const<_Tp>::type>::type type;};
|
|
#if _LIBCPP_STD_VER > 11
|
|
template <class _Tp> using remove_cv_t = typename remove_cv<_Tp>::type;
|
|
#endif
|
|
|
|
// is_void
|
|
|
|
template <class _Tp> struct __is_void : public false_type {};
|
|
template <> struct __is_void<void> : public true_type {};
|
|
|
|
template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_void
|
|
: public __is_void<typename remove_cv<_Tp>::type> {};
|
|
|
|
// __is_nullptr_t
|
|
|
|
template <class _Tp> struct ____is_nullptr_t : public false_type {};
|
|
template <> struct ____is_nullptr_t<nullptr_t> : public true_type {};
|
|
|
|
template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY __is_nullptr_t
|
|
: public ____is_nullptr_t<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 _LIBCPP_TYPE_VIS_ONLY 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 _LIBCPP_TYPE_VIS_ONLY is_floating_point
|
|
: public __is_floating_point<typename remove_cv<_Tp>::type> {};
|
|
|
|
// is_array
|
|
|
|
template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_array
|
|
: public false_type {};
|
|
template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_array<_Tp[]>
|
|
: public true_type {};
|
|
template <class _Tp, size_t _Np> struct _LIBCPP_TYPE_VIS_ONLY 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 _LIBCPP_TYPE_VIS_ONLY is_pointer
|
|
: public __is_pointer<typename remove_cv<_Tp>::type> {};
|
|
|
|
// is_reference
|
|
|
|
template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_lvalue_reference : public false_type {};
|
|
template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_lvalue_reference<_Tp&> : public true_type {};
|
|
|
|
template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_rvalue_reference : public false_type {};
|
|
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
|
template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_rvalue_reference<_Tp&&> : public true_type {};
|
|
#endif
|
|
|
|
template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_reference : public false_type {};
|
|
template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_reference<_Tp&> : public true_type {};
|
|
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
|
template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_reference<_Tp&&> : public true_type {};
|
|
#endif
|
|
|
|
#if defined(__clang__) || (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)
|
|
#define _LIBCPP_HAS_TYPE_TRAITS
|
|
#endif
|
|
|
|
// is_union
|
|
|
|
#if __has_feature(is_union) || (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)
|
|
|
|
template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_union
|
|
: public integral_constant<bool, __is_union(_Tp)> {};
|
|
|
|
#else
|
|
|
|
template <class _Tp> struct __libcpp_union : public false_type {};
|
|
template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_union
|
|
: public __libcpp_union<typename remove_cv<_Tp>::type> {};
|
|
|
|
#endif
|
|
|
|
// is_class
|
|
|
|
#if __has_feature(is_class) || (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)
|
|
|
|
template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_class
|
|
: public integral_constant<bool, __is_class(_Tp)> {};
|
|
|
|
#else
|
|
|
|
namespace __is_class_imp
|
|
{
|
|
template <class _Tp> char __test(int _Tp::*);
|
|
template <class _Tp> __two __test(...);
|
|
}
|
|
|
|
template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_class
|
|
: public integral_constant<bool, sizeof(__is_class_imp::__test<_Tp>(0)) == 1 && !is_union<_Tp>::value> {};
|
|
|
|
#endif
|
|
|
|
// is_same
|
|
|
|
template <class _Tp, class _Up> struct _LIBCPP_TYPE_VIS_ONLY is_same : public false_type {};
|
|
template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_same<_Tp, _Tp> : public true_type {};
|
|
|
|
// 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 ||
|
|
is_same<_Tp, nullptr_t>::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 _LIBCPP_TYPE_VIS_ONLY 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 _LIBCPP_TYPE_VIS_ONLY 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 _LIBCPP_TYPE_VIS_ONLY is_member_pointer
|
|
: public __is_member_pointer<typename remove_cv<_Tp>::type> {};
|
|
|
|
// is_member_object_pointer
|
|
|
|
template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_member_object_pointer
|
|
: public integral_constant<bool, is_member_pointer<_Tp>::value &&
|
|
!is_member_function_pointer<_Tp>::value> {};
|
|
|
|
// is_enum
|
|
|
|
#if __has_feature(is_enum) || (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)
|
|
|
|
template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_enum
|
|
: public integral_constant<bool, __is_enum(_Tp)> {};
|
|
|
|
#else
|
|
|
|
template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY 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 > {};
|
|
|
|
#endif
|
|
|
|
// is_arithmetic
|
|
|
|
template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_arithmetic
|
|
: public integral_constant<bool, is_integral<_Tp>::value ||
|
|
is_floating_point<_Tp>::value> {};
|
|
|
|
// is_fundamental
|
|
|
|
template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_fundamental
|
|
: public integral_constant<bool, is_void<_Tp>::value ||
|
|
__is_nullptr_t<_Tp>::value ||
|
|
is_arithmetic<_Tp>::value> {};
|
|
|
|
// is_scalar
|
|
|
|
template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_scalar
|
|
: public integral_constant<bool, is_arithmetic<_Tp>::value ||
|
|
is_member_pointer<_Tp>::value ||
|
|
is_pointer<_Tp>::value ||
|
|
__is_nullptr_t<_Tp>::value ||
|
|
is_enum<_Tp>::value > {};
|
|
|
|
template <> struct _LIBCPP_TYPE_VIS_ONLY is_scalar<nullptr_t> : public true_type {};
|
|
|
|
// is_object
|
|
|
|
template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY 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 _LIBCPP_TYPE_VIS_ONLY 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 _LIBCPP_TYPE_VIS_ONLY add_const
|
|
{typedef typename __add_const<_Tp>::type type;};
|
|
|
|
#if _LIBCPP_STD_VER > 11
|
|
template <class _Tp> using add_const_t = typename add_const<_Tp>::type;
|
|
#endif
|
|
|
|
// 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 _LIBCPP_TYPE_VIS_ONLY add_volatile
|
|
{typedef typename __add_volatile<_Tp>::type type;};
|
|
|
|
#if _LIBCPP_STD_VER > 11
|
|
template <class _Tp> using add_volatile_t = typename add_volatile<_Tp>::type;
|
|
#endif
|
|
|
|
// add_cv
|
|
|
|
template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY add_cv
|
|
{typedef typename add_const<typename add_volatile<_Tp>::type>::type type;};
|
|
|
|
#if _LIBCPP_STD_VER > 11
|
|
template <class _Tp> using add_cv_t = typename add_cv<_Tp>::type;
|
|
#endif
|
|
|
|
// remove_reference
|
|
|
|
template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY remove_reference {typedef _Tp type;};
|
|
template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY remove_reference<_Tp&> {typedef _Tp type;};
|
|
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
|
template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY remove_reference<_Tp&&> {typedef _Tp type;};
|
|
#endif
|
|
|
|
#if _LIBCPP_STD_VER > 11
|
|
template <class _Tp> using remove_reference_t = typename remove_reference<_Tp>::type;
|
|
#endif
|
|
|
|
// add_lvalue_reference
|
|
|
|
template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY add_lvalue_reference {typedef _Tp& type;};
|
|
template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY add_lvalue_reference<_Tp&> {typedef _Tp& type;}; // for older compiler
|
|
template <> struct _LIBCPP_TYPE_VIS_ONLY add_lvalue_reference<void> {typedef void type;};
|
|
template <> struct _LIBCPP_TYPE_VIS_ONLY add_lvalue_reference<const void> {typedef const void type;};
|
|
template <> struct _LIBCPP_TYPE_VIS_ONLY add_lvalue_reference<volatile void> {typedef volatile void type;};
|
|
template <> struct _LIBCPP_TYPE_VIS_ONLY add_lvalue_reference<const volatile void> {typedef const volatile void type;};
|
|
|
|
#if _LIBCPP_STD_VER > 11
|
|
template <class _Tp> using add_lvalue_reference_t = typename add_lvalue_reference<_Tp>::type;
|
|
#endif
|
|
|
|
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
|
|
|
template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY add_rvalue_reference {typedef _Tp&& type;};
|
|
template <> struct _LIBCPP_TYPE_VIS_ONLY add_rvalue_reference<void> {typedef void type;};
|
|
template <> struct _LIBCPP_TYPE_VIS_ONLY add_rvalue_reference<const void> {typedef const void type;};
|
|
template <> struct _LIBCPP_TYPE_VIS_ONLY add_rvalue_reference<volatile void> {typedef volatile void type;};
|
|
template <> struct _LIBCPP_TYPE_VIS_ONLY add_rvalue_reference<const volatile void> {typedef const volatile void type;};
|
|
|
|
#if _LIBCPP_STD_VER > 11
|
|
template <class _Tp> using add_rvalue_reference_t = typename add_rvalue_reference<_Tp>::type;
|
|
#endif
|
|
|
|
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
|
|
|
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
|
|
|
template <class _Tp>
|
|
typename add_rvalue_reference<_Tp>::type
|
|
declval() _NOEXCEPT;
|
|
|
|
#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
|
|
|
template <class _Tp>
|
|
typename add_lvalue_reference<_Tp>::type
|
|
declval();
|
|
|
|
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
|
|
|
struct __any
|
|
{
|
|
__any(...);
|
|
};
|
|
|
|
// remove_pointer
|
|
|
|
template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY remove_pointer {typedef _Tp type;};
|
|
template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY remove_pointer<_Tp*> {typedef _Tp type;};
|
|
template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY remove_pointer<_Tp* const> {typedef _Tp type;};
|
|
template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY remove_pointer<_Tp* volatile> {typedef _Tp type;};
|
|
template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY remove_pointer<_Tp* const volatile> {typedef _Tp type;};
|
|
|
|
#if _LIBCPP_STD_VER > 11
|
|
template <class _Tp> using remove_pointer_t = typename remove_pointer<_Tp>::type;
|
|
#endif
|
|
|
|
// add_pointer
|
|
|
|
template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY add_pointer
|
|
{typedef typename remove_reference<_Tp>::type* type;};
|
|
|
|
#if _LIBCPP_STD_VER > 11
|
|
template <class _Tp> using add_pointer_t = typename add_pointer<_Tp>::type;
|
|
#endif
|
|
|
|
// 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 _LIBCPP_TYPE_VIS_ONLY 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 _LIBCPP_TYPE_VIS_ONLY is_unsigned : public __is_unsigned<_Tp> {};
|
|
|
|
// rank
|
|
|
|
template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY rank
|
|
: public integral_constant<size_t, 0> {};
|
|
template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY rank<_Tp[]>
|
|
: public integral_constant<size_t, rank<_Tp>::value + 1> {};
|
|
template <class _Tp, size_t _Np> struct _LIBCPP_TYPE_VIS_ONLY rank<_Tp[_Np]>
|
|
: public integral_constant<size_t, rank<_Tp>::value + 1> {};
|
|
|
|
// extent
|
|
|
|
template <class _Tp, unsigned _Ip = 0> struct _LIBCPP_TYPE_VIS_ONLY extent
|
|
: public integral_constant<size_t, 0> {};
|
|
template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY extent<_Tp[], 0>
|
|
: public integral_constant<size_t, 0> {};
|
|
template <class _Tp, unsigned _Ip> struct _LIBCPP_TYPE_VIS_ONLY extent<_Tp[], _Ip>
|
|
: public integral_constant<size_t, extent<_Tp, _Ip-1>::value> {};
|
|
template <class _Tp, size_t _Np> struct _LIBCPP_TYPE_VIS_ONLY extent<_Tp[_Np], 0>
|
|
: public integral_constant<size_t, _Np> {};
|
|
template <class _Tp, size_t _Np, unsigned _Ip> struct _LIBCPP_TYPE_VIS_ONLY extent<_Tp[_Np], _Ip>
|
|
: public integral_constant<size_t, extent<_Tp, _Ip-1>::value> {};
|
|
|
|
// remove_extent
|
|
|
|
template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY remove_extent
|
|
{typedef _Tp type;};
|
|
template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY remove_extent<_Tp[]>
|
|
{typedef _Tp type;};
|
|
template <class _Tp, size_t _Np> struct _LIBCPP_TYPE_VIS_ONLY remove_extent<_Tp[_Np]>
|
|
{typedef _Tp type;};
|
|
|
|
#if _LIBCPP_STD_VER > 11
|
|
template <class _Tp> using remove_extent_t = typename remove_extent<_Tp>::type;
|
|
#endif
|
|
|
|
// remove_all_extents
|
|
|
|
template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY remove_all_extents
|
|
{typedef _Tp type;};
|
|
template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY remove_all_extents<_Tp[]>
|
|
{typedef typename remove_all_extents<_Tp>::type type;};
|
|
template <class _Tp, size_t _Np> struct _LIBCPP_TYPE_VIS_ONLY remove_all_extents<_Tp[_Np]>
|
|
{typedef typename remove_all_extents<_Tp>::type type;};
|
|
|
|
#if _LIBCPP_STD_VER > 11
|
|
template <class _Tp> using remove_all_extents_t = typename remove_all_extents<_Tp>::type;
|
|
#endif
|
|
|
|
// 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 _LIBCPP_TYPE_VIS_ONLY is_abstract : public __libcpp_abstract<_Tp> {};
|
|
|
|
// is_base_of
|
|
|
|
#ifdef _LIBCPP_HAS_IS_BASE_OF
|
|
|
|
template <class _Bp, class _Dp>
|
|
struct _LIBCPP_TYPE_VIS_ONLY is_base_of
|
|
: public integral_constant<bool, __is_base_of(_Bp, _Dp)> {};
|
|
|
|
#else // __has_feature(is_base_of)
|
|
|
|
namespace __is_base_of_imp
|
|
{
|
|
template <class _Tp>
|
|
struct _Dst
|
|
{
|
|
_Dst(const volatile _Tp &);
|
|
};
|
|
template <class _Tp>
|
|
struct _Src
|
|
{
|
|
operator const volatile _Tp &();
|
|
template <class _Up> operator const _Dst<_Up> &();
|
|
};
|
|
template <size_t> struct __one { typedef char type; };
|
|
template <class _Bp, class _Dp> typename __one<sizeof(_Dst<_Bp>(declval<_Src<_Dp> >()))>::type __test(int);
|
|
template <class _Bp, class _Dp> __two __test(...);
|
|
}
|
|
|
|
template <class _Bp, class _Dp>
|
|
struct _LIBCPP_TYPE_VIS_ONLY is_base_of
|
|
: public integral_constant<bool, is_class<_Bp>::value &&
|
|
sizeof(__is_base_of_imp::__test<_Bp, _Dp>(0)) == 2> {};
|
|
|
|
#endif // __has_feature(is_base_of)
|
|
|
|
// is_convertible
|
|
|
|
#if __has_feature(is_convertible_to)
|
|
|
|
template <class _T1, class _T2> struct _LIBCPP_TYPE_VIS_ONLY is_convertible
|
|
: public integral_constant<bool, __is_convertible_to(_T1, _T2) &&
|
|
!is_abstract<_T2>::value> {};
|
|
|
|
#else // __has_feature(is_convertible_to)
|
|
|
|
namespace __is_convertible_imp
|
|
{
|
|
template <class _Tp> char __test(_Tp);
|
|
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,
|
|
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
|
sizeof(__is_convertible_imp::__test<_T2>(__is_convertible_imp::__source<_T1>())) == 1
|
|
#else
|
|
sizeof(__is_convertible_imp::__test<_T2>(__is_convertible_imp::__source<_T1>())) == 1
|
|
&& !(!is_function<_T1>::value && !is_reference<_T1>::value && is_reference<_T2>::value
|
|
&& (!is_const<typename remove_reference<_T2>::type>::value
|
|
|| is_volatile<typename remove_reference<_T2>::type>::value)
|
|
&& (is_same<typename remove_cv<_T1>::type,
|
|
typename remove_cv<typename remove_reference<_T2>::type>::type>::value
|
|
|| is_base_of<typename remove_reference<_T2>::type, _T1>::value))
|
|
#endif
|
|
>
|
|
{};
|
|
|
|
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*, 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 _LIBCPP_TYPE_VIS_ONLY 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;
|
|
};
|
|
|
|
#endif // __has_feature(is_convertible_to)
|
|
|
|
// is_empty
|
|
|
|
#if __has_feature(is_empty)
|
|
|
|
template <class _Tp>
|
|
struct _LIBCPP_TYPE_VIS_ONLY is_empty
|
|
: public integral_constant<bool, __is_empty(_Tp)> {};
|
|
|
|
#else // __has_feature(is_empty)
|
|
|
|
template <class _Tp>
|
|
struct __is_empty1
|
|
: public _Tp
|
|
{
|
|
double __lx;
|
|
};
|
|
|
|
struct __is_empty2
|
|
{
|
|
double __lx;
|
|
};
|
|
|
|
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 _LIBCPP_TYPE_VIS_ONLY is_empty : public __libcpp_empty<_Tp> {};
|
|
|
|
#endif // __has_feature(is_empty)
|
|
|
|
// is_polymorphic
|
|
|
|
#if __has_feature(is_polymorphic)
|
|
|
|
template <class _Tp>
|
|
struct _LIBCPP_TYPE_VIS_ONLY is_polymorphic
|
|
: public integral_constant<bool, __is_polymorphic(_Tp)> {};
|
|
|
|
#else
|
|
|
|
template<typename _Tp> char &__is_polymorphic_impl(
|
|
typename enable_if<sizeof((_Tp*)dynamic_cast<const volatile void*>(declval<_Tp*>())) != 0,
|
|
int>::type);
|
|
template<typename _Tp> __two &__is_polymorphic_impl(...);
|
|
|
|
template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_polymorphic
|
|
: public integral_constant<bool, sizeof(__is_polymorphic_impl<_Tp>(0)) == 1> {};
|
|
|
|
#endif // __has_feature(is_polymorphic)
|
|
|
|
// has_virtual_destructor
|
|
|
|
#if __has_feature(has_virtual_destructor) || (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)
|
|
|
|
template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY has_virtual_destructor
|
|
: public integral_constant<bool, __has_virtual_destructor(_Tp)> {};
|
|
|
|
#else // _LIBCPP_HAS_TYPE_TRAITS
|
|
|
|
template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY has_virtual_destructor
|
|
: public false_type {};
|
|
|
|
#endif // _LIBCPP_HAS_TYPE_TRAITS
|
|
|
|
// alignment_of
|
|
|
|
template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY alignment_of
|
|
: public integral_constant<size_t, __alignof__(_Tp)> {};
|
|
|
|
// aligned_storage
|
|
|
|
template <class _Hp, class _Tp>
|
|
struct __type_list
|
|
{
|
|
typedef _Hp _Head;
|
|
typedef _Tp _Tail;
|
|
};
|
|
|
|
struct __nat
|
|
{
|
|
#ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS
|
|
__nat() = delete;
|
|
__nat(const __nat&) = delete;
|
|
__nat& operator=(const __nat&) = delete;
|
|
~__nat() = delete;
|
|
#endif
|
|
};
|
|
|
|
template <class _Tp>
|
|
struct __align_type
|
|
{
|
|
static const size_t value = alignment_of<_Tp>::value;
|
|
typedef _Tp type;
|
|
};
|
|
|
|
struct __struct_double {long double __lx;};
|
|
struct __struct_double4 {double __lx[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, size_t _Align = __find_max_align<__all_types, _Len>::value>
|
|
struct _LIBCPP_TYPE_VIS_ONLY 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];
|
|
};
|
|
};
|
|
|
|
#if _LIBCPP_STD_VER > 11
|
|
template <size_t _Len, size_t _Align = __find_max_align<__all_types, _Len>::value>
|
|
using aligned_storage_t = typename aligned_storage<_Len, _Align>::type;
|
|
#endif
|
|
|
|
#define _CREATE_ALIGNED_STORAGE_SPECIALIZATION(n) \
|
|
template <size_t _Len>\
|
|
struct _LIBCPP_TYPE_VIS_ONLY aligned_storage<_Len, n>\
|
|
{\
|
|
struct _ALIGNAS(n) type\
|
|
{\
|
|
unsigned char __lx[_Len];\
|
|
};\
|
|
}
|
|
|
|
_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);
|
|
// MSDN says that MSVC does not support alignment beyond 8192 (=0x2000)
|
|
#if !defined(_LIBCPP_MSVC)
|
|
_CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x4000);
|
|
#endif // !_LIBCPP_MSVC
|
|
|
|
#undef _CREATE_ALIGNED_STORAGE_SPECIALIZATION
|
|
|
|
#ifndef _LIBCPP_HAS_NO_VARIADICS
|
|
|
|
// aligned_union
|
|
|
|
template <size_t _I0, size_t ..._In>
|
|
struct __static_max;
|
|
|
|
template <size_t _I0>
|
|
struct __static_max<_I0>
|
|
{
|
|
static const size_t value = _I0;
|
|
};
|
|
|
|
template <size_t _I0, size_t _I1, size_t ..._In>
|
|
struct __static_max<_I0, _I1, _In...>
|
|
{
|
|
static const size_t value = _I0 >= _I1 ? __static_max<_I0, _In...>::value :
|
|
__static_max<_I1, _In...>::value;
|
|
};
|
|
|
|
template <size_t _Len, class _Type0, class ..._Types>
|
|
struct aligned_union
|
|
{
|
|
static const size_t alignment_value = __static_max<__alignof__(_Type0),
|
|
__alignof__(_Types)...>::value;
|
|
static const size_t __len = __static_max<_Len, sizeof(_Type0),
|
|
sizeof(_Types)...>::value;
|
|
typedef typename aligned_storage<__len, alignment_value>::type type;
|
|
};
|
|
|
|
#if _LIBCPP_STD_VER > 11
|
|
template <size_t _Len, class ..._Types> using aligned_union_t = typename aligned_union<_Len, _Types...>::type;
|
|
#endif
|
|
|
|
#endif // _LIBCPP_HAS_NO_VARIADICS
|
|
|
|
// __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 decltype(__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 decltype(__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 _LIBCPP_TYPE_VIS_ONLY make_signed
|
|
{
|
|
typedef typename __apply_cv<_Tp, typename __make_signed<typename remove_cv<_Tp>::type>::type>::type type;
|
|
};
|
|
|
|
#if _LIBCPP_STD_VER > 11
|
|
template <class _Tp> using make_signed_t = typename make_signed<_Tp>::type;
|
|
#endif
|
|
|
|
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 _LIBCPP_TYPE_VIS_ONLY make_unsigned
|
|
{
|
|
typedef typename __apply_cv<_Tp, typename __make_unsigned<typename remove_cv<_Tp>::type>::type>::type type;
|
|
};
|
|
|
|
#if _LIBCPP_STD_VER > 11
|
|
template <class _Tp> using make_unsigned_t = typename make_unsigned<_Tp>::type;
|
|
#endif
|
|
|
|
#ifdef _LIBCPP_HAS_NO_VARIADICS
|
|
|
|
template <class _Tp, class _Up = void, class V = void>
|
|
struct _LIBCPP_TYPE_VIS_ONLY common_type
|
|
{
|
|
public:
|
|
typedef typename common_type<typename common_type<_Tp, _Up>::type, V>::type type;
|
|
};
|
|
|
|
template <class _Tp>
|
|
struct _LIBCPP_TYPE_VIS_ONLY common_type<_Tp, void, void>
|
|
{
|
|
public:
|
|
typedef _Tp type;
|
|
};
|
|
|
|
template <class _Tp, class _Up>
|
|
struct _LIBCPP_TYPE_VIS_ONLY 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
|
|
public:
|
|
typedef typename remove_reference<decltype(true ? __t() : __u())>::type type;
|
|
};
|
|
|
|
#else // _LIBCPP_HAS_NO_VARIADICS
|
|
|
|
template <class ..._Tp> struct common_type;
|
|
|
|
template <class _Tp>
|
|
struct _LIBCPP_TYPE_VIS_ONLY common_type<_Tp>
|
|
{
|
|
typedef _Tp type;
|
|
};
|
|
|
|
template <class _Tp, class _Up>
|
|
struct _LIBCPP_TYPE_VIS_ONLY common_type<_Tp, _Up>
|
|
{
|
|
private:
|
|
static _Tp&& __t();
|
|
static _Up&& __u();
|
|
static bool __f();
|
|
public:
|
|
typedef typename remove_reference<decltype(__f() ? __t() : __u())>::type type;
|
|
};
|
|
|
|
template <class _Tp, class _Up, class ..._Vp>
|
|
struct _LIBCPP_TYPE_VIS_ONLY common_type<_Tp, _Up, _Vp...>
|
|
{
|
|
typedef typename common_type<typename common_type<_Tp, _Up>::type, _Vp...>::type type;
|
|
};
|
|
|
|
#if _LIBCPP_STD_VER > 11
|
|
template <class ..._Tp> using common_type_t = typename common_type<_Tp...>::type;
|
|
#endif
|
|
|
|
#endif // _LIBCPP_HAS_NO_VARIADICS
|
|
|
|
// is_assignable
|
|
|
|
template<typename, typename T> struct __select_2nd { typedef T type; };
|
|
|
|
template <class _Tp, class _Arg>
|
|
typename __select_2nd<decltype((_VSTD::declval<_Tp>() = _VSTD::declval<_Arg>())), true_type>::type
|
|
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
|
__is_assignable_test(_Tp&&, _Arg&&);
|
|
#else
|
|
__is_assignable_test(_Tp, _Arg&);
|
|
#endif
|
|
|
|
template <class _Arg>
|
|
false_type
|
|
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
|
__is_assignable_test(__any, _Arg&&);
|
|
#else
|
|
__is_assignable_test(__any, _Arg&);
|
|
#endif
|
|
|
|
template <class _Tp, class _Arg, bool = is_void<_Tp>::value || is_void<_Arg>::value>
|
|
struct __is_assignable_imp
|
|
: public common_type
|
|
<
|
|
decltype(__is_assignable_test(declval<_Tp>(), declval<_Arg>()))
|
|
>::type {};
|
|
|
|
template <class _Tp, class _Arg>
|
|
struct __is_assignable_imp<_Tp, _Arg, true>
|
|
: public false_type
|
|
{
|
|
};
|
|
|
|
template <class _Tp, class _Arg>
|
|
struct is_assignable
|
|
: public __is_assignable_imp<_Tp, _Arg> {};
|
|
|
|
// is_copy_assignable
|
|
|
|
template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_copy_assignable
|
|
: public is_assignable<typename add_lvalue_reference<_Tp>::type,
|
|
const typename add_lvalue_reference<_Tp>::type> {};
|
|
|
|
// is_move_assignable
|
|
|
|
template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_move_assignable
|
|
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
|
: public is_assignable<typename add_lvalue_reference<_Tp>::type,
|
|
const typename add_rvalue_reference<_Tp>::type> {};
|
|
#else
|
|
: public is_copy_assignable<_Tp> {};
|
|
#endif
|
|
|
|
// is_destructible
|
|
|
|
template <class _Tp>
|
|
struct __destructible_test
|
|
{
|
|
_Tp __t;
|
|
};
|
|
|
|
template <class _Tp>
|
|
decltype((_VSTD::declval<__destructible_test<_Tp> >().~__destructible_test<_Tp>(), true_type()))
|
|
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
|
__is_destructible_test(_Tp&&);
|
|
#else
|
|
__is_destructible_test(_Tp&);
|
|
#endif
|
|
|
|
false_type
|
|
__is_destructible_test(__any);
|
|
|
|
template <class _Tp, bool = is_void<_Tp>::value || is_abstract<_Tp>::value
|
|
|| is_function<_Tp>::value>
|
|
struct __destructible_imp
|
|
: public common_type
|
|
<
|
|
decltype(__is_destructible_test(declval<_Tp>()))
|
|
>::type {};
|
|
|
|
template <class _Tp>
|
|
struct __destructible_imp<_Tp, true>
|
|
: public false_type {};
|
|
|
|
template <class _Tp>
|
|
struct is_destructible
|
|
: public __destructible_imp<_Tp> {};
|
|
|
|
template <class _Tp>
|
|
struct is_destructible<_Tp[]>
|
|
: public false_type {};
|
|
|
|
// move
|
|
|
|
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
|
|
|
template <class _Tp>
|
|
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
|
|
typename remove_reference<_Tp>::type&&
|
|
move(_Tp&& __t) _NOEXCEPT
|
|
{
|
|
typedef typename remove_reference<_Tp>::type _Up;
|
|
return static_cast<_Up&&>(__t);
|
|
}
|
|
|
|
template <class _Tp>
|
|
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
|
|
_Tp&&
|
|
forward(typename std::remove_reference<_Tp>::type& __t) _NOEXCEPT
|
|
{
|
|
return static_cast<_Tp&&>(__t);
|
|
}
|
|
|
|
template <class _Tp>
|
|
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
|
|
_Tp&&
|
|
forward(typename std::remove_reference<_Tp>::type&& __t) _NOEXCEPT
|
|
{
|
|
static_assert(!std::is_lvalue_reference<_Tp>::value,
|
|
"Can not forward an rvalue as an lvalue.");
|
|
return static_cast<_Tp&&>(__t);
|
|
}
|
|
|
|
#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
|
|
|
template <class _Tp>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
_Tp&
|
|
move(_Tp& __t)
|
|
{
|
|
return __t;
|
|
}
|
|
|
|
template <class _Tp>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
const _Tp&
|
|
move(const _Tp& __t)
|
|
{
|
|
return __t;
|
|
}
|
|
|
|
template <class _Tp>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
_Tp&
|
|
forward(typename std::remove_reference<_Tp>::type& __t) _NOEXCEPT
|
|
{
|
|
return __t;
|
|
}
|
|
|
|
|
|
template <class _Tp>
|
|
class __rv
|
|
{
|
|
typedef typename remove_reference<_Tp>::type _Trr;
|
|
_Trr& t_;
|
|
public:
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
_Trr* operator->() {return &t_;}
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
explicit __rv(_Trr& __t) : t_(__t) {}
|
|
};
|
|
|
|
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
|
|
|
template <class _Tp>
|
|
struct _LIBCPP_TYPE_VIS_ONLY 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;
|
|
};
|
|
|
|
#if _LIBCPP_STD_VER > 11
|
|
template <class _Tp> using decay_t = typename decay<_Tp>::type;
|
|
#endif
|
|
|
|
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
|
|
|
template <class _Tp>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename decay<_Tp>::type
|
|
__decay_copy(_Tp&& __t)
|
|
{
|
|
return _VSTD::forward<_Tp>(__t);
|
|
}
|
|
|
|
#else
|
|
|
|
template <class _Tp>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename decay<_Tp>::type
|
|
__decay_copy(const _Tp& __t)
|
|
{
|
|
return _VSTD::forward<_Tp>(__t);
|
|
}
|
|
|
|
#endif
|
|
|
|
template <class _MP, bool _IsMemberFuctionPtr, bool _IsMemberObjectPtr>
|
|
struct __member_pointer_traits_imp
|
|
{
|
|
};
|
|
|
|
#ifndef _LIBCPP_HAS_NO_VARIADICS
|
|
|
|
template <class _Rp, class _Class, class ..._Param>
|
|
struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param...), true, false>
|
|
{
|
|
typedef _Class _ClassType;
|
|
typedef _Rp _ReturnType;
|
|
};
|
|
|
|
template <class _Rp, class _Class, class ..._Param>
|
|
struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param...) const, true, false>
|
|
{
|
|
typedef _Class const _ClassType;
|
|
typedef _Rp _ReturnType;
|
|
};
|
|
|
|
template <class _Rp, class _Class, class ..._Param>
|
|
struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param...) volatile, true, false>
|
|
{
|
|
typedef _Class volatile _ClassType;
|
|
typedef _Rp _ReturnType;
|
|
};
|
|
|
|
template <class _Rp, class _Class, class ..._Param>
|
|
struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param...) const volatile, true, false>
|
|
{
|
|
typedef _Class const volatile _ClassType;
|
|
typedef _Rp _ReturnType;
|
|
};
|
|
|
|
#if __has_feature(cxx_reference_qualified_functions)
|
|
|
|
template <class _Rp, class _Class, class ..._Param>
|
|
struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param...) &, true, false>
|
|
{
|
|
typedef _Class& _ClassType;
|
|
typedef _Rp _ReturnType;
|
|
};
|
|
|
|
template <class _Rp, class _Class, class ..._Param>
|
|
struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param...) const&, true, false>
|
|
{
|
|
typedef _Class const& _ClassType;
|
|
typedef _Rp _ReturnType;
|
|
};
|
|
|
|
template <class _Rp, class _Class, class ..._Param>
|
|
struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param...) volatile&, true, false>
|
|
{
|
|
typedef _Class volatile& _ClassType;
|
|
typedef _Rp _ReturnType;
|
|
};
|
|
|
|
template <class _Rp, class _Class, class ..._Param>
|
|
struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param...) const volatile&, true, false>
|
|
{
|
|
typedef _Class const volatile& _ClassType;
|
|
typedef _Rp _ReturnType;
|
|
};
|
|
|
|
template <class _Rp, class _Class, class ..._Param>
|
|
struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param...) &&, true, false>
|
|
{
|
|
typedef _Class&& _ClassType;
|
|
typedef _Rp _ReturnType;
|
|
};
|
|
|
|
template <class _Rp, class _Class, class ..._Param>
|
|
struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param...) const&&, true, false>
|
|
{
|
|
typedef _Class const&& _ClassType;
|
|
typedef _Rp _ReturnType;
|
|
};
|
|
|
|
template <class _Rp, class _Class, class ..._Param>
|
|
struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param...) volatile&&, true, false>
|
|
{
|
|
typedef _Class volatile&& _ClassType;
|
|
typedef _Rp _ReturnType;
|
|
};
|
|
|
|
template <class _Rp, class _Class, class ..._Param>
|
|
struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param...) const volatile&&, true, false>
|
|
{
|
|
typedef _Class const volatile&& _ClassType;
|
|
typedef _Rp _ReturnType;
|
|
};
|
|
|
|
#endif // __has_feature(cxx_reference_qualified_functions)
|
|
|
|
#else // _LIBCPP_HAS_NO_VARIADICS
|
|
|
|
template <class _Rp, class _Class>
|
|
struct __member_pointer_traits_imp<_Rp (_Class::*)(), true, false>
|
|
{
|
|
typedef _Class _ClassType;
|
|
typedef _Rp _ReturnType;
|
|
};
|
|
|
|
template <class _Rp, class _Class, class _P0>
|
|
struct __member_pointer_traits_imp<_Rp (_Class::*)(_P0), true, false>
|
|
{
|
|
typedef _Class _ClassType;
|
|
typedef _Rp _ReturnType;
|
|
};
|
|
|
|
template <class _Rp, class _Class, class _P0, class _P1>
|
|
struct __member_pointer_traits_imp<_Rp (_Class::*)(_P0, _P1), true, false>
|
|
{
|
|
typedef _Class _ClassType;
|
|
typedef _Rp _ReturnType;
|
|
};
|
|
|
|
template <class _Rp, class _Class, class _P0, class _P1, class _P2>
|
|
struct __member_pointer_traits_imp<_Rp (_Class::*)(_P0, _P1, _P2), true, false>
|
|
{
|
|
typedef _Class _ClassType;
|
|
typedef _Rp _ReturnType;
|
|
};
|
|
|
|
template <class _Rp, class _Class>
|
|
struct __member_pointer_traits_imp<_Rp (_Class::*)() const, true, false>
|
|
{
|
|
typedef _Class const _ClassType;
|
|
typedef _Rp _ReturnType;
|
|
};
|
|
|
|
template <class _Rp, class _Class, class _P0>
|
|
struct __member_pointer_traits_imp<_Rp (_Class::*)(_P0) const, true, false>
|
|
{
|
|
typedef _Class const _ClassType;
|
|
typedef _Rp _ReturnType;
|
|
};
|
|
|
|
template <class _Rp, class _Class, class _P0, class _P1>
|
|
struct __member_pointer_traits_imp<_Rp (_Class::*)(_P0, _P1) const, true, false>
|
|
{
|
|
typedef _Class const _ClassType;
|
|
typedef _Rp _ReturnType;
|
|
};
|
|
|
|
template <class _Rp, class _Class, class _P0, class _P1, class _P2>
|
|
struct __member_pointer_traits_imp<_Rp (_Class::*)(_P0, _P1, _P2) const, true, false>
|
|
{
|
|
typedef _Class const _ClassType;
|
|
typedef _Rp _ReturnType;
|
|
};
|
|
|
|
template <class _Rp, class _Class>
|
|
struct __member_pointer_traits_imp<_Rp (_Class::*)() volatile, true, false>
|
|
{
|
|
typedef _Class volatile _ClassType;
|
|
typedef _Rp _ReturnType;
|
|
};
|
|
|
|
template <class _Rp, class _Class, class _P0>
|
|
struct __member_pointer_traits_imp<_Rp (_Class::*)(_P0) volatile, true, false>
|
|
{
|
|
typedef _Class volatile _ClassType;
|
|
typedef _Rp _ReturnType;
|
|
};
|
|
|
|
template <class _Rp, class _Class, class _P0, class _P1>
|
|
struct __member_pointer_traits_imp<_Rp (_Class::*)(_P0, _P1) volatile, true, false>
|
|
{
|
|
typedef _Class volatile _ClassType;
|
|
typedef _Rp _ReturnType;
|
|
};
|
|
|
|
template <class _Rp, class _Class, class _P0, class _P1, class _P2>
|
|
struct __member_pointer_traits_imp<_Rp (_Class::*)(_P0, _P1, _P2) volatile, true, false>
|
|
{
|
|
typedef _Class volatile _ClassType;
|
|
typedef _Rp _ReturnType;
|
|
};
|
|
|
|
template <class _Rp, class _Class>
|
|
struct __member_pointer_traits_imp<_Rp (_Class::*)() const volatile, true, false>
|
|
{
|
|
typedef _Class const volatile _ClassType;
|
|
typedef _Rp _ReturnType;
|
|
};
|
|
|
|
template <class _Rp, class _Class, class _P0>
|
|
struct __member_pointer_traits_imp<_Rp (_Class::*)(_P0) const volatile, true, false>
|
|
{
|
|
typedef _Class const volatile _ClassType;
|
|
typedef _Rp _ReturnType;
|
|
};
|
|
|
|
template <class _Rp, class _Class, class _P0, class _P1>
|
|
struct __member_pointer_traits_imp<_Rp (_Class::*)(_P0, _P1) const volatile, true, false>
|
|
{
|
|
typedef _Class const volatile _ClassType;
|
|
typedef _Rp _ReturnType;
|
|
};
|
|
|
|
template <class _Rp, class _Class, class _P0, class _P1, class _P2>
|
|
struct __member_pointer_traits_imp<_Rp (_Class::*)(_P0, _P1, _P2) const volatile, true, false>
|
|
{
|
|
typedef _Class const volatile _ClassType;
|
|
typedef _Rp _ReturnType;
|
|
};
|
|
|
|
#endif // _LIBCPP_HAS_NO_VARIADICS
|
|
|
|
template <class _Rp, class _Class>
|
|
struct __member_pointer_traits_imp<_Rp _Class::*, false, true>
|
|
{
|
|
typedef _Class _ClassType;
|
|
typedef _Rp _ReturnType;
|
|
};
|
|
|
|
template <class _MP>
|
|
struct __member_pointer_traits
|
|
: public __member_pointer_traits_imp<typename remove_cv<_MP>::type,
|
|
is_member_function_pointer<_MP>::value,
|
|
is_member_object_pointer<_MP>::value>
|
|
{
|
|
// typedef ... _ClassType;
|
|
// typedef ... _ReturnType;
|
|
};
|
|
|
|
// result_of
|
|
|
|
template <class _Callable> class result_of;
|
|
|
|
#ifdef _LIBCPP_HAS_NO_VARIADICS
|
|
|
|
template <class _Fn, bool, bool>
|
|
class __result_of
|
|
{
|
|
};
|
|
|
|
template <class _Fn>
|
|
class __result_of<_Fn(), true, false>
|
|
{
|
|
public:
|
|
typedef decltype(declval<_Fn>()()) type;
|
|
};
|
|
|
|
template <class _Fn, class _A0>
|
|
class __result_of<_Fn(_A0), true, false>
|
|
{
|
|
public:
|
|
typedef decltype(declval<_Fn>()(declval<_A0>())) type;
|
|
};
|
|
|
|
template <class _Fn, class _A0, class _A1>
|
|
class __result_of<_Fn(_A0, _A1), true, false>
|
|
{
|
|
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, false>
|
|
{
|
|
public:
|
|
typedef decltype(declval<_Fn>()(declval<_A0>(), declval<_A1>(), declval<_A2>())) type;
|
|
};
|
|
|
|
template <class _MP, class _Tp, bool _IsMemberFunctionPtr>
|
|
struct __result_of_mp;
|
|
|
|
// member function pointer
|
|
|
|
template <class _MP, class _Tp>
|
|
struct __result_of_mp<_MP, _Tp, true>
|
|
: public common_type<typename __member_pointer_traits<_MP>::_ReturnType>
|
|
{
|
|
};
|
|
|
|
// member data pointer
|
|
|
|
template <class _MP, class _Tp, bool>
|
|
struct __result_of_mdp;
|
|
|
|
template <class _Rp, class _Class, class _Tp>
|
|
struct __result_of_mdp<_Rp _Class::*, _Tp, false>
|
|
{
|
|
typedef typename __apply_cv<decltype(*_VSTD::declval<_Tp>()), _Rp>::type& type;
|
|
};
|
|
|
|
template <class _Rp, class _Class, class _Tp>
|
|
struct __result_of_mdp<_Rp _Class::*, _Tp, true>
|
|
{
|
|
typedef typename __apply_cv<_Tp, _Rp>::type& type;
|
|
};
|
|
|
|
template <class _Rp, class _Class, class _Tp>
|
|
struct __result_of_mp<_Rp _Class::*, _Tp, false>
|
|
: public __result_of_mdp<_Rp _Class::*, _Tp,
|
|
is_base_of<_Class, typename remove_reference<_Tp>::type>::value>
|
|
{
|
|
};
|
|
|
|
|
|
|
|
template <class _Fn, class _Tp>
|
|
class __result_of<_Fn(_Tp), false, true> // _Fn must be member pointer
|
|
: public __result_of_mp<typename remove_reference<_Fn>::type,
|
|
_Tp,
|
|
is_member_function_pointer<typename remove_reference<_Fn>::type>::value>
|
|
{
|
|
};
|
|
|
|
template <class _Fn, class _Tp, class _A0>
|
|
class __result_of<_Fn(_Tp, _A0), false, true> // _Fn must be member pointer
|
|
: public __result_of_mp<typename remove_reference<_Fn>::type,
|
|
_Tp,
|
|
is_member_function_pointer<typename remove_reference<_Fn>::type>::value>
|
|
{
|
|
};
|
|
|
|
template <class _Fn, class _Tp, class _A0, class _A1>
|
|
class __result_of<_Fn(_Tp, _A0, _A1), false, true> // _Fn must be member pointer
|
|
: public __result_of_mp<typename remove_reference<_Fn>::type,
|
|
_Tp,
|
|
is_member_function_pointer<typename remove_reference<_Fn>::type>::value>
|
|
{
|
|
};
|
|
|
|
template <class _Fn, class _Tp, class _A0, class _A1, class _A2>
|
|
class __result_of<_Fn(_Tp, _A0, _A1, _A2), false, true> // _Fn must be member pointer
|
|
: public __result_of_mp<typename remove_reference<_Fn>::type,
|
|
_Tp,
|
|
is_member_function_pointer<typename remove_reference<_Fn>::type>::value>
|
|
{
|
|
};
|
|
|
|
// result_of
|
|
|
|
template <class _Fn>
|
|
class _LIBCPP_TYPE_VIS_ONLY result_of<_Fn()>
|
|
: public __result_of<_Fn(),
|
|
is_class<typename remove_reference<_Fn>::type>::value ||
|
|
is_function<typename remove_reference<_Fn>::type>::value,
|
|
is_member_pointer<typename remove_reference<_Fn>::type>::value
|
|
>
|
|
{
|
|
};
|
|
|
|
template <class _Fn, class _A0>
|
|
class _LIBCPP_TYPE_VIS_ONLY result_of<_Fn(_A0)>
|
|
: public __result_of<_Fn(_A0),
|
|
is_class<typename remove_reference<_Fn>::type>::value ||
|
|
is_function<typename remove_reference<_Fn>::type>::value,
|
|
is_member_pointer<typename remove_reference<_Fn>::type>::value
|
|
>
|
|
{
|
|
};
|
|
|
|
template <class _Fn, class _A0, class _A1>
|
|
class _LIBCPP_TYPE_VIS_ONLY result_of<_Fn(_A0, _A1)>
|
|
: public __result_of<_Fn(_A0, _A1),
|
|
is_class<typename remove_reference<_Fn>::type>::value ||
|
|
is_function<typename remove_reference<_Fn>::type>::value,
|
|
is_member_pointer<typename remove_reference<_Fn>::type>::value
|
|
>
|
|
{
|
|
};
|
|
|
|
template <class _Fn, class _A0, class _A1, class _A2>
|
|
class _LIBCPP_TYPE_VIS_ONLY 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_reference<_Fn>::type>::value,
|
|
is_member_pointer<typename remove_reference<_Fn>::type>::value
|
|
>
|
|
{
|
|
};
|
|
|
|
#endif // _LIBCPP_HAS_NO_VARIADICS
|
|
|
|
#ifndef _LIBCPP_HAS_NO_VARIADICS
|
|
|
|
// template <class T, class... Args> struct is_constructible;
|
|
|
|
// main is_constructible test
|
|
|
|
template <class _Tp, class ..._Args>
|
|
typename __select_2nd<decltype(_VSTD::move(_Tp(_VSTD::declval<_Args>()...))), true_type>::type
|
|
__is_constructible_test(_Tp&&, _Args&& ...);
|
|
|
|
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 _Rp, class... _A1, class... _A2>
|
|
struct __is_constructible<false, _Rp(_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 __lxx(_Tp);
|
|
false_type static __lxx(...);
|
|
};
|
|
|
|
template <class _Tp, class _A0>
|
|
struct __is_constructible<true, _Tp, _A0>
|
|
: public common_type
|
|
<
|
|
decltype(__is_constructible_ref<_Tp>::__lxx(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 _LIBCPP_TYPE_VIS_ONLY 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 _Ap, size_t _Np>
|
|
struct __is_constructible<false, _Ap[_Np]>
|
|
: public is_constructible<typename remove_all_extents<_Ap>::type>
|
|
{};
|
|
|
|
// Otherwise array types are not constructible by this syntax
|
|
|
|
template <class _Ap, size_t _Np, class ..._Args>
|
|
struct __is_constructible<false, _Ap[_Np], _Args...>
|
|
: public false_type
|
|
{};
|
|
|
|
// Incomplete array types are not constructible
|
|
|
|
template <class _Ap, class ..._Args>
|
|
struct __is_constructible<false, _Ap[], _Args...>
|
|
: public false_type
|
|
{};
|
|
|
|
#else // _LIBCPP_HAS_NO_VARIADICS
|
|
|
|
// template <class T> struct is_constructible0;
|
|
|
|
// main is_constructible0 test
|
|
|
|
template <class _Tp>
|
|
decltype((_Tp(), true_type()))
|
|
__is_constructible0_test(_Tp&);
|
|
|
|
false_type
|
|
__is_constructible0_test(__any);
|
|
|
|
template <class _Tp, class _A0>
|
|
decltype((_Tp(_VSTD::declval<_A0>()), true_type()))
|
|
__is_constructible1_test(_Tp&, _A0&);
|
|
|
|
template <class _A0>
|
|
false_type
|
|
__is_constructible1_test(__any, _A0&);
|
|
|
|
template <class _Tp, class _A0, class _A1>
|
|
decltype((_Tp(_VSTD::declval<_A0>(), _VSTD::declval<_A1>()), true_type()))
|
|
__is_constructible2_test(_Tp&, _A0&, _A1&);
|
|
|
|
template <class _A0, class _A1>
|
|
false_type
|
|
__is_constructible2_test(__any, _A0&, _A1&);
|
|
|
|
template <bool, class _Tp>
|
|
struct __is_constructible0_imp // false, _Tp is not a scalar
|
|
: public common_type
|
|
<
|
|
decltype(__is_constructible0_test(declval<_Tp&>()))
|
|
>::type
|
|
{};
|
|
|
|
template <bool, class _Tp, class _A0>
|
|
struct __is_constructible1_imp // false, _Tp is not a scalar
|
|
: public common_type
|
|
<
|
|
decltype(__is_constructible1_test(declval<_Tp&>(), declval<_A0&>()))
|
|
>::type
|
|
{};
|
|
|
|
template <bool, class _Tp, class _A0, class _A1>
|
|
struct __is_constructible2_imp // false, _Tp is not a scalar
|
|
: public common_type
|
|
<
|
|
decltype(__is_constructible2_test(declval<_Tp&>(), declval<_A0>(), declval<_A1>()))
|
|
>::type
|
|
{};
|
|
|
|
// handle scalars and reference types
|
|
|
|
// Scalars are default constructible, references are not
|
|
|
|
template <class _Tp>
|
|
struct __is_constructible0_imp<true, _Tp>
|
|
: public is_scalar<_Tp>
|
|
{};
|
|
|
|
template <class _Tp, class _A0>
|
|
struct __is_constructible1_imp<true, _Tp, _A0>
|
|
: public is_convertible<_A0, _Tp>
|
|
{};
|
|
|
|
template <class _Tp, class _A0, class _A1>
|
|
struct __is_constructible2_imp<true, _Tp, _A0, _A1>
|
|
: public false_type
|
|
{};
|
|
|
|
// Treat scalars and reference types separately
|
|
|
|
template <bool, class _Tp>
|
|
struct __is_constructible0_void_check
|
|
: public __is_constructible0_imp<is_scalar<_Tp>::value || is_reference<_Tp>::value,
|
|
_Tp>
|
|
{};
|
|
|
|
template <bool, class _Tp, class _A0>
|
|
struct __is_constructible1_void_check
|
|
: public __is_constructible1_imp<is_scalar<_Tp>::value || is_reference<_Tp>::value,
|
|
_Tp, _A0>
|
|
{};
|
|
|
|
template <bool, class _Tp, class _A0, class _A1>
|
|
struct __is_constructible2_void_check
|
|
: public __is_constructible2_imp<is_scalar<_Tp>::value || is_reference<_Tp>::value,
|
|
_Tp, _A0, _A1>
|
|
{};
|
|
|
|
// If any of T or Args is void, is_constructible should be false
|
|
|
|
template <class _Tp>
|
|
struct __is_constructible0_void_check<true, _Tp>
|
|
: public false_type
|
|
{};
|
|
|
|
template <class _Tp, class _A0>
|
|
struct __is_constructible1_void_check<true, _Tp, _A0>
|
|
: public false_type
|
|
{};
|
|
|
|
template <class _Tp, class _A0, class _A1>
|
|
struct __is_constructible2_void_check<true, _Tp, _A0, _A1>
|
|
: public false_type
|
|
{};
|
|
|
|
// is_constructible entry point
|
|
|
|
namespace __is_construct
|
|
{
|
|
|
|
struct __nat {};
|
|
|
|
}
|
|
|
|
template <class _Tp, class _A0 = __is_construct::__nat,
|
|
class _A1 = __is_construct::__nat>
|
|
struct _LIBCPP_TYPE_VIS_ONLY is_constructible
|
|
: public __is_constructible2_void_check<is_void<_Tp>::value
|
|
|| is_abstract<_Tp>::value
|
|
|| is_function<_Tp>::value
|
|
|| is_void<_A0>::value
|
|
|| is_void<_A1>::value,
|
|
_Tp, _A0, _A1>
|
|
{};
|
|
|
|
template <class _Tp>
|
|
struct _LIBCPP_TYPE_VIS_ONLY is_constructible<_Tp, __is_construct::__nat, __is_construct::__nat>
|
|
: public __is_constructible0_void_check<is_void<_Tp>::value
|
|
|| is_abstract<_Tp>::value
|
|
|| is_function<_Tp>::value,
|
|
_Tp>
|
|
{};
|
|
|
|
template <class _Tp, class _A0>
|
|
struct _LIBCPP_TYPE_VIS_ONLY is_constructible<_Tp, _A0, __is_construct::__nat>
|
|
: public __is_constructible1_void_check<is_void<_Tp>::value
|
|
|| is_abstract<_Tp>::value
|
|
|| is_function<_Tp>::value
|
|
|| is_void<_A0>::value,
|
|
_Tp, _A0>
|
|
{};
|
|
|
|
// Array types are default constructible if their element type
|
|
// is default constructible
|
|
|
|
template <class _Ap, size_t _Np>
|
|
struct __is_constructible0_imp<false, _Ap[_Np]>
|
|
: public is_constructible<typename remove_all_extents<_Ap>::type>
|
|
{};
|
|
|
|
template <class _Ap, size_t _Np, class _A0>
|
|
struct __is_constructible1_imp<false, _Ap[_Np], _A0>
|
|
: public false_type
|
|
{};
|
|
|
|
template <class _Ap, size_t _Np, class _A0, class _A1>
|
|
struct __is_constructible2_imp<false, _Ap[_Np], _A0, _A1>
|
|
: public false_type
|
|
{};
|
|
|
|
// Incomplete array types are not constructible
|
|
|
|
template <class _Ap>
|
|
struct __is_constructible0_imp<false, _Ap[]>
|
|
: public false_type
|
|
{};
|
|
|
|
template <class _Ap, class _A0>
|
|
struct __is_constructible1_imp<false, _Ap[], _A0>
|
|
: public false_type
|
|
{};
|
|
|
|
template <class _Ap, class _A0, class _A1>
|
|
struct __is_constructible2_imp<false, _Ap[], _A0, _A1>
|
|
: public false_type
|
|
{};
|
|
|
|
#endif // _LIBCPP_HAS_NO_VARIADICS
|
|
|
|
// is_default_constructible
|
|
|
|
template <class _Tp>
|
|
struct _LIBCPP_TYPE_VIS_ONLY is_default_constructible
|
|
: public is_constructible<_Tp>
|
|
{};
|
|
|
|
// is_copy_constructible
|
|
|
|
template <class _Tp>
|
|
struct _LIBCPP_TYPE_VIS_ONLY is_copy_constructible
|
|
: public is_constructible<_Tp, const typename add_lvalue_reference<_Tp>::type>
|
|
{};
|
|
|
|
// is_move_constructible
|
|
|
|
template <class _Tp>
|
|
struct _LIBCPP_TYPE_VIS_ONLY is_move_constructible
|
|
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
|
: public is_constructible<_Tp, typename add_rvalue_reference<_Tp>::type>
|
|
#else
|
|
: public is_copy_constructible<_Tp>
|
|
#endif
|
|
{};
|
|
|
|
// is_trivially_constructible
|
|
|
|
#ifndef _LIBCPP_HAS_NO_VARIADICS
|
|
|
|
#if __has_feature(is_trivially_constructible)
|
|
|
|
template <class _Tp, class... _Args>
|
|
struct _LIBCPP_TYPE_VIS_ONLY is_trivially_constructible
|
|
: integral_constant<bool, __is_trivially_constructible(_Tp, _Args...)>
|
|
{
|
|
};
|
|
|
|
#else // !__has_feature(is_trivially_constructible)
|
|
|
|
template <class _Tp, class... _Args>
|
|
struct _LIBCPP_TYPE_VIS_ONLY is_trivially_constructible
|
|
: false_type
|
|
{
|
|
};
|
|
|
|
template <class _Tp>
|
|
struct _LIBCPP_TYPE_VIS_ONLY is_trivially_constructible<_Tp>
|
|
#if __has_feature(has_trivial_constructor) || (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)
|
|
: integral_constant<bool, __has_trivial_constructor(_Tp)>
|
|
#else
|
|
: integral_constant<bool, is_scalar<_Tp>::value>
|
|
#endif
|
|
{
|
|
};
|
|
|
|
template <class _Tp>
|
|
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
|
struct _LIBCPP_TYPE_VIS_ONLY is_trivially_constructible<_Tp, _Tp&&>
|
|
#else
|
|
struct _LIBCPP_TYPE_VIS_ONLY is_trivially_constructible<_Tp, _Tp>
|
|
#endif
|
|
: integral_constant<bool, is_scalar<_Tp>::value>
|
|
{
|
|
};
|
|
|
|
template <class _Tp>
|
|
struct _LIBCPP_TYPE_VIS_ONLY is_trivially_constructible<_Tp, const _Tp&>
|
|
: integral_constant<bool, is_scalar<_Tp>::value>
|
|
{
|
|
};
|
|
|
|
template <class _Tp>
|
|
struct _LIBCPP_TYPE_VIS_ONLY is_trivially_constructible<_Tp, _Tp&>
|
|
: integral_constant<bool, is_scalar<_Tp>::value>
|
|
{
|
|
};
|
|
|
|
#endif // !__has_feature(is_trivially_constructible)
|
|
|
|
#else // _LIBCPP_HAS_NO_VARIADICS
|
|
|
|
template <class _Tp, class _A0 = __is_construct::__nat,
|
|
class _A1 = __is_construct::__nat>
|
|
struct _LIBCPP_TYPE_VIS_ONLY is_trivially_constructible
|
|
: false_type
|
|
{
|
|
};
|
|
|
|
#if __has_feature(is_trivially_constructible)
|
|
|
|
template <class _Tp>
|
|
struct _LIBCPP_TYPE_VIS_ONLY is_trivially_constructible<_Tp, __is_construct::__nat,
|
|
__is_construct::__nat>
|
|
: integral_constant<bool, __is_trivially_constructible(_Tp)>
|
|
{
|
|
};
|
|
|
|
template <class _Tp>
|
|
struct _LIBCPP_TYPE_VIS_ONLY is_trivially_constructible<_Tp, _Tp,
|
|
__is_construct::__nat>
|
|
: integral_constant<bool, __is_trivially_constructible(_Tp, _Tp)>
|
|
{
|
|
};
|
|
|
|
template <class _Tp>
|
|
struct _LIBCPP_TYPE_VIS_ONLY is_trivially_constructible<_Tp, const _Tp&,
|
|
__is_construct::__nat>
|
|
: integral_constant<bool, __is_trivially_constructible(_Tp, const _Tp&)>
|
|
{
|
|
};
|
|
|
|
template <class _Tp>
|
|
struct _LIBCPP_TYPE_VIS_ONLY is_trivially_constructible<_Tp, _Tp&,
|
|
__is_construct::__nat>
|
|
: integral_constant<bool, __is_trivially_constructible(_Tp, _Tp&)>
|
|
{
|
|
};
|
|
|
|
#else // !__has_feature(is_trivially_constructible)
|
|
|
|
template <class _Tp>
|
|
struct _LIBCPP_TYPE_VIS_ONLY is_trivially_constructible<_Tp, __is_construct::__nat,
|
|
__is_construct::__nat>
|
|
: integral_constant<bool, is_scalar<_Tp>::value>
|
|
{
|
|
};
|
|
|
|
template <class _Tp>
|
|
struct _LIBCPP_TYPE_VIS_ONLY is_trivially_constructible<_Tp, _Tp,
|
|
__is_construct::__nat>
|
|
: integral_constant<bool, is_scalar<_Tp>::value>
|
|
{
|
|
};
|
|
|
|
template <class _Tp>
|
|
struct _LIBCPP_TYPE_VIS_ONLY is_trivially_constructible<_Tp, const _Tp&,
|
|
__is_construct::__nat>
|
|
: integral_constant<bool, is_scalar<_Tp>::value>
|
|
{
|
|
};
|
|
|
|
template <class _Tp>
|
|
struct _LIBCPP_TYPE_VIS_ONLY is_trivially_constructible<_Tp, _Tp&,
|
|
__is_construct::__nat>
|
|
: integral_constant<bool, is_scalar<_Tp>::value>
|
|
{
|
|
};
|
|
|
|
#endif // !__has_feature(is_trivially_constructible)
|
|
|
|
#endif // _LIBCPP_HAS_NO_VARIADICS
|
|
|
|
// is_trivially_default_constructible
|
|
|
|
template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_trivially_default_constructible
|
|
: public is_trivially_constructible<_Tp>
|
|
{};
|
|
|
|
// is_trivially_copy_constructible
|
|
|
|
template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_trivially_copy_constructible
|
|
: public is_trivially_constructible<_Tp, const typename add_lvalue_reference<_Tp>::type>
|
|
{};
|
|
|
|
// is_trivially_move_constructible
|
|
|
|
template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_trivially_move_constructible
|
|
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
|
: public is_trivially_constructible<_Tp, typename add_rvalue_reference<_Tp>::type>
|
|
#else
|
|
: public is_trivially_copy_constructible<_Tp>
|
|
#endif
|
|
{};
|
|
|
|
// is_trivially_assignable
|
|
|
|
#if __has_feature(is_trivially_constructible)
|
|
|
|
template <class _Tp, class _Arg>
|
|
struct is_trivially_assignable
|
|
: integral_constant<bool, __is_trivially_assignable(_Tp, _Arg)>
|
|
{
|
|
};
|
|
|
|
#else // !__has_feature(is_trivially_constructible)
|
|
|
|
template <class _Tp, class _Arg>
|
|
struct is_trivially_assignable
|
|
: public false_type {};
|
|
|
|
template <class _Tp>
|
|
struct is_trivially_assignable<_Tp&, _Tp>
|
|
: integral_constant<bool, is_scalar<_Tp>::value> {};
|
|
|
|
template <class _Tp>
|
|
struct is_trivially_assignable<_Tp&, _Tp&>
|
|
: integral_constant<bool, is_scalar<_Tp>::value> {};
|
|
|
|
template <class _Tp>
|
|
struct is_trivially_assignable<_Tp&, const _Tp&>
|
|
: integral_constant<bool, is_scalar<_Tp>::value> {};
|
|
|
|
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
|
|
|
template <class _Tp>
|
|
struct is_trivially_assignable<_Tp&, _Tp&&>
|
|
: integral_constant<bool, is_scalar<_Tp>::value> {};
|
|
|
|
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
|
|
|
#endif // !__has_feature(is_trivially_constructible)
|
|
|
|
// is_trivially_copy_assignable
|
|
|
|
template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_trivially_copy_assignable
|
|
: public is_trivially_assignable<typename add_lvalue_reference<_Tp>::type,
|
|
const typename add_lvalue_reference<_Tp>::type>
|
|
{};
|
|
|
|
// is_trivially_move_assignable
|
|
|
|
template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_trivially_move_assignable
|
|
: public is_trivially_assignable<typename add_lvalue_reference<_Tp>::type,
|
|
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
|
typename add_rvalue_reference<_Tp>::type>
|
|
#else
|
|
typename add_lvalue_reference<_Tp>::type>
|
|
#endif
|
|
{};
|
|
|
|
// is_trivially_destructible
|
|
|
|
#if __has_feature(has_trivial_destructor) || (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)
|
|
|
|
template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_trivially_destructible
|
|
: public integral_constant<bool, __has_trivial_destructor(_Tp)> {};
|
|
|
|
#else // _LIBCPP_HAS_TYPE_TRAITS
|
|
|
|
template <class _Tp> struct __libcpp_trivial_destructor
|
|
: public integral_constant<bool, is_scalar<_Tp>::value ||
|
|
is_reference<_Tp>::value> {};
|
|
|
|
template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_trivially_destructible
|
|
: public __libcpp_trivial_destructor<typename remove_all_extents<_Tp>::type> {};
|
|
|
|
#endif // _LIBCPP_HAS_TYPE_TRAITS
|
|
|
|
// is_nothrow_constructible
|
|
|
|
#ifndef _LIBCPP_HAS_NO_VARIADICS
|
|
|
|
#if __has_feature(cxx_noexcept)
|
|
|
|
template <bool, class _Tp, class... _Args> struct __is_nothrow_constructible;
|
|
|
|
template <class _Tp, class... _Args>
|
|
struct __is_nothrow_constructible<true, _Tp, _Args...>
|
|
: public integral_constant<bool, noexcept(_Tp(declval<_Args>()...))>
|
|
{
|
|
};
|
|
|
|
template <class _Tp, class... _Args>
|
|
struct __is_nothrow_constructible<false, _Tp, _Args...>
|
|
: public false_type
|
|
{
|
|
};
|
|
|
|
template <class _Tp, class... _Args>
|
|
struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_constructible
|
|
: __is_nothrow_constructible<is_constructible<_Tp, _Args...>::value, _Tp, _Args...>
|
|
{
|
|
};
|
|
|
|
template <class _Tp, size_t _Ns>
|
|
struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_constructible<_Tp[_Ns]>
|
|
: __is_nothrow_constructible<is_constructible<_Tp>::value, _Tp>
|
|
{
|
|
};
|
|
|
|
#else // __has_feature(cxx_noexcept)
|
|
|
|
template <class _Tp, class... _Args>
|
|
struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_constructible
|
|
: false_type
|
|
{
|
|
};
|
|
|
|
template <class _Tp>
|
|
struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_constructible<_Tp>
|
|
#if __has_feature(has_nothrow_constructor) || (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)
|
|
: integral_constant<bool, __has_nothrow_constructor(_Tp)>
|
|
#else
|
|
: integral_constant<bool, is_scalar<_Tp>::value>
|
|
#endif
|
|
{
|
|
};
|
|
|
|
template <class _Tp>
|
|
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
|
struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_constructible<_Tp, _Tp&&>
|
|
#else
|
|
struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_constructible<_Tp, _Tp>
|
|
#endif
|
|
#if __has_feature(has_nothrow_copy) || (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)
|
|
: integral_constant<bool, __has_nothrow_copy(_Tp)>
|
|
#else
|
|
: integral_constant<bool, is_scalar<_Tp>::value>
|
|
#endif
|
|
{
|
|
};
|
|
|
|
template <class _Tp>
|
|
struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_constructible<_Tp, const _Tp&>
|
|
#if __has_feature(has_nothrow_copy) || (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)
|
|
: integral_constant<bool, __has_nothrow_copy(_Tp)>
|
|
#else
|
|
: integral_constant<bool, is_scalar<_Tp>::value>
|
|
#endif
|
|
{
|
|
};
|
|
|
|
template <class _Tp>
|
|
struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_constructible<_Tp, _Tp&>
|
|
#if __has_feature(has_nothrow_copy) || (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)
|
|
: integral_constant<bool, __has_nothrow_copy(_Tp)>
|
|
#else
|
|
: integral_constant<bool, is_scalar<_Tp>::value>
|
|
#endif
|
|
{
|
|
};
|
|
|
|
#endif // __has_feature(cxx_noexcept)
|
|
|
|
#else // _LIBCPP_HAS_NO_VARIADICS
|
|
|
|
template <class _Tp, class _A0 = __is_construct::__nat,
|
|
class _A1 = __is_construct::__nat>
|
|
struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_constructible
|
|
: false_type
|
|
{
|
|
};
|
|
|
|
template <class _Tp>
|
|
struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_constructible<_Tp, __is_construct::__nat,
|
|
__is_construct::__nat>
|
|
#if __has_feature(has_nothrow_constructor) || (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)
|
|
: integral_constant<bool, __has_nothrow_constructor(_Tp)>
|
|
#else
|
|
: integral_constant<bool, is_scalar<_Tp>::value>
|
|
#endif
|
|
{
|
|
};
|
|
|
|
template <class _Tp>
|
|
struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_constructible<_Tp, _Tp,
|
|
__is_construct::__nat>
|
|
#if __has_feature(has_nothrow_copy) || (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)
|
|
: integral_constant<bool, __has_nothrow_copy(_Tp)>
|
|
#else
|
|
: integral_constant<bool, is_scalar<_Tp>::value>
|
|
#endif
|
|
{
|
|
};
|
|
|
|
template <class _Tp>
|
|
struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_constructible<_Tp, const _Tp&,
|
|
__is_construct::__nat>
|
|
#if __has_feature(has_nothrow_copy) || (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)
|
|
: integral_constant<bool, __has_nothrow_copy(_Tp)>
|
|
#else
|
|
: integral_constant<bool, is_scalar<_Tp>::value>
|
|
#endif
|
|
{
|
|
};
|
|
|
|
template <class _Tp>
|
|
struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_constructible<_Tp, _Tp&,
|
|
__is_construct::__nat>
|
|
#if __has_feature(has_nothrow_copy) || (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)
|
|
: integral_constant<bool, __has_nothrow_copy(_Tp)>
|
|
#else
|
|
: integral_constant<bool, is_scalar<_Tp>::value>
|
|
#endif
|
|
{
|
|
};
|
|
|
|
#endif // _LIBCPP_HAS_NO_VARIADICS
|
|
|
|
// is_nothrow_default_constructible
|
|
|
|
template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_default_constructible
|
|
: public is_nothrow_constructible<_Tp>
|
|
{};
|
|
|
|
// is_nothrow_copy_constructible
|
|
|
|
template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_copy_constructible
|
|
: public is_nothrow_constructible<_Tp, const typename add_lvalue_reference<_Tp>::type>
|
|
{};
|
|
|
|
// is_nothrow_move_constructible
|
|
|
|
template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_move_constructible
|
|
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
|
: public is_nothrow_constructible<_Tp, typename add_rvalue_reference<_Tp>::type>
|
|
#else
|
|
: public is_nothrow_copy_constructible<_Tp>
|
|
#endif
|
|
{};
|
|
|
|
// is_nothrow_assignable
|
|
|
|
#if __has_feature(cxx_noexcept)
|
|
|
|
template <bool, class _Tp, class _Arg> struct __is_nothrow_assignable;
|
|
|
|
template <class _Tp, class _Arg>
|
|
struct __is_nothrow_assignable<false, _Tp, _Arg>
|
|
: public false_type
|
|
{
|
|
};
|
|
|
|
template <class _Tp, class _Arg>
|
|
struct __is_nothrow_assignable<true, _Tp, _Arg>
|
|
: public integral_constant<bool, noexcept(_VSTD::declval<_Tp>() = _VSTD::declval<_Arg>()) >
|
|
{
|
|
};
|
|
|
|
template <class _Tp, class _Arg>
|
|
struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_assignable
|
|
: public __is_nothrow_assignable<is_assignable<_Tp, _Arg>::value, _Tp, _Arg>
|
|
{
|
|
};
|
|
|
|
#else // __has_feature(cxx_noexcept)
|
|
|
|
template <class _Tp, class _Arg>
|
|
struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_assignable
|
|
: public false_type {};
|
|
|
|
template <class _Tp>
|
|
struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_assignable<_Tp&, _Tp>
|
|
#if __has_feature(has_nothrow_assign) || (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)
|
|
: integral_constant<bool, __has_nothrow_assign(_Tp)> {};
|
|
#else
|
|
: integral_constant<bool, is_scalar<_Tp>::value> {};
|
|
#endif
|
|
|
|
template <class _Tp>
|
|
struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_assignable<_Tp&, _Tp&>
|
|
#if __has_feature(has_nothrow_assign) || (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)
|
|
: integral_constant<bool, __has_nothrow_assign(_Tp)> {};
|
|
#else
|
|
: integral_constant<bool, is_scalar<_Tp>::value> {};
|
|
#endif
|
|
|
|
template <class _Tp>
|
|
struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_assignable<_Tp&, const _Tp&>
|
|
#if __has_feature(has_nothrow_assign) || (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)
|
|
: integral_constant<bool, __has_nothrow_assign(_Tp)> {};
|
|
#else
|
|
: integral_constant<bool, is_scalar<_Tp>::value> {};
|
|
#endif
|
|
|
|
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
|
|
|
template <class _Tp>
|
|
struct is_nothrow_assignable<_Tp&, _Tp&&>
|
|
#if __has_feature(has_nothrow_assign) || (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)
|
|
: integral_constant<bool, __has_nothrow_assign(_Tp)> {};
|
|
#else
|
|
: integral_constant<bool, is_scalar<_Tp>::value> {};
|
|
#endif
|
|
|
|
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
|
|
|
#endif // __has_feature(cxx_noexcept)
|
|
|
|
// is_nothrow_copy_assignable
|
|
|
|
template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_copy_assignable
|
|
: public is_nothrow_assignable<typename add_lvalue_reference<_Tp>::type,
|
|
const typename add_lvalue_reference<_Tp>::type>
|
|
{};
|
|
|
|
// is_nothrow_move_assignable
|
|
|
|
template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_move_assignable
|
|
: public is_nothrow_assignable<typename add_lvalue_reference<_Tp>::type,
|
|
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
|
typename add_rvalue_reference<_Tp>::type>
|
|
#else
|
|
typename add_lvalue_reference<_Tp>::type>
|
|
#endif
|
|
{};
|
|
|
|
// is_nothrow_destructible
|
|
|
|
#if __has_feature(cxx_noexcept)
|
|
|
|
template <bool, class _Tp> struct __is_nothrow_destructible;
|
|
|
|
template <class _Tp>
|
|
struct __is_nothrow_destructible<false, _Tp>
|
|
: public false_type
|
|
{
|
|
};
|
|
|
|
template <class _Tp>
|
|
struct __is_nothrow_destructible<true, _Tp>
|
|
: public integral_constant<bool, noexcept(_VSTD::declval<_Tp>().~_Tp()) >
|
|
{
|
|
};
|
|
|
|
template <class _Tp>
|
|
struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_destructible
|
|
: public __is_nothrow_destructible<is_destructible<_Tp>::value, _Tp>
|
|
{
|
|
};
|
|
|
|
template <class _Tp, size_t _Ns>
|
|
struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_destructible<_Tp[_Ns]>
|
|
: public is_nothrow_destructible<_Tp>
|
|
{
|
|
};
|
|
|
|
template <class _Tp>
|
|
struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_destructible<_Tp&>
|
|
: public true_type
|
|
{
|
|
};
|
|
|
|
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
|
|
|
template <class _Tp>
|
|
struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_destructible<_Tp&&>
|
|
: public true_type
|
|
{
|
|
};
|
|
|
|
#endif
|
|
|
|
#else
|
|
|
|
template <class _Tp> struct __libcpp_nothrow_destructor
|
|
: public integral_constant<bool, is_scalar<_Tp>::value ||
|
|
is_reference<_Tp>::value> {};
|
|
|
|
template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_destructible
|
|
: public __libcpp_nothrow_destructor<typename remove_all_extents<_Tp>::type> {};
|
|
|
|
#endif
|
|
|
|
// is_pod
|
|
|
|
#if __has_feature(is_pod) || (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)
|
|
|
|
template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_pod
|
|
: public integral_constant<bool, __is_pod(_Tp)> {};
|
|
|
|
#else // _LIBCPP_HAS_TYPE_TRAITS
|
|
|
|
template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_pod
|
|
: public integral_constant<bool, is_trivially_default_constructible<_Tp>::value &&
|
|
is_trivially_copy_constructible<_Tp>::value &&
|
|
is_trivially_copy_assignable<_Tp>::value &&
|
|
is_trivially_destructible<_Tp>::value> {};
|
|
|
|
#endif // _LIBCPP_HAS_TYPE_TRAITS
|
|
|
|
// is_literal_type;
|
|
|
|
template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_literal_type
|
|
#if __has_feature(is_literal)
|
|
: public integral_constant<bool, __is_literal(_Tp)>
|
|
#else
|
|
: integral_constant<bool, is_scalar<typename remove_all_extents<_Tp>::type>::value ||
|
|
is_reference<typename remove_all_extents<_Tp>::type>::value>
|
|
#endif
|
|
{};
|
|
|
|
// is_standard_layout;
|
|
|
|
template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_standard_layout
|
|
#if __has_feature(is_standard_layout)
|
|
: public integral_constant<bool, __is_standard_layout(_Tp)>
|
|
#else
|
|
: integral_constant<bool, is_scalar<typename remove_all_extents<_Tp>::type>::value>
|
|
#endif
|
|
{};
|
|
|
|
// is_trivially_copyable;
|
|
|
|
template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_trivially_copyable
|
|
#if __has_feature(is_trivially_copyable)
|
|
: public integral_constant<bool, __is_trivially_copyable(_Tp)>
|
|
#else
|
|
: integral_constant<bool, is_scalar<typename remove_all_extents<_Tp>::type>::value>
|
|
#endif
|
|
{};
|
|
|
|
// is_trivial;
|
|
|
|
template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_trivial
|
|
#if __has_feature(is_trivial)
|
|
: public integral_constant<bool, __is_trivial(_Tp)>
|
|
#else
|
|
: integral_constant<bool, is_trivially_copyable<_Tp>::value &&
|
|
is_trivially_default_constructible<_Tp>::value>
|
|
#endif
|
|
{};
|
|
|
|
#ifndef _LIBCPP_HAS_NO_VARIADICS
|
|
|
|
// Check for complete types
|
|
|
|
template <class ..._Tp> struct __check_complete;
|
|
|
|
template <>
|
|
struct __check_complete<>
|
|
{
|
|
};
|
|
|
|
template <class _Hp, class _T0, class ..._Tp>
|
|
struct __check_complete<_Hp, _T0, _Tp...>
|
|
: private __check_complete<_Hp>,
|
|
private __check_complete<_T0, _Tp...>
|
|
{
|
|
};
|
|
|
|
template <class _Hp>
|
|
struct __check_complete<_Hp, _Hp>
|
|
: private __check_complete<_Hp>
|
|
{
|
|
};
|
|
|
|
template <class _Tp>
|
|
struct __check_complete<_Tp>
|
|
{
|
|
static_assert(sizeof(_Tp) > 0, "Type must be complete.");
|
|
};
|
|
|
|
template <class _Tp>
|
|
struct __check_complete<_Tp&>
|
|
: private __check_complete<_Tp>
|
|
{
|
|
};
|
|
|
|
template <class _Tp>
|
|
struct __check_complete<_Tp&&>
|
|
: private __check_complete<_Tp>
|
|
{
|
|
};
|
|
|
|
template <class _Rp, class ..._Param>
|
|
struct __check_complete<_Rp (*)(_Param...)>
|
|
: private __check_complete<_Rp>
|
|
{
|
|
};
|
|
|
|
template <class ..._Param>
|
|
struct __check_complete<void (*)(_Param...)>
|
|
{
|
|
};
|
|
|
|
template <class _Rp, class ..._Param>
|
|
struct __check_complete<_Rp (_Param...)>
|
|
: private __check_complete<_Rp>
|
|
{
|
|
};
|
|
|
|
template <class ..._Param>
|
|
struct __check_complete<void (_Param...)>
|
|
{
|
|
};
|
|
|
|
template <class _Rp, class _Class, class ..._Param>
|
|
struct __check_complete<_Rp (_Class::*)(_Param...)>
|
|
: private __check_complete<_Class>
|
|
{
|
|
};
|
|
|
|
template <class _Rp, class _Class, class ..._Param>
|
|
struct __check_complete<_Rp (_Class::*)(_Param...) const>
|
|
: private __check_complete<_Class>
|
|
{
|
|
};
|
|
|
|
template <class _Rp, class _Class, class ..._Param>
|
|
struct __check_complete<_Rp (_Class::*)(_Param...) volatile>
|
|
: private __check_complete<_Class>
|
|
{
|
|
};
|
|
|
|
template <class _Rp, class _Class, class ..._Param>
|
|
struct __check_complete<_Rp (_Class::*)(_Param...) const volatile>
|
|
: private __check_complete<_Class>
|
|
{
|
|
};
|
|
|
|
#if __has_feature(cxx_reference_qualified_functions)
|
|
|
|
template <class _Rp, class _Class, class ..._Param>
|
|
struct __check_complete<_Rp (_Class::*)(_Param...) &>
|
|
: private __check_complete<_Class>
|
|
{
|
|
};
|
|
|
|
template <class _Rp, class _Class, class ..._Param>
|
|
struct __check_complete<_Rp (_Class::*)(_Param...) const&>
|
|
: private __check_complete<_Class>
|
|
{
|
|
};
|
|
|
|
template <class _Rp, class _Class, class ..._Param>
|
|
struct __check_complete<_Rp (_Class::*)(_Param...) volatile&>
|
|
: private __check_complete<_Class>
|
|
{
|
|
};
|
|
|
|
template <class _Rp, class _Class, class ..._Param>
|
|
struct __check_complete<_Rp (_Class::*)(_Param...) const volatile&>
|
|
: private __check_complete<_Class>
|
|
{
|
|
};
|
|
|
|
template <class _Rp, class _Class, class ..._Param>
|
|
struct __check_complete<_Rp (_Class::*)(_Param...) &&>
|
|
: private __check_complete<_Class>
|
|
{
|
|
};
|
|
|
|
template <class _Rp, class _Class, class ..._Param>
|
|
struct __check_complete<_Rp (_Class::*)(_Param...) const&&>
|
|
: private __check_complete<_Class>
|
|
{
|
|
};
|
|
|
|
template <class _Rp, class _Class, class ..._Param>
|
|
struct __check_complete<_Rp (_Class::*)(_Param...) volatile&&>
|
|
: private __check_complete<_Class>
|
|
{
|
|
};
|
|
|
|
template <class _Rp, class _Class, class ..._Param>
|
|
struct __check_complete<_Rp (_Class::*)(_Param...) const volatile&&>
|
|
: private __check_complete<_Class>
|
|
{
|
|
};
|
|
|
|
#endif
|
|
|
|
template <class _Rp, class _Class>
|
|
struct __check_complete<_Rp _Class::*>
|
|
: private __check_complete<_Class>
|
|
{
|
|
};
|
|
|
|
// __invoke forward declarations
|
|
|
|
// fall back - none of the bullets
|
|
|
|
template <class ..._Args>
|
|
auto
|
|
__invoke(__any, _Args&& ...__args)
|
|
-> __nat;
|
|
|
|
// bullets 1 and 2
|
|
|
|
template <class _Fp, class _A0, class ..._Args,
|
|
class = typename enable_if
|
|
<
|
|
is_member_function_pointer<typename remove_reference<_Fp>::type>::value &&
|
|
is_base_of<typename __member_pointer_traits<typename remove_reference<_Fp>::type>::_ClassType,
|
|
typename remove_reference<_A0>::type>::value
|
|
>::type
|
|
>
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
auto
|
|
__invoke(_Fp&& __f, _A0&& __a0, _Args&& ...__args)
|
|
-> decltype((_VSTD::forward<_A0>(__a0).*__f)(_VSTD::forward<_Args>(__args)...));
|
|
|
|
template <class _Fp, class _A0, class ..._Args,
|
|
class = typename enable_if
|
|
<
|
|
is_member_function_pointer<typename remove_reference<_Fp>::type>::value &&
|
|
!is_base_of<typename __member_pointer_traits<typename remove_reference<_Fp>::type>::_ClassType,
|
|
typename remove_reference<_A0>::type>::value
|
|
>::type
|
|
>
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
auto
|
|
__invoke(_Fp&& __f, _A0&& __a0, _Args&& ...__args)
|
|
-> decltype(((*_VSTD::forward<_A0>(__a0)).*__f)(_VSTD::forward<_Args>(__args)...));
|
|
|
|
// bullets 3 and 4
|
|
|
|
template <class _Fp, class _A0,
|
|
class = typename enable_if
|
|
<
|
|
is_member_object_pointer<typename remove_reference<_Fp>::type>::value &&
|
|
is_base_of<typename __member_pointer_traits<typename remove_reference<_Fp>::type>::_ClassType,
|
|
typename remove_reference<_A0>::type>::value
|
|
>::type
|
|
>
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
auto
|
|
__invoke(_Fp&& __f, _A0&& __a0)
|
|
-> decltype(_VSTD::forward<_A0>(__a0).*__f);
|
|
|
|
template <class _Fp, class _A0,
|
|
class = typename enable_if
|
|
<
|
|
is_member_object_pointer<typename remove_reference<_Fp>::type>::value &&
|
|
!is_base_of<typename __member_pointer_traits<typename remove_reference<_Fp>::type>::_ClassType,
|
|
typename remove_reference<_A0>::type>::value
|
|
>::type
|
|
>
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
auto
|
|
__invoke(_Fp&& __f, _A0&& __a0)
|
|
-> decltype((*_VSTD::forward<_A0>(__a0)).*__f);
|
|
|
|
// bullet 5
|
|
|
|
template <class _Fp, class ..._Args>
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
auto
|
|
__invoke(_Fp&& __f, _Args&& ...__args)
|
|
-> decltype(_VSTD::forward<_Fp>(__f)(_VSTD::forward<_Args>(__args)...));
|
|
|
|
// __invokable
|
|
|
|
template <class _Fp, class ..._Args>
|
|
struct __invokable_imp
|
|
: private __check_complete<_Fp>
|
|
{
|
|
typedef decltype(
|
|
__invoke(_VSTD::declval<_Fp>(), _VSTD::declval<_Args>()...)
|
|
) type;
|
|
static const bool value = !is_same<type, __nat>::value;
|
|
};
|
|
|
|
template <class _Fp, class ..._Args>
|
|
struct __invokable
|
|
: public integral_constant<bool,
|
|
__invokable_imp<_Fp, _Args...>::value>
|
|
{
|
|
};
|
|
|
|
// __invoke_of
|
|
|
|
template <bool _Invokable, class _Fp, class ..._Args>
|
|
struct __invoke_of_imp // false
|
|
{
|
|
};
|
|
|
|
template <class _Fp, class ..._Args>
|
|
struct __invoke_of_imp<true, _Fp, _Args...>
|
|
{
|
|
typedef typename __invokable_imp<_Fp, _Args...>::type type;
|
|
};
|
|
|
|
template <class _Fp, class ..._Args>
|
|
struct __invoke_of
|
|
: public __invoke_of_imp<__invokable<_Fp, _Args...>::value, _Fp, _Args...>
|
|
{
|
|
};
|
|
|
|
template <class _Fp, class ..._Args>
|
|
class _LIBCPP_TYPE_VIS_ONLY result_of<_Fp(_Args...)>
|
|
: public __invoke_of<_Fp, _Args...>
|
|
{
|
|
};
|
|
|
|
#if _LIBCPP_STD_VER > 11
|
|
template <class _Tp> using result_of_t = typename result_of<_Tp>::type;
|
|
#endif
|
|
|
|
#endif // _LIBCPP_HAS_NO_VARIADICS
|
|
|
|
template <class _Tp>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
#ifndef _LIBCPP_HAS_NO_ADVANCED_SFINAE
|
|
typename enable_if
|
|
<
|
|
is_move_constructible<_Tp>::value &&
|
|
is_move_assignable<_Tp>::value
|
|
>::type
|
|
#else
|
|
void
|
|
#endif
|
|
swap(_Tp& __x, _Tp& __y) _NOEXCEPT_(is_nothrow_move_constructible<_Tp>::value &&
|
|
is_nothrow_move_assignable<_Tp>::value)
|
|
{
|
|
_Tp __t(_VSTD::move(__x));
|
|
__x = _VSTD::move(__y);
|
|
__y = _VSTD::move(__t);
|
|
}
|
|
|
|
template <class _ForwardIterator1, class _ForwardIterator2>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
void
|
|
iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b)
|
|
// _NOEXCEPT_(_NOEXCEPT_(swap(*__a, *__b)))
|
|
_NOEXCEPT_(_NOEXCEPT_(swap(*_VSTD::declval<_ForwardIterator1>(),
|
|
*_VSTD::declval<_ForwardIterator2>())))
|
|
{
|
|
swap(*__a, *__b);
|
|
}
|
|
|
|
// __swappable
|
|
|
|
namespace __detail
|
|
{
|
|
|
|
using _VSTD::swap;
|
|
__nat swap(__any, __any);
|
|
|
|
template <class _Tp>
|
|
struct __swappable
|
|
{
|
|
typedef decltype(swap(_VSTD::declval<_Tp&>(), _VSTD::declval<_Tp&>())) type;
|
|
static const bool value = !is_same<type, __nat>::value;
|
|
};
|
|
|
|
} // __detail
|
|
|
|
template <class _Tp>
|
|
struct __is_swappable
|
|
: public integral_constant<bool, __detail::__swappable<_Tp>::value>
|
|
{
|
|
};
|
|
|
|
#if __has_feature(cxx_noexcept)
|
|
|
|
template <bool, class _Tp>
|
|
struct __is_nothrow_swappable_imp
|
|
: public integral_constant<bool, noexcept(swap(_VSTD::declval<_Tp&>(),
|
|
_VSTD::declval<_Tp&>()))>
|
|
{
|
|
};
|
|
|
|
template <class _Tp>
|
|
struct __is_nothrow_swappable_imp<false, _Tp>
|
|
: public false_type
|
|
{
|
|
};
|
|
|
|
template <class _Tp>
|
|
struct __is_nothrow_swappable
|
|
: public __is_nothrow_swappable_imp<__is_swappable<_Tp>::value, _Tp>
|
|
{
|
|
};
|
|
|
|
#else // __has_feature(cxx_noexcept)
|
|
|
|
template <class _Tp>
|
|
struct __is_nothrow_swappable
|
|
: public false_type
|
|
{
|
|
};
|
|
|
|
#endif // __has_feature(cxx_noexcept)
|
|
|
|
#ifdef _LIBCXX_UNDERLYING_TYPE
|
|
|
|
template <class _Tp>
|
|
struct underlying_type
|
|
{
|
|
typedef _LIBCXX_UNDERLYING_TYPE(_Tp) type;
|
|
};
|
|
|
|
#if _LIBCPP_STD_VER > 11
|
|
template <class _Tp> using underlying_type_t = typename underlying_type<_Tp>::type;
|
|
#endif
|
|
|
|
#else // _LIBCXX_UNDERLYING_TYPE
|
|
|
|
template <class _Tp, bool _Support = false>
|
|
struct underlying_type
|
|
{
|
|
static_assert(_Support, "The underyling_type trait requires compiler "
|
|
"support. Either no such support exists or "
|
|
"libc++ does not know how to use it.");
|
|
};
|
|
|
|
#endif // _LIBCXX_UNDERLYING_TYPE
|
|
|
|
#ifndef _LIBCPP_HAS_NO_ADVANCED_SFINAE
|
|
|
|
template <class _Tp>
|
|
struct __has_operator_addressof_imp
|
|
{
|
|
template <class>
|
|
static auto __test(__any) -> false_type;
|
|
template <class _Up>
|
|
static auto __test(_Up* __u)
|
|
-> typename __select_2nd<decltype(__u->operator&()), true_type>::type;
|
|
|
|
static const bool value = decltype(__test<_Tp>(nullptr))::value;
|
|
};
|
|
|
|
template <class _Tp>
|
|
struct __has_operator_addressof
|
|
: public integral_constant<bool, __has_operator_addressof_imp<_Tp>::value>
|
|
{};
|
|
|
|
#endif // _LIBCPP_HAS_NO_ADVANCED_SFINAE
|
|
|
|
_LIBCPP_END_NAMESPACE_STD
|
|
|
|
#endif // _LIBCPP_TYPE_TRAITS
|