[libc++] Remove workarounds for [[nodebug]] not working properly on typedefs in older Clangs
Clang used to support [[nodebug]] everywhere except on typedefs. Since we don't support such old Clangs anymore, we can get rid of _LIBCPP_NODEBUG_TYPE in favour of always using _LIBCPP_NODEBUG. Differential Revision: https://reviews.llvm.org/D108996
This commit is contained in:
Louis Dionne
parent
8f9cc3bc29
commit
3557c7c122
|
|
@ -599,7 +599,6 @@ function(cxx_add_warning_flags target)
|
|||
-Wno-user-defined-literals
|
||||
-Wno-covered-switch-default
|
||||
-Wno-suggest-override
|
||||
-Wno-ignored-attributes # FIXME: Caused by _LIBCPP_NODEBUG_TYPE not being supported on older clangs
|
||||
)
|
||||
if (LIBCXX_TARGETING_CLANG_CL)
|
||||
target_add_compile_flags_if_supported(${target} PRIVATE
|
||||
|
|
|
|||
|
|
@ -1287,12 +1287,6 @@ extern "C" _LIBCPP_FUNC_VIS void __sanitizer_annotate_contiguous_container(
|
|||
#define _LIBCPP_NODEBUG
|
||||
#endif
|
||||
|
||||
#if __has_attribute(__nodebug__) && (defined(_LIBCPP_CLANG_VER) && _LIBCPP_CLANG_VER >= 900)
|
||||
# define _LIBCPP_NODEBUG_TYPE __attribute__((nodebug))
|
||||
#else
|
||||
# define _LIBCPP_NODEBUG_TYPE
|
||||
#endif
|
||||
|
||||
#if __has_attribute(__standalone_debug__)
|
||||
#define _LIBCPP_STANDALONE_DEBUG __attribute__((__standalone_debug__))
|
||||
#else
|
||||
|
|
|
|||
|
|
@ -127,8 +127,8 @@ class __alloc_func<_Fp, _Ap, _Rp(_ArgTypes...)>
|
|||
__compressed_pair<_Fp, _Ap> __f_;
|
||||
|
||||
public:
|
||||
typedef _LIBCPP_NODEBUG_TYPE _Fp _Target;
|
||||
typedef _LIBCPP_NODEBUG_TYPE _Ap _Alloc;
|
||||
typedef _LIBCPP_NODEBUG _Fp _Target;
|
||||
typedef _LIBCPP_NODEBUG _Ap _Alloc;
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
const _Target& __target() const { return __f_.first(); }
|
||||
|
|
@ -205,7 +205,7 @@ class __default_alloc_func<_Fp, _Rp(_ArgTypes...)> {
|
|||
_Fp __f_;
|
||||
|
||||
public:
|
||||
typedef _LIBCPP_NODEBUG_TYPE _Fp _Target;
|
||||
typedef _LIBCPP_NODEBUG _Fp _Target;
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
const _Target& __target() const { return __f_; }
|
||||
|
|
|
|||
|
|
@ -836,29 +836,29 @@ _LIBCPP_SUPPRESS_DEPRECATED_POP
|
|||
|
||||
#ifndef _LIBCPP_CXX03_LANG
|
||||
template <class _Key, class _Hash>
|
||||
using __check_hash_requirements _LIBCPP_NODEBUG_TYPE = integral_constant<bool,
|
||||
using __check_hash_requirements _LIBCPP_NODEBUG = integral_constant<bool,
|
||||
is_copy_constructible<_Hash>::value &&
|
||||
is_move_constructible<_Hash>::value &&
|
||||
__invokable_r<size_t, _Hash, _Key const&>::value
|
||||
>;
|
||||
|
||||
template <class _Key, class _Hash = hash<_Key> >
|
||||
using __has_enabled_hash _LIBCPP_NODEBUG_TYPE = integral_constant<bool,
|
||||
using __has_enabled_hash _LIBCPP_NODEBUG = integral_constant<bool,
|
||||
__check_hash_requirements<_Key, _Hash>::value &&
|
||||
is_default_constructible<_Hash>::value
|
||||
>;
|
||||
|
||||
#if _LIBCPP_STD_VER > 14
|
||||
template <class _Type, class>
|
||||
using __enable_hash_helper_imp _LIBCPP_NODEBUG_TYPE = _Type;
|
||||
using __enable_hash_helper_imp _LIBCPP_NODEBUG = _Type;
|
||||
|
||||
template <class _Type, class ..._Keys>
|
||||
using __enable_hash_helper _LIBCPP_NODEBUG_TYPE = __enable_hash_helper_imp<_Type,
|
||||
using __enable_hash_helper _LIBCPP_NODEBUG = __enable_hash_helper_imp<_Type,
|
||||
typename enable_if<__all<__has_enabled_hash<_Keys>::value...>::value>::type
|
||||
>;
|
||||
#else
|
||||
template <class _Type, class ...>
|
||||
using __enable_hash_helper _LIBCPP_NODEBUG_TYPE = _Type;
|
||||
using __enable_hash_helper _LIBCPP_NODEBUG = _Type;
|
||||
#endif
|
||||
|
||||
#endif // !_LIBCPP_CXX03_LANG
|
||||
|
|
|
|||
|
|
@ -18,13 +18,13 @@
|
|||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
template <class _Tp>
|
||||
struct __unwrap_reference { typedef _LIBCPP_NODEBUG_TYPE _Tp type; };
|
||||
struct __unwrap_reference { typedef _LIBCPP_NODEBUG _Tp type; };
|
||||
|
||||
template <class _Tp>
|
||||
class reference_wrapper;
|
||||
|
||||
template <class _Tp>
|
||||
struct __unwrap_reference<reference_wrapper<_Tp> > { typedef _LIBCPP_NODEBUG_TYPE _Tp& type; };
|
||||
struct __unwrap_reference<reference_wrapper<_Tp> > { typedef _LIBCPP_NODEBUG _Tp& type; };
|
||||
|
||||
template <class _Tp>
|
||||
struct decay;
|
||||
|
|
|
|||
|
|
@ -89,7 +89,7 @@ struct __weak_result_type_imp // bool is true
|
|||
: public __maybe_derive_from_unary_function<_Tp>,
|
||||
public __maybe_derive_from_binary_function<_Tp>
|
||||
{
|
||||
typedef _LIBCPP_NODEBUG_TYPE typename _Tp::result_type result_type;
|
||||
typedef _LIBCPP_NODEBUG typename _Tp::result_type result_type;
|
||||
};
|
||||
|
||||
template <class _Tp>
|
||||
|
|
@ -110,19 +110,19 @@ struct __weak_result_type
|
|||
template <class _Rp>
|
||||
struct __weak_result_type<_Rp ()>
|
||||
{
|
||||
typedef _LIBCPP_NODEBUG_TYPE _Rp result_type;
|
||||
typedef _LIBCPP_NODEBUG _Rp result_type;
|
||||
};
|
||||
|
||||
template <class _Rp>
|
||||
struct __weak_result_type<_Rp (&)()>
|
||||
{
|
||||
typedef _LIBCPP_NODEBUG_TYPE _Rp result_type;
|
||||
typedef _LIBCPP_NODEBUG _Rp result_type;
|
||||
};
|
||||
|
||||
template <class _Rp>
|
||||
struct __weak_result_type<_Rp (*)()>
|
||||
{
|
||||
typedef _LIBCPP_NODEBUG_TYPE _Rp result_type;
|
||||
typedef _LIBCPP_NODEBUG _Rp result_type;
|
||||
};
|
||||
|
||||
// 1 argument case
|
||||
|
|
|
|||
|
|
@ -36,7 +36,7 @@ extern _LIBCPP_EXPORTED_FROM_ABI const allocator_arg_t allocator_arg;
|
|||
template <class _Tp, class _Alloc, class ..._Args>
|
||||
struct __uses_alloc_ctor_imp
|
||||
{
|
||||
typedef _LIBCPP_NODEBUG_TYPE typename __uncvref<_Alloc>::type _RawAlloc;
|
||||
typedef _LIBCPP_NODEBUG typename __uncvref<_Alloc>::type _RawAlloc;
|
||||
static const bool __ua = uses_allocator<_Tp, _RawAlloc>::value;
|
||||
static const bool __ic =
|
||||
is_constructible<_Tp, allocator_arg_t, _Alloc, _Args...>::value;
|
||||
|
|
|
|||
|
|
@ -36,11 +36,11 @@ template <class _Tp, class _Alloc,
|
|||
class _RawAlloc = typename remove_reference<_Alloc>::type,
|
||||
bool = __has_pointer<_RawAlloc>::value>
|
||||
struct __pointer {
|
||||
using type _LIBCPP_NODEBUG_TYPE = typename _RawAlloc::pointer;
|
||||
using type _LIBCPP_NODEBUG = typename _RawAlloc::pointer;
|
||||
};
|
||||
template <class _Tp, class _Alloc, class _RawAlloc>
|
||||
struct __pointer<_Tp, _Alloc, _RawAlloc, false> {
|
||||
using type _LIBCPP_NODEBUG_TYPE = _Tp*;
|
||||
using type _LIBCPP_NODEBUG = _Tp*;
|
||||
};
|
||||
|
||||
// __const_pointer
|
||||
|
|
@ -48,14 +48,14 @@ _LIBCPP_ALLOCATOR_TRAITS_HAS_XXX(__has_const_pointer, const_pointer);
|
|||
template <class _Tp, class _Ptr, class _Alloc,
|
||||
bool = __has_const_pointer<_Alloc>::value>
|
||||
struct __const_pointer {
|
||||
using type _LIBCPP_NODEBUG_TYPE = typename _Alloc::const_pointer;
|
||||
using type _LIBCPP_NODEBUG = typename _Alloc::const_pointer;
|
||||
};
|
||||
template <class _Tp, class _Ptr, class _Alloc>
|
||||
struct __const_pointer<_Tp, _Ptr, _Alloc, false> {
|
||||
#ifdef _LIBCPP_CXX03_LANG
|
||||
using type = typename pointer_traits<_Ptr>::template rebind<const _Tp>::other;
|
||||
#else
|
||||
using type _LIBCPP_NODEBUG_TYPE = typename pointer_traits<_Ptr>::template rebind<const _Tp>;
|
||||
using type _LIBCPP_NODEBUG = typename pointer_traits<_Ptr>::template rebind<const _Tp>;
|
||||
#endif
|
||||
};
|
||||
|
||||
|
|
@ -64,14 +64,14 @@ _LIBCPP_ALLOCATOR_TRAITS_HAS_XXX(__has_void_pointer, void_pointer);
|
|||
template <class _Ptr, class _Alloc,
|
||||
bool = __has_void_pointer<_Alloc>::value>
|
||||
struct __void_pointer {
|
||||
using type _LIBCPP_NODEBUG_TYPE = typename _Alloc::void_pointer;
|
||||
using type _LIBCPP_NODEBUG = typename _Alloc::void_pointer;
|
||||
};
|
||||
template <class _Ptr, class _Alloc>
|
||||
struct __void_pointer<_Ptr, _Alloc, false> {
|
||||
#ifdef _LIBCPP_CXX03_LANG
|
||||
using type _LIBCPP_NODEBUG_TYPE = typename pointer_traits<_Ptr>::template rebind<void>::other;
|
||||
using type _LIBCPP_NODEBUG = typename pointer_traits<_Ptr>::template rebind<void>::other;
|
||||
#else
|
||||
using type _LIBCPP_NODEBUG_TYPE = typename pointer_traits<_Ptr>::template rebind<void>;
|
||||
using type _LIBCPP_NODEBUG = typename pointer_traits<_Ptr>::template rebind<void>;
|
||||
#endif
|
||||
};
|
||||
|
||||
|
|
@ -80,14 +80,14 @@ _LIBCPP_ALLOCATOR_TRAITS_HAS_XXX(__has_const_void_pointer, const_void_pointer);
|
|||
template <class _Ptr, class _Alloc,
|
||||
bool = __has_const_void_pointer<_Alloc>::value>
|
||||
struct __const_void_pointer {
|
||||
using type _LIBCPP_NODEBUG_TYPE = typename _Alloc::const_void_pointer;
|
||||
using type _LIBCPP_NODEBUG = typename _Alloc::const_void_pointer;
|
||||
};
|
||||
template <class _Ptr, class _Alloc>
|
||||
struct __const_void_pointer<_Ptr, _Alloc, false> {
|
||||
#ifdef _LIBCPP_CXX03_LANG
|
||||
using type _LIBCPP_NODEBUG_TYPE = typename pointer_traits<_Ptr>::template rebind<const void>::other;
|
||||
using type _LIBCPP_NODEBUG = typename pointer_traits<_Ptr>::template rebind<const void>::other;
|
||||
#else
|
||||
using type _LIBCPP_NODEBUG_TYPE = typename pointer_traits<_Ptr>::template rebind<const void>;
|
||||
using type _LIBCPP_NODEBUG = typename pointer_traits<_Ptr>::template rebind<const void>;
|
||||
#endif
|
||||
};
|
||||
|
||||
|
|
@ -97,18 +97,18 @@ template <class _Alloc, class _DiffType, bool = __has_size_type<_Alloc>::value>
|
|||
struct __size_type : make_unsigned<_DiffType> { };
|
||||
template <class _Alloc, class _DiffType>
|
||||
struct __size_type<_Alloc, _DiffType, true> {
|
||||
using type _LIBCPP_NODEBUG_TYPE = typename _Alloc::size_type;
|
||||
using type _LIBCPP_NODEBUG = typename _Alloc::size_type;
|
||||
};
|
||||
|
||||
// __alloc_traits_difference_type
|
||||
_LIBCPP_ALLOCATOR_TRAITS_HAS_XXX(__has_alloc_traits_difference_type, difference_type);
|
||||
template <class _Alloc, class _Ptr, bool = __has_alloc_traits_difference_type<_Alloc>::value>
|
||||
struct __alloc_traits_difference_type {
|
||||
using type _LIBCPP_NODEBUG_TYPE = typename pointer_traits<_Ptr>::difference_type;
|
||||
using type _LIBCPP_NODEBUG = typename pointer_traits<_Ptr>::difference_type;
|
||||
};
|
||||
template <class _Alloc, class _Ptr>
|
||||
struct __alloc_traits_difference_type<_Alloc, _Ptr, true> {
|
||||
using type _LIBCPP_NODEBUG_TYPE = typename _Alloc::difference_type;
|
||||
using type _LIBCPP_NODEBUG = typename _Alloc::difference_type;
|
||||
};
|
||||
|
||||
// __propagate_on_container_copy_assignment
|
||||
|
|
@ -117,7 +117,7 @@ template <class _Alloc, bool = __has_propagate_on_container_copy_assignment<_All
|
|||
struct __propagate_on_container_copy_assignment : false_type { };
|
||||
template <class _Alloc>
|
||||
struct __propagate_on_container_copy_assignment<_Alloc, true> {
|
||||
using type _LIBCPP_NODEBUG_TYPE = typename _Alloc::propagate_on_container_copy_assignment;
|
||||
using type _LIBCPP_NODEBUG = typename _Alloc::propagate_on_container_copy_assignment;
|
||||
};
|
||||
|
||||
// __propagate_on_container_move_assignment
|
||||
|
|
@ -126,7 +126,7 @@ template <class _Alloc, bool = __has_propagate_on_container_move_assignment<_All
|
|||
struct __propagate_on_container_move_assignment : false_type { };
|
||||
template <class _Alloc>
|
||||
struct __propagate_on_container_move_assignment<_Alloc, true> {
|
||||
using type _LIBCPP_NODEBUG_TYPE = typename _Alloc::propagate_on_container_move_assignment;
|
||||
using type _LIBCPP_NODEBUG = typename _Alloc::propagate_on_container_move_assignment;
|
||||
};
|
||||
|
||||
// __propagate_on_container_swap
|
||||
|
|
@ -135,7 +135,7 @@ template <class _Alloc, bool = __has_propagate_on_container_swap<_Alloc>::value>
|
|||
struct __propagate_on_container_swap : false_type { };
|
||||
template <class _Alloc>
|
||||
struct __propagate_on_container_swap<_Alloc, true> {
|
||||
using type _LIBCPP_NODEBUG_TYPE = typename _Alloc::propagate_on_container_swap;
|
||||
using type _LIBCPP_NODEBUG = typename _Alloc::propagate_on_container_swap;
|
||||
};
|
||||
|
||||
// __is_always_equal
|
||||
|
|
@ -144,7 +144,7 @@ template <class _Alloc, bool = __has_is_always_equal<_Alloc>::value>
|
|||
struct __is_always_equal : is_empty<_Alloc> { };
|
||||
template <class _Alloc>
|
||||
struct __is_always_equal<_Alloc, true> {
|
||||
using type _LIBCPP_NODEBUG_TYPE = typename _Alloc::is_always_equal;
|
||||
using type _LIBCPP_NODEBUG = typename _Alloc::is_always_equal;
|
||||
};
|
||||
|
||||
// __allocator_traits_rebind
|
||||
|
|
@ -158,15 +158,15 @@ struct __has_rebind_other<_Tp, _Up, typename __void_t<
|
|||
|
||||
template <class _Tp, class _Up, bool = __has_rebind_other<_Tp, _Up>::value>
|
||||
struct __allocator_traits_rebind {
|
||||
using type _LIBCPP_NODEBUG_TYPE = typename _Tp::template rebind<_Up>::other;
|
||||
using type _LIBCPP_NODEBUG = typename _Tp::template rebind<_Up>::other;
|
||||
};
|
||||
template <template <class, class...> class _Alloc, class _Tp, class ..._Args, class _Up>
|
||||
struct __allocator_traits_rebind<_Alloc<_Tp, _Args...>, _Up, true> {
|
||||
using type _LIBCPP_NODEBUG_TYPE = typename _Alloc<_Tp, _Args...>::template rebind<_Up>::other;
|
||||
using type _LIBCPP_NODEBUG = typename _Alloc<_Tp, _Args...>::template rebind<_Up>::other;
|
||||
};
|
||||
template <template <class, class...> class _Alloc, class _Tp, class ..._Args, class _Up>
|
||||
struct __allocator_traits_rebind<_Alloc<_Tp, _Args...>, _Up, false> {
|
||||
using type _LIBCPP_NODEBUG_TYPE = _Alloc<_Up, _Args...>;
|
||||
using type _LIBCPP_NODEBUG = _Alloc<_Up, _Args...>;
|
||||
};
|
||||
_LIBCPP_SUPPRESS_DEPRECATED_POP
|
||||
|
||||
|
|
@ -352,7 +352,7 @@ struct _LIBCPP_TEMPLATE_VIS allocator_traits
|
|||
template <class _Traits, class _Tp>
|
||||
struct __rebind_alloc_helper {
|
||||
#ifndef _LIBCPP_CXX03_LANG
|
||||
using type _LIBCPP_NODEBUG_TYPE = typename _Traits::template rebind_alloc<_Tp>;
|
||||
using type _LIBCPP_NODEBUG = typename _Traits::template rebind_alloc<_Tp>;
|
||||
#else
|
||||
using type = typename _Traits::template rebind_alloc<_Tp>::other;
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -115,8 +115,8 @@ public:
|
|||
"The current implementation is NOT ABI-compatible with the previous "
|
||||
"implementation for this configuration");
|
||||
|
||||
typedef _LIBCPP_NODEBUG_TYPE __compressed_pair_elem<_T1, 0> _Base1;
|
||||
typedef _LIBCPP_NODEBUG_TYPE __compressed_pair_elem<_T2, 1> _Base2;
|
||||
typedef _LIBCPP_NODEBUG __compressed_pair_elem<_T1, 0> _Base1;
|
||||
typedef _LIBCPP_NODEBUG __compressed_pair_elem<_T2, 1> _Base2;
|
||||
|
||||
template <bool _Dummy = true,
|
||||
class = typename enable_if<
|
||||
|
|
|
|||
|
|
@ -33,19 +33,19 @@ struct __pointer_traits_element_type;
|
|||
template <class _Ptr>
|
||||
struct __pointer_traits_element_type<_Ptr, true>
|
||||
{
|
||||
typedef _LIBCPP_NODEBUG_TYPE typename _Ptr::element_type type;
|
||||
typedef _LIBCPP_NODEBUG typename _Ptr::element_type type;
|
||||
};
|
||||
|
||||
template <template <class, class...> class _Sp, class _Tp, class ..._Args>
|
||||
struct __pointer_traits_element_type<_Sp<_Tp, _Args...>, true>
|
||||
{
|
||||
typedef _LIBCPP_NODEBUG_TYPE typename _Sp<_Tp, _Args...>::element_type type;
|
||||
typedef _LIBCPP_NODEBUG typename _Sp<_Tp, _Args...>::element_type type;
|
||||
};
|
||||
|
||||
template <template <class, class...> class _Sp, class _Tp, class ..._Args>
|
||||
struct __pointer_traits_element_type<_Sp<_Tp, _Args...>, false>
|
||||
{
|
||||
typedef _LIBCPP_NODEBUG_TYPE _Tp type;
|
||||
typedef _LIBCPP_NODEBUG _Tp type;
|
||||
};
|
||||
|
||||
template <class _Tp, class = void>
|
||||
|
|
@ -58,13 +58,13 @@ struct __has_difference_type<_Tp,
|
|||
template <class _Ptr, bool = __has_difference_type<_Ptr>::value>
|
||||
struct __pointer_traits_difference_type
|
||||
{
|
||||
typedef _LIBCPP_NODEBUG_TYPE ptrdiff_t type;
|
||||
typedef _LIBCPP_NODEBUG ptrdiff_t type;
|
||||
};
|
||||
|
||||
template <class _Ptr>
|
||||
struct __pointer_traits_difference_type<_Ptr, true>
|
||||
{
|
||||
typedef _LIBCPP_NODEBUG_TYPE typename _Ptr::difference_type type;
|
||||
typedef _LIBCPP_NODEBUG typename _Ptr::difference_type type;
|
||||
};
|
||||
|
||||
template <class _Tp, class _Up>
|
||||
|
|
@ -84,9 +84,9 @@ template <class _Tp, class _Up, bool = __has_rebind<_Tp, _Up>::value>
|
|||
struct __pointer_traits_rebind
|
||||
{
|
||||
#ifndef _LIBCPP_CXX03_LANG
|
||||
typedef _LIBCPP_NODEBUG_TYPE typename _Tp::template rebind<_Up> type;
|
||||
typedef _LIBCPP_NODEBUG typename _Tp::template rebind<_Up> type;
|
||||
#else
|
||||
typedef _LIBCPP_NODEBUG_TYPE typename _Tp::template rebind<_Up>::other type;
|
||||
typedef _LIBCPP_NODEBUG typename _Tp::template rebind<_Up>::other type;
|
||||
#endif
|
||||
};
|
||||
|
||||
|
|
@ -94,9 +94,9 @@ template <template <class, class...> class _Sp, class _Tp, class ..._Args, class
|
|||
struct __pointer_traits_rebind<_Sp<_Tp, _Args...>, _Up, true>
|
||||
{
|
||||
#ifndef _LIBCPP_CXX03_LANG
|
||||
typedef _LIBCPP_NODEBUG_TYPE typename _Sp<_Tp, _Args...>::template rebind<_Up> type;
|
||||
typedef _LIBCPP_NODEBUG typename _Sp<_Tp, _Args...>::template rebind<_Up> type;
|
||||
#else
|
||||
typedef _LIBCPP_NODEBUG_TYPE typename _Sp<_Tp, _Args...>::template rebind<_Up>::other type;
|
||||
typedef _LIBCPP_NODEBUG typename _Sp<_Tp, _Args...>::template rebind<_Up>::other type;
|
||||
#endif
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -48,10 +48,10 @@ _LIBCPP_BEGIN_NAMESPACE_STD
|
|||
template <class _Alloc>
|
||||
class __allocator_destructor
|
||||
{
|
||||
typedef _LIBCPP_NODEBUG_TYPE allocator_traits<_Alloc> __alloc_traits;
|
||||
typedef _LIBCPP_NODEBUG allocator_traits<_Alloc> __alloc_traits;
|
||||
public:
|
||||
typedef _LIBCPP_NODEBUG_TYPE typename __alloc_traits::pointer pointer;
|
||||
typedef _LIBCPP_NODEBUG_TYPE typename __alloc_traits::size_type size_type;
|
||||
typedef _LIBCPP_NODEBUG typename __alloc_traits::pointer pointer;
|
||||
typedef _LIBCPP_NODEBUG typename __alloc_traits::size_type size_type;
|
||||
private:
|
||||
_Alloc& __alloc_;
|
||||
size_type __s_;
|
||||
|
|
|
|||
|
|
@ -119,7 +119,7 @@ class _LIBCPP_UNIQUE_PTR_TRIVIAL_ABI _LIBCPP_TEMPLATE_VIS unique_ptr {
|
|||
public:
|
||||
typedef _Tp element_type;
|
||||
typedef _Dp deleter_type;
|
||||
typedef _LIBCPP_NODEBUG_TYPE typename __pointer<_Tp, deleter_type>::type pointer;
|
||||
typedef _LIBCPP_NODEBUG typename __pointer<_Tp, deleter_type>::type pointer;
|
||||
|
||||
static_assert(!is_rvalue_reference<deleter_type>::value,
|
||||
"the specified deleter type cannot be an rvalue reference");
|
||||
|
|
@ -129,38 +129,38 @@ private:
|
|||
|
||||
struct __nat { int __for_bool_; };
|
||||
|
||||
typedef _LIBCPP_NODEBUG_TYPE __unique_ptr_deleter_sfinae<_Dp> _DeleterSFINAE;
|
||||
typedef _LIBCPP_NODEBUG __unique_ptr_deleter_sfinae<_Dp> _DeleterSFINAE;
|
||||
|
||||
template <bool _Dummy>
|
||||
using _LValRefType _LIBCPP_NODEBUG_TYPE =
|
||||
using _LValRefType _LIBCPP_NODEBUG =
|
||||
typename __dependent_type<_DeleterSFINAE, _Dummy>::__lval_ref_type;
|
||||
|
||||
template <bool _Dummy>
|
||||
using _GoodRValRefType _LIBCPP_NODEBUG_TYPE =
|
||||
using _GoodRValRefType _LIBCPP_NODEBUG =
|
||||
typename __dependent_type<_DeleterSFINAE, _Dummy>::__good_rval_ref_type;
|
||||
|
||||
template <bool _Dummy>
|
||||
using _BadRValRefType _LIBCPP_NODEBUG_TYPE =
|
||||
using _BadRValRefType _LIBCPP_NODEBUG =
|
||||
typename __dependent_type<_DeleterSFINAE, _Dummy>::__bad_rval_ref_type;
|
||||
|
||||
template <bool _Dummy, class _Deleter = typename __dependent_type<
|
||||
__identity<deleter_type>, _Dummy>::type>
|
||||
using _EnableIfDeleterDefaultConstructible _LIBCPP_NODEBUG_TYPE =
|
||||
using _EnableIfDeleterDefaultConstructible _LIBCPP_NODEBUG =
|
||||
typename enable_if<is_default_constructible<_Deleter>::value &&
|
||||
!is_pointer<_Deleter>::value>::type;
|
||||
|
||||
template <class _ArgType>
|
||||
using _EnableIfDeleterConstructible _LIBCPP_NODEBUG_TYPE =
|
||||
using _EnableIfDeleterConstructible _LIBCPP_NODEBUG =
|
||||
typename enable_if<is_constructible<deleter_type, _ArgType>::value>::type;
|
||||
|
||||
template <class _UPtr, class _Up>
|
||||
using _EnableIfMoveConvertible _LIBCPP_NODEBUG_TYPE = typename enable_if<
|
||||
using _EnableIfMoveConvertible _LIBCPP_NODEBUG = typename enable_if<
|
||||
is_convertible<typename _UPtr::pointer, pointer>::value &&
|
||||
!is_array<_Up>::value
|
||||
>::type;
|
||||
|
||||
template <class _UDel>
|
||||
using _EnableIfDeleterConvertible _LIBCPP_NODEBUG_TYPE = typename enable_if<
|
||||
using _EnableIfDeleterConvertible _LIBCPP_NODEBUG = typename enable_if<
|
||||
(is_reference<_Dp>::value && is_same<_Dp, _UDel>::value) ||
|
||||
(!is_reference<_Dp>::value && is_convertible<_UDel, _Dp>::value)
|
||||
>::type;
|
||||
|
|
@ -347,35 +347,35 @@ private:
|
|||
typedef __unique_ptr_deleter_sfinae<_Dp> _DeleterSFINAE;
|
||||
|
||||
template <bool _Dummy>
|
||||
using _LValRefType _LIBCPP_NODEBUG_TYPE =
|
||||
using _LValRefType _LIBCPP_NODEBUG =
|
||||
typename __dependent_type<_DeleterSFINAE, _Dummy>::__lval_ref_type;
|
||||
|
||||
template <bool _Dummy>
|
||||
using _GoodRValRefType _LIBCPP_NODEBUG_TYPE =
|
||||
using _GoodRValRefType _LIBCPP_NODEBUG =
|
||||
typename __dependent_type<_DeleterSFINAE, _Dummy>::__good_rval_ref_type;
|
||||
|
||||
template <bool _Dummy>
|
||||
using _BadRValRefType _LIBCPP_NODEBUG_TYPE =
|
||||
using _BadRValRefType _LIBCPP_NODEBUG =
|
||||
typename __dependent_type<_DeleterSFINAE, _Dummy>::__bad_rval_ref_type;
|
||||
|
||||
template <bool _Dummy, class _Deleter = typename __dependent_type<
|
||||
__identity<deleter_type>, _Dummy>::type>
|
||||
using _EnableIfDeleterDefaultConstructible _LIBCPP_NODEBUG_TYPE =
|
||||
using _EnableIfDeleterDefaultConstructible _LIBCPP_NODEBUG =
|
||||
typename enable_if<is_default_constructible<_Deleter>::value &&
|
||||
!is_pointer<_Deleter>::value>::type;
|
||||
|
||||
template <class _ArgType>
|
||||
using _EnableIfDeleterConstructible _LIBCPP_NODEBUG_TYPE =
|
||||
using _EnableIfDeleterConstructible _LIBCPP_NODEBUG =
|
||||
typename enable_if<is_constructible<deleter_type, _ArgType>::value>::type;
|
||||
|
||||
template <class _Pp>
|
||||
using _EnableIfPointerConvertible _LIBCPP_NODEBUG_TYPE = typename enable_if<
|
||||
using _EnableIfPointerConvertible _LIBCPP_NODEBUG = typename enable_if<
|
||||
_CheckArrayPointerConversion<_Pp>::value
|
||||
>::type;
|
||||
|
||||
template <class _UPtr, class _Up,
|
||||
class _ElemT = typename _UPtr::element_type>
|
||||
using _EnableIfMoveConvertible _LIBCPP_NODEBUG_TYPE = typename enable_if<
|
||||
using _EnableIfMoveConvertible _LIBCPP_NODEBUG = typename enable_if<
|
||||
is_array<_Up>::value &&
|
||||
is_same<pointer, element_type*>::value &&
|
||||
is_same<typename _UPtr::pointer, _ElemT*>::value &&
|
||||
|
|
@ -383,13 +383,13 @@ private:
|
|||
>::type;
|
||||
|
||||
template <class _UDel>
|
||||
using _EnableIfDeleterConvertible _LIBCPP_NODEBUG_TYPE = typename enable_if<
|
||||
using _EnableIfDeleterConvertible _LIBCPP_NODEBUG = typename enable_if<
|
||||
(is_reference<_Dp>::value && is_same<_Dp, _UDel>::value) ||
|
||||
(!is_reference<_Dp>::value && is_convertible<_UDel, _Dp>::value)
|
||||
>::type;
|
||||
|
||||
template <class _UDel>
|
||||
using _EnableIfDeleterAssignable _LIBCPP_NODEBUG_TYPE = typename enable_if<
|
||||
using _EnableIfDeleterAssignable _LIBCPP_NODEBUG = typename enable_if<
|
||||
is_assignable<_Dp&, _UDel&&>::value
|
||||
>::type;
|
||||
|
||||
|
|
|
|||
|
|
@ -58,19 +58,19 @@ template <size_t _Ip, class _Tp> struct _LIBCPP_TEMPLATE_VIS tuple_element;
|
|||
template <size_t _Ip, class _Tp>
|
||||
struct _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, const _Tp>
|
||||
{
|
||||
typedef _LIBCPP_NODEBUG_TYPE typename add_const<typename tuple_element<_Ip, _Tp>::type>::type type;
|
||||
typedef _LIBCPP_NODEBUG typename add_const<typename tuple_element<_Ip, _Tp>::type>::type type;
|
||||
};
|
||||
|
||||
template <size_t _Ip, class _Tp>
|
||||
struct _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, volatile _Tp>
|
||||
{
|
||||
typedef _LIBCPP_NODEBUG_TYPE typename add_volatile<typename tuple_element<_Ip, _Tp>::type>::type type;
|
||||
typedef _LIBCPP_NODEBUG typename add_volatile<typename tuple_element<_Ip, _Tp>::type>::type type;
|
||||
};
|
||||
|
||||
template <size_t _Ip, class _Tp>
|
||||
struct _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, const volatile _Tp>
|
||||
{
|
||||
typedef _LIBCPP_NODEBUG_TYPE typename add_cv<typename tuple_element<_Ip, _Tp>::type>::type type;
|
||||
typedef _LIBCPP_NODEBUG typename add_cv<typename tuple_element<_Ip, _Tp>::type>::type type;
|
||||
};
|
||||
|
||||
template <class _Tp> struct __tuple_like : false_type {};
|
||||
|
|
@ -99,7 +99,7 @@ namespace __detail {
|
|||
|
||||
template<typename _Tp, size_t ..._Extra> struct __repeat;
|
||||
template<typename _Tp, _Tp ..._Np, size_t ..._Extra> struct __repeat<__integer_sequence<_Tp, _Np...>, _Extra...> {
|
||||
typedef _LIBCPP_NODEBUG_TYPE __integer_sequence<_Tp,
|
||||
typedef _LIBCPP_NODEBUG __integer_sequence<_Tp,
|
||||
_Np...,
|
||||
sizeof...(_Np) + _Np...,
|
||||
2 * sizeof...(_Np) + _Np...,
|
||||
|
|
@ -253,7 +253,7 @@ template <class ..._Tp> struct __tuple_types {};
|
|||
namespace __indexer_detail {
|
||||
|
||||
template <size_t _Idx, class _Tp>
|
||||
struct __indexed { using type _LIBCPP_NODEBUG_TYPE = _Tp; };
|
||||
struct __indexed { using type _LIBCPP_NODEBUG = _Tp; };
|
||||
|
||||
template <class _Types, class _Indexes> struct __indexer;
|
||||
|
||||
|
|
@ -268,7 +268,7 @@ __indexed<_Idx, _Tp> __at_index(__indexed<_Idx, _Tp> const&);
|
|||
} // namespace __indexer_detail
|
||||
|
||||
template <size_t _Idx, class ..._Types>
|
||||
using __type_pack_element _LIBCPP_NODEBUG_TYPE = typename decltype(
|
||||
using __type_pack_element _LIBCPP_NODEBUG = typename decltype(
|
||||
__indexer_detail::__at_index<_Idx>(
|
||||
__indexer_detail::__indexer<
|
||||
__tuple_types<_Types...>,
|
||||
|
|
@ -281,7 +281,7 @@ template <size_t _Ip, class ..._Types>
|
|||
struct _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, __tuple_types<_Types...>>
|
||||
{
|
||||
static_assert(_Ip < sizeof...(_Types), "tuple_element index out of range");
|
||||
typedef _LIBCPP_NODEBUG_TYPE __type_pack_element<_Ip, _Types...> type;
|
||||
typedef _LIBCPP_NODEBUG __type_pack_element<_Ip, _Types...> type;
|
||||
};
|
||||
|
||||
|
||||
|
|
@ -301,34 +301,34 @@ struct __apply_cv_mf<false, false, false> {
|
|||
};
|
||||
template <>
|
||||
struct __apply_cv_mf<false, true, false> {
|
||||
template <class _Tp> using __apply _LIBCPP_NODEBUG_TYPE = const _Tp;
|
||||
template <class _Tp> using __apply _LIBCPP_NODEBUG = const _Tp;
|
||||
};
|
||||
template <>
|
||||
struct __apply_cv_mf<false, false, true> {
|
||||
template <class _Tp> using __apply _LIBCPP_NODEBUG_TYPE = volatile _Tp;
|
||||
template <class _Tp> using __apply _LIBCPP_NODEBUG = volatile _Tp;
|
||||
};
|
||||
template <>
|
||||
struct __apply_cv_mf<false, true, true> {
|
||||
template <class _Tp> using __apply _LIBCPP_NODEBUG_TYPE = const volatile _Tp;
|
||||
template <class _Tp> using __apply _LIBCPP_NODEBUG = const volatile _Tp;
|
||||
};
|
||||
template <>
|
||||
struct __apply_cv_mf<true, false, false> {
|
||||
template <class _Tp> using __apply _LIBCPP_NODEBUG_TYPE = _Tp&;
|
||||
template <class _Tp> using __apply _LIBCPP_NODEBUG = _Tp&;
|
||||
};
|
||||
template <>
|
||||
struct __apply_cv_mf<true, true, false> {
|
||||
template <class _Tp> using __apply _LIBCPP_NODEBUG_TYPE = const _Tp&;
|
||||
template <class _Tp> using __apply _LIBCPP_NODEBUG = const _Tp&;
|
||||
};
|
||||
template <>
|
||||
struct __apply_cv_mf<true, false, true> {
|
||||
template <class _Tp> using __apply _LIBCPP_NODEBUG_TYPE = volatile _Tp&;
|
||||
template <class _Tp> using __apply _LIBCPP_NODEBUG = volatile _Tp&;
|
||||
};
|
||||
template <>
|
||||
struct __apply_cv_mf<true, true, true> {
|
||||
template <class _Tp> using __apply _LIBCPP_NODEBUG_TYPE = const volatile _Tp&;
|
||||
template <class _Tp> using __apply _LIBCPP_NODEBUG = const volatile _Tp&;
|
||||
};
|
||||
template <class _Tp, class _RawTp = typename remove_reference<_Tp>::type>
|
||||
using __apply_cv_t _LIBCPP_NODEBUG_TYPE = __apply_cv_mf<
|
||||
using __apply_cv_t _LIBCPP_NODEBUG = __apply_cv_mf<
|
||||
is_lvalue_reference<_Tp>::value,
|
||||
is_const<_RawTp>::value,
|
||||
is_volatile<_RawTp>::value>;
|
||||
|
|
@ -347,7 +347,7 @@ template <template <class...> class _Tuple, class ..._Types, size_t ..._Idx>
|
|||
struct __make_tuple_types_flat<_Tuple<_Types...>, __tuple_indices<_Idx...>> {
|
||||
// Specialization for pair, tuple, and __tuple_types
|
||||
template <class _Tp, class _ApplyFn = __apply_cv_t<_Tp>>
|
||||
using __apply_quals _LIBCPP_NODEBUG_TYPE = __tuple_types<
|
||||
using __apply_quals _LIBCPP_NODEBUG = __tuple_types<
|
||||
typename _ApplyFn::template __apply<__type_pack_element<_Idx, _Types...>>...
|
||||
>;
|
||||
};
|
||||
|
|
@ -375,12 +375,12 @@ struct __make_tuple_types
|
|||
|
||||
template <class ..._Types, size_t _Ep>
|
||||
struct __make_tuple_types<tuple<_Types...>, _Ep, 0, true> {
|
||||
typedef _LIBCPP_NODEBUG_TYPE __tuple_types<_Types...> type;
|
||||
typedef _LIBCPP_NODEBUG __tuple_types<_Types...> type;
|
||||
};
|
||||
|
||||
template <class ..._Types, size_t _Ep>
|
||||
struct __make_tuple_types<__tuple_types<_Types...>, _Ep, 0, true> {
|
||||
typedef _LIBCPP_NODEBUG_TYPE __tuple_types<_Types...> type;
|
||||
typedef _LIBCPP_NODEBUG __tuple_types<_Types...> type;
|
||||
};
|
||||
|
||||
template <bool ..._Preds>
|
||||
|
|
@ -454,12 +454,12 @@ struct __tuple_assignable<_Tp, _Up, true, true>
|
|||
template <size_t _Ip, class ..._Tp>
|
||||
struct _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, tuple<_Tp...> >
|
||||
{
|
||||
typedef _LIBCPP_NODEBUG_TYPE typename tuple_element<_Ip, __tuple_types<_Tp...> >::type type;
|
||||
typedef _LIBCPP_NODEBUG typename tuple_element<_Ip, __tuple_types<_Tp...> >::type type;
|
||||
};
|
||||
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
template <size_t _Ip, class ..._Tp>
|
||||
using tuple_element_t _LIBCPP_NODEBUG_TYPE = typename tuple_element <_Ip, _Tp...>::type;
|
||||
using tuple_element_t _LIBCPP_NODEBUG = typename tuple_element <_Ip, _Tp...>::type;
|
||||
#endif
|
||||
|
||||
template <bool _IsTuple, class _SizeTrait, size_t _Expected>
|
||||
|
|
@ -471,7 +471,7 @@ struct __tuple_like_with_size_imp<true, _SizeTrait, _Expected>
|
|||
|
||||
template <class _Tuple, size_t _ExpectedSize,
|
||||
class _RawTuple = typename __uncvref<_Tuple>::type>
|
||||
using __tuple_like_with_size _LIBCPP_NODEBUG_TYPE = __tuple_like_with_size_imp<
|
||||
using __tuple_like_with_size _LIBCPP_NODEBUG = __tuple_like_with_size_imp<
|
||||
__tuple_like<_RawTuple>::value,
|
||||
tuple_size<_RawTuple>, _ExpectedSize
|
||||
>;
|
||||
|
|
|
|||
|
|
@ -39,11 +39,11 @@ template<size_t... _Ip>
|
|||
#if __has_builtin(__make_integer_seq) && !defined(_LIBCPP_TESTING_FALLBACK_MAKE_INTEGER_SEQUENCE)
|
||||
|
||||
template <class _Tp, _Tp _Ep>
|
||||
using __make_integer_sequence _LIBCPP_NODEBUG_TYPE = __make_integer_seq<integer_sequence, _Tp, _Ep>;
|
||||
using __make_integer_sequence _LIBCPP_NODEBUG = __make_integer_seq<integer_sequence, _Tp, _Ep>;
|
||||
|
||||
#else
|
||||
|
||||
template<typename _Tp, _Tp _Np> using __make_integer_sequence_unchecked _LIBCPP_NODEBUG_TYPE =
|
||||
template<typename _Tp, _Tp _Np> using __make_integer_sequence_unchecked _LIBCPP_NODEBUG =
|
||||
typename __detail::__make<_Np>::type::template __convert<integer_sequence, _Tp>;
|
||||
|
||||
template <class _Tp, _Tp _Ep>
|
||||
|
|
@ -54,11 +54,11 @@ struct __make_integer_sequence_checked
|
|||
static_assert(0 <= _Ep, "std::make_integer_sequence must have a non-negative sequence length");
|
||||
// Workaround GCC bug by preventing bad installations when 0 <= _Ep
|
||||
// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=68929
|
||||
typedef _LIBCPP_NODEBUG_TYPE __make_integer_sequence_unchecked<_Tp, 0 <= _Ep ? _Ep : 0> type;
|
||||
typedef _LIBCPP_NODEBUG __make_integer_sequence_unchecked<_Tp, 0 <= _Ep ? _Ep : 0> type;
|
||||
};
|
||||
|
||||
template <class _Tp, _Tp _Ep>
|
||||
using __make_integer_sequence _LIBCPP_NODEBUG_TYPE = typename __make_integer_sequence_checked<_Tp, _Ep>::type;
|
||||
using __make_integer_sequence _LIBCPP_NODEBUG = typename __make_integer_sequence_checked<_Tp, _Ep>::type;
|
||||
|
||||
#endif
|
||||
|
||||
|
|
|
|||
|
|
@ -22,7 +22,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD
|
|||
template <class _Tp>
|
||||
_LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR typename remove_reference<_Tp>::type&&
|
||||
move(_Tp&& __t) _NOEXCEPT {
|
||||
typedef _LIBCPP_NODEBUG_TYPE typename remove_reference<_Tp>::type _Up;
|
||||
typedef _LIBCPP_NODEBUG typename remove_reference<_Tp>::type _Up;
|
||||
return static_cast<_Up&&>(__t);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -104,7 +104,7 @@ struct _LIBCPP_TEMPLATE_VIS pair
|
|||
};
|
||||
|
||||
template <bool _MaybeEnable>
|
||||
using _CheckArgsDep _LIBCPP_NODEBUG_TYPE = typename conditional<
|
||||
using _CheckArgsDep _LIBCPP_NODEBUG = typename conditional<
|
||||
_MaybeEnable, _CheckArgs, __check_tuple_constructor_fail>::type;
|
||||
|
||||
struct _CheckTupleLikeConstructor {
|
||||
|
|
@ -126,7 +126,7 @@ struct _LIBCPP_TEMPLATE_VIS pair
|
|||
};
|
||||
|
||||
template <class _Tuple>
|
||||
using _CheckTLC _LIBCPP_NODEBUG_TYPE = typename conditional<
|
||||
using _CheckTLC _LIBCPP_NODEBUG = typename conditional<
|
||||
__tuple_like_with_size<_Tuple, 2>::value
|
||||
&& !is_same<typename decay<_Tuple>::type, pair>::value,
|
||||
_CheckTupleLikeConstructor,
|
||||
|
|
@ -408,13 +408,13 @@ struct _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, pair<_T1, _T2> >
|
|||
template <class _T1, class _T2>
|
||||
struct _LIBCPP_TEMPLATE_VIS tuple_element<0, pair<_T1, _T2> >
|
||||
{
|
||||
typedef _LIBCPP_NODEBUG_TYPE _T1 type;
|
||||
typedef _LIBCPP_NODEBUG _T1 type;
|
||||
};
|
||||
|
||||
template <class _T1, class _T2>
|
||||
struct _LIBCPP_TEMPLATE_VIS tuple_element<1, pair<_T1, _T2> >
|
||||
{
|
||||
typedef _LIBCPP_NODEBUG_TYPE _T2 type;
|
||||
typedef _LIBCPP_NODEBUG _T2 type;
|
||||
};
|
||||
|
||||
template <size_t _Ip> struct __get_pair;
|
||||
|
|
|
|||
|
|
@ -1128,7 +1128,7 @@ inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
|
|||
typename tuple_element<_Ip, tuple<_Tp...> >::type&
|
||||
get(tuple<_Tp...>& __t) _NOEXCEPT
|
||||
{
|
||||
typedef _LIBCPP_NODEBUG_TYPE typename tuple_element<_Ip, tuple<_Tp...> >::type type;
|
||||
typedef _LIBCPP_NODEBUG typename tuple_element<_Ip, tuple<_Tp...> >::type type;
|
||||
return static_cast<__tuple_leaf<_Ip, type>&>(__t.__base_).get();
|
||||
}
|
||||
|
||||
|
|
@ -1137,7 +1137,7 @@ inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
|
|||
const typename tuple_element<_Ip, tuple<_Tp...> >::type&
|
||||
get(const tuple<_Tp...>& __t) _NOEXCEPT
|
||||
{
|
||||
typedef _LIBCPP_NODEBUG_TYPE typename tuple_element<_Ip, tuple<_Tp...> >::type type;
|
||||
typedef _LIBCPP_NODEBUG typename tuple_element<_Ip, tuple<_Tp...> >::type type;
|
||||
return static_cast<const __tuple_leaf<_Ip, type>&>(__t.__base_).get();
|
||||
}
|
||||
|
||||
|
|
@ -1146,7 +1146,7 @@ inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
|
|||
typename tuple_element<_Ip, tuple<_Tp...> >::type&&
|
||||
get(tuple<_Tp...>&& __t) _NOEXCEPT
|
||||
{
|
||||
typedef _LIBCPP_NODEBUG_TYPE typename tuple_element<_Ip, tuple<_Tp...> >::type type;
|
||||
typedef _LIBCPP_NODEBUG typename tuple_element<_Ip, tuple<_Tp...> >::type type;
|
||||
return static_cast<type&&>(
|
||||
static_cast<__tuple_leaf<_Ip, type>&&>(__t.__base_).get());
|
||||
}
|
||||
|
|
@ -1156,7 +1156,7 @@ inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
|
|||
const typename tuple_element<_Ip, tuple<_Tp...> >::type&&
|
||||
get(const tuple<_Tp...>&& __t) _NOEXCEPT
|
||||
{
|
||||
typedef _LIBCPP_NODEBUG_TYPE typename tuple_element<_Ip, tuple<_Tp...> >::type type;
|
||||
typedef _LIBCPP_NODEBUG typename tuple_element<_Ip, tuple<_Tp...> >::type type;
|
||||
return static_cast<const type&&>(
|
||||
static_cast<const __tuple_leaf<_Ip, type>&&>(__t.__base_).get());
|
||||
}
|
||||
|
|
@ -1375,7 +1375,7 @@ template <class _Tp, class _Up> struct __tuple_cat_type;
|
|||
template <class ..._Ttypes, class ..._Utypes>
|
||||
struct __tuple_cat_type<tuple<_Ttypes...>, __tuple_types<_Utypes...> >
|
||||
{
|
||||
typedef _LIBCPP_NODEBUG_TYPE tuple<_Ttypes..., _Utypes...> type;
|
||||
typedef _LIBCPP_NODEBUG tuple<_Ttypes..., _Utypes...> type;
|
||||
};
|
||||
|
||||
template <class _ResultTuple, bool _Is_Tuple0TupleLike, class ..._Tuples>
|
||||
|
|
@ -1386,7 +1386,7 @@ struct __tuple_cat_return_1
|
|||
template <class ..._Types, class _Tuple0>
|
||||
struct __tuple_cat_return_1<tuple<_Types...>, true, _Tuple0>
|
||||
{
|
||||
typedef _LIBCPP_NODEBUG_TYPE typename __tuple_cat_type<tuple<_Types...>,
|
||||
typedef _LIBCPP_NODEBUG typename __tuple_cat_type<tuple<_Types...>,
|
||||
typename __make_tuple_types<typename __uncvref<_Tuple0>::type>::type>::type
|
||||
type;
|
||||
};
|
||||
|
|
@ -1416,7 +1416,7 @@ struct __tuple_cat_return<_Tuple0, _Tuples...>
|
|||
template <>
|
||||
struct __tuple_cat_return<>
|
||||
{
|
||||
typedef _LIBCPP_NODEBUG_TYPE tuple<> type;
|
||||
typedef _LIBCPP_NODEBUG tuple<> type;
|
||||
};
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
|
||||
|
|
@ -1432,7 +1432,7 @@ struct __tuple_cat_return_ref_imp;
|
|||
template <class ..._Types, size_t ..._I0, class _Tuple0>
|
||||
struct __tuple_cat_return_ref_imp<tuple<_Types...>, __tuple_indices<_I0...>, _Tuple0>
|
||||
{
|
||||
typedef _LIBCPP_NODEBUG_TYPE typename remove_reference<_Tuple0>::type _T0;
|
||||
typedef _LIBCPP_NODEBUG typename remove_reference<_Tuple0>::type _T0;
|
||||
typedef tuple<_Types..., typename __apply_cv<_Tuple0,
|
||||
typename tuple_element<_I0, _T0>::type>::type&&...> type;
|
||||
};
|
||||
|
|
@ -1480,8 +1480,8 @@ struct __tuple_cat<tuple<_Types...>, __tuple_indices<_I0...>, __tuple_indices<_J
|
|||
typename __tuple_cat_return_ref<tuple<_Types...>&&, _Tuple0&&, _Tuple1&&, _Tuples&&...>::type
|
||||
operator()(tuple<_Types...> __t, _Tuple0&& __t0, _Tuple1&& __t1, _Tuples&& ...__tpls)
|
||||
{
|
||||
typedef _LIBCPP_NODEBUG_TYPE typename remove_reference<_Tuple0>::type _T0;
|
||||
typedef _LIBCPP_NODEBUG_TYPE typename remove_reference<_Tuple1>::type _T1;
|
||||
typedef _LIBCPP_NODEBUG typename remove_reference<_Tuple0>::type _T0;
|
||||
typedef _LIBCPP_NODEBUG typename remove_reference<_Tuple1>::type _T1;
|
||||
return __tuple_cat<
|
||||
tuple<_Types...,
|
||||
typename __apply_cv<_Tuple0, typename tuple_element<
|
||||
|
|
@ -1501,7 +1501,7 @@ inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
|
|||
typename __tuple_cat_return<_Tuple0, _Tuples...>::type
|
||||
tuple_cat(_Tuple0&& __t0, _Tuples&&... __tpls)
|
||||
{
|
||||
typedef _LIBCPP_NODEBUG_TYPE typename remove_reference<_Tuple0>::type _T0;
|
||||
typedef _LIBCPP_NODEBUG typename remove_reference<_Tuple0>::type _T0;
|
||||
return __tuple_cat<tuple<>, __tuple_indices<>,
|
||||
typename __make_tuple_indices<tuple_size<_T0>::value>::type>()
|
||||
(tuple<>(), _VSTD::forward<_Tuple0>(__t0),
|
||||
|
|
|
|||
|
|
@ -459,46 +459,46 @@ typedef _LIBCPP_BOOL_CONSTANT(true) true_type;
|
|||
typedef _LIBCPP_BOOL_CONSTANT(false) false_type;
|
||||
|
||||
template <bool _Val>
|
||||
using _BoolConstant _LIBCPP_NODEBUG_TYPE = integral_constant<bool, _Val>;
|
||||
using _BoolConstant _LIBCPP_NODEBUG = integral_constant<bool, _Val>;
|
||||
|
||||
template <bool> struct _MetaBase;
|
||||
template <>
|
||||
struct _MetaBase<true> {
|
||||
template <class _Tp, class _Up>
|
||||
using _SelectImpl _LIBCPP_NODEBUG_TYPE = _Tp;
|
||||
using _SelectImpl _LIBCPP_NODEBUG = _Tp;
|
||||
template <template <class...> class _FirstFn, template <class...> class, class ..._Args>
|
||||
using _SelectApplyImpl _LIBCPP_NODEBUG_TYPE = _FirstFn<_Args...>;
|
||||
using _SelectApplyImpl _LIBCPP_NODEBUG = _FirstFn<_Args...>;
|
||||
template <class _First, class...>
|
||||
using _FirstImpl _LIBCPP_NODEBUG_TYPE = _First;
|
||||
using _FirstImpl _LIBCPP_NODEBUG = _First;
|
||||
template <class, class _Second, class...>
|
||||
using _SecondImpl _LIBCPP_NODEBUG_TYPE = _Second;
|
||||
using _SecondImpl _LIBCPP_NODEBUG = _Second;
|
||||
template <class _Tp = void>
|
||||
using _EnableIfImpl _LIBCPP_NODEBUG_TYPE = _Tp;
|
||||
using _EnableIfImpl _LIBCPP_NODEBUG = _Tp;
|
||||
template <class _Result, class _First, class ..._Rest>
|
||||
using _OrImpl _LIBCPP_NODEBUG_TYPE = typename _MetaBase<_First::value != true && sizeof...(_Rest) != 0>::template _OrImpl<_First, _Rest...>;
|
||||
using _OrImpl _LIBCPP_NODEBUG = typename _MetaBase<_First::value != true && sizeof...(_Rest) != 0>::template _OrImpl<_First, _Rest...>;
|
||||
};
|
||||
|
||||
template <>
|
||||
struct _MetaBase<false> {
|
||||
template <class _Tp, class _Up>
|
||||
using _SelectImpl _LIBCPP_NODEBUG_TYPE = _Up;
|
||||
using _SelectImpl _LIBCPP_NODEBUG = _Up;
|
||||
template <template <class...> class, template <class...> class _SecondFn, class ..._Args>
|
||||
using _SelectApplyImpl _LIBCPP_NODEBUG_TYPE = _SecondFn<_Args...>;
|
||||
using _SelectApplyImpl _LIBCPP_NODEBUG = _SecondFn<_Args...>;
|
||||
template <class _Result, class ...>
|
||||
using _OrImpl _LIBCPP_NODEBUG_TYPE = _Result;
|
||||
using _OrImpl _LIBCPP_NODEBUG = _Result;
|
||||
};
|
||||
template <bool _Cond, class _Ret = void>
|
||||
using _EnableIf _LIBCPP_NODEBUG_TYPE = typename _MetaBase<_Cond>::template _EnableIfImpl<_Ret>;
|
||||
using _EnableIf _LIBCPP_NODEBUG = typename _MetaBase<_Cond>::template _EnableIfImpl<_Ret>;
|
||||
template <bool _Cond, class _IfRes, class _ElseRes>
|
||||
using _If _LIBCPP_NODEBUG_TYPE = typename _MetaBase<_Cond>::template _SelectImpl<_IfRes, _ElseRes>;
|
||||
using _If _LIBCPP_NODEBUG = typename _MetaBase<_Cond>::template _SelectImpl<_IfRes, _ElseRes>;
|
||||
template <class ..._Rest>
|
||||
using _Or _LIBCPP_NODEBUG_TYPE = typename _MetaBase< sizeof...(_Rest) != 0 >::template _OrImpl<false_type, _Rest...>;
|
||||
using _Or _LIBCPP_NODEBUG = typename _MetaBase< sizeof...(_Rest) != 0 >::template _OrImpl<false_type, _Rest...>;
|
||||
template <class _Pred>
|
||||
struct _Not : _BoolConstant<!_Pred::value> {};
|
||||
template <class ..._Args>
|
||||
using _FirstType _LIBCPP_NODEBUG_TYPE = typename _MetaBase<(sizeof...(_Args) >= 1)>::template _FirstImpl<_Args...>;
|
||||
using _FirstType _LIBCPP_NODEBUG = typename _MetaBase<(sizeof...(_Args) >= 1)>::template _FirstImpl<_Args...>;
|
||||
template <class ..._Args>
|
||||
using _SecondType _LIBCPP_NODEBUG_TYPE = typename _MetaBase<(sizeof...(_Args) >= 2)>::template _SecondImpl<_Args...>;
|
||||
using _SecondType _LIBCPP_NODEBUG = typename _MetaBase<(sizeof...(_Args) >= 2)>::template _SecondImpl<_Args...>;
|
||||
|
||||
template <class ...> using __expand_to_true = true_type;
|
||||
template <class ..._Pred>
|
||||
|
|
@ -506,7 +506,7 @@ __expand_to_true<_EnableIf<_Pred::value>...> __and_helper(int);
|
|||
template <class ...>
|
||||
false_type __and_helper(...);
|
||||
template <class ..._Pred>
|
||||
using _And _LIBCPP_NODEBUG_TYPE = decltype(__and_helper<_Pred...>(0));
|
||||
using _And _LIBCPP_NODEBUG = decltype(__and_helper<_Pred...>(0));
|
||||
|
||||
template <template <class...> class _Func, class ..._Args>
|
||||
struct _Lazy : _Func<_Args...> {};
|
||||
|
|
@ -519,7 +519,7 @@ template <template <class...> class, class ...>
|
|||
false_type __sfinae_test_impl(...);
|
||||
|
||||
template <template <class ...> class _Templ, class ..._Args>
|
||||
using _IsValidExpansion _LIBCPP_NODEBUG_TYPE = decltype(__sfinae_test_impl<_Templ, _Args...>(0));
|
||||
using _IsValidExpansion _LIBCPP_NODEBUG = decltype(__sfinae_test_impl<_Templ, _Args...>(0));
|
||||
|
||||
template <class>
|
||||
struct __void_t { typedef void type; };
|
||||
|
|
@ -528,7 +528,7 @@ template <class _Tp>
|
|||
struct __identity { typedef _Tp type; };
|
||||
|
||||
template <class _Tp>
|
||||
using __identity_t _LIBCPP_NODEBUG_TYPE = typename __identity<_Tp>::type;
|
||||
using __identity_t _LIBCPP_NODEBUG = typename __identity<_Tp>::type;
|
||||
|
||||
template <class _Tp, bool>
|
||||
struct _LIBCPP_TEMPLATE_VIS __dependent_type : public _Tp {};
|
||||
|
|
@ -1296,7 +1296,7 @@ struct __is_referenceable : integral_constant<bool,
|
|||
// add_const
|
||||
|
||||
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS add_const {
|
||||
typedef _LIBCPP_NODEBUG_TYPE const _Tp type;
|
||||
typedef _LIBCPP_NODEBUG const _Tp type;
|
||||
};
|
||||
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
|
|
@ -1306,7 +1306,7 @@ template <class _Tp> using add_const_t = typename add_const<_Tp>::type;
|
|||
// add_volatile
|
||||
|
||||
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS add_volatile {
|
||||
typedef _LIBCPP_NODEBUG_TYPE volatile _Tp type;
|
||||
typedef _LIBCPP_NODEBUG volatile _Tp type;
|
||||
};
|
||||
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
|
|
@ -1315,7 +1315,7 @@ template <class _Tp> using add_volatile_t = typename add_volatile<_Tp>::type;
|
|||
|
||||
// add_cv
|
||||
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS add_cv {
|
||||
typedef _LIBCPP_NODEBUG_TYPE const volatile _Tp type;
|
||||
typedef _LIBCPP_NODEBUG const volatile _Tp type;
|
||||
};
|
||||
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
|
|
@ -1331,9 +1331,9 @@ struct _LIBCPP_TEMPLATE_VIS remove_reference { typedef __remove_reference(_Tp) t
|
|||
|
||||
#else // __has_keyword(__remove_reference)
|
||||
|
||||
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_reference {typedef _LIBCPP_NODEBUG_TYPE _Tp type;};
|
||||
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_reference<_Tp&> {typedef _LIBCPP_NODEBUG_TYPE _Tp type;};
|
||||
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_reference<_Tp&&> {typedef _LIBCPP_NODEBUG_TYPE _Tp type;};
|
||||
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_reference {typedef _LIBCPP_NODEBUG _Tp type;};
|
||||
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_reference<_Tp&> {typedef _LIBCPP_NODEBUG _Tp type;};
|
||||
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_reference<_Tp&&> {typedef _LIBCPP_NODEBUG _Tp type;};
|
||||
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
template <class _Tp> using remove_reference_t = typename remove_reference<_Tp>::type;
|
||||
|
|
@ -1343,21 +1343,21 @@ template <class _Tp> using remove_reference_t = typename remove_reference<_Tp>::
|
|||
|
||||
// add_lvalue_reference
|
||||
|
||||
template <class _Tp, bool = __is_referenceable<_Tp>::value> struct __add_lvalue_reference_impl { typedef _LIBCPP_NODEBUG_TYPE _Tp type; };
|
||||
template <class _Tp > struct __add_lvalue_reference_impl<_Tp, true> { typedef _LIBCPP_NODEBUG_TYPE _Tp& type; };
|
||||
template <class _Tp, bool = __is_referenceable<_Tp>::value> struct __add_lvalue_reference_impl { typedef _LIBCPP_NODEBUG _Tp type; };
|
||||
template <class _Tp > struct __add_lvalue_reference_impl<_Tp, true> { typedef _LIBCPP_NODEBUG _Tp& type; };
|
||||
|
||||
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS add_lvalue_reference
|
||||
{typedef _LIBCPP_NODEBUG_TYPE typename __add_lvalue_reference_impl<_Tp>::type type;};
|
||||
{typedef _LIBCPP_NODEBUG typename __add_lvalue_reference_impl<_Tp>::type type;};
|
||||
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
template <class _Tp> using add_lvalue_reference_t = typename add_lvalue_reference<_Tp>::type;
|
||||
#endif
|
||||
|
||||
template <class _Tp, bool = __is_referenceable<_Tp>::value> struct __add_rvalue_reference_impl { typedef _LIBCPP_NODEBUG_TYPE _Tp type; };
|
||||
template <class _Tp > struct __add_rvalue_reference_impl<_Tp, true> { typedef _LIBCPP_NODEBUG_TYPE _Tp&& type; };
|
||||
template <class _Tp, bool = __is_referenceable<_Tp>::value> struct __add_rvalue_reference_impl { typedef _LIBCPP_NODEBUG _Tp type; };
|
||||
template <class _Tp > struct __add_rvalue_reference_impl<_Tp, true> { typedef _LIBCPP_NODEBUG _Tp&& type; };
|
||||
|
||||
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS add_rvalue_reference
|
||||
{typedef _LIBCPP_NODEBUG_TYPE typename __add_rvalue_reference_impl<_Tp>::type type;};
|
||||
{typedef _LIBCPP_NODEBUG typename __add_rvalue_reference_impl<_Tp>::type type;};
|
||||
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
template <class _Tp> using add_rvalue_reference_t = typename add_rvalue_reference<_Tp>::type;
|
||||
|
|
@ -1378,17 +1378,17 @@ declval() _NOEXCEPT;
|
|||
|
||||
template <class _Tp>
|
||||
struct __uncvref {
|
||||
typedef _LIBCPP_NODEBUG_TYPE typename remove_cv<typename remove_reference<_Tp>::type>::type type;
|
||||
typedef _LIBCPP_NODEBUG typename remove_cv<typename remove_reference<_Tp>::type>::type type;
|
||||
};
|
||||
|
||||
template <class _Tp>
|
||||
struct __unconstref {
|
||||
typedef _LIBCPP_NODEBUG_TYPE typename remove_const<typename remove_reference<_Tp>::type>::type type;
|
||||
typedef _LIBCPP_NODEBUG typename remove_const<typename remove_reference<_Tp>::type>::type type;
|
||||
};
|
||||
|
||||
#ifndef _LIBCPP_CXX03_LANG
|
||||
template <class _Tp>
|
||||
using __uncvref_t _LIBCPP_NODEBUG_TYPE = typename __uncvref<_Tp>::type;
|
||||
using __uncvref_t _LIBCPP_NODEBUG = typename __uncvref<_Tp>::type;
|
||||
#endif
|
||||
|
||||
// __is_same_uncvref
|
||||
|
|
@ -1413,11 +1413,11 @@ struct __any
|
|||
|
||||
// remove_pointer
|
||||
|
||||
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_pointer {typedef _LIBCPP_NODEBUG_TYPE _Tp type;};
|
||||
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_pointer<_Tp*> {typedef _LIBCPP_NODEBUG_TYPE _Tp type;};
|
||||
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_pointer<_Tp* const> {typedef _LIBCPP_NODEBUG_TYPE _Tp type;};
|
||||
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_pointer<_Tp* volatile> {typedef _LIBCPP_NODEBUG_TYPE _Tp type;};
|
||||
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_pointer<_Tp* const volatile> {typedef _LIBCPP_NODEBUG_TYPE _Tp type;};
|
||||
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_pointer {typedef _LIBCPP_NODEBUG _Tp type;};
|
||||
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_pointer<_Tp*> {typedef _LIBCPP_NODEBUG _Tp type;};
|
||||
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_pointer<_Tp* const> {typedef _LIBCPP_NODEBUG _Tp type;};
|
||||
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_pointer<_Tp* volatile> {typedef _LIBCPP_NODEBUG _Tp type;};
|
||||
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_pointer<_Tp* const volatile> {typedef _LIBCPP_NODEBUG _Tp type;};
|
||||
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
template <class _Tp> using remove_pointer_t = typename remove_pointer<_Tp>::type;
|
||||
|
|
@ -1429,12 +1429,12 @@ template <class _Tp,
|
|||
bool = __is_referenceable<_Tp>::value ||
|
||||
_IsSame<typename remove_cv<_Tp>::type, void>::value>
|
||||
struct __add_pointer_impl
|
||||
{typedef _LIBCPP_NODEBUG_TYPE typename remove_reference<_Tp>::type* type;};
|
||||
{typedef _LIBCPP_NODEBUG typename remove_reference<_Tp>::type* type;};
|
||||
template <class _Tp> struct __add_pointer_impl<_Tp, false>
|
||||
{typedef _LIBCPP_NODEBUG_TYPE _Tp type;};
|
||||
{typedef _LIBCPP_NODEBUG _Tp type;};
|
||||
|
||||
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS add_pointer
|
||||
{typedef _LIBCPP_NODEBUG_TYPE typename __add_pointer_impl<_Tp>::type type;};
|
||||
{typedef _LIBCPP_NODEBUG typename __add_pointer_impl<_Tp>::type type;};
|
||||
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
template <class _Tp> using add_pointer_t = typename add_pointer<_Tp>::type;
|
||||
|
|
@ -1621,13 +1621,13 @@ bool is_unbounded_array_v = is_unbounded_array<_Tp>::value;
|
|||
|
||||
template <class _Up, bool>
|
||||
struct __decay {
|
||||
typedef _LIBCPP_NODEBUG_TYPE typename remove_cv<_Up>::type type;
|
||||
typedef _LIBCPP_NODEBUG typename remove_cv<_Up>::type type;
|
||||
};
|
||||
|
||||
template <class _Up>
|
||||
struct __decay<_Up, true> {
|
||||
public:
|
||||
typedef _LIBCPP_NODEBUG_TYPE typename conditional
|
||||
typedef _LIBCPP_NODEBUG typename conditional
|
||||
<
|
||||
is_array<_Up>::value,
|
||||
typename remove_extent<_Up>::type*,
|
||||
|
|
@ -1644,9 +1644,9 @@ template <class _Tp>
|
|||
struct _LIBCPP_TEMPLATE_VIS decay
|
||||
{
|
||||
private:
|
||||
typedef _LIBCPP_NODEBUG_TYPE typename remove_reference<_Tp>::type _Up;
|
||||
typedef _LIBCPP_NODEBUG typename remove_reference<_Tp>::type _Up;
|
||||
public:
|
||||
typedef _LIBCPP_NODEBUG_TYPE typename __decay<_Up, __is_referenceable<_Up>::value>::type type;
|
||||
typedef _LIBCPP_NODEBUG typename __decay<_Up, __is_referenceable<_Up>::value>::type type;
|
||||
};
|
||||
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
|
|
@ -2214,26 +2214,26 @@ template <class _TypeList, size_t _Size, bool = _Size <= sizeof(typename _TypeLi
|
|||
template <class _Hp, class _Tp, size_t _Size>
|
||||
struct __find_first<__type_list<_Hp, _Tp>, _Size, true>
|
||||
{
|
||||
typedef _LIBCPP_NODEBUG_TYPE _Hp type;
|
||||
typedef _LIBCPP_NODEBUG _Hp type;
|
||||
};
|
||||
|
||||
template <class _Hp, class _Tp, size_t _Size>
|
||||
struct __find_first<__type_list<_Hp, _Tp>, _Size, false>
|
||||
{
|
||||
typedef _LIBCPP_NODEBUG_TYPE typename __find_first<_Tp, _Size>::type type;
|
||||
typedef _LIBCPP_NODEBUG 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 _LIBCPP_NODEBUG_TYPE _Up type;
|
||||
typedef _LIBCPP_NODEBUG _Up type;
|
||||
};
|
||||
|
||||
template <class _Tp, class _Up>
|
||||
struct __apply_cv<_Tp, _Up, true, false>
|
||||
{
|
||||
typedef _LIBCPP_NODEBUG_TYPE const _Up type;
|
||||
typedef _LIBCPP_NODEBUG const _Up type;
|
||||
};
|
||||
|
||||
template <class _Tp, class _Up>
|
||||
|
|
@ -2379,7 +2379,7 @@ struct __common_type2_imp<_Tp, _Up,
|
|||
true ? declval<_Tp>() : declval<_Up>()
|
||||
)>::type>
|
||||
{
|
||||
typedef _LIBCPP_NODEBUG_TYPE typename decay<decltype(
|
||||
typedef _LIBCPP_NODEBUG typename decay<decltype(
|
||||
true ? declval<_Tp>() : declval<_Up>()
|
||||
)>::type type;
|
||||
};
|
||||
|
|
@ -2672,7 +2672,7 @@ template <class...> struct common_reference {};
|
|||
|
||||
// is_assignable
|
||||
|
||||
template<typename, typename _Tp> struct __select_2nd { typedef _LIBCPP_NODEBUG_TYPE _Tp type; };
|
||||
template<typename, typename _Tp> struct __select_2nd { typedef _LIBCPP_NODEBUG _Tp type; };
|
||||
|
||||
#if __has_keyword(__is_assignable)
|
||||
|
||||
|
|
|
|||
|
|
@ -1196,11 +1196,11 @@ struct __narrowing_check {
|
|||
template <class _Dest>
|
||||
static auto __test_impl(_Dest (&&)[1]) -> __identity<_Dest>;
|
||||
template <class _Dest, class _Source>
|
||||
using _Apply _LIBCPP_NODEBUG_TYPE = decltype(__test_impl<_Dest>({declval<_Source>()}));
|
||||
using _Apply _LIBCPP_NODEBUG = decltype(__test_impl<_Dest>({declval<_Source>()}));
|
||||
};
|
||||
|
||||
template <class _Dest, class _Source>
|
||||
using __check_for_narrowing _LIBCPP_NODEBUG_TYPE =
|
||||
using __check_for_narrowing _LIBCPP_NODEBUG =
|
||||
typename _If<
|
||||
#ifdef _LIBCPP_ENABLE_NARROWING_CONVERSIONS_IN_VARIANT
|
||||
false &&
|
||||
|
|
@ -1244,11 +1244,11 @@ struct __make_overloads_imp;
|
|||
template <size_t ..._Idx>
|
||||
struct __make_overloads_imp<__tuple_indices<_Idx...> > {
|
||||
template <class ..._Types>
|
||||
using _Apply _LIBCPP_NODEBUG_TYPE = __all_overloads<__overload<_Types, _Idx>...>;
|
||||
using _Apply _LIBCPP_NODEBUG = __all_overloads<__overload<_Types, _Idx>...>;
|
||||
};
|
||||
|
||||
template <class ..._Types>
|
||||
using _MakeOverloads _LIBCPP_NODEBUG_TYPE = typename __make_overloads_imp<
|
||||
using _MakeOverloads _LIBCPP_NODEBUG = typename __make_overloads_imp<
|
||||
__make_indices_imp<sizeof...(_Types), 0> >::template _Apply<_Types...>;
|
||||
|
||||
template <class _Tp, class... _Types>
|
||||
|
|
|
|||
Loading…
Reference in New Issue