This is an archive of the discontinued LLVM Phabricator instance.

Differential D132785

[libc++] Avoid instantiating type_trait classes
ClosedPublic

Authored by philnik on Aug 27 2022, 1:21 AM.

Details

Reviewers
ldionne
Mordante
var-const
huixie90
Group Reviewers
Restricted Project
Commits
rG5fab33af7f08: [libc++] Avoid instantiating type_trait classes
Summary

Use using aliases to avoid instantiating lots of types

Diff Detail

Unit TestsFailed

TimeTest
1,970 mslibcxx CI No transitive includes > llvm-libc++-shared-cfg-in.libcxx::modules_include.sh.cpp

Event Timeline

philnik created this revision.Aug 27 2022, 1:21 AM
Herald added a project: Restricted Project. · View Herald TranscriptAug 27 2022, 1:21 AM
Herald added a subscriber: miyuki. · View Herald Transcript
philnik requested review of this revision.Aug 27 2022, 1:21 AM
Herald added a project: Restricted Project. · View Herald TranscriptAug 27 2022, 1:21 AM
Herald added a reviewer: Restricted Project. · View Herald Transcript
Herald added a subscriber: libcxx-commits. · View Herald Transcript
Harbormaster completed remote builds in B183734: Diff 456095.Aug 27 2022, 1:22 AM
philnik updated this revision to Diff 456096.Aug 27 2022, 1:26 AM

Rebased

Harbormaster completed remote builds in B183735: Diff 456096.Aug 27 2022, 2:31 AM
philnik updated this revision to Diff 457218.Sep 1 2022, 3:27 AM
  • Try to fix CI
Harbormaster completed remote builds in B184545: Diff 457218.Sep 1 2022, 4:49 AM
ldionne accepted this revision.Sep 2 2022, 9:45 AM

LGTM assuming fixing the GCC issues don't require any significant changes. My preference would actually be to rewrite the SFINAE in a separate patch prior to this one, so that this one doesn't need to change at all. If you do that, ping me on Discord so I can fast track it.

This revision is now accepted and ready to land.Sep 2 2022, 9:45 AM
philnik updated this revision to Diff 458058.Sep 5 2022, 3:35 PM
  • Fix GCC
philnik added a comment.Sep 5 2022, 3:37 PM
In D132785#3767230, @ldionne wrote:

LGTM assuming fixing the GCC issues don't require any significant changes. My preference would actually be to rewrite the SFINAE in a separate patch prior to this one, so that this one doesn't need to change at all. If you do that, ping me on Discord so I can fast track it.

It was just replacing _IsSame<typename remove_cv<_Tp>::type, void>::value with is_void<_Tp>::value, so I don't think it's worth an extra PR.

Harbormaster completed remote builds in B185148: Diff 458058.Sep 5 2022, 5:59 PM
philnik updated this revision to Diff 458182.Sep 6 2022, 8:34 AM

Rebased

Harbormaster completed remote builds in B185230: Diff 458182.Sep 6 2022, 10:05 AM
Closed by commit rG5fab33af7f08: [libc++] Avoid instantiating type_trait classes (authored by philnik). · Explain WhySep 6 2022, 10:09 AM
This revision was automatically updated to reflect the committed changes.
philnik added a commit: rG5fab33af7f08: [libc++] Avoid instantiating type_trait classes.

Revision Contents

PathSize
libcxx/
include/
__algorithm/
4 lines
2 lines
10 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
__concepts/
2 lines
__coroutine/
2 lines
__filesystem/
6 lines
__functional/
12 lines
2 lines
2 lines
26 lines
__iterator/
2 lines
4 lines
2 lines
__memory/
2 lines
2 lines
9 lines
8 lines
2 lines
6 lines
4 lines
__numeric/
8 lines
__random/
2 lines
2 lines
6 lines
22 lines
16 lines
__type_traits/
24 lines
23 lines
25 lines
4 lines
6 lines
4 lines
8 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
4 lines
4 lines
2 lines
2 lines
8 lines
4 lines
2 lines
3 lines
2 lines
2 lines
2 lines
19 lines
25 lines
8 lines
8 lines
4 lines
10 lines
11 lines
8 lines
8 lines
8 lines
8 lines
__utility/
4 lines
4 lines
4 lines
8 lines
12 lines
experimental/
2 lines
2 lines
4 lines
8 lines
ext/
4 lines
17 lines
2 lines
16 lines
4 lines
8 lines
12 lines
2 lines
2 lines
18 lines
4 lines
2 lines
37 lines
12 lines
24 lines
src/
4 lines
test/
std/
utilities/
meta/
meta.unary/
168 lines

Diff 458058

libcxx/include/__algorithm/copy.h

Show All 34 Lines while (__first != __last) {
++__first; ++__first;
++__result; ++__result;
} }
return pair<_InIter, _OutIter>(std::move(__first), std::move(__result)); return pair<_InIter, _OutIter>(std::move(__first), std::move(__result));
} }
template <class _InValueT, template <class _InValueT,
class _OutValueT, class _OutValueT,
class = __enable_if_t<is_same<typename remove_const<_InValueT>::type, _OutValueT>::value class = __enable_if_t<is_same<__remove_const_t<_InValueT>, _OutValueT>::value
&& is_trivially_copy_assignable<_OutValueT>::value> > && is_trivially_copy_assignable<_OutValueT>::value> >
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
pair<_InValueT*, _OutValueT*> __copy_impl(_InValueT* __first, _InValueT* __last, _OutValueT* __result) { pair<_InValueT*, _OutValueT*> __copy_impl(_InValueT* __first, _InValueT* __last, _OutValueT* __result) {
if (__libcpp_is_constant_evaluated() if (__libcpp_is_constant_evaluated()
// TODO: Remove this once GCC supports __builtin_memmove during constant evaluation // TODO: Remove this once GCC supports __builtin_memmove during constant evaluation
#ifndef _LIBCPP_COMPILER_GCC #ifndef _LIBCPP_COMPILER_GCC
&& !is_trivially_copyable<_InValueT>::value && !is_trivially_copyable<_InValueT>::value
#endif #endif
) )
return std::__copy_impl<_InValueT*, _InValueT*, _OutValueT*>(__first, __last, __result); return std::__copy_impl<_InValueT*, _InValueT*, _OutValueT*>(__first, __last, __result);
const size_t __n = static_cast<size_t>(__last - __first); const size_t __n = static_cast<size_t>(__last - __first);
if (__n > 0) if (__n > 0)
::__builtin_memmove(__result, __first, __n * sizeof(_OutValueT)); ::__builtin_memmove(__result, __first, __n * sizeof(_OutValueT));
return std::make_pair(__first + __n, __result + __n); return std::make_pair(__first + __n, __result + __n);
} }
template <class _InIter, class _OutIter, template <class _InIter, class _OutIter,
__enable_if_t<is_same<typename remove_const<__iter_value_type<_InIter> >::type, __iter_value_type<_OutIter> >::value __enable_if_t<is_same<__remove_const_t<__iter_value_type<_InIter> >, __iter_value_type<_OutIter> >::value
&& __is_cpp17_contiguous_iterator<typename _InIter::iterator_type>::value && __is_cpp17_contiguous_iterator<typename _InIter::iterator_type>::value
&& __is_cpp17_contiguous_iterator<typename _OutIter::iterator_type>::value && __is_cpp17_contiguous_iterator<typename _OutIter::iterator_type>::value
&& is_trivially_copy_assignable<__iter_value_type<_OutIter> >::value && is_trivially_copy_assignable<__iter_value_type<_OutIter> >::value
&& __is_reverse_iterator<_InIter>::value && __is_reverse_iterator<_InIter>::value
&& __is_reverse_iterator<_OutIter>::value, int> = 0> && __is_reverse_iterator<_OutIter>::value, int> = 0>
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
pair<_InIter, _OutIter> pair<_InIter, _OutIter>
__copy_impl(_InIter __first, _InIter __last, _OutIter __result) { __copy_impl(_InIter __first, _InIter __last, _OutIter __result) {
Show All 39 Lines

libcxx/include/__algorithm/half_positive.h

Show All 23 Lines
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
typename enable_if typename enable_if
< <
is_integral<_Integral>::value, is_integral<_Integral>::value,
_Integral _Integral
>::type >::type
__half_positive(_Integral __value) __half_positive(_Integral __value)
{ {
return static_cast<_Integral>(static_cast<typename make_unsigned<_Integral>::type>(__value) / 2); return static_cast<_Integral>(static_cast<__make_unsigned_t<_Integral> >(__value) / 2);
} }
template <typename _Tp> template <typename _Tp>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
typename enable_if typename enable_if
< <
!is_integral<_Tp>::value, !is_integral<_Tp>::value,
_Tp _Tp
Show All 9 Lines

libcxx/include/__algorithm/iterator_operations.h

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Linesstruct _IterOps<_ClassicAlgPolicy> {
using __deref_t = decltype(*std::declval<_Iter&>()); using __deref_t = decltype(*std::declval<_Iter&>());
template <class _Iter> template <class _Iter>
using __move_t = decltype(std::move(*std::declval<_Iter&>())); using __move_t = decltype(std::move(*std::declval<_Iter&>()));
template <class _Iter> template <class _Iter>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
static void __validate_iter_reference() { static void __validate_iter_reference() {
static_assert(is_same<__deref_t<_Iter>, typename iterator_traits<__uncvref_t<_Iter> >::reference>::value, static_assert(is_same<__deref_t<_Iter>, typename iterator_traits<__remove_cvref_t<_Iter> >::reference>::value,
"It looks like your iterator's `iterator_traits<It>::reference` does not match the return type of " "It looks like your iterator's `iterator_traits<It>::reference` does not match the return type of "
"dereferencing the iterator, i.e., calling `*it`. This is undefined behavior according to [input.iterators] " "dereferencing the iterator, i.e., calling `*it`. This is undefined behavior according to [input.iterators] "
"and can lead to dangling reference issues at runtime, so we are flagging this."); "and can lead to dangling reference issues at runtime, so we are flagging this.");
} }
// iter_move // iter_move
template <class _Iter> template <class _Iter>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 static _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 static
Show All 33 Linesstruct _IterOps<_ClassicAlgPolicy> {
template <class _Iterator> template <class _Iterator>
_LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR_SINCE_CXX14
_Iterator next(_Iterator, _Iterator __last) { _Iterator next(_Iterator, _Iterator __last) {
return __last; return __last;
} }
template <class _Iter> template <class _Iter>
_LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR_SINCE_CXX14
__uncvref_t<_Iter> next(_Iter&& __it, __remove_cvref_t<_Iter> next(_Iter&& __it,
typename iterator_traits<__uncvref_t<_Iter> >::difference_type __n = 1) { typename iterator_traits<__remove_cvref_t<_Iter> >::difference_type __n = 1) {
return std::next(std::forward<_Iter>(__it), __n); return std::next(std::forward<_Iter>(__it), __n);
} }
// prev // prev
template <class _Iter> template <class _Iter>
_LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR_SINCE_CXX14
__uncvref_t<_Iter> prev(_Iter&& __iter, __remove_cvref_t<_Iter> prev(_Iter&& __iter,
typename iterator_traits<__uncvref_t<_Iter> >::difference_type __n = 1) { typename iterator_traits<__remove_cvref_t<_Iter> >::difference_type __n = 1) {
return std::prev(std::forward<_Iter>(__iter), __n); return std::prev(std::forward<_Iter>(__iter), __n);
} }
template <class _Iter> template <class _Iter>
_LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR_SINCE_CXX14
void __advance_to(_Iter& __first, _Iter __last) { void __advance_to(_Iter& __first, _Iter __last) {
__first = __last; __first = __last;
} }
}; };
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_ITERATOR_OPERATIONS_H #endif // _LIBCPP___ALGORITHM_ITERATOR_OPERATIONS_H

libcxx/include/__algorithm/move.h

Show All 35 Lines while (__first != __last) {
++__result; ++__result;
} }
return std::make_pair(std::move(__first), std::move(__result)); return std::make_pair(std::move(__first), std::move(__result));
} }
template <class _AlgPolicy, template <class _AlgPolicy,
class _InType, class _InType,
class _OutType, class _OutType,
class = __enable_if_t<is_same<typename remove_const<_InType>::type, _OutType>::value class = __enable_if_t<is_same<__remove_const_t<_InType>, _OutType>::value
&& is_trivially_move_assignable<_OutType>::value> > && is_trivially_move_assignable<_OutType>::value> >
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
pair<_InType*, _OutType*> __move_impl(_InType* __first, _InType* __last, _OutType* __result) { pair<_InType*, _OutType*> __move_impl(_InType* __first, _InType* __last, _OutType* __result) {
if (__libcpp_is_constant_evaluated() if (__libcpp_is_constant_evaluated()
// TODO: Remove this once GCC supports __builtin_memmove during constant evaluation // TODO: Remove this once GCC supports __builtin_memmove during constant evaluation
#ifndef _LIBCPP_COMPILER_GCC #ifndef _LIBCPP_COMPILER_GCC
&& !is_trivially_copyable<_InType>::value && !is_trivially_copyable<_InType>::value
#endif #endif
Show All 12 Lines
template <class _Iter> template <class _Iter>
struct __is_trivially_move_assignable_unwrapped struct __is_trivially_move_assignable_unwrapped
: __is_trivially_move_assignable_unwrapped_impl<decltype(std::__unwrap_iter<_Iter>(std::declval<_Iter>()))> {}; : __is_trivially_move_assignable_unwrapped_impl<decltype(std::__unwrap_iter<_Iter>(std::declval<_Iter>()))> {};
template <class _AlgPolicy, template <class _AlgPolicy,
class _InIter, class _InIter,
class _OutIter, class _OutIter,
__enable_if_t<is_same<typename remove_const<typename iterator_traits<_InIter>::value_type>::type, __enable_if_t<is_same<__remove_const_t<typename iterator_traits<_InIter>::value_type>,
typename iterator_traits<_OutIter>::value_type>::value typename iterator_traits<_OutIter>::value_type>::value
&& __is_cpp17_contiguous_iterator<_InIter>::value && __is_cpp17_contiguous_iterator<_InIter>::value
&& __is_cpp17_contiguous_iterator<_OutIter>::value && __is_cpp17_contiguous_iterator<_OutIter>::value
&& is_trivially_move_assignable<__iter_value_type<_OutIter> >::value, int> = 0> && is_trivially_move_assignable<__iter_value_type<_OutIter> >::value, int> = 0>
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
pair<reverse_iterator<_InIter>, reverse_iterator<_OutIter> > pair<reverse_iterator<_InIter>, reverse_iterator<_OutIter> >
__move_impl(reverse_iterator<_InIter> __first, __move_impl(reverse_iterator<_InIter> __first,
reverse_iterator<_InIter> __last, reverse_iterator<_InIter> __last,
Show All 38 Lines

libcxx/include/__algorithm/move_backward.h

Show All 38 Lines
{ {
return _VSTD::__move_backward_constexpr<_AlgPolicy>(__first, __last, __result); return _VSTD::__move_backward_constexpr<_AlgPolicy>(__first, __last, __result);
} }
template <class _AlgPolicy, class _Tp, class _Up> template <class _AlgPolicy, class _Tp, class _Up>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
typename enable_if typename enable_if
< <
is_same<typename remove_const<_Tp>::type, _Up>::value && is_same<__remove_const_t<_Tp>, _Up>::value &&
is_trivially_move_assignable<_Up>::value, is_trivially_move_assignable<_Up>::value,
_Up* _Up*
>::type >::type
__move_backward_impl(_Tp* __first, _Tp* __last, _Up* __result) __move_backward_impl(_Tp* __first, _Tp* __last, _Up* __result)
{ {
const size_t __n = static_cast<size_t>(__last - __first); const size_t __n = static_cast<size_t>(__last - __first);
if (__n > 0) if (__n > 0)
{ {
Show All 34 Lines

libcxx/include/__algorithm/partition.h

Show First 20 Lines • Show All 73 Lines • ▼ Show 20 Lines while (true)
++__first; ++__first;
} }
} }
template <class _AlgPolicy, class _ForwardIterator, class _Sentinel, class _Predicate, class _IterCategory> template <class _AlgPolicy, class _ForwardIterator, class _Sentinel, class _Predicate, class _IterCategory>
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
pair<_ForwardIterator, _ForwardIterator> __partition( pair<_ForwardIterator, _ForwardIterator> __partition(
_ForwardIterator __first, _Sentinel __last, _Predicate&& __pred, _IterCategory __iter_category) { _ForwardIterator __first, _Sentinel __last, _Predicate&& __pred, _IterCategory __iter_category) {
return std::__partition_impl<__uncvref_t<_Predicate>&, _AlgPolicy>( return std::__partition_impl<__remove_cvref_t<_Predicate>&, _AlgPolicy>(
std::move(__first), std::move(__last), __pred, __iter_category); std::move(__first), std::move(__last), __pred, __iter_category);
} }
template <class _ForwardIterator, class _Predicate> template <class _ForwardIterator, class _Predicate>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
_ForwardIterator _ForwardIterator
partition(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) partition(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred)
{ {
using _IterCategory = typename iterator_traits<_ForwardIterator>::iterator_category; using _IterCategory = typename iterator_traits<_ForwardIterator>::iterator_category;
auto __result = std::__partition<_ClassicAlgPolicy>(std::move(__first), std::move(__last), __pred, _IterCategory()); auto __result = std::__partition<_ClassicAlgPolicy>(std::move(__first), std::move(__last), __pred, _IterCategory());
return __result.first; return __result.first;
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_PARTITION_H #endif // _LIBCPP___ALGORITHM_PARTITION_H

libcxx/include/__algorithm/ranges_iterator_concept.h

Show All 20 Lines
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER > 17
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
template <class _IterMaybeQualified> template <class _IterMaybeQualified>
consteval auto __get_iterator_concept() { consteval auto __get_iterator_concept() {
using _Iter = __uncvref_t<_IterMaybeQualified>; using _Iter = __remove_cvref_t<_IterMaybeQualified>;
if constexpr (contiguous_iterator<_Iter>) if constexpr (contiguous_iterator<_Iter>)
return contiguous_iterator_tag(); return contiguous_iterator_tag();
else if constexpr (random_access_iterator<_Iter>) else if constexpr (random_access_iterator<_Iter>)
return random_access_iterator_tag(); return random_access_iterator_tag();
else if constexpr (bidirectional_iterator<_Iter>) else if constexpr (bidirectional_iterator<_Iter>)
return bidirectional_iterator_tag(); return bidirectional_iterator_tag();
else if constexpr (forward_iterator<_Iter>) else if constexpr (forward_iterator<_Iter>)
Show All 14 Lines

libcxx/include/__algorithm/ranges_merge.h

Show First 20 Lines • Show All 41 Lines • ▼ Show 20 Linestemplate <
class _InIter1, class _InIter1,
class _Sent1, class _Sent1,
class _InIter2, class _InIter2,
class _Sent2, class _Sent2,
class _OutIter, class _OutIter,
class _Comp, class _Comp,
class _Proj1, class _Proj1,
class _Proj2> class _Proj2>
_LIBCPP_HIDE_FROM_ABI constexpr merge_result<__uncvref_t<_InIter1>, __uncvref_t<_InIter2>, __uncvref_t<_OutIter>> _LIBCPP_HIDE_FROM_ABI constexpr merge_result<__remove_cvref_t<_InIter1>, __remove_cvref_t<_InIter2>, __remove_cvref_t<_OutIter>>
__merge_impl( __merge_impl(
_InIter1&& __first1, _InIter1&& __first1,
_Sent1&& __last1, _Sent1&& __last1,
_InIter2&& __first2, _InIter2&& __first2,
_Sent2&& __last2, _Sent2&& __last2,
_OutIter&& __result, _OutIter&& __result,
_Comp&& __comp, _Comp&& __comp,
_Proj1&& __proj1, _Proj1&& __proj1,
▲ Show 20 Lines • Show All 84 Lines • Show Last 20 Lines

libcxx/include/__algorithm/ranges_partition.h

Show All 37 Lines
namespace ranges { namespace ranges {
namespace __partition { namespace __partition {
struct __fn { struct __fn {
template <class _Iter, class _Sent, class _Proj, class _Pred> template <class _Iter, class _Sent, class _Proj, class _Pred>
_LIBCPP_HIDE_FROM_ABI static constexpr _LIBCPP_HIDE_FROM_ABI static constexpr
subrange<__uncvref_t<_Iter>> __partition_fn_impl(_Iter&& __first, _Sent&& __last, _Pred&& __pred, _Proj&& __proj) { subrange<__remove_cvref_t<_Iter>> __partition_fn_impl(_Iter&& __first, _Sent&& __last, _Pred&& __pred, _Proj&& __proj) {
auto&& __projected_pred = std::__make_projected(__pred, __proj); auto&& __projected_pred = std::__make_projected(__pred, __proj);
auto __result = std::__partition<_RangeAlgPolicy>( auto __result = std::__partition<_RangeAlgPolicy>(
std::move(__first), std::move(__last), __projected_pred, __iterator_concept<_Iter>()); std::move(__first), std::move(__last), __projected_pred, __iterator_concept<_Iter>());
return {std::move(__result.first), std::move(__result.second)}; return {std::move(__result.first), std::move(__result.second)};
} }
template <permutable _Iter, sentinel_for<_Iter> _Sent, class _Proj = identity, template <permutable _Iter, sentinel_for<_Iter> _Sent, class _Proj = identity,
Show All 28 Lines

libcxx/include/__algorithm/ranges_partition_copy.h

Show All 37 Lines
namespace __partition_copy { namespace __partition_copy {
struct __fn { struct __fn {
// TODO(ranges): delegate to the classic algorithm. // TODO(ranges): delegate to the classic algorithm.
template <class _InIter, class _Sent, class _OutIter1, class _OutIter2, class _Proj, class _Pred> template <class _InIter, class _Sent, class _OutIter1, class _OutIter2, class _Proj, class _Pred>
_LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_HIDE_FROM_ABI constexpr
static partition_copy_result< static partition_copy_result<
__uncvref_t<_InIter>, __uncvref_t<_OutIter1>, __uncvref_t<_OutIter2> __remove_cvref_t<_InIter>, __remove_cvref_t<_OutIter1>, __remove_cvref_t<_OutIter2>
> __partition_copy_fn_impl( _InIter&& __first, _Sent&& __last, _OutIter1&& __out_true, _OutIter2&& __out_false, > __partition_copy_fn_impl( _InIter&& __first, _Sent&& __last, _OutIter1&& __out_true, _OutIter2&& __out_false,
_Pred& __pred, _Proj& __proj) { _Pred& __pred, _Proj& __proj) {
for (; __first != __last; ++__first) { for (; __first != __last; ++__first) {
if (std::invoke(__pred, std::invoke(__proj, *__first))) { if (std::invoke(__pred, std::invoke(__proj, *__first))) {
*__out_true = *__first; *__out_true = *__first;
++__out_true; ++__out_true;
} else { } else {
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

libcxx/include/__algorithm/ranges_stable_partition.h

Show All 39 Lines
namespace ranges { namespace ranges {
namespace __stable_partition { namespace __stable_partition {
struct __fn { struct __fn {
template <class _Iter, class _Sent, class _Proj, class _Pred> template <class _Iter, class _Sent, class _Proj, class _Pred>
_LIBCPP_HIDE_FROM_ABI static _LIBCPP_HIDE_FROM_ABI static
subrange<__uncvref_t<_Iter>> __stable_partition_fn_impl( subrange<__remove_cvref_t<_Iter>> __stable_partition_fn_impl(
_Iter&& __first, _Sent&& __last, _Pred&& __pred, _Proj&& __proj) { _Iter&& __first, _Sent&& __last, _Pred&& __pred, _Proj&& __proj) {
auto __last_iter = ranges::next(__first, __last); auto __last_iter = ranges::next(__first, __last);
auto&& __projected_pred = std::__make_projected(__pred, __proj); auto&& __projected_pred = std::__make_projected(__pred, __proj);
auto __result = std::__stable_partition<_RangeAlgPolicy>( auto __result = std::__stable_partition<_RangeAlgPolicy>(
std::move(__first), __last_iter, __projected_pred, __iterator_concept<_Iter>()); std::move(__first), __last_iter, __projected_pred, __iterator_concept<_Iter>());
return {std::move(__result), std::move(__last_iter)}; return {std::move(__result), std::move(__last_iter)};
Show All 32 Lines

libcxx/include/__algorithm/set_difference.h

Show All 21 Lines
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template < class _Comp, class _InIter1, class _Sent1, class _InIter2, class _Sent2, class _OutIter> template < class _Comp, class _InIter1, class _Sent1, class _InIter2, class _Sent2, class _OutIter>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 pair<__uncvref_t<_InIter1>, __uncvref_t<_OutIter> > _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 pair<__remove_cvref_t<_InIter1>, __remove_cvref_t<_OutIter> >
__set_difference( __set_difference(
_InIter1&& __first1, _Sent1&& __last1, _InIter2&& __first2, _Sent2&& __last2, _OutIter&& __result, _Comp&& __comp) { _InIter1&& __first1, _Sent1&& __last1, _InIter2&& __first2, _Sent2&& __last2, _OutIter&& __result, _Comp&& __comp) {
while (__first1 != __last1 && __first2 != __last2) { while (__first1 != __last1 && __first2 != __last2) {
if (__comp(*__first1, *__first2)) { if (__comp(*__first1, *__first2)) {
*__result = *__first1; *__result = *__first1;
++__first1; ++__first1;
++__result; ++__result;
} else if (__comp(*__first2, *__first1)) { } else if (__comp(*__first2, *__first1)) {
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

libcxx/include/__algorithm/stable_partition.h

Show First 20 Lines • Show All 299 Lines • ▼ Show 20 Lines_LIBCPP_SUPPRESS_DEPRECATED_POP
return std::__stable_partition_impl<_AlgPolicy, _Predicate&>( return std::__stable_partition_impl<_AlgPolicy, _Predicate&>(
std::move(__first), std::move(__last), __pred, __len, __p, bidirectional_iterator_tag()); std::move(__first), std::move(__last), __pred, __len, __p, bidirectional_iterator_tag());
} }
template <class _AlgPolicy, class _Predicate, class _ForwardIterator, class _IterCategory> template <class _AlgPolicy, class _Predicate, class _ForwardIterator, class _IterCategory>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
_ForwardIterator __stable_partition( _ForwardIterator __stable_partition(
_ForwardIterator __first, _ForwardIterator __last, _Predicate&& __pred, _IterCategory __iter_category) { _ForwardIterator __first, _ForwardIterator __last, _Predicate&& __pred, _IterCategory __iter_category) {
return std::__stable_partition_impl<_AlgPolicy, __uncvref_t<_Predicate>&>( return std::__stable_partition_impl<_AlgPolicy, __remove_cvref_t<_Predicate>&>(
std::move(__first), std::move(__last), __pred, __iter_category); std::move(__first), std::move(__last), __pred, __iter_category);
} }
template <class _ForwardIterator, class _Predicate> template <class _ForwardIterator, class _Predicate>
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
_ForwardIterator _ForwardIterator
stable_partition(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) stable_partition(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred)
{ {
using _IterCategory = typename iterator_traits<_ForwardIterator>::iterator_category; using _IterCategory = typename iterator_traits<_ForwardIterator>::iterator_category;
return std::__stable_partition<_ClassicAlgPolicy, _Predicate&>( return std::__stable_partition<_ClassicAlgPolicy, _Predicate&>(
std::move(__first), std::move(__last), __pred, _IterCategory()); std::move(__first), std::move(__last), __pred, _IterCategory());
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_STABLE_PARTITION_H #endif // _LIBCPP___ALGORITHM_STABLE_PARTITION_H

libcxx/include/__algorithm/uniform_random_bit_generator_adaptor.h

Show All 36 Lines
private: private:
// The generator is not required to be copyable or movable, so it has to be stored as a reference. // The generator is not required to be copyable or movable, so it has to be stored as a reference.
_Gen& __gen; _Gen& __gen;
public: public:
using result_type = invoke_result_t<_Gen&>; using result_type = invoke_result_t<_Gen&>;
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
static constexpr auto min() { return __uncvref_t<_Gen>::min(); } static constexpr auto min() { return __remove_cvref_t<_Gen>::min(); }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
static constexpr auto max() { return __uncvref_t<_Gen>::max(); } static constexpr auto max() { return __remove_cvref_t<_Gen>::max(); }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
constexpr explicit _ClassicGenAdaptor(_Gen& __g) : __gen(__g) {} constexpr explicit _ClassicGenAdaptor(_Gen& __g) : __gen(__g) {}
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
constexpr auto operator()() const { return __gen(); } constexpr auto operator()() const { return __gen(); }
}; };
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
_LIBCPP_POP_MACROS _LIBCPP_POP_MACROS
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER > 17
#endif // _LIBCPP___ALGORITHM_RANGES_UNIFORM_RANDOM_BIT_GENERATOR_ADAPTOR_H #endif // _LIBCPP___ALGORITHM_RANGES_UNIFORM_RANDOM_BIT_GENERATOR_ADAPTOR_H

libcxx/include/__concepts/class_or_enum.h

Show All 22 Lines
// Whether a type is a class type or enumeration type according to the Core wording. // Whether a type is a class type or enumeration type according to the Core wording.
template<class _Tp> template<class _Tp>
concept __class_or_enum = is_class_v<_Tp> || is_union_v<_Tp> || is_enum_v<_Tp>; concept __class_or_enum = is_class_v<_Tp> || is_union_v<_Tp> || is_enum_v<_Tp>;
// Work around Clang bug https://llvm.org/PR52970 // Work around Clang bug https://llvm.org/PR52970
// TODO: remove this workaround once libc++ no longer has to support Clang 13 (it was fixed in Clang 14). // TODO: remove this workaround once libc++ no longer has to support Clang 13 (it was fixed in Clang 14).
template<class _Tp> template<class _Tp>
concept __workaround_52970 = is_class_v<__uncvref_t<_Tp>> || is_union_v<__uncvref_t<_Tp>>; concept __workaround_52970 = is_class_v<__remove_cvref_t<_Tp>> || is_union_v<__remove_cvref_t<_Tp>>;
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER > 17
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___CONCEPTS_CLASS_OR_ENUM_H #endif // _LIBCPP___CONCEPTS_CLASS_OR_ENUM_H

libcxx/include/__coroutine/coroutine_handle.h

Show First 20 Lines • Show All 109 Lines • ▼ Show 20 Linespublic:
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
constexpr coroutine_handle() noexcept = default; constexpr coroutine_handle() noexcept = default;
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
constexpr coroutine_handle(nullptr_t) noexcept {} constexpr coroutine_handle(nullptr_t) noexcept {}
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
static coroutine_handle from_promise(_Promise& __promise) { static coroutine_handle from_promise(_Promise& __promise) {
using _RawPromise = typename remove_cv<_Promise>::type; using _RawPromise = __remove_cv_t<_Promise>;
coroutine_handle __tmp; coroutine_handle __tmp;
__tmp.__handle_ = __tmp.__handle_ =
__builtin_coro_promise(_VSTD::addressof(const_cast<_RawPromise&>(__promise)), alignof(_Promise), true); __builtin_coro_promise(_VSTD::addressof(const_cast<_RawPromise&>(__promise)), alignof(_Promise), true);
return __tmp; return __tmp;
} }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
coroutine_handle& operator=(nullptr_t) noexcept { coroutine_handle& operator=(nullptr_t) noexcept {
▲ Show 20 Lines • Show All 76 Lines • Show Last 20 Lines

libcxx/include/__filesystem/path.h

Show First 20 Lines • Show All 135 Lines • ▼ Show 20 Linesstruct __is_pathable_string<
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
static _ECharT __first_or_null(_Str const& __s) { static _ECharT __first_or_null(_Str const& __s) {
return __s.empty() ? _ECharT{} : __s[0]; return __s.empty() ? _ECharT{} : __s[0];
} }
}; };
template <class _Source, class _DS = typename decay<_Source>::type, template <class _Source, class _DS = typename decay<_Source>::type,
class _UnqualPtrType = class _UnqualPtrType =
typename remove_const<typename remove_pointer<_DS>::type>::type, __remove_const_t<__remove_pointer_t<_DS> >,
bool _IsCharPtr = is_pointer<_DS>::value&& bool _IsCharPtr = is_pointer<_DS>::value&&
__can_convert_char<_UnqualPtrType>::value> __can_convert_char<_UnqualPtrType>::value>
struct __is_pathable_char_array : false_type {}; struct __is_pathable_char_array : false_type {};
template <class _Source, class _ECharT, class _UPtr> template <class _Source, class _ECharT, class _UPtr>
struct __is_pathable_char_array<_Source, _ECharT*, _UPtr, true> struct __is_pathable_char_array<_Source, _ECharT*, _UPtr, true>
: __can_convert_char<typename remove_const<_ECharT>::type> { : __can_convert_char<__remove_const_t<_ECharT> > {
using _Base = __can_convert_char<typename remove_const<_ECharT>::type>; using _Base = __can_convert_char<__remove_const_t<_ECharT> >;
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
static _ECharT const* __range_begin(const _ECharT* __b) { return __b; } static _ECharT const* __range_begin(const _ECharT* __b) { return __b; }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
static _ECharT const* __range_end(const _ECharT* __b) { static _ECharT const* __range_end(const _ECharT* __b) {
using _Iter = const _ECharT*; using _Iter = const _ECharT*;
const _ECharT __sentinel = _ECharT{}; const _ECharT __sentinel = _ECharT{};
▲ Show 20 Lines • Show All 931 Lines • Show Last 20 Lines

libcxx/include/__functional/bind.h

Show All 19 Lines
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template<class _Tp> template<class _Tp>
struct is_bind_expression : _If< struct is_bind_expression : _If<
_IsSame<_Tp, __uncvref_t<_Tp> >::value, _IsSame<_Tp, __remove_cvref_t<_Tp> >::value,
false_type, false_type,
is_bind_expression<__uncvref_t<_Tp> > is_bind_expression<__remove_cvref_t<_Tp> >
> {}; > {};
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER > 14
template <class _Tp> template <class _Tp>
inline constexpr size_t is_bind_expression_v = is_bind_expression<_Tp>::value; inline constexpr size_t is_bind_expression_v = is_bind_expression<_Tp>::value;
#endif #endif
template<class _Tp> template<class _Tp>
struct is_placeholder : _If< struct is_placeholder : _If<
_IsSame<_Tp, __uncvref_t<_Tp> >::value, _IsSame<_Tp, __remove_cvref_t<_Tp> >::value,
integral_constant<int, 0>, integral_constant<int, 0>,
is_placeholder<__uncvref_t<_Tp> > is_placeholder<__remove_cvref_t<_Tp> >
> {}; > {};
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER > 14
template <class _Tp> template <class _Tp>
inline constexpr size_t is_placeholder_v = is_placeholder<_Tp>::value; inline constexpr size_t is_placeholder_v = is_placeholder<_Tp>::value;
#endif #endif
namespace placeholders namespace placeholders
▲ Show 20 Lines • Show All 223 Lines • ▼ Show 20 Linesprivate:
_Td __bound_args_; _Td __bound_args_;
typedef typename __make_tuple_indices<sizeof...(_BoundArgs)>::type __indices; typedef typename __make_tuple_indices<sizeof...(_BoundArgs)>::type __indices;
public: public:
template <class _Gp, class ..._BA, template <class _Gp, class ..._BA,
class = typename enable_if class = typename enable_if
< <
is_constructible<_Fd, _Gp>::value && is_constructible<_Fd, _Gp>::value &&
!is_same<typename remove_reference<_Gp>::type, !is_same<__libcpp_remove_reference_t<_Gp>,
__bind>::value __bind>::value
>::type> >::type>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
explicit __bind(_Gp&& __f, _BA&& ...__bound_args) explicit __bind(_Gp&& __f, _BA&& ...__bound_args)
: __f_(_VSTD::forward<_Gp>(__f)), : __f_(_VSTD::forward<_Gp>(__f)),
__bound_args_(_VSTD::forward<_BA>(__bound_args)...) {} __bound_args_(_VSTD::forward<_BA>(__bound_args)...) {}
template <class ..._Args> template <class ..._Args>
Show All 28 Lines
public: public:
typedef _Rp result_type; typedef _Rp result_type;
template <class _Gp, class ..._BA, template <class _Gp, class ..._BA,
class = typename enable_if class = typename enable_if
< <
is_constructible<_Fd, _Gp>::value && is_constructible<_Fd, _Gp>::value &&
!is_same<typename remove_reference<_Gp>::type, !is_same<__libcpp_remove_reference_t<_Gp>,
__bind_r>::value __bind_r>::value
>::type> >::type>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
explicit __bind_r(_Gp&& __f, _BA&& ...__bound_args) explicit __bind_r(_Gp&& __f, _BA&& ...__bound_args)
: base(_VSTD::forward<_Gp>(__f), : base(_VSTD::forward<_Gp>(__f),
_VSTD::forward<_BA>(__bound_args)...) {} _VSTD::forward<_BA>(__bound_args)...) {}
template <class ..._Args> template <class ..._Args>
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

libcxx/include/__functional/function.h

Show First 20 Lines • Show All 962 Lines • ▼ Show 20 Lines#ifndef _LIBCPP_ABI_OPTIMIZED_FUNCTION
typedef __function::__value_func<_Rp(_ArgTypes...)> __func; typedef __function::__value_func<_Rp(_ArgTypes...)> __func;
#else #else
typedef __function::__policy_func<_Rp(_ArgTypes...)> __func; typedef __function::__policy_func<_Rp(_ArgTypes...)> __func;
#endif #endif
__func __f_; __func __f_;
template <class _Fp, bool = _And< template <class _Fp, bool = _And<
_IsNotSame<__uncvref_t<_Fp>, function>, _IsNotSame<__remove_cvref_t<_Fp>, function>,
__invokable<_Fp, _ArgTypes...> __invokable<_Fp, _ArgTypes...>
>::value> >::value>
struct __callable; struct __callable;
template <class _Fp> template <class _Fp>
struct __callable<_Fp, true> struct __callable<_Fp, true>
{ {
static const bool value = is_void<_Rp>::value || static const bool value = is_void<_Rp>::value ||
__is_core_convertible<typename __invoke_of<_Fp, _ArgTypes...>::type, __is_core_convertible<typename __invoke_of<_Fp, _ArgTypes...>::type,
▲ Show 20 Lines • Show All 1,834 Lines • Show Last 20 Lines

libcxx/include/__functional/invoke.h

Show First 20 Lines • Show All 242 Lines • ▼ Show 20 Lines
struct __member_pointer_traits_imp<_Rp _Class::*, false, true> struct __member_pointer_traits_imp<_Rp _Class::*, false, true>
{ {
typedef _Class _ClassType; typedef _Class _ClassType;
typedef _Rp _ReturnType; typedef _Rp _ReturnType;
}; };
template <class _MP> template <class _MP>
struct __member_pointer_traits struct __member_pointer_traits
: public __member_pointer_traits_imp<typename remove_cv<_MP>::type, : public __member_pointer_traits_imp<__remove_cv_t<_MP>,
is_member_function_pointer<_MP>::value, is_member_function_pointer<_MP>::value,
is_member_object_pointer<_MP>::value> is_member_object_pointer<_MP>::value>
{ {
// typedef ... _ClassType; // typedef ... _ClassType;
// typedef ... _ReturnType; // typedef ... _ReturnType;
// typedef ... _FnType; // typedef ... _FnType;
}; };
▲ Show 20 Lines • Show All 279 Lines • Show Last 20 Lines

libcxx/include/__hash_table

Show First 20 Lines • Show All 43 Lines • ▼ Show 20 Lines
template <class _Key, class _Value> template <class _Key, class _Value>
struct __is_hash_value_type_imp<__hash_value_type<_Key, _Value> > : true_type {}; struct __is_hash_value_type_imp<__hash_value_type<_Key, _Value> > : true_type {};
template <class ..._Args> template <class ..._Args>
struct __is_hash_value_type : false_type {}; struct __is_hash_value_type : false_type {};
template <class _One> template <class _One>
struct __is_hash_value_type<_One> : __is_hash_value_type_imp<__uncvref_t<_One> > {}; struct __is_hash_value_type<_One> : __is_hash_value_type_imp<__remove_cvref_t<_One> > {};
_LIBCPP_FUNC_VIS _LIBCPP_FUNC_VIS
size_t __next_prime(size_t __n); size_t __next_prime(size_t __n);
template <class _NodePtr> template <class _NodePtr>
struct __hash_node_base struct __hash_node_base
{ {
typedef typename pointer_traits<_NodePtr>::element_type __node_type; typedef typename pointer_traits<_NodePtr>::element_type __node_type;
typedef __hash_node_base __first_node; typedef __hash_node_base __first_node;
typedef typename __rebind_pointer<_NodePtr, __first_node>::type __node_base_pointer; typedef __rebind_pointer_t<_NodePtr, __first_node> __node_base_pointer;
typedef _NodePtr __node_pointer; typedef _NodePtr __node_pointer;
#if defined(_LIBCPP_ABI_FIX_UNORDERED_NODE_POINTER_UB) #if defined(_LIBCPP_ABI_FIX_UNORDERED_NODE_POINTER_UB)
typedef __node_base_pointer __next_pointer; typedef __node_base_pointer __next_pointer;
#else #else
typedef typename conditional< typedef typename conditional<
is_pointer<__node_pointer>::value, is_pointer<__node_pointer>::value,
__node_base_pointer, __node_base_pointer,
Show All 21 Lines#endif
_LIBCPP_INLINE_VISIBILITY __hash_node_base() _NOEXCEPT : __next_(nullptr) {} _LIBCPP_INLINE_VISIBILITY __hash_node_base() _NOEXCEPT : __next_(nullptr) {}
}; };
template <class _Tp, class _VoidPtr> template <class _Tp, class _VoidPtr>
struct _LIBCPP_STANDALONE_DEBUG __hash_node struct _LIBCPP_STANDALONE_DEBUG __hash_node
: public __hash_node_base : public __hash_node_base
< <
typename __rebind_pointer<_VoidPtr, __hash_node<_Tp, _VoidPtr> >::type __rebind_pointer_t<_VoidPtr, __hash_node<_Tp, _VoidPtr> >
> >
{ {
typedef _Tp __node_value_type; typedef _Tp __node_value_type;
size_t __hash_; size_t __hash_;
__node_value_type __value_; __node_value_type __value_;
}; };
▲ Show 20 Lines • Show All 95 Lines • ▼ Show 20 Lines
template <class _Tp, class _AllocPtr, class _KVTypes = __hash_key_value_types<_Tp>, template <class _Tp, class _AllocPtr, class _KVTypes = __hash_key_value_types<_Tp>,
bool = _KVTypes::__is_map> bool = _KVTypes::__is_map>
struct __hash_map_pointer_types {}; struct __hash_map_pointer_types {};
template <class _Tp, class _AllocPtr, class _KVTypes> template <class _Tp, class _AllocPtr, class _KVTypes>
struct __hash_map_pointer_types<_Tp, _AllocPtr, _KVTypes, true> { struct __hash_map_pointer_types<_Tp, _AllocPtr, _KVTypes, true> {
typedef typename _KVTypes::__map_value_type _Mv; typedef typename _KVTypes::__map_value_type _Mv;
typedef typename __rebind_pointer<_AllocPtr, _Mv>::type typedef __rebind_pointer_t<_AllocPtr, _Mv>
__map_value_type_pointer; __map_value_type_pointer;
typedef typename __rebind_pointer<_AllocPtr, const _Mv>::type typedef __rebind_pointer_t<_AllocPtr, const _Mv>
__const_map_value_type_pointer; __const_map_value_type_pointer;
}; };
template <class _NodePtr, class _NodeT = typename pointer_traits<_NodePtr>::element_type> template <class _NodePtr, class _NodeT = typename pointer_traits<_NodePtr>::element_type>
struct __hash_node_types; struct __hash_node_types;
template <class _NodePtr, class _Tp, class _VoidPtr> template <class _NodePtr, class _Tp, class _VoidPtr>
struct __hash_node_types<_NodePtr, __hash_node<_Tp, _VoidPtr> > struct __hash_node_types<_NodePtr, __hash_node<_Tp, _VoidPtr> >
: public __hash_key_value_types<_Tp>, __hash_map_pointer_types<_Tp, _VoidPtr> : public __hash_key_value_types<_Tp>, __hash_map_pointer_types<_Tp, _VoidPtr>
{ {
typedef __hash_key_value_types<_Tp> __base; typedef __hash_key_value_types<_Tp> __base;
public: public:
typedef ptrdiff_t difference_type; typedef ptrdiff_t difference_type;
typedef size_t size_type; typedef size_t size_type;
typedef typename __rebind_pointer<_NodePtr, void>::type __void_pointer; typedef __rebind_pointer_t<_NodePtr, void> __void_pointer;
typedef typename pointer_traits<_NodePtr>::element_type __node_type; typedef typename pointer_traits<_NodePtr>::element_type __node_type;
typedef _NodePtr __node_pointer; typedef _NodePtr __node_pointer;
typedef __hash_node_base<__node_pointer> __node_base_type; typedef __hash_node_base<__node_pointer> __node_base_type;
typedef typename __rebind_pointer<_NodePtr, __node_base_type>::type typedef __rebind_pointer_t<_NodePtr, __node_base_type>
__node_base_pointer; __node_base_pointer;
typedef typename __node_base_type::__next_pointer __next_pointer; typedef typename __node_base_type::__next_pointer __next_pointer;
typedef _Tp __node_value_type; typedef _Tp __node_value_type;
typedef typename __rebind_pointer<_VoidPtr, __node_value_type>::type typedef __rebind_pointer_t<_VoidPtr, __node_value_type>
__node_value_type_pointer; __node_value_type_pointer;
typedef typename __rebind_pointer<_VoidPtr, const __node_value_type>::type typedef __rebind_pointer_t<_VoidPtr, const __node_value_type>
__const_node_value_type_pointer; __const_node_value_type_pointer;
private: private:
static_assert(!is_const<__node_type>::value, static_assert(!is_const<__node_type>::value,
"_NodePtr should never be a pointer to const"); "_NodePtr should never be a pointer to const");
static_assert((is_same<typename pointer_traits<_VoidPtr>::element_type, void>::value), static_assert((is_same<typename pointer_traits<_VoidPtr>::element_type, void>::value),
"_VoidPtr does not point to unqualified void type"); "_VoidPtr does not point to unqualified void type");
static_assert((is_same<typename __rebind_pointer<_VoidPtr, __node_type>::type, static_assert((is_same<__rebind_pointer_t<_VoidPtr, __node_type>,
_NodePtr>::value), "_VoidPtr does not rebind to _NodePtr."); _NodePtr>::value), "_VoidPtr does not rebind to _NodePtr.");
}; };
template <class _HashIterator> template <class _HashIterator>
struct __hash_node_types_from_iterator; struct __hash_node_types_from_iterator;
template <class _NodePtr> template <class _NodePtr>
struct __hash_node_types_from_iterator<__hash_iterator<_NodePtr> > : __hash_node_types<_NodePtr> {}; struct __hash_node_types_from_iterator<__hash_iterator<_NodePtr> > : __hash_node_types<_NodePtr> {};
template <class _NodePtr> template <class _NodePtr>
struct __hash_node_types_from_iterator<__hash_const_iterator<_NodePtr> > : __hash_node_types<_NodePtr> {}; struct __hash_node_types_from_iterator<__hash_const_iterator<_NodePtr> > : __hash_node_types<_NodePtr> {};
template <class _NodePtr> template <class _NodePtr>
struct __hash_node_types_from_iterator<__hash_local_iterator<_NodePtr> > : __hash_node_types<_NodePtr> {}; struct __hash_node_types_from_iterator<__hash_local_iterator<_NodePtr> > : __hash_node_types<_NodePtr> {};
template <class _NodePtr> template <class _NodePtr>
struct __hash_node_types_from_iterator<__hash_const_local_iterator<_NodePtr> > : __hash_node_types<_NodePtr> {}; struct __hash_node_types_from_iterator<__hash_const_local_iterator<_NodePtr> > : __hash_node_types<_NodePtr> {};
template <class _NodeValueTp, class _VoidPtr> template <class _NodeValueTp, class _VoidPtr>
struct __make_hash_node_types { struct __make_hash_node_types {
typedef __hash_node<_NodeValueTp, _VoidPtr> _NodeTp; typedef __hash_node<_NodeValueTp, _VoidPtr> _NodeTp;
typedef typename __rebind_pointer<_VoidPtr, _NodeTp>::type _NodePtr; typedef __rebind_pointer_t<_VoidPtr, _NodeTp> _NodePtr;
typedef __hash_node_types<_NodePtr> type; typedef __hash_node_types<_NodePtr> type;
}; };
template <class _NodePtr> template <class _NodePtr>
class _LIBCPP_TEMPLATE_VIS __hash_iterator class _LIBCPP_TEMPLATE_VIS __hash_iterator
{ {
typedef __hash_node_types<_NodePtr> _NodeTypes; typedef __hash_node_types<_NodePtr> _NodeTypes;
typedef _NodePtr __node_pointer; typedef _NodePtr __node_pointer;
▲ Show 20 Lines • Show All 328 Lines • ▼ Show 20 Linesclass _LIBCPP_TEMPLATE_VIS __hash_const_local_iterator
typedef typename _NodeTypes::__next_pointer __next_pointer; typedef typename _NodeTypes::__next_pointer __next_pointer;
__next_pointer __node_; __next_pointer __node_;
size_t __bucket_; size_t __bucket_;
size_t __bucket_count_; size_t __bucket_count_;
typedef pointer_traits<__node_pointer> __pointer_traits; typedef pointer_traits<__node_pointer> __pointer_traits;
typedef typename __pointer_traits::element_type __node; typedef typename __pointer_traits::element_type __node;
typedef typename remove_const<__node>::type __non_const_node; typedef __remove_const_t<__node> __non_const_node;
typedef typename __rebind_pointer<__node_pointer, __non_const_node>::type typedef __rebind_pointer_t<__node_pointer, __non_const_node>
__non_const_node_pointer; __non_const_node_pointer;
public: public:
typedef __hash_local_iterator<__non_const_node_pointer> typedef __hash_local_iterator<__non_const_node_pointer>
__non_const_iterator; __non_const_iterator;
typedef forward_iterator_tag iterator_category; typedef forward_iterator_tag iterator_category;
typedef typename _NodeTypes::__node_value_type value_type; typedef typename _NodeTypes::__node_value_type value_type;
typedef typename _NodeTypes::difference_type difference_type; typedef typename _NodeTypes::difference_type difference_type;
▲ Show 20 Lines • Show All 2,084 Lines • Show Last 20 Lines

libcxx/include/__iterator/distance.h

Show First 20 Lines • Show All 69 Lines • ▼ Show 20 Lines while (__first != __last) {
++__n; ++__n;
} }
return __n; return __n;
} }
template<class _Ip, sized_sentinel_for<decay_t<_Ip>> _Sp> template<class _Ip, sized_sentinel_for<decay_t<_Ip>> _Sp>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
constexpr iter_difference_t<_Ip> operator()(_Ip&& __first, _Sp __last) const { constexpr iter_difference_t<_Ip> operator()(_Ip&& __first, _Sp __last) const {
if constexpr (sized_sentinel_for<_Sp, __uncvref_t<_Ip>>) { if constexpr (sized_sentinel_for<_Sp, __remove_cvref_t<_Ip>>) {
return __last - __first; return __last - __first;
} else { } else {
return __last - decay_t<_Ip>(__first); return __last - decay_t<_Ip>(__first);
} }
} }
template<range _Rp> template<range _Rp>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
Show All 21 Lines

libcxx/include/__iterator/iterator_traits.h

Show First 20 Lines • Show All 402 Lines • ▼ Show 20 Lines
template<class _Tp> template<class _Tp>
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER > 17
requires is_object_v<_Tp> requires is_object_v<_Tp>
#endif #endif
struct _LIBCPP_TEMPLATE_VIS iterator_traits<_Tp*> struct _LIBCPP_TEMPLATE_VIS iterator_traits<_Tp*>
{ {
typedef ptrdiff_t difference_type; typedef ptrdiff_t difference_type;
typedef typename remove_cv<_Tp>::type value_type; typedef __remove_cv_t<_Tp> value_type;
typedef _Tp* pointer; typedef _Tp* pointer;
typedef _Tp& reference; typedef _Tp& reference;
typedef random_access_iterator_tag iterator_category; typedef random_access_iterator_tag iterator_category;
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER > 17
typedef contiguous_iterator_tag iterator_concept; typedef contiguous_iterator_tag iterator_concept;
#endif #endif
}; };
▲ Show 20 Lines • Show All 68 Lines • ▼ Show 20 Linesstruct __is_exactly_cpp17_bidirectional_iterator
: public integral_constant<bool, : public integral_constant<bool,
__has_iterator_category_convertible_to<_Tp, bidirectional_iterator_tag>::value && __has_iterator_category_convertible_to<_Tp, bidirectional_iterator_tag>::value &&
!__has_iterator_category_convertible_to<_Tp, random_access_iterator_tag>::value> {}; !__has_iterator_category_convertible_to<_Tp, random_access_iterator_tag>::value> {};
template<class _InputIterator> template<class _InputIterator>
using __iter_value_type = typename iterator_traits<_InputIterator>::value_type; using __iter_value_type = typename iterator_traits<_InputIterator>::value_type;
template<class _InputIterator> template<class _InputIterator>
using __iter_key_type = typename remove_const<typename iterator_traits<_InputIterator>::value_type::first_type>::type; using __iter_key_type = __remove_const_t<typename iterator_traits<_InputIterator>::value_type::first_type>;
template<class _InputIterator> template<class _InputIterator>
using __iter_mapped_type = typename iterator_traits<_InputIterator>::value_type::second_type; using __iter_mapped_type = typename iterator_traits<_InputIterator>::value_type::second_type;
template<class _InputIterator> template<class _InputIterator>
using __iter_to_alloc_type = pair< using __iter_to_alloc_type = pair<
typename add_const<typename iterator_traits<_InputIterator>::value_type::first_type>::type, typename add_const<typename iterator_traits<_InputIterator>::value_type::first_type>::type,
typename iterator_traits<_InputIterator>::value_type::second_type>; typename iterator_traits<_InputIterator>::value_type::second_type>;
Show All 16 Lines

libcxx/include/__iterator/move_iterator.h

Show First 20 Lines • Show All 76 Lines • ▼ Show 20 Lines#else
> iterator_category; > iterator_category;
typedef typename iterator_traits<iterator_type>::value_type value_type; typedef typename iterator_traits<iterator_type>::value_type value_type;
typedef typename iterator_traits<iterator_type>::difference_type difference_type; typedef typename iterator_traits<iterator_type>::difference_type difference_type;
typedef iterator_type pointer; typedef iterator_type pointer;
typedef typename iterator_traits<iterator_type>::reference __reference; typedef typename iterator_traits<iterator_type>::reference __reference;
typedef typename conditional< typedef typename conditional<
is_reference<__reference>::value, is_reference<__reference>::value,
typename remove_reference<__reference>::type&&, __libcpp_remove_reference_t<__reference>&&,
__reference __reference
>::type reference; >::type reference;
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER > 17
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
explicit move_iterator(_Iter __i) : __current_(std::move(__i)) {} explicit move_iterator(_Iter __i) : __current_(std::move(__i)) {}
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
▲ Show 20 Lines • Show All 233 Lines • Show Last 20 Lines

libcxx/include/__memory/allocator_arg_t.h

Show All 30 Lines
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
// allocator construction // allocator construction
template <class _Tp, class _Alloc, class ..._Args> template <class _Tp, class _Alloc, class ..._Args>
struct __uses_alloc_ctor_imp struct __uses_alloc_ctor_imp
{ {
typedef _LIBCPP_NODEBUG __uncvref_t<_Alloc> _RawAlloc; typedef _LIBCPP_NODEBUG __remove_cvref_t<_Alloc> _RawAlloc;
static const bool __ua = uses_allocator<_Tp, _RawAlloc>::value; static const bool __ua = uses_allocator<_Tp, _RawAlloc>::value;
static const bool __ic = static const bool __ic =
is_constructible<_Tp, allocator_arg_t, _Alloc, _Args...>::value; is_constructible<_Tp, allocator_arg_t, _Alloc, _Args...>::value;
static const int value = __ua ? 2 - __ic : 0; static const int value = __ua ? 2 - __ic : 0;
}; };
template <class _Tp, class _Alloc, class ..._Args> template <class _Tp, class _Alloc, class ..._Args>
struct __uses_alloc_ctor struct __uses_alloc_ctor
Show All 31 Lines

libcxx/include/__memory/allocator_traits.h

Show All 27 Lines
#define _LIBCPP_ALLOCATOR_TRAITS_HAS_XXX(NAME, PROPERTY) \ #define _LIBCPP_ALLOCATOR_TRAITS_HAS_XXX(NAME, PROPERTY) \
template <class _Tp, class = void> struct NAME : false_type { }; \ template <class _Tp, class = void> struct NAME : false_type { }; \
template <class _Tp> struct NAME<_Tp, typename __void_t<typename _Tp:: PROPERTY >::type> : true_type { } template <class _Tp> struct NAME<_Tp, typename __void_t<typename _Tp:: PROPERTY >::type> : true_type { }
// __pointer // __pointer
_LIBCPP_ALLOCATOR_TRAITS_HAS_XXX(__has_pointer, pointer); _LIBCPP_ALLOCATOR_TRAITS_HAS_XXX(__has_pointer, pointer);
template <class _Tp, class _Alloc, template <class _Tp, class _Alloc,
class _RawAlloc = typename remove_reference<_Alloc>::type, class _RawAlloc = __libcpp_remove_reference_t<_Alloc>,
bool = __has_pointer<_RawAlloc>::value> bool = __has_pointer<_RawAlloc>::value>
struct __pointer { struct __pointer {
using type _LIBCPP_NODEBUG = typename _RawAlloc::pointer; using type _LIBCPP_NODEBUG = typename _RawAlloc::pointer;
}; };
template <class _Tp, class _Alloc, class _RawAlloc> template <class _Tp, class _Alloc, class _RawAlloc>
struct __pointer<_Tp, _Alloc, _RawAlloc, false> { struct __pointer<_Tp, _Alloc, _RawAlloc, false> {
using type _LIBCPP_NODEBUG = _Tp*; using type _LIBCPP_NODEBUG = _Tp*;
}; };
▲ Show 20 Lines • Show All 361 Lines • Show Last 20 Lines

libcxx/include/__memory/pointer_traits.h

Show First 20 Lines • Show All 145 Lines • ▼ Show 20 Linesprivate:
struct __nat {}; struct __nat {};
public: public:
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
static pointer pointer_to(typename conditional<is_void<element_type>::value, static pointer pointer_to(typename conditional<is_void<element_type>::value,
__nat, element_type>::type& __r) _NOEXCEPT __nat, element_type>::type& __r) _NOEXCEPT
{return _VSTD::addressof(__r);} {return _VSTD::addressof(__r);}
}; };
template <class _From, class _To>
struct __rebind_pointer {
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
typedef typename pointer_traits<_From>::template rebind<_To> type; template <class _From, class _To>
using __rebind_pointer_t = typename pointer_traits<_From>::template rebind<_To>;
#else #else
typedef typename pointer_traits<_From>::template rebind<_To>::other type; template <class _From, class _To>
using __rebind_pointer_t = typename pointer_traits<_From>::template rebind<_To>::other;
#endif #endif
};
// to_address // to_address
template <class _Pointer, class = void> template <class _Pointer, class = void>
struct __to_address_helper; struct __to_address_helper;
template <class _Tp> template <class _Tp>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
▲ Show 20 Lines • Show All 71 Lines • Show Last 20 Lines

libcxx/include/__memory/shared_ptr.h

Show First 20 Lines • Show All 683 Lines • ▼ Show 20 Lines
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER > 11
if (__ptr_ == nullptr) if (__ptr_ == nullptr)
__cntrl_ = nullptr; __cntrl_ = nullptr;
else else
#endif #endif
{ {
typedef typename __shared_ptr_default_allocator<_Yp>::type _AllocT; typedef typename __shared_ptr_default_allocator<_Yp>::type _AllocT;
typedef __shared_ptr_pointer<typename unique_ptr<_Yp, _Dp>::pointer, typedef __shared_ptr_pointer<typename unique_ptr<_Yp, _Dp>::pointer,
reference_wrapper<typename remove_reference<_Dp>::type>, reference_wrapper<__libcpp_remove_reference_t<_Dp> >,
_AllocT> _CntrlBlk; _AllocT> _CntrlBlk;
__cntrl_ = new _CntrlBlk(__r.get(), _VSTD::ref(__r.get_deleter()), _AllocT()); __cntrl_ = new _CntrlBlk(__r.get(), _VSTD::ref(__r.get_deleter()), _AllocT());
__enable_weak_this(__r.get(), __r.get()); __enable_weak_this(__r.get(), __r.get());
} }
__r.release(); __r.release();
} }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
▲ Show 20 Lines • Show All 98 Lines • ▼ Show 20 Lines#endif
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
element_type* get() const _NOEXCEPT element_type* get() const _NOEXCEPT
{ {
return __ptr_; return __ptr_;
} }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
typename add_lvalue_reference<element_type>::type operator*() const _NOEXCEPT __add_lvalue_reference_t<element_type> operator*() const _NOEXCEPT
{ {
return *__ptr_; return *__ptr_;
} }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
element_type* operator->() const _NOEXCEPT element_type* operator->() const _NOEXCEPT
{ {
static_assert(!is_array<_Tp>::value, static_assert(!is_array<_Tp>::value,
Show All 36 Lines#endif
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
bool __owner_equivalent(const shared_ptr& __p) const bool __owner_equivalent(const shared_ptr& __p) const
{ {
return __cntrl_ == __p.__cntrl_; return __cntrl_ == __p.__cntrl_;
} }
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER > 14
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
typename add_lvalue_reference<element_type>::type operator[](ptrdiff_t __i) const __add_lvalue_reference_t<element_type> operator[](ptrdiff_t __i) const
{ {
static_assert(is_array<_Tp>::value, static_assert(is_array<_Tp>::value,
"std::shared_ptr<T>::operator[] is only valid when T is an array type."); "std::shared_ptr<T>::operator[] is only valid when T is an array type.");
return __ptr_[__i]; return __ptr_[__i];
} }
#endif #endif
#ifndef _LIBCPP_NO_RTTI #ifndef _LIBCPP_NO_RTTI
Show All 32 Linesprivate:
}; };
template <class _Yp, class _OrigPtr, class = __enable_if_t< template <class _Yp, class _OrigPtr, class = __enable_if_t<
is_convertible<_OrigPtr*, const enable_shared_from_this<_Yp>*>::value is_convertible<_OrigPtr*, const enable_shared_from_this<_Yp>*>::value
> > > >
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
void __enable_weak_this(const enable_shared_from_this<_Yp>* __e, _OrigPtr* __ptr) _NOEXCEPT void __enable_weak_this(const enable_shared_from_this<_Yp>* __e, _OrigPtr* __ptr) _NOEXCEPT
{ {
typedef typename remove_cv<_Yp>::type _RawYp; typedef __remove_cv_t<_Yp> _RawYp;
if (__e && __e->__weak_this_.expired()) if (__e && __e->__weak_this_.expired())
{ {
__e->__weak_this_ = shared_ptr<_RawYp>(*this, __e->__weak_this_ = shared_ptr<_RawYp>(*this,
const_cast<_RawYp*>(static_cast<const _Yp*>(__ptr))); const_cast<_RawYp*>(static_cast<const _Yp*>(__ptr)));
} }
} }
_LIBCPP_HIDE_FROM_ABI void __enable_weak_this(...) _NOEXCEPT { } _LIBCPP_HIDE_FROM_ABI void __enable_weak_this(...) _NOEXCEPT { }
▲ Show 20 Lines • Show All 1,025 Lines • Show Last 20 Lines

libcxx/include/__memory/uninitialized_algorithms.h

Show First 20 Lines • Show All 551 Lines • ▼ Show 20 Lines
template <class _Alloc, class _Type> template <class _Alloc, class _Type>
struct __allocator_has_trivial_copy_construct : _Not<__has_construct<_Alloc, _Type*, const _Type&> > {}; struct __allocator_has_trivial_copy_construct : _Not<__has_construct<_Alloc, _Type*, const _Type&> > {};
template <class _Type> template <class _Type>
struct __allocator_has_trivial_copy_construct<allocator<_Type>, _Type> : true_type {}; struct __allocator_has_trivial_copy_construct<allocator<_Type>, _Type> : true_type {};
template <class _Alloc, template <class _Alloc,
class _Type, class _Type,
class _RawType = typename remove_const<_Type>::type, class _RawType = __remove_const_t<_Type>,
__enable_if_t< __enable_if_t<
// using _RawType because of the allocator<T const> extension // using _RawType because of the allocator<T const> extension
is_trivially_copy_constructible<_RawType>::value && is_trivially_copy_assignable<_RawType>::value && is_trivially_copy_constructible<_RawType>::value && is_trivially_copy_assignable<_RawType>::value &&
__allocator_has_trivial_copy_construct<_Alloc, _RawType>::value>* = nullptr> __allocator_has_trivial_copy_construct<_Alloc, _RawType>::value>* = nullptr>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _Type* _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _Type*
__uninitialized_allocator_copy(_Alloc&, const _Type* __first1, const _Type* __last1, _Type* __first2) { __uninitialized_allocator_copy(_Alloc&, const _Type* __first1, const _Type* __last1, _Type* __first2) {
// TODO: Remove the const_cast once we drop support for std::allocator<T const> // TODO: Remove the const_cast once we drop support for std::allocator<T const>
if (__libcpp_is_constant_evaluated()) { if (__libcpp_is_constant_evaluated()) {
▲ Show 20 Lines • Show All 75 Lines • Show Last 20 Lines

libcxx/include/__memory/unique_ptr.h

Show First 20 Lines • Show All 262 Lines • ▼ Show 20 Lines#endif
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
unique_ptr& operator=(nullptr_t) _NOEXCEPT { unique_ptr& operator=(nullptr_t) _NOEXCEPT {
reset(); reset();
return *this; return *this;
} }
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
typename add_lvalue_reference<_Tp>::type __add_lvalue_reference_t<_Tp>
operator*() const { operator*() const {
return *__ptr_.first(); return *__ptr_.first();
} }
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
pointer operator->() const _NOEXCEPT { pointer operator->() const _NOEXCEPT {
return __ptr_.first(); return __ptr_.first();
} }
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
▲ Show 20 Lines • Show All 205 Lines • ▼ Show 20 Linespublic:
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
unique_ptr& operator=(nullptr_t) _NOEXCEPT { unique_ptr& operator=(nullptr_t) _NOEXCEPT {
reset(); reset();
return *this; return *this;
} }
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
typename add_lvalue_reference<_Tp>::type __add_lvalue_reference_t<_Tp>
operator[](size_t __i) const { operator[](size_t __i) const {
return __ptr_.first()[__i]; return __ptr_.first()[__i];
} }
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
pointer get() const _NOEXCEPT { pointer get() const _NOEXCEPT {
return __ptr_.first(); return __ptr_.first();
} }
▲ Show 20 Lines • Show All 242 Lines • ▼ Show 20 Linesmake_unique(_Args&&... __args)
return unique_ptr<_Tp>(new _Tp(_VSTD::forward<_Args>(__args)...)); return unique_ptr<_Tp>(new _Tp(_VSTD::forward<_Args>(__args)...));
} }
template<class _Tp> template<class _Tp>
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
typename __unique_if<_Tp>::__unique_array_unknown_bound typename __unique_if<_Tp>::__unique_array_unknown_bound
make_unique(size_t __n) make_unique(size_t __n)
{ {
typedef typename remove_extent<_Tp>::type _Up; typedef __remove_extent_t<_Tp> _Up;
return unique_ptr<_Tp>(new _Up[__n]()); return unique_ptr<_Tp>(new _Up[__n]());
} }
template<class _Tp, class... _Args> template<class _Tp, class... _Args>
typename __unique_if<_Tp>::__unique_array_known_bound typename __unique_if<_Tp>::__unique_array_known_bound
make_unique(_Args&&...) = delete; make_unique(_Args&&...) = delete;
#endif // _LIBCPP_STD_VER > 11 #endif // _LIBCPP_STD_VER > 11
Show All 27 Lines

libcxx/include/__node_handle

Show First 20 Lines • Show All 84 Lines • ▼ Show 20 Linesclass _LIBCPP_TEMPLATE_VIS __basic_node_handle
template <class _Tp, class _Compare, class _Allocator> template <class _Tp, class _Compare, class _Allocator>
friend class __tree; friend class __tree;
template <class _Tp, class _Hash, class _Equal, class _Allocator> template <class _Tp, class _Hash, class _Equal, class _Allocator>
friend class __hash_table; friend class __hash_table;
friend struct _MapOrSetSpecifics< friend struct _MapOrSetSpecifics<
_NodeType, __basic_node_handle<_NodeType, _Alloc, _MapOrSetSpecifics>>; _NodeType, __basic_node_handle<_NodeType, _Alloc, _MapOrSetSpecifics>>;
typedef allocator_traits<_Alloc> __alloc_traits; typedef allocator_traits<_Alloc> __alloc_traits;
typedef typename __rebind_pointer<typename __alloc_traits::void_pointer, typedef __rebind_pointer_t<typename __alloc_traits::void_pointer,
_NodeType>::type _NodeType>
__node_pointer_type; __node_pointer_type;
public: public:
typedef _Alloc allocator_type; typedef _Alloc allocator_type;
private: private:
__node_pointer_type __ptr_ = nullptr; __node_pointer_type __ptr_ = nullptr;
optional<allocator_type> __alloc_; optional<allocator_type> __alloc_;
▲ Show 20 Lines • Show All 151 Lines • Show Last 20 Lines

libcxx/include/__numeric/gcd_lcm.h

Show First 20 Lines • Show All 54 Lines • ▼ Show 20 Lines
} }
template<class _Tp, class _Up> template<class _Tp, class _Up>
_LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
common_type_t<_Tp,_Up> common_type_t<_Tp,_Up>
gcd(_Tp __m, _Up __n) gcd(_Tp __m, _Up __n)
{ {
static_assert((is_integral<_Tp>::value && is_integral<_Up>::value), "Arguments to gcd must be integer types"); static_assert((is_integral<_Tp>::value && is_integral<_Up>::value), "Arguments to gcd must be integer types");
static_assert((!is_same<typename remove_cv<_Tp>::type, bool>::value), "First argument to gcd cannot be bool" ); static_assert((!is_same<__remove_cv_t<_Tp>, bool>::value), "First argument to gcd cannot be bool" );
static_assert((!is_same<typename remove_cv<_Up>::type, bool>::value), "Second argument to gcd cannot be bool" ); static_assert((!is_same<__remove_cv_t<_Up>, bool>::value), "Second argument to gcd cannot be bool" );
using _Rp = common_type_t<_Tp,_Up>; using _Rp = common_type_t<_Tp,_Up>;
using _Wp = make_unsigned_t<_Rp>; using _Wp = make_unsigned_t<_Rp>;
return static_cast<_Rp>(_VSTD::__gcd( return static_cast<_Rp>(_VSTD::__gcd(
static_cast<_Wp>(__ct_abs<_Rp, _Tp>()(__m)), static_cast<_Wp>(__ct_abs<_Rp, _Tp>()(__m)),
static_cast<_Wp>(__ct_abs<_Rp, _Up>()(__n)))); static_cast<_Wp>(__ct_abs<_Rp, _Up>()(__n))));
} }
template<class _Tp, class _Up> template<class _Tp, class _Up>
_LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
common_type_t<_Tp,_Up> common_type_t<_Tp,_Up>
lcm(_Tp __m, _Up __n) lcm(_Tp __m, _Up __n)
{ {
static_assert((is_integral<_Tp>::value && is_integral<_Up>::value), "Arguments to lcm must be integer types"); static_assert((is_integral<_Tp>::value && is_integral<_Up>::value), "Arguments to lcm must be integer types");
static_assert((!is_same<typename remove_cv<_Tp>::type, bool>::value), "First argument to lcm cannot be bool" ); static_assert((!is_same<__remove_cv_t<_Tp>, bool>::value), "First argument to lcm cannot be bool" );
static_assert((!is_same<typename remove_cv<_Up>::type, bool>::value), "Second argument to lcm cannot be bool" ); static_assert((!is_same<__remove_cv_t<_Up>, bool>::value), "Second argument to lcm cannot be bool" );
if (__m == 0 || __n == 0) if (__m == 0 || __n == 0)
return 0; return 0;
using _Rp = common_type_t<_Tp,_Up>; using _Rp = common_type_t<_Tp,_Up>;
_Rp __val1 = __ct_abs<_Rp, _Tp>()(__m) / _VSTD::gcd(__m, __n); _Rp __val1 = __ct_abs<_Rp, _Tp>()(__m) / _VSTD::gcd(__m, __n);
_Rp __val2 = __ct_abs<_Rp, _Up>()(__n); _Rp __val2 = __ct_abs<_Rp, _Up>()(__n);
_LIBCPP_ASSERT((numeric_limits<_Rp>::max() / __val1 > __val2), "Overflow in lcm"); _LIBCPP_ASSERT((numeric_limits<_Rp>::max() / __val1 > __val2), "Overflow in lcm");
return __val1 * __val2; return __val1 * __val2;
Show All 9 Lines

libcxx/include/__random/is_seed_sequence.h

Show All 17 Lines
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Sseq, class _Engine> template <class _Sseq, class _Engine>
struct __is_seed_sequence struct __is_seed_sequence
{ {
static _LIBCPP_CONSTEXPR const bool value = static _LIBCPP_CONSTEXPR const bool value =
!is_convertible<_Sseq, typename _Engine::result_type>::value && !is_convertible<_Sseq, typename _Engine::result_type>::value &&
!is_same<typename remove_cv<_Sseq>::type, _Engine>::value; !is_same<__remove_cv_t<_Sseq>, _Engine>::value;
}; };
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___RANDOM_IS_SEED_SEQUENCE_H #endif // _LIBCPP___RANDOM_IS_SEED_SEQUENCE_H

libcxx/include/__random/uniform_int_distribution.h

Show First 20 Lines • Show All 232 Lines • ▼ Show 20 Lines
template<class _IntType> template<class _IntType>
template<class _URNG> template<class _URNG>
typename uniform_int_distribution<_IntType>::result_type typename uniform_int_distribution<_IntType>::result_type
uniform_int_distribution<_IntType>::operator()(_URNG& __g, const param_type& __p) uniform_int_distribution<_IntType>::operator()(_URNG& __g, const param_type& __p)
_LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK
{ {
static_assert(__libcpp_random_is_valid_urng<_URNG>::value, ""); static_assert(__libcpp_random_is_valid_urng<_URNG>::value, "");
typedef typename conditional<sizeof(result_type) <= sizeof(uint32_t), uint32_t, typedef typename conditional<sizeof(result_type) <= sizeof(uint32_t), uint32_t,
typename make_unsigned<result_type>::type>::type _UIntType; __make_unsigned_t<result_type> >::type _UIntType;
const _UIntType _Rp = _UIntType(__p.b()) - _UIntType(__p.a()) + _UIntType(1); const _UIntType _Rp = _UIntType(__p.b()) - _UIntType(__p.a()) + _UIntType(1);
if (_Rp == 1) if (_Rp == 1)
return __p.a(); return __p.a();
const size_t _Dt = numeric_limits<_UIntType>::digits; const size_t _Dt = numeric_limits<_UIntType>::digits;
typedef __independent_bits_engine<_URNG, _UIntType> _Eng; typedef __independent_bits_engine<_URNG, _UIntType> _Eng;
if (_Rp == 0) if (_Rp == 0)
return static_cast<result_type>(_Eng(__g, _Dt)()); return static_cast<result_type>(_Eng(__g, _Dt)());
size_t __w = _Dt - __countl_zero(_Rp) - 1; size_t __w = _Dt - __countl_zero(_Rp) - 1;
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

libcxx/include/__split_buffer

Show First 20 Lines • Show All 41 Lines • ▼ Show 20 Lines
struct __split_buffer struct __split_buffer
{ {
private: private:
__split_buffer(const __split_buffer&); __split_buffer(const __split_buffer&);
__split_buffer& operator=(const __split_buffer&); __split_buffer& operator=(const __split_buffer&);
public: public:
typedef _Tp value_type; typedef _Tp value_type;
typedef _Allocator allocator_type; typedef _Allocator allocator_type;
typedef typename remove_reference<allocator_type>::type __alloc_rr; typedef __libcpp_remove_reference_t<allocator_type> __alloc_rr;
typedef allocator_traits<__alloc_rr> __alloc_traits; typedef allocator_traits<__alloc_rr> __alloc_traits;
typedef value_type& reference; typedef value_type& reference;
typedef const value_type& const_reference; typedef const value_type& const_reference;
typedef typename __alloc_traits::size_type size_type; typedef typename __alloc_traits::size_type size_type;
typedef typename __alloc_traits::difference_type difference_type; typedef typename __alloc_traits::difference_type difference_type;
typedef typename __alloc_traits::pointer pointer; typedef typename __alloc_traits::pointer pointer;
typedef typename __alloc_traits::const_pointer const_pointer; typedef typename __alloc_traits::const_pointer const_pointer;
typedef pointer iterator; typedef pointer iterator;
typedef const_pointer const_iterator; typedef const_pointer const_iterator;
pointer __first_; pointer __first_;
pointer __begin_; pointer __begin_;
pointer __end_; pointer __end_;
__compressed_pair<pointer, allocator_type> __end_cap_; __compressed_pair<pointer, allocator_type> __end_cap_;
typedef typename add_lvalue_reference<allocator_type>::type __alloc_ref; typedef __add_lvalue_reference_t<allocator_type> __alloc_ref;
typedef typename add_lvalue_reference<allocator_type>::type __alloc_const_ref; typedef __add_lvalue_reference_t<allocator_type> __alloc_const_ref;
_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI __alloc_rr& __alloc() _NOEXCEPT {return __end_cap_.second();} _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI __alloc_rr& __alloc() _NOEXCEPT {return __end_cap_.second();}
_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI const __alloc_rr& __alloc() const _NOEXCEPT {return __end_cap_.second();} _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI const __alloc_rr& __alloc() const _NOEXCEPT {return __end_cap_.second();}
_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI pointer& __end_cap() _NOEXCEPT {return __end_cap_.first();} _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI pointer& __end_cap() _NOEXCEPT {return __end_cap_.first();}
_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI const pointer& __end_cap() const _NOEXCEPT {return __end_cap_.first();} _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI const pointer& __end_cap() const _NOEXCEPT {return __end_cap_.first();}
_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
__split_buffer() __split_buffer()
▲ Show 20 Lines • Show All 578 Lines • Show Last 20 Lines

libcxx/include/__tree

Show First 20 Lines • Show All 549 Lines • ▼ Show 20 Lines
template <class _Key, class _Value> template <class _Key, class _Value>
struct __is_tree_value_type_imp<__value_type<_Key, _Value> > : true_type {}; struct __is_tree_value_type_imp<__value_type<_Key, _Value> > : true_type {};
template <class ..._Args> template <class ..._Args>
struct __is_tree_value_type : false_type {}; struct __is_tree_value_type : false_type {};
template <class _One> template <class _One>
struct __is_tree_value_type<_One> : __is_tree_value_type_imp<__uncvref_t<_One> > {}; struct __is_tree_value_type<_One> : __is_tree_value_type_imp<__remove_cvref_t<_One> > {};
template <class _Tp> template <class _Tp>
struct __tree_key_value_types { struct __tree_key_value_types {
typedef _Tp key_type; typedef _Tp key_type;
typedef _Tp __node_value_type; typedef _Tp __node_value_type;
typedef _Tp __container_value_type; typedef _Tp __container_value_type;
static const bool __is_map = false; static const bool __is_map = false;
▲ Show 20 Lines • Show All 61 Lines • ▼ Show 20 Linesstruct __tree_key_value_types<__value_type<_Key, _Tp> > {
} }
}; };
template <class _VoidPtr> template <class _VoidPtr>
struct __tree_node_base_types { struct __tree_node_base_types {
typedef _VoidPtr __void_pointer; typedef _VoidPtr __void_pointer;
typedef __tree_node_base<__void_pointer> __node_base_type; typedef __tree_node_base<__void_pointer> __node_base_type;
typedef typename __rebind_pointer<_VoidPtr, __node_base_type>::type typedef __rebind_pointer_t<_VoidPtr, __node_base_type>
__node_base_pointer; __node_base_pointer;
typedef __tree_end_node<__node_base_pointer> __end_node_type; typedef __tree_end_node<__node_base_pointer> __end_node_type;
typedef typename __rebind_pointer<_VoidPtr, __end_node_type>::type typedef __rebind_pointer_t<_VoidPtr, __end_node_type>
__end_node_pointer; __end_node_pointer;
#if defined(_LIBCPP_ABI_TREE_REMOVE_NODE_POINTER_UB) #if defined(_LIBCPP_ABI_TREE_REMOVE_NODE_POINTER_UB)
typedef __end_node_pointer __parent_pointer; typedef __end_node_pointer __parent_pointer;
#else #else
typedef typename conditional< typedef typename conditional<
is_pointer<__end_node_pointer>::value, is_pointer<__end_node_pointer>::value,
__end_node_pointer, __end_node_pointer,
__node_base_pointer>::type __parent_pointer; __node_base_pointer>::type __parent_pointer;
#endif #endif
private: private:
static_assert((is_same<typename pointer_traits<_VoidPtr>::element_type, void>::value), static_assert((is_same<typename pointer_traits<_VoidPtr>::element_type, void>::value),
"_VoidPtr does not point to unqualified void type"); "_VoidPtr does not point to unqualified void type");
}; };
template <class _Tp, class _AllocPtr, class _KVTypes = __tree_key_value_types<_Tp>, template <class _Tp, class _AllocPtr, class _KVTypes = __tree_key_value_types<_Tp>,
bool = _KVTypes::__is_map> bool = _KVTypes::__is_map>
struct __tree_map_pointer_types {}; struct __tree_map_pointer_types {};
template <class _Tp, class _AllocPtr, class _KVTypes> template <class _Tp, class _AllocPtr, class _KVTypes>
struct __tree_map_pointer_types<_Tp, _AllocPtr, _KVTypes, true> { struct __tree_map_pointer_types<_Tp, _AllocPtr, _KVTypes, true> {
typedef typename _KVTypes::__map_value_type _Mv; typedef typename _KVTypes::__map_value_type _Mv;
typedef typename __rebind_pointer<_AllocPtr, _Mv>::type typedef __rebind_pointer_t<_AllocPtr, _Mv>
__map_value_type_pointer; __map_value_type_pointer;
typedef typename __rebind_pointer<_AllocPtr, const _Mv>::type typedef __rebind_pointer_t<_AllocPtr, const _Mv>
__const_map_value_type_pointer; __const_map_value_type_pointer;
}; };
template <class _NodePtr, class _NodeT = typename pointer_traits<_NodePtr>::element_type> template <class _NodePtr, class _NodeT = typename pointer_traits<_NodePtr>::element_type>
struct __tree_node_types; struct __tree_node_types;
template <class _NodePtr, class _Tp, class _VoidPtr> template <class _NodePtr, class _Tp, class _VoidPtr>
struct __tree_node_types<_NodePtr, __tree_node<_Tp, _VoidPtr> > struct __tree_node_types<_NodePtr, __tree_node<_Tp, _VoidPtr> >
: public __tree_node_base_types<_VoidPtr>, : public __tree_node_base_types<_VoidPtr>,
__tree_key_value_types<_Tp>, __tree_key_value_types<_Tp>,
__tree_map_pointer_types<_Tp, _VoidPtr> __tree_map_pointer_types<_Tp, _VoidPtr>
{ {
typedef __tree_node_base_types<_VoidPtr> __base; typedef __tree_node_base_types<_VoidPtr> __base;
typedef __tree_key_value_types<_Tp> __key_base; typedef __tree_key_value_types<_Tp> __key_base;
typedef __tree_map_pointer_types<_Tp, _VoidPtr> __map_pointer_base; typedef __tree_map_pointer_types<_Tp, _VoidPtr> __map_pointer_base;
public: public:
typedef typename pointer_traits<_NodePtr>::element_type __node_type; typedef typename pointer_traits<_NodePtr>::element_type __node_type;
typedef _NodePtr __node_pointer; typedef _NodePtr __node_pointer;
typedef _Tp __node_value_type; typedef _Tp __node_value_type;
typedef typename __rebind_pointer<_VoidPtr, __node_value_type>::type typedef __rebind_pointer_t<_VoidPtr, __node_value_type>
__node_value_type_pointer; __node_value_type_pointer;
typedef typename __rebind_pointer<_VoidPtr, const __node_value_type>::type typedef __rebind_pointer_t<_VoidPtr, const __node_value_type>
__const_node_value_type_pointer; __const_node_value_type_pointer;
#if defined(_LIBCPP_ABI_TREE_REMOVE_NODE_POINTER_UB) #if defined(_LIBCPP_ABI_TREE_REMOVE_NODE_POINTER_UB)
typedef typename __base::__end_node_pointer __iter_pointer; typedef typename __base::__end_node_pointer __iter_pointer;
#else #else
typedef typename conditional< typedef typename conditional<
is_pointer<__node_pointer>::value, is_pointer<__node_pointer>::value,
typename __base::__end_node_pointer, typename __base::__end_node_pointer,
__node_pointer>::type __iter_pointer; __node_pointer>::type __iter_pointer;
#endif #endif
private: private:
static_assert(!is_const<__node_type>::value, static_assert(!is_const<__node_type>::value,
"_NodePtr should never be a pointer to const"); "_NodePtr should never be a pointer to const");
static_assert((is_same<typename __rebind_pointer<_VoidPtr, __node_type>::type, static_assert((is_same<__rebind_pointer_t<_VoidPtr, __node_type>,
_NodePtr>::value), "_VoidPtr does not rebind to _NodePtr."); _NodePtr>::value), "_VoidPtr does not rebind to _NodePtr.");
}; };
template <class _ValueTp, class _VoidPtr> template <class _ValueTp, class _VoidPtr>
struct __make_tree_node_types { struct __make_tree_node_types {
typedef typename __rebind_pointer<_VoidPtr, __tree_node<_ValueTp, _VoidPtr> >::type typedef __rebind_pointer_t<_VoidPtr, __tree_node<_ValueTp, _VoidPtr> >
_NodePtr; _NodePtr;
typedef __tree_node_types<_NodePtr> type; typedef __tree_node_types<_NodePtr> type;
}; };
// node // node
template <class _Pointer> template <class _Pointer>
class __tree_end_node class __tree_end_node
▲ Show 20 Lines • Show All 550 Lines • ▼ Show 20 Lines#endif
} }
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
iterator __insert_unique(const_iterator __p, __container_value_type&& __v) { iterator __insert_unique(const_iterator __p, __container_value_type&& __v) {
return __emplace_hint_unique_key_args(__p, _NodeTypes::__get_key(__v), _VSTD::move(__v)).first; return __emplace_hint_unique_key_args(__p, _NodeTypes::__get_key(__v), _VSTD::move(__v)).first;
} }
template <class _Vp, template <class _Vp,
class = __enable_if_t<!is_same<typename __unconstref<_Vp>::type, __container_value_type>::value> > class = __enable_if_t<!is_same<__remove_const_ref_t<_Vp>, __container_value_type>::value> >
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
pair<iterator, bool> __insert_unique(_Vp&& __v) { pair<iterator, bool> __insert_unique(_Vp&& __v) {
return __emplace_unique(_VSTD::forward<_Vp>(__v)); return __emplace_unique(_VSTD::forward<_Vp>(__v));
} }
template <class _Vp, template <class _Vp,
class = __enable_if_t<!is_same<typename __unconstref<_Vp>::type, __container_value_type>::value> > class = __enable_if_t<!is_same<__remove_const_ref_t<_Vp>, __container_value_type>::value> >
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
iterator __insert_unique(const_iterator __p, _Vp&& __v) { iterator __insert_unique(const_iterator __p, _Vp&& __v) {
return __emplace_hint_unique(__p, _VSTD::forward<_Vp>(__v)); return __emplace_hint_unique(__p, _VSTD::forward<_Vp>(__v));
} }
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
iterator __insert_multi(__container_value_type&& __v) { iterator __insert_multi(__container_value_type&& __v) {
return __emplace_multi(_VSTD::move(__v)); return __emplace_multi(_VSTD::move(__v));
▲ Show 20 Lines • Show All 1,456 Lines • Show Last 20 Lines

libcxx/include/__tuple

Show First 20 Lines • Show All 322 Lines • ▼ Show 20 Lines
template <> template <>
struct __apply_cv_mf<true, false, true> { struct __apply_cv_mf<true, false, true> {
template <class _Tp> using __apply _LIBCPP_NODEBUG = volatile _Tp&; template <class _Tp> using __apply _LIBCPP_NODEBUG = volatile _Tp&;
}; };
template <> template <>
struct __apply_cv_mf<true, true, true> { struct __apply_cv_mf<true, true, true> {
template <class _Tp> using __apply _LIBCPP_NODEBUG = const volatile _Tp&; template <class _Tp> using __apply _LIBCPP_NODEBUG = const volatile _Tp&;
}; };
template <class _Tp, class _RawTp = typename remove_reference<_Tp>::type> template <class _Tp, class _RawTp = __libcpp_remove_reference_t<_Tp> >
using __apply_cv_t _LIBCPP_NODEBUG = __apply_cv_mf< using __apply_cv_t _LIBCPP_NODEBUG = __apply_cv_mf<
is_lvalue_reference<_Tp>::value, is_lvalue_reference<_Tp>::value,
is_const<_RawTp>::value, is_const<_RawTp>::value,
is_volatile<_RawTp>::value>; is_volatile<_RawTp>::value>;
// __make_tuple_types // __make_tuple_types
// __make_tuple_types<_Tuple<_Types...>, _Ep, _Sp>::type is a // __make_tuple_types<_Tuple<_Types...>, _Ep, _Sp>::type is a
Show All 18 Linesstruct __make_tuple_types_flat<array<_Vt, _Np>, __tuple_indices<_Idx...>> {
template <size_t> template <size_t>
using __value_type = _Vt; using __value_type = _Vt;
template <class _Tp, class _ApplyFn = __apply_cv_t<_Tp>> template <class _Tp, class _ApplyFn = __apply_cv_t<_Tp>>
using __apply_quals = __tuple_types< using __apply_quals = __tuple_types<
typename _ApplyFn::template __apply<__value_type<_Idx>>... typename _ApplyFn::template __apply<__value_type<_Idx>>...
>; >;
}; };
template <class _Tp, size_t _Ep = tuple_size<typename remove_reference<_Tp>::type>::value, template <class _Tp, size_t _Ep = tuple_size<__libcpp_remove_reference_t<_Tp> >::value,
size_t _Sp = 0, size_t _Sp = 0,
bool _SameSize = (_Ep == tuple_size<typename remove_reference<_Tp>::type>::value)> bool _SameSize = (_Ep == tuple_size<__libcpp_remove_reference_t<_Tp> >::value)>
struct __make_tuple_types struct __make_tuple_types
{ {
static_assert(_Sp <= _Ep, "__make_tuple_types input error"); static_assert(_Sp <= _Ep, "__make_tuple_types input error");
using _RawTp = typename remove_cv<typename remove_reference<_Tp>::type>::type; using _RawTp = __remove_cv_t<__libcpp_remove_reference_t<_Tp> >;
using _Maker = __make_tuple_types_flat<_RawTp, typename __make_tuple_indices<_Ep, _Sp>::type>; using _Maker = __make_tuple_types_flat<_RawTp, typename __make_tuple_indices<_Ep, _Sp>::type>;
using type = typename _Maker::template __apply_quals<_Tp>; using type = typename _Maker::template __apply_quals<_Tp>;
}; };
template <class ..._Types, size_t _Ep> template <class ..._Types, size_t _Ep>
struct __make_tuple_types<tuple<_Types...>, _Ep, 0, true> { struct __make_tuple_types<tuple<_Types...>, _Ep, 0, true> {
typedef _LIBCPP_NODEBUG __tuple_types<_Types...> type; typedef _LIBCPP_NODEBUG __tuple_types<_Types...> type;
}; };
Show All 22 Linesstruct __tuple_sfinae_base {
template <class _FromArgs, class _ToArgs> template <class _FromArgs, class _ToArgs>
using __convertible = decltype(__do_test<is_convertible>(_FromArgs{}, _ToArgs{})); using __convertible = decltype(__do_test<is_convertible>(_FromArgs{}, _ToArgs{}));
template <class _FromArgs, class _ToArgs> template <class _FromArgs, class _ToArgs>
using __assignable = decltype(__do_test<is_assignable>(_ToArgs{}, _FromArgs{})); using __assignable = decltype(__do_test<is_assignable>(_ToArgs{}, _FromArgs{}));
}; };
// __tuple_convertible // __tuple_convertible
template <class _Tp, class _Up, bool = __tuple_like<typename remove_reference<_Tp>::type>::value, template <class _Tp, class _Up, bool = __tuple_like<__libcpp_remove_reference_t<_Tp> >::value,
bool = __tuple_like<_Up>::value> bool = __tuple_like<_Up>::value>
struct __tuple_convertible struct __tuple_convertible
: public false_type {}; : public false_type {};
template <class _Tp, class _Up> template <class _Tp, class _Up>
struct __tuple_convertible<_Tp, _Up, true, true> struct __tuple_convertible<_Tp, _Up, true, true>
: public __tuple_sfinae_base::__convertible< : public __tuple_sfinae_base::__convertible<
typename __make_tuple_types<_Tp>::type typename __make_tuple_types<_Tp>::type
, typename __make_tuple_types<_Up>::type , typename __make_tuple_types<_Up>::type
> >
{}; {};
// __tuple_constructible // __tuple_constructible
template <class _Tp, class _Up, bool = __tuple_like<typename remove_reference<_Tp>::type>::value, template <class _Tp, class _Up, bool = __tuple_like<__libcpp_remove_reference_t<_Tp> >::value,
bool = __tuple_like<_Up>::value> bool = __tuple_like<_Up>::value>
struct __tuple_constructible struct __tuple_constructible
: public false_type {}; : public false_type {};
template <class _Tp, class _Up> template <class _Tp, class _Up>
struct __tuple_constructible<_Tp, _Up, true, true> struct __tuple_constructible<_Tp, _Up, true, true>
: public __tuple_sfinae_base::__constructible< : public __tuple_sfinae_base::__constructible<
typename __make_tuple_types<_Tp>::type typename __make_tuple_types<_Tp>::type
, typename __make_tuple_types<_Up>::type , typename __make_tuple_types<_Up>::type
> >
{}; {};
// __tuple_assignable // __tuple_assignable
template <class _Tp, class _Up, bool = __tuple_like<typename remove_reference<_Tp>::type>::value, template <class _Tp, class _Up, bool = __tuple_like<__libcpp_remove_reference_t<_Tp> >::value,
bool = __tuple_like<_Up>::value> bool = __tuple_like<_Up>::value>
struct __tuple_assignable struct __tuple_assignable
: public false_type {}; : public false_type {};
template <class _Tp, class _Up> template <class _Tp, class _Up>
struct __tuple_assignable<_Tp, _Up, true, true> struct __tuple_assignable<_Tp, _Up, true, true>
: public __tuple_sfinae_base::__assignable< : public __tuple_sfinae_base::__assignable<
typename __make_tuple_types<_Tp>::type typename __make_tuple_types<_Tp>::type
Show All 15 Lines
template <bool _IsTuple, class _SizeTrait, size_t _Expected> template <bool _IsTuple, class _SizeTrait, size_t _Expected>
struct __tuple_like_with_size_imp : false_type {}; struct __tuple_like_with_size_imp : false_type {};
template <class _SizeTrait, size_t _Expected> template <class _SizeTrait, size_t _Expected>
struct __tuple_like_with_size_imp<true, _SizeTrait, _Expected> struct __tuple_like_with_size_imp<true, _SizeTrait, _Expected>
: integral_constant<bool, _SizeTrait::value == _Expected> {}; : integral_constant<bool, _SizeTrait::value == _Expected> {};
template <class _Tuple, size_t _ExpectedSize, class _RawTuple = __uncvref_t<_Tuple> > template <class _Tuple, size_t _ExpectedSize, class _RawTuple = __remove_cvref_t<_Tuple> >
using __tuple_like_with_size _LIBCPP_NODEBUG = __tuple_like_with_size_imp< using __tuple_like_with_size _LIBCPP_NODEBUG = __tuple_like_with_size_imp<
__tuple_like<_RawTuple>::value, __tuple_like<_RawTuple>::value,
tuple_size<_RawTuple>, _ExpectedSize tuple_size<_RawTuple>, _ExpectedSize
>; >;
struct _LIBCPP_TYPE_VIS __check_tuple_constructor_fail { struct _LIBCPP_TYPE_VIS __check_tuple_constructor_fail {
static constexpr bool __enable_explicit_default() { return false; } static constexpr bool __enable_explicit_default() { return false; }
▲ Show 20 Lines • Show All 70 Lines • Show Last 20 Lines

libcxx/include/__type_traits/add_lvalue_reference.h

Show All 13 Lines
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if __has_builtin(__add_lvalue_reference) #if __has_builtin(__add_lvalue_reference)
template <class _Tp> template <class _Tp>
struct add_lvalue_reference { using __add_lvalue_reference_t = __add_lvalue_reference(_Tp);
using type _LIBCPP_NODEBUG = __add_lvalue_reference(_Tp);
};
#else #else
template <class _Tp, bool = __libcpp_is_referenceable<_Tp>::value> template <class _Tp, bool = __libcpp_is_referenceable<_Tp>::value>
struct __add_lvalue_reference_impl { struct __add_lvalue_reference_impl {
typedef _LIBCPP_NODEBUG _Tp type; typedef _LIBCPP_NODEBUG _Tp type;
}; };
template <class _Tp > struct __add_lvalue_reference_impl<_Tp, true> { typedef _LIBCPP_NODEBUG _Tp& type; }; template <class _Tp >
struct __add_lvalue_reference_impl<_Tp, true> {
typedef _LIBCPP_NODEBUG _Tp& type;
};
template <class _Tp>
using __add_lvalue_reference_t = typename __add_lvalue_reference_impl<_Tp>::type;
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS add_lvalue_reference
{typedef _LIBCPP_NODEBUG typename __add_lvalue_reference_impl<_Tp>::type type;};
#endif // __has_builtin(__add_lvalue_reference) #endif // __has_builtin(__add_lvalue_reference)
template <class _Tp>
struct add_lvalue_reference {
using type _LIBCPP_NODEBUG = __add_lvalue_reference_t<_Tp>;
};
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER > 11
template <class _Tp> using add_lvalue_reference_t = typename add_lvalue_reference<_Tp>::type; template <class _Tp> using add_lvalue_reference_t = __add_lvalue_reference_t<_Tp>;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_ADD_LVALUE_REFERENCE_H #endif // _LIBCPP___TYPE_TRAITS_ADD_LVALUE_REFERENCE_H

libcxx/include/__type_traits/add_pointer.h

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef _LIBCPP___TYPE_TRAITS_ADD_POINTER_H #ifndef _LIBCPP___TYPE_TRAITS_ADD_POINTER_H
#define _LIBCPP___TYPE_TRAITS_ADD_POINTER_H #define _LIBCPP___TYPE_TRAITS_ADD_POINTER_H
#include <__config> #include <__config>
#include <__type_traits/is_referenceable.h> #include <__type_traits/is_referenceable.h>
#include <__type_traits/is_same.h> #include <__type_traits/is_same.h>
#include <__type_traits/is_void.h>
#include <__type_traits/remove_cv.h> #include <__type_traits/remove_cv.h>
#include <__type_traits/remove_reference.h> #include <__type_traits/remove_reference.h>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if __has_builtin(__add_pointer) #if __has_builtin(__add_pointer)
template <class _Tp> template <class _Tp>
struct add_pointer { using __add_pointer_t = __add_pointer(_Tp);
using type _LIBCPP_NODEBUG = __add_pointer(_Tp);
};
#else #else
template <class _Tp, template <class _Tp,
bool = __libcpp_is_referenceable<_Tp>::value || _IsSame<typename remove_cv<_Tp>::type, void>::value> bool = __libcpp_is_referenceable<_Tp>::value || is_void<_Tp>::value>
struct __add_pointer_impl { struct __add_pointer_impl {
typedef _LIBCPP_NODEBUG typename remove_reference<_Tp>::type* type; typedef _LIBCPP_NODEBUG __libcpp_remove_reference_t<_Tp>* type;
}; };
template <class _Tp> struct __add_pointer_impl<_Tp, false> template <class _Tp> struct __add_pointer_impl<_Tp, false>
{typedef _LIBCPP_NODEBUG _Tp type;}; {typedef _LIBCPP_NODEBUG _Tp type;};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS add_pointer template <class _Tp>
{typedef _LIBCPP_NODEBUG typename __add_pointer_impl<_Tp>::type type;}; using __add_pointer_t = typename __add_pointer_impl<_Tp>::type;
#endif // __has_builtin(__add_pointer) #endif // __has_builtin(__add_pointer)
template <class _Tp>
struct add_pointer {
using type _LIBCPP_NODEBUG = __add_pointer_t<_Tp>;
};
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER > 11
template <class _Tp> using add_pointer_t = typename add_pointer<_Tp>::type; template <class _Tp> using add_pointer_t = __add_pointer_t<_Tp>;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_ADD_POINTER_H #endif // _LIBCPP___TYPE_TRAITS_ADD_POINTER_H

libcxx/include/__type_traits/add_rvalue_reference.h

Show All 13 Lines
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if __has_builtin(__add_rvalue_reference) #if __has_builtin(__add_rvalue_reference)
template <class _Tp> template <class _Tp>
struct add_rvalue_reference { using __add_rvalue_reference_t = __add_rvalue_reference(_Tp);
using type _LIBCPP_NODEBUG = __add_rvalue_reference(_Tp);
};
#else #else
template <class _Tp, bool = __libcpp_is_referenceable<_Tp>::value> template <class _Tp, bool = __libcpp_is_referenceable<_Tp>::value>
struct __add_rvalue_reference_impl { struct __add_rvalue_reference_impl {
typedef _LIBCPP_NODEBUG _Tp type; typedef _LIBCPP_NODEBUG _Tp type;
}; };
template <class _Tp > struct __add_rvalue_reference_impl<_Tp, true> { typedef _LIBCPP_NODEBUG _Tp&& type; }; template <class _Tp >
struct __add_rvalue_reference_impl<_Tp, true> {
typedef _LIBCPP_NODEBUG _Tp&& type;
};
template <class _Tp>
using __add_rvalue_reference_t = typename __add_rvalue_reference_impl<_Tp>::type;
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS add_rvalue_reference
{typedef _LIBCPP_NODEBUG typename __add_rvalue_reference_impl<_Tp>::type type;};
#endif // __has_builtin(__add_rvalue_reference) #endif // __has_builtin(__add_rvalue_reference)
template <class _Tp>
struct add_rvalue_reference {
using type = __add_rvalue_reference_t<_Tp>;
};
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER > 11
template <class _Tp> using add_rvalue_reference_t = typename add_rvalue_reference<_Tp>::type; template <class _Tp>
using add_rvalue_reference_t = __add_rvalue_reference_t<_Tp>;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_ADD_RVALUE_REFERENCE_H #endif // _LIBCPP___TYPE_TRAITS_ADD_RVALUE_REFERENCE_H

libcxx/include/__type_traits/apply_cv.h

Show All 15 Lines
#include <cstddef> #include <cstddef>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp, class _Up, bool = is_const<typename remove_reference<_Tp>::type>::value, template <class _Tp, class _Up, bool = is_const<__libcpp_remove_reference_t<_Tp> >::value,
bool = is_volatile<typename remove_reference<_Tp>::type>::value> bool = is_volatile<__libcpp_remove_reference_t<_Tp> >::value>
struct __apply_cv struct __apply_cv
{ {
typedef _LIBCPP_NODEBUG _Up type; typedef _LIBCPP_NODEBUG _Up type;
}; };
template <class _Tp, class _Up> template <class _Tp, class _Up>
struct __apply_cv<_Tp, _Up, true, false> struct __apply_cv<_Tp, _Up, true, false>
{ {
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

libcxx/include/__type_traits/can_extract_key.h

Show All 23 Lines
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
// These traits are used in __tree and __hash_table // These traits are used in __tree and __hash_table
struct __extract_key_fail_tag {}; struct __extract_key_fail_tag {};
struct __extract_key_self_tag {}; struct __extract_key_self_tag {};
struct __extract_key_first_tag {}; struct __extract_key_first_tag {};
template <class _ValTy, class _Key, template <class _ValTy, class _Key,
class _RawValTy = typename __unconstref<_ValTy>::type> class _RawValTy = __remove_const_ref_t<_ValTy> >
struct __can_extract_key struct __can_extract_key
: conditional<_IsSame<_RawValTy, _Key>::value, __extract_key_self_tag, : conditional<_IsSame<_RawValTy, _Key>::value, __extract_key_self_tag,
__extract_key_fail_tag>::type {}; __extract_key_fail_tag>::type {};
template <class _Pair, class _Key, class _First, class _Second> template <class _Pair, class _Key, class _First, class _Second>
struct __can_extract_key<_Pair, _Key, pair<_First, _Second> > struct __can_extract_key<_Pair, _Key, pair<_First, _Second> >
: conditional<_IsSame<typename remove_const<_First>::type, _Key>::value, : conditional<_IsSame<__remove_const_t<_First>, _Key>::value,
__extract_key_first_tag, __extract_key_fail_tag>::type {}; __extract_key_first_tag, __extract_key_fail_tag>::type {};
// __can_extract_map_key uses true_type/false_type instead of the tags. // __can_extract_map_key uses true_type/false_type instead of the tags.
// It returns true if _Key != _ContainerValueTy (the container is a map not a set) // It returns true if _Key != _ContainerValueTy (the container is a map not a set)
// and _ValTy == _Key. // and _ValTy == _Key.
template <class _ValTy, class _Key, class _ContainerValueTy, template <class _ValTy, class _Key, class _ContainerValueTy,
class _RawValTy = typename __unconstref<_ValTy>::type> class _RawValTy = __remove_const_ref_t<_ValTy> >
struct __can_extract_map_key struct __can_extract_map_key
: integral_constant<bool, _IsSame<_RawValTy, _Key>::value> {}; : integral_constant<bool, _IsSame<_RawValTy, _Key>::value> {};
// This specialization returns __extract_key_fail_tag for non-map containers // This specialization returns __extract_key_fail_tag for non-map containers
// because _Key == _ContainerValueTy // because _Key == _ContainerValueTy
template <class _ValTy, class _Key, class _RawValTy> template <class _ValTy, class _Key, class _RawValTy>
struct __can_extract_map_key<_ValTy, _Key, _Key, _RawValTy> struct __can_extract_map_key<_ValTy, _Key, _Key, _RawValTy>
: false_type {}; : false_type {};
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_CAN_EXTRACT_KEY_H #endif // _LIBCPP___TYPE_TRAITS_CAN_EXTRACT_KEY_H

libcxx/include/__type_traits/copy_cvref.h

Show All 23 Lines
struct __copy_cvref struct __copy_cvref
{ {
using type = __copy_cv_t<_From, _To>; using type = __copy_cv_t<_From, _To>;
}; };
template <class _From, class _To> template <class _From, class _To>
struct __copy_cvref<_From&, _To> struct __copy_cvref<_From&, _To>
{ {
using type = typename add_lvalue_reference<__copy_cv_t<_From, _To> >::type; using type = __add_lvalue_reference_t<__copy_cv_t<_From, _To> >;
}; };
template <class _From, class _To> template <class _From, class _To>
struct __copy_cvref<_From&&, _To> struct __copy_cvref<_From&&, _To>
{ {
using type = typename add_rvalue_reference<__copy_cv_t<_From, _To> >::type; using type = __add_rvalue_reference_t<__copy_cv_t<_From, _To> >;
}; };
template <class _From, class _To> template <class _From, class _To>
using __copy_cvref_t = typename __copy_cvref<_From, _To>::type; using __copy_cvref_t = typename __copy_cvref<_From, _To>::type;
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_COPY_CVREF_H #endif // _LIBCPP___TYPE_TRAITS_COPY_CVREF_H

libcxx/include/__type_traits/decay.h

Show All 27 Lines
#if __has_builtin(__decay) #if __has_builtin(__decay)
template <class _Tp> template <class _Tp>
struct decay { struct decay {
using type _LIBCPP_NODEBUG = __decay(_Tp); using type _LIBCPP_NODEBUG = __decay(_Tp);
}; };
#else #else
template <class _Up, bool> template <class _Up, bool>
struct __decay { struct __decay {
typedef _LIBCPP_NODEBUG typename remove_cv<_Up>::type type; typedef _LIBCPP_NODEBUG __remove_cv_t<_Up> type;
}; };
template <class _Up> template <class _Up>
struct __decay<_Up, true> { struct __decay<_Up, true> {
public: public:
typedef _LIBCPP_NODEBUG typename conditional typedef _LIBCPP_NODEBUG typename conditional
< <
is_array<_Up>::value, is_array<_Up>::value,
typename remove_extent<_Up>::type*, __remove_extent_t<_Up>*,
typename conditional typename conditional
< <
is_function<_Up>::value, is_function<_Up>::value,
typename add_pointer<_Up>::type, typename add_pointer<_Up>::type,
typename remove_cv<_Up>::type __remove_cv_t<_Up>
>::type >::type
>::type type; >::type type;
}; };
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS decay struct _LIBCPP_TEMPLATE_VIS decay
{ {
private: private:
typedef _LIBCPP_NODEBUG typename remove_reference<_Tp>::type _Up; typedef _LIBCPP_NODEBUG __libcpp_remove_reference_t<_Tp> _Up;
public: public:
typedef _LIBCPP_NODEBUG typename __decay<_Up, __libcpp_is_referenceable<_Up>::value>::type type; typedef _LIBCPP_NODEBUG typename __decay<_Up, __libcpp_is_referenceable<_Up>::value>::type type;
}; };
#endif // __has_builtin(__decay) #endif // __has_builtin(__decay)
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER > 11
template <class _Tp> using decay_t = typename decay<_Tp>::type; template <class _Tp> using decay_t = typename decay<_Tp>::type;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_DECAY_H #endif // _LIBCPP___TYPE_TRAITS_DECAY_H

libcxx/include/__type_traits/is_convertible.h

Show First 20 Lines • Show All 47 Lines • ▼ Show 20 Linestemplate <class _Tp, bool _IsArray = is_array<_Tp>::value,
bool _IsVoid = is_void<_Tp>::value> bool _IsVoid = is_void<_Tp>::value>
struct __is_array_function_or_void {enum {value = 0};}; 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, 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, true, false> {enum {value = 2};};
template <class _Tp> struct __is_array_function_or_void<_Tp, false, false, true> {enum {value = 3};}; template <class _Tp> struct __is_array_function_or_void<_Tp, false, false, true> {enum {value = 3};};
} }
template <class _Tp, template <class _Tp,
unsigned = __is_convertible_imp::__is_array_function_or_void<typename remove_reference<_Tp>::type>::value> unsigned = __is_convertible_imp::__is_array_function_or_void<__libcpp_remove_reference_t<_Tp> >::value>
struct __is_convertible_check struct __is_convertible_check
{ {
static const size_t __v = 0; static const size_t __v = 0;
}; };
template <class _Tp> template <class _Tp>
struct __is_convertible_check<_Tp, 0> struct __is_convertible_check<_Tp, 0>
{ {
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

libcxx/include/__type_traits/is_copy_assignable.h

Show All 18 Lines
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_copy_assignable struct _LIBCPP_TEMPLATE_VIS is_copy_assignable
: public integral_constant< : public integral_constant<
bool, bool,
__is_assignable(typename add_lvalue_reference<_Tp>::type, __is_assignable(__add_lvalue_reference_t<_Tp>,
typename add_lvalue_reference<typename add_const<_Tp>::type>::type)> {}; __add_lvalue_reference_t<typename add_const<_Tp>::type>)> {};
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER > 14
template <class _Tp> template <class _Tp>
inline constexpr bool is_copy_assignable_v = is_copy_assignable<_Tp>::value; inline constexpr bool is_copy_assignable_v = is_copy_assignable<_Tp>::value;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_COPY_ASSIGNABLE_H #endif // _LIBCPP___TYPE_TRAITS_IS_COPY_ASSIGNABLE_H

libcxx/include/__type_traits/is_copy_constructible.h

Show All 18 Lines
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_copy_constructible struct _LIBCPP_TEMPLATE_VIS is_copy_constructible
: public integral_constant< : public integral_constant<
bool, bool,
__is_constructible(_Tp, typename add_lvalue_reference<typename add_const<_Tp>::type>::type)> {}; __is_constructible(_Tp, __add_lvalue_reference_t<typename add_const<_Tp>::type>)> {};
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER > 14
template <class _Tp> template <class _Tp>
inline constexpr bool is_copy_constructible_v = is_copy_constructible<_Tp>::value; inline constexpr bool is_copy_constructible_v = is_copy_constructible<_Tp>::value;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_COPY_CONSTRUCTIBLE_H #endif // _LIBCPP___TYPE_TRAITS_IS_COPY_CONSTRUCTIBLE_H

libcxx/include/__type_traits/is_destructible.h

Show First 20 Lines • Show All 57 Lines • ▼ Show 20 Lines
}; };
template <class _Tp, bool> template <class _Tp, bool>
struct __destructible_imp; struct __destructible_imp;
template <class _Tp> template <class _Tp>
struct __destructible_imp<_Tp, false> struct __destructible_imp<_Tp, false>
: public integral_constant<bool, : public integral_constant<bool,
__is_destructor_wellformed<typename remove_all_extents<_Tp>::type>::value> {}; __is_destructor_wellformed<__remove_all_extents_t<_Tp> >::value> {};
template <class _Tp> template <class _Tp>
struct __destructible_imp<_Tp, true> struct __destructible_imp<_Tp, true>
: public true_type {}; : public true_type {};
template <class _Tp, bool> template <class _Tp, bool>
struct __destructible_false; struct __destructible_false;
Show All 28 Lines

libcxx/include/__type_traits/is_floating_point.h

Show All 19 Lines
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp> struct __libcpp_is_floating_point : public false_type {}; template <class _Tp> struct __libcpp_is_floating_point : public false_type {};
template <> struct __libcpp_is_floating_point<float> : public true_type {}; template <> struct __libcpp_is_floating_point<float> : public true_type {};
template <> struct __libcpp_is_floating_point<double> : public true_type {}; template <> struct __libcpp_is_floating_point<double> : public true_type {};
template <> struct __libcpp_is_floating_point<long double> : public true_type {}; template <> struct __libcpp_is_floating_point<long double> : public true_type {};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_floating_point template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_floating_point
: public __libcpp_is_floating_point<typename remove_cv<_Tp>::type> {}; : public __libcpp_is_floating_point<__remove_cv_t<_Tp> > {};
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER > 14
template <class _Tp> template <class _Tp>
inline constexpr bool is_floating_point_v = is_floating_point<_Tp>::value; inline constexpr bool is_floating_point_v = is_floating_point<_Tp>::value;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_FLOATING_POINT_H #endif // _LIBCPP___TYPE_TRAITS_IS_FLOATING_POINT_H

libcxx/include/__type_traits/is_integral.h

Show First 20 Lines • Show All 52 Lines • ▼ Show 20 Lines
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER > 14
template <class _Tp> template <class _Tp>
inline constexpr bool is_integral_v = __is_integral(_Tp); inline constexpr bool is_integral_v = __is_integral(_Tp);
#endif #endif
#else #else
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_integral template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_integral
: public _BoolConstant<__libcpp_is_integral<typename remove_cv<_Tp>::type>::value> {}; : public _BoolConstant<__libcpp_is_integral<__remove_cv_t<_Tp> >::value> {};
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER > 14
template <class _Tp> template <class _Tp>
inline constexpr bool is_integral_v = is_integral<_Tp>::value; inline constexpr bool is_integral_v = is_integral<_Tp>::value;
#endif #endif
#endif // __has_builtin(__is_integral) #endif // __has_builtin(__is_integral)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_INTEGRAL_H #endif // _LIBCPP___TYPE_TRAITS_IS_INTEGRAL_H

libcxx/include/__type_traits/is_member_function_pointer.h

Show First 20 Lines • Show All 44 Lines • ▼ Show 20 Lines
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER > 14
template <class _Tp> template <class _Tp>
inline constexpr bool is_member_function_pointer_v = __is_member_function_pointer(_Tp); inline constexpr bool is_member_function_pointer_v = __is_member_function_pointer(_Tp);
#endif #endif
#else // __has_builtin(__is_member_function_pointer) #else // __has_builtin(__is_member_function_pointer)
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_member_function_pointer template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_member_function_pointer
: public _BoolConstant< __libcpp_is_member_pointer<typename remove_cv<_Tp>::type>::__is_func > {}; : public _BoolConstant< __libcpp_is_member_pointer<__remove_cv_t<_Tp> >::__is_func > {};
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER > 14
template <class _Tp> template <class _Tp>
inline constexpr bool is_member_function_pointer_v = is_member_function_pointer<_Tp>::value; inline constexpr bool is_member_function_pointer_v = is_member_function_pointer<_Tp>::value;
#endif #endif
#endif // __has_builtin(__is_member_function_pointer) #endif // __has_builtin(__is_member_function_pointer)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_MEMBER_FUNCTION_POINTER_H #endif // _LIBCPP___TYPE_TRAITS_IS_MEMBER_FUNCTION_POINTER_H

libcxx/include/__type_traits/is_member_object_pointer.h

Show All 26 Lines
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER > 14
template <class _Tp> template <class _Tp>
inline constexpr bool is_member_object_pointer_v = __is_member_object_pointer(_Tp); inline constexpr bool is_member_object_pointer_v = __is_member_object_pointer(_Tp);
#endif #endif
#else // __has_builtin(__is_member_object_pointer) #else // __has_builtin(__is_member_object_pointer)
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_member_object_pointer template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_member_object_pointer
: public _BoolConstant< __libcpp_is_member_pointer<typename remove_cv<_Tp>::type>::__is_obj > {}; : public _BoolConstant< __libcpp_is_member_pointer<__remove_cv_t<_Tp> >::__is_obj > {};
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER > 14
template <class _Tp> template <class _Tp>
inline constexpr bool is_member_object_pointer_v = is_member_object_pointer<_Tp>::value; inline constexpr bool is_member_object_pointer_v = is_member_object_pointer<_Tp>::value;
#endif #endif
#endif // __has_builtin(__is_member_object_pointer) #endif // __has_builtin(__is_member_object_pointer)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_MEMBER_FUNCTION_POINTER_H #endif // _LIBCPP___TYPE_TRAITS_IS_MEMBER_FUNCTION_POINTER_H

libcxx/include/__type_traits/is_member_pointer.h

Show All 25 Lines
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER > 14
template <class _Tp> template <class _Tp>
inline constexpr bool is_member_pointer_v = __is_member_pointer(_Tp); inline constexpr bool is_member_pointer_v = __is_member_pointer(_Tp);
#endif #endif
#else // __has_builtin(__is_member_pointer) #else // __has_builtin(__is_member_pointer)
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_member_pointer template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_member_pointer
: public _BoolConstant< __libcpp_is_member_pointer<typename remove_cv<_Tp>::type>::__is_member > {}; : public _BoolConstant< __libcpp_is_member_pointer<__remove_cv_t<_Tp> >::__is_member > {};
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER > 14
template <class _Tp> template <class _Tp>
inline constexpr bool is_member_pointer_v = is_member_pointer<_Tp>::value; inline constexpr bool is_member_pointer_v = is_member_pointer<_Tp>::value;
#endif #endif
#endif // __has_builtin(__is_member_pointer) #endif // __has_builtin(__is_member_pointer)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_MEMBER_POINTER_H #endif // _LIBCPP___TYPE_TRAITS_IS_MEMBER_POINTER_H

libcxx/include/__type_traits/is_move_assignable.h

Show All 18 Lines
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_move_assignable struct _LIBCPP_TEMPLATE_VIS is_move_assignable
: public integral_constant< : public integral_constant<
bool, bool,
__is_assignable(typename add_lvalue_reference<_Tp>::type, typename add_rvalue_reference<_Tp>::type)> {}; __is_assignable(__add_lvalue_reference_t<_Tp>, __add_rvalue_reference_t<_Tp>)> {};
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER > 14
template <class _Tp> template <class _Tp>
inline constexpr bool is_move_assignable_v = is_move_assignable<_Tp>::value; inline constexpr bool is_move_assignable_v = is_move_assignable<_Tp>::value;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_MOVE_ASSIGNABLE_H #endif // _LIBCPP___TYPE_TRAITS_IS_MOVE_ASSIGNABLE_H

libcxx/include/__type_traits/is_move_constructible.h

Show All 15 Lines
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_move_constructible struct _LIBCPP_TEMPLATE_VIS is_move_constructible
: public integral_constant<bool, __is_constructible(_Tp, typename add_rvalue_reference<_Tp>::type)> : public integral_constant<bool, __is_constructible(_Tp, __add_rvalue_reference_t<_Tp>)>
{}; {};
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER > 14
template <class _Tp> template <class _Tp>
inline constexpr bool is_move_constructible_v = is_move_constructible<_Tp>::value; inline constexpr bool is_move_constructible_v = is_move_constructible<_Tp>::value;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_MOVE_CONSTRUCTIBLE_H #endif // _LIBCPP___TYPE_TRAITS_IS_MOVE_CONSTRUCTIBLE_H

libcxx/include/__type_traits/is_nothrow_copy_assignable.h

Show All 19 Lines
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_nothrow_copy_assignable struct _LIBCPP_TEMPLATE_VIS is_nothrow_copy_assignable
: public integral_constant< : public integral_constant<
bool, bool,
__is_nothrow_assignable( __is_nothrow_assignable(
typename add_lvalue_reference<_Tp>::type, __add_lvalue_reference_t<_Tp>,
typename add_lvalue_reference<typename add_const<_Tp>::type>::type)> {}; __add_lvalue_reference_t<typename add_const<_Tp>::type>)> {};
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER > 14
template <class _Tp> template <class _Tp>
inline constexpr bool is_nothrow_copy_assignable_v = is_nothrow_copy_assignable<_Tp>::value; inline constexpr bool is_nothrow_copy_assignable_v = is_nothrow_copy_assignable<_Tp>::value;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_NOTHROW_COPY_ASSIGNABLE_H #endif // _LIBCPP___TYPE_TRAITS_IS_NOTHROW_COPY_ASSIGNABLE_H

libcxx/include/__type_traits/is_nothrow_copy_constructible.h

Show All 20 Lines
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
// TODO: remove this implementation once https://gcc.gnu.org/bugzilla/show_bug.cgi?id=106611 is fixed // TODO: remove this implementation once https://gcc.gnu.org/bugzilla/show_bug.cgi?id=106611 is fixed
#ifdef _LIBCPP_COMPILER_GCC #ifdef _LIBCPP_COMPILER_GCC
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_nothrow_copy_constructible template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_nothrow_copy_constructible
: public is_nothrow_constructible<_Tp, : public is_nothrow_constructible<_Tp,
typename add_lvalue_reference<typename add_const<_Tp>::type>::type> {}; __add_lvalue_reference_t<typename add_const<_Tp>::type> > {};
#else // _LIBCPP_COMPILER_GCC #else // _LIBCPP_COMPILER_GCC
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_nothrow_copy_constructible struct _LIBCPP_TEMPLATE_VIS is_nothrow_copy_constructible
: public integral_constant< : public integral_constant<
bool, bool,
__is_nothrow_constructible(_Tp, typename add_lvalue_reference<typename add_const<_Tp>::type>::type)> {}; __is_nothrow_constructible(_Tp, typename add_lvalue_reference<typename add_const<_Tp>::type>::type)> {};
Show All 11 Lines

libcxx/include/__type_traits/is_nothrow_destructible.h

Show First 20 Lines • Show All 65 Lines • ▼ Show 20 Lines
#else #else
template <class _Tp> struct __libcpp_nothrow_destructor template <class _Tp> struct __libcpp_nothrow_destructor
: public integral_constant<bool, is_scalar<_Tp>::value || : public integral_constant<bool, is_scalar<_Tp>::value ||
is_reference<_Tp>::value> {}; is_reference<_Tp>::value> {};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_nothrow_destructible template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_nothrow_destructible
: public __libcpp_nothrow_destructor<typename remove_all_extents<_Tp>::type> {}; : public __libcpp_nothrow_destructor<__remove_all_extents_t<_Tp> > {};
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_nothrow_destructible<_Tp[]> struct _LIBCPP_TEMPLATE_VIS is_nothrow_destructible<_Tp[]>
: public false_type {}; : public false_type {};
#endif #endif
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER > 14
template <class _Tp> template <class _Tp>
inline constexpr bool is_nothrow_destructible_v = is_nothrow_destructible<_Tp>::value; inline constexpr bool is_nothrow_destructible_v = is_nothrow_destructible<_Tp>::value;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_NOTHROW_DESTRUCTIBLE_H #endif // _LIBCPP___TYPE_TRAITS_IS_NOTHROW_DESTRUCTIBLE_H

libcxx/include/__type_traits/is_nothrow_move_assignable.h

Show All 18 Lines
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_nothrow_move_assignable struct _LIBCPP_TEMPLATE_VIS is_nothrow_move_assignable
: public integral_constant< : public integral_constant<
bool, bool,
__is_nothrow_assignable(typename add_lvalue_reference<_Tp>::type, typename add_rvalue_reference<_Tp>::type)> { __is_nothrow_assignable(__add_lvalue_reference_t<_Tp>, __add_rvalue_reference_t<_Tp>)> {
}; };
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER > 14
template <class _Tp> template <class _Tp>
inline constexpr bool is_nothrow_move_assignable_v = is_nothrow_move_assignable<_Tp>::value; inline constexpr bool is_nothrow_move_assignable_v = is_nothrow_move_assignable<_Tp>::value;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_NOTHROW_MOVE_ASSIGNABLE_H #endif // _LIBCPP___TYPE_TRAITS_IS_NOTHROW_MOVE_ASSIGNABLE_H

libcxx/include/__type_traits/is_nothrow_move_constructible.h

Show All 18 Lines
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
// TODO: remove this implementation once https://gcc.gnu.org/bugzilla/show_bug.cgi?id=106611 is fixed // TODO: remove this implementation once https://gcc.gnu.org/bugzilla/show_bug.cgi?id=106611 is fixed
#ifndef _LIBCPP_COMPILER_GCC #ifndef _LIBCPP_COMPILER_GCC
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_nothrow_move_constructible template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_nothrow_move_constructible
: public integral_constant<bool, __is_nothrow_constructible(_Tp, typename add_rvalue_reference<_Tp>::type)> : public integral_constant<bool, __is_nothrow_constructible(_Tp, __add_rvalue_reference_t<_Tp>)>
{}; {};
#else // _LIBCPP_COMPILER_GCC #else // _LIBCPP_COMPILER_GCC
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_nothrow_move_constructible template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_nothrow_move_constructible
: public is_nothrow_constructible<_Tp, typename add_rvalue_reference<_Tp>::type> : public is_nothrow_constructible<_Tp, __add_rvalue_reference_t<_Tp> >
{}; {};
#endif // _LIBCPP_COMPILER_GCC #endif // _LIBCPP_COMPILER_GCC
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER > 14
template <class _Tp> template <class _Tp>
inline constexpr bool is_nothrow_move_constructible_v = is_nothrow_move_constructible<_Tp>::value; inline constexpr bool is_nothrow_move_constructible_v = is_nothrow_move_constructible<_Tp>::value;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_NOTHROW_MOVE_CONSTRUCTIBLE_H #endif // _LIBCPP___TYPE_TRAITS_IS_NOTHROW_MOVE_CONSTRUCTIBLE_H

libcxx/include/__type_traits/is_null_pointer.h

Show All 18 Lines
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp> struct __is_nullptr_t_impl : public false_type {}; template <class _Tp> struct __is_nullptr_t_impl : public false_type {};
template <> struct __is_nullptr_t_impl<nullptr_t> : public true_type {}; template <> struct __is_nullptr_t_impl<nullptr_t> : public true_type {};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS __is_nullptr_t template <class _Tp> struct _LIBCPP_TEMPLATE_VIS __is_nullptr_t
: public __is_nullptr_t_impl<typename remove_cv<_Tp>::type> {}; : public __is_nullptr_t_impl<__remove_cv_t<_Tp> > {};
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER > 11
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_null_pointer template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_null_pointer
: public __is_nullptr_t_impl<typename remove_cv<_Tp>::type> {}; : public __is_nullptr_t_impl<__remove_cv_t<_Tp> > {};
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER > 14
template <class _Tp> template <class _Tp>
inline constexpr bool is_null_pointer_v = is_null_pointer<_Tp>::value; inline constexpr bool is_null_pointer_v = is_null_pointer<_Tp>::value;
#endif #endif
#endif // _LIBCPP_STD_VER > 11 #endif // _LIBCPP_STD_VER > 11
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_NULL_POINTER_H #endif // _LIBCPP___TYPE_TRAITS_IS_NULL_POINTER_H

libcxx/include/__type_traits/is_pointer.h

Show All 37 Lines
#if defined(_LIBCPP_HAS_OBJC_ARC) #if defined(_LIBCPP_HAS_OBJC_ARC)
template <class _Tp> struct __libcpp_remove_objc_qualifiers<_Tp __strong> { typedef _Tp type; }; template <class _Tp> struct __libcpp_remove_objc_qualifiers<_Tp __strong> { typedef _Tp type; };
template <class _Tp> struct __libcpp_remove_objc_qualifiers<_Tp __weak> { typedef _Tp type; }; template <class _Tp> struct __libcpp_remove_objc_qualifiers<_Tp __weak> { typedef _Tp type; };
template <class _Tp> struct __libcpp_remove_objc_qualifiers<_Tp __autoreleasing> { typedef _Tp type; }; template <class _Tp> struct __libcpp_remove_objc_qualifiers<_Tp __autoreleasing> { typedef _Tp type; };
template <class _Tp> struct __libcpp_remove_objc_qualifiers<_Tp __unsafe_unretained> { typedef _Tp type; }; template <class _Tp> struct __libcpp_remove_objc_qualifiers<_Tp __unsafe_unretained> { typedef _Tp type; };
#endif #endif
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_pointer template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_pointer
: public __libcpp_is_pointer<typename __libcpp_remove_objc_qualifiers<typename remove_cv<_Tp>::type>::type> {}; : public __libcpp_is_pointer<typename __libcpp_remove_objc_qualifiers<__remove_cv_t<_Tp> >::type> {};
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER > 14
template <class _Tp> template <class _Tp>
inline constexpr bool is_pointer_v = is_pointer<_Tp>::value; inline constexpr bool is_pointer_v = is_pointer<_Tp>::value;
#endif #endif
#endif // __has_builtin(__is_pointer) #endif // __has_builtin(__is_pointer)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_POINTER_H #endif // _LIBCPP___TYPE_TRAITS_IS_POINTER_H

libcxx/include/__type_traits/is_reference_wrapper.h

Show All 18 Lines
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp> class _LIBCPP_TEMPLATE_VIS reference_wrapper; template <class _Tp> class _LIBCPP_TEMPLATE_VIS reference_wrapper;
template <class _Tp> struct __is_reference_wrapper_impl : public false_type {}; template <class _Tp> struct __is_reference_wrapper_impl : public false_type {};
template <class _Tp> struct __is_reference_wrapper_impl<reference_wrapper<_Tp> > : public true_type {}; template <class _Tp> struct __is_reference_wrapper_impl<reference_wrapper<_Tp> > : public true_type {};
template <class _Tp> struct __is_reference_wrapper template <class _Tp> struct __is_reference_wrapper
: public __is_reference_wrapper_impl<typename remove_cv<_Tp>::type> {}; : public __is_reference_wrapper_impl<__remove_cv_t<_Tp> > {};
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_ENABLE_IF_H #endif // _LIBCPP___TYPE_TRAITS_ENABLE_IF_H

libcxx/include/__type_traits/is_swappable.h

Show First 20 Lines • Show All 115 Lines • ▼ Show 20 Lines
{ {
}; };
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_swappable struct _LIBCPP_TEMPLATE_VIS is_swappable
: public conditional< : public conditional<
__libcpp_is_referenceable<_Tp>::value, __libcpp_is_referenceable<_Tp>::value,
is_swappable_with< is_swappable_with<
typename add_lvalue_reference<_Tp>::type, __add_lvalue_reference_t<_Tp>,
typename add_lvalue_reference<_Tp>::type>, __add_lvalue_reference_t<_Tp> >,
false_type false_type
>::type >::type
{ {
}; };
template <class _Tp, class _Up> template <class _Tp, class _Up>
struct _LIBCPP_TEMPLATE_VIS is_nothrow_swappable_with struct _LIBCPP_TEMPLATE_VIS is_nothrow_swappable_with
: public integral_constant<bool, __detail::__nothrow_swappable_with<_Tp, _Up>::value> : public integral_constant<bool, __detail::__nothrow_swappable_with<_Tp, _Up>::value>
{ {
}; };
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_nothrow_swappable struct _LIBCPP_TEMPLATE_VIS is_nothrow_swappable
: public conditional< : public conditional<
__libcpp_is_referenceable<_Tp>::value, __libcpp_is_referenceable<_Tp>::value,
is_nothrow_swappable_with< is_nothrow_swappable_with<
typename add_lvalue_reference<_Tp>::type, __add_lvalue_reference_t<_Tp>,
typename add_lvalue_reference<_Tp>::type>, __add_lvalue_reference_t<_Tp> >,
false_type false_type
>::type >::type
{ {
}; };
template <class _Tp, class _Up> template <class _Tp, class _Up>
inline constexpr bool is_swappable_with_v = is_swappable_with<_Tp, _Up>::value; inline constexpr bool is_swappable_with_v = is_swappable_with<_Tp, _Up>::value;
Show All 14 Lines

libcxx/include/__type_traits/is_trivially_copy_assignable.h

Show All 19 Lines
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_trivially_copy_assignable struct _LIBCPP_TEMPLATE_VIS is_trivially_copy_assignable
: public integral_constant< : public integral_constant<
bool, bool,
__is_trivially_assignable( __is_trivially_assignable(
typename add_lvalue_reference<_Tp>::type, __add_lvalue_reference_t<_Tp>,
typename add_lvalue_reference<typename add_const<_Tp>::type>::type)> {}; __add_lvalue_reference_t<typename add_const<_Tp>::type>)> {};
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER > 14
template <class _Tp> template <class _Tp>
inline constexpr bool is_trivially_copy_assignable_v = is_trivially_copy_assignable<_Tp>::value; inline constexpr bool is_trivially_copy_assignable_v = is_trivially_copy_assignable<_Tp>::value;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_TRIVIALLY_COPY_ASSIGNABLE_H #endif // _LIBCPP___TYPE_TRAITS_IS_TRIVIALLY_COPY_ASSIGNABLE_H

libcxx/include/__type_traits/is_trivially_copy_constructible.h

Show All 14 Lines
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_trivially_copy_constructible template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_trivially_copy_constructible
: public integral_constant<bool, __is_trivially_constructible(_Tp, typename add_lvalue_reference<const _Tp>::type)> : public integral_constant<bool, __is_trivially_constructible(_Tp, __add_lvalue_reference_t<const _Tp>)>
{}; {};
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER > 14
template <class _Tp> template <class _Tp>
inline constexpr bool is_trivially_copy_constructible_v = is_trivially_copy_constructible<_Tp>::value; inline constexpr bool is_trivially_copy_constructible_v = is_trivially_copy_constructible<_Tp>::value;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_TRIVIALLY_COPY_CONSTRUCTIBLE_H #endif // _LIBCPP___TYPE_TRAITS_IS_TRIVIALLY_COPY_CONSTRUCTIBLE_H

libcxx/include/__type_traits/is_trivially_move_assignable.h

Show All 18 Lines
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_trivially_move_assignable struct _LIBCPP_TEMPLATE_VIS is_trivially_move_assignable
: public integral_constant< : public integral_constant<
bool, bool,
__is_trivially_assignable( __is_trivially_assignable(__add_lvalue_reference_t<_Tp>, __add_rvalue_reference_t<_Tp>)> {};
typename add_lvalue_reference<_Tp>::type, typename add_rvalue_reference<_Tp>::type)> {};
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER > 14
template <class _Tp> template <class _Tp>
inline constexpr bool is_trivially_move_assignable_v = is_trivially_move_assignable<_Tp>::value; inline constexpr bool is_trivially_move_assignable_v = is_trivially_move_assignable<_Tp>::value;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_TRIVIALLY_MOVE_ASSIGNABLE_H #endif // _LIBCPP___TYPE_TRAITS_IS_TRIVIALLY_MOVE_ASSIGNABLE_H

libcxx/include/__type_traits/is_trivially_move_constructible.h

Show All 15 Lines
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_trivially_move_constructible struct _LIBCPP_TEMPLATE_VIS is_trivially_move_constructible
: public integral_constant<bool, __is_trivially_constructible(_Tp, typename add_rvalue_reference<_Tp>::type)> {}; : public integral_constant<bool, __is_trivially_constructible(_Tp, __add_rvalue_reference_t<_Tp>)> {};
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER > 14
template <class _Tp> template <class _Tp>
inline constexpr bool is_trivially_move_constructible_v = is_trivially_move_constructible<_Tp>::value; inline constexpr bool is_trivially_move_constructible_v = is_trivially_move_constructible<_Tp>::value;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_TRIVIALLY_MOVE_CONSTRUCTIBLE_H #endif // _LIBCPP___TYPE_TRAITS_IS_TRIVIALLY_MOVE_CONSTRUCTIBLE_H

libcxx/include/__type_traits/is_void.h

Show All 25 Lines
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER > 14
template <class _Tp> template <class _Tp>
inline constexpr bool is_void_v = __is_void(_Tp); inline constexpr bool is_void_v = __is_void(_Tp);
#endif #endif
#else #else
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_void template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_void
: public is_same<typename remove_cv<_Tp>::type, void> {}; : public is_same<__remove_cv_t<_Tp>, void> {};
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER > 14
template <class _Tp> template <class _Tp>
inline constexpr bool is_void_v = is_void<_Tp>::value; inline constexpr bool is_void_v = is_void<_Tp>::value;
#endif #endif
#endif // __has_builtin(__is_void) #endif // __has_builtin(__is_void)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_VOID_H #endif // _LIBCPP___TYPE_TRAITS_IS_VOID_H

libcxx/include/__type_traits/make_const_lvalue_ref.h

Show All 13 Lines
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template<class _Tp> template<class _Tp>
using __make_const_lvalue_ref = const typename remove_reference<_Tp>::type&; using __make_const_lvalue_ref = const __libcpp_remove_reference_t<_Tp>&;
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_MAKE_CONST_LVALUE_REF_H #endif // _LIBCPP___TYPE_TRAITS_MAKE_CONST_LVALUE_REF_H

libcxx/include/__type_traits/make_signed.h

Show All 18 Lines
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if __has_builtin(__make_signed) #if __has_builtin(__make_signed)
template <class _Tp> template <class _Tp>
struct make_signed { using __make_signed_t = __make_signed(_Tp);
using type _LIBCPP_NODEBUG = __make_signed(_Tp);
};
#else #else
typedef typedef
__type_list<signed char, __type_list<signed char,
__type_list<signed short, __type_list<signed short,
__type_list<signed int, __type_list<signed int,
__type_list<signed long, __type_list<signed long,
__type_list<signed long long, __type_list<signed long long,
# ifndef _LIBCPP_HAS_NO_INT128 # ifndef _LIBCPP_HAS_NO_INT128
Show All 24 Lines
template <> struct __make_signed< signed long long, true> {typedef long 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 <> struct __make_signed<unsigned long long, true> {typedef long long type;};
# ifndef _LIBCPP_HAS_NO_INT128 # ifndef _LIBCPP_HAS_NO_INT128
template <> struct __make_signed<__int128_t, true> {typedef __int128_t type;}; template <> struct __make_signed<__int128_t, true> {typedef __int128_t type;};
template <> struct __make_signed<__uint128_t, true> {typedef __int128_t type;}; template <> struct __make_signed<__uint128_t, true> {typedef __int128_t type;};
# endif # endif
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS make_signed using __make_signed_t = typename __apply_cv<_Tp, typename __make_signed<__remove_cv_t<_Tp> >::type>::type;
{
typedef typename __apply_cv<_Tp, typename __make_signed<typename remove_cv<_Tp>::type>::type>::type type;
};
#endif // __has_builtin(__make_signed) #endif // __has_builtin(__make_signed)
template <class _Tp>
struct make_signed {
using type _LIBCPP_NODEBUG = __make_signed_t<_Tp>;
};
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER > 11
template <class _Tp> using make_signed_t = typename make_signed<_Tp>::type; template <class _Tp> using make_signed_t = __make_signed_t<_Tp>;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_MAKE_SIGNED_H #endif // _LIBCPP___TYPE_TRAITS_MAKE_SIGNED_H

libcxx/include/__type_traits/make_unsigned.h

Show All 20 Lines
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if __has_builtin(__make_unsigned) #if __has_builtin(__make_unsigned)
template <class _Tp> template <class _Tp>
struct make_unsigned { using __make_unsigned_t = __make_unsigned(_Tp);
using type _LIBCPP_NODEBUG = __make_unsigned(_Tp);
};
#else #else
typedef typedef
__type_list<unsigned char, __type_list<unsigned char,
__type_list<unsigned short, __type_list<unsigned short,
__type_list<unsigned int, __type_list<unsigned int,
__type_list<unsigned long, __type_list<unsigned long,
__type_list<unsigned long long, __type_list<unsigned long long,
# ifndef _LIBCPP_HAS_NO_INT128 # ifndef _LIBCPP_HAS_NO_INT128
Show All 24 Lines
template <> struct __make_unsigned< signed long long, true> {typedef unsigned long 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 <> struct __make_unsigned<unsigned long long, true> {typedef unsigned long long type;};
# ifndef _LIBCPP_HAS_NO_INT128 # ifndef _LIBCPP_HAS_NO_INT128
template <> struct __make_unsigned<__int128_t, true> {typedef __uint128_t type;}; template <> struct __make_unsigned<__int128_t, true> {typedef __uint128_t type;};
template <> struct __make_unsigned<__uint128_t, true> {typedef __uint128_t type;}; template <> struct __make_unsigned<__uint128_t, true> {typedef __uint128_t type;};
# endif # endif
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS make_unsigned using __make_unsigned_t = typename __apply_cv<_Tp, typename __make_unsigned<__remove_cv_t<_Tp> >::type>::type;
{
typedef typename __apply_cv<_Tp, typename __make_unsigned<typename remove_cv<_Tp>::type>::type>::type type;
};
#endif // __has_builtin(__make_unsigned) #endif // __has_builtin(__make_unsigned)
template <class _Tp>
struct make_unsigned {
using type _LIBCPP_NODEBUG = __make_unsigned_t<_Tp>;
};
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER > 11
template <class _Tp> using make_unsigned_t = typename make_unsigned<_Tp>::type; template <class _Tp> using make_unsigned_t = __make_unsigned_t<_Tp>;
#endif #endif
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
template <class _Tp> template <class _Tp>
_LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_HIDE_FROM_ABI constexpr
typename make_unsigned<_Tp>::type __to_unsigned_like(_Tp __x) noexcept { __make_unsigned_t<_Tp> __to_unsigned_like(_Tp __x) noexcept {
return static_cast<typename make_unsigned<_Tp>::type>(__x); return static_cast<__make_unsigned_t<_Tp> >(__x);
} }
#endif #endif
template <class _Tp, class _Up> template <class _Tp, class _Up>
using __copy_unsigned_t = __conditional_t<is_unsigned<_Tp>::value, typename make_unsigned<_Up>::type, _Up>; using __copy_unsigned_t = __conditional_t<is_unsigned<_Tp>::value, __make_unsigned_t<_Up>, _Up>;
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_MAKE_UNSIGNED_H #endif // _LIBCPP___TYPE_TRAITS_MAKE_UNSIGNED_H

libcxx/include/__type_traits/remove_all_extents.h

Show All 17 Lines
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if __has_builtin(__remove_all_extents) #if __has_builtin(__remove_all_extents)
template <class _Tp> template <class _Tp>
struct remove_all_extents { struct remove_all_extents {
using type _LIBCPP_NODEBUG = __remove_all_extents(_Tp); using type _LIBCPP_NODEBUG = __remove_all_extents(_Tp);
}; };
template <class _Tp>
using __remove_all_extents_t = __remove_all_extents(_Tp);
#else #else
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_all_extents template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_all_extents
{typedef _Tp type;}; {typedef _Tp type;};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_all_extents<_Tp[]> template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_all_extents<_Tp[]>
{typedef typename remove_all_extents<_Tp>::type type;}; {typedef typename remove_all_extents<_Tp>::type type;};
template <class _Tp, size_t _Np> struct _LIBCPP_TEMPLATE_VIS remove_all_extents<_Tp[_Np]> template <class _Tp, size_t _Np> struct _LIBCPP_TEMPLATE_VIS remove_all_extents<_Tp[_Np]>
{typedef typename remove_all_extents<_Tp>::type type;}; {typedef typename remove_all_extents<_Tp>::type type;};
template <class _Tp>
using __remove_all_extents_t = typename remove_all_extents<_Tp>::type;
#endif // __has_builtin(__remove_all_extents) #endif // __has_builtin(__remove_all_extents)
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER > 11
template <class _Tp> using remove_all_extents_t = typename remove_all_extents<_Tp>::type; template <class _Tp> using remove_all_extents_t = __remove_all_extents_t<_Tp>;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_REMOVE_ALL_EXTENTS_H #endif // _LIBCPP___TYPE_TRAITS_REMOVE_ALL_EXTENTS_H

libcxx/include/__type_traits/remove_const.h

Show All 16 Lines
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if __has_builtin(__remove_const) #if __has_builtin(__remove_const)
template <class _Tp> template <class _Tp>
struct remove_const { struct remove_const {
using type _LIBCPP_NODEBUG = __remove_const(_Tp); using type _LIBCPP_NODEBUG = __remove_const(_Tp);
}; };
template <class _Tp>
using __remove_const_t = __remove_const(_Tp);
#else #else
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_const {typedef _Tp type;}; template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_const {typedef _Tp type;};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_const<const _Tp> {typedef _Tp type;}; template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_const<const _Tp> {typedef _Tp type;};
template <class _Tp>
using __remove_const_t = typename remove_const<_Tp>::type;
#endif // __has_builtin(__remove_const) #endif // __has_builtin(__remove_const)
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER > 11
template <class _Tp> using remove_const_t = typename remove_const<_Tp>::type; template <class _Tp> using remove_const_t = __remove_const_t<_Tp>;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_REMOVE_CONST_H #endif // _LIBCPP___TYPE_TRAITS_REMOVE_CONST_H

libcxx/include/__type_traits/remove_const_ref.h

Show All 14 Lines
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp> template <class _Tp>
struct __unconstref { using __remove_const_ref_t = __remove_const_t<__libcpp_remove_reference_t<_Tp> >;
typedef _LIBCPP_NODEBUG typename remove_const<typename remove_reference<_Tp>::type>::type type;
};
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_REMOVE_CONST_REF_H #endif // _LIBCPP___TYPE_TRAITS_REMOVE_CONST_REF_H

libcxx/include/__type_traits/remove_cv.h

Show All 18 Lines
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if __has_builtin(__remove_cv) #if __has_builtin(__remove_cv)
template <class _Tp> template <class _Tp>
struct remove_cv { struct remove_cv {
using type _LIBCPP_NODEBUG = __remove_cv(_Tp); using type _LIBCPP_NODEBUG = __remove_cv(_Tp);
}; };
template <class _Tp>
using __remove_cv_t = __remove_cv(_Tp);
#else #else
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_cv template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_cv
{typedef typename remove_volatile<typename remove_const<_Tp>::type>::type type;}; {typedef __remove_volatile_t<__remove_const_t<_Tp> > type;};
template <class _Tp>
using __remove_cv_t = __remove_volatile_t<__remove_const_t<_Tp> >;
#endif // __has_builtin(__remove_cv) #endif // __has_builtin(__remove_cv)
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER > 11
template <class _Tp> using remove_cv_t = typename remove_cv<_Tp>::type; template <class _Tp> using remove_cv_t = __remove_cv_t<_Tp>;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_REMOVE_CV_H #endif // _LIBCPP___TYPE_TRAITS_REMOVE_CV_H

libcxx/include/__type_traits/remove_cvref.h

Show All 16 Lines
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if __has_builtin(__remove_cvref) #if __has_builtin(__remove_cvref)
template <class _Tp> template <class _Tp>
using __uncvref_t _LIBCPP_NODEBUG = __remove_cvref(_Tp); using __remove_cvref_t _LIBCPP_NODEBUG = __remove_cvref(_Tp);
#else #else
template <class _Tp> template <class _Tp>
using __uncvref_t _LIBCPP_NODEBUG = typename remove_cv<typename remove_reference<_Tp>::type>::type; using __remove_cvref_t _LIBCPP_NODEBUG = __remove_cv_t<__libcpp_remove_reference_t<_Tp> >;
#endif // __has_builtin(__remove_cvref) #endif // __has_builtin(__remove_cvref)
template <class _Tp, class _Up> template <class _Tp, class _Up>
struct __is_same_uncvref : _IsSame<__uncvref_t<_Tp>, __uncvref_t<_Up> > {}; struct __is_same_uncvref : _IsSame<__remove_cvref_t<_Tp>, __remove_cvref_t<_Up> > {};
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER > 17
// remove_cvref - same as __uncvref
template <class _Tp> template <class _Tp>
struct remove_cvref { struct remove_cvref {
using type _LIBCPP_NODEBUG = __uncvref_t<_Tp>; using type _LIBCPP_NODEBUG = __remove_cvref_t<_Tp>;
}; };
template <class _Tp> using remove_cvref_t = typename remove_cvref<_Tp>::type; template <class _Tp> using remove_cvref_t = __remove_cvref_t<_Tp>;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_REMOVE_CVREF_H #endif // _LIBCPP___TYPE_TRAITS_REMOVE_CVREF_H

libcxx/include/__type_traits/remove_extent.h

Show All 17 Lines
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if __has_builtin(__remove_extent) #if __has_builtin(__remove_extent)
template <class _Tp> template <class _Tp>
struct remove_extent { struct remove_extent {
using type _LIBCPP_NODEBUG = __remove_extent(_Tp); using type _LIBCPP_NODEBUG = __remove_extent(_Tp);
}; };
template <class _Tp>
using __remove_extent_t = __remove_extent(_Tp);
#else #else
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_extent template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_extent
{typedef _Tp type;}; {typedef _Tp type;};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_extent<_Tp[]> template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_extent<_Tp[]>
{typedef _Tp type;}; {typedef _Tp type;};
template <class _Tp, size_t _Np> struct _LIBCPP_TEMPLATE_VIS remove_extent<_Tp[_Np]> template <class _Tp, size_t _Np> struct _LIBCPP_TEMPLATE_VIS remove_extent<_Tp[_Np]>
{typedef _Tp type;}; {typedef _Tp type;};
template <class _Tp>
using __remove_extent_t = typename remove_extent<_Tp>::type;
#endif // __has_builtin(__remove_extent) #endif // __has_builtin(__remove_extent)
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER > 11
template <class _Tp> using remove_extent_t = typename remove_extent<_Tp>::type; template <class _Tp> using remove_extent_t = __remove_extent_t<_Tp>;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_REMOVE_EXTENT_H #endif // _LIBCPP___TYPE_TRAITS_REMOVE_EXTENT_H

libcxx/include/__type_traits/remove_pointer.h

Show All 16 Lines
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if __has_builtin(__remove_pointer) #if __has_builtin(__remove_pointer)
template <class _Tp> template <class _Tp>
struct remove_pointer { struct remove_pointer {
using type _LIBCPP_NODEBUG = __remove_pointer(_Tp); using type _LIBCPP_NODEBUG = __remove_pointer(_Tp);
}; };
template <class _Tp>
using __remove_pointer_t = __remove_pointer(_Tp);
#else #else
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_pointer {typedef _LIBCPP_NODEBUG _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*> {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* 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* volatile> {typedef _LIBCPP_NODEBUG _Tp type;};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_pointer<_Tp* const volatile> {typedef _LIBCPP_NODEBUG _Tp type;}; template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_pointer<_Tp* const volatile> {typedef _LIBCPP_NODEBUG _Tp type;};
template <class _Tp>
using __remove_pointer_t = typename remove_pointer<_Tp>::type;
#endif // __has_builtin(__remove_pointer) #endif // __has_builtin(__remove_pointer)
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER > 11
template <class _Tp> using remove_pointer_t = typename remove_pointer<_Tp>::type; template <class _Tp> using remove_pointer_t = __remove_pointer_t<_Tp>;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_REMOVE_POINTER_H #endif // _LIBCPP___TYPE_TRAITS_REMOVE_POINTER_H

libcxx/include/__type_traits/remove_reference.h

Show All 17 Lines
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if __has_builtin(__remove_reference_t) #if __has_builtin(__remove_reference_t)
template <class _Tp> template <class _Tp>
struct remove_reference { struct remove_reference {
using type _LIBCPP_NODEBUG = __remove_reference_t(_Tp); using type _LIBCPP_NODEBUG = __remove_reference_t(_Tp);
}; };
template <class _Tp>
using __libcpp_remove_reference_t = __remove_reference_t(_Tp);
#else #else
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_reference {typedef _LIBCPP_NODEBUG _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;};
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;};
template <class _Tp>
using __libcpp_remove_reference_t = typename remove_reference<_Tp>::type;
#endif // __has_builtin(__remove_reference_t) #endif // __has_builtin(__remove_reference_t)
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER > 11
template <class _Tp> using remove_reference_t = typename remove_reference<_Tp>::type; template <class _Tp> using remove_reference_t = __libcpp_remove_reference_t<_Tp>;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_REMOVE_REFERENCE_H #endif // _LIBCPP___TYPE_TRAITS_REMOVE_REFERENCE_H

libcxx/include/__type_traits/remove_volatile.h

Show All 16 Lines
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if __has_builtin(__remove_volatile) #if __has_builtin(__remove_volatile)
template <class _Tp> template <class _Tp>
struct remove_volatile { struct remove_volatile {
using type _LIBCPP_NODEBUG = __remove_volatile(_Tp); using type _LIBCPP_NODEBUG = __remove_volatile(_Tp);
}; };
template <class _Tp>
using __remove_volatile_t = __remove_volatile(_Tp);
#else #else
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_volatile {typedef _Tp type;}; template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_volatile {typedef _Tp type;};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_volatile<volatile _Tp> {typedef _Tp type;}; template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_volatile<volatile _Tp> {typedef _Tp type;};
template <class _Tp>
using __remove_volatile_t = typename remove_volatile<_Tp>::type;
#endif // __has_builtin(__remove_volatile) #endif // __has_builtin(__remove_volatile)
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER > 11
template <class _Tp> using remove_volatile_t = typename remove_volatile<_Tp>::type; template <class _Tp> using remove_volatile_t = __remove_volatile_t<_Tp>;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_REMOVE_VOLATILE_H #endif // _LIBCPP___TYPE_TRAITS_REMOVE_VOLATILE_H

libcxx/include/__utility/forward.h

Show All 16 Lines
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp> template <class _Tp>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR _Tp&& _LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR _Tp&&
forward(typename remove_reference<_Tp>::type& __t) _NOEXCEPT { forward(__libcpp_remove_reference_t<_Tp>& __t) _NOEXCEPT {
return static_cast<_Tp&&>(__t); return static_cast<_Tp&&>(__t);
} }
template <class _Tp> template <class _Tp>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR _Tp&& _LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR _Tp&&
forward(typename remove_reference<_Tp>::type&& __t) _NOEXCEPT { forward(__libcpp_remove_reference_t<_Tp>&& __t) _NOEXCEPT {
static_assert(!is_lvalue_reference<_Tp>::value, "cannot forward an rvalue as an lvalue"); static_assert(!is_lvalue_reference<_Tp>::value, "cannot forward an rvalue as an lvalue");
return static_cast<_Tp&&>(__t); return static_cast<_Tp&&>(__t);
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___UTILITY_FORWARD_H #endif // _LIBCPP___UTILITY_FORWARD_H

libcxx/include/__utility/in_place.h

Show All 37 Lines
}; };
template <size_t _Idx> template <size_t _Idx>
inline constexpr in_place_index_t<_Idx> in_place_index{}; inline constexpr in_place_index_t<_Idx> in_place_index{};
template <class _Tp> struct __is_inplace_type_imp : false_type {}; template <class _Tp> struct __is_inplace_type_imp : false_type {};
template <class _Tp> struct __is_inplace_type_imp<in_place_type_t<_Tp>> : true_type {}; template <class _Tp> struct __is_inplace_type_imp<in_place_type_t<_Tp>> : true_type {};
template <class _Tp> template <class _Tp>
using __is_inplace_type = __is_inplace_type_imp<__uncvref_t<_Tp>>; using __is_inplace_type = __is_inplace_type_imp<__remove_cvref_t<_Tp>>;
template <class _Tp> struct __is_inplace_index_imp : false_type {}; template <class _Tp> struct __is_inplace_index_imp : false_type {};
template <size_t _Idx> struct __is_inplace_index_imp<in_place_index_t<_Idx>> : true_type {}; template <size_t _Idx> struct __is_inplace_index_imp<in_place_index_t<_Idx>> : true_type {};
template <class _Tp> template <class _Tp>
using __is_inplace_index = __is_inplace_index_imp<__uncvref_t<_Tp>>; using __is_inplace_index = __is_inplace_index_imp<__remove_cvref_t<_Tp>>;
#endif // _LIBCPP_STD_VER > 14 #endif // _LIBCPP_STD_VER > 14
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___UTILITY_IN_PLACE_H #endif // _LIBCPP___UTILITY_IN_PLACE_H

libcxx/include/__utility/move.h

Show All 14 Lines
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp> template <class _Tp>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR typename remove_reference<_Tp>::type&& _LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR __libcpp_remove_reference_t<_Tp>&&
move(_Tp&& __t) _NOEXCEPT { move(_Tp&& __t) _NOEXCEPT {
typedef _LIBCPP_NODEBUG typename remove_reference<_Tp>::type _Up; typedef _LIBCPP_NODEBUG __libcpp_remove_reference_t<_Tp> _Up;
return static_cast<_Up&&>(__t); return static_cast<_Up&&>(__t);
} }
template <class _Tp> template <class _Tp>
using __move_if_noexcept_result_t = using __move_if_noexcept_result_t =
typename conditional<!is_nothrow_move_constructible<_Tp>::value && is_copy_constructible<_Tp>::value, const _Tp&, typename conditional<!is_nothrow_move_constructible<_Tp>::value && is_copy_constructible<_Tp>::value, const _Tp&,
_Tp&&>::type; _Tp&&>::type;
Show All 9 Lines

libcxx/include/any

Show First 20 Lines • Show All 600 Lines • ▼ Show 20 Linesany make_any(initializer_list<_Up> __il, _Args&&... __args) {
return any(in_place_type<_Tp>, __il, _VSTD::forward<_Args>(__args)...); return any(in_place_type<_Tp>, __il, _VSTD::forward<_Args>(__args)...);
} }
template <class _ValueType> template <class _ValueType>
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_AVAILABILITY_THROW_BAD_ANY_CAST _LIBCPP_AVAILABILITY_THROW_BAD_ANY_CAST
_ValueType any_cast(any const & __v) _ValueType any_cast(any const & __v)
{ {
using _RawValueType = __uncvref_t<_ValueType>; using _RawValueType = __remove_cvref_t<_ValueType>;
static_assert(is_constructible<_ValueType, _RawValueType const &>::value, static_assert(is_constructible<_ValueType, _RawValueType const &>::value,
"ValueType is required to be a const lvalue reference " "ValueType is required to be a const lvalue reference "
"or a CopyConstructible type"); "or a CopyConstructible type");
auto __tmp = _VSTD::any_cast<add_const_t<_RawValueType>>(&__v); auto __tmp = _VSTD::any_cast<add_const_t<_RawValueType>>(&__v);
if (__tmp == nullptr) if (__tmp == nullptr)
__throw_bad_any_cast(); __throw_bad_any_cast();
return static_cast<_ValueType>(*__tmp); return static_cast<_ValueType>(*__tmp);
} }
template <class _ValueType> template <class _ValueType>
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_AVAILABILITY_THROW_BAD_ANY_CAST _LIBCPP_AVAILABILITY_THROW_BAD_ANY_CAST
_ValueType any_cast(any & __v) _ValueType any_cast(any & __v)
{ {
using _RawValueType = __uncvref_t<_ValueType>; using _RawValueType = __remove_cvref_t<_ValueType>;
static_assert(is_constructible<_ValueType, _RawValueType &>::value, static_assert(is_constructible<_ValueType, _RawValueType &>::value,
"ValueType is required to be an lvalue reference " "ValueType is required to be an lvalue reference "
"or a CopyConstructible type"); "or a CopyConstructible type");
auto __tmp = _VSTD::any_cast<_RawValueType>(&__v); auto __tmp = _VSTD::any_cast<_RawValueType>(&__v);
if (__tmp == nullptr) if (__tmp == nullptr)
__throw_bad_any_cast(); __throw_bad_any_cast();
return static_cast<_ValueType>(*__tmp); return static_cast<_ValueType>(*__tmp);
} }
template <class _ValueType> template <class _ValueType>
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_AVAILABILITY_THROW_BAD_ANY_CAST _LIBCPP_AVAILABILITY_THROW_BAD_ANY_CAST
_ValueType any_cast(any && __v) _ValueType any_cast(any && __v)
{ {
using _RawValueType = __uncvref_t<_ValueType>; using _RawValueType = __remove_cvref_t<_ValueType>;
static_assert(is_constructible<_ValueType, _RawValueType>::value, static_assert(is_constructible<_ValueType, _RawValueType>::value,
"ValueType is required to be an rvalue reference " "ValueType is required to be an rvalue reference "
"or a CopyConstructible type"); "or a CopyConstructible type");
auto __tmp = _VSTD::any_cast<_RawValueType>(&__v); auto __tmp = _VSTD::any_cast<_RawValueType>(&__v);
if (__tmp == nullptr) if (__tmp == nullptr)
__throw_bad_any_cast(); __throw_bad_any_cast();
return static_cast<_ValueType>(_VSTD::move(*__tmp)); return static_cast<_ValueType>(_VSTD::move(*__tmp));
} }
Show All 23 Lines
template <class _ValueType> template <class _ValueType>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
add_pointer_t<_ValueType> add_pointer_t<_ValueType>
any_cast(any * __any) _NOEXCEPT any_cast(any * __any) _NOEXCEPT
{ {
using __any_imp::_Action; using __any_imp::_Action;
static_assert(!is_reference<_ValueType>::value, static_assert(!is_reference<_ValueType>::value,
"_ValueType may not be a reference."); "_ValueType may not be a reference.");
typedef typename add_pointer<_ValueType>::type _ReturnType; typedef add_pointer_t<_ValueType> _ReturnType;
if (__any && __any->__h) { if (__any && __any->__h) {
void *__p = __any->__call(_Action::_Get, nullptr, void *__p = __any->__call(_Action::_Get, nullptr,
#if !defined(_LIBCPP_NO_RTTI) #if !defined(_LIBCPP_NO_RTTI)
&typeid(_ValueType), &typeid(_ValueType),
#else #else
nullptr, nullptr,
#endif #endif
__any_imp::__get_fallback_typeid<_ValueType>()); __any_imp::__get_fallback_typeid<_ValueType>());
Show All 11 Lines

libcxx/include/atomic

Show First 20 Lines • Show All 942 Lines • ▼ Show 20 Lines
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
void __cxx_atomic_store(__cxx_atomic_base_impl<_Tp> * __a, _Tp __val, memory_order __order) _NOEXCEPT { void __cxx_atomic_store(__cxx_atomic_base_impl<_Tp> * __a, _Tp __val, memory_order __order) _NOEXCEPT {
__c11_atomic_store(&__a->__a_value, __val, static_cast<__memory_order_underlying_t>(__order)); __c11_atomic_store(&__a->__a_value, __val, static_cast<__memory_order_underlying_t>(__order));
} }
template<class _Tp> template<class _Tp>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
_Tp __cxx_atomic_load(__cxx_atomic_base_impl<_Tp> const volatile* __a, memory_order __order) _NOEXCEPT { _Tp __cxx_atomic_load(__cxx_atomic_base_impl<_Tp> const volatile* __a, memory_order __order) _NOEXCEPT {
using __ptr_type = typename remove_const<decltype(__a->__a_value)>::type*; using __ptr_type = __remove_const_t<decltype(__a->__a_value)>*;
return __c11_atomic_load(const_cast<__ptr_type>(&__a->__a_value), static_cast<__memory_order_underlying_t>(__order)); return __c11_atomic_load(const_cast<__ptr_type>(&__a->__a_value), static_cast<__memory_order_underlying_t>(__order));
} }
template<class _Tp> template<class _Tp>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
_Tp __cxx_atomic_load(__cxx_atomic_base_impl<_Tp> const* __a, memory_order __order) _NOEXCEPT { _Tp __cxx_atomic_load(__cxx_atomic_base_impl<_Tp> const* __a, memory_order __order) _NOEXCEPT {
using __ptr_type = typename remove_const<decltype(__a->__a_value)>::type*; using __ptr_type = __remove_const_t<decltype(__a->__a_value)>*;
return __c11_atomic_load(const_cast<__ptr_type>(&__a->__a_value), static_cast<__memory_order_underlying_t>(__order)); return __c11_atomic_load(const_cast<__ptr_type>(&__a->__a_value), static_cast<__memory_order_underlying_t>(__order));
} }
template<class _Tp> template<class _Tp>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
_Tp __cxx_atomic_exchange(__cxx_atomic_base_impl<_Tp> volatile* __a, _Tp __value, memory_order __order) _NOEXCEPT { _Tp __cxx_atomic_exchange(__cxx_atomic_base_impl<_Tp> volatile* __a, _Tp __value, memory_order __order) _NOEXCEPT {
return __c11_atomic_exchange(&__a->__a_value, __value, static_cast<__memory_order_underlying_t>(__order)); return __c11_atomic_exchange(&__a->__a_value, __value, static_cast<__memory_order_underlying_t>(__order));
} }
▲ Show 20 Lines • Show All 835 Lines • ▼ Show 20 Lines _Tp* operator=(_Tp* __d) volatile _NOEXCEPT
{__base::store(__d); return __d;} {__base::store(__d); return __d;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
_Tp* operator=(_Tp* __d) _NOEXCEPT _Tp* operator=(_Tp* __d) _NOEXCEPT
{__base::store(__d); return __d;} {__base::store(__d); return __d;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
_Tp* fetch_add(ptrdiff_t __op, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT { _Tp* fetch_add(ptrdiff_t __op, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT {
// __atomic_fetch_add accepts function pointers, guard against them. // __atomic_fetch_add accepts function pointers, guard against them.
static_assert(!is_function<typename remove_pointer<_Tp>::type>::value, "Pointer to function isn't allowed"); static_assert(!is_function<__remove_pointer_t<_Tp> >::value, "Pointer to function isn't allowed");
return __cxx_atomic_fetch_add(&this->__a_, __op, __m); return __cxx_atomic_fetch_add(&this->__a_, __op, __m);
} }
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
_Tp* fetch_add(ptrdiff_t __op, memory_order __m = memory_order_seq_cst) _NOEXCEPT { _Tp* fetch_add(ptrdiff_t __op, memory_order __m = memory_order_seq_cst) _NOEXCEPT {
// __atomic_fetch_add accepts function pointers, guard against them. // __atomic_fetch_add accepts function pointers, guard against them.
static_assert(!is_function<typename remove_pointer<_Tp>::type>::value, "Pointer to function isn't allowed"); static_assert(!is_function<__remove_pointer_t<_Tp> >::value, "Pointer to function isn't allowed");
return __cxx_atomic_fetch_add(&this->__a_, __op, __m); return __cxx_atomic_fetch_add(&this->__a_, __op, __m);
} }
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
_Tp* fetch_sub(ptrdiff_t __op, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT { _Tp* fetch_sub(ptrdiff_t __op, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT {
// __atomic_fetch_add accepts function pointers, guard against them. // __atomic_fetch_add accepts function pointers, guard against them.
static_assert(!is_function<typename remove_pointer<_Tp>::type>::value, "Pointer to function isn't allowed"); static_assert(!is_function<__remove_pointer_t<_Tp> >::value, "Pointer to function isn't allowed");
return __cxx_atomic_fetch_sub(&this->__a_, __op, __m); return __cxx_atomic_fetch_sub(&this->__a_, __op, __m);
} }
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
_Tp* fetch_sub(ptrdiff_t __op, memory_order __m = memory_order_seq_cst) _NOEXCEPT { _Tp* fetch_sub(ptrdiff_t __op, memory_order __m = memory_order_seq_cst) _NOEXCEPT {
// __atomic_fetch_add accepts function pointers, guard against them. // __atomic_fetch_add accepts function pointers, guard against them.
static_assert(!is_function<typename remove_pointer<_Tp>::type>::value, "Pointer to function isn't allowed"); static_assert(!is_function<__remove_pointer_t<_Tp> >::value, "Pointer to function isn't allowed");
return __cxx_atomic_fetch_sub(&this->__a_, __op, __m); return __cxx_atomic_fetch_sub(&this->__a_, __op, __m);
} }
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
_Tp* operator++(int) volatile _NOEXCEPT {return fetch_add(1);} _Tp* operator++(int) volatile _NOEXCEPT {return fetch_add(1);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
_Tp* operator++(int) _NOEXCEPT {return fetch_add(1);} _Tp* operator++(int) _NOEXCEPT {return fetch_add(1);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
▲ Show 20 Lines • Show All 867 Lines • Show Last 20 Lines

libcxx/include/experimental/coroutine

Show First 20 Lines • Show All 235 Lines • ▼ Show 20 Linespublic:
static coroutine_handle from_address(_Promise*) { static coroutine_handle from_address(_Promise*) {
static_assert(_CallIsValid, static_assert(_CallIsValid,
"coroutine_handle<promise_type>::from_address cannot be used with " "coroutine_handle<promise_type>::from_address cannot be used with "
"pointers to the coroutine's promise type; use 'from_promise' instead"); "pointers to the coroutine's promise type; use 'from_promise' instead");
} }
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
static coroutine_handle from_promise(_Promise& __promise) _NOEXCEPT { static coroutine_handle from_promise(_Promise& __promise) _NOEXCEPT {
typedef typename remove_cv<_Promise>::type _RawPromise; typedef __remove_cv_t<_Promise> _RawPromise;
coroutine_handle __tmp; coroutine_handle __tmp;
__tmp.__handle_ = __builtin_coro_promise( __tmp.__handle_ = __builtin_coro_promise(
_VSTD::addressof(const_cast<_RawPromise&>(__promise)), _VSTD::addressof(const_cast<_RawPromise&>(__promise)),
_LIBCPP_ALIGNOF(_Promise), true); _LIBCPP_ALIGNOF(_Promise), true);
return __tmp; return __tmp;
} }
}; };
▲ Show 20 Lines • Show All 75 Lines • Show Last 20 Lines

libcxx/include/experimental/functional

Show First 20 Lines • Show All 155 Lines • ▼ Show 20 Lines
// Special case small numeric values; use an array // Special case small numeric values; use an array
template<class _Key, typename _Value, class _Hash, class _BinaryPredicate> template<class _Key, typename _Value, class _Hash, class _BinaryPredicate>
class _BMSkipTable<_Key, _Value, _Hash, _BinaryPredicate, true> { class _BMSkipTable<_Key, _Value, _Hash, _BinaryPredicate, true> {
private: private:
typedef _Value value_type; typedef _Value value_type;
typedef _Key key_type; typedef _Key key_type;
typedef typename make_unsigned<key_type>::type unsigned_key_type; typedef __make_unsigned_t<key_type> unsigned_key_type;
typedef std::array<value_type, 256> skip_map; typedef std::array<value_type, 256> skip_map;
skip_map __table; skip_map __table;
public: public:
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
_BMSkipTable(size_t /*__sz*/, _Value __default, _Hash /*__hf*/, _BinaryPredicate /*__pred*/) _BMSkipTable(size_t /*__sz*/, _Value __default, _Hash /*__hf*/, _BinaryPredicate /*__pred*/)
{ {
std::fill_n(__table.begin(), __table.size(), __default); std::fill_n(__table.begin(), __table.size(), __default);
▲ Show 20 Lines • Show All 264 Lines • Show Last 20 Lines

libcxx/include/experimental/propagate_const

Show First 20 Lines • Show All 139 Lines • ▼ Show 20 Lines
{ {
public: public:
typedef remove_reference_t<decltype(*declval<_Tp&>())> element_type; typedef remove_reference_t<decltype(*declval<_Tp&>())> element_type;
static_assert(!is_array<_Tp>::value, static_assert(!is_array<_Tp>::value,
"Instantiation of propagate_const with an array type is ill-formed."); "Instantiation of propagate_const with an array type is ill-formed.");
static_assert(!is_reference<_Tp>::value, static_assert(!is_reference<_Tp>::value,
"Instantiation of propagate_const with a reference type is ill-formed."); "Instantiation of propagate_const with a reference type is ill-formed.");
static_assert(!(is_pointer<_Tp>::value && is_function<typename remove_pointer<_Tp>::type>::value), static_assert(!(is_pointer<_Tp>::value && is_function<__remove_pointer_t<_Tp> >::value),
"Instantiation of propagate_const with a function-pointer type is ill-formed."); "Instantiation of propagate_const with a function-pointer type is ill-formed.");
static_assert(!(is_pointer<_Tp>::value && is_same<typename remove_cv<typename remove_pointer<_Tp>::type>::type, void>::value), static_assert(!(is_pointer<_Tp>::value && is_same<__remove_cv_t<__remove_pointer_t<_Tp> >, void>::value),
"Instantiation of propagate_const with a pointer to (possibly cv-qualified) void is ill-formed."); "Instantiation of propagate_const with a pointer to (possibly cv-qualified) void is ill-formed.");
private: private:
template <class _Up> template <class _Up>
static _LIBCPP_CONSTEXPR element_type* __get_pointer(_Up* __u) static _LIBCPP_CONSTEXPR element_type* __get_pointer(_Up* __u)
{ {
return __u; return __u;
} }
▲ Show 20 Lines • Show All 423 Lines • Show Last 20 Lines

libcxx/include/experimental/simd

Show First 20 Lines • Show All 1,056 Lines • ▼ Show 20 Lines
template <class _Tp, class _Abi = simd_abi::compatible<_Tp>> template <class _Tp, class _Abi = simd_abi::compatible<_Tp>>
struct simd_size; struct simd_size;
template <class _Tp, _StorageKind __kind, int _Np> template <class _Tp, _StorageKind __kind, int _Np>
struct simd_size<_Tp, __simd_abi<__kind, _Np>> struct simd_size<_Tp, __simd_abi<__kind, _Np>>
: std::integral_constant<size_t, _Np> { : std::integral_constant<size_t, _Np> {
static_assert( static_assert(
std::is_arithmetic<_Tp>::value && std::is_arithmetic<_Tp>::value &&
!std::is_same<typename std::remove_const<_Tp>::type, bool>::value, !std::is_same<__remove_const_t<_Tp>, bool>::value,
"Element type should be vectorizable"); "Element type should be vectorizable");
}; };
// TODO: implement it. // TODO: implement it.
template <class _Tp, class _Up = typename _Tp::value_type> template <class _Tp, class _Up = typename _Tp::value_type>
struct memory_alignment; struct memory_alignment;
template <class _Tp, class _Abi = simd_abi::compatible<_Tp>> template <class _Tp, class _Abi = simd_abi::compatible<_Tp>>
▲ Show 20 Lines • Show All 225 Lines • ▼ Show 20 Lines
// [simd.whereexpr] // [simd.whereexpr]
// TODO implement where expressions. // TODO implement where expressions.
template <class _MaskType, class _Tp> template <class _MaskType, class _Tp>
class const_where_expression { class const_where_expression {
public: public:
const_where_expression(const const_where_expression&) = delete; const_where_expression(const const_where_expression&) = delete;
const_where_expression& operator=(const const_where_expression&) = delete; const_where_expression& operator=(const const_where_expression&) = delete;
typename remove_const<_Tp>::type operator-() const&&; __remove_const_t<_Tp> operator-() const&&;
template <class _Up, class _Flags> template <class _Up, class _Flags>
void copy_to(_Up*, _Flags) const&&; void copy_to(_Up*, _Flags) const&&;
}; };
template <class _MaskType, class _Tp> template <class _MaskType, class _Tp>
class where_expression : public const_where_expression<_MaskType, _Tp> { class where_expression : public const_where_expression<_MaskType, _Tp> {
public: public:
where_expression(const where_expression&) = delete; where_expression(const where_expression&) = delete;
▲ Show 20 Lines • Show All 50 Lines • ▼ Show 20 Linesprivate:
__simd_storage<_Tp, _Abi> __s_; __simd_storage<_Tp, _Abi> __s_;
template <class _Up> template <class _Up>
static constexpr bool __can_broadcast() { static constexpr bool __can_broadcast() {
return (std::is_arithmetic<_Up>::value && return (std::is_arithmetic<_Up>::value &&
__is_non_narrowing_arithmetic_convertible<_Up, _Tp>()) || __is_non_narrowing_arithmetic_convertible<_Up, _Tp>()) ||
(!std::is_arithmetic<_Up>::value && (!std::is_arithmetic<_Up>::value &&
std::is_convertible<_Up, _Tp>::value) || std::is_convertible<_Up, _Tp>::value) ||
std::is_same<typename std::remove_const<_Up>::type, int>::value || std::is_same<__remove_const_t<_Up>, int>::value ||
(std::is_same<typename std::remove_const<_Up>::type, (std::is_same<__remove_const_t<_Up>,
unsigned int>::value && unsigned int>::value &&
std::is_unsigned<_Tp>::value); std::is_unsigned<_Tp>::value);
} }
template <class _Generator, size_t... __indicies> template <class _Generator, size_t... __indicies>
static constexpr decltype( static constexpr decltype(
std::forward_as_tuple(std::declval<_Generator>()( std::forward_as_tuple(std::declval<_Generator>()(
std::integral_constant<size_t, __indicies>())...), std::integral_constant<size_t, __indicies>())...),
▲ Show 20 Lines • Show All 201 Lines • Show Last 20 Lines

libcxx/include/ext/hash_map

Show First 20 Lines • Show All 376 Lines • ▼ Show 20 Linesclass _LIBCPP_TEMPLATE_VIS __hash_map_iterator
typedef const typename _HashIterator::value_type::first_type key_type; typedef const typename _HashIterator::value_type::first_type key_type;
typedef typename _HashIterator::value_type::second_type mapped_type; typedef typename _HashIterator::value_type::second_type mapped_type;
public: public:
typedef std::forward_iterator_tag iterator_category; typedef std::forward_iterator_tag iterator_category;
typedef std::pair<key_type, mapped_type> value_type; typedef std::pair<key_type, mapped_type> value_type;
typedef typename _HashIterator::difference_type difference_type; typedef typename _HashIterator::difference_type difference_type;
typedef value_type& reference; typedef value_type& reference;
typedef typename std::__rebind_pointer<typename _HashIterator::pointer, value_type>::type typedef std::__rebind_pointer_t<typename _HashIterator::pointer, value_type>
pointer; pointer;
_LIBCPP_INLINE_VISIBILITY __hash_map_iterator() {} _LIBCPP_INLINE_VISIBILITY __hash_map_iterator() {}
_LIBCPP_INLINE_VISIBILITY __hash_map_iterator(_HashIterator __i) : __i_(__i) {} _LIBCPP_INLINE_VISIBILITY __hash_map_iterator(_HashIterator __i) : __i_(__i) {}
_LIBCPP_INLINE_VISIBILITY reference operator*() const {return *operator->();} _LIBCPP_INLINE_VISIBILITY reference operator*() const {return *operator->();}
_LIBCPP_INLINE_VISIBILITY pointer operator->() const {return (pointer)__i_.operator->();} _LIBCPP_INLINE_VISIBILITY pointer operator->() const {return (pointer)__i_.operator->();}
Show All 28 Linesclass _LIBCPP_TEMPLATE_VIS __hash_map_const_iterator
typedef const typename _HashIterator::value_type::first_type key_type; typedef const typename _HashIterator::value_type::first_type key_type;
typedef typename _HashIterator::value_type::second_type mapped_type; typedef typename _HashIterator::value_type::second_type mapped_type;
public: public:
typedef std::forward_iterator_tag iterator_category; typedef std::forward_iterator_tag iterator_category;
typedef std::pair<key_type, mapped_type> value_type; typedef std::pair<key_type, mapped_type> value_type;
typedef typename _HashIterator::difference_type difference_type; typedef typename _HashIterator::difference_type difference_type;
typedef const value_type& reference; typedef const value_type& reference;
typedef typename std::__rebind_pointer<typename _HashIterator::pointer, const value_type>::type typedef std::__rebind_pointer_t<typename _HashIterator::pointer, const value_type>
pointer; pointer;
_LIBCPP_INLINE_VISIBILITY __hash_map_const_iterator() {} _LIBCPP_INLINE_VISIBILITY __hash_map_const_iterator() {}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
__hash_map_const_iterator(_HashIterator __i) : __i_(__i) {} __hash_map_const_iterator(_HashIterator __i) : __i_(__i) {}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
__hash_map_const_iterator( __hash_map_const_iterator(
▲ Show 20 Lines • Show All 552 Lines • Show Last 20 Lines

libcxx/include/forward_list

Show First 20 Lines • Show All 233 Lines • ▼ Show 20 Lines
template <class _Tp, class _VoidPtr> template <class _Tp, class _VoidPtr>
struct __forward_list_node_value_type<__forward_list_node<_Tp, _VoidPtr> > { struct __forward_list_node_value_type<__forward_list_node<_Tp, _VoidPtr> > {
typedef _Tp type; typedef _Tp type;
}; };
template <class _NodePtr> template <class _NodePtr>
struct __forward_node_traits { struct __forward_node_traits {
typedef typename remove_cv< typedef __remove_cv_t<
typename pointer_traits<_NodePtr>::element_type>::type __node; typename pointer_traits<_NodePtr>::element_type> __node;
typedef typename __forward_list_node_value_type<__node>::type __node_value_type; typedef typename __forward_list_node_value_type<__node>::type __node_value_type;
typedef _NodePtr __node_pointer; typedef _NodePtr __node_pointer;
typedef __forward_begin_node<_NodePtr> __begin_node; typedef __forward_begin_node<_NodePtr> __begin_node;
typedef typename __rebind_pointer<_NodePtr, __begin_node>::type typedef __rebind_pointer_t<_NodePtr, __begin_node> __begin_node_pointer;
__begin_node_pointer; typedef __rebind_pointer_t<_NodePtr, void> __void_pointer;
typedef typename __rebind_pointer<_NodePtr, void>::type __void_pointer;
#if defined(_LIBCPP_ABI_FORWARD_LIST_REMOVE_NODE_POINTER_UB) #if defined(_LIBCPP_ABI_FORWARD_LIST_REMOVE_NODE_POINTER_UB)
typedef __begin_node_pointer __iter_node_pointer; typedef __begin_node_pointer __iter_node_pointer;
#else #else
typedef typename conditional< typedef typename conditional<
is_pointer<__void_pointer>::value, is_pointer<__void_pointer>::value,
__begin_node_pointer, __begin_node_pointer,
__node_pointer __node_pointer
Show All 15 Lines static __iter_node_pointer __as_iter_node(__non_iter_node_pointer __p) {
return static_cast<__iter_node_pointer>(static_cast<__void_pointer>(__p)); return static_cast<__iter_node_pointer>(static_cast<__void_pointer>(__p));
} }
}; };
template <class _NodePtr> template <class _NodePtr>
struct __forward_begin_node struct __forward_begin_node
{ {
typedef _NodePtr pointer; typedef _NodePtr pointer;
typedef typename __rebind_pointer<_NodePtr, __forward_begin_node>::type __begin_node_pointer; typedef __rebind_pointer_t<_NodePtr, __forward_begin_node> __begin_node_pointer;
pointer __next_; pointer __next_;
_LIBCPP_INLINE_VISIBILITY __forward_begin_node() : __next_(nullptr) {} _LIBCPP_INLINE_VISIBILITY __forward_begin_node() : __next_(nullptr) {}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
__begin_node_pointer __next_as_begin() const { __begin_node_pointer __next_as_begin() const {
return static_cast<__begin_node_pointer>(__next_); return static_cast<__begin_node_pointer>(__next_);
} }
}; };
template <class _Tp, class _VoidPtr> template <class _Tp, class _VoidPtr>
struct _LIBCPP_HIDDEN __begin_node_of struct _LIBCPP_HIDDEN __begin_node_of
{ {
typedef __forward_begin_node< typedef __forward_begin_node<
typename __rebind_pointer<_VoidPtr, __forward_list_node<_Tp, _VoidPtr> >::type __rebind_pointer_t<_VoidPtr, __forward_list_node<_Tp, _VoidPtr> >
> type; > type;
}; };
template <class _Tp, class _VoidPtr> template <class _Tp, class _VoidPtr>
struct _LIBCPP_STANDALONE_DEBUG __forward_list_node struct _LIBCPP_STANDALONE_DEBUG __forward_list_node
: public __begin_node_of<_Tp, _VoidPtr>::type : public __begin_node_of<_Tp, _VoidPtr>::type
{ {
typedef _Tp value_type; typedef _Tp value_type;
▲ Show 20 Lines • Show All 42 Lines • ▼ Show 20 Linesclass _LIBCPP_TEMPLATE_VIS __forward_list_iterator
template<class> friend class _LIBCPP_TEMPLATE_VIS __forward_list_const_iterator; template<class> friend class _LIBCPP_TEMPLATE_VIS __forward_list_const_iterator;
public: public:
typedef forward_iterator_tag iterator_category; typedef forward_iterator_tag iterator_category;
typedef typename __traits::__node_value_type value_type; typedef typename __traits::__node_value_type value_type;
typedef value_type& reference; typedef value_type& reference;
typedef typename pointer_traits<__node_pointer>::difference_type typedef typename pointer_traits<__node_pointer>::difference_type
difference_type; difference_type;
typedef typename __rebind_pointer<__node_pointer, value_type>::type pointer; typedef __rebind_pointer_t<__node_pointer, value_type> pointer;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
__forward_list_iterator() _NOEXCEPT : __ptr_(nullptr) {} __forward_list_iterator() _NOEXCEPT : __ptr_(nullptr) {}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
reference operator*() const {return __get_unsafe_node_pointer()->__value_;} reference operator*() const {return __get_unsafe_node_pointer()->__value_;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
pointer operator->() const { pointer operator->() const {
▲ Show 20 Lines • Show All 64 Lines • ▼ Show 20 Linesclass _LIBCPP_TEMPLATE_VIS __forward_list_const_iterator
template<class, class> friend class forward_list; template<class, class> friend class forward_list;
public: public:
typedef forward_iterator_tag iterator_category; typedef forward_iterator_tag iterator_category;
typedef typename __traits::__node_value_type value_type; typedef typename __traits::__node_value_type value_type;
typedef const value_type& reference; typedef const value_type& reference;
typedef typename pointer_traits<__node_pointer>::difference_type typedef typename pointer_traits<__node_pointer>::difference_type
difference_type; difference_type;
typedef typename __rebind_pointer<__node_pointer, const value_type>::type typedef __rebind_pointer_t<__node_pointer, const value_type>
pointer; pointer;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
__forward_list_const_iterator() _NOEXCEPT : __ptr_(nullptr) {} __forward_list_const_iterator() _NOEXCEPT : __ptr_(nullptr) {}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
__forward_list_const_iterator(__forward_list_iterator<__node_pointer> __p) _NOEXCEPT __forward_list_const_iterator(__forward_list_iterator<__node_pointer> __p) _NOEXCEPT
: __ptr_(__p.__ptr_) {} : __ptr_(__p.__ptr_) {}
▲ Show 20 Lines • Show All 1,346 Lines • Show Last 20 Lines

libcxx/include/functional

Show First 20 Lines • Show All 528 Lines • ▼ Show 20 Lines
#include <__functional/reference_wrapper.h> #include <__functional/reference_wrapper.h>
#include <__functional/unary_function.h> // TODO: deprecate #include <__functional/unary_function.h> // TODO: deprecate
#include <__functional/unary_negate.h> #include <__functional/unary_negate.h>
#include <__functional/unwrap_ref.h> #include <__functional/unwrap_ref.h>
#include <__utility/forward.h> #include <__utility/forward.h>
#include <concepts> #include <concepts>
#include <exception> #include <exception>
#include <memory> #include <memory>
#include <tuple>
#include <type_traits> #include <type_traits>
#include <typeinfo> #include <typeinfo>
#include <version> #include <version>
#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES #ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
# include <tuple>
# include <utility> # include <utility>
#endif #endif
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
#endif // _LIBCPP_FUNCTIONAL #endif // _LIBCPP_FUNCTIONAL

libcxx/include/future

Show First 20 Lines • Show All 635 Lines • ▼ Show 20 Linespublic:
template <class _Arg> template <class _Arg>
void set_value(_Arg&& __arg); void set_value(_Arg&& __arg);
template <class _Arg> template <class _Arg>
void set_value_at_thread_exit(_Arg&& __arg); void set_value_at_thread_exit(_Arg&& __arg);
_Rp move(); _Rp move();
typename add_lvalue_reference<_Rp>::type copy(); __add_lvalue_reference_t<_Rp> copy();
}; };
template <class _Rp> template <class _Rp>
void void
__assoc_state<_Rp>::__on_zero_shared() _NOEXCEPT __assoc_state<_Rp>::__on_zero_shared() _NOEXCEPT
{ {
if (this->__state_ & base::__constructed) if (this->__state_ & base::__constructed)
reinterpret_cast<_Rp*>(&__value_)->~_Rp(); reinterpret_cast<_Rp*>(&__value_)->~_Rp();
Show All 34 Lines__assoc_state<_Rp>::move()
unique_lock<mutex> __lk(this->__mut_); unique_lock<mutex> __lk(this->__mut_);
this->__sub_wait(__lk); this->__sub_wait(__lk);
if (this->__exception_ != nullptr) if (this->__exception_ != nullptr)
rethrow_exception(this->__exception_); rethrow_exception(this->__exception_);
return _VSTD::move(*reinterpret_cast<_Rp*>(&__value_)); return _VSTD::move(*reinterpret_cast<_Rp*>(&__value_));
} }
template <class _Rp> template <class _Rp>
typename add_lvalue_reference<_Rp>::type __add_lvalue_reference_t<_Rp>
__assoc_state<_Rp>::copy() __assoc_state<_Rp>::copy()
{ {
unique_lock<mutex> __lk(this->__mut_); unique_lock<mutex> __lk(this->__mut_);
this->__sub_wait(__lk); this->__sub_wait(__lk);
if (this->__exception_ != nullptr) if (this->__exception_ != nullptr)
rethrow_exception(this->__exception_); rethrow_exception(this->__exception_);
return *reinterpret_cast<_Rp*>(&__value_); return *reinterpret_cast<_Rp*>(&__value_);
} }
▲ Show 20 Lines • Show All 1,045 Lines • ▼ Show 20 Lines__packaged_task_function<_Rp(_ArgTypes...)>::__packaged_task_function(__packaged_task_function&& __f) _NOEXCEPT
} }
} }
template<class _Rp, class ..._ArgTypes> template<class _Rp, class ..._ArgTypes>
template <class _Fp> template <class _Fp>
__packaged_task_function<_Rp(_ArgTypes...)>::__packaged_task_function(_Fp&& __f) __packaged_task_function<_Rp(_ArgTypes...)>::__packaged_task_function(_Fp&& __f)
: __f_(nullptr) : __f_(nullptr)
{ {
typedef typename remove_reference<typename decay<_Fp>::type>::type _FR; typedef __libcpp_remove_reference_t<typename decay<_Fp>::type> _FR;
typedef __packaged_task_func<_FR, allocator<_FR>, _Rp(_ArgTypes...)> _FF; typedef __packaged_task_func<_FR, allocator<_FR>, _Rp(_ArgTypes...)> _FF;
if (sizeof(_FF) <= sizeof(__buf_)) if (sizeof(_FF) <= sizeof(__buf_))
{ {
::new ((void*)&__buf_) _FF(_VSTD::forward<_Fp>(__f)); ::new ((void*)&__buf_) _FF(_VSTD::forward<_Fp>(__f));
__f_ = (__base*)&__buf_; __f_ = (__base*)&__buf_;
} }
else else
{ {
typedef allocator<_FF> _Ap; typedef allocator<_FF> _Ap;
_Ap __a; _Ap __a;
typedef __allocator_destructor<_Ap> _Dp; typedef __allocator_destructor<_Ap> _Dp;
unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1)); unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1));
::new ((void*)__hold.get()) _FF(_VSTD::forward<_Fp>(__f), allocator<_FR>(__a)); ::new ((void*)__hold.get()) _FF(_VSTD::forward<_Fp>(__f), allocator<_FR>(__a));
__f_ = __hold.release(); __f_ = __hold.release();
} }
} }
template<class _Rp, class ..._ArgTypes> template<class _Rp, class ..._ArgTypes>
template <class _Fp, class _Alloc> template <class _Fp, class _Alloc>
__packaged_task_function<_Rp(_ArgTypes...)>::__packaged_task_function( __packaged_task_function<_Rp(_ArgTypes...)>::__packaged_task_function(
allocator_arg_t, const _Alloc& __a0, _Fp&& __f) allocator_arg_t, const _Alloc& __a0, _Fp&& __f)
: __f_(nullptr) : __f_(nullptr)
{ {
typedef typename remove_reference<typename decay<_Fp>::type>::type _FR; typedef __libcpp_remove_reference_t<typename decay<_Fp>::type> _FR;
typedef __packaged_task_func<_FR, _Alloc, _Rp(_ArgTypes...)> _FF; typedef __packaged_task_func<_FR, _Alloc, _Rp(_ArgTypes...)> _FF;
if (sizeof(_FF) <= sizeof(__buf_)) if (sizeof(_FF) <= sizeof(__buf_))
{ {
__f_ = (__base*)&__buf_; __f_ = (__base*)&__buf_;
::new ((void*)__f_) _FF(_VSTD::forward<_Fp>(__f)); ::new ((void*)__f_) _FF(_VSTD::forward<_Fp>(__f));
} }
else else
{ {
▲ Show 20 Lines • Show All 96 Lines • ▼ Show 20 Linesprivate:
__packaged_task_function<result_type(_ArgTypes...)> __f_; __packaged_task_function<result_type(_ArgTypes...)> __f_;
promise<result_type> __p_; promise<result_type> __p_;
public: public:
// construction and destruction // construction and destruction
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
packaged_task() _NOEXCEPT : __p_(nullptr) {} packaged_task() _NOEXCEPT : __p_(nullptr) {}
template <class _Fp, template <class _Fp,
class = __enable_if_t<!is_same<__uncvref_t<_Fp>, packaged_task>::value> > class = __enable_if_t<!is_same<__remove_cvref_t<_Fp>, packaged_task>::value> >
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
explicit packaged_task(_Fp&& __f) : __f_(_VSTD::forward<_Fp>(__f)) {} explicit packaged_task(_Fp&& __f) : __f_(_VSTD::forward<_Fp>(__f)) {}
template <class _Fp, class _Allocator, template <class _Fp, class _Allocator,
class = __enable_if_t<!is_same<__uncvref_t<_Fp>, packaged_task>::value> > class = __enable_if_t<!is_same<__remove_cvref_t<_Fp>, packaged_task>::value> >
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
packaged_task(allocator_arg_t, const _Allocator& __a, _Fp&& __f) packaged_task(allocator_arg_t, const _Allocator& __a, _Fp&& __f)
: __f_(allocator_arg, __a, _VSTD::forward<_Fp>(__f)), : __f_(allocator_arg, __a, _VSTD::forward<_Fp>(__f)),
__p_(allocator_arg, __a) {} __p_(allocator_arg, __a) {}
// ~packaged_task() = default; // ~packaged_task() = default;
// no copy // no copy
packaged_task(const packaged_task&) = delete; packaged_task(const packaged_task&) = delete;
▲ Show 20 Lines • Show All 94 Lines • ▼ Show 20 Linesprivate:
__packaged_task_function<result_type(_ArgTypes...)> __f_; __packaged_task_function<result_type(_ArgTypes...)> __f_;
promise<result_type> __p_; promise<result_type> __p_;
public: public:
// construction and destruction // construction and destruction
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
packaged_task() _NOEXCEPT : __p_(nullptr) {} packaged_task() _NOEXCEPT : __p_(nullptr) {}
template <class _Fp, template <class _Fp,
class = __enable_if_t<!is_same<__uncvref_t<_Fp>, packaged_task>::value> > class = __enable_if_t<!is_same<__remove_cvref_t<_Fp>, packaged_task>::value> >
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
explicit packaged_task(_Fp&& __f) : __f_(_VSTD::forward<_Fp>(__f)) {} explicit packaged_task(_Fp&& __f) : __f_(_VSTD::forward<_Fp>(__f)) {}
template <class _Fp, class _Allocator, template <class _Fp, class _Allocator,
class = __enable_if_t<!is_same<__uncvref_t<_Fp>, packaged_task>::value> > class = __enable_if_t<!is_same<__remove_cvref_t<_Fp>, packaged_task>::value> >
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
packaged_task(allocator_arg_t, const _Allocator& __a, _Fp&& __f) packaged_task(allocator_arg_t, const _Allocator& __a, _Fp&& __f)
: __f_(allocator_arg, __a, _VSTD::forward<_Fp>(__f)), : __f_(allocator_arg, __a, _VSTD::forward<_Fp>(__f)),
__p_(allocator_arg, __a) {} __p_(allocator_arg, __a) {}
// ~packaged_task() = default; // ~packaged_task() = default;
// no copy // no copy
packaged_task(const packaged_task&) = delete; packaged_task(const packaged_task&) = delete;
▲ Show 20 Lines • Show All 418 Lines • Show Last 20 Lines

libcxx/include/limits

Show First 20 Lines • Show All 445 Lines • ▼ Show 20 Lines
#else #else
static _LIBCPP_CONSTEXPR const bool tinyness_before = false; static _LIBCPP_CONSTEXPR const bool tinyness_before = false;
#endif #endif
static _LIBCPP_CONSTEXPR const float_round_style round_style = round_to_nearest; static _LIBCPP_CONSTEXPR const float_round_style round_style = round_to_nearest;
}; };
template <class _Tp> template <class _Tp>
class _LIBCPP_TEMPLATE_VIS numeric_limits class _LIBCPP_TEMPLATE_VIS numeric_limits
: private __libcpp_numeric_limits<typename remove_cv<_Tp>::type> : private __libcpp_numeric_limits<__remove_cv_t<_Tp> >
{ {
typedef __libcpp_numeric_limits<typename remove_cv<_Tp>::type> __base; typedef __libcpp_numeric_limits<__remove_cv_t<_Tp> > __base;
typedef typename __base::type type; typedef typename __base::type type;
public: public:
static _LIBCPP_CONSTEXPR const bool is_specialized = __base::is_specialized; static _LIBCPP_CONSTEXPR const bool is_specialized = __base::is_specialized;
_LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type min() _NOEXCEPT {return __base::min();} _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type min() _NOEXCEPT {return __base::min();}
_LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type max() _NOEXCEPT {return __base::max();} _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type max() _NOEXCEPT {return __base::max();}
_LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type lowest() _NOEXCEPT {return __base::lowest();} _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type lowest() _NOEXCEPT {return __base::lowest();}
static _LIBCPP_CONSTEXPR const int digits = __base::digits; static _LIBCPP_CONSTEXPR const int digits = __base::digits;
▲ Show 20 Lines • Show All 364 Lines • Show Last 20 Lines

libcxx/include/list

Show First 20 Lines • Show All 231 Lines • ▼ Show 20 Lines
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp, class _VoidPtr> struct __list_node; template <class _Tp, class _VoidPtr> struct __list_node;
template <class _Tp, class _VoidPtr> struct __list_node_base; template <class _Tp, class _VoidPtr> struct __list_node_base;
template <class _Tp, class _VoidPtr> template <class _Tp, class _VoidPtr>
struct __list_node_pointer_traits { struct __list_node_pointer_traits {
typedef typename __rebind_pointer<_VoidPtr, __list_node<_Tp, _VoidPtr> >::type typedef __rebind_pointer_t<_VoidPtr, __list_node<_Tp, _VoidPtr> >
__node_pointer; __node_pointer;
typedef typename __rebind_pointer<_VoidPtr, __list_node_base<_Tp, _VoidPtr> >::type typedef __rebind_pointer_t<_VoidPtr, __list_node_base<_Tp, _VoidPtr> >
__base_pointer; __base_pointer;
#if defined(_LIBCPP_ABI_LIST_REMOVE_NODE_POINTER_UB) #if defined(_LIBCPP_ABI_LIST_REMOVE_NODE_POINTER_UB)
typedef __base_pointer __link_pointer; typedef __base_pointer __link_pointer;
#else #else
typedef typename conditional< typedef typename conditional<
is_pointer<_VoidPtr>::value, is_pointer<_VoidPtr>::value,
__base_pointer, __base_pointer,
▲ Show 20 Lines • Show All 84 Lines • ▼ Show 20 Lines#endif
template<class, class> friend class list; template<class, class> friend class list;
template<class, class> friend class __list_imp; template<class, class> friend class __list_imp;
template<class, class> friend class __list_const_iterator; template<class, class> friend class __list_const_iterator;
public: public:
typedef bidirectional_iterator_tag iterator_category; typedef bidirectional_iterator_tag iterator_category;
typedef _Tp value_type; typedef _Tp value_type;
typedef value_type& reference; typedef value_type& reference;
typedef typename __rebind_pointer<_VoidPtr, value_type>::type pointer; typedef __rebind_pointer_t<_VoidPtr, value_type> pointer;
typedef typename pointer_traits<pointer>::difference_type difference_type; typedef typename pointer_traits<pointer>::difference_type difference_type;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
__list_iterator() _NOEXCEPT : __ptr_(nullptr) __list_iterator() _NOEXCEPT : __ptr_(nullptr)
{ {
_VSTD::__debug_db_insert_i(this); _VSTD::__debug_db_insert_i(this);
} }
▲ Show 20 Lines • Show All 91 Lines • ▼ Show 20 Lines#endif
} }
template<class, class> friend class list; template<class, class> friend class list;
template<class, class> friend class __list_imp; template<class, class> friend class __list_imp;
public: public:
typedef bidirectional_iterator_tag iterator_category; typedef bidirectional_iterator_tag iterator_category;
typedef _Tp value_type; typedef _Tp value_type;
typedef const value_type& reference; typedef const value_type& reference;
typedef typename __rebind_pointer<_VoidPtr, const value_type>::type pointer; typedef __rebind_pointer_t<_VoidPtr, const value_type> pointer;
typedef typename pointer_traits<pointer>::difference_type difference_type; typedef typename pointer_traits<pointer>::difference_type difference_type;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
__list_const_iterator() _NOEXCEPT : __ptr_(nullptr) __list_const_iterator() _NOEXCEPT : __ptr_(nullptr)
{ {
_VSTD::__debug_db_insert_i(this); _VSTD::__debug_db_insert_i(this);
} }
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
▲ Show 20 Lines • Show All 1,908 Lines • Show Last 20 Lines

libcxx/include/locale

Show First 20 Lines • Show All 750 Lines • ▼ Show 20 Lines
template <class _Tp> template <class _Tp>
_LIBCPP_HIDDEN _Tp _LIBCPP_HIDDEN _Tp
__num_get_signed_integral(const char* __a, const char* __a_end, __num_get_signed_integral(const char* __a, const char* __a_end,
ios_base::iostate& __err, int __base) ios_base::iostate& __err, int __base)
{ {
if (__a != __a_end) if (__a != __a_end)
{ {
typename remove_reference<decltype(errno)>::type __save_errno = errno; __libcpp_remove_reference_t<decltype(errno)> __save_errno = errno;
errno = 0; errno = 0;
char *__p2; char *__p2;
long long __ll = strtoll_l(__a, &__p2, __base, _LIBCPP_GET_C_LOCALE); long long __ll = strtoll_l(__a, &__p2, __base, _LIBCPP_GET_C_LOCALE);
typename remove_reference<decltype(errno)>::type __current_errno = errno; __libcpp_remove_reference_t<decltype(errno)> __current_errno = errno;
if (__current_errno == 0) if (__current_errno == 0)
errno = __save_errno; errno = __save_errno;
if (__p2 != __a_end) if (__p2 != __a_end)
{ {
__err = ios_base::failbit; __err = ios_base::failbit;
return 0; return 0;
} }
else if (__current_errno == ERANGE || else if (__current_errno == ERANGE ||
Show All 19 Lines
{ {
if (__a != __a_end) if (__a != __a_end)
{ {
const bool __negate = *__a == '-'; const bool __negate = *__a == '-';
if (__negate && ++__a == __a_end) { if (__negate && ++__a == __a_end) {
__err = ios_base::failbit; __err = ios_base::failbit;
return 0; return 0;
} }
typename remove_reference<decltype(errno)>::type __save_errno = errno; __libcpp_remove_reference_t<decltype(errno)> __save_errno = errno;
errno = 0; errno = 0;
char *__p2; char *__p2;
unsigned long long __ll = strtoull_l(__a, &__p2, __base, _LIBCPP_GET_C_LOCALE); unsigned long long __ll = strtoull_l(__a, &__p2, __base, _LIBCPP_GET_C_LOCALE);
typename remove_reference<decltype(errno)>::type __current_errno = errno; __libcpp_remove_reference_t<decltype(errno)> __current_errno = errno;
if (__current_errno == 0) if (__current_errno == 0)
errno = __save_errno; errno = __save_errno;
if (__p2 != __a_end) if (__p2 != __a_end)
{ {
__err = ios_base::failbit; __err = ios_base::failbit;
return 0; return 0;
} }
else if (__current_errno == ERANGE || numeric_limits<_Tp>::max() < __ll) else if (__current_errno == ERANGE || numeric_limits<_Tp>::max() < __ll)
Show All 33 Lines
template <class _Tp> template <class _Tp>
_LIBCPP_HIDDEN _LIBCPP_HIDDEN
_Tp _Tp
__num_get_float(const char* __a, const char* __a_end, ios_base::iostate& __err) __num_get_float(const char* __a, const char* __a_end, ios_base::iostate& __err)
{ {
if (__a != __a_end) if (__a != __a_end)
{ {
typename remove_reference<decltype(errno)>::type __save_errno = errno; __libcpp_remove_reference_t<decltype(errno)> __save_errno = errno;
errno = 0; errno = 0;
char *__p2; char *__p2;
_Tp __ld = __do_strtod<_Tp>(__a, &__p2); _Tp __ld = __do_strtod<_Tp>(__a, &__p2);
typename remove_reference<decltype(errno)>::type __current_errno = errno; __libcpp_remove_reference_t<decltype(errno)> __current_errno = errno;
if (__current_errno == 0) if (__current_errno == 0)
errno = __save_errno; errno = __save_errno;
if (__p2 != __a_end) if (__p2 != __a_end)
{ {
__err = ios_base::failbit; __err = ios_base::failbit;
return 0; return 0;
} }
else if (__current_errno == ERANGE) else if (__current_errno == ERANGE)
▲ Show 20 Lines • Show All 3,494 Lines • Show Last 20 Lines

libcxx/include/memory

Show First 20 Lines • Show All 876 Lines • ▼ Show 20 Lines
#include <__memory/unique_ptr.h> #include <__memory/unique_ptr.h>
#include <__memory/uses_allocator.h> #include <__memory/uses_allocator.h>
#include <cstddef> #include <cstddef>
#include <cstdint> #include <cstdint>
#include <cstring> #include <cstring>
#include <iosfwd> #include <iosfwd>
#include <new> #include <new>
#include <stdexcept> #include <stdexcept>
#include <tuple>
#include <type_traits> #include <type_traits>
#include <typeinfo> #include <typeinfo>
#include <version> #include <version>
#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES #ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
# include <iterator> # include <iterator>
# include <tuple>
# include <utility> # include <utility>
#endif #endif
// standard-mandated includes // standard-mandated includes
#include <compare> #include <compare>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
▲ Show 20 Lines • Show All 148 Lines • Show Last 20 Lines

libcxx/include/new

Show First 20 Lines • Show All 359 Lines • ▼ Show 20 Lines
#endif // !_LIBCPP_HAS_NO_ALIGNED_ALLOCATION #endif // !_LIBCPP_HAS_NO_ALIGNED_ALLOCATION
template <class _Tp> template <class _Tp>
_LIBCPP_NODISCARD_AFTER_CXX17 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_NODISCARD_AFTER_CXX17 inline _LIBCPP_HIDE_FROM_ABI
_LIBCPP_CONSTEXPR _Tp* __launder(_Tp* __p) _NOEXCEPT _LIBCPP_CONSTEXPR _Tp* __launder(_Tp* __p) _NOEXCEPT
{ {
static_assert (!(is_function<_Tp>::value), "can't launder functions" ); static_assert (!(is_function<_Tp>::value), "can't launder functions" );
static_assert (!(is_same<void, typename remove_cv<_Tp>::type>::value), "can't launder cv-void" ); static_assert (!(is_same<void, __remove_cv_t<_Tp> >::value), "can't launder cv-void" );
return __builtin_launder(__p); return __builtin_launder(__p);
} }
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER > 14
template <class _Tp> template <class _Tp>
_LIBCPP_NODISCARD_AFTER_CXX17 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_NODISCARD_AFTER_CXX17 inline _LIBCPP_HIDE_FROM_ABI
constexpr _Tp* launder(_Tp* __p) noexcept constexpr _Tp* launder(_Tp* __p) noexcept
{ {
Show All 18 Lines

libcxx/include/optional

Show First 20 Lines • Show All 411 Lines • ▼ Show 20 Lines
struct __optional_storage_base<_Tp, true> struct __optional_storage_base<_Tp, true>
{ {
using value_type = _Tp; using value_type = _Tp;
using __raw_type = remove_reference_t<_Tp>; using __raw_type = remove_reference_t<_Tp>;
__raw_type* __value_; __raw_type* __value_;
template <class _Up> template <class _Up>
static constexpr bool __can_bind_reference() { static constexpr bool __can_bind_reference() {
using _RawUp = typename remove_reference<_Up>::type; using _RawUp = __libcpp_remove_reference_t<_Up>;
using _UpPtr = _RawUp*; using _UpPtr = _RawUp*;
using _RawTp = typename remove_reference<_Tp>::type; using _RawTp = __libcpp_remove_reference_t<_Tp>;
using _TpPtr = _RawTp*; using _TpPtr = _RawTp*;
using _CheckLValueArg = integral_constant<bool, using _CheckLValueArg = integral_constant<bool,
(is_lvalue_reference<_Up>::value && is_convertible<_UpPtr, _TpPtr>::value) (is_lvalue_reference<_Up>::value && is_convertible<_UpPtr, _TpPtr>::value)
|| is_same<_RawUp, reference_wrapper<_RawTp>>::value || is_same<_RawUp, reference_wrapper<_RawTp>>::value
|| is_same<_RawUp, reference_wrapper<typename remove_const<_RawTp>::type>>::value || is_same<_RawUp, reference_wrapper<__remove_const_t<_RawTp>>>::value
>; >;
return (is_lvalue_reference<_Tp>::value && _CheckLValueArg::value) return (is_lvalue_reference<_Tp>::value && _CheckLValueArg::value)
|| (is_rvalue_reference<_Tp>::value && !is_lvalue_reference<_Up>::value && || (is_rvalue_reference<_Tp>::value && !is_lvalue_reference<_Up>::value &&
is_convertible<_UpPtr, _TpPtr>::value); is_convertible<_UpPtr, _TpPtr>::value);
} }
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
constexpr __optional_storage_base() noexcept constexpr __optional_storage_base() noexcept
▲ Show 20 Lines • Show All 211 Lines • ▼ Show 20 Linesclass optional
, private __optional_sfinae_assign_base_t<_Tp> , private __optional_sfinae_assign_base_t<_Tp>
{ {
using __base = __optional_move_assign_base<_Tp>; using __base = __optional_move_assign_base<_Tp>;
public: public:
using value_type = _Tp; using value_type = _Tp;
private: private:
// Disable the reference extension using this static assert. // Disable the reference extension using this static assert.
static_assert(!is_same_v<__uncvref_t<value_type>, in_place_t>, static_assert(!is_same_v<__remove_cvref_t<value_type>, in_place_t>,
"instantiation of optional with in_place_t is ill-formed"); "instantiation of optional with in_place_t is ill-formed");
static_assert(!is_same_v<__uncvref_t<value_type>, nullopt_t>, static_assert(!is_same_v<__remove_cvref_t<value_type>, nullopt_t>,
"instantiation of optional with nullopt_t is ill-formed"); "instantiation of optional with nullopt_t is ill-formed");
static_assert(!is_reference_v<value_type>, static_assert(!is_reference_v<value_type>,
"instantiation of optional with a reference type is ill-formed"); "instantiation of optional with a reference type is ill-formed");
static_assert(is_destructible_v<value_type>, static_assert(is_destructible_v<value_type>,
"instantiation of optional with a non-destructible type is ill-formed"); "instantiation of optional with a non-destructible type is ill-formed");
static_assert(!is_array_v<value_type>, static_assert(!is_array_v<value_type>,
"instantiation of optional with an array type is ill-formed"); "instantiation of optional with an array type is ill-formed");
// LWG2756: conditionally explicit conversion from _Up // LWG2756: conditionally explicit conversion from _Up
struct _CheckOptionalArgsConstructor { struct _CheckOptionalArgsConstructor {
template <class _Up> template <class _Up>
static constexpr bool __enable_implicit() { static constexpr bool __enable_implicit() {
return is_constructible_v<_Tp, _Up&&> && return is_constructible_v<_Tp, _Up&&> &&
is_convertible_v<_Up&&, _Tp>; is_convertible_v<_Up&&, _Tp>;
} }
template <class _Up> template <class _Up>
static constexpr bool __enable_explicit() { static constexpr bool __enable_explicit() {
return is_constructible_v<_Tp, _Up&&> && return is_constructible_v<_Tp, _Up&&> &&
!is_convertible_v<_Up&&, _Tp>; !is_convertible_v<_Up&&, _Tp>;
} }
}; };
template <class _Up> template <class _Up>
using _CheckOptionalArgsCtor = _If< using _CheckOptionalArgsCtor = _If<
_IsNotSame<__uncvref_t<_Up>, in_place_t>::value && _IsNotSame<__remove_cvref_t<_Up>, in_place_t>::value &&
_IsNotSame<__uncvref_t<_Up>, optional>::value, _IsNotSame<__remove_cvref_t<_Up>, optional>::value,
_CheckOptionalArgsConstructor, _CheckOptionalArgsConstructor,
__check_tuple_constructor_fail __check_tuple_constructor_fail
>; >;
template <class _QualUp> template <class _QualUp>
struct _CheckOptionalLikeConstructor { struct _CheckOptionalLikeConstructor {
template <class _Up, class _Opt = optional<_Up>> template <class _Up, class _Opt = optional<_Up>>
using __check_constructible_from_opt = _Or< using __check_constructible_from_opt = _Or<
is_constructible<_Tp, _Opt&>, is_constructible<_Tp, _Opt&>,
▲ Show 20 Lines • Show All 143 Lines • ▼ Show 20 Lines#endif
_LIBCPP_INLINE_VISIBILITY optional& operator=(const optional&) = default; _LIBCPP_INLINE_VISIBILITY optional& operator=(const optional&) = default;
_LIBCPP_INLINE_VISIBILITY optional& operator=(optional&&) = default; _LIBCPP_INLINE_VISIBILITY optional& operator=(optional&&) = default;
// LWG2756 // LWG2756
template <class _Up = value_type, template <class _Up = value_type,
class = enable_if_t< class = enable_if_t<
_And< _And<
_IsNotSame<__uncvref_t<_Up>, optional>, _IsNotSame<__remove_cvref_t<_Up>, optional>,
_Or< _Or<
_IsNotSame<__uncvref_t<_Up>, value_type>, _IsNotSame<__remove_cvref_t<_Up>, value_type>,
_Not<is_scalar<value_type>> _Not<is_scalar<value_type>>
>, >,
is_constructible<value_type, _Up>, is_constructible<value_type, _Up>,
is_assignable<value_type&, _Up> is_assignable<value_type&, _Up>
>::value> >::value>
> >
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR_SINCE_CXX20 optional& _LIBCPP_CONSTEXPR_SINCE_CXX20 optional&
▲ Show 20 Lines • Show All 737 Lines • Show Last 20 Lines

libcxx/include/scoped_allocator

Show First 20 Lines • Show All 373 Lines • ▼ Show 20 Linesstruct __outermost
typedef _Alloc type; typedef _Alloc type;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
type& operator()(type& __a) const _NOEXCEPT {return __a;} type& operator()(type& __a) const _NOEXCEPT {return __a;}
}; };
template <class _Alloc> template <class _Alloc>
struct __outermost<_Alloc, true> struct __outermost<_Alloc, true>
{ {
typedef typename remove_reference typedef __libcpp_remove_reference_t
< <
decltype(declval<_Alloc>().outer_allocator()) decltype(declval<_Alloc>().outer_allocator())
>::type _OuterAlloc; > _OuterAlloc;
typedef typename __outermost<_OuterAlloc>::type type; typedef typename __outermost<_OuterAlloc>::type type;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
type& operator()(_Alloc& __a) const _NOEXCEPT type& operator()(_Alloc& __a) const _NOEXCEPT
{return __outermost<_OuterAlloc>()(__a.outer_allocator());} {return __outermost<_OuterAlloc>()(__a.outer_allocator());}
}; };
template <class _OuterAlloc, class... _InnerAllocs> template <class _OuterAlloc, class... _InnerAllocs>
class _LIBCPP_TEMPLATE_VIS scoped_allocator_adaptor<_OuterAlloc, _InnerAllocs...> class _LIBCPP_TEMPLATE_VIS scoped_allocator_adaptor<_OuterAlloc, _InnerAllocs...>
▲ Show 20 Lines • Show All 302 Lines • Show Last 20 Lines

libcxx/include/thread

Show First 20 Lines • Show All 230 Lines • ▼ Show 20 Lines
public: public:
typedef __thread_id id; typedef __thread_id id;
typedef __libcpp_thread_t native_handle_type; typedef __libcpp_thread_t native_handle_type;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
thread() _NOEXCEPT : __t_(_LIBCPP_NULL_THREAD) {} thread() _NOEXCEPT : __t_(_LIBCPP_NULL_THREAD) {}
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
template <class _Fp, class ..._Args, template <class _Fp, class ..._Args,
class = __enable_if_t<!is_same<__uncvref_t<_Fp>, thread>::value> > class = __enable_if_t<!is_same<__remove_cvref_t<_Fp>, thread>::value> >
_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
explicit thread(_Fp&& __f, _Args&&... __args); explicit thread(_Fp&& __f, _Args&&... __args);
#else // _LIBCPP_CXX03_LANG #else // _LIBCPP_CXX03_LANG
template <class _Fp> template <class _Fp>
_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
explicit thread(_Fp __f); explicit thread(_Fp __f);
#endif #endif
~thread(); ~thread();
▲ Show 20 Lines • Show All 169 Lines • Show Last 20 Lines

libcxx/include/tuple

Show First 20 Lines • Show All 302 Lines • ▼ Show 20 Lines template <class _Alloc>
__tuple_leaf(integral_constant<int, 2>, const _Alloc& __a) __tuple_leaf(integral_constant<int, 2>, const _Alloc& __a)
: __value_(__a) : __value_(__a)
{static_assert(!is_reference<_Hp>::value, {static_assert(!is_reference<_Hp>::value,
"Attempted to default construct a reference element in a tuple");} "Attempted to default construct a reference element in a tuple");}
template <class _Tp, template <class _Tp,
class = __enable_if_t< class = __enable_if_t<
_And< _And<
_IsNotSame<__uncvref_t<_Tp>, __tuple_leaf>, _IsNotSame<__remove_cvref_t<_Tp>, __tuple_leaf>,
is_constructible<_Hp, _Tp> is_constructible<_Hp, _Tp>
>::value >::value
> >
> >
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
explicit __tuple_leaf(_Tp&& __t) _NOEXCEPT_((is_nothrow_constructible<_Hp, _Tp>::value)) explicit __tuple_leaf(_Tp&& __t) _NOEXCEPT_((is_nothrow_constructible<_Hp, _Tp>::value))
: __value_(_VSTD::forward<_Tp>(__t)) : __value_(_VSTD::forward<_Tp>(__t))
{static_assert(__can_bind_reference<_Tp&&>(), {static_assert(__can_bind_reference<_Tp&&>(),
▲ Show 20 Lines • Show All 62 Lines • ▼ Show 20 Linespublic:
template <class _Alloc> template <class _Alloc>
_LIBCPP_INLINE_VISIBILITY constexpr _LIBCPP_INLINE_VISIBILITY constexpr
__tuple_leaf(integral_constant<int, 2>, const _Alloc& __a) __tuple_leaf(integral_constant<int, 2>, const _Alloc& __a)
: _Hp(__a) {} : _Hp(__a) {}
template <class _Tp, template <class _Tp,
class = __enable_if_t< class = __enable_if_t<
_And< _And<
_IsNotSame<__uncvref_t<_Tp>, __tuple_leaf>, _IsNotSame<__remove_cvref_t<_Tp>, __tuple_leaf>,
is_constructible<_Hp, _Tp> is_constructible<_Hp, _Tp>
>::value >::value
> >
> >
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
explicit __tuple_leaf(_Tp&& __t) _NOEXCEPT_((is_nothrow_constructible<_Hp, _Tp>::value)) explicit __tuple_leaf(_Tp&& __t) _NOEXCEPT_((is_nothrow_constructible<_Hp, _Tp>::value))
: _Hp(_VSTD::forward<_Tp>(__t)) {} : _Hp(_VSTD::forward<_Tp>(__t)) {}
▲ Show 20 Lines • Show All 270 Lines • ▼ Show 20 Lines explicit tuple(allocator_arg_t, const _Alloc& __a, const _Tp& ... __t)
typename __make_tuple_types<tuple, sizeof...(_Tp)>::type(), typename __make_tuple_types<tuple, sizeof...(_Tp)>::type(),
typename __make_tuple_indices<0>::type(), typename __make_tuple_indices<0>::type(),
typename __make_tuple_types<tuple, 0>::type(), typename __make_tuple_types<tuple, 0>::type(),
__t... __t...
) {} ) {}
// tuple(U&& ...) constructors (including allocator_arg_t variants) // tuple(U&& ...) constructors (including allocator_arg_t variants)
template <class ..._Up> struct _IsThisTuple : false_type { }; template <class ..._Up> struct _IsThisTuple : false_type { };
template <class _Up> struct _IsThisTuple<_Up> : is_same<__uncvref_t<_Up>, tuple> { }; template <class _Up> struct _IsThisTuple<_Up> : is_same<__remove_cvref_t<_Up>, tuple> { };
template <class ..._Up> template <class ..._Up>
struct _EnableUTypesCtor : _And< struct _EnableUTypesCtor : _And<
_BoolConstant<sizeof...(_Tp) >= 1>, _BoolConstant<sizeof...(_Tp) >= 1>,
_Not<_IsThisTuple<_Up...> >, // extension to allow mis-behaved user constructors _Not<_IsThisTuple<_Up...> >, // extension to allow mis-behaved user constructors
is_constructible<_Tp, _Up>... is_constructible<_Tp, _Up>...
> { }; > { };
▲ Show 20 Lines • Show All 78 Lines • ▼ Show 20 Linespublic:
, int> = 0> , int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
tuple(allocator_arg_t, const _Alloc& __alloc, tuple&& __t) tuple(allocator_arg_t, const _Alloc& __alloc, tuple&& __t)
: __base_(allocator_arg_t(), __alloc, _VSTD::move(__t)) : __base_(allocator_arg_t(), __alloc, _VSTD::move(__t))
{ } { }
// tuple(const tuple<U...>&) constructors (including allocator_arg_t variants) // tuple(const tuple<U...>&) constructors (including allocator_arg_t variants)
template <class _OtherTuple, class _DecayedOtherTuple = __uncvref_t<_OtherTuple>, class = void> template <class _OtherTuple, class _DecayedOtherTuple = __remove_cvref_t<_OtherTuple>, class = void>
struct _EnableCtorFromUTypesTuple : false_type {}; struct _EnableCtorFromUTypesTuple : false_type {};
template <class _OtherTuple, class... _Up> template <class _OtherTuple, class... _Up>
struct _EnableCtorFromUTypesTuple<_OtherTuple, tuple<_Up...>, struct _EnableCtorFromUTypesTuple<_OtherTuple, tuple<_Up...>,
// the length of the packs needs to checked first otherwise the 2 packs cannot be expanded simultaneously below // the length of the packs needs to checked first otherwise the 2 packs cannot be expanded simultaneously below
__enable_if_t<sizeof...(_Up) == sizeof...(_Tp)>> : _And< __enable_if_t<sizeof...(_Up) == sizeof...(_Tp)>> : _And<
// the two conditions below are not in spec. The purpose is to disable the UTypes Ctor when copy/move Ctor can work. // the two conditions below are not in spec. The purpose is to disable the UTypes Ctor when copy/move Ctor can work.
// Otherwise, is_constructible can trigger hard error in those cases https://godbolt.org/z/M94cGdKcE // Otherwise, is_constructible can trigger hard error in those cases https://godbolt.org/z/M94cGdKcE
▲ Show 20 Lines • Show All 135 Lines • ▼ Show 20 Lines#if _LIBCPP_STD_VER > 20
_LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_HIDE_FROM_ABI constexpr
explicit(!(is_convertible_v<const _Up&&, _Tp> && ...)) explicit(!(is_convertible_v<const _Up&&, _Tp> && ...))
tuple(allocator_arg_t, const _Alloc& __alloc, const tuple<_Up...>&& __t) tuple(allocator_arg_t, const _Alloc& __alloc, const tuple<_Up...>&& __t)
: __base_(allocator_arg_t(), __alloc, std::move(__t)) {} : __base_(allocator_arg_t(), __alloc, std::move(__t)) {}
#endif // _LIBCPP_STD_VER > 20 #endif // _LIBCPP_STD_VER > 20
// tuple(const pair<U1, U2>&) constructors (including allocator_arg_t variants) // tuple(const pair<U1, U2>&) constructors (including allocator_arg_t variants)
template <template <class...> class Pred, class _Pair, class _DecayedPair = __uncvref_t<_Pair>, class _Tuple = tuple> template <template <class...> class Pred, class _Pair, class _DecayedPair = __remove_cvref_t<_Pair>, class _Tuple = tuple>
struct _CtorPredicateFromPair : false_type{}; struct _CtorPredicateFromPair : false_type{};
template <template <class...> class Pred, class _Pair, class _Up1, class _Up2, class _Tp1, class _Tp2> template <template <class...> class Pred, class _Pair, class _Up1, class _Up2, class _Tp1, class _Tp2>
struct _CtorPredicateFromPair<Pred, _Pair, pair<_Up1, _Up2>, tuple<_Tp1, _Tp2> > : _And< struct _CtorPredicateFromPair<Pred, _Pair, pair<_Up1, _Up2>, tuple<_Tp1, _Tp2> > : _And<
Pred<_Tp1, __copy_cvref_t<_Pair, _Up1> >, Pred<_Tp1, __copy_cvref_t<_Pair, _Up1> >,
Pred<_Tp2, __copy_cvref_t<_Pair, _Up2> > Pred<_Tp2, __copy_cvref_t<_Pair, _Up2> >
> {}; > {};
template <class _Pair> template <class _Pair>
struct _EnableCtorFromPair : _CtorPredicateFromPair<is_constructible, _Pair>{}; struct _EnableCtorFromPair : _CtorPredicateFromPair<is_constructible, _Pair>{};
template <class _Pair> template <class _Pair>
struct _NothrowConstructibleFromPair : _CtorPredicateFromPair<is_nothrow_constructible, _Pair>{}; struct _NothrowConstructibleFromPair : _CtorPredicateFromPair<is_nothrow_constructible, _Pair>{};
template <class _Pair, class _DecayedPair = __uncvref_t<_Pair>, class _Tuple = tuple> template <class _Pair, class _DecayedPair = __remove_cvref_t<_Pair>, class _Tuple = tuple>
struct _BothImplicitlyConvertible : false_type{}; struct _BothImplicitlyConvertible : false_type{};
template <class _Pair, class _Up1, class _Up2, class _Tp1, class _Tp2> template <class _Pair, class _Up1, class _Up2, class _Tp1, class _Tp2>
struct _BothImplicitlyConvertible<_Pair, pair<_Up1, _Up2>, tuple<_Tp1, _Tp2> > : _And< struct _BothImplicitlyConvertible<_Pair, pair<_Up1, _Up2>, tuple<_Tp1, _Tp2> > : _And<
is_convertible<__copy_cvref_t<_Pair, _Up1>, _Tp1>, is_convertible<__copy_cvref_t<_Pair, _Up1>, _Tp1>,
is_convertible<__copy_cvref_t<_Pair, _Up2>, _Tp2> is_convertible<__copy_cvref_t<_Pair, _Up2>, _Tp2>
> {}; > {};
▲ Show 20 Lines • Show All 216 Lines • ▼ Show 20 Lines const tuple& operator=(tuple<_UTypes...>&& __u) const {
__u, __u,
__tuple_types<_UTypes...>(), __tuple_types<_UTypes...>(),
typename __make_tuple_indices<sizeof...(_Tp)>::type()); typename __make_tuple_indices<sizeof...(_Tp)>::type());
return *this; return *this;
} }
#endif // _LIBCPP_STD_VER > 20 #endif // _LIBCPP_STD_VER > 20
template <template<class...> class Pred, bool _Const, template <template<class...> class Pred, bool _Const,
class _Pair, class _DecayedPair = __uncvref_t<_Pair>, class _Tuple = tuple> class _Pair, class _DecayedPair = __remove_cvref_t<_Pair>, class _Tuple = tuple>
struct _AssignPredicateFromPair : false_type {}; struct _AssignPredicateFromPair : false_type {};
template <template<class...> class Pred, bool _Const, template <template<class...> class Pred, bool _Const,
class _Pair, class _Up1, class _Up2, class _Tp1, class _Tp2> class _Pair, class _Up1, class _Up2, class _Tp1, class _Tp2>
struct _AssignPredicateFromPair<Pred, _Const, _Pair, pair<_Up1, _Up2>, tuple<_Tp1, _Tp2> > : struct _AssignPredicateFromPair<Pred, _Const, _Pair, pair<_Up1, _Up2>, tuple<_Tp1, _Tp2> > :
_And<Pred<__maybe_const<_Const, _Tp1>&, __copy_cvref_t<_Pair, _Up1> >, _And<Pred<__maybe_const<_Const, _Tp1>&, __copy_cvref_t<_Pair, _Up1> >,
Pred<__maybe_const<_Const, _Tp2>&, __copy_cvref_t<_Pair, _Up2> > Pred<__maybe_const<_Const, _Tp2>&, __copy_cvref_t<_Pair, _Up2> >
> {}; > {};
▲ Show 20 Lines • Show All 453 Lines • ▼ Show 20 Lines
{ {
}; };
template <class ..._Types, class _Tuple0> template <class ..._Types, class _Tuple0>
struct __tuple_cat_return_1<tuple<_Types...>, true, _Tuple0> struct __tuple_cat_return_1<tuple<_Types...>, true, _Tuple0>
{ {
using type _LIBCPP_NODEBUG = typename __tuple_cat_type< using type _LIBCPP_NODEBUG = typename __tuple_cat_type<
tuple<_Types...>, tuple<_Types...>,
typename __make_tuple_types<__uncvref_t<_Tuple0> >::type typename __make_tuple_types<__remove_cvref_t<_Tuple0> >::type
>::type; >::type;
}; };
template <class ..._Types, class _Tuple0, class _Tuple1, class ..._Tuples> template <class ..._Types, class _Tuple0, class _Tuple1, class ..._Tuples>
struct __tuple_cat_return_1<tuple<_Types...>, true, _Tuple0, _Tuple1, _Tuples...> struct __tuple_cat_return_1<tuple<_Types...>, true, _Tuple0, _Tuple1, _Tuples...>
: public __tuple_cat_return_1< : public __tuple_cat_return_1<
typename __tuple_cat_type< typename __tuple_cat_type<
tuple<_Types...>, tuple<_Types...>,
typename __make_tuple_types<__uncvref_t<_Tuple0> >::type typename __make_tuple_types<__remove_cvref_t<_Tuple0> >::type
>::type, >::type,
__tuple_like<typename remove_reference<_Tuple1>::type>::value, __tuple_like<__libcpp_remove_reference_t<_Tuple1> >::value,
_Tuple1, _Tuples...> _Tuple1, _Tuples...>
{ {
}; };
template <class ..._Tuples> struct __tuple_cat_return; template <class ..._Tuples> struct __tuple_cat_return;
template <class _Tuple0, class ..._Tuples> template <class _Tuple0, class ..._Tuples>
struct __tuple_cat_return<_Tuple0, _Tuples...> struct __tuple_cat_return<_Tuple0, _Tuples...>
: public __tuple_cat_return_1<tuple<>, : public __tuple_cat_return_1<tuple<>,
__tuple_like<typename remove_reference<_Tuple0>::type>::value, _Tuple0, __tuple_like<__libcpp_remove_reference_t<_Tuple0> >::value, _Tuple0,
_Tuples...> _Tuples...>
{ {
}; };
template <> template <>
struct __tuple_cat_return<> struct __tuple_cat_return<>
{ {
typedef _LIBCPP_NODEBUG tuple<> type; typedef _LIBCPP_NODEBUG tuple<> type;
}; };
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
tuple<> tuple<>
tuple_cat() tuple_cat()
{ {
return tuple<>(); return tuple<>();
} }
template <class _Rp, class _Indices, class _Tuple0, class ..._Tuples> template <class _Rp, class _Indices, class _Tuple0, class ..._Tuples>
struct __tuple_cat_return_ref_imp; struct __tuple_cat_return_ref_imp;
template <class ..._Types, size_t ..._I0, class _Tuple0> template <class ..._Types, size_t ..._I0, class _Tuple0>
struct __tuple_cat_return_ref_imp<tuple<_Types...>, __tuple_indices<_I0...>, _Tuple0> struct __tuple_cat_return_ref_imp<tuple<_Types...>, __tuple_indices<_I0...>, _Tuple0>
{ {
typedef _LIBCPP_NODEBUG typename remove_reference<_Tuple0>::type _T0; typedef _LIBCPP_NODEBUG __libcpp_remove_reference_t<_Tuple0> _T0;
typedef tuple<_Types..., typename __apply_cv<_Tuple0, typedef tuple<_Types..., typename __apply_cv<_Tuple0,
typename tuple_element<_I0, _T0>::type>::type&&...> type; typename tuple_element<_I0, _T0>::type>::type&&...> type;
}; };
template <class ..._Types, size_t ..._I0, class _Tuple0, class _Tuple1, class ..._Tuples> template <class ..._Types, size_t ..._I0, class _Tuple0, class _Tuple1, class ..._Tuples>
struct __tuple_cat_return_ref_imp<tuple<_Types...>, __tuple_indices<_I0...>, struct __tuple_cat_return_ref_imp<tuple<_Types...>, __tuple_indices<_I0...>,
_Tuple0, _Tuple1, _Tuples...> _Tuple0, _Tuple1, _Tuples...>
: public __tuple_cat_return_ref_imp< : public __tuple_cat_return_ref_imp<
tuple<_Types..., typename __apply_cv<_Tuple0, tuple<_Types..., typename __apply_cv<_Tuple0,
typename tuple_element<_I0, typename tuple_element<_I0,
typename remove_reference<_Tuple0>::type>::type>::type&&...>, __libcpp_remove_reference_t<_Tuple0> >::type>::type&&...>,
typename __make_tuple_indices<tuple_size<typename typename __make_tuple_indices<tuple_size<__libcpp_remove_reference_t<_Tuple1> >::value>::type,
remove_reference<_Tuple1>::type>::value>::type,
_Tuple1, _Tuples...> _Tuple1, _Tuples...>
{ {
}; };
template <class _Tuple0, class ..._Tuples> template <class _Tuple0, class ..._Tuples>
struct __tuple_cat_return_ref struct __tuple_cat_return_ref
: public __tuple_cat_return_ref_imp<tuple<>, : public __tuple_cat_return_ref_imp<tuple<>,
typename __make_tuple_indices< typename __make_tuple_indices<
tuple_size<typename remove_reference<_Tuple0>::type>::value tuple_size<__libcpp_remove_reference_t<_Tuple0> >::value
>::type, _Tuple0, _Tuples...> >::type, _Tuple0, _Tuples...>
{ {
}; };
template <class _Types, class _I0, class _J0> template <class _Types, class _I0, class _J0>
struct __tuple_cat; struct __tuple_cat;
template <class ..._Types, size_t ..._I0, size_t ..._J0> template <class ..._Types, size_t ..._I0, size_t ..._J0>
Show All 11 Linesstruct __tuple_cat<tuple<_Types...>, __tuple_indices<_I0...>, __tuple_indices<_J0...> >
} }
template <class _Tuple0, class _Tuple1, class ..._Tuples> template <class _Tuple0, class _Tuple1, class ..._Tuples>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
typename __tuple_cat_return_ref<tuple<_Types...>&&, _Tuple0&&, _Tuple1&&, _Tuples&&...>::type typename __tuple_cat_return_ref<tuple<_Types...>&&, _Tuple0&&, _Tuple1&&, _Tuples&&...>::type
operator()(tuple<_Types...> __t, _Tuple0&& __t0, _Tuple1&& __t1, _Tuples&& ...__tpls) operator()(tuple<_Types...> __t, _Tuple0&& __t0, _Tuple1&& __t1, _Tuples&& ...__tpls)
{ {
(void)__t; // avoid unused parameter warning on GCC when _I0 is empty (void)__t; // avoid unused parameter warning on GCC when _I0 is empty
typedef _LIBCPP_NODEBUG typename remove_reference<_Tuple0>::type _T0; typedef _LIBCPP_NODEBUG __libcpp_remove_reference_t<_Tuple0> _T0;
typedef _LIBCPP_NODEBUG typename remove_reference<_Tuple1>::type _T1; typedef _LIBCPP_NODEBUG __libcpp_remove_reference_t<_Tuple1> _T1;
return __tuple_cat< return __tuple_cat<
tuple<_Types..., tuple<_Types...,
typename __apply_cv<_Tuple0, typename tuple_element< typename __apply_cv<_Tuple0, typename tuple_element<
_J0, _T0>::type>::type&&...>, _J0, _T0>::type>::type&&...>,
typename __make_tuple_indices<sizeof...(_Types) + typename __make_tuple_indices<sizeof...(_Types) +
tuple_size<_T0>::value>::type, tuple_size<_T0>::value>::type,
typename __make_tuple_indices<tuple_size<_T1>::value>::type>()( typename __make_tuple_indices<tuple_size<_T1>::value>::type>()(
_VSTD::forward_as_tuple( _VSTD::forward_as_tuple(
_VSTD::forward<_Types>(_VSTD::get<_I0>(__t))..., _VSTD::forward<_Types>(_VSTD::get<_I0>(__t))...,
_VSTD::get<_J0>(_VSTD::forward<_Tuple0>(__t0))...), _VSTD::get<_J0>(_VSTD::forward<_Tuple0>(__t0))...),
_VSTD::forward<_Tuple1>(__t1), _VSTD::forward<_Tuples>(__tpls)...); _VSTD::forward<_Tuple1>(__t1), _VSTD::forward<_Tuples>(__tpls)...);
} }
}; };
template <class _Tuple0, class... _Tuples> template <class _Tuple0, class... _Tuples>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
typename __tuple_cat_return<_Tuple0, _Tuples...>::type typename __tuple_cat_return<_Tuple0, _Tuples...>::type
tuple_cat(_Tuple0&& __t0, _Tuples&&... __tpls) tuple_cat(_Tuple0&& __t0, _Tuples&&... __tpls)
{ {
typedef _LIBCPP_NODEBUG typename remove_reference<_Tuple0>::type _T0; typedef _LIBCPP_NODEBUG __libcpp_remove_reference_t<_Tuple0> _T0;
return __tuple_cat<tuple<>, __tuple_indices<>, return __tuple_cat<tuple<>, __tuple_indices<>,
typename __make_tuple_indices<tuple_size<_T0>::value>::type>() typename __make_tuple_indices<tuple_size<_T0>::value>::type>()
(tuple<>(), _VSTD::forward<_Tuple0>(__t0), (tuple<>(), _VSTD::forward<_Tuple0>(__t0),
_VSTD::forward<_Tuples>(__tpls)...); _VSTD::forward<_Tuples>(__tpls)...);
} }
template <class ..._Tp, class _Alloc> template <class ..._Tp, class _Alloc>
struct _LIBCPP_TEMPLATE_VIS uses_allocator<tuple<_Tp...>, _Alloc> struct _LIBCPP_TEMPLATE_VIS uses_allocator<tuple<_Tp...>, _Alloc>
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

libcxx/include/valarray

Show First 20 Lines • Show All 683 Lines • ▼ Show 20 Linesstruct __tanh_expr
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
_Tp operator()(const _Tp& __x) const _Tp operator()(const _Tp& __x) const
{return tanh(__x);} {return tanh(__x);}
}; };
template <class _ValExpr> template <class _ValExpr>
class __slice_expr class __slice_expr
{ {
typedef typename remove_reference<_ValExpr>::type _RmExpr; typedef __libcpp_remove_reference_t<_ValExpr> _RmExpr;
public: public:
typedef typename _RmExpr::value_type value_type; typedef typename _RmExpr::value_type value_type;
typedef value_type __result_type; typedef value_type __result_type;
private: private:
_ValExpr __expr_; _ValExpr __expr_;
size_t __start_; size_t __start_;
size_t __size_; size_t __size_;
Show All 23 Lines
class __mask_expr; class __mask_expr;
template <class _ValExpr> template <class _ValExpr>
class __indirect_expr; class __indirect_expr;
template <class _ValExpr> template <class _ValExpr>
class __shift_expr class __shift_expr
{ {
typedef typename remove_reference<_ValExpr>::type _RmExpr; typedef __libcpp_remove_reference_t<_ValExpr> _RmExpr;
public: public:
typedef typename _RmExpr::value_type value_type; typedef typename _RmExpr::value_type value_type;
typedef value_type __result_type; typedef value_type __result_type;
private: private:
_ValExpr __expr_; _ValExpr __expr_;
size_t __size_; size_t __size_;
ptrdiff_t __ul_; ptrdiff_t __ul_;
Show All 26 Linespublic:
size_t size() const {return __size_;} size_t size() const {return __size_;}
template <class> friend class __val_expr; template <class> friend class __val_expr;
}; };
template <class _ValExpr> template <class _ValExpr>
class __cshift_expr class __cshift_expr
{ {
typedef typename remove_reference<_ValExpr>::type _RmExpr; typedef __libcpp_remove_reference_t<_ValExpr> _RmExpr;
public: public:
typedef typename _RmExpr::value_type value_type; typedef typename _RmExpr::value_type value_type;
typedef value_type __result_type; typedef value_type __result_type;
private: private:
_ValExpr __expr_; _ValExpr __expr_;
size_t __size_; size_t __size_;
size_t __m_; size_t __m_;
▲ Show 20 Lines • Show All 1,458 Lines • ▼ Show 20 Linesmask_array<_Tp>::operator=(const value_type& __x) const
size_t __n = __1d_.size(); size_t __n = __1d_.size();
for (size_t __i = 0; __i < __n; ++__i) for (size_t __i = 0; __i < __n; ++__i)
__vp_[__1d_[__i]] = __x; __vp_[__1d_[__i]] = __x;
} }
template <class _ValExpr> template <class _ValExpr>
class __mask_expr class __mask_expr
{ {
typedef typename remove_reference<_ValExpr>::type _RmExpr; typedef __libcpp_remove_reference_t<_ValExpr> _RmExpr;
public: public:
typedef typename _RmExpr::value_type value_type; typedef typename _RmExpr::value_type value_type;
typedef value_type __result_type; typedef value_type __result_type;
private: private:
_ValExpr __expr_; _ValExpr __expr_;
valarray<size_t> __1d_; valarray<size_t> __1d_;
▲ Show 20 Lines • Show All 346 Lines • ▼ Show 20 Linesindirect_array<_Tp>::operator=(const value_type& __x) const
typedef const size_t* _Ip; typedef const size_t* _Ip;
for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i) for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i)
__vp_[*__i] = __x; __vp_[*__i] = __x;
} }
template <class _ValExpr> template <class _ValExpr>
class __indirect_expr class __indirect_expr
{ {
typedef typename remove_reference<_ValExpr>::type _RmExpr; typedef __libcpp_remove_reference_t<_ValExpr> _RmExpr;
public: public:
typedef typename _RmExpr::value_type value_type; typedef typename _RmExpr::value_type value_type;
typedef value_type __result_type; typedef value_type __result_type;
private: private:
_ValExpr __expr_; _ValExpr __expr_;
valarray<size_t> __1d_; valarray<size_t> __1d_;
Show All 23 Linespublic:
template <class> friend class __val_expr; template <class> friend class __val_expr;
template <class> friend class _LIBCPP_TEMPLATE_VIS valarray; template <class> friend class _LIBCPP_TEMPLATE_VIS valarray;
}; };
template<class _ValExpr> template<class _ValExpr>
class __val_expr class __val_expr
{ {
typedef typename remove_reference<_ValExpr>::type _RmExpr; typedef __libcpp_remove_reference_t<_ValExpr> _RmExpr;
_ValExpr __expr_; _ValExpr __expr_;
public: public:
typedef typename _RmExpr::value_type value_type; typedef typename _RmExpr::value_type value_type;
typedef typename _RmExpr::__result_type __result_type; typedef typename _RmExpr::__result_type __result_type;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
explicit __val_expr(const _RmExpr& __e) : __expr_(__e) {} explicit __val_expr(const _RmExpr& __e) : __expr_(__e) {}
▲ Show 20 Lines • Show All 2,274 Lines • Show Last 20 Lines

libcxx/include/variant

Show First 20 Lines • Show All 538 Lines • ▼ Show 20 Lines static constexpr void __std_visit_visitor_return_type_check() {
static_assert( static_assert(
__all<is_same_v<_Fp, _Fs>...>::value, __all<is_same_v<_Fp, _Fs>...>::value,
"`std::visit` requires the visitor to have a single return type."); "`std::visit` requires the visitor to have a single return type.");
} }
template <class... _Fs> template <class... _Fs>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
static constexpr auto __make_farray(_Fs&&... __fs) { static constexpr auto __make_farray(_Fs&&... __fs) {
__std_visit_visitor_return_type_check<__uncvref_t<_Fs>...>(); __std_visit_visitor_return_type_check<__remove_cvref_t<_Fs>...>();
using __result = __farray<common_type_t<__uncvref_t<_Fs>...>, sizeof...(_Fs)>; using __result = __farray<common_type_t<__remove_cvref_t<_Fs>...>, sizeof...(_Fs)>;
return __result{{_VSTD::forward<_Fs>(__fs)...}}; return __result{{_VSTD::forward<_Fs>(__fs)...}};
} }
template <size_t... _Is> template <size_t... _Is>
struct __dispatcher { struct __dispatcher {
template <class _Fp, class... _Vs> template <class _Fp, class... _Vs>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
static constexpr decltype(auto) __dispatch(_Fp __f, _Vs... __vs) { static constexpr decltype(auto) __dispatch(_Fp __f, _Vs... __vs) {
Show All 20 Linesprivate:
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
static constexpr auto __make_fdiagonal_impl(index_sequence<_Is...>) { static constexpr auto __make_fdiagonal_impl(index_sequence<_Is...>) {
return __base::__make_farray(__make_fdiagonal_impl<_Is, _Fp, _Vs...>()...); return __base::__make_farray(__make_fdiagonal_impl<_Is, _Fp, _Vs...>()...);
} }
template <class _Fp, class _Vp, class... _Vs> template <class _Fp, class _Vp, class... _Vs>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
static constexpr auto __make_fdiagonal() { static constexpr auto __make_fdiagonal() {
constexpr size_t _Np = __uncvref_t<_Vp>::__size(); constexpr size_t _Np = __remove_cvref_t<_Vp>::__size();
static_assert(__all<(_Np == __uncvref_t<_Vs>::__size())...>::value); static_assert(__all<(_Np == __remove_cvref_t<_Vs>::__size())...>::value);
return __make_fdiagonal_impl<_Fp, _Vp, _Vs...>(make_index_sequence<_Np>{}); return __make_fdiagonal_impl<_Fp, _Vp, _Vs...>(make_index_sequence<_Np>{});
} }
template <class _Fp, class... _Vs, size_t... _Is> template <class _Fp, class... _Vs, size_t... _Is>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
static constexpr auto __make_fmatrix_impl(index_sequence<_Is...> __is) { static constexpr auto __make_fmatrix_impl(index_sequence<_Is...> __is) {
return __make_dispatch<_Fp, _Vs...>(__is); return __make_dispatch<_Fp, _Vs...>(__is);
} }
template <class _Fp, class... _Vs, size_t... _Is, size_t... _Js, class... _Ls> template <class _Fp, class... _Vs, size_t... _Is, size_t... _Js, class... _Ls>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
static constexpr auto __make_fmatrix_impl(index_sequence<_Is...>, static constexpr auto __make_fmatrix_impl(index_sequence<_Is...>,
index_sequence<_Js...>, index_sequence<_Js...>,
_Ls... __ls) { _Ls... __ls) {
return __base::__make_farray(__make_fmatrix_impl<_Fp, _Vs...>( return __base::__make_farray(__make_fmatrix_impl<_Fp, _Vs...>(
index_sequence<_Is..., _Js>{}, __ls...)...); index_sequence<_Is..., _Js>{}, __ls...)...);
} }
template <class _Fp, class... _Vs> template <class _Fp, class... _Vs>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
static constexpr auto __make_fmatrix() { static constexpr auto __make_fmatrix() {
return __make_fmatrix_impl<_Fp, _Vs...>( return __make_fmatrix_impl<_Fp, _Vs...>(
index_sequence<>{}, make_index_sequence<__uncvref_t<_Vs>::__size()>{}...); index_sequence<>{}, make_index_sequence<__remove_cvref_t<_Vs>::__size()>{}...);
} }
}; };
struct __variant { struct __variant {
template <class _Visitor, class... _Vs> template <class _Visitor, class... _Vs>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
static constexpr decltype(auto) static constexpr decltype(auto)
__visit_alt_at(size_t __index, _Visitor&& __visitor, _Vs&&... __vs) { __visit_alt_at(size_t __index, _Visitor&& __visitor, _Vs&&... __vs) {
▲ Show 20 Lines • Show All 244 Lines • ▼ Show 20 Lines
_LIBCPP_VARIANT_DESTRUCTOR( _LIBCPP_VARIANT_DESTRUCTOR(
_Trait::_Available, _Trait::_Available,
~__dtor() { __destroy(); }, ~__dtor() { __destroy(); },
void __destroy() noexcept { void __destroy() noexcept {
if (!this->valueless_by_exception()) { if (!this->valueless_by_exception()) {
__visitation::__base::__visit_alt( __visitation::__base::__visit_alt(
[](auto& __alt) noexcept { [](auto& __alt) noexcept {
using __alt_type = __uncvref_t<decltype(__alt)>; using __alt_type = __remove_cvref_t<decltype(__alt)>;
__alt.~__alt_type(); __alt.~__alt_type();
}, },
*this); *this);
} }
this->__index = __variant_npos<__index_t>; this->__index = __variant_npos<__index_t>;
}); });
_LIBCPP_VARIANT_DESTRUCTOR( _LIBCPP_VARIANT_DESTRUCTOR(
▲ Show 20 Lines • Show All 355 Lines • ▼ Show 20 Lines
template <class _Tp, size_t _Idx> template <class _Tp, size_t _Idx>
struct __overload { struct __overload {
template <class _Up> template <class _Up>
auto operator()(_Tp, _Up&&) const -> __check_for_narrowing<_Tp, _Up>; auto operator()(_Tp, _Up&&) const -> __check_for_narrowing<_Tp, _Up>;
}; };
template <class _Tp, size_t> template <class _Tp, size_t>
struct __overload_bool { struct __overload_bool {
template <class _Up, class _Ap = __uncvref_t<_Up>> template <class _Up, class _Ap = __remove_cvref_t<_Up>>
auto operator()(bool, _Up&&) const auto operator()(bool, _Up&&) const
-> enable_if_t<is_same_v<_Ap, bool>, __type_identity<_Tp>>; -> enable_if_t<is_same_v<_Ap, bool>, __type_identity<_Tp>>;
}; };
template <size_t _Idx> template <size_t _Idx>
struct __overload<bool, _Idx> : __overload_bool<bool, _Idx> {}; struct __overload<bool, _Idx> : __overload_bool<bool, _Idx> {};
template <size_t _Idx> template <size_t _Idx>
struct __overload<bool const, _Idx> : __overload_bool<bool const, _Idx> {}; struct __overload<bool const, _Idx> : __overload_bool<bool const, _Idx> {};
▲ Show 20 Lines • Show All 60 Lines • ▼ Show 20 Linespublic:
constexpr variant() noexcept(is_nothrow_default_constructible_v<__first_type>) constexpr variant() noexcept(is_nothrow_default_constructible_v<__first_type>)
: __impl(in_place_index<0>) {} : __impl(in_place_index<0>) {}
variant(const variant&) = default; variant(const variant&) = default;
variant(variant&&) = default; variant(variant&&) = default;
template < template <
class _Arg, class _Arg,
enable_if_t<!is_same_v<__uncvref_t<_Arg>, variant>, int> = 0, enable_if_t<!is_same_v<__remove_cvref_t<_Arg>, variant>, int> = 0,
enable_if_t<!__is_inplace_type<__uncvref_t<_Arg>>::value, int> = 0, enable_if_t<!__is_inplace_type<__remove_cvref_t<_Arg>>::value, int> = 0,
enable_if_t<!__is_inplace_index<__uncvref_t<_Arg>>::value, int> = 0, enable_if_t<!__is_inplace_index<__remove_cvref_t<_Arg>>::value, int> = 0,
class _Tp = __variant_detail::__best_match_t<_Arg, _Types...>, class _Tp = __variant_detail::__best_match_t<_Arg, _Types...>,
size_t _Ip = size_t _Ip =
__find_detail::__find_unambiguous_index_sfinae<_Tp, _Types...>::value, __find_detail::__find_unambiguous_index_sfinae<_Tp, _Types...>::value,
enable_if_t<is_constructible_v<_Tp, _Arg>, int> = 0> enable_if_t<is_constructible_v<_Tp, _Arg>, int> = 0>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
constexpr variant(_Arg&& __arg) noexcept( constexpr variant(_Arg&& __arg) noexcept(
is_nothrow_constructible_v<_Tp, _Arg>) is_nothrow_constructible_v<_Tp, _Arg>)
: __impl(in_place_index<_Ip>, _VSTD::forward<_Arg>(__arg)) {} : __impl(in_place_index<_Ip>, _VSTD::forward<_Arg>(__arg)) {}
▲ Show 20 Lines • Show All 53 Lines • ▼ Show 20 Linespublic:
~variant() = default; ~variant() = default;
variant& operator=(const variant&) = default; variant& operator=(const variant&) = default;
variant& operator=(variant&&) = default; variant& operator=(variant&&) = default;
template < template <
class _Arg, class _Arg,
enable_if_t<!is_same_v<__uncvref_t<_Arg>, variant>, int> = 0, enable_if_t<!is_same_v<__remove_cvref_t<_Arg>, variant>, int> = 0,
class _Tp = __variant_detail::__best_match_t<_Arg, _Types...>, class _Tp = __variant_detail::__best_match_t<_Arg, _Types...>,
size_t _Ip = size_t _Ip =
__find_detail::__find_unambiguous_index_sfinae<_Tp, _Types...>::value, __find_detail::__find_unambiguous_index_sfinae<_Tp, _Types...>::value,
enable_if_t<is_assignable_v<_Tp&, _Arg> && is_constructible_v<_Tp, _Arg>, enable_if_t<is_assignable_v<_Tp&, _Arg> && is_constructible_v<_Tp, _Arg>,
int> = 0> int> = 0>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
variant& operator=(_Arg&& __arg) noexcept( variant& operator=(_Arg&& __arg) noexcept(
is_nothrow_assignable_v<_Tp&, _Arg> && is_nothrow_assignable_v<_Tp&, _Arg> &&
▲ Show 20 Lines • Show All 375 Lines • ▼ Show 20 Linesstruct _LIBCPP_TEMPLATE_VIS hash<
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
result_type operator()(const argument_type& __v) const { result_type operator()(const argument_type& __v) const {
using __variant_detail::__visitation::__variant; using __variant_detail::__visitation::__variant;
size_t __res = size_t __res =
__v.valueless_by_exception() __v.valueless_by_exception()
? 299792458 // Random value chosen by the universe upon creation ? 299792458 // Random value chosen by the universe upon creation
: __variant::__visit_alt( : __variant::__visit_alt(
[](const auto& __alt) { [](const auto& __alt) {
using __alt_type = __uncvref_t<decltype(__alt)>; using __alt_type = __remove_cvref_t<decltype(__alt)>;
using __value_type = remove_const_t< using __value_type = remove_const_t<
typename __alt_type::__value_type>; typename __alt_type::__value_type>;
return hash<__value_type>{}(__alt.__value); return hash<__value_type>{}(__alt.__value);
}, },
__v); __v);
return __hash_combine(__res, hash<size_t>{}(__v.index())); return __hash_combine(__res, hash<size_t>{}(__v.index()));
} }
}; };
Show All 30 Lines

libcxx/src/string.cpp

Show First 20 Lines • Show All 79 Lines • ▼ Show 20 Lines
} }
// as_integer // as_integer
template<typename V, typename S, typename F> template<typename V, typename S, typename F>
inline V as_integer_helper(const string& func, const S& str, size_t* idx, int base, F f) { inline V as_integer_helper(const string& func, const S& str, size_t* idx, int base, F f) {
typename S::value_type* ptr = nullptr; typename S::value_type* ptr = nullptr;
const typename S::value_type* const p = str.c_str(); const typename S::value_type* const p = str.c_str();
typename remove_reference<decltype(errno)>::type errno_save = errno; __libcpp_remove_reference_t<decltype(errno)> errno_save = errno;
errno = 0; errno = 0;
V r = f(p, &ptr, base); V r = f(p, &ptr, base);
swap(errno, errno_save); swap(errno, errno_save);
if (errno_save == ERANGE) if (errno_save == ERANGE)
throw_from_string_out_of_range(func); throw_from_string_out_of_range(func);
if (ptr == p) if (ptr == p)
throw_from_string_invalid_arg(func); throw_from_string_invalid_arg(func);
if (idx) if (idx)
▲ Show 20 Lines • Show All 70 Lines • ▼ Show 20 Lines
#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS #endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
// as_float // as_float
template<typename V, typename S, typename F> template<typename V, typename S, typename F>
inline V as_float_helper(const string& func, const S& str, size_t* idx, F f) { inline V as_float_helper(const string& func, const S& str, size_t* idx, F f) {
typename S::value_type* ptr = nullptr; typename S::value_type* ptr = nullptr;
const typename S::value_type* const p = str.c_str(); const typename S::value_type* const p = str.c_str();
typename remove_reference<decltype(errno)>::type errno_save = errno; __libcpp_remove_reference_t<decltype(errno)> errno_save = errno;
errno = 0; errno = 0;
V r = f(p, &ptr); V r = f(p, &ptr);
swap(errno, errno_save); swap(errno, errno_save);
if (errno_save == ERANGE) if (errno_save == ERANGE)
throw_from_string_out_of_range(func); throw_from_string_out_of_range(func);
if (ptr == p) if (ptr == p)
throw_from_string_invalid_arg(func); throw_from_string_invalid_arg(func);
if (idx) if (idx)
▲ Show 20 Lines • Show All 209 Lines • Show Last 20 Lines

libcxx/test/std/utilities/meta/meta.unary/dependent_return_type.compile.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// Check that all the type_trait aliases can be mangled
// UNSUPPORTED: c++03, c++11
// ignore deprecated volatile return types
// ADDITIONAL_COMPILE_FLAGS: -Wno-deprecated-volatile
#include <type_traits>
#include <utility>
#include "test_macros.h"
template <class T>
std::add_const_t<T> add_const() {
return {};
}
template <class T>
std::add_cv_t<T> add_cv() {
return {};
}
template <class T>
std::add_lvalue_reference_t<T> add_lvalue_reference() {
static int i;
return i;
}
template <class T>
std::add_pointer_t<T> add_pointer() {
return {};
}
template <class T>
std::add_rvalue_reference_t<T> add_rvalue_reference() {
static int i;
return std::move(i);
}
template <class T>
std::add_volatile_t<T> add_volatile() {
static int i;
return std::move(i);
}
template <class T>
std::conditional_t<true, T, T> conditional() {
return {};
}
template <class T>
std::decay_t<T> decay() {
return {};
}
template <class T>
std::enable_if_t<true, T> enable_if() {
return {};
}
template <class T>
std::make_signed_t<T> make_signed() {
return {};
}
template <class T>
std::make_unsigned_t<T> make_unsigned() {
return {};
}
template <class T>
std::remove_all_extents_t<T> remove_all_extents() {
return {};
}
template <class T>
std::remove_const_t<T> remove_const() {
return {};
}
template <class T>
std::remove_cv_t<T> remove_cv() {
return {};
}
#if TEST_STD_VER >= 20
template <class T>
std::remove_cvref_t<T> remove_cvref() {
return {};
}
#endif
template <class T>
std::remove_extent_t<T> remove_extent() {
return {};
}
template <class T>
std::remove_pointer_t<T> remove_pointer() {
return {};
}
template <class T>
std::remove_reference_t<T> remove_reference() {
return {};
}
template <class T>
std::remove_volatile_t<T> remove_volatile() {
return {};
}
#if TEST_STD_VER >= 20
template <class T>
std::type_identity_t<T> type_identity() {
return {};
}
#endif
template <class T>
std::underlying_type_t<T> underlying_type() {
return {};
}
enum class E : int {};
#if TEST_STD_VER >= 17
template <class T>
std::void_t<T> void_t() {}
#endif
void instantiate() {
add_const<int>();
add_cv<int>();
add_lvalue_reference<int>();
add_pointer<int>();
add_rvalue_reference<int>();
add_volatile<int>();
decay<int>();
enable_if<int>();
make_signed<int>();
make_unsigned<int>();
remove_all_extents<int>();
remove_const<int>();
remove_cv<int>();
#if TEST_STD_VER >= 20
remove_cvref<int>();
#endif
remove_extent<int>();
remove_pointer<int>();
remove_reference<int>();
remove_volatile<int>();
#if TEST_STD_VER >= 20
type_identity<int>();
#endif
underlying_type<E>();
#if TEST_STD_VER >= 17
void_t<int>();
#endif
}