This is an archive of the discontinued LLVM Phabricator instance.

Differential D131498

[libc++][NFC] Rename the constexpr macros
ClosedPublic

Authored by philnik on Aug 9 2022, 7:59 AM.

Details

Reviewers
ldionne
Mordante
var-const
huixie90
fsb4000
avogelsgesang
jloser
Group Reviewers
Restricted Project
Commits
rG5146b57b403b: [libc++][NFC] Rename the constexpr macros
Summary

This was discussed on Discord with the consensus that we should rename the macros.

Diff Detail

Event Timeline

philnik created this revision.Aug 9 2022, 7:59 AM
Herald added a project: Restricted Project. · View Herald TranscriptAug 9 2022, 7:59 AM
philnik requested review of this revision.Aug 9 2022, 7:59 AM
Herald added a project: Restricted Project. · View Herald TranscriptAug 9 2022, 7:59 AM
Herald added a reviewer: Restricted Project. · View Herald Transcript
Herald added a subscriber: libcxx-commits. · View Herald Transcript
Harbormaster completed remote builds in B180173: Diff 451153.Aug 9 2022, 10:11 PM
avogelsgesang accepted this revision.Aug 10 2022, 1:17 AM

LGTM, thanks!

I didn't actually look through all the files, I only looked at a random sample. I trust that you made the changes using sed or some other automation, and that the test cases would catch any functional regressions

libcxx/.clang-format
18

not sure what the outcome of the Discord discussion was (somehow I can't find the channel anymore?), but personally I would prefer to also change _LIBCPP_CONSTEXPR_AFTER_CXX20 to _LIBCPP_CONSTEXPR_CXX23

Please don't let this stop you from merging your change though. It is a clear improvement compared to the previous state

philnik added inline comments.Aug 10 2022, 5:17 AM
libcxx/.clang-format
18

Oops. We don't actually have a _LIBCPP_CONSTEXPR_AFTER_CXX20 yet. Looks like I accidentally added it to the clang-format. I'll rename it when I commit the patch (assuming nobody requests further changes).

Mordante accepted this revision as: Mordante.Aug 10 2022, 8:21 AM

Thanks for working on this, it's great to have everything consistent in one go!
I have spot checked the changes, but I assume you used a tool to do the changes automatically.
LGTM, but I think it's good to get a few more explicit approvals so leave the final approval to somebody else.

libcxx/.clang-format
18

Mainly curious can this be a regex?

libcxx/test/libcxx/nasty_macros.compile.pass.cpp
146

Thanks!

philnik marked 2 inline comments as done.Aug 10 2022, 8:39 AM
philnik added inline comments.
libcxx/.clang-format
18

The clang-format docs say that AttributeMacros is a List of Strings. So I don't think so. I've made a feature request here

huixie90 added inline comments.Aug 11 2022, 3:38 PM
libcxx/include/__config
835

I am ok with the name in your patch. But have you considered
_LIBCPP_CONSTEXPR_SINCE_CXX14
The reason why I like this name is because in the synopsis it is exact these words "// constexpr since C++14"

jloser added inline comments.Aug 12 2022, 6:04 AM
libcxx/include/__config
835

I quite like the naming convention of using "since", e.g. _LIBCPP_CONSTEXPR_SINCE_CXX14 as you proposed, @huixie90. I'm also not opposed to @philnik current proposed rename as I do like it better than the status quo on top of tree.

philnik marked an inline comment as done.Aug 12 2022, 6:14 AM
philnik added inline comments.
libcxx/include/__config
835

I have considered the name, but I think that _LIBCPP_CONSTEXPR_SINCE_CXXab is unnecessarily verbose. We already use TEST_CONSTEXPR_CXXab in the tests and AFAIK nobody ever complained about it. @ldionne also proposed _LIBCPP_CONSTEXPR_IN_CXXab, but there the same applies.

jloser accepted this revision.Aug 12 2022, 6:18 AM
Mordante added inline comments.Aug 13 2022, 5:10 AM
libcxx/include/__config
835

+1 for using the same naming style in our main code and our tests.

Mordante mentioned this in D131857: [libc++][string] Removes obsolete constexpr..Aug 14 2022, 5:18 AM
ldionne accepted this revision.Aug 18 2022, 10:16 AM

LGTM, but I'd like to use SINCE, and I think the side discussion of what to do with internal helpers is worth figuring out without necessarily taking any action in this patch.

libcxx/include/__config
835

My preference is also _LIBCPP_CONSTEXPR_SINCE_CXX14. If we want full consistency, I would actually rename the test macros to TEST_CONSTEXPR_SINCE_CXX14. I think that SINCE expresses the intent of the macro much better, i.e. "this API is constexpr since C++xy". Without SINCE, one could imagine that this instead represents e.g. the constexpr capabilities of the compiler, which is not the case (we assume those capabilities, instead). So yeah, big +1 for using SINCE.

In fact, I think we really have two macros here. Once of them is _LIBCPP_CONSTEXPR_SINCE_CXXYZ, aimed towards our API, and the other one is _LIBCPP_CXXYZ_CONSTEXPR_SUPPORTED, aimed for implementation detail functions that essentially want to be constexpr as early as the language supports it. I am not sure it makes sense to introduce that macro, though, but it illustrates why I like the SINCE variant better.

libcxx/include/__memory/compressed_pair.h
44

I think this should work? In fact we could just use constexpr, maybe.

libcxx/include/__memory/uninitialized_algorithms.h
625

For example, is there a reason why this is only constexpr in C++20? Maybe it should be marked as constexpr whenever we have support for C++14 generalized constexpr?

libcxx/test/libcxx/nasty_macros.compile.pass.cpp
146

I don't think this is necessary. I understand the goal of catching non-rebased patches, however such patches are going to fail with unknown identifier _LIBCPP_CONSTEXPR_AFTER_CXX14 anyway if someone forgets to use the new macro names. So I don't think this is going to catch anything that we wouldn't otherwise catch.

This revision is now accepted and ready to land.Aug 18 2022, 10:16 AM
var-const accepted this revision.Aug 18 2022, 2:38 PM
var-const added inline comments.
libcxx/include/__memory/uninitialized_algorithms.h
625

General question -- for internal functions, should we make them constexpr in the lowest language mode possible, or just in the language mode where they are actually used? I'm slightly concerned about overconstraining the implementation, though we can probably always work around that if necessary.

philnik updated this revision to Diff 453948.Aug 19 2022, 4:11 AM
philnik marked 5 inline comments as done.
  • Use _SINCE_ style

I'll land this as soon as possible, since it will conflict with a lot of patches

libcxx/include/__memory/uninitialized_algorithms.h
625

We normally use what works, i.e. the lowest language mode feasible. Don't try to make some function constexpr in C++11 just because it's technically possible. But you might as well do it when the function would work in C++11 constexpr.

Harbormaster completed remote builds in B182190: Diff 453948.Aug 19 2022, 5:43 AM
Closed by commit rG5146b57b403b: [libc++][NFC] Rename the constexpr macros (authored by philnik). · Explain WhyAug 19 2022, 6:35 AM
This revision was automatically updated to reflect the committed changes.
philnik added a commit: rG5146b57b403b: [libc++][NFC] Rename the constexpr macros.

Revision Contents

PathSize
libcxx/
6 lines
include/
__algorithm/
6 lines
2 lines
2 lines
4 lines
28 lines
10 lines
12 lines
4 lines
2 lines
4 lines
2 lines
2 lines
12 lines
6 lines
6 lines
4 lines
2 lines
12 lines
6 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
6 lines
4 lines
6 lines
2 lines
18 lines
4 lines
6 lines
2 lines
20 lines
6 lines
6 lines
6 lines
8 lines
6 lines
6 lines
8 lines
8 lines
8 lines
8 lines
8 lines
12 lines
10 lines
6 lines
2 lines
10 lines
8 lines
6 lines
8 lines
2 lines
2 lines
6 lines
6 lines
8 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
8 lines
2 lines
20 lines
2 lines
14 lines
12 lines
6 lines
8 lines
8 lines
8 lines
4 lines
16 lines
6 lines
6 lines
4 lines
6 lines
10 lines
2 lines
6 lines
142 lines
__charconv/
6 lines
__chrono/
24 lines
2 lines
2 lines
2 lines
34 lines
12 lines
10 lines
__debug_utils/
2 lines
__functional/
6 lines
16 lines
4 lines
2 lines
6 lines
4 lines
76 lines
16 lines
6 lines
2 lines
__iterator/
16 lines
8 lines
16 lines
28 lines
6 lines
14 lines
14 lines
50 lines
2 lines
2 lines
20 lines
58 lines
44 lines
__memory/
2 lines
20 lines
24 lines
18 lines
16 lines
4 lines
6 lines
14 lines
2 lines
__numeric/
4 lines
4 lines
4 lines
6 lines
4 lines
2 lines
4 lines
6 lines
2 lines
4 lines
6 lines
158 lines
__string/
134 lines
24 lines
__utility/
2 lines
2 lines
74 lines
4 lines
8 lines
118 lines
2 lines
4 lines
28 lines
experimental/
6 lines
14 lines
8 lines
52 lines
804 lines
112 lines
2 lines
192 lines
4 lines
630 lines
src/
experimental/
2 lines
filesystem/
20 lines
test/
libcxx/
5 lines

Diff 451153

libcxx/.clang-format

BasedOnStyle: LLVM BasedOnStyle: LLVM
AlignAfterOpenBracket: Align AlignAfterOpenBracket: Align
AlignConsecutiveAssignments: Consecutive AlignConsecutiveAssignments: Consecutive
AlignConsecutiveBitFields: Consecutive AlignConsecutiveBitFields: Consecutive
AlignEscapedNewlines: Right AlignEscapedNewlines: Right
AlignOperands: AlignAfterOperator AlignOperands: AlignAfterOperator
AlignTrailingComments: true AlignTrailingComments: true
AllowAllArgumentsOnNextLine: true AllowAllArgumentsOnNextLine: true
AllowAllParametersOfDeclarationOnNextLine: true AllowAllParametersOfDeclarationOnNextLine: true
AllowShortFunctionsOnASingleLine: true AllowShortFunctionsOnASingleLine: true
AllowShortLambdasOnASingleLine: All AllowShortLambdasOnASingleLine: All
AttributeMacros: ['_LIBCPP_HIDE_FROM_ABI', AttributeMacros: ['_LIBCPP_HIDE_FROM_ABI',
'_LIBCPP_CONSTEXPR', '_LIBCPP_CONSTEXPR',
'_LIBCPP_CONSTEXPR_AFTER_CXX11', '_LIBCPP_CONSTEXPR_CXX14',
'_LIBCPP_CONSTEXPR_AFTER_CXX14', '_LIBCPP_CONSTEXPR_CXX17',
'_LIBCPP_CONSTEXPR_AFTER_CXX17', '_LIBCPP_CONSTEXPR_CXX20',
'_LIBCPP_CONSTEXPR_AFTER_CXX20', '_LIBCPP_CONSTEXPR_AFTER_CXX20',
avogelsgesangUnsubmitted
Done
ReplyInline Actions

not sure what the outcome of the Discord discussion was (somehow I can't find the channel anymore?), but personally I would prefer to also change _LIBCPP_CONSTEXPR_AFTER_CXX20 to _LIBCPP_CONSTEXPR_CXX23

Please don't let this stop you from merging your change though. It is a clear improvement compared to the previous state

avogelsgesang: not sure what the outcome of the Discord discussion was (somehow I can't find the channel…
philnikAuthorUnsubmitted
Done
ReplyInline Actions

Oops. We don't actually have a _LIBCPP_CONSTEXPR_AFTER_CXX20 yet. Looks like I accidentally added it to the clang-format. I'll rename it when I commit the patch (assuming nobody requests further changes).

philnik: Oops. We don't actually have a `_LIBCPP_CONSTEXPR_AFTER_CXX20` yet. Looks like I accidentally…
MordanteUnsubmitted
Done
ReplyInline Actions

Mainly curious can this be a regex?

Mordante: Mainly curious can this be a regex?
philnikAuthorUnsubmitted
Done
ReplyInline Actions

The clang-format docs say that AttributeMacros is a List of Strings. So I don't think so. I've made a feature request here

philnik: The clang-format docs say that `AttributeMacros` is a `List of Strings`. So I don't think so.
'_LIBCPP_ALIGNOF', '_LIBCPP_ALIGNOF',
'_ALIGNAS_TYPE', '_ALIGNAS_TYPE',
'_ALIGNAS', '_ALIGNAS',
'_LIBCPP_NORETURN', '_LIBCPP_NORETURN',
'_LIBCPP_ALWAYS_INLINE', '_LIBCPP_ALWAYS_INLINE',
'_LIBCPP_DISABLE_EXTENTSION_WARNING', '_LIBCPP_DISABLE_EXTENTSION_WARNING',
'_LIBCPP_HIDDEN', '_LIBCPP_HIDDEN',
'_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS', '_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS',
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

libcxx/include/__algorithm/adjacent_find.h

Show All 17 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 _Iter, class _Sent, class _BinaryPredicate> template <class _Iter, class _Sent, class _BinaryPredicate>
_LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _Iter _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20 _Iter
__adjacent_find(_Iter __first, _Sent __last, _BinaryPredicate&& __pred) { __adjacent_find(_Iter __first, _Sent __last, _BinaryPredicate&& __pred) {
if (__first == __last) if (__first == __last)
return __first; return __first;
_Iter __i = __first; _Iter __i = __first;
while (++__i != __last) { while (++__i != __last) {
if (__pred(*__first, *__i)) if (__pred(*__first, *__i))
return __first; return __first;
__first = __i; __first = __i;
} }
return __i; return __i;
} }
template <class _ForwardIterator, class _BinaryPredicate> template <class _ForwardIterator, class _BinaryPredicate>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _ForwardIterator _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20 _ForwardIterator
adjacent_find(_ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred) { adjacent_find(_ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred) {
return std::__adjacent_find(std::move(__first), std::move(__last), __pred); return std::__adjacent_find(std::move(__first), std::move(__last), __pred);
} }
template <class _ForwardIterator> template <class _ForwardIterator>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _ForwardIterator _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20 _ForwardIterator
adjacent_find(_ForwardIterator __first, _ForwardIterator __last) { adjacent_find(_ForwardIterator __first, _ForwardIterator __last) {
typedef typename iterator_traits<_ForwardIterator>::value_type __v; typedef typename iterator_traits<_ForwardIterator>::value_type __v;
return std::adjacent_find(std::move(__first), std::move(__last), __equal_to<__v>()); return std::adjacent_find(std::move(__first), std::move(__last), __equal_to<__v>());
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_ADJACENT_FIND_H #endif // _LIBCPP___ALGORITHM_ADJACENT_FIND_H

libcxx/include/__algorithm/all_of.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 _InputIterator, class _Predicate> template <class _InputIterator, class _Predicate>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 bool _LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 bool
all_of(_InputIterator __first, _InputIterator __last, _Predicate __pred) { all_of(_InputIterator __first, _InputIterator __last, _Predicate __pred) {
for (; __first != __last; ++__first) for (; __first != __last; ++__first)
if (!__pred(*__first)) if (!__pred(*__first))
return false; return false;
return true; return true;
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_ALL_OF_H #endif // _LIBCPP___ALGORITHM_ALL_OF_H

libcxx/include/__algorithm/any_of.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 _InputIterator, class _Predicate> template <class _InputIterator, class _Predicate>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 bool _LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 bool
any_of(_InputIterator __first, _InputIterator __last, _Predicate __pred) { any_of(_InputIterator __first, _InputIterator __last, _Predicate __pred) {
for (; __first != __last; ++__first) for (; __first != __last; ++__first)
if (__pred(*__first)) if (__pred(*__first))
return true; return true;
return false; return false;
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_ANY_OF_H #endif // _LIBCPP___ALGORITHM_ANY_OF_H

libcxx/include/__algorithm/binary_search.h

Show All 17 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 _ForwardIterator, class _Tp, class _Compare> template <class _ForwardIterator, class _Tp, class _Compare>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_NODISCARD_EXT inline
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
bool bool
binary_search(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value, _Compare __comp) binary_search(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value, _Compare __comp)
{ {
using _Comp_ref = typename __comp_ref_type<_Compare>::type; using _Comp_ref = typename __comp_ref_type<_Compare>::type;
__first = std::lower_bound<_ForwardIterator, _Tp, _Comp_ref>(__first, __last, __value, __comp); __first = std::lower_bound<_ForwardIterator, _Tp, _Comp_ref>(__first, __last, __value, __comp);
return __first != __last && !__comp(__value, *__first); return __first != __last && !__comp(__value, *__first);
} }
template <class _ForwardIterator, class _Tp> template <class _ForwardIterator, class _Tp>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_NODISCARD_EXT inline
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
bool bool
binary_search(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) binary_search(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value)
{ {
return std::binary_search(__first, __last, __value, return std::binary_search(__first, __last, __value,
__less<typename iterator_traits<_ForwardIterator>::value_type, _Tp>()); __less<typename iterator_traits<_ForwardIterator>::value_type, _Tp>());
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_BINARY_SEARCH_H #endif // _LIBCPP___ALGORITHM_BINARY_SEARCH_H

libcxx/include/__algorithm/comp.h

Show All 17 Lines
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
// I'd like to replace these with _VSTD::equal_to<void>, but can't because: // I'd like to replace these with _VSTD::equal_to<void>, but can't because:
// * That only works with C++14 and later, and // * That only works with C++14 and later, and
// * We haven't included <functional> here. // * We haven't included <functional> here.
template <class _T1, class _T2 = _T1> template <class _T1, class _T2 = _T1>
struct __equal_to struct __equal_to
{ {
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 bool operator()(const _T1& __x, const _T1& __y) const {return __x == __y;} _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 bool operator()(const _T1& __x, const _T1& __y) const {return __x == __y;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 bool operator()(const _T1& __x, const _T2& __y) const {return __x == __y;} _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 bool operator()(const _T1& __x, const _T2& __y) const {return __x == __y;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 bool operator()(const _T2& __x, const _T1& __y) const {return __x == __y;} _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 bool operator()(const _T2& __x, const _T1& __y) const {return __x == __y;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 bool operator()(const _T2& __x, const _T2& __y) const {return __x == __y;} _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 bool operator()(const _T2& __x, const _T2& __y) const {return __x == __y;}
}; };
template <class _T1> template <class _T1>
struct __equal_to<_T1, _T1> struct __equal_to<_T1, _T1>
{ {
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
bool operator()(const _T1& __x, const _T1& __y) const {return __x == __y;} bool operator()(const _T1& __x, const _T1& __y) const {return __x == __y;}
}; };
template <class _T1> template <class _T1>
struct __equal_to<const _T1, _T1> struct __equal_to<const _T1, _T1>
{ {
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
bool operator()(const _T1& __x, const _T1& __y) const {return __x == __y;} bool operator()(const _T1& __x, const _T1& __y) const {return __x == __y;}
}; };
template <class _T1> template <class _T1>
struct __equal_to<_T1, const _T1> struct __equal_to<_T1, const _T1>
{ {
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
bool operator()(const _T1& __x, const _T1& __y) const {return __x == __y;} bool operator()(const _T1& __x, const _T1& __y) const {return __x == __y;}
}; };
template <class _T1, class _T2 = _T1> template <class _T1, class _T2 = _T1>
struct __less struct __less
{ {
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
bool operator()(const _T1& __x, const _T1& __y) const {return __x < __y;} bool operator()(const _T1& __x, const _T1& __y) const {return __x < __y;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
bool operator()(const _T1& __x, const _T2& __y) const {return __x < __y;} bool operator()(const _T1& __x, const _T2& __y) const {return __x < __y;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
bool operator()(const _T2& __x, const _T1& __y) const {return __x < __y;} bool operator()(const _T2& __x, const _T1& __y) const {return __x < __y;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
bool operator()(const _T2& __x, const _T2& __y) const {return __x < __y;} bool operator()(const _T2& __x, const _T2& __y) const {return __x < __y;}
}; };
template <class _T1> template <class _T1>
struct __less<_T1, _T1> struct __less<_T1, _T1>
{ {
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
bool operator()(const _T1& __x, const _T1& __y) const {return __x < __y;} bool operator()(const _T1& __x, const _T1& __y) const {return __x < __y;}
}; };
template <class _T1> template <class _T1>
struct __less<const _T1, _T1> struct __less<const _T1, _T1>
{ {
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
bool operator()(const _T1& __x, const _T1& __y) const {return __x < __y;} bool operator()(const _T1& __x, const _T1& __y) const {return __x < __y;}
}; };
template <class _T1> template <class _T1>
struct __less<_T1, const _T1> struct __less<_T1, const _T1>
{ {
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
bool operator()(const _T1& __x, const _T1& __y) const {return __x < __y;} bool operator()(const _T1& __x, const _T1& __y) const {return __x < __y;}
}; };
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_COMP_H #endif // _LIBCPP___ALGORITHM_COMP_H

libcxx/include/__algorithm/comp_ref_type.h

Show All 17 Lines
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Compare> template <class _Compare>
struct __debug_less struct __debug_less
{ {
_Compare &__comp_; _Compare &__comp_;
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_CONSTEXPR_CXX14
__debug_less(_Compare& __c) : __comp_(__c) {} __debug_less(_Compare& __c) : __comp_(__c) {}
template <class _Tp, class _Up> template <class _Tp, class _Up>
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_CONSTEXPR_CXX14
bool operator()(const _Tp& __x, const _Up& __y) bool operator()(const _Tp& __x, const _Up& __y)
{ {
bool __r = __comp_(__x, __y); bool __r = __comp_(__x, __y);
if (__r) if (__r)
__do_compare_assert(0, __y, __x); __do_compare_assert(0, __y, __x);
return __r; return __r;
} }
template <class _Tp, class _Up> template <class _Tp, class _Up>
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_CONSTEXPR_CXX14
bool operator()(_Tp& __x, _Up& __y) bool operator()(_Tp& __x, _Up& __y)
{ {
bool __r = __comp_(__x, __y); bool __r = __comp_(__x, __y);
if (__r) if (__r)
__do_compare_assert(0, __y, __x); __do_compare_assert(0, __y, __x);
return __r; return __r;
} }
template <class _LHS, class _RHS> template <class _LHS, class _RHS>
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_CONSTEXPR_CXX14
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
decltype((void)declval<_Compare&>()( decltype((void)declval<_Compare&>()(
declval<_LHS &>(), declval<_RHS &>())) declval<_LHS &>(), declval<_RHS &>()))
__do_compare_assert(int, _LHS & __l, _RHS & __r) { __do_compare_assert(int, _LHS & __l, _RHS & __r) {
_LIBCPP_DEBUG_ASSERT(!__comp_(__l, __r), _LIBCPP_DEBUG_ASSERT(!__comp_(__l, __r),
"Comparator does not induce a strict weak ordering"); "Comparator does not induce a strict weak ordering");
(void)__l; (void)__l;
(void)__r; (void)__r;
} }
template <class _LHS, class _RHS> template <class _LHS, class _RHS>
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_CONSTEXPR_CXX14
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
void __do_compare_assert(long, _LHS &, _RHS &) {} void __do_compare_assert(long, _LHS &, _RHS &) {}
}; };
template <class _Comp> template <class _Comp>
struct __comp_ref_type { struct __comp_ref_type {
// Pass the comparator by lvalue reference. Or in debug mode, using a // Pass the comparator by lvalue reference. Or in debug mode, using a
// debugging wrapper that stores a reference. // debugging wrapper that stores a reference.
Show All 10 Lines

libcxx/include/__algorithm/copy.h

Show All 22 Lines
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
// copy // copy
template <class _InIter, class _Sent, class _OutIter> template <class _InIter, class _Sent, class _OutIter>
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14
pair<_InIter, _OutIter> __copy_impl(_InIter __first, _Sent __last, _OutIter __result) { pair<_InIter, _OutIter> __copy_impl(_InIter __first, _Sent __last, _OutIter __result) {
while (__first != __last) { while (__first != __last) {
*__result = *__first; *__result = *__first;
++__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<typename remove_const<_InValueT>::type, _OutValueT>::value
&& is_trivially_copy_assignable<_OutValueT>::value> > && is_trivially_copy_assignable<_OutValueT>::value> >
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_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<typename remove_const<__iter_value_type<_InIter> >::type, __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_AFTER_CXX11 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14
pair<_InIter, _OutIter> pair<_InIter, _OutIter>
__copy_impl(_InIter __first, _InIter __last, _OutIter __result) { __copy_impl(_InIter __first, _InIter __last, _OutIter __result) {
auto __first_base = std::__unwrap_iter(__first.base()); auto __first_base = std::__unwrap_iter(__first.base());
auto __last_base = std::__unwrap_iter(__last.base()); auto __last_base = std::__unwrap_iter(__last.base());
auto __result_base = std::__unwrap_iter(__result.base()); auto __result_base = std::__unwrap_iter(__result.base());
auto __result_first = __result_base - (__first_base - __last_base); auto __result_first = __result_base - (__first_base - __last_base);
std::__copy_impl(__last_base, __first_base, __result_first); std::__copy_impl(__last_base, __first_base, __result_first);
return std::make_pair(__last, _OutIter(std::__rewrap_iter(__result.base(), __result_first))); return std::make_pair(__last, _OutIter(std::__rewrap_iter(__result.base(), __result_first)));
} }
template <class _InIter, class _Sent, class _OutIter, template <class _InIter, class _Sent, class _OutIter,
__enable_if_t<!(is_copy_constructible<_InIter>::value __enable_if_t<!(is_copy_constructible<_InIter>::value
&& is_copy_constructible<_Sent>::value && is_copy_constructible<_Sent>::value
&& is_copy_constructible<_OutIter>::value), int> = 0 > && is_copy_constructible<_OutIter>::value), int> = 0 >
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14
pair<_InIter, _OutIter> __copy(_InIter __first, _Sent __last, _OutIter __result) { pair<_InIter, _OutIter> __copy(_InIter __first, _Sent __last, _OutIter __result) {
return std::__copy_impl(std::move(__first), std::move(__last), std::move(__result)); return std::__copy_impl(std::move(__first), std::move(__last), std::move(__result));
} }
template <class _InIter, class _Sent, class _OutIter, template <class _InIter, class _Sent, class _OutIter,
__enable_if_t<is_copy_constructible<_InIter>::value __enable_if_t<is_copy_constructible<_InIter>::value
&& is_copy_constructible<_Sent>::value && is_copy_constructible<_Sent>::value
&& is_copy_constructible<_OutIter>::value, int> = 0> && is_copy_constructible<_OutIter>::value, int> = 0>
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14
pair<_InIter, _OutIter> __copy(_InIter __first, _Sent __last, _OutIter __result) { pair<_InIter, _OutIter> __copy(_InIter __first, _Sent __last, _OutIter __result) {
auto __range = std::__unwrap_range(__first, __last); auto __range = std::__unwrap_range(__first, __last);
auto __ret = std::__copy_impl(std::move(__range.first), std::move(__range.second), std::__unwrap_iter(__result)); auto __ret = std::__copy_impl(std::move(__range.first), std::move(__range.second), std::__unwrap_iter(__result));
return std::make_pair( return std::make_pair(
std::__rewrap_range<_Sent>(__first, __ret.first), std::__rewrap_iter(__result, __ret.second)); std::__rewrap_range<_Sent>(__first, __ret.first), std::__rewrap_iter(__result, __ret.second));
} }
template <class _InputIterator, class _OutputIterator> template <class _InputIterator, class _OutputIterator>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
_OutputIterator _OutputIterator
copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result) { copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result) {
return std::__copy(__first, __last, __result).second; return std::__copy(__first, __last, __result).second;
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_COPY_H #endif // _LIBCPP___ALGORITHM_COPY_H

libcxx/include/__algorithm/copy_backward.h

Show All 24 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 _AlgPolicy, class _InputIterator, class _OutputIterator, template <class _AlgPolicy, class _InputIterator, class _OutputIterator,
__enable_if_t<is_same<_AlgPolicy, _ClassicAlgPolicy>::value, int> = 0> __enable_if_t<is_same<_AlgPolicy, _ClassicAlgPolicy>::value, int> = 0>
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 pair<_InputIterator, _OutputIterator> inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14 pair<_InputIterator, _OutputIterator>
__copy_backward(_InputIterator __first, _InputIterator __last, _OutputIterator __result) { __copy_backward(_InputIterator __first, _InputIterator __last, _OutputIterator __result) {
auto __ret = std::__copy( auto __ret = std::__copy(
__unconstrained_reverse_iterator<_InputIterator>(__last), __unconstrained_reverse_iterator<_InputIterator>(__last),
__unconstrained_reverse_iterator<_InputIterator>(__first), __unconstrained_reverse_iterator<_InputIterator>(__first),
__unconstrained_reverse_iterator<_OutputIterator>(__result)); __unconstrained_reverse_iterator<_OutputIterator>(__result));
return pair<_InputIterator, _OutputIterator>(__ret.first.base(), __ret.second.base()); return pair<_InputIterator, _OutputIterator>(__ret.first.base(), __ret.second.base());
} }
#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES) #if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
template <class _AlgPolicy, class _Iter1, class _Sent1, class _Iter2, template <class _AlgPolicy, class _Iter1, class _Sent1, class _Iter2,
__enable_if_t<is_same<_AlgPolicy, _RangeAlgPolicy>::value, int> = 0> __enable_if_t<is_same<_AlgPolicy, _RangeAlgPolicy>::value, int> = 0>
_LIBCPP_HIDE_FROM_ABI constexpr pair<_Iter1, _Iter2> __copy_backward(_Iter1 __first, _Sent1 __last, _Iter2 __result) { _LIBCPP_HIDE_FROM_ABI constexpr pair<_Iter1, _Iter2> __copy_backward(_Iter1 __first, _Sent1 __last, _Iter2 __result) {
auto __last_iter = _IterOps<_AlgPolicy>::next(__first, std::move(__last)); auto __last_iter = _IterOps<_AlgPolicy>::next(__first, std::move(__last));
auto __reverse_range = std::__reverse_range(std::ranges::subrange(std::move(__first), __last_iter)); auto __reverse_range = std::__reverse_range(std::ranges::subrange(std::move(__first), __last_iter));
auto __ret = ranges::copy(std::move(__reverse_range), std::make_reverse_iterator(__result)); auto __ret = ranges::copy(std::move(__reverse_range), std::make_reverse_iterator(__result));
return std::make_pair(__last_iter, __ret.out.base()); return std::make_pair(__last_iter, __ret.out.base());
} }
#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES) #endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
template <class _BidirectionalIterator1, class _BidirectionalIterator2> template <class _BidirectionalIterator1, class _BidirectionalIterator2>
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _BidirectionalIterator2 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20 _BidirectionalIterator2
copy_backward(_BidirectionalIterator1 __first, _BidirectionalIterator1 __last, _BidirectionalIterator2 __result) { copy_backward(_BidirectionalIterator1 __first, _BidirectionalIterator1 __last, _BidirectionalIterator2 __result) {
return std::__copy_backward<_ClassicAlgPolicy>(__first, __last, __result).second; return std::__copy_backward<_ClassicAlgPolicy>(__first, __last, __result).second;
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_COPY_BACKWARD_H #endif // _LIBCPP___ALGORITHM_COPY_BACKWARD_H

libcxx/include/__algorithm/copy_if.h

Show All 12 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 _InputIterator, class _OutputIterator, class _Predicate> template<class _InputIterator, class _OutputIterator, class _Predicate>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
_OutputIterator _OutputIterator
copy_if(_InputIterator __first, _InputIterator __last, copy_if(_InputIterator __first, _InputIterator __last,
_OutputIterator __result, _Predicate __pred) _OutputIterator __result, _Predicate __pred)
{ {
for (; __first != __last; ++__first) for (; __first != __last; ++__first)
{ {
if (__pred(*__first)) if (__pred(*__first))
{ {
Show All 10 Lines

libcxx/include/__algorithm/copy_n.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 _InputIterator, class _Size, class _OutputIterator> template<class _InputIterator, class _Size, class _OutputIterator>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
typename enable_if typename enable_if
< <
__is_cpp17_input_iterator<_InputIterator>::value && __is_cpp17_input_iterator<_InputIterator>::value &&
!__is_cpp17_random_access_iterator<_InputIterator>::value, !__is_cpp17_random_access_iterator<_InputIterator>::value,
_OutputIterator _OutputIterator
>::type >::type
copy_n(_InputIterator __first, _Size __orig_n, _OutputIterator __result) copy_n(_InputIterator __first, _Size __orig_n, _OutputIterator __result)
{ {
Show All 9 Lines if (__n > 0)
*__result = *__first; *__result = *__first;
++__result; ++__result;
} }
} }
return __result; return __result;
} }
template<class _InputIterator, class _Size, class _OutputIterator> template<class _InputIterator, class _Size, class _OutputIterator>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
typename enable_if typename enable_if
< <
__is_cpp17_random_access_iterator<_InputIterator>::value, __is_cpp17_random_access_iterator<_InputIterator>::value,
_OutputIterator _OutputIterator
>::type >::type
copy_n(_InputIterator __first, _Size __orig_n, _OutputIterator __result) copy_n(_InputIterator __first, _Size __orig_n, _OutputIterator __result)
{ {
typedef typename iterator_traits<_InputIterator>::difference_type difference_type; typedef typename iterator_traits<_InputIterator>::difference_type difference_type;
typedef decltype(_VSTD::__convert_to_integral(__orig_n)) _IntegralSize; typedef decltype(_VSTD::__convert_to_integral(__orig_n)) _IntegralSize;
_IntegralSize __n = __orig_n; _IntegralSize __n = __orig_n;
return _VSTD::copy(__first, __first + difference_type(__n), __result); return _VSTD::copy(__first, __first + difference_type(__n), __result);
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_COPY_N_H #endif // _LIBCPP___ALGORITHM_COPY_N_H

libcxx/include/__algorithm/count.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 _InputIterator, class _Tp> template <class _InputIterator, class _Tp>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
typename iterator_traits<_InputIterator>::difference_type typename iterator_traits<_InputIterator>::difference_type
count(_InputIterator __first, _InputIterator __last, const _Tp& __value) { count(_InputIterator __first, _InputIterator __last, const _Tp& __value) {
typename iterator_traits<_InputIterator>::difference_type __r(0); typename iterator_traits<_InputIterator>::difference_type __r(0);
for (; __first != __last; ++__first) for (; __first != __last; ++__first)
if (*__first == __value) if (*__first == __value)
++__r; ++__r;
return __r; return __r;
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_COUNT_H #endif // _LIBCPP___ALGORITHM_COUNT_H

libcxx/include/__algorithm/count_if.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 _InputIterator, class _Predicate> template <class _InputIterator, class _Predicate>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
typename iterator_traits<_InputIterator>::difference_type typename iterator_traits<_InputIterator>::difference_type
count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred) { count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred) {
typename iterator_traits<_InputIterator>::difference_type __r(0); typename iterator_traits<_InputIterator>::difference_type __r(0);
for (; __first != __last; ++__first) for (; __first != __last; ++__first)
if (__pred(*__first)) if (__pred(*__first))
++__r; ++__r;
return __r; return __r;
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_COUNT_IF_H #endif // _LIBCPP___ALGORITHM_COUNT_IF_H

libcxx/include/__algorithm/equal.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 _InputIterator1, class _InputIterator2, class _BinaryPredicate> template <class _InputIterator1, class _InputIterator2, class _BinaryPredicate>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 bool _LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 bool
equal(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _BinaryPredicate __pred) { equal(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _BinaryPredicate __pred) {
for (; __first1 != __last1; ++__first1, (void)++__first2) for (; __first1 != __last1; ++__first1, (void)++__first2)
if (!__pred(*__first1, *__first2)) if (!__pred(*__first1, *__first2))
return false; return false;
return true; return true;
} }
template <class _InputIterator1, class _InputIterator2> template <class _InputIterator1, class _InputIterator2>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 bool _LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 bool
equal(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2) { equal(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2) {
typedef typename iterator_traits<_InputIterator1>::value_type __v1; typedef typename iterator_traits<_InputIterator1>::value_type __v1;
typedef typename iterator_traits<_InputIterator2>::value_type __v2; typedef typename iterator_traits<_InputIterator2>::value_type __v2;
return _VSTD::equal(__first1, __last1, __first2, __equal_to<__v1, __v2>()); return _VSTD::equal(__first1, __last1, __first2, __equal_to<__v1, __v2>());
} }
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER > 11
template <class _BinaryPredicate, class _InputIterator1, class _InputIterator2> template <class _BinaryPredicate, class _InputIterator1, class _InputIterator2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 bool inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 bool
__equal(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, __equal(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2,
_BinaryPredicate __pred, input_iterator_tag, input_iterator_tag) { _BinaryPredicate __pred, input_iterator_tag, input_iterator_tag) {
for (; __first1 != __last1 && __first2 != __last2; ++__first1, (void)++__first2) for (; __first1 != __last1 && __first2 != __last2; ++__first1, (void)++__first2)
if (!__pred(*__first1, *__first2)) if (!__pred(*__first1, *__first2))
return false; return false;
return __first1 == __last1 && __first2 == __last2; return __first1 == __last1 && __first2 == __last2;
} }
template <class _BinaryPredicate, class _RandomAccessIterator1, class _RandomAccessIterator2> template <class _BinaryPredicate, class _RandomAccessIterator1, class _RandomAccessIterator2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 bool inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 bool
__equal(_RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1, _RandomAccessIterator2 __first2, __equal(_RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1, _RandomAccessIterator2 __first2,
_RandomAccessIterator2 __last2, _BinaryPredicate __pred, random_access_iterator_tag, _RandomAccessIterator2 __last2, _BinaryPredicate __pred, random_access_iterator_tag,
random_access_iterator_tag) { random_access_iterator_tag) {
if (_VSTD::distance(__first1, __last1) != _VSTD::distance(__first2, __last2)) if (_VSTD::distance(__first1, __last1) != _VSTD::distance(__first2, __last2))
return false; return false;
return _VSTD::equal<_RandomAccessIterator1, _RandomAccessIterator2, return _VSTD::equal<_RandomAccessIterator1, _RandomAccessIterator2,
_BinaryPredicate&>(__first1, __last1, __first2, __pred); _BinaryPredicate&>(__first1, __last1, __first2, __pred);
} }
template <class _InputIterator1, class _InputIterator2, class _BinaryPredicate> template <class _InputIterator1, class _InputIterator2, class _BinaryPredicate>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 bool _LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 bool
equal(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, equal(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2,
_BinaryPredicate __pred) { _BinaryPredicate __pred) {
return _VSTD::__equal<_BinaryPredicate&>( return _VSTD::__equal<_BinaryPredicate&>(
__first1, __last1, __first2, __last2, __pred, typename iterator_traits<_InputIterator1>::iterator_category(), __first1, __last1, __first2, __last2, __pred, typename iterator_traits<_InputIterator1>::iterator_category(),
typename iterator_traits<_InputIterator2>::iterator_category()); typename iterator_traits<_InputIterator2>::iterator_category());
} }
template <class _InputIterator1, class _InputIterator2> template <class _InputIterator1, class _InputIterator2>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 bool _LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 bool
equal(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2) { equal(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2) {
typedef typename iterator_traits<_InputIterator1>::value_type __v1; typedef typename iterator_traits<_InputIterator1>::value_type __v1;
typedef typename iterator_traits<_InputIterator2>::value_type __v2; typedef typename iterator_traits<_InputIterator2>::value_type __v2;
return _VSTD::__equal(__first1, __last1, __first2, __last2, __equal_to<__v1, __v2>(), return _VSTD::__equal(__first1, __last1, __first2, __last2, __equal_to<__v1, __v2>(),
typename iterator_traits<_InputIterator1>::iterator_category(), typename iterator_traits<_InputIterator1>::iterator_category(),
typename iterator_traits<_InputIterator2>::iterator_category()); typename iterator_traits<_InputIterator2>::iterator_category());
} }
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_EQUAL_H #endif // _LIBCPP___ALGORITHM_EQUAL_H

libcxx/include/__algorithm/equal_range.h

Show All 28 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 _AlgPolicy, class _Compare, class _Iter, class _Sent, class _Tp, class _Proj> template <class _AlgPolicy, class _Compare, class _Iter, class _Sent, class _Tp, class _Proj>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 pair<_Iter, _Iter> _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20 pair<_Iter, _Iter>
__equal_range(_Iter __first, _Sent __last, const _Tp& __value, _Compare&& __comp, _Proj&& __proj) { __equal_range(_Iter __first, _Sent __last, const _Tp& __value, _Compare&& __comp, _Proj&& __proj) {
auto __len = _IterOps<_AlgPolicy>::distance(__first, __last); auto __len = _IterOps<_AlgPolicy>::distance(__first, __last);
_Iter __end = _IterOps<_AlgPolicy>::next(__first, __last); _Iter __end = _IterOps<_AlgPolicy>::next(__first, __last);
while (__len != 0) { while (__len != 0) {
auto __half_len = std::__half_positive(__len); auto __half_len = std::__half_positive(__len);
_Iter __mid = _IterOps<_AlgPolicy>::next(__first, __half_len); _Iter __mid = _IterOps<_AlgPolicy>::next(__first, __half_len);
if (std::__invoke(__comp, std::__invoke(__proj, *__mid), __value)) { if (std::__invoke(__comp, std::__invoke(__proj, *__mid), __value)) {
__first = ++__mid; __first = ++__mid;
__len -= __half_len + 1; __len -= __half_len + 1;
} else if (std::__invoke(__comp, __value, std::__invoke(__proj, *__mid))) { } else if (std::__invoke(__comp, __value, std::__invoke(__proj, *__mid))) {
__end = __mid; __end = __mid;
__len = __half_len; __len = __half_len;
} else { } else {
_Iter __mp1 = __mid; _Iter __mp1 = __mid;
return pair<_Iter, _Iter>( return pair<_Iter, _Iter>(
std::__lower_bound_impl<_AlgPolicy>(__first, __mid, __value, __comp, __proj), std::__lower_bound_impl<_AlgPolicy>(__first, __mid, __value, __comp, __proj),
std::__upper_bound<_AlgPolicy>(++__mp1, __end, __value, __comp, __proj)); std::__upper_bound<_AlgPolicy>(++__mp1, __end, __value, __comp, __proj));
} }
} }
return pair<_Iter, _Iter>(__first, __first); return pair<_Iter, _Iter>(__first, __first);
} }
template <class _ForwardIterator, class _Tp, class _Compare> template <class _ForwardIterator, class _Tp, class _Compare>
_LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 pair<_ForwardIterator, _ForwardIterator> _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20 pair<_ForwardIterator, _ForwardIterator>
equal_range(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value, _Compare __comp) { equal_range(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value, _Compare __comp) {
static_assert(__is_callable<_Compare, decltype(*__first), const _Tp&>::value, static_assert(__is_callable<_Compare, decltype(*__first), const _Tp&>::value,
"The comparator has to be callable"); "The comparator has to be callable");
static_assert(is_copy_constructible<_ForwardIterator>::value, static_assert(is_copy_constructible<_ForwardIterator>::value,
"Iterator has to be copy constructible"); "Iterator has to be copy constructible");
typedef typename __comp_ref_type<_Compare>::type _Comp_ref; typedef typename __comp_ref_type<_Compare>::type _Comp_ref;
return std::__equal_range<_ClassicAlgPolicy>( return std::__equal_range<_ClassicAlgPolicy>(
std::move(__first), std::move(__last), __value, static_cast<_Comp_ref>(__comp), std::__identity()); std::move(__first), std::move(__last), __value, static_cast<_Comp_ref>(__comp), std::__identity());
} }
template <class _ForwardIterator, class _Tp> template <class _ForwardIterator, class _Tp>
_LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 pair<_ForwardIterator, _ForwardIterator> _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20 pair<_ForwardIterator, _ForwardIterator>
equal_range(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) { equal_range(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) {
return std::equal_range( return std::equal_range(
std::move(__first), std::move(__first),
std::move(__last), std::move(__last),
__value, __value,
__less<typename iterator_traits<_ForwardIterator>::value_type, _Tp>()); __less<typename iterator_traits<_ForwardIterator>::value_type, _Tp>());
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_EQUAL_RANGE_H #endif // _LIBCPP___ALGORITHM_EQUAL_RANGE_H

libcxx/include/__algorithm/fill.h

Show All 17 Lines
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
// fill isn't specialized for std::memset, because the compiler already optimizes the loop to a call to std::memset. // fill isn't specialized for std::memset, because the compiler already optimizes the loop to a call to std::memset.
template <class _ForwardIterator, class _Tp> template <class _ForwardIterator, class _Tp>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
void void
__fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value, forward_iterator_tag) __fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value, forward_iterator_tag)
{ {
for (; __first != __last; ++__first) for (; __first != __last; ++__first)
*__first = __value; *__first = __value;
} }
template <class _RandomAccessIterator, class _Tp> template <class _RandomAccessIterator, class _Tp>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
void void
__fill(_RandomAccessIterator __first, _RandomAccessIterator __last, const _Tp& __value, random_access_iterator_tag) __fill(_RandomAccessIterator __first, _RandomAccessIterator __last, const _Tp& __value, random_access_iterator_tag)
{ {
_VSTD::fill_n(__first, __last - __first, __value); _VSTD::fill_n(__first, __last - __first, __value);
} }
template <class _ForwardIterator, class _Tp> template <class _ForwardIterator, class _Tp>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
void void
fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value)
{ {
_VSTD::__fill(__first, __last, __value, typename iterator_traits<_ForwardIterator>::iterator_category()); _VSTD::__fill(__first, __last, __value, typename iterator_traits<_ForwardIterator>::iterator_category());
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_FILL_H #endif // _LIBCPP___ALGORITHM_FILL_H

libcxx/include/__algorithm/fill_n.h

Show All 16 Lines
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
// fill_n isn't specialized for std::memset, because the compiler already optimizes the loop to a call to std::memset. // fill_n isn't specialized for std::memset, because the compiler already optimizes the loop to a call to std::memset.
template <class _OutputIterator, class _Size, class _Tp> template <class _OutputIterator, class _Size, class _Tp>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
_OutputIterator _OutputIterator
__fill_n(_OutputIterator __first, _Size __n, const _Tp& __value) __fill_n(_OutputIterator __first, _Size __n, const _Tp& __value)
{ {
for (; __n > 0; ++__first, (void) --__n) for (; __n > 0; ++__first, (void) --__n)
*__first = __value; *__first = __value;
return __first; return __first;
} }
template <class _OutputIterator, class _Size, class _Tp> template <class _OutputIterator, class _Size, class _Tp>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
_OutputIterator _OutputIterator
fill_n(_OutputIterator __first, _Size __n, const _Tp& __value) fill_n(_OutputIterator __first, _Size __n, const _Tp& __value)
{ {
return _VSTD::__fill_n(__first, _VSTD::__convert_to_integral(__n), __value); return _VSTD::__fill_n(__first, _VSTD::__convert_to_integral(__n), __value);
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_FILL_N_H #endif // _LIBCPP___ALGORITHM_FILL_N_H

libcxx/include/__algorithm/find.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 _InputIterator, class _Tp> template <class _InputIterator, class _Tp>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _InputIterator _LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 _InputIterator
find(_InputIterator __first, _InputIterator __last, const _Tp& __value) { find(_InputIterator __first, _InputIterator __last, const _Tp& __value) {
for (; __first != __last; ++__first) for (; __first != __last; ++__first)
if (*__first == __value) if (*__first == __value)
break; break;
return __first; return __first;
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_FIND_H #endif // _LIBCPP___ALGORITHM_FIND_H

libcxx/include/__algorithm/find_end.h

Show All 31 Linestemplate <
class _AlgPolicy, class _AlgPolicy,
class _Iter1, class _Iter1,
class _Sent1, class _Sent1,
class _Iter2, class _Iter2,
class _Sent2, class _Sent2,
class _Pred, class _Pred,
class _Proj1, class _Proj1,
class _Proj2> class _Proj2>
_LIBCPP_HIDE_FROM_ABI inline _LIBCPP_CONSTEXPR_AFTER_CXX11 pair<_Iter1, _Iter1> __find_end_impl( _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_CONSTEXPR_CXX14 pair<_Iter1, _Iter1> __find_end_impl(
_Iter1 __first1, _Iter1 __first1,
_Sent1 __last1, _Sent1 __last1,
_Iter2 __first2, _Iter2 __first2,
_Sent2 __last2, _Sent2 __last2,
_Pred& __pred, _Pred& __pred,
_Proj1& __proj1, _Proj1& __proj1,
_Proj2& __proj2, _Proj2& __proj2,
forward_iterator_tag, forward_iterator_tag,
Show All 37 Linestemplate <
class _IterOps, class _IterOps,
class _Pred, class _Pred,
class _Iter1, class _Iter1,
class _Sent1, class _Sent1,
class _Iter2, class _Iter2,
class _Sent2, class _Sent2,
class _Proj1, class _Proj1,
class _Proj2> class _Proj2>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _Iter1 __find_end( _LIBCPP_CONSTEXPR_CXX20 _Iter1 __find_end(
_Iter1 __first1, _Iter1 __first1,
_Sent1 __sent1, _Sent1 __sent1,
_Iter2 __first2, _Iter2 __first2,
_Sent2 __sent2, _Sent2 __sent2,
_Pred& __pred, _Pred& __pred,
_Proj1& __proj1, _Proj1& __proj1,
_Proj2& __proj2, _Proj2& __proj2,
bidirectional_iterator_tag, bidirectional_iterator_tag,
Show All 36 Linestemplate <
class _AlgPolicy, class _AlgPolicy,
class _Pred, class _Pred,
class _Iter1, class _Iter1,
class _Sent1, class _Sent1,
class _Iter2, class _Iter2,
class _Sent2, class _Sent2,
class _Proj1, class _Proj1,
class _Proj2> class _Proj2>
_LIBCPP_CONSTEXPR_AFTER_CXX11 _Iter1 __find_end( _LIBCPP_CONSTEXPR_CXX14 _Iter1 __find_end(
_Iter1 __first1, _Iter1 __first1,
_Sent1 __sent1, _Sent1 __sent1,
_Iter2 __first2, _Iter2 __first2,
_Sent2 __sent2, _Sent2 __sent2,
_Pred& __pred, _Pred& __pred,
_Proj1& __proj1, _Proj1& __proj1,
_Proj2& __proj2, _Proj2& __proj2,
random_access_iterator_tag, random_access_iterator_tag,
Show All 28 Lines while (true) {
if (!std::__invoke(__pred, std::__invoke(__proj1, *--__m1), std::__invoke(*--__m2))) { if (!std::__invoke(__pred, std::__invoke(__proj1, *--__m1), std::__invoke(*--__m2))) {
break; break;
} }
} }
} }
} }
template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate> template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14
_ForwardIterator1 __find_end_classic(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator1 __find_end_classic(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator2 __first2, _ForwardIterator2 __last2,
_BinaryPredicate& __pred) { _BinaryPredicate& __pred) {
auto __proj = __identity(); auto __proj = __identity();
return std::__find_end_impl<_ClassicAlgPolicy>( return std::__find_end_impl<_ClassicAlgPolicy>(
__first1, __first1,
__last1, __last1,
__first2, __first2,
__last2, __last2,
__pred, __pred,
__proj, __proj,
__proj, __proj,
typename iterator_traits<_ForwardIterator1>::iterator_category(), typename iterator_traits<_ForwardIterator1>::iterator_category(),
typename iterator_traits<_ForwardIterator2>::iterator_category()) typename iterator_traits<_ForwardIterator2>::iterator_category())
.first; .first;
} }
template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate> template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
_ForwardIterator1 find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator1 find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator2 __first2, _ForwardIterator2 __last2,
_BinaryPredicate __pred) { _BinaryPredicate __pred) {
return std::__find_end_classic(__first1, __last1, __first2, __last2, __pred); return std::__find_end_classic(__first1, __last1, __first2, __last2, __pred);
} }
template <class _ForwardIterator1, class _ForwardIterator2> template <class _ForwardIterator1, class _ForwardIterator2>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
_ForwardIterator1 find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator1 find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2, _ForwardIterator2 __last2) { _ForwardIterator2 __first2, _ForwardIterator2 __last2) {
using __v1 = typename iterator_traits<_ForwardIterator1>::value_type; using __v1 = typename iterator_traits<_ForwardIterator1>::value_type;
using __v2 = typename iterator_traits<_ForwardIterator2>::value_type; using __v2 = typename iterator_traits<_ForwardIterator2>::value_type;
return std::find_end(__first1, __last1, __first2, __last2, __equal_to<__v1, __v2>()); return std::find_end(__first1, __last1, __first2, __last2, __equal_to<__v1, __v2>());
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_FIND_END_OF_H #endif // _LIBCPP___ALGORITHM_FIND_END_OF_H

libcxx/include/__algorithm/find_first_of.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 _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate> template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
_LIBCPP_CONSTEXPR_AFTER_CXX11 _ForwardIterator1 __find_first_of_ce(_ForwardIterator1 __first1, _LIBCPP_CONSTEXPR_CXX14 _ForwardIterator1 __find_first_of_ce(_ForwardIterator1 __first1,
_ForwardIterator1 __last1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2, _ForwardIterator2 __first2,
_ForwardIterator2 __last2, _ForwardIterator2 __last2,
_BinaryPredicate&& __pred) { _BinaryPredicate&& __pred) {
for (; __first1 != __last1; ++__first1) for (; __first1 != __last1; ++__first1)
for (_ForwardIterator2 __j = __first2; __j != __last2; ++__j) for (_ForwardIterator2 __j = __first2; __j != __last2; ++__j)
if (__pred(*__first1, *__j)) if (__pred(*__first1, *__j))
return __first1; return __first1;
return __last1; return __last1;
} }
template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate> template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _ForwardIterator1 _LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 _ForwardIterator1
find_first_of(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, find_first_of(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
_ForwardIterator2 __last2, _BinaryPredicate __pred) { _ForwardIterator2 __last2, _BinaryPredicate __pred) {
return _VSTD::__find_first_of_ce(__first1, __last1, __first2, __last2, __pred); return _VSTD::__find_first_of_ce(__first1, __last1, __first2, __last2, __pred);
} }
template <class _ForwardIterator1, class _ForwardIterator2> template <class _ForwardIterator1, class _ForwardIterator2>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _ForwardIterator1 find_first_of( _LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 _ForwardIterator1 find_first_of(
_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2) { _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2) {
typedef typename iterator_traits<_ForwardIterator1>::value_type __v1; typedef typename iterator_traits<_ForwardIterator1>::value_type __v1;
typedef typename iterator_traits<_ForwardIterator2>::value_type __v2; typedef typename iterator_traits<_ForwardIterator2>::value_type __v2;
return _VSTD::__find_first_of_ce(__first1, __last1, __first2, __last2, __equal_to<__v1, __v2>()); return _VSTD::__find_first_of_ce(__first1, __last1, __first2, __last2, __equal_to<__v1, __v2>());
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_FIND_FIRST_OF_H #endif // _LIBCPP___ALGORITHM_FIND_FIRST_OF_H

libcxx/include/__algorithm/find_if.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 _InputIterator, class _Predicate> template <class _InputIterator, class _Predicate>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _InputIterator _LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 _InputIterator
find_if(_InputIterator __first, _InputIterator __last, _Predicate __pred) { find_if(_InputIterator __first, _InputIterator __last, _Predicate __pred) {
for (; __first != __last; ++__first) for (; __first != __last; ++__first)
if (__pred(*__first)) if (__pred(*__first))
break; break;
return __first; return __first;
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_FIND_IF_H #endif // _LIBCPP___ALGORITHM_FIND_IF_H

libcxx/include/__algorithm/find_if_not.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 _InputIterator, class _Predicate> template <class _InputIterator, class _Predicate>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _InputIterator _LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 _InputIterator
find_if_not(_InputIterator __first, _InputIterator __last, _Predicate __pred) { find_if_not(_InputIterator __first, _InputIterator __last, _Predicate __pred) {
for (; __first != __last; ++__first) for (; __first != __last; ++__first)
if (!__pred(*__first)) if (!__pred(*__first))
break; break;
return __first; return __first;
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_FIND_IF_NOT_H #endif // _LIBCPP___ALGORITHM_FIND_IF_NOT_H

libcxx/include/__algorithm/for_each.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 _InputIterator, class _Function> template <class _InputIterator, class _Function>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _Function for_each(_InputIterator __first, inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 _Function for_each(_InputIterator __first,
_InputIterator __last, _InputIterator __last,
_Function __f) { _Function __f) {
for (; __first != __last; ++__first) for (; __first != __last; ++__first)
__f(*__first); __f(*__first);
return __f; return __f;
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_FOR_EACH_H #endif // _LIBCPP___ALGORITHM_FOR_EACH_H

libcxx/include/__algorithm/for_each_n.h

Show All 16 Lines
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER > 14
template <class _InputIterator, class _Size, class _Function> template <class _InputIterator, class _Size, class _Function>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _InputIterator for_each_n(_InputIterator __first, inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 _InputIterator for_each_n(_InputIterator __first,
_Size __orig_n, _Size __orig_n,
_Function __f) { _Function __f) {
typedef decltype(_VSTD::__convert_to_integral(__orig_n)) _IntegralSize; typedef decltype(_VSTD::__convert_to_integral(__orig_n)) _IntegralSize;
_IntegralSize __n = __orig_n; _IntegralSize __n = __orig_n;
while (__n > 0) { while (__n > 0) {
__f(*__first); __f(*__first);
++__first; ++__first;
--__n; --__n;
Show All 9 Lines

libcxx/include/__algorithm/generate.h

Show All 12 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 _ForwardIterator, class _Generator> template <class _ForwardIterator, class _Generator>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
void void
generate(_ForwardIterator __first, _ForwardIterator __last, _Generator __gen) generate(_ForwardIterator __first, _ForwardIterator __last, _Generator __gen)
{ {
for (; __first != __last; ++__first) for (; __first != __last; ++__first)
*__first = __gen(); *__first = __gen();
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_GENERATE_H #endif // _LIBCPP___ALGORITHM_GENERATE_H

libcxx/include/__algorithm/generate_n.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 _OutputIterator, class _Size, class _Generator> template <class _OutputIterator, class _Size, class _Generator>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
_OutputIterator _OutputIterator
generate_n(_OutputIterator __first, _Size __orig_n, _Generator __gen) generate_n(_OutputIterator __first, _Size __orig_n, _Generator __gen)
{ {
typedef decltype(_VSTD::__convert_to_integral(__orig_n)) _IntegralSize; typedef decltype(_VSTD::__convert_to_integral(__orig_n)) _IntegralSize;
_IntegralSize __n = __orig_n; _IntegralSize __n = __orig_n;
for (; __n > 0; ++__first, (void) --__n) for (; __n > 0; ++__first, (void) --__n)
*__first = __gen(); *__first = __gen();
return __first; return __first;
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_GENERATE_N_H #endif // _LIBCPP___ALGORITHM_GENERATE_N_H

libcxx/include/__algorithm/includes.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 _Iter1, class _Sent1, class _Iter2, class _Sent2, class _Comp, class _Proj1, class _Proj2> template <class _Iter1, class _Sent1, class _Iter2, class _Sent2, class _Comp, class _Proj1, class _Proj2>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 bool _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20 bool
__includes(_Iter1 __first1, _Sent1 __last1, _Iter2 __first2, _Sent2 __last2, __includes(_Iter1 __first1, _Sent1 __last1, _Iter2 __first2, _Sent2 __last2,
_Comp&& __comp, _Proj1&& __proj1, _Proj2&& __proj2) { _Comp&& __comp, _Proj1&& __proj1, _Proj2&& __proj2) {
for (; __first2 != __last2; ++__first1) { for (; __first2 != __last2; ++__first1) {
if (__first1 == __last1 || std::__invoke( if (__first1 == __last1 || std::__invoke(
__comp, std::__invoke(__proj2, *__first2), std::__invoke(__proj1, *__first1))) __comp, std::__invoke(__proj2, *__first2), std::__invoke(__proj1, *__first1)))
return false; return false;
if (!std::__invoke(__comp, std::__invoke(__proj1, *__first1), std::__invoke(__proj2, *__first2))) if (!std::__invoke(__comp, std::__invoke(__proj1, *__first1), std::__invoke(__proj2, *__first2)))
++__first2; ++__first2;
} }
return true; return true;
} }
template <class _InputIterator1, class _InputIterator2, class _Compare> template <class _InputIterator1, class _InputIterator2, class _Compare>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 bool includes( _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20 bool includes(
_InputIterator1 __first1, _InputIterator1 __first1,
_InputIterator1 __last1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __first2,
_InputIterator2 __last2, _InputIterator2 __last2,
_Compare __comp) { _Compare __comp) {
static_assert(__is_callable<_Compare, decltype(*__first1), decltype(*__first2)>::value, static_assert(__is_callable<_Compare, decltype(*__first1), decltype(*__first2)>::value,
"Comparator has to be callable"); "Comparator has to be callable");
typedef typename __comp_ref_type<_Compare>::type _Comp_ref; typedef typename __comp_ref_type<_Compare>::type _Comp_ref;
return std::__includes( return std::__includes(
std::move(__first1), std::move(__last1), std::move(__first2), std::move(__last2), std::move(__first1), std::move(__last1), std::move(__first2), std::move(__last2),
static_cast<_Comp_ref>(__comp), __identity(), __identity()); static_cast<_Comp_ref>(__comp), __identity(), __identity());
} }
template <class _InputIterator1, class _InputIterator2> template <class _InputIterator1, class _InputIterator2>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 bool _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20 bool
includes(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2) { includes(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2) {
return std::includes( return std::includes(
std::move(__first1), std::move(__first1),
std::move(__last1), std::move(__last1),
std::move(__first2), std::move(__first2),
std::move(__last2), std::move(__last2),
__less<typename iterator_traits<_InputIterator1>::value_type, __less<typename iterator_traits<_InputIterator1>::value_type,
typename iterator_traits<_InputIterator2>::value_type>()); typename iterator_traits<_InputIterator2>::value_type>());
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_INCLUDES_H #endif // _LIBCPP___ALGORITHM_INCLUDES_H

libcxx/include/__algorithm/is_heap.h

Show All 17 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 _RandomAccessIterator, class _Compare> template <class _RandomAccessIterator, class _Compare>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_NODISCARD_EXT inline
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
bool bool
is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
{ {
typedef typename __comp_ref_type<_Compare>::type _Comp_ref; typedef typename __comp_ref_type<_Compare>::type _Comp_ref;
return std::__is_heap_until(__first, __last, static_cast<_Comp_ref>(__comp)) == __last; return std::__is_heap_until(__first, __last, static_cast<_Comp_ref>(__comp)) == __last;
} }
template<class _RandomAccessIterator> template<class _RandomAccessIterator>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_NODISCARD_EXT inline
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
bool bool
is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
{ {
return _VSTD::is_heap(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>()); return _VSTD::is_heap(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_IS_HEAP_H #endif // _LIBCPP___ALGORITHM_IS_HEAP_H

libcxx/include/__algorithm/is_heap_until.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 _Compare, class _RandomAccessIterator> template <class _Compare, class _RandomAccessIterator>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _RandomAccessIterator _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20 _RandomAccessIterator
__is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare&& __comp) __is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare&& __comp)
{ {
typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type; typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
difference_type __len = __last - __first; difference_type __len = __last - __first;
difference_type __p = 0; difference_type __p = 0;
difference_type __c = 1; difference_type __c = 1;
_RandomAccessIterator __pp = __first; _RandomAccessIterator __pp = __first;
while (__c < __len) while (__c < __len)
Show All 10 Lines while (__c < __len)
++__p; ++__p;
++__pp; ++__pp;
__c = 2 * __p + 1; __c = 2 * __p + 1;
} }
return __last; return __last;
} }
template <class _RandomAccessIterator, class _Compare> template <class _RandomAccessIterator, class _Compare>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _RandomAccessIterator _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20 _RandomAccessIterator
is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
{ {
typedef typename __comp_ref_type<_Compare>::type _Comp_ref; typedef typename __comp_ref_type<_Compare>::type _Comp_ref;
return std::__is_heap_until(__first, __last, static_cast<_Comp_ref>(__comp)); return std::__is_heap_until(__first, __last, static_cast<_Comp_ref>(__comp));
} }
template<class _RandomAccessIterator> template<class _RandomAccessIterator>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _RandomAccessIterator _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20 _RandomAccessIterator
is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last) is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last)
{ {
return _VSTD::__is_heap_until(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>()); return _VSTD::__is_heap_until(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_IS_HEAP_UNTIL_H #endif // _LIBCPP___ALGORITHM_IS_HEAP_UNTIL_H

libcxx/include/__algorithm/is_partitioned.h

Show All 12 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 _InputIterator, class _Predicate> template <class _InputIterator, class _Predicate>
_LIBCPP_NODISCARD_EXT _LIBCPP_CONSTEXPR_AFTER_CXX17 bool _LIBCPP_NODISCARD_EXT _LIBCPP_CONSTEXPR_CXX20 bool
is_partitioned(_InputIterator __first, _InputIterator __last, _Predicate __pred) is_partitioned(_InputIterator __first, _InputIterator __last, _Predicate __pred)
{ {
for (; __first != __last; ++__first) for (; __first != __last; ++__first)
if (!__pred(*__first)) if (!__pred(*__first))
break; break;
if ( __first == __last ) if ( __first == __last )
return true; return true;
++__first; ++__first;
Show All 9 Lines

libcxx/include/__algorithm/is_permutation.h

Show First 20 Lines • Show All 49 Lines • ▼ Show 20 Lines
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER > 17
// Internal functions // Internal functions
// For each element in [f1, l1) see if there are the same number of equal elements in [f2, l2) // For each element in [f1, l1) see if there are the same number of equal elements in [f2, l2)
template <class _AlgPolicy, template <class _AlgPolicy,
class _Iter1, class _Sent1, class _Iter2, class _Sent2, class _Iter1, class _Sent1, class _Iter2, class _Sent2,
class _Proj1, class _Proj2, class _Pred> class _Proj1, class _Proj2, class _Pred>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 bool _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20 bool
__is_permutation_impl(_Iter1 __first1, _Sent1 __last1, _Iter2 __first2, _Sent2 __last2, __is_permutation_impl(_Iter1 __first1, _Sent1 __last1, _Iter2 __first2, _Sent2 __last2,
_Pred&& __pred, _Proj1&& __proj1, _Proj2&& __proj2) { _Pred&& __pred, _Proj1&& __proj1, _Proj2&& __proj2) {
using _D1 = __iter_diff_t<_Iter1>; using _D1 = __iter_diff_t<_Iter1>;
for (auto __i = __first1; __i != __last1; ++__i) { for (auto __i = __first1; __i != __last1; ++__i) {
// Have we already counted the number of *__i in [f1, l1)? // Have we already counted the number of *__i in [f1, l1)?
auto __match = __first1; auto __match = __first1;
for (; __match != __i; ++__match) { for (; __match != __i; ++__match) {
Show All 22 Lines for (auto __i = __first1; __i != __last1; ++__i) {
} }
} }
return true; return true;
} }
// 2+1 iterators, predicate. Not used by range algorithms. // 2+1 iterators, predicate. Not used by range algorithms.
template <class _AlgPolicy, class _ForwardIterator1, class _Sentinel1, class _ForwardIterator2, class _BinaryPredicate> template <class _AlgPolicy, class _ForwardIterator1, class _Sentinel1, class _ForwardIterator2, class _BinaryPredicate>
_LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 bool _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20 bool
__is_permutation(_ForwardIterator1 __first1, _Sentinel1 __last1, _ForwardIterator2 __first2, __is_permutation(_ForwardIterator1 __first1, _Sentinel1 __last1, _ForwardIterator2 __first2,
_BinaryPredicate&& __pred) { _BinaryPredicate&& __pred) {
// Shorten sequences as much as possible by lopping of any equal prefix. // Shorten sequences as much as possible by lopping of any equal prefix.
for (; __first1 != __last1; ++__first1, (void)++__first2) { for (; __first1 != __last1; ++__first1, (void)++__first2) {
if (!__pred(*__first1, *__first2)) if (!__pred(*__first1, *__first2))
break; break;
} }
Show All 11 Lines return std::__is_permutation_impl<_AlgPolicy>(
std::move(__first1), std::move(__last1), std::move(__first2), std::move(__last2), std::move(__first1), std::move(__last1), std::move(__first2), std::move(__last2),
__pred, __identity(), __identity()); __pred, __identity(), __identity());
} }
// 2+2 iterators, predicate, non-constant time `distance`. // 2+2 iterators, predicate, non-constant time `distance`.
template <class _AlgPolicy, template <class _AlgPolicy,
class _Iter1, class _Sent1, class _Iter2, class _Sent2, class _Iter1, class _Sent1, class _Iter2, class _Sent2,
class _Proj1, class _Proj2, class _Pred> class _Proj1, class _Proj2, class _Pred>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 bool _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20 bool
__is_permutation(_Iter1 __first1, _Sent1 __last1, _Iter2 __first2, _Sent2 __last2, __is_permutation(_Iter1 __first1, _Sent1 __last1, _Iter2 __first2, _Sent2 __last2,
_Pred&& __pred, _Proj1&& __proj1, _Proj2&& __proj2, _Pred&& __pred, _Proj1&& __proj1, _Proj2&& __proj2,
/*_ConstTimeDistance=*/false_type) { /*_ConstTimeDistance=*/false_type) {
// Shorten sequences as much as possible by lopping of any equal prefix. // Shorten sequences as much as possible by lopping of any equal prefix.
while (__first1 != __last1 && __first2 != __last2) { while (__first1 != __last1 && __first2 != __last2) {
if (!std::__invoke(__pred, std::__invoke(__proj1, *__first1), std::__invoke(__proj2, *__first2))) if (!std::__invoke(__pred, std::__invoke(__proj1, *__first1), std::__invoke(__proj2, *__first2)))
break; break;
++__first1; ++__first1;
Show All 17 Lines return std::__is_permutation_impl<_AlgPolicy>(
std::move(__first1), std::move(__last1), std::move(__first2), std::move(__last2), std::move(__first1), std::move(__last1), std::move(__first2), std::move(__last2),
__pred, __proj1, __proj2); __pred, __proj1, __proj2);
} }
// 2+2 iterators, predicate, specialization for constant-time `distance` call. // 2+2 iterators, predicate, specialization for constant-time `distance` call.
template <class _AlgPolicy, template <class _AlgPolicy,
class _Iter1, class _Sent1, class _Iter2, class _Sent2, class _Iter1, class _Sent1, class _Iter2, class _Sent2,
class _Proj1, class _Proj2, class _Pred> class _Proj1, class _Proj2, class _Pred>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 bool _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20 bool
__is_permutation(_Iter1 __first1, _Sent1 __last1, _Iter2 __first2, _Sent2 __last2, __is_permutation(_Iter1 __first1, _Sent1 __last1, _Iter2 __first2, _Sent2 __last2,
_Pred&& __pred, _Proj1&& __proj1, _Proj2&& __proj2, _Pred&& __pred, _Proj1&& __proj1, _Proj2&& __proj2,
/*_ConstTimeDistance=*/true_type) { /*_ConstTimeDistance=*/true_type) {
if (std::distance(__first1, __last1) != std::distance(__first2, __last2)) if (std::distance(__first1, __last1) != std::distance(__first2, __last2))
return false; return false;
return std::__is_permutation<_AlgPolicy>( return std::__is_permutation<_AlgPolicy>(
std::move(__first1), std::move(__last1), std::move(__first2), std::move(__last2), std::move(__first1), std::move(__last1), std::move(__first2), std::move(__last2),
__pred, __proj1, __proj2, __pred, __proj1, __proj2,
/*_ConstTimeDistance=*/false_type()); /*_ConstTimeDistance=*/false_type());
} }
// 2+2 iterators, predicate // 2+2 iterators, predicate
template <class _AlgPolicy, template <class _AlgPolicy,
class _Iter1, class _Sent1, class _Iter2, class _Sent2, class _Iter1, class _Sent1, class _Iter2, class _Sent2,
class _Proj1, class _Proj2, class _Pred> class _Proj1, class _Proj2, class _Pred>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 bool _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20 bool
__is_permutation(_Iter1 __first1, _Sent1 __last1, _Iter2 __first2, _Sent2 __last2, __is_permutation(_Iter1 __first1, _Sent1 __last1, _Iter2 __first2, _Sent2 __last2,
_Pred&& __pred, _Proj1&& __proj1, _Proj2&& __proj2) { _Pred&& __pred, _Proj1&& __proj1, _Proj2&& __proj2) {
return std::__is_permutation<_AlgPolicy>( return std::__is_permutation<_AlgPolicy>(
std::move(__first1), std::move(__last1), std::move(__first2), std::move(__last2), std::move(__first1), std::move(__last1), std::move(__first2), std::move(__last2),
__pred, __proj1, __proj2, __pred, __proj1, __proj2,
_ConstTimeDistance<_Iter1, _Sent1, _Iter2, _Sent2>()); _ConstTimeDistance<_Iter1, _Sent1, _Iter2, _Sent2>());
} }
// Public interface // Public interface
// 2+1 iterators, predicate // 2+1 iterators, predicate
template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate> template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
_LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 bool _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20 bool
is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
_BinaryPredicate __pred) { _BinaryPredicate __pred) {
static_assert(__is_callable<_BinaryPredicate, decltype(*__first1), decltype(*__first2)>::value, static_assert(__is_callable<_BinaryPredicate, decltype(*__first1), decltype(*__first2)>::value,
"The predicate has to be callable"); "The predicate has to be callable");
return std::__is_permutation<_ClassicAlgPolicy>( return std::__is_permutation<_ClassicAlgPolicy>(
std::move(__first1), std::move(__last1), std::move(__first2), __pred); std::move(__first1), std::move(__last1), std::move(__first2), __pred);
} }
// 2+1 iterators // 2+1 iterators
template <class _ForwardIterator1, class _ForwardIterator2> template <class _ForwardIterator1, class _ForwardIterator2>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 bool _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20 bool
is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2) { is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2) {
using __v1 = __iter_value_type<_ForwardIterator1>; using __v1 = __iter_value_type<_ForwardIterator1>;
using __v2 = __iter_value_type<_ForwardIterator2>; using __v2 = __iter_value_type<_ForwardIterator2>;
return std::is_permutation(__first1, __last1, __first2, __equal_to<__v1, __v2>()); return std::is_permutation(__first1, __last1, __first2, __equal_to<__v1, __v2>());
} }
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER > 11
// 2+2 iterators // 2+2 iterators
template <class _ForwardIterator1, class _ForwardIterator2> template <class _ForwardIterator1, class _ForwardIterator2>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 bool _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20 bool
is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
_ForwardIterator2 __last2) { _ForwardIterator2 __last2) {
using __v1 = __iter_value_type<_ForwardIterator1>; using __v1 = __iter_value_type<_ForwardIterator1>;
using __v2 = __iter_value_type<_ForwardIterator2>; using __v2 = __iter_value_type<_ForwardIterator2>;
return std::__is_permutation<_ClassicAlgPolicy>( return std::__is_permutation<_ClassicAlgPolicy>(
std::move(__first1), std::move(__last1), std::move(__first2), std::move(__last2), std::move(__first1), std::move(__last1), std::move(__first2), std::move(__last2),
__equal_to<__v1, __v2>(), __identity(), __identity()); __equal_to<__v1, __v2>(), __identity(), __identity());
} }
// 2+2 iterators, predicate // 2+2 iterators, predicate
template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate> template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 bool _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20 bool
is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
_ForwardIterator2 __last2, _BinaryPredicate __pred) { _ForwardIterator2 __last2, _BinaryPredicate __pred) {
static_assert(__is_callable<_BinaryPredicate, decltype(*__first1), decltype(*__first2)>::value, static_assert(__is_callable<_BinaryPredicate, decltype(*__first1), decltype(*__first2)>::value,
"The predicate has to be callable"); "The predicate has to be callable");
return std::__is_permutation<_ClassicAlgPolicy>( return std::__is_permutation<_ClassicAlgPolicy>(
std::move(__first1), std::move(__last1), std::move(__first2), std::move(__last2), std::move(__first1), std::move(__last1), std::move(__first2), std::move(__last2),
__pred, __identity(), __identity()); __pred, __identity(), __identity());
} }
#endif // _LIBCPP_STD_VER > 11 #endif // _LIBCPP_STD_VER > 11
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_IS_PERMUTATION_H #endif // _LIBCPP___ALGORITHM_IS_PERMUTATION_H

libcxx/include/__algorithm/is_sorted.h

Show All 17 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 _ForwardIterator, class _Compare> template <class _ForwardIterator, class _Compare>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_NODISCARD_EXT inline
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
bool bool
is_sorted(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp) is_sorted(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp)
{ {
typedef typename __comp_ref_type<_Compare>::type _Comp_ref; typedef typename __comp_ref_type<_Compare>::type _Comp_ref;
return _VSTD::__is_sorted_until<_Comp_ref>(__first, __last, __comp) == __last; return _VSTD::__is_sorted_until<_Comp_ref>(__first, __last, __comp) == __last;
} }
template<class _ForwardIterator> template<class _ForwardIterator>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_NODISCARD_EXT inline
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
bool bool
is_sorted(_ForwardIterator __first, _ForwardIterator __last) is_sorted(_ForwardIterator __first, _ForwardIterator __last)
{ {
return _VSTD::is_sorted(__first, __last, __less<typename iterator_traits<_ForwardIterator>::value_type>()); return _VSTD::is_sorted(__first, __last, __less<typename iterator_traits<_ForwardIterator>::value_type>());
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_IS_SORTED_H #endif // _LIBCPP___ALGORITHM_IS_SORTED_H

libcxx/include/__algorithm/is_sorted_until.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 _Compare, class _ForwardIterator> template <class _Compare, class _ForwardIterator>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _ForwardIterator _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20 _ForwardIterator
__is_sorted_until(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp) __is_sorted_until(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp)
{ {
if (__first != __last) if (__first != __last)
{ {
_ForwardIterator __i = __first; _ForwardIterator __i = __first;
while (++__i != __last) while (++__i != __last)
{ {
if (__comp(*__i, *__first)) if (__comp(*__i, *__first))
return __i; return __i;
__first = __i; __first = __i;
} }
} }
return __last; return __last;
} }
template <class _ForwardIterator, class _Compare> template <class _ForwardIterator, class _Compare>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _ForwardIterator _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20 _ForwardIterator
is_sorted_until(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp) is_sorted_until(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp)
{ {
typedef typename __comp_ref_type<_Compare>::type _Comp_ref; typedef typename __comp_ref_type<_Compare>::type _Comp_ref;
return _VSTD::__is_sorted_until<_Comp_ref>(__first, __last, __comp); return _VSTD::__is_sorted_until<_Comp_ref>(__first, __last, __comp);
} }
template<class _ForwardIterator> template<class _ForwardIterator>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _ForwardIterator _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20 _ForwardIterator
is_sorted_until(_ForwardIterator __first, _ForwardIterator __last) is_sorted_until(_ForwardIterator __first, _ForwardIterator __last)
{ {
return _VSTD::is_sorted_until(__first, __last, __less<typename iterator_traits<_ForwardIterator>::value_type>()); return _VSTD::is_sorted_until(__first, __last, __less<typename iterator_traits<_ForwardIterator>::value_type>());
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_IS_SORTED_UNTIL_H #endif // _LIBCPP___ALGORITHM_IS_SORTED_UNTIL_H

libcxx/include/__algorithm/iter_swap.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 _ForwardIterator1, class _ForwardIterator2> template <class _ForwardIterator1, class _ForwardIterator2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 void iter_swap(_ForwardIterator1 __a, inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 void iter_swap(_ForwardIterator1 __a,
_ForwardIterator2 __b) _ForwardIterator2 __b)
// _NOEXCEPT_(_NOEXCEPT_(swap(*__a, *__b))) // _NOEXCEPT_(_NOEXCEPT_(swap(*__a, *__b)))
_NOEXCEPT_(_NOEXCEPT_(swap(*declval<_ForwardIterator1>(), *declval<_ForwardIterator2>()))) { _NOEXCEPT_(_NOEXCEPT_(swap(*declval<_ForwardIterator1>(), *declval<_ForwardIterator2>()))) {
swap(*__a, *__b); swap(*__a, *__b);
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_ITER_SWAP_H #endif // _LIBCPP___ALGORITHM_ITER_SWAP_H

libcxx/include/__algorithm/iterator_operations.h

Show First 20 Lines • Show All 70 Lines • ▼ Show 20 Linesstruct _IterOps<_ClassicAlgPolicy> {
template <class _Iter> template <class _Iter>
using __iterator_category = typename iterator_traits<_Iter>::iterator_category; using __iterator_category = typename iterator_traits<_Iter>::iterator_category;
template <class _Iter> template <class _Iter>
using __difference_type = typename iterator_traits<_Iter>::difference_type; using __difference_type = typename iterator_traits<_Iter>::difference_type;
// advance // advance
template <class _Iter, class _Distance> template <class _Iter, class _Distance>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14
static void advance(_Iter& __iter, _Distance __count) { static void advance(_Iter& __iter, _Distance __count) {
std::advance(__iter, __count); std::advance(__iter, __count);
} }
// distance // distance
template <class _Iter> template <class _Iter>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14
static typename iterator_traits<_Iter>::difference_type distance(_Iter __first, _Iter __last) { static typename iterator_traits<_Iter>::difference_type distance(_Iter __first, _Iter __last) {
return std::distance(__first, __last); return std::distance(__first, __last);
} }
template <class _Iter> template <class _Iter>
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_AFTER_CXX11 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_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<__uncvref_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_AFTER_CXX11 static _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14 static
// If the result of dereferencing `_Iter` is a reference type, deduce the result of calling `std::move` on it. Note // If the result of dereferencing `_Iter` is a reference type, deduce the result of calling `std::move` on it. Note
// that the C++03 mode doesn't support `decltype(auto)` as the return type. // that the C++03 mode doesn't support `decltype(auto)` as the return type.
__enable_if_t< __enable_if_t<
is_reference<__deref_t<_Iter> >::value, is_reference<__deref_t<_Iter> >::value,
__move_t<_Iter> > __move_t<_Iter> >
__iter_move(_Iter&& __i) { __iter_move(_Iter&& __i) {
__validate_iter_reference<_Iter>(); __validate_iter_reference<_Iter>();
return std::move(*std::forward<_Iter>(__i)); return std::move(*std::forward<_Iter>(__i));
} }
template <class _Iter> template <class _Iter>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 static _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14 static
// If the result of dereferencing `_Iter` is a value type, deduce the return value of this function to also be a // If the result of dereferencing `_Iter` is a value type, deduce the return value of this function to also be a
// value -- otherwise, after `operator*` returns a temporary, this function would return a dangling reference to that // value -- otherwise, after `operator*` returns a temporary, this function would return a dangling reference to that
// temporary. Note that the C++03 mode doesn't support `auto` as the return type. // temporary. Note that the C++03 mode doesn't support `auto` as the return type.
__enable_if_t< __enable_if_t<
!is_reference<__deref_t<_Iter> >::value, !is_reference<__deref_t<_Iter> >::value,
__deref_t<_Iter> > __deref_t<_Iter> >
__iter_move(_Iter&& __i) { __iter_move(_Iter&& __i) {
__validate_iter_reference<_Iter>(); __validate_iter_reference<_Iter>();
return *std::forward<_Iter>(__i); return *std::forward<_Iter>(__i);
} }
// iter_swap // iter_swap
template <class _Iter1, class _Iter2> template <class _Iter1, class _Iter2>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14
static void iter_swap(_Iter1&& __a, _Iter2&& __b) { static void iter_swap(_Iter1&& __a, _Iter2&& __b) {
std::iter_swap(std::forward<_Iter1>(__a), std::forward<_Iter2>(__b)); std::iter_swap(std::forward<_Iter1>(__a), std::forward<_Iter2>(__b));
} }
// next // next
template <class _Iterator> template <class _Iterator>
_LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR_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_AFTER_CXX11 _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR_CXX14
__uncvref_t<_Iter> next(_Iter&& __it, __uncvref_t<_Iter> next(_Iter&& __it,
typename iterator_traits<__uncvref_t<_Iter> >::difference_type __n = 1) { typename iterator_traits<__uncvref_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_AFTER_CXX11 _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR_CXX14
__uncvref_t<_Iter> prev(_Iter&& __iter, __uncvref_t<_Iter> prev(_Iter&& __iter,
typename iterator_traits<__uncvref_t<_Iter> >::difference_type __n = 1) { typename iterator_traits<__uncvref_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_AFTER_CXX11 _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR_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/lexicographical_compare.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 _Compare, class _InputIterator1, class _InputIterator2> template <class _Compare, class _InputIterator1, class _InputIterator2>
_LIBCPP_CONSTEXPR_AFTER_CXX17 bool _LIBCPP_CONSTEXPR_CXX20 bool
__lexicographical_compare(_InputIterator1 __first1, _InputIterator1 __last1, __lexicographical_compare(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2, _Compare __comp) _InputIterator2 __first2, _InputIterator2 __last2, _Compare __comp)
{ {
for (; __first2 != __last2; ++__first1, (void) ++__first2) for (; __first2 != __last2; ++__first1, (void) ++__first2)
{ {
if (__first1 == __last1 || __comp(*__first1, *__first2)) if (__first1 == __last1 || __comp(*__first1, *__first2))
return true; return true;
if (__comp(*__first2, *__first1)) if (__comp(*__first2, *__first1))
return false; return false;
} }
return false; return false;
} }
template <class _InputIterator1, class _InputIterator2, class _Compare> template <class _InputIterator1, class _InputIterator2, class _Compare>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_NODISCARD_EXT inline
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
bool bool
lexicographical_compare(_InputIterator1 __first1, _InputIterator1 __last1, lexicographical_compare(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2, _Compare __comp) _InputIterator2 __first2, _InputIterator2 __last2, _Compare __comp)
{ {
typedef typename __comp_ref_type<_Compare>::type _Comp_ref; typedef typename __comp_ref_type<_Compare>::type _Comp_ref;
return _VSTD::__lexicographical_compare<_Comp_ref>(__first1, __last1, __first2, __last2, __comp); return _VSTD::__lexicographical_compare<_Comp_ref>(__first1, __last1, __first2, __last2, __comp);
} }
template <class _InputIterator1, class _InputIterator2> template <class _InputIterator1, class _InputIterator2>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_NODISCARD_EXT inline
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
bool bool
lexicographical_compare(_InputIterator1 __first1, _InputIterator1 __last1, lexicographical_compare(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2) _InputIterator2 __first2, _InputIterator2 __last2)
{ {
return _VSTD::lexicographical_compare(__first1, __last1, __first2, __last2, return _VSTD::lexicographical_compare(__first1, __last1, __first2, __last2,
__less<typename iterator_traits<_InputIterator1>::value_type, __less<typename iterator_traits<_InputIterator1>::value_type,
typename iterator_traits<_InputIterator2>::value_type>()); typename iterator_traits<_InputIterator2>::value_type>());
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_LEXICOGRAPHICAL_COMPARE_H #endif // _LIBCPP___ALGORITHM_LEXICOGRAPHICAL_COMPARE_H

libcxx/include/__algorithm/lower_bound.h

Show All 23 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 _AlgPolicy, class _Iter, class _Sent, class _Type, class _Proj, class _Comp> template <class _AlgPolicy, class _Iter, class _Sent, class _Type, class _Proj, class _Comp>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
_Iter __lower_bound_impl(_Iter __first, _Sent __last, const _Type& __value, _Comp& __comp, _Proj& __proj) { _Iter __lower_bound_impl(_Iter __first, _Sent __last, const _Type& __value, _Comp& __comp, _Proj& __proj) {
auto __len = _IterOps<_AlgPolicy>::distance(__first, __last); auto __len = _IterOps<_AlgPolicy>::distance(__first, __last);
while (__len != 0) { while (__len != 0) {
auto __l2 = std::__half_positive(__len); auto __l2 = std::__half_positive(__len);
_Iter __m = __first; _Iter __m = __first;
_IterOps<_AlgPolicy>::advance(__m, __l2); _IterOps<_AlgPolicy>::advance(__m, __l2);
if (std::__invoke(__comp, std::__invoke(__proj, *__m), __value)) { if (std::__invoke(__comp, std::__invoke(__proj, *__m), __value)) {
__first = ++__m; __first = ++__m;
__len -= __l2 + 1; __len -= __l2 + 1;
} else { } else {
__len = __l2; __len = __l2;
} }
} }
return __first; return __first;
} }
template <class _ForwardIterator, class _Tp, class _Compare> template <class _ForwardIterator, class _Tp, class _Compare>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
_ForwardIterator lower_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value, _Compare __comp) { _ForwardIterator lower_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value, _Compare __comp) {
static_assert(__is_callable<_Compare, decltype(*__first), const _Tp&>::value, static_assert(__is_callable<_Compare, decltype(*__first), const _Tp&>::value,
"The comparator has to be callable"); "The comparator has to be callable");
auto __proj = std::__identity(); auto __proj = std::__identity();
return std::__lower_bound_impl<_ClassicAlgPolicy>(__first, __last, __value, __comp, __proj); return std::__lower_bound_impl<_ClassicAlgPolicy>(__first, __last, __value, __comp, __proj);
} }
template <class _ForwardIterator, class _Tp> template <class _ForwardIterator, class _Tp>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
_ForwardIterator lower_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) { _ForwardIterator lower_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) {
return std::lower_bound(__first, __last, __value, return std::lower_bound(__first, __last, __value,
__less<typename iterator_traits<_ForwardIterator>::value_type, _Tp>()); __less<typename iterator_traits<_ForwardIterator>::value_type, _Tp>());
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_LOWER_BOUND_H #endif // _LIBCPP___ALGORITHM_LOWER_BOUND_H

libcxx/include/__algorithm/make_heap.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
template <class _AlgPolicy, class _Compare, class _RandomAccessIterator> template <class _AlgPolicy, class _Compare, class _RandomAccessIterator>
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14
void __make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare&& __comp) { void __make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare&& __comp) {
using _CompRef = typename __comp_ref_type<_Compare>::type; using _CompRef = typename __comp_ref_type<_Compare>::type;
_CompRef __comp_ref = __comp; _CompRef __comp_ref = __comp;
using difference_type = typename iterator_traits<_RandomAccessIterator>::difference_type; using difference_type = typename iterator_traits<_RandomAccessIterator>::difference_type;
difference_type __n = __last - __first; difference_type __n = __last - __first;
if (__n > 1) { if (__n > 1) {
// start from the first parent, there is no need to consider children // start from the first parent, there is no need to consider children
for (difference_type __start = (__n - 2) / 2; __start >= 0; --__start) { for (difference_type __start = (__n - 2) / 2; __start >= 0; --__start) {
std::__sift_down<_AlgPolicy>(__first, __comp_ref, __n, __first + __start); std::__sift_down<_AlgPolicy>(__first, __comp_ref, __n, __first + __start);
} }
} }
} }
template <class _RandomAccessIterator, class _Compare> template <class _RandomAccessIterator, class _Compare>
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
void make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) { void make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) {
std::__make_heap<_ClassicAlgPolicy>(std::move(__first), std::move(__last), __comp); std::__make_heap<_ClassicAlgPolicy>(std::move(__first), std::move(__last), __comp);
} }
template <class _RandomAccessIterator> template <class _RandomAccessIterator>
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
void make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) { void make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) {
std::make_heap(std::move(__first), std::move(__last), std::make_heap(std::move(__first), std::move(__last),
__less<typename iterator_traits<_RandomAccessIterator>::value_type>()); __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_MAKE_HEAP_H #endif // _LIBCPP___ALGORITHM_MAKE_HEAP_H

libcxx/include/__algorithm/max.h

Show All 20 Lines
_LIBCPP_PUSH_MACROS _LIBCPP_PUSH_MACROS
#include <__undef_macros> #include <__undef_macros>
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp, class _Compare> template <class _Tp, class _Compare>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_NODISCARD_EXT inline
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
const _Tp& const _Tp&
max(const _Tp& __a, const _Tp& __b, _Compare __comp) max(const _Tp& __a, const _Tp& __b, _Compare __comp)
{ {
return __comp(__a, __b) ? __b : __a; return __comp(__a, __b) ? __b : __a;
} }
template <class _Tp> template <class _Tp>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_NODISCARD_EXT inline
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
const _Tp& const _Tp&
max(const _Tp& __a, const _Tp& __b) max(const _Tp& __a, const _Tp& __b)
{ {
return _VSTD::max(__a, __b, __less<_Tp>()); return _VSTD::max(__a, __b, __less<_Tp>());
} }
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
template<class _Tp, class _Compare> template<class _Tp, class _Compare>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_NODISCARD_EXT inline
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
_Tp _Tp
max(initializer_list<_Tp> __t, _Compare __comp) max(initializer_list<_Tp> __t, _Compare __comp)
{ {
typedef typename __comp_ref_type<_Compare>::type _Comp_ref; typedef typename __comp_ref_type<_Compare>::type _Comp_ref;
return *_VSTD::__max_element<_Comp_ref>(__t.begin(), __t.end(), __comp); return *_VSTD::__max_element<_Comp_ref>(__t.begin(), __t.end(), __comp);
} }
template<class _Tp> template<class _Tp>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_NODISCARD_EXT inline
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
_Tp _Tp
max(initializer_list<_Tp> __t) max(initializer_list<_Tp> __t)
{ {
return *_VSTD::max_element(__t.begin(), __t.end(), __less<_Tp>()); return *_VSTD::max_element(__t.begin(), __t.end(), __less<_Tp>());
} }
#endif // _LIBCPP_CXX03_LANG #endif // _LIBCPP_CXX03_LANG
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
_LIBCPP_POP_MACROS _LIBCPP_POP_MACROS
#endif // _LIBCPP___ALGORITHM_MAX_H #endif // _LIBCPP___ALGORITHM_MAX_H

libcxx/include/__algorithm/max_element.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 _Compare, class _ForwardIterator> template <class _Compare, class _ForwardIterator>
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 _ForwardIterator inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14 _ForwardIterator
__max_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp) __max_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp)
{ {
static_assert(__is_cpp17_forward_iterator<_ForwardIterator>::value, static_assert(__is_cpp17_forward_iterator<_ForwardIterator>::value,
"std::max_element requires a ForwardIterator"); "std::max_element requires a ForwardIterator");
if (__first != __last) if (__first != __last)
{ {
_ForwardIterator __i = __first; _ForwardIterator __i = __first;
while (++__i != __last) while (++__i != __last)
if (__comp(*__first, *__i)) if (__comp(*__first, *__i))
__first = __i; __first = __i;
} }
return __first; return __first;
} }
template <class _ForwardIterator, class _Compare> template <class _ForwardIterator, class _Compare>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 _ForwardIterator _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14 _ForwardIterator
max_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp) max_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp)
{ {
typedef typename __comp_ref_type<_Compare>::type _Comp_ref; typedef typename __comp_ref_type<_Compare>::type _Comp_ref;
return _VSTD::__max_element<_Comp_ref>(__first, __last, __comp); return _VSTD::__max_element<_Comp_ref>(__first, __last, __comp);
} }
template <class _ForwardIterator> template <class _ForwardIterator>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 _ForwardIterator _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14 _ForwardIterator
max_element(_ForwardIterator __first, _ForwardIterator __last) max_element(_ForwardIterator __first, _ForwardIterator __last)
{ {
return _VSTD::max_element(__first, __last, return _VSTD::max_element(__first, __last,
__less<typename iterator_traits<_ForwardIterator>::value_type>()); __less<typename iterator_traits<_ForwardIterator>::value_type>());
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_MAX_ELEMENT_H #endif // _LIBCPP___ALGORITHM_MAX_ELEMENT_H

libcxx/include/__algorithm/merge.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 _Compare, class _InputIterator1, class _InputIterator2, class _OutputIterator> template <class _Compare, class _InputIterator1, class _InputIterator2, class _OutputIterator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
_OutputIterator _OutputIterator
__merge(_InputIterator1 __first1, _InputIterator1 __last1, __merge(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp) _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp)
{ {
for (; __first1 != __last1; ++__result) for (; __first1 != __last1; ++__result)
{ {
if (__first2 == __last2) if (__first2 == __last2)
return _VSTD::copy(__first1, __last1, __result); return _VSTD::copy(__first1, __last1, __result);
if (__comp(*__first2, *__first1)) if (__comp(*__first2, *__first1))
{ {
*__result = *__first2; *__result = *__first2;
++__first2; ++__first2;
} }
else else
{ {
*__result = *__first1; *__result = *__first1;
++__first1; ++__first1;
} }
} }
return _VSTD::copy(__first2, __last2, __result); return _VSTD::copy(__first2, __last2, __result);
} }
template <class _InputIterator1, class _InputIterator2, class _OutputIterator, class _Compare> template <class _InputIterator1, class _InputIterator2, class _OutputIterator, class _Compare>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
_OutputIterator _OutputIterator
merge(_InputIterator1 __first1, _InputIterator1 __last1, merge(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp) _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp)
{ {
typedef typename __comp_ref_type<_Compare>::type _Comp_ref; typedef typename __comp_ref_type<_Compare>::type _Comp_ref;
return _VSTD::__merge<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __comp); return _VSTD::__merge<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __comp);
} }
template <class _InputIterator1, class _InputIterator2, class _OutputIterator> template <class _InputIterator1, class _InputIterator2, class _OutputIterator>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
_OutputIterator _OutputIterator
merge(_InputIterator1 __first1, _InputIterator1 __last1, merge(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result) _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result)
{ {
typedef typename iterator_traits<_InputIterator1>::value_type __v1; typedef typename iterator_traits<_InputIterator1>::value_type __v1;
typedef typename iterator_traits<_InputIterator2>::value_type __v2; typedef typename iterator_traits<_InputIterator2>::value_type __v2;
return _VSTD::merge(__first1, __last1, __first2, __last2, __result, __less<__v1, __v2>()); return _VSTD::merge(__first1, __last1, __first2, __last2, __result, __less<__v1, __v2>());
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_MERGE_H #endif // _LIBCPP___ALGORITHM_MERGE_H

libcxx/include/__algorithm/min.h

Show All 20 Lines
_LIBCPP_PUSH_MACROS _LIBCPP_PUSH_MACROS
#include <__undef_macros> #include <__undef_macros>
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp, class _Compare> template <class _Tp, class _Compare>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_NODISCARD_EXT inline
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
const _Tp& const _Tp&
min(const _Tp& __a, const _Tp& __b, _Compare __comp) min(const _Tp& __a, const _Tp& __b, _Compare __comp)
{ {
return __comp(__b, __a) ? __b : __a; return __comp(__b, __a) ? __b : __a;
} }
template <class _Tp> template <class _Tp>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_NODISCARD_EXT inline
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
const _Tp& const _Tp&
min(const _Tp& __a, const _Tp& __b) min(const _Tp& __a, const _Tp& __b)
{ {
return _VSTD::min(__a, __b, __less<_Tp>()); return _VSTD::min(__a, __b, __less<_Tp>());
} }
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
template<class _Tp, class _Compare> template<class _Tp, class _Compare>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_NODISCARD_EXT inline
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
_Tp _Tp
min(initializer_list<_Tp> __t, _Compare __comp) min(initializer_list<_Tp> __t, _Compare __comp)
{ {
typedef typename __comp_ref_type<_Compare>::type _Comp_ref; typedef typename __comp_ref_type<_Compare>::type _Comp_ref;
return *_VSTD::__min_element<_Comp_ref>(__t.begin(), __t.end(), __comp); return *_VSTD::__min_element<_Comp_ref>(__t.begin(), __t.end(), __comp);
} }
template<class _Tp> template<class _Tp>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_NODISCARD_EXT inline
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
_Tp _Tp
min(initializer_list<_Tp> __t) min(initializer_list<_Tp> __t)
{ {
return *_VSTD::min_element(__t.begin(), __t.end(), __less<_Tp>()); return *_VSTD::min_element(__t.begin(), __t.end(), __less<_Tp>());
} }
#endif // _LIBCPP_CXX03_LANG #endif // _LIBCPP_CXX03_LANG
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
_LIBCPP_POP_MACROS _LIBCPP_POP_MACROS
#endif // _LIBCPP___ALGORITHM_MIN_H #endif // _LIBCPP___ALGORITHM_MIN_H

libcxx/include/__algorithm/min_element.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 _Comp, class _Iter, class _Sent, class _Proj> template <class _Comp, class _Iter, class _Sent, class _Proj>
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14
_Iter __min_element(_Iter __first, _Sent __last, _Comp __comp, _Proj& __proj) { _Iter __min_element(_Iter __first, _Sent __last, _Comp __comp, _Proj& __proj) {
if (__first == __last) if (__first == __last)
return __first; return __first;
_Iter __i = __first; _Iter __i = __first;
while (++__i != __last) while (++__i != __last)
if (std::__invoke(__comp, std::__invoke(__proj, *__i), std::__invoke(__proj, *__first))) if (std::__invoke(__comp, std::__invoke(__proj, *__i), std::__invoke(__proj, *__first)))
__first = __i; __first = __i;
return __first; return __first;
} }
template <class _Comp, class _Iter, class _Sent> template <class _Comp, class _Iter, class _Sent>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14
_Iter __min_element(_Iter __first, _Sent __last, _Comp __comp) { _Iter __min_element(_Iter __first, _Sent __last, _Comp __comp) {
auto __proj = __identity(); auto __proj = __identity();
return std::__min_element<_Comp>(std::move(__first), std::move(__last), __comp, __proj); return std::__min_element<_Comp>(std::move(__first), std::move(__last), __comp, __proj);
} }
template <class _ForwardIterator, class _Compare> template <class _ForwardIterator, class _Compare>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 _ForwardIterator _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14 _ForwardIterator
min_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp) min_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp)
{ {
static_assert(__is_cpp17_forward_iterator<_ForwardIterator>::value, static_assert(__is_cpp17_forward_iterator<_ForwardIterator>::value,
"std::min_element requires a ForwardIterator"); "std::min_element requires a ForwardIterator");
static_assert(__is_callable<_Compare, decltype(*__first), decltype(*__first)>::value, static_assert(__is_callable<_Compare, decltype(*__first), decltype(*__first)>::value,
"The comparator has to be callable"); "The comparator has to be callable");
typedef typename __comp_ref_type<_Compare>::type _Comp_ref; typedef typename __comp_ref_type<_Compare>::type _Comp_ref;
return std::__min_element<_Comp_ref>(std::move(__first), std::move(__last), __comp); return std::__min_element<_Comp_ref>(std::move(__first), std::move(__last), __comp);
} }
template <class _ForwardIterator> template <class _ForwardIterator>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 _ForwardIterator _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14 _ForwardIterator
min_element(_ForwardIterator __first, _ForwardIterator __last) min_element(_ForwardIterator __first, _ForwardIterator __last)
{ {
return _VSTD::min_element(__first, __last, return _VSTD::min_element(__first, __last,
__less<typename iterator_traits<_ForwardIterator>::value_type>()); __less<typename iterator_traits<_ForwardIterator>::value_type>());
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_MIN_ELEMENT_H #endif // _LIBCPP___ALGORITHM_MIN_ELEMENT_H

libcxx/include/__algorithm/minmax.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, class _Compare> template<class _Tp, class _Compare>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_NODISCARD_EXT inline
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
pair<const _Tp&, const _Tp&> pair<const _Tp&, const _Tp&>
minmax(const _Tp& __a, const _Tp& __b, _Compare __comp) minmax(const _Tp& __a, const _Tp& __b, _Compare __comp)
{ {
return __comp(__b, __a) ? pair<const _Tp&, const _Tp&>(__b, __a) : return __comp(__b, __a) ? pair<const _Tp&, const _Tp&>(__b, __a) :
pair<const _Tp&, const _Tp&>(__a, __b); pair<const _Tp&, const _Tp&>(__a, __b);
} }
template<class _Tp> template<class _Tp>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_NODISCARD_EXT inline
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
pair<const _Tp&, const _Tp&> pair<const _Tp&, const _Tp&>
minmax(const _Tp& __a, const _Tp& __b) minmax(const _Tp& __a, const _Tp& __b)
{ {
return std::minmax(__a, __b, __less<_Tp>()); return std::minmax(__a, __b, __less<_Tp>());
} }
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
template<class _Tp, class _Compare> template<class _Tp, class _Compare>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14
pair<_Tp, _Tp> minmax(initializer_list<_Tp> __t, _Compare __comp) { pair<_Tp, _Tp> minmax(initializer_list<_Tp> __t, _Compare __comp) {
static_assert(__is_callable<_Compare, _Tp, _Tp>::value, "The comparator has to be callable"); static_assert(__is_callable<_Compare, _Tp, _Tp>::value, "The comparator has to be callable");
__identity __proj; __identity __proj;
auto __ret = std::__minmax_element_impl(__t.begin(), __t.end(), __comp, __proj); auto __ret = std::__minmax_element_impl(__t.begin(), __t.end(), __comp, __proj);
return pair<_Tp, _Tp>(*__ret.first, *__ret.second); return pair<_Tp, _Tp>(*__ret.first, *__ret.second);
} }
template<class _Tp> template<class _Tp>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_NODISCARD_EXT inline
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
pair<_Tp, _Tp> pair<_Tp, _Tp>
minmax(initializer_list<_Tp> __t) minmax(initializer_list<_Tp> __t)
{ {
return std::minmax(__t, __less<_Tp>()); return std::minmax(__t, __less<_Tp>());
} }
#endif // _LIBCPP_CXX03_LANG #endif // _LIBCPP_CXX03_LANG
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_MINMAX_H #endif // _LIBCPP___ALGORITHM_MINMAX_H

libcxx/include/__algorithm/minmax_element.h

Show All 26 Linesclass _MinmaxElementLessFunc {
_Comp& __comp_; _Comp& __comp_;
_Proj& __proj_; _Proj& __proj_;
public: public:
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR
_MinmaxElementLessFunc(_Comp& __comp, _Proj& __proj) : __comp_(__comp), __proj_(__proj) {} _MinmaxElementLessFunc(_Comp& __comp, _Proj& __proj) : __comp_(__comp), __proj_(__proj) {}
template <class _Iter> template <class _Iter>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14
bool operator()(_Iter& __it1, _Iter& __it2) { bool operator()(_Iter& __it1, _Iter& __it2) {
return std::__invoke(__comp_, std::__invoke(__proj_, *__it1), std::__invoke(__proj_, *__it2)); return std::__invoke(__comp_, std::__invoke(__proj_, *__it1), std::__invoke(__proj_, *__it2));
} }
}; };
template <class _Iter, class _Sent, class _Proj, class _Comp> template <class _Iter, class _Sent, class _Proj, class _Comp>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14
pair<_Iter, _Iter> __minmax_element_impl(_Iter __first, _Sent __last, _Comp& __comp, _Proj& __proj) { pair<_Iter, _Iter> __minmax_element_impl(_Iter __first, _Sent __last, _Comp& __comp, _Proj& __proj) {
auto __less = _MinmaxElementLessFunc<_Comp, _Proj>(__comp, __proj); auto __less = _MinmaxElementLessFunc<_Comp, _Proj>(__comp, __proj);
pair<_Iter, _Iter> __result(__first, __first); pair<_Iter, _Iter> __result(__first, __first);
if (__first == __last || ++__first == __last) if (__first == __last || ++__first == __last)
return __result; return __result;
if (__less(__first, __result.first)) if (__less(__first, __result.first))
Show All 23 Lines if (!__less(__i, __result.second))
__result.second = __first; __result.second = __first;
} }
} }
return __result; return __result;
} }
template <class _ForwardIterator, class _Compare> template <class _ForwardIterator, class _Compare>
_LIBCPP_NODISCARD_EXT _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_NODISCARD_EXT _LIBCPP_CONSTEXPR_CXX14
pair<_ForwardIterator, _ForwardIterator> pair<_ForwardIterator, _ForwardIterator>
minmax_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp) { minmax_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp) {
static_assert(__is_cpp17_forward_iterator<_ForwardIterator>::value, static_assert(__is_cpp17_forward_iterator<_ForwardIterator>::value,
"std::minmax_element requires a ForwardIterator"); "std::minmax_element requires a ForwardIterator");
static_assert(__is_callable<_Compare, decltype(*__first), decltype(*__first)>::value, static_assert(__is_callable<_Compare, decltype(*__first), decltype(*__first)>::value,
"The comparator has to be callable"); "The comparator has to be callable");
auto __proj = __identity(); auto __proj = __identity();
return std::__minmax_element_impl(__first, __last, __comp, __proj); return std::__minmax_element_impl(__first, __last, __comp, __proj);
} }
template <class _ForwardIterator> template <class _ForwardIterator>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14
pair<_ForwardIterator, _ForwardIterator> minmax_element(_ForwardIterator __first, _ForwardIterator __last) { pair<_ForwardIterator, _ForwardIterator> minmax_element(_ForwardIterator __first, _ForwardIterator __last) {
return std::minmax_element(__first, __last, __less<typename iterator_traits<_ForwardIterator>::value_type>()); return std::minmax_element(__first, __last, __less<typename iterator_traits<_ForwardIterator>::value_type>());
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_MINMAX_ELEMENT_H #endif // _LIBCPP___ALGORITHM_MINMAX_ELEMENT_H

libcxx/include/__algorithm/mismatch.h

Show All 17 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 _InputIterator1, class _InputIterator2, class _BinaryPredicate> template <class _InputIterator1, class _InputIterator2, class _BinaryPredicate>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR_AFTER_CXX17 pair<_InputIterator1, _InputIterator2> _LIBCPP_CONSTEXPR_CXX20 pair<_InputIterator1, _InputIterator2>
mismatch(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _BinaryPredicate __pred) { mismatch(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _BinaryPredicate __pred) {
for (; __first1 != __last1; ++__first1, (void)++__first2) for (; __first1 != __last1; ++__first1, (void)++__first2)
if (!__pred(*__first1, *__first2)) if (!__pred(*__first1, *__first2))
break; break;
return pair<_InputIterator1, _InputIterator2>(__first1, __first2); return pair<_InputIterator1, _InputIterator2>(__first1, __first2);
} }
template <class _InputIterator1, class _InputIterator2> template <class _InputIterator1, class _InputIterator2>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR_AFTER_CXX17 pair<_InputIterator1, _InputIterator2> _LIBCPP_CONSTEXPR_CXX20 pair<_InputIterator1, _InputIterator2>
mismatch(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2) { mismatch(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2) {
typedef typename iterator_traits<_InputIterator1>::value_type __v1; typedef typename iterator_traits<_InputIterator1>::value_type __v1;
typedef typename iterator_traits<_InputIterator2>::value_type __v2; typedef typename iterator_traits<_InputIterator2>::value_type __v2;
return _VSTD::mismatch(__first1, __last1, __first2, __equal_to<__v1, __v2>()); return _VSTD::mismatch(__first1, __last1, __first2, __equal_to<__v1, __v2>());
} }
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER > 11
template <class _InputIterator1, class _InputIterator2, class _BinaryPredicate> template <class _InputIterator1, class _InputIterator2, class _BinaryPredicate>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR_AFTER_CXX17 pair<_InputIterator1, _InputIterator2> _LIBCPP_CONSTEXPR_CXX20 pair<_InputIterator1, _InputIterator2>
mismatch(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, mismatch(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2,
_BinaryPredicate __pred) { _BinaryPredicate __pred) {
for (; __first1 != __last1 && __first2 != __last2; ++__first1, (void)++__first2) for (; __first1 != __last1 && __first2 != __last2; ++__first1, (void)++__first2)
if (!__pred(*__first1, *__first2)) if (!__pred(*__first1, *__first2))
break; break;
return pair<_InputIterator1, _InputIterator2>(__first1, __first2); return pair<_InputIterator1, _InputIterator2>(__first1, __first2);
} }
template <class _InputIterator1, class _InputIterator2> template <class _InputIterator1, class _InputIterator2>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR_AFTER_CXX17 pair<_InputIterator1, _InputIterator2> _LIBCPP_CONSTEXPR_CXX20 pair<_InputIterator1, _InputIterator2>
mismatch(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2) { mismatch(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2) {
typedef typename iterator_traits<_InputIterator1>::value_type __v1; typedef typename iterator_traits<_InputIterator1>::value_type __v1;
typedef typename iterator_traits<_InputIterator2>::value_type __v2; typedef typename iterator_traits<_InputIterator2>::value_type __v2;
return _VSTD::mismatch(__first1, __last1, __first2, __last2, __equal_to<__v1, __v2>()); return _VSTD::mismatch(__first1, __last1, __first2, __last2, __equal_to<__v1, __v2>());
} }
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_MISMATCH_H #endif // _LIBCPP___ALGORITHM_MISMATCH_H

libcxx/include/__algorithm/move.h

Show All 22 Lines
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
// move // move
template <class _AlgPolicy, class _InIter, class _Sent, class _OutIter> template <class _AlgPolicy, class _InIter, class _Sent, class _OutIter>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
pair<_InIter, _OutIter> __move_impl(_InIter __first, _Sent __last, _OutIter __result) { pair<_InIter, _OutIter> __move_impl(_InIter __first, _Sent __last, _OutIter __result) {
while (__first != __last) { while (__first != __last) {
*__result = _IterOps<_AlgPolicy>::__iter_move(__first); *__result = _IterOps<_AlgPolicy>::__iter_move(__first);
++__first; ++__first;
++__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<typename remove_const<_InType>::type, _OutType>::value
&& is_trivially_move_assignable<_OutType>::value> > && is_trivially_move_assignable<_OutType>::value> >
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_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
) )
return std::__move_impl<_AlgPolicy, _InType*, _InType*, _OutType*>(__first, __last, __result); return std::__move_impl<_AlgPolicy, _InType*, _InType*, _OutType*>(__first, __last, __result);
Show All 15 Lines
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<typename remove_const<typename iterator_traits<_InIter>::value_type>::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_AFTER_CXX14 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_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,
reverse_iterator<_OutIter> __result) { reverse_iterator<_OutIter> __result) {
auto __first_base = std::__unwrap_iter(__first.base()); auto __first_base = std::__unwrap_iter(__first.base());
auto __last_base = std::__unwrap_iter(__last.base()); auto __last_base = std::__unwrap_iter(__last.base());
auto __result_base = std::__unwrap_iter(__result.base()); auto __result_base = std::__unwrap_iter(__result.base());
auto __result_first = __result_base - (__first_base - __last_base); auto __result_first = __result_base - (__first_base - __last_base);
std::__move_impl<_AlgPolicy>(__last_base, __first_base, __result_first); std::__move_impl<_AlgPolicy>(__last_base, __first_base, __result_first);
return std::make_pair(__last, reverse_iterator<_OutIter>(std::__rewrap_iter(__result.base(), __result_first))); return std::make_pair(__last, reverse_iterator<_OutIter>(std::__rewrap_iter(__result.base(), __result_first)));
} }
template <class _AlgPolicy, class _InIter, class _Sent, class _OutIter> template <class _AlgPolicy, class _InIter, class _Sent, class _OutIter>
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14
__enable_if_t<is_copy_constructible<_InIter>::value __enable_if_t<is_copy_constructible<_InIter>::value
&& is_copy_constructible<_Sent>::value && is_copy_constructible<_Sent>::value
&& is_copy_constructible<_OutIter>::value, pair<_InIter, _OutIter> > && is_copy_constructible<_OutIter>::value, pair<_InIter, _OutIter> >
__move(_InIter __first, _Sent __last, _OutIter __result) { __move(_InIter __first, _Sent __last, _OutIter __result) {
auto __ret = std::__move_impl<_AlgPolicy>( auto __ret = std::__move_impl<_AlgPolicy>(
std::__unwrap_iter(__first), std::__unwrap_iter(__last), std::__unwrap_iter(__result)); std::__unwrap_iter(__first), std::__unwrap_iter(__last), std::__unwrap_iter(__result));
return std::make_pair(std::__rewrap_iter(__first, __ret.first), std::__rewrap_iter(__result, __ret.second)); return std::make_pair(std::__rewrap_iter(__first, __ret.first), std::__rewrap_iter(__result, __ret.second));
} }
template <class _AlgPolicy, class _InIter, class _Sent, class _OutIter> template <class _AlgPolicy, class _InIter, class _Sent, class _OutIter>
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14
__enable_if_t<!is_copy_constructible<_InIter>::value __enable_if_t<!is_copy_constructible<_InIter>::value
|| !is_copy_constructible<_Sent>::value || !is_copy_constructible<_Sent>::value
|| !is_copy_constructible<_OutIter>::value, pair<_InIter, _OutIter> > || !is_copy_constructible<_OutIter>::value, pair<_InIter, _OutIter> >
__move(_InIter __first, _Sent __last, _OutIter __result) { __move(_InIter __first, _Sent __last, _OutIter __result) {
return std::__move_impl<_AlgPolicy>(std::move(__first), std::move(__last), std::move(__result)); return std::__move_impl<_AlgPolicy>(std::move(__first), std::move(__last), std::move(__result));
} }
template <class _InputIterator, class _OutputIterator> template <class _InputIterator, class _OutputIterator>
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
_OutputIterator move(_InputIterator __first, _InputIterator __last, _OutputIterator __result) { _OutputIterator move(_InputIterator __first, _InputIterator __last, _OutputIterator __result) {
return std::__move<_ClassicAlgPolicy>(__first, __last, __result).second; return std::__move<_ClassicAlgPolicy>(__first, __last, __result).second;
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_MOVE_H #endif // _LIBCPP___ALGORITHM_MOVE_H

libcxx/include/__algorithm/move_backward.h

Show All 17 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 _AlgPolicy, class _InputIterator, class _OutputIterator> template <class _AlgPolicy, class _InputIterator, class _OutputIterator>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
_OutputIterator _OutputIterator
__move_backward_constexpr(_InputIterator __first, _InputIterator __last, _OutputIterator __result) __move_backward_constexpr(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
{ {
while (__first != __last) while (__first != __last)
*--__result = _IterOps<_AlgPolicy>::__iter_move(--__last); *--__result = _IterOps<_AlgPolicy>::__iter_move(--__last);
return __result; return __result;
} }
template <class _AlgPolicy, class _InputIterator, class _OutputIterator> template <class _AlgPolicy, class _InputIterator, class _OutputIterator>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
_OutputIterator _OutputIterator
__move_backward_impl(_InputIterator __first, _InputIterator __last, _OutputIterator __result) __move_backward_impl(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
{ {
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_AFTER_CXX14 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
typename enable_if typename enable_if
< <
is_same<typename remove_const<_Tp>::type, _Up>::value && is_same<typename remove_const<_Tp>::type, _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)
{ {
__result -= __n; __result -= __n;
_VSTD::memmove(__result, __first, __n * sizeof(_Up)); _VSTD::memmove(__result, __first, __n * sizeof(_Up));
} }
return __result; return __result;
} }
template <class _AlgPolicy, class _BidirectionalIterator1, class _BidirectionalIterator2> template <class _AlgPolicy, class _BidirectionalIterator1, class _BidirectionalIterator2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
_BidirectionalIterator2 _BidirectionalIterator2
__move_backward(_BidirectionalIterator1 __first, _BidirectionalIterator1 __last, __move_backward(_BidirectionalIterator1 __first, _BidirectionalIterator1 __last,
_BidirectionalIterator2 __result) _BidirectionalIterator2 __result)
{ {
if (__libcpp_is_constant_evaluated()) { if (__libcpp_is_constant_evaluated()) {
return _VSTD::__move_backward_constexpr<_AlgPolicy>(__first, __last, __result); return _VSTD::__move_backward_constexpr<_AlgPolicy>(__first, __last, __result);
} else { } else {
return _VSTD::__rewrap_iter(__result, return _VSTD::__rewrap_iter(__result,
_VSTD::__move_backward_impl<_AlgPolicy>(_VSTD::__unwrap_iter(__first), _VSTD::__move_backward_impl<_AlgPolicy>(_VSTD::__unwrap_iter(__first),
_VSTD::__unwrap_iter(__last), _VSTD::__unwrap_iter(__last),
_VSTD::__unwrap_iter(__result))); _VSTD::__unwrap_iter(__result)));
} }
} }
template <class _BidirectionalIterator1, class _BidirectionalIterator2> template <class _BidirectionalIterator1, class _BidirectionalIterator2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
_BidirectionalIterator2 _BidirectionalIterator2
move_backward(_BidirectionalIterator1 __first, _BidirectionalIterator1 __last, move_backward(_BidirectionalIterator1 __first, _BidirectionalIterator1 __last,
_BidirectionalIterator2 __result) _BidirectionalIterator2 __result)
{ {
return std::__move_backward<_ClassicAlgPolicy>(std::move(__first), std::move(__last), std::move(__result)); return std::__move_backward<_ClassicAlgPolicy>(std::move(__first), std::move(__last), std::move(__result));
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_MOVE_BACKWARD_H #endif // _LIBCPP___ALGORITHM_MOVE_BACKWARD_H

libcxx/include/__algorithm/next_permutation.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 _AlgPolicy, class _Compare, class _BidirectionalIterator, class _Sentinel> template <class _AlgPolicy, class _Compare, class _BidirectionalIterator, class _Sentinel>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
pair<_BidirectionalIterator, bool> pair<_BidirectionalIterator, bool>
__next_permutation(_BidirectionalIterator __first, _Sentinel __last, _Compare&& __comp) __next_permutation(_BidirectionalIterator __first, _Sentinel __last, _Compare&& __comp)
{ {
using _Result = pair<_BidirectionalIterator, bool>; using _Result = pair<_BidirectionalIterator, bool>;
_BidirectionalIterator __last_iter = _IterOps<_AlgPolicy>::next(__first, __last); _BidirectionalIterator __last_iter = _IterOps<_AlgPolicy>::next(__first, __last);
_BidirectionalIterator __i = __last_iter; _BidirectionalIterator __i = __last_iter;
if (__first == __last || __first == --__i) if (__first == __last || __first == --__i)
Show All 15 Lines while (true)
{ {
std::__reverse<_AlgPolicy>(__first, __last_iter); std::__reverse<_AlgPolicy>(__first, __last_iter);
return _Result(std::move(__last_iter), false); return _Result(std::move(__last_iter), false);
} }
} }
} }
template <class _BidirectionalIterator, class _Compare> template <class _BidirectionalIterator, class _Compare>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
bool bool
next_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last, _Compare __comp) next_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last, _Compare __comp)
{ {
using _Comp_ref = typename __comp_ref_type<_Compare>::type; using _Comp_ref = typename __comp_ref_type<_Compare>::type;
return std::__next_permutation<_ClassicAlgPolicy>( return std::__next_permutation<_ClassicAlgPolicy>(
std::move(__first), std::move(__last), static_cast<_Comp_ref>(__comp)).second; std::move(__first), std::move(__last), static_cast<_Comp_ref>(__comp)).second;
} }
template <class _BidirectionalIterator> template <class _BidirectionalIterator>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
bool bool
next_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last) next_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last)
{ {
return _VSTD::next_permutation(__first, __last, return _VSTD::next_permutation(__first, __last,
__less<typename iterator_traits<_BidirectionalIterator>::value_type>()); __less<typename iterator_traits<_BidirectionalIterator>::value_type>());
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_NEXT_PERMUTATION_H #endif // _LIBCPP___ALGORITHM_NEXT_PERMUTATION_H

libcxx/include/__algorithm/none_of.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 _InputIterator, class _Predicate> template <class _InputIterator, class _Predicate>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 bool _LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 bool
none_of(_InputIterator __first, _InputIterator __last, _Predicate __pred) { none_of(_InputIterator __first, _InputIterator __last, _Predicate __pred) {
for (; __first != __last; ++__first) for (; __first != __last; ++__first)
if (__pred(*__first)) if (__pred(*__first))
return false; return false;
return true; return true;
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_NONE_OF_H #endif // _LIBCPP___ALGORITHM_NONE_OF_H

libcxx/include/__algorithm/nth_element.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
template<class _Compare, class _RandomAccessIterator> template<class _Compare, class _RandomAccessIterator>
_LIBCPP_CONSTEXPR_AFTER_CXX11 bool _LIBCPP_CONSTEXPR_CXX14 bool
__nth_element_find_guard(_RandomAccessIterator& __i, _RandomAccessIterator& __j, __nth_element_find_guard(_RandomAccessIterator& __i, _RandomAccessIterator& __j,
_RandomAccessIterator __m, _Compare __comp) _RandomAccessIterator __m, _Compare __comp)
{ {
// manually guard downward moving __j against __i // manually guard downward moving __j against __i
while (true) { while (true) {
if (__i == --__j) { if (__i == --__j) {
return false; return false;
} }
if (__comp(*__j, *__m)) { if (__comp(*__j, *__m)) {
return true; // found guard for downward moving __j, now use unguarded partition return true; // found guard for downward moving __j, now use unguarded partition
} }
} }
} }
template <class _AlgPolicy, class _Compare, class _RandomAccessIterator> template <class _AlgPolicy, class _Compare, class _RandomAccessIterator>
_LIBCPP_CONSTEXPR_AFTER_CXX11 void _LIBCPP_CONSTEXPR_CXX14 void
__nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth, _RandomAccessIterator __last, _Compare __comp) __nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth, _RandomAccessIterator __last, _Compare __comp)
{ {
using _Ops = _IterOps<_AlgPolicy>; using _Ops = _IterOps<_AlgPolicy>;
// _Compare is known to be a reference type // _Compare is known to be a reference type
typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type; typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
const difference_type __limit = 7; const difference_type __limit = 7;
while (true) while (true)
▲ Show 20 Lines • Show All 164 Lines • ▼ Show 20 Lines while (true)
{ {
// _VSTD::__nth_element<_Compare>(__i+1, __nth, __last, __comp); // _VSTD::__nth_element<_Compare>(__i+1, __nth, __last, __comp);
__first = ++__i; __first = ++__i;
} }
} }
} }
template <class _AlgPolicy, class _RandomAccessIterator, class _Compare> template <class _AlgPolicy, class _RandomAccessIterator, class _Compare>
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
void __nth_element_impl(_RandomAccessIterator __first, _RandomAccessIterator __nth, _RandomAccessIterator __last, void __nth_element_impl(_RandomAccessIterator __first, _RandomAccessIterator __nth, _RandomAccessIterator __last,
_Compare& __comp) { _Compare& __comp) {
if (__nth == __last) if (__nth == __last)
return; return;
std::__debug_randomize_range<_AlgPolicy>(__first, __last); std::__debug_randomize_range<_AlgPolicy>(__first, __last);
using _Comp_ref = typename __comp_ref_type<_Compare>::type; using _Comp_ref = typename __comp_ref_type<_Compare>::type;
std::__nth_element<_AlgPolicy, _Comp_ref>(__first, __nth, __last, __comp); std::__nth_element<_AlgPolicy, _Comp_ref>(__first, __nth, __last, __comp);
std::__debug_randomize_range<_AlgPolicy>(__first, __nth); std::__debug_randomize_range<_AlgPolicy>(__first, __nth);
if (__nth != __last) { if (__nth != __last) {
std::__debug_randomize_range<_AlgPolicy>(++__nth, __last); std::__debug_randomize_range<_AlgPolicy>(++__nth, __last);
} }
} }
template <class _RandomAccessIterator, class _Compare> template <class _RandomAccessIterator, class _Compare>
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
void nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth, _RandomAccessIterator __last, void nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth, _RandomAccessIterator __last,
_Compare __comp) { _Compare __comp) {
std::__nth_element_impl<_ClassicAlgPolicy>(std::move(__first), std::move(__nth), std::move(__last), __comp); std::__nth_element_impl<_ClassicAlgPolicy>(std::move(__first), std::move(__nth), std::move(__last), __comp);
} }
template <class _RandomAccessIterator> template <class _RandomAccessIterator>
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
void nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth, _RandomAccessIterator __last) { void nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth, _RandomAccessIterator __last) {
std::nth_element(std::move(__first), std::move(__nth), std::move(__last), __less<typename std::nth_element(std::move(__first), std::move(__nth), std::move(__last), __less<typename
iterator_traits<_RandomAccessIterator>::value_type>()); iterator_traits<_RandomAccessIterator>::value_type>());
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_NTH_ELEMENT_H #endif // _LIBCPP___ALGORITHM_NTH_ELEMENT_H

libcxx/include/__algorithm/partial_sort.h

Show All 23 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 _AlgPolicy, class _Compare, class _RandomAccessIterator, class _Sentinel> template <class _AlgPolicy, class _Compare, class _RandomAccessIterator, class _Sentinel>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
_RandomAccessIterator __partial_sort_impl( _RandomAccessIterator __partial_sort_impl(
_RandomAccessIterator __first, _RandomAccessIterator __middle, _Sentinel __last, _Compare&& __comp) { _RandomAccessIterator __first, _RandomAccessIterator __middle, _Sentinel __last, _Compare&& __comp) {
if (__first == __middle) { if (__first == __middle) {
return _IterOps<_AlgPolicy>::next(__middle, __last); return _IterOps<_AlgPolicy>::next(__middle, __last);
} }
std::__make_heap<_AlgPolicy>(__first, __middle, __comp); std::__make_heap<_AlgPolicy>(__first, __middle, __comp);
Show All 9 Lines_RandomAccessIterator __partial_sort_impl(
} }
std::__sort_heap<_AlgPolicy>(std::move(__first), std::move(__middle), __comp); std::__sort_heap<_AlgPolicy>(std::move(__first), std::move(__middle), __comp);
return __i; return __i;
} }
template <class _AlgPolicy, class _Compare, class _RandomAccessIterator, class _Sentinel> template <class _AlgPolicy, class _Compare, class _RandomAccessIterator, class _Sentinel>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
_RandomAccessIterator __partial_sort(_RandomAccessIterator __first, _RandomAccessIterator __middle, _Sentinel __last, _RandomAccessIterator __partial_sort(_RandomAccessIterator __first, _RandomAccessIterator __middle, _Sentinel __last,
_Compare& __comp) { _Compare& __comp) {
if (__first == __middle) if (__first == __middle)
return _IterOps<_AlgPolicy>::next(__middle, __last); return _IterOps<_AlgPolicy>::next(__middle, __last);
std::__debug_randomize_range<_AlgPolicy>(__first, __last); std::__debug_randomize_range<_AlgPolicy>(__first, __last);
using _Comp_ref = typename __comp_ref_type<_Compare>::type; using _Comp_ref = typename __comp_ref_type<_Compare>::type;
auto __last_iter = std::__partial_sort_impl<_AlgPolicy>(__first, __middle, __last, static_cast<_Comp_ref>(__comp)); auto __last_iter = std::__partial_sort_impl<_AlgPolicy>(__first, __middle, __last, static_cast<_Comp_ref>(__comp));
std::__debug_randomize_range<_AlgPolicy>(__middle, __last); std::__debug_randomize_range<_AlgPolicy>(__middle, __last);
return __last_iter; return __last_iter;
} }
template <class _RandomAccessIterator, class _Compare> template <class _RandomAccessIterator, class _Compare>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
void void
partial_sort(_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last, partial_sort(_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last,
_Compare __comp) _Compare __comp)
{ {
static_assert(std::is_copy_constructible<_RandomAccessIterator>::value, "Iterators must be copy constructible."); static_assert(std::is_copy_constructible<_RandomAccessIterator>::value, "Iterators must be copy constructible.");
static_assert(std::is_copy_assignable<_RandomAccessIterator>::value, "Iterators must be copy assignable."); static_assert(std::is_copy_assignable<_RandomAccessIterator>::value, "Iterators must be copy assignable.");
(void)std::__partial_sort<_ClassicAlgPolicy>(std::move(__first), std::move(__middle), std::move(__last), __comp); (void)std::__partial_sort<_ClassicAlgPolicy>(std::move(__first), std::move(__middle), std::move(__last), __comp);
} }
template <class _RandomAccessIterator> template <class _RandomAccessIterator>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
void void
partial_sort(_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last) partial_sort(_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last)
{ {
_VSTD::partial_sort(__first, __middle, __last, _VSTD::partial_sort(__first, __middle, __last,
__less<typename iterator_traits<_RandomAccessIterator>::value_type>()); __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_PARTIAL_SORT_H #endif // _LIBCPP___ALGORITHM_PARTIAL_SORT_H

libcxx/include/__algorithm/partial_sort_copy.h

Show All 27 Lines
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _AlgPolicy, class _Compare, template <class _AlgPolicy, class _Compare,
class _InputIterator, class _Sentinel1, class _RandomAccessIterator, class _Sentinel2, class _InputIterator, class _Sentinel1, class _RandomAccessIterator, class _Sentinel2,
class _Proj1, class _Proj2> class _Proj1, class _Proj2>
_LIBCPP_CONSTEXPR_AFTER_CXX17 pair<_InputIterator, _RandomAccessIterator> _LIBCPP_CONSTEXPR_CXX20 pair<_InputIterator, _RandomAccessIterator>
__partial_sort_copy(_InputIterator __first, _Sentinel1 __last, __partial_sort_copy(_InputIterator __first, _Sentinel1 __last,
_RandomAccessIterator __result_first, _Sentinel2 __result_last, _RandomAccessIterator __result_first, _Sentinel2 __result_last,
_Compare&& __comp, _Proj1&& __proj1, _Proj2&& __proj2) _Compare&& __comp, _Proj1&& __proj1, _Proj2&& __proj2)
{ {
_RandomAccessIterator __r = __result_first; _RandomAccessIterator __r = __result_first;
auto&& __projected_comp = std::__make_projected(__comp, __proj2); auto&& __projected_comp = std::__make_projected(__comp, __proj2);
if (__r != __result_last) if (__r != __result_last)
Show All 10 Lines if (__r != __result_last)
std::__sort_heap<_AlgPolicy>(__result_first, __r, __projected_comp); std::__sort_heap<_AlgPolicy>(__result_first, __r, __projected_comp);
} }
return pair<_InputIterator, _RandomAccessIterator>( return pair<_InputIterator, _RandomAccessIterator>(
_IterOps<_AlgPolicy>::next(std::move(__first), std::move(__last)), std::move(__r)); _IterOps<_AlgPolicy>::next(std::move(__first), std::move(__last)), std::move(__r));
} }
template <class _InputIterator, class _RandomAccessIterator, class _Compare> template <class _InputIterator, class _RandomAccessIterator, class _Compare>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
_RandomAccessIterator _RandomAccessIterator
partial_sort_copy(_InputIterator __first, _InputIterator __last, partial_sort_copy(_InputIterator __first, _InputIterator __last,
_RandomAccessIterator __result_first, _RandomAccessIterator __result_last, _Compare __comp) _RandomAccessIterator __result_first, _RandomAccessIterator __result_last, _Compare __comp)
{ {
static_assert(__is_callable<_Compare, decltype(*__first), decltype(*__result_first)>::value, static_assert(__is_callable<_Compare, decltype(*__first), decltype(*__result_first)>::value,
"Comparator has to be callable"); "Comparator has to be callable");
using _Comp_ref = typename __comp_ref_type<_Compare>::type; using _Comp_ref = typename __comp_ref_type<_Compare>::type;
auto __result = std::__partial_sort_copy<_ClassicAlgPolicy>(__first, __last, __result_first, __result_last, auto __result = std::__partial_sort_copy<_ClassicAlgPolicy>(__first, __last, __result_first, __result_last,
static_cast<_Comp_ref>(__comp), __identity(), __identity()); static_cast<_Comp_ref>(__comp), __identity(), __identity());
return __result.second; return __result.second;
} }
template <class _InputIterator, class _RandomAccessIterator> template <class _InputIterator, class _RandomAccessIterator>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
_RandomAccessIterator _RandomAccessIterator
partial_sort_copy(_InputIterator __first, _InputIterator __last, partial_sort_copy(_InputIterator __first, _InputIterator __last,
_RandomAccessIterator __result_first, _RandomAccessIterator __result_last) _RandomAccessIterator __result_first, _RandomAccessIterator __result_last)
{ {
return _VSTD::partial_sort_copy(__first, __last, __result_first, __result_last, return _VSTD::partial_sort_copy(__first, __last, __result_first, __result_last,
__less<typename iterator_traits<_RandomAccessIterator>::value_type>()); __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_PARTIAL_SORT_COPY_H #endif // _LIBCPP___ALGORITHM_PARTIAL_SORT_COPY_H

libcxx/include/__algorithm/partition.h

Show All 17 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 _Predicate, class _AlgPolicy, class _ForwardIterator, class _Sentinel> template <class _Predicate, class _AlgPolicy, class _ForwardIterator, class _Sentinel>
_LIBCPP_CONSTEXPR_AFTER_CXX17 pair<_ForwardIterator, _ForwardIterator> _LIBCPP_CONSTEXPR_CXX20 pair<_ForwardIterator, _ForwardIterator>
__partition_impl(_ForwardIterator __first, _Sentinel __last, _Predicate __pred, forward_iterator_tag) __partition_impl(_ForwardIterator __first, _Sentinel __last, _Predicate __pred, forward_iterator_tag)
{ {
while (true) while (true)
{ {
if (__first == __last) if (__first == __last)
return std::make_pair(std::move(__first), std::move(__first)); return std::make_pair(std::move(__first), std::move(__first));
if (!__pred(*__first)) if (!__pred(*__first))
break; break;
++__first; ++__first;
} }
_ForwardIterator __p = __first; _ForwardIterator __p = __first;
while (++__p != __last) while (++__p != __last)
{ {
if (__pred(*__p)) if (__pred(*__p))
{ {
_IterOps<_AlgPolicy>::iter_swap(__first, __p); _IterOps<_AlgPolicy>::iter_swap(__first, __p);
++__first; ++__first;
} }
} }
return std::make_pair(std::move(__first), std::move(__p)); return std::make_pair(std::move(__first), std::move(__p));
} }
template <class _Predicate, class _AlgPolicy, class _BidirectionalIterator, class _Sentinel> template <class _Predicate, class _AlgPolicy, class _BidirectionalIterator, class _Sentinel>
_LIBCPP_CONSTEXPR_AFTER_CXX17 pair<_BidirectionalIterator, _BidirectionalIterator> _LIBCPP_CONSTEXPR_CXX20 pair<_BidirectionalIterator, _BidirectionalIterator>
__partition_impl(_BidirectionalIterator __first, _Sentinel __sentinel, _Predicate __pred, __partition_impl(_BidirectionalIterator __first, _Sentinel __sentinel, _Predicate __pred,
bidirectional_iterator_tag) bidirectional_iterator_tag)
{ {
_BidirectionalIterator __original_last = _IterOps<_AlgPolicy>::next(__first, __sentinel); _BidirectionalIterator __original_last = _IterOps<_AlgPolicy>::next(__first, __sentinel);
_BidirectionalIterator __last = __original_last; _BidirectionalIterator __last = __original_last;
while (true) while (true)
{ {
Show All 11 Lines while (true)
return std::make_pair(std::move(__first), std::move(__original_last)); return std::make_pair(std::move(__first), std::move(__original_last));
} while (!__pred(*__last)); } while (!__pred(*__last));
_IterOps<_AlgPolicy>::iter_swap(__first, __last); _IterOps<_AlgPolicy>::iter_swap(__first, __last);
++__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_AFTER_CXX17 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_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<__uncvref_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_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_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/partition_copy.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 _InputIterator, class _OutputIterator1, template <class _InputIterator, class _OutputIterator1,
class _OutputIterator2, class _Predicate> class _OutputIterator2, class _Predicate>
_LIBCPP_CONSTEXPR_AFTER_CXX17 pair<_OutputIterator1, _OutputIterator2> _LIBCPP_CONSTEXPR_CXX20 pair<_OutputIterator1, _OutputIterator2>
partition_copy(_InputIterator __first, _InputIterator __last, partition_copy(_InputIterator __first, _InputIterator __last,
_OutputIterator1 __out_true, _OutputIterator2 __out_false, _OutputIterator1 __out_true, _OutputIterator2 __out_false,
_Predicate __pred) _Predicate __pred)
{ {
for (; __first != __last; ++__first) for (; __first != __last; ++__first)
{ {
if (__pred(*__first)) if (__pred(*__first))
{ {
Show All 15 Lines

libcxx/include/__algorithm/partition_point.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 _ForwardIterator, class _Predicate> template<class _ForwardIterator, class _Predicate>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _ForwardIterator _LIBCPP_CONSTEXPR_CXX20 _ForwardIterator
partition_point(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) partition_point(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred)
{ {
typedef typename iterator_traits<_ForwardIterator>::difference_type difference_type; typedef typename iterator_traits<_ForwardIterator>::difference_type difference_type;
difference_type __len = _VSTD::distance(__first, __last); difference_type __len = _VSTD::distance(__first, __last);
while (__len != 0) while (__len != 0)
{ {
difference_type __l2 = _VSTD::__half_positive(__len); difference_type __l2 = _VSTD::__half_positive(__len);
_ForwardIterator __m = __first; _ForwardIterator __m = __first;
Show All 15 Lines

libcxx/include/__algorithm/pop_heap.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 _AlgPolicy, class _Compare, class _RandomAccessIterator> template <class _AlgPolicy, class _Compare, class _RandomAccessIterator>
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14
void __pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare& __comp, void __pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare& __comp,
typename iterator_traits<_RandomAccessIterator>::difference_type __len) { typename iterator_traits<_RandomAccessIterator>::difference_type __len) {
_LIBCPP_ASSERT(__len > 0, "The heap given to pop_heap must be non-empty"); _LIBCPP_ASSERT(__len > 0, "The heap given to pop_heap must be non-empty");
using _CompRef = typename __comp_ref_type<_Compare>::type; using _CompRef = typename __comp_ref_type<_Compare>::type;
_CompRef __comp_ref = __comp; _CompRef __comp_ref = __comp;
using value_type = typename iterator_traits<_RandomAccessIterator>::value_type; using value_type = typename iterator_traits<_RandomAccessIterator>::value_type;
Show All 9 Lines if (__hole == __last) {
++__hole; ++__hole;
*__last = std::move(__top); *__last = std::move(__top);
std::__sift_up<_AlgPolicy>(__first, __hole, __comp_ref, __hole - __first); std::__sift_up<_AlgPolicy>(__first, __hole, __comp_ref, __hole - __first);
} }
} }
} }
template <class _RandomAccessIterator, class _Compare> template <class _RandomAccessIterator, class _Compare>
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
void pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) { void pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) {
static_assert(std::is_copy_constructible<_RandomAccessIterator>::value, "Iterators must be copy constructible."); static_assert(std::is_copy_constructible<_RandomAccessIterator>::value, "Iterators must be copy constructible.");
static_assert(std::is_copy_assignable<_RandomAccessIterator>::value, "Iterators must be copy assignable."); static_assert(std::is_copy_assignable<_RandomAccessIterator>::value, "Iterators must be copy assignable.");
typename iterator_traits<_RandomAccessIterator>::difference_type __len = __last - __first; typename iterator_traits<_RandomAccessIterator>::difference_type __len = __last - __first;
std::__pop_heap<_ClassicAlgPolicy>(std::move(__first), std::move(__last), __comp, __len); std::__pop_heap<_ClassicAlgPolicy>(std::move(__first), std::move(__last), __comp, __len);
} }
template <class _RandomAccessIterator> template <class _RandomAccessIterator>
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
void pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) { void pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) {
std::pop_heap(std::move(__first), std::move(__last), std::pop_heap(std::move(__first), std::move(__last),
__less<typename iterator_traits<_RandomAccessIterator>::value_type>()); __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_POP_HEAP_H #endif // _LIBCPP___ALGORITHM_POP_HEAP_H

libcxx/include/__algorithm/prev_permutation.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 _AlgPolicy, class _Compare, class _BidirectionalIterator, class _Sentinel> template <class _AlgPolicy, class _Compare, class _BidirectionalIterator, class _Sentinel>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
pair<_BidirectionalIterator, bool> pair<_BidirectionalIterator, bool>
__prev_permutation(_BidirectionalIterator __first, _Sentinel __last, _Compare&& __comp) __prev_permutation(_BidirectionalIterator __first, _Sentinel __last, _Compare&& __comp)
{ {
using _Result = pair<_BidirectionalIterator, bool>; using _Result = pair<_BidirectionalIterator, bool>;
_BidirectionalIterator __last_iter = _IterOps<_AlgPolicy>::next(__first, __last); _BidirectionalIterator __last_iter = _IterOps<_AlgPolicy>::next(__first, __last);
_BidirectionalIterator __i = __last_iter; _BidirectionalIterator __i = __last_iter;
if (__first == __last || __first == --__i) if (__first == __last || __first == --__i)
Show All 15 Lines while (true)
{ {
std::__reverse<_AlgPolicy>(__first, __last_iter); std::__reverse<_AlgPolicy>(__first, __last_iter);
return _Result(std::move(__last_iter), false); return _Result(std::move(__last_iter), false);
} }
} }
} }
template <class _BidirectionalIterator, class _Compare> template <class _BidirectionalIterator, class _Compare>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
bool bool
prev_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last, _Compare __comp) prev_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last, _Compare __comp)
{ {
using _Comp_ref = typename __comp_ref_type<_Compare>::type; using _Comp_ref = typename __comp_ref_type<_Compare>::type;
return std::__prev_permutation<_ClassicAlgPolicy>( return std::__prev_permutation<_ClassicAlgPolicy>(
std::move(__first), std::move(__last), static_cast<_Comp_ref>(__comp)).second; std::move(__first), std::move(__last), static_cast<_Comp_ref>(__comp)).second;
} }
template <class _BidirectionalIterator> template <class _BidirectionalIterator>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
bool bool
prev_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last) prev_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last)
{ {
return _VSTD::prev_permutation(__first, __last, return _VSTD::prev_permutation(__first, __last,
__less<typename iterator_traits<_BidirectionalIterator>::value_type>()); __less<typename iterator_traits<_BidirectionalIterator>::value_type>());
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_PREV_PERMUTATION_H #endif // _LIBCPP___ALGORITHM_PREV_PERMUTATION_H

libcxx/include/__algorithm/push_heap.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
template <class _AlgPolicy, class _Compare, class _RandomAccessIterator> template <class _AlgPolicy, class _Compare, class _RandomAccessIterator>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14
void __sift_up(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare&& __comp, void __sift_up(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare&& __comp,
typename iterator_traits<_RandomAccessIterator>::difference_type __len) { typename iterator_traits<_RandomAccessIterator>::difference_type __len) {
using value_type = typename iterator_traits<_RandomAccessIterator>::value_type; using value_type = typename iterator_traits<_RandomAccessIterator>::value_type;
if (__len > 1) { if (__len > 1) {
__len = (__len - 2) / 2; __len = (__len - 2) / 2;
_RandomAccessIterator __ptr = __first + __len; _RandomAccessIterator __ptr = __first + __len;
Show All 9 Lines if (__comp(*__ptr, *--__last)) {
} while (__comp(*__ptr, __t)); } while (__comp(*__ptr, __t));
*__last = std::move(__t); *__last = std::move(__t);
} }
} }
} }
template <class _AlgPolicy, class _RandomAccessIterator, class _Compare> template <class _AlgPolicy, class _RandomAccessIterator, class _Compare>
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14
void __push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare& __comp) { void __push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare& __comp) {
using _CompRef = typename __comp_ref_type<_Compare>::type; using _CompRef = typename __comp_ref_type<_Compare>::type;
typename iterator_traits<_RandomAccessIterator>::difference_type __len = __last - __first; typename iterator_traits<_RandomAccessIterator>::difference_type __len = __last - __first;
std::__sift_up<_AlgPolicy, _CompRef>(std::move(__first), std::move(__last), __comp, __len); std::__sift_up<_AlgPolicy, _CompRef>(std::move(__first), std::move(__last), __comp, __len);
} }
template <class _RandomAccessIterator, class _Compare> template <class _RandomAccessIterator, class _Compare>
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
void push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) { void push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) {
static_assert(std::is_copy_constructible<_RandomAccessIterator>::value, "Iterators must be copy constructible."); static_assert(std::is_copy_constructible<_RandomAccessIterator>::value, "Iterators must be copy constructible.");
static_assert(std::is_copy_assignable<_RandomAccessIterator>::value, "Iterators must be copy assignable."); static_assert(std::is_copy_assignable<_RandomAccessIterator>::value, "Iterators must be copy assignable.");
std::__push_heap<_ClassicAlgPolicy>(std::move(__first), std::move(__last), __comp); std::__push_heap<_ClassicAlgPolicy>(std::move(__first), std::move(__last), __comp);
} }
template <class _RandomAccessIterator> template <class _RandomAccessIterator>
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
void push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) { void push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) {
std::push_heap(std::move(__first), std::move(__last), std::push_heap(std::move(__first), std::move(__last),
__less<typename iterator_traits<_RandomAccessIterator>::value_type>()); __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_PUSH_HEAP_H #endif // _LIBCPP___ALGORITHM_PUSH_HEAP_H

libcxx/include/__algorithm/remove.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 _ForwardIterator, class _Tp> template <class _ForwardIterator, class _Tp>
_LIBCPP_NODISCARD_EXT _LIBCPP_CONSTEXPR_AFTER_CXX17 _ForwardIterator _LIBCPP_NODISCARD_EXT _LIBCPP_CONSTEXPR_CXX20 _ForwardIterator
remove(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) remove(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value)
{ {
__first = _VSTD::find(__first, __last, __value); __first = _VSTD::find(__first, __last, __value);
if (__first != __last) if (__first != __last)
{ {
_ForwardIterator __i = __first; _ForwardIterator __i = __first;
while (++__i != __last) while (++__i != __last)
{ {
Show All 13 Lines

libcxx/include/__algorithm/remove_copy.h

Show All 12 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 _InputIterator, class _OutputIterator, class _Tp> template <class _InputIterator, class _OutputIterator, class _Tp>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
_OutputIterator _OutputIterator
remove_copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result, const _Tp& __value) remove_copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result, const _Tp& __value)
{ {
for (; __first != __last; ++__first) for (; __first != __last; ++__first)
{ {
if (!(*__first == __value)) if (!(*__first == __value))
{ {
*__result = *__first; *__result = *__first;
Show All 9 Lines

libcxx/include/__algorithm/remove_copy_if.h

Show All 12 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 _InputIterator, class _OutputIterator, class _Predicate> template <class _InputIterator, class _OutputIterator, class _Predicate>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
_OutputIterator _OutputIterator
remove_copy_if(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _Predicate __pred) remove_copy_if(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _Predicate __pred)
{ {
for (; __first != __last; ++__first) for (; __first != __last; ++__first)
{ {
if (!__pred(*__first)) if (!__pred(*__first))
{ {
*__result = *__first; *__result = *__first;
Show All 9 Lines

libcxx/include/__algorithm/remove_if.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 _ForwardIterator, class _Predicate> template <class _ForwardIterator, class _Predicate>
_LIBCPP_NODISCARD_EXT _LIBCPP_CONSTEXPR_AFTER_CXX17 _ForwardIterator _LIBCPP_NODISCARD_EXT _LIBCPP_CONSTEXPR_CXX20 _ForwardIterator
remove_if(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) remove_if(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred)
{ {
__first = _VSTD::find_if<_ForwardIterator, _Predicate&>(__first, __last, __pred); __first = _VSTD::find_if<_ForwardIterator, _Predicate&>(__first, __last, __pred);
if (__first != __last) if (__first != __last)
{ {
_ForwardIterator __i = __first; _ForwardIterator __i = __first;
while (++__i != __last) while (++__i != __last)
{ {
Show All 13 Lines

libcxx/include/__algorithm/replace.h

Show All 12 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 _ForwardIterator, class _Tp> template <class _ForwardIterator, class _Tp>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
void void
replace(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __old_value, const _Tp& __new_value) replace(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __old_value, const _Tp& __new_value)
{ {
for (; __first != __last; ++__first) for (; __first != __last; ++__first)
if (*__first == __old_value) if (*__first == __old_value)
*__first = __new_value; *__first = __new_value;
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_REPLACE_H #endif // _LIBCPP___ALGORITHM_REPLACE_H

libcxx/include/__algorithm/replace_copy.h

Show All 12 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 _InputIterator, class _OutputIterator, class _Tp> template <class _InputIterator, class _OutputIterator, class _Tp>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
_OutputIterator _OutputIterator
replace_copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result, replace_copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result,
const _Tp& __old_value, const _Tp& __new_value) const _Tp& __old_value, const _Tp& __new_value)
{ {
for (; __first != __last; ++__first, (void) ++__result) for (; __first != __last; ++__first, (void) ++__result)
if (*__first == __old_value) if (*__first == __old_value)
*__result = __new_value; *__result = __new_value;
else else
*__result = *__first; *__result = *__first;
return __result; return __result;
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_REPLACE_COPY_H #endif // _LIBCPP___ALGORITHM_REPLACE_COPY_H

libcxx/include/__algorithm/replace_copy_if.h

Show All 12 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 _InputIterator, class _OutputIterator, class _Predicate, class _Tp> template <class _InputIterator, class _OutputIterator, class _Predicate, class _Tp>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
_OutputIterator _OutputIterator
replace_copy_if(_InputIterator __first, _InputIterator __last, _OutputIterator __result, replace_copy_if(_InputIterator __first, _InputIterator __last, _OutputIterator __result,
_Predicate __pred, const _Tp& __new_value) _Predicate __pred, const _Tp& __new_value)
{ {
for (; __first != __last; ++__first, (void) ++__result) for (; __first != __last; ++__first, (void) ++__result)
if (__pred(*__first)) if (__pred(*__first))
*__result = __new_value; *__result = __new_value;
else else
*__result = *__first; *__result = *__first;
return __result; return __result;
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_REPLACE_COPY_IF_H #endif // _LIBCPP___ALGORITHM_REPLACE_COPY_IF_H

libcxx/include/__algorithm/replace_if.h

Show All 12 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 _ForwardIterator, class _Predicate, class _Tp> template <class _ForwardIterator, class _Predicate, class _Tp>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
void void
replace_if(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred, const _Tp& __new_value) replace_if(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred, const _Tp& __new_value)
{ {
for (; __first != __last; ++__first) for (; __first != __last; ++__first)
if (__pred(*__first)) if (__pred(*__first))
*__first = __new_value; *__first = __new_value;
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_REPLACE_IF_H #endif // _LIBCPP___ALGORITHM_REPLACE_IF_H

libcxx/include/__algorithm/reverse.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 _AlgPolicy, class _BidirectionalIterator> template <class _AlgPolicy, class _BidirectionalIterator>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
void void
__reverse_impl(_BidirectionalIterator __first, _BidirectionalIterator __last, bidirectional_iterator_tag) __reverse_impl(_BidirectionalIterator __first, _BidirectionalIterator __last, bidirectional_iterator_tag)
{ {
while (__first != __last) while (__first != __last)
{ {
if (__first == --__last) if (__first == --__last)
break; break;
_IterOps<_AlgPolicy>::iter_swap(__first, __last); _IterOps<_AlgPolicy>::iter_swap(__first, __last);
++__first; ++__first;
} }
} }
template <class _AlgPolicy, class _RandomAccessIterator> template <class _AlgPolicy, class _RandomAccessIterator>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
void void
__reverse_impl(_RandomAccessIterator __first, _RandomAccessIterator __last, random_access_iterator_tag) __reverse_impl(_RandomAccessIterator __first, _RandomAccessIterator __last, random_access_iterator_tag)
{ {
if (__first != __last) if (__first != __last)
for (; __first < --__last; ++__first) for (; __first < --__last; ++__first)
_IterOps<_AlgPolicy>::iter_swap(__first, __last); _IterOps<_AlgPolicy>::iter_swap(__first, __last);
} }
template <class _AlgPolicy, class _BidirectionalIterator, class _Sentinel> template <class _AlgPolicy, class _BidirectionalIterator, class _Sentinel>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
void __reverse(_BidirectionalIterator __first, _Sentinel __last) { void __reverse(_BidirectionalIterator __first, _Sentinel __last) {
using _IterCategory = typename _IterOps<_AlgPolicy>::template __iterator_category<_BidirectionalIterator>; using _IterCategory = typename _IterOps<_AlgPolicy>::template __iterator_category<_BidirectionalIterator>;
std::__reverse_impl<_AlgPolicy>(std::move(__first), std::move(__last), _IterCategory()); std::__reverse_impl<_AlgPolicy>(std::move(__first), std::move(__last), _IterCategory());
} }
template <class _BidirectionalIterator> template <class _BidirectionalIterator>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
void void
reverse(_BidirectionalIterator __first, _BidirectionalIterator __last) reverse(_BidirectionalIterator __first, _BidirectionalIterator __last)
{ {
std::__reverse<_ClassicAlgPolicy>(std::move(__first), std::move(__last)); std::__reverse<_ClassicAlgPolicy>(std::move(__first), std::move(__last));
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_REVERSE_H #endif // _LIBCPP___ALGORITHM_REVERSE_H

libcxx/include/__algorithm/reverse_copy.h

Show All 12 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 _BidirectionalIterator, class _OutputIterator> template <class _BidirectionalIterator, class _OutputIterator>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
_OutputIterator _OutputIterator
reverse_copy(_BidirectionalIterator __first, _BidirectionalIterator __last, _OutputIterator __result) reverse_copy(_BidirectionalIterator __first, _BidirectionalIterator __last, _OutputIterator __result)
{ {
for (; __first != __last; ++__result) for (; __first != __last; ++__result)
*__result = *--__last; *__result = *--__last;
return __result; return __result;
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_REVERSE_COPY_H #endif // _LIBCPP___ALGORITHM_REVERSE_COPY_H

libcxx/include/__algorithm/rotate.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
template <class _AlgPolicy, class _ForwardIterator> template <class _AlgPolicy, class _ForwardIterator>
_LIBCPP_CONSTEXPR_AFTER_CXX11 _ForwardIterator _LIBCPP_CONSTEXPR_CXX14 _ForwardIterator
__rotate_left(_ForwardIterator __first, _ForwardIterator __last) __rotate_left(_ForwardIterator __first, _ForwardIterator __last)
{ {
typedef typename iterator_traits<_ForwardIterator>::value_type value_type; typedef typename iterator_traits<_ForwardIterator>::value_type value_type;
using _Ops = _IterOps<_AlgPolicy>; using _Ops = _IterOps<_AlgPolicy>;
value_type __tmp = _Ops::__iter_move(__first); value_type __tmp = _Ops::__iter_move(__first);
_ForwardIterator __lm1 = std::__move<_AlgPolicy>( _ForwardIterator __lm1 = std::__move<_AlgPolicy>(
_Ops::next(__first), __last, __first).second; _Ops::next(__first), __last, __first).second;
*__lm1 = _VSTD::move(__tmp); *__lm1 = _VSTD::move(__tmp);
return __lm1; return __lm1;
} }
template <class _AlgPolicy, class _BidirectionalIterator> template <class _AlgPolicy, class _BidirectionalIterator>
_LIBCPP_CONSTEXPR_AFTER_CXX11 _BidirectionalIterator _LIBCPP_CONSTEXPR_CXX14 _BidirectionalIterator
__rotate_right(_BidirectionalIterator __first, _BidirectionalIterator __last) __rotate_right(_BidirectionalIterator __first, _BidirectionalIterator __last)
{ {
typedef typename iterator_traits<_BidirectionalIterator>::value_type value_type; typedef typename iterator_traits<_BidirectionalIterator>::value_type value_type;
using _Ops = _IterOps<_AlgPolicy>; using _Ops = _IterOps<_AlgPolicy>;
_BidirectionalIterator __lm1 = _Ops::prev(__last); _BidirectionalIterator __lm1 = _Ops::prev(__last);
value_type __tmp = _Ops::__iter_move(__lm1); value_type __tmp = _Ops::__iter_move(__lm1);
_BidirectionalIterator __fp1 = std::__move_backward<_AlgPolicy>(__first, __lm1, std::move(__last)); _BidirectionalIterator __fp1 = std::__move_backward<_AlgPolicy>(__first, __lm1, std::move(__last));
*__first = _VSTD::move(__tmp); *__first = _VSTD::move(__tmp);
return __fp1; return __fp1;
} }
template <class _AlgPolicy, class _ForwardIterator> template <class _AlgPolicy, class _ForwardIterator>
_LIBCPP_CONSTEXPR_AFTER_CXX14 _ForwardIterator _LIBCPP_CONSTEXPR_CXX17 _ForwardIterator
__rotate_forward(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last) __rotate_forward(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last)
{ {
_ForwardIterator __i = __middle; _ForwardIterator __i = __middle;
while (true) while (true)
{ {
_IterOps<_AlgPolicy>::iter_swap(__first, __i); _IterOps<_AlgPolicy>::iter_swap(__first, __i);
++__first; ++__first;
if (++__i == __last) if (++__i == __last)
Show All 19 Lines if (__first != __middle)
__middle = __i; __middle = __i;
} }
} }
return __r; return __r;
} }
template<typename _Integral> template<typename _Integral>
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR_AFTER_CXX14 _Integral _LIBCPP_CONSTEXPR_CXX17 _Integral
__algo_gcd(_Integral __x, _Integral __y) __algo_gcd(_Integral __x, _Integral __y)
{ {
do do
{ {
_Integral __t = __x % __y; _Integral __t = __x % __y;
__x = __y; __x = __y;
__y = __t; __y = __t;
} while (__y); } while (__y);
return __x; return __x;
} }
template <class _AlgPolicy, typename _RandomAccessIterator> template <class _AlgPolicy, typename _RandomAccessIterator>
_LIBCPP_CONSTEXPR_AFTER_CXX14 _RandomAccessIterator _LIBCPP_CONSTEXPR_CXX17 _RandomAccessIterator
__rotate_gcd(_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last) __rotate_gcd(_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last)
{ {
typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type; typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type; typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type;
using _Ops = _IterOps<_AlgPolicy>; using _Ops = _IterOps<_AlgPolicy>;
const difference_type __m1 = __middle - __first; const difference_type __m1 = __middle - __first;
const difference_type __m2 = _Ops::distance(__middle, __last); const difference_type __m2 = _Ops::distance(__middle, __last);
Show All 20 Lines for (_RandomAccessIterator __p = __first + __g; __p != __first;)
} while (__p2 != __p); } while (__p2 != __p);
*__p1 = _VSTD::move(__t); *__p1 = _VSTD::move(__t);
} }
return __first + __m2; return __first + __m2;
} }
template <class _AlgPolicy, class _ForwardIterator> template <class _AlgPolicy, class _ForwardIterator>
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR_AFTER_CXX11 _ForwardIterator _LIBCPP_CONSTEXPR_CXX14 _ForwardIterator
__rotate_impl(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last, __rotate_impl(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last,
_VSTD::forward_iterator_tag) _VSTD::forward_iterator_tag)
{ {
typedef typename iterator_traits<_ForwardIterator>::value_type value_type; typedef typename iterator_traits<_ForwardIterator>::value_type value_type;
if (is_trivially_move_assignable<value_type>::value) if (is_trivially_move_assignable<value_type>::value)
{ {
if (_IterOps<_AlgPolicy>::next(__first) == __middle) if (_IterOps<_AlgPolicy>::next(__first) == __middle)
return std::__rotate_left<_AlgPolicy>(__first, __last); return std::__rotate_left<_AlgPolicy>(__first, __last);
} }
return std::__rotate_forward<_AlgPolicy>(__first, __middle, __last); return std::__rotate_forward<_AlgPolicy>(__first, __middle, __last);
} }
template <class _AlgPolicy, class _BidirectionalIterator> template <class _AlgPolicy, class _BidirectionalIterator>
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR_AFTER_CXX11 _BidirectionalIterator _LIBCPP_CONSTEXPR_CXX14 _BidirectionalIterator
__rotate_impl(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last, __rotate_impl(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last,
bidirectional_iterator_tag) bidirectional_iterator_tag)
{ {
typedef typename iterator_traits<_BidirectionalIterator>::value_type value_type; typedef typename iterator_traits<_BidirectionalIterator>::value_type value_type;
if (is_trivially_move_assignable<value_type>::value) if (is_trivially_move_assignable<value_type>::value)
{ {
if (_IterOps<_AlgPolicy>::next(__first) == __middle) if (_IterOps<_AlgPolicy>::next(__first) == __middle)
return std::__rotate_left<_AlgPolicy>(__first, __last); return std::__rotate_left<_AlgPolicy>(__first, __last);
if (_IterOps<_AlgPolicy>::next(__middle) == __last) if (_IterOps<_AlgPolicy>::next(__middle) == __last)
return std::__rotate_right<_AlgPolicy>(__first, __last); return std::__rotate_right<_AlgPolicy>(__first, __last);
} }
return std::__rotate_forward<_AlgPolicy>(__first, __middle, __last); return std::__rotate_forward<_AlgPolicy>(__first, __middle, __last);
} }
template <class _AlgPolicy, class _RandomAccessIterator> template <class _AlgPolicy, class _RandomAccessIterator>
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR_AFTER_CXX11 _RandomAccessIterator _LIBCPP_CONSTEXPR_CXX14 _RandomAccessIterator
__rotate_impl(_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last, __rotate_impl(_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last,
random_access_iterator_tag) random_access_iterator_tag)
{ {
typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type; typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type;
if (is_trivially_move_assignable<value_type>::value) if (is_trivially_move_assignable<value_type>::value)
{ {
if (_IterOps<_AlgPolicy>::next(__first) == __middle) if (_IterOps<_AlgPolicy>::next(__first) == __middle)
return std::__rotate_left<_AlgPolicy>(__first, __last); return std::__rotate_left<_AlgPolicy>(__first, __last);
if (_IterOps<_AlgPolicy>::next(__middle) == __last) if (_IterOps<_AlgPolicy>::next(__middle) == __last)
return std::__rotate_right<_AlgPolicy>(__first, __last); return std::__rotate_right<_AlgPolicy>(__first, __last);
return std::__rotate_gcd<_AlgPolicy>(__first, __middle, __last); return std::__rotate_gcd<_AlgPolicy>(__first, __middle, __last);
} }
return std::__rotate_forward<_AlgPolicy>(__first, __middle, __last); return std::__rotate_forward<_AlgPolicy>(__first, __middle, __last);
} }
template <class _AlgPolicy, class _Iterator, class _Sentinel> template <class _AlgPolicy, class _Iterator, class _Sentinel>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14
pair<_Iterator, _Iterator> pair<_Iterator, _Iterator>
__rotate(_Iterator __first, _Iterator __middle, _Sentinel __last) { __rotate(_Iterator __first, _Iterator __middle, _Sentinel __last) {
using _Ret = pair<_Iterator, _Iterator>; using _Ret = pair<_Iterator, _Iterator>;
_Iterator __last_iter = _IterOps<_AlgPolicy>::next(__middle, __last); _Iterator __last_iter = _IterOps<_AlgPolicy>::next(__middle, __last);
if (__first == __middle) if (__first == __middle)
return _Ret(__last_iter, __last_iter); return _Ret(__last_iter, __last_iter);
if (__middle == __last) if (__middle == __last)
return _Ret(std::move(__first), std::move(__last_iter)); return _Ret(std::move(__first), std::move(__last_iter));
using _IterCategory = typename _IterOps<_AlgPolicy>::template __iterator_category<_Iterator>; using _IterCategory = typename _IterOps<_AlgPolicy>::template __iterator_category<_Iterator>;
auto __result = std::__rotate_impl<_AlgPolicy>( auto __result = std::__rotate_impl<_AlgPolicy>(
std::move(__first), std::move(__middle), __last_iter, _IterCategory()); std::move(__first), std::move(__middle), __last_iter, _IterCategory());
return _Ret(std::move(__result), std::move(__last_iter)); return _Ret(std::move(__result), std::move(__last_iter));
} }
template <class _ForwardIterator> template <class _ForwardIterator>
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR_AFTER_CXX17 _ForwardIterator _LIBCPP_CONSTEXPR_CXX20 _ForwardIterator
rotate(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last) rotate(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last)
{ {
return std::__rotate<_ClassicAlgPolicy>( return std::__rotate<_ClassicAlgPolicy>(
std::move(__first), std::move(__middle), std::move(__last)).first; std::move(__first), std::move(__middle), std::move(__last)).first;
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_ROTATE_H #endif // _LIBCPP___ALGORITHM_ROTATE_H

libcxx/include/__algorithm/rotate_copy.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 _ForwardIterator, class _OutputIterator> template <class _ForwardIterator, class _OutputIterator>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
_OutputIterator _OutputIterator
rotate_copy(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last, _OutputIterator __result) rotate_copy(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last, _OutputIterator __result)
{ {
return _VSTD::copy(__first, __middle, _VSTD::copy(__middle, __last, __result)); return _VSTD::copy(__first, __middle, _VSTD::copy(__middle, __last, __result));
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_ROTATE_COPY_H #endif // _LIBCPP___ALGORITHM_ROTATE_COPY_H

libcxx/include/__algorithm/search.h

Show All 27 Lines
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _AlgPolicy, template <class _AlgPolicy,
class _Iter1, class _Sent1, class _Iter1, class _Sent1,
class _Iter2, class _Sent2, class _Iter2, class _Sent2,
class _Pred, class _Pred,
class _Proj1, class _Proj1,
class _Proj2> class _Proj2>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14
pair<_Iter1, _Iter1> __search_forward_impl(_Iter1 __first1, _Sent1 __last1, pair<_Iter1, _Iter1> __search_forward_impl(_Iter1 __first1, _Sent1 __last1,
_Iter2 __first2, _Sent2 __last2, _Iter2 __first2, _Sent2 __last2,
_Pred& __pred, _Pred& __pred,
_Proj1& __proj1, _Proj1& __proj1,
_Proj2& __proj2) { _Proj2& __proj2) {
if (__first2 == __last2) if (__first2 == __last2)
return std::make_pair(__first1, __first1); // Everything matches an empty sequence return std::make_pair(__first1, __first1); // Everything matches an empty sequence
while (true) { while (true) {
Show All 30 Lines
template <class _AlgPolicy, template <class _AlgPolicy,
class _Iter1, class _Sent1, class _Iter1, class _Sent1,
class _Iter2, class _Sent2, class _Iter2, class _Sent2,
class _Pred, class _Pred,
class _Proj1, class _Proj1,
class _Proj2, class _Proj2,
class _DiffT1, class _DiffT1,
class _DiffT2> class _DiffT2>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14
pair<_Iter1, _Iter1> __search_random_access_impl(_Iter1 __first1, _Sent1 __last1, pair<_Iter1, _Iter1> __search_random_access_impl(_Iter1 __first1, _Sent1 __last1,
_Iter2 __first2, _Sent2 __last2, _Iter2 __first2, _Sent2 __last2,
_Pred& __pred, _Pred& __pred,
_Proj1& __proj1, _Proj1& __proj1,
_Proj2& __proj2, _Proj2& __proj2,
_DiffT1 __size1, _DiffT1 __size1,
_DiffT2 __size2) { _DiffT2 __size2) {
const _Iter1 __s = __first1 + __size1 - _DiffT1(__size2 - 1); // Start of pattern match can't go beyond here const _Iter1 __s = __first1 + __size1 - _DiffT1(__size2 - 1); // Start of pattern match can't go beyond here
Show All 23 Linespair<_Iter1, _Iter1> __search_random_access_impl(_Iter1 __first1, _Sent1 __last1,
} }
} }
template <class _Iter1, class _Sent1, template <class _Iter1, class _Sent1,
class _Iter2, class _Sent2, class _Iter2, class _Sent2,
class _Pred, class _Pred,
class _Proj1, class _Proj1,
class _Proj2> class _Proj2>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14
pair<_Iter1, _Iter1> __search_impl(_Iter1 __first1, _Sent1 __last1, pair<_Iter1, _Iter1> __search_impl(_Iter1 __first1, _Sent1 __last1,
_Iter2 __first2, _Sent2 __last2, _Iter2 __first2, _Sent2 __last2,
_Pred& __pred, _Pred& __pred,
_Proj1& __proj1, _Proj1& __proj1,
_Proj2& __proj2, _Proj2& __proj2,
__enable_if_t<__is_cpp17_random_access_iterator<_Iter1>::value __enable_if_t<__is_cpp17_random_access_iterator<_Iter1>::value
&& __is_cpp17_random_access_iterator<_Iter2>::value>* = nullptr) { && __is_cpp17_random_access_iterator<_Iter2>::value>* = nullptr) {
Show All 15 Lines return std::__search_random_access_impl<_ClassicAlgPolicy>(__first1, __last1,
__size2); __size2);
} }
template <class _Iter1, class _Sent1, template <class _Iter1, class _Sent1,
class _Iter2, class _Sent2, class _Iter2, class _Sent2,
class _Pred, class _Pred,
class _Proj1, class _Proj1,
class _Proj2> class _Proj2>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14
pair<_Iter1, _Iter1> __search_impl(_Iter1 __first1, _Sent1 __last1, pair<_Iter1, _Iter1> __search_impl(_Iter1 __first1, _Sent1 __last1,
_Iter2 __first2, _Sent2 __last2, _Iter2 __first2, _Sent2 __last2,
_Pred& __pred, _Pred& __pred,
_Proj1& __proj1, _Proj1& __proj1,
_Proj2& __proj2, _Proj2& __proj2,
__enable_if_t<__is_cpp17_forward_iterator<_Iter1>::value __enable_if_t<__is_cpp17_forward_iterator<_Iter1>::value
&& __is_cpp17_forward_iterator<_Iter2>::value && __is_cpp17_forward_iterator<_Iter2>::value
&& !(__is_cpp17_random_access_iterator<_Iter1>::value && !(__is_cpp17_random_access_iterator<_Iter1>::value
&& __is_cpp17_random_access_iterator<_Iter2>::value)>* = nullptr) { && __is_cpp17_random_access_iterator<_Iter2>::value)>* = nullptr) {
return std::__search_forward_impl<_ClassicAlgPolicy>(__first1, __last1, return std::__search_forward_impl<_ClassicAlgPolicy>(__first1, __last1,
__first2, __last2, __first2, __last2,
__pred, __pred,
__proj1, __proj1,
__proj2); __proj2);
} }
template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate> template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
_ForwardIterator1 search(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator1 search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator2 __first2, _ForwardIterator2 __last2,
_BinaryPredicate __pred) { _BinaryPredicate __pred) {
static_assert(__is_callable<_BinaryPredicate, decltype(*__first1), decltype(*__first2)>::value, static_assert(__is_callable<_BinaryPredicate, decltype(*__first1), decltype(*__first2)>::value,
"BinaryPredicate has to be callable"); "BinaryPredicate has to be callable");
auto __proj = __identity(); auto __proj = __identity();
return std::__search_impl(__first1, __last1, __first2, __last2, __pred, __proj, __proj).first; return std::__search_impl(__first1, __last1, __first2, __last2, __pred, __proj, __proj).first;
} }
template <class _ForwardIterator1, class _ForwardIterator2> template <class _ForwardIterator1, class _ForwardIterator2>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
_ForwardIterator1 search(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator1 search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2, _ForwardIterator2 __last2) { _ForwardIterator2 __first2, _ForwardIterator2 __last2) {
using __v1 = typename iterator_traits<_ForwardIterator1>::value_type; using __v1 = typename iterator_traits<_ForwardIterator1>::value_type;
using __v2 = typename iterator_traits<_ForwardIterator2>::value_type; using __v2 = typename iterator_traits<_ForwardIterator2>::value_type;
return std::search(__first1, __last1, __first2, __last2, __equal_to<__v1, __v2>()); return std::search(__first1, __last1, __first2, __last2, __equal_to<__v1, __v2>());
} }
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER > 14
template <class _ForwardIterator, class _Searcher> template <class _ForwardIterator, class _Searcher>
_LIBCPP_NODISCARD_EXT _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _ForwardIterator _LIBCPP_NODISCARD_EXT _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 _ForwardIterator
search(_ForwardIterator __f, _ForwardIterator __l, const _Searcher& __s) { search(_ForwardIterator __f, _ForwardIterator __l, const _Searcher& __s) {
return __s(__f, __l).first; return __s(__f, __l).first;
} }
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_SEARCH_H #endif // _LIBCPP___ALGORITHM_SEARCH_H

libcxx/include/__algorithm/search_n.h

Show All 23 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 _AlgPolicy, class _Pred, class _Iter, class _Sent, class _SizeT, class _Type, class _Proj> template <class _AlgPolicy, class _Pred, class _Iter, class _Sent, class _SizeT, class _Type, class _Proj>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14
pair<_Iter, _Iter> __search_n_forward_impl(_Iter __first, _Sent __last, pair<_Iter, _Iter> __search_n_forward_impl(_Iter __first, _Sent __last,
_SizeT __count, _SizeT __count,
const _Type& __value, const _Type& __value,
_Pred& __pred, _Pred& __pred,
_Proj& __proj) { _Proj& __proj) {
if (__count <= 0) if (__count <= 0)
return std::make_pair(__first, __first); return std::make_pair(__first, __first);
while (true) { while (true) {
Show All 25 Lines while (true) {
++__first; ++__first;
break; break;
} // else there is a match, check next elements } // else there is a match, check next elements
} }
} }
} }
template <class _AlgPolicy, class _Pred, class _Iter, class _Sent, class _SizeT, class _Type, class _Proj, class _DiffT> template <class _AlgPolicy, class _Pred, class _Iter, class _Sent, class _SizeT, class _Type, class _Proj, class _DiffT>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14
std::pair<_Iter, _Iter> __search_n_random_access_impl(_Iter __first, _Sent __last, std::pair<_Iter, _Iter> __search_n_random_access_impl(_Iter __first, _Sent __last,
_SizeT __count, _SizeT __count,
const _Type& __value, const _Type& __value,
_Pred& __pred, _Pred& __pred,
_Proj& __proj, _Proj& __proj,
_DiffT __size1) { _DiffT __size1) {
using difference_type = typename iterator_traits<_Iter>::difference_type; using difference_type = typename iterator_traits<_Iter>::difference_type;
if (__count == 0) if (__count == 0)
Show All 34 Linesstd::pair<_Iter, _Iter> __search_n_random_access_impl(_Iter __first, _Sent __last,
} }
} }
template <class _Iter, class _Sent, template <class _Iter, class _Sent,
class _DiffT, class _DiffT,
class _Type, class _Type,
class _Pred, class _Pred,
class _Proj> class _Proj>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14
pair<_Iter, _Iter> __search_n_impl(_Iter __first, _Sent __last, pair<_Iter, _Iter> __search_n_impl(_Iter __first, _Sent __last,
_DiffT __count, _DiffT __count,
const _Type& __value, const _Type& __value,
_Pred& __pred, _Pred& __pred,
_Proj& __proj, _Proj& __proj,
__enable_if_t<__is_cpp17_random_access_iterator<_Iter>::value>* = nullptr) { __enable_if_t<__is_cpp17_random_access_iterator<_Iter>::value>* = nullptr) {
return std::__search_n_random_access_impl<_ClassicAlgPolicy>(__first, __last, return std::__search_n_random_access_impl<_ClassicAlgPolicy>(__first, __last,
__count, __count,
__value, __value,
__pred, __pred,
__proj, __proj,
__last - __first); __last - __first);
} }
template <class _Iter1, class _Sent1, template <class _Iter1, class _Sent1,
class _DiffT, class _DiffT,
class _Type, class _Type,
class _Pred, class _Pred,
class _Proj> class _Proj>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14
pair<_Iter1, _Iter1> __search_n_impl(_Iter1 __first, _Sent1 __last, pair<_Iter1, _Iter1> __search_n_impl(_Iter1 __first, _Sent1 __last,
_DiffT __count, _DiffT __count,
const _Type& __value, const _Type& __value,
_Pred& __pred, _Pred& __pred,
_Proj& __proj, _Proj& __proj,
__enable_if_t<__is_cpp17_forward_iterator<_Iter1>::value __enable_if_t<__is_cpp17_forward_iterator<_Iter1>::value
&& !__is_cpp17_random_access_iterator<_Iter1>::value>* = nullptr) { && !__is_cpp17_random_access_iterator<_Iter1>::value>* = nullptr) {
return std::__search_n_forward_impl<_ClassicAlgPolicy>(__first, __last, return std::__search_n_forward_impl<_ClassicAlgPolicy>(__first, __last,
__count, __count,
__value, __value,
__pred, __pred,
__proj); __proj);
} }
template <class _ForwardIterator, class _Size, class _Tp, class _BinaryPredicate> template <class _ForwardIterator, class _Size, class _Tp, class _BinaryPredicate>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
_ForwardIterator search_n(_ForwardIterator __first, _ForwardIterator __last, _ForwardIterator search_n(_ForwardIterator __first, _ForwardIterator __last,
_Size __count, _Size __count,
const _Tp& __value, const _Tp& __value,
_BinaryPredicate __pred) { _BinaryPredicate __pred) {
static_assert(__is_callable<_BinaryPredicate, decltype(*__first), const _Tp&>::value, static_assert(__is_callable<_BinaryPredicate, decltype(*__first), const _Tp&>::value,
"BinaryPredicate has to be callable"); "BinaryPredicate has to be callable");
auto __proj = __identity(); auto __proj = __identity();
return std::__search_n_impl(__first, __last, std::__convert_to_integral(__count), __value, __pred, __proj).first; return std::__search_n_impl(__first, __last, std::__convert_to_integral(__count), __value, __pred, __proj).first;
} }
template <class _ForwardIterator, class _Size, class _Tp> template <class _ForwardIterator, class _Size, class _Tp>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
_ForwardIterator search_n(_ForwardIterator __first, _ForwardIterator __last, _Size __count, const _Tp& __value) { _ForwardIterator search_n(_ForwardIterator __first, _ForwardIterator __last, _Size __count, const _Tp& __value) {
typedef typename iterator_traits<_ForwardIterator>::value_type __v; typedef typename iterator_traits<_ForwardIterator>::value_type __v;
return std::search_n(__first, __last, std::__convert_to_integral(__count), __value, __equal_to<__v, _Tp>()); return std::search_n(__first, __last, std::__convert_to_integral(__count), __value, __equal_to<__v, _Tp>());
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_SEARCH_N_H #endif // _LIBCPP___ALGORITHM_SEARCH_N_H

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_AFTER_CXX17 pair<__uncvref_t<_InIter1>, __uncvref_t<_OutIter> > _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20 pair<__uncvref_t<_InIter1>, __uncvref_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)) {
++__first2; ++__first2;
} else { } else {
++__first1; ++__first1;
++__first2; ++__first2;
} }
} }
return std::__copy(std::move(__first1), std::move(__last1), std::move(__result)); return std::__copy(std::move(__first1), std::move(__last1), std::move(__result));
} }
template <class _InputIterator1, class _InputIterator2, class _OutputIterator, class _Compare> template <class _InputIterator1, class _InputIterator2, class _OutputIterator, class _Compare>
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _OutputIterator set_difference( inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20 _OutputIterator set_difference(
_InputIterator1 __first1, _InputIterator1 __first1,
_InputIterator1 __last1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __first2,
_InputIterator2 __last2, _InputIterator2 __last2,
_OutputIterator __result, _OutputIterator __result,
_Compare __comp) { _Compare __comp) {
typedef typename __comp_ref_type<_Compare>::type _Comp_ref; typedef typename __comp_ref_type<_Compare>::type _Comp_ref;
return std::__set_difference<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __comp).second; return std::__set_difference<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __comp).second;
} }
template <class _InputIterator1, class _InputIterator2, class _OutputIterator> template <class _InputIterator1, class _InputIterator2, class _OutputIterator>
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _OutputIterator set_difference( inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20 _OutputIterator set_difference(
_InputIterator1 __first1, _InputIterator1 __first1,
_InputIterator1 __last1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __first2,
_InputIterator2 __last2, _InputIterator2 __last2,
_OutputIterator __result) { _OutputIterator __result) {
return std::__set_difference( return std::__set_difference(
__first1, __first1,
__last1, __last1,
Show All 10 Lines

libcxx/include/__algorithm/set_intersection.h

Show All 24 Lines
template <class _InIter1, class _InIter2, class _OutIter> template <class _InIter1, class _InIter2, class _OutIter>
struct __set_intersection_result { struct __set_intersection_result {
_InIter1 __in1_; _InIter1 __in1_;
_InIter2 __in2_; _InIter2 __in2_;
_OutIter __out_; _OutIter __out_;
// need a constructor as C++03 aggregate init is hard // need a constructor as C++03 aggregate init is hard
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
__set_intersection_result(_InIter1&& __in_iter1, _InIter2&& __in_iter2, _OutIter&& __out_iter) __set_intersection_result(_InIter1&& __in_iter1, _InIter2&& __in_iter2, _OutIter&& __out_iter)
: __in1_(std::move(__in_iter1)), __in2_(std::move(__in_iter2)), __out_(std::move(__out_iter)) {} : __in1_(std::move(__in_iter1)), __in2_(std::move(__in_iter2)), __out_(std::move(__out_iter)) {}
}; };
template <class _AlgPolicy, class _Compare, class _InIter1, class _Sent1, class _InIter2, class _Sent2, class _OutIter> template <class _AlgPolicy, class _Compare, class _InIter1, class _Sent1, class _InIter2, class _Sent2, class _OutIter>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 __set_intersection_result<_InIter1, _InIter2, _OutIter> _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20 __set_intersection_result<_InIter1, _InIter2, _OutIter>
__set_intersection( __set_intersection(
_InIter1 __first1, _Sent1 __last1, _InIter2 __first2, _Sent2 __last2, _OutIter __result, _Compare&& __comp) { _InIter1 __first1, _Sent1 __last1, _InIter2 __first2, _Sent2 __last2, _OutIter __result, _Compare&& __comp) {
while (__first1 != __last1 && __first2 != __last2) { while (__first1 != __last1 && __first2 != __last2) {
if (__comp(*__first1, *__first2)) if (__comp(*__first1, *__first2))
++__first1; ++__first1;
else { else {
if (!__comp(*__first2, *__first1)) { if (!__comp(*__first2, *__first1)) {
*__result = *__first1; *__result = *__first1;
++__result; ++__result;
++__first1; ++__first1;
} }
++__first2; ++__first2;
} }
} }
return __set_intersection_result<_InIter1, _InIter2, _OutIter>( return __set_intersection_result<_InIter1, _InIter2, _OutIter>(
_IterOps<_AlgPolicy>::next(std::move(__first1), std::move(__last1)), _IterOps<_AlgPolicy>::next(std::move(__first1), std::move(__last1)),
_IterOps<_AlgPolicy>::next(std::move(__first2), std::move(__last2)), _IterOps<_AlgPolicy>::next(std::move(__first2), std::move(__last2)),
std::move(__result)); std::move(__result));
} }
template <class _InputIterator1, class _InputIterator2, class _OutputIterator, class _Compare> template <class _InputIterator1, class _InputIterator2, class _OutputIterator, class _Compare>
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _OutputIterator set_intersection( inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20 _OutputIterator set_intersection(
_InputIterator1 __first1, _InputIterator1 __first1,
_InputIterator1 __last1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __first2,
_InputIterator2 __last2, _InputIterator2 __last2,
_OutputIterator __result, _OutputIterator __result,
_Compare __comp) { _Compare __comp) {
typedef typename __comp_ref_type<_Compare>::type _Comp_ref; typedef typename __comp_ref_type<_Compare>::type _Comp_ref;
return std::__set_intersection<_ClassicAlgPolicy, _Comp_ref>( return std::__set_intersection<_ClassicAlgPolicy, _Comp_ref>(
std::move(__first1), std::move(__first1),
std::move(__last1), std::move(__last1),
std::move(__first2), std::move(__first2),
std::move(__last2), std::move(__last2),
std::move(__result), std::move(__result),
__comp) __comp)
.__out_; .__out_;
} }
template <class _InputIterator1, class _InputIterator2, class _OutputIterator> template <class _InputIterator1, class _InputIterator2, class _OutputIterator>
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _OutputIterator set_intersection( inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20 _OutputIterator set_intersection(
_InputIterator1 __first1, _InputIterator1 __first1,
_InputIterator1 __last1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __first2,
_InputIterator2 __last2, _InputIterator2 __last2,
_OutputIterator __result) { _OutputIterator __result) {
return std::__set_intersection<_ClassicAlgPolicy>( return std::__set_intersection<_ClassicAlgPolicy>(
std::move(__first1), std::move(__first1),
std::move(__last1), std::move(__last1),
Show All 11 Lines

libcxx/include/__algorithm/set_symmetric_difference.h

Show All 23 Lines
template <class _InIter1, class _InIter2, class _OutIter> template <class _InIter1, class _InIter2, class _OutIter>
struct __set_symmetric_difference_result { struct __set_symmetric_difference_result {
_InIter1 __in1_; _InIter1 __in1_;
_InIter2 __in2_; _InIter2 __in2_;
_OutIter __out_; _OutIter __out_;
// need a constructor as C++03 aggregate init is hard // need a constructor as C++03 aggregate init is hard
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
__set_symmetric_difference_result(_InIter1&& __in_iter1, _InIter2&& __in_iter2, _OutIter&& __out_iter) __set_symmetric_difference_result(_InIter1&& __in_iter1, _InIter2&& __in_iter2, _OutIter&& __out_iter)
: __in1_(std::move(__in_iter1)), __in2_(std::move(__in_iter2)), __out_(std::move(__out_iter)) {} : __in1_(std::move(__in_iter1)), __in2_(std::move(__in_iter2)), __out_(std::move(__out_iter)) {}
}; };
template <class _Compare, class _InIter1, class _Sent1, class _InIter2, class _Sent2, class _OutIter> template <class _Compare, class _InIter1, class _Sent1, class _InIter2, class _Sent2, class _OutIter>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 __set_symmetric_difference_result<_InIter1, _InIter2, _OutIter> _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20 __set_symmetric_difference_result<_InIter1, _InIter2, _OutIter>
__set_symmetric_difference( __set_symmetric_difference(
_InIter1 __first1, _Sent1 __last1, _InIter2 __first2, _Sent2 __last2, _OutIter __result, _Compare&& __comp) { _InIter1 __first1, _Sent1 __last1, _InIter2 __first2, _Sent2 __last2, _OutIter __result, _Compare&& __comp) {
while (__first1 != __last1) { while (__first1 != __last1) {
if (__first2 == __last2) { if (__first2 == __last2) {
auto __ret1 = std::__copy_impl(std::move(__first1), std::move(__last1), std::move(__result)); auto __ret1 = std::__copy_impl(std::move(__first1), std::move(__last1), std::move(__result));
return __set_symmetric_difference_result<_InIter1, _InIter2, _OutIter>( return __set_symmetric_difference_result<_InIter1, _InIter2, _OutIter>(
std::move(__ret1.first), std::move(__first2), std::move((__ret1.second))); std::move(__ret1.first), std::move(__first2), std::move((__ret1.second)));
} }
Show All 12 Lines while (__first1 != __last1) {
} }
} }
auto __ret2 = std::__copy_impl(std::move(__first2), std::move(__last2), std::move(__result)); auto __ret2 = std::__copy_impl(std::move(__first2), std::move(__last2), std::move(__result));
return __set_symmetric_difference_result<_InIter1, _InIter2, _OutIter>( return __set_symmetric_difference_result<_InIter1, _InIter2, _OutIter>(
std::move(__first1), std::move(__ret2.first), std::move((__ret2.second))); std::move(__first1), std::move(__ret2.first), std::move((__ret2.second)));
} }
template <class _InputIterator1, class _InputIterator2, class _OutputIterator, class _Compare> template <class _InputIterator1, class _InputIterator2, class _OutputIterator, class _Compare>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _OutputIterator set_symmetric_difference( _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20 _OutputIterator set_symmetric_difference(
_InputIterator1 __first1, _InputIterator1 __first1,
_InputIterator1 __last1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __first2,
_InputIterator2 __last2, _InputIterator2 __last2,
_OutputIterator __result, _OutputIterator __result,
_Compare __comp) { _Compare __comp) {
typedef typename __comp_ref_type<_Compare>::type _Comp_ref; typedef typename __comp_ref_type<_Compare>::type _Comp_ref;
return std::__set_symmetric_difference<_Comp_ref>( return std::__set_symmetric_difference<_Comp_ref>(
std::move(__first1), std::move(__first1),
std::move(__last1), std::move(__last1),
std::move(__first2), std::move(__first2),
std::move(__last2), std::move(__last2),
std::move(__result), std::move(__result),
__comp) __comp)
.__out_; .__out_;
} }
template <class _InputIterator1, class _InputIterator2, class _OutputIterator> template <class _InputIterator1, class _InputIterator2, class _OutputIterator>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _OutputIterator set_symmetric_difference( _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20 _OutputIterator set_symmetric_difference(
_InputIterator1 __first1, _InputIterator1 __first1,
_InputIterator1 __last1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __first2,
_InputIterator2 __last2, _InputIterator2 __last2,
_OutputIterator __result) { _OutputIterator __result) {
return std::set_symmetric_difference( return std::set_symmetric_difference(
std::move(__first1), std::move(__first1),
std::move(__last1), std::move(__last1),
Show All 10 Lines

libcxx/include/__algorithm/set_union.h

Show All 23 Lines
template <class _InIter1, class _InIter2, class _OutIter> template <class _InIter1, class _InIter2, class _OutIter>
struct __set_union_result { struct __set_union_result {
_InIter1 __in1_; _InIter1 __in1_;
_InIter2 __in2_; _InIter2 __in2_;
_OutIter __out_; _OutIter __out_;
// need a constructor as C++03 aggregate init is hard // need a constructor as C++03 aggregate init is hard
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
__set_union_result(_InIter1&& __in_iter1, _InIter2&& __in_iter2, _OutIter&& __out_iter) __set_union_result(_InIter1&& __in_iter1, _InIter2&& __in_iter2, _OutIter&& __out_iter)
: __in1_(std::move(__in_iter1)), __in2_(std::move(__in_iter2)), __out_(std::move(__out_iter)) {} : __in1_(std::move(__in_iter1)), __in2_(std::move(__in_iter2)), __out_(std::move(__out_iter)) {}
}; };
template <class _Compare, class _InIter1, class _Sent1, class _InIter2, class _Sent2, class _OutIter> template <class _Compare, class _InIter1, class _Sent1, class _InIter2, class _Sent2, class _OutIter>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 __set_union_result<_InIter1, _InIter2, _OutIter> __set_union( _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20 __set_union_result<_InIter1, _InIter2, _OutIter> __set_union(
_InIter1 __first1, _Sent1 __last1, _InIter2 __first2, _Sent2 __last2, _OutIter __result, _Compare&& __comp) { _InIter1 __first1, _Sent1 __last1, _InIter2 __first2, _Sent2 __last2, _OutIter __result, _Compare&& __comp) {
for (; __first1 != __last1; ++__result) { for (; __first1 != __last1; ++__result) {
if (__first2 == __last2) { if (__first2 == __last2) {
auto __ret1 = std::__copy_impl(std::move(__first1), std::move(__last1), std::move(__result)); auto __ret1 = std::__copy_impl(std::move(__first1), std::move(__last1), std::move(__result));
return __set_union_result<_InIter1, _InIter2, _OutIter>( return __set_union_result<_InIter1, _InIter2, _OutIter>(
std::move(__ret1.first), std::move(__first2), std::move((__ret1.second))); std::move(__ret1.first), std::move(__first2), std::move((__ret1.second)));
} }
if (__comp(*__first2, *__first1)) { if (__comp(*__first2, *__first1)) {
*__result = *__first2; *__result = *__first2;
++__first2; ++__first2;
} else { } else {
if (!__comp(*__first1, *__first2)) { if (!__comp(*__first1, *__first2)) {
++__first2; ++__first2;
} }
*__result = *__first1; *__result = *__first1;
++__first1; ++__first1;
} }
} }
auto __ret2 = std::__copy_impl(std::move(__first2), std::move(__last2), std::move(__result)); auto __ret2 = std::__copy_impl(std::move(__first2), std::move(__last2), std::move(__result));
return __set_union_result<_InIter1, _InIter2, _OutIter>( return __set_union_result<_InIter1, _InIter2, _OutIter>(
std::move(__first1), std::move(__ret2.first), std::move((__ret2.second))); std::move(__first1), std::move(__ret2.first), std::move((__ret2.second)));
} }
template <class _InputIterator1, class _InputIterator2, class _OutputIterator, class _Compare> template <class _InputIterator1, class _InputIterator2, class _OutputIterator, class _Compare>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _OutputIterator set_union( _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20 _OutputIterator set_union(
_InputIterator1 __first1, _InputIterator1 __first1,
_InputIterator1 __last1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __first2,
_InputIterator2 __last2, _InputIterator2 __last2,
_OutputIterator __result, _OutputIterator __result,
_Compare __comp) { _Compare __comp) {
typedef typename __comp_ref_type<_Compare>::type _Comp_ref; typedef typename __comp_ref_type<_Compare>::type _Comp_ref;
return std::__set_union<_Comp_ref>( return std::__set_union<_Comp_ref>(
std::move(__first1), std::move(__first1),
std::move(__last1), std::move(__last1),
std::move(__first2), std::move(__first2),
std::move(__last2), std::move(__last2),
std::move(__result), std::move(__result),
__comp) __comp)
.__out_; .__out_;
} }
template <class _InputIterator1, class _InputIterator2, class _OutputIterator> template <class _InputIterator1, class _InputIterator2, class _OutputIterator>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _OutputIterator set_union( _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20 _OutputIterator set_union(
_InputIterator1 __first1, _InputIterator1 __first1,
_InputIterator1 __last1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __first2,
_InputIterator2 __last2, _InputIterator2 __last2,
_OutputIterator __result) { _OutputIterator __result) {
return std::set_union( return std::set_union(
std::move(__first1), std::move(__first1),
std::move(__last1), std::move(__last1),
Show All 10 Lines

libcxx/include/__algorithm/sift_down.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 _AlgPolicy, class _Compare, class _RandomAccessIterator> template <class _AlgPolicy, class _Compare, class _RandomAccessIterator>
_LIBCPP_CONSTEXPR_AFTER_CXX11 void _LIBCPP_CONSTEXPR_CXX14 void
__sift_down(_RandomAccessIterator __first, _Compare&& __comp, __sift_down(_RandomAccessIterator __first, _Compare&& __comp,
typename iterator_traits<_RandomAccessIterator>::difference_type __len, typename iterator_traits<_RandomAccessIterator>::difference_type __len,
_RandomAccessIterator __start) _RandomAccessIterator __start)
{ {
using _Ops = _IterOps<_AlgPolicy>; using _Ops = _IterOps<_AlgPolicy>;
typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type; typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type; typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type;
Show All 39 Lines do
} }
// check if we are in heap-order // check if we are in heap-order
} while (!__comp(*__child_i, __top)); } while (!__comp(*__child_i, __top));
*__start = _VSTD::move(__top); *__start = _VSTD::move(__top);
} }
template <class _AlgPolicy, class _Compare, class _RandomAccessIterator> template <class _AlgPolicy, class _Compare, class _RandomAccessIterator>
_LIBCPP_CONSTEXPR_AFTER_CXX11 _RandomAccessIterator _LIBCPP_CONSTEXPR_CXX14 _RandomAccessIterator
__floyd_sift_down(_RandomAccessIterator __first, _Compare&& __comp, __floyd_sift_down(_RandomAccessIterator __first, _Compare&& __comp,
typename iterator_traits<_RandomAccessIterator>::difference_type __len) typename iterator_traits<_RandomAccessIterator>::difference_type __len)
{ {
using difference_type = typename iterator_traits<_RandomAccessIterator>::difference_type; using difference_type = typename iterator_traits<_RandomAccessIterator>::difference_type;
_LIBCPP_ASSERT(__len >= 2, "shouldn't be called unless __len >= 2"); _LIBCPP_ASSERT(__len >= 2, "shouldn't be called unless __len >= 2");
_RandomAccessIterator __hole = __first; _RandomAccessIterator __hole = __first;
_RandomAccessIterator __child_i = __first; _RandomAccessIterator __child_i = __first;
Show All 25 Lines

libcxx/include/__algorithm/sort.h

Show All 37 Lines
template <class _PolicyT, class _CompT, class = void> template <class _PolicyT, class _CompT, class = void>
struct _WrapAlgPolicy { struct _WrapAlgPolicy {
using type = _WrapAlgPolicy; using type = _WrapAlgPolicy;
using _AlgPolicy = _PolicyT; using _AlgPolicy = _PolicyT;
using _Comp = _CompT; using _Comp = _CompT;
_Comp& __comp; _Comp& __comp;
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14
_WrapAlgPolicy(_Comp& __c) : __comp(__c) {} _WrapAlgPolicy(_Comp& __c) : __comp(__c) {}
}; };
// Specialization for the "classic" policy tag that avoids creating a struct and simply defines an alias for the // Specialization for the "classic" policy tag that avoids creating a struct and simply defines an alias for the
// comparator. When unwrapping, a pristine comparator is always considered to have the "classic" tag attached. Passing // comparator. When unwrapping, a pristine comparator is always considered to have the "classic" tag attached. Passing
// the pristine comparator where possible allows using template instantiations from the dylib. // the pristine comparator where possible allows using template instantiations from the dylib.
template <class _PolicyT, class _CompT> template <class _PolicyT, class _CompT>
struct _WrapAlgPolicy<_PolicyT, _CompT, __enable_if_t<std::is_same<_PolicyT, _ClassicAlgPolicy>::value> > { struct _WrapAlgPolicy<_PolicyT, _CompT, __enable_if_t<std::is_same<_PolicyT, _ClassicAlgPolicy>::value> > {
using type = _CompT; using type = _CompT;
}; };
// Unwraps a pristine functor (e.g. `std::less`) as if it were wrapped using `_WrapAlgPolicy`. The policy tag is always // Unwraps a pristine functor (e.g. `std::less`) as if it were wrapped using `_WrapAlgPolicy`. The policy tag is always
// set to "classic". // set to "classic".
template <class _CompT> template <class _CompT>
struct _UnwrapAlgPolicy { struct _UnwrapAlgPolicy {
using _AlgPolicy = _ClassicAlgPolicy; using _AlgPolicy = _ClassicAlgPolicy;
using _Comp = _CompT; using _Comp = _CompT;
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 static _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14 static
_Comp __get_comp(_Comp __comp) { return __comp; } _Comp __get_comp(_Comp __comp) { return __comp; }
}; };
// Unwraps a `_WrapAlgPolicy` struct. // Unwraps a `_WrapAlgPolicy` struct.
template <class... _Ts> template <class... _Ts>
struct _UnwrapAlgPolicy<_WrapAlgPolicy<_Ts...> > { struct _UnwrapAlgPolicy<_WrapAlgPolicy<_Ts...> > {
using _Wrapped = _WrapAlgPolicy<_Ts...>; using _Wrapped = _WrapAlgPolicy<_Ts...>;
using _AlgPolicy = typename _Wrapped::_AlgPolicy; using _AlgPolicy = typename _Wrapped::_AlgPolicy;
using _Comp = typename _Wrapped::_Comp; using _Comp = typename _Wrapped::_Comp;
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 static _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14 static
_Comp __get_comp(_Wrapped& __w) { return __w.__comp; } _Comp __get_comp(_Wrapped& __w) { return __w.__comp; }
}; };
// stable, 2-3 compares, 0-2 swaps // stable, 2-3 compares, 0-2 swaps
template <class _AlgPolicy, class _Compare, class _ForwardIterator> template <class _AlgPolicy, class _Compare, class _ForwardIterator>
_LIBCPP_CONSTEXPR_AFTER_CXX11 unsigned __sort3(_ForwardIterator __x, _ForwardIterator __y, _ForwardIterator __z, _LIBCPP_CONSTEXPR_CXX14 unsigned __sort3(_ForwardIterator __x, _ForwardIterator __y, _ForwardIterator __z,
_Compare __c) { _Compare __c) {
using _Ops = _IterOps<_AlgPolicy>; using _Ops = _IterOps<_AlgPolicy>;
unsigned __r = 0; unsigned __r = 0;
if (!__c(*__y, *__x)) // if x <= y if (!__c(*__y, *__x)) // if x <= y
{ {
if (!__c(*__z, *__y)) // if y <= z if (!__c(*__z, *__y)) // if y <= z
return __r; // x <= y && y <= z return __r; // x <= y && y <= z
▲ Show 20 Lines • Show All 184 Lines • ▼ Show 20 Lines
inline _LIBCPP_HIDE_FROM_ABI __enable_if_t<!__use_branchless_sort<_Compare, _RandomAccessIterator>::value, void> inline _LIBCPP_HIDE_FROM_ABI __enable_if_t<!__use_branchless_sort<_Compare, _RandomAccessIterator>::value, void>
__sort5_maybe_branchless(_RandomAccessIterator __x1, _RandomAccessIterator __x2, _RandomAccessIterator __x3, __sort5_maybe_branchless(_RandomAccessIterator __x1, _RandomAccessIterator __x2, _RandomAccessIterator __x3,
_RandomAccessIterator __x4, _RandomAccessIterator __x5, _Compare __c) { _RandomAccessIterator __x4, _RandomAccessIterator __x5, _Compare __c) {
std::__sort5_wrap_policy<_AlgPolicy, _Compare>(__x1, __x2, __x3, __x4, __x5, __c); std::__sort5_wrap_policy<_AlgPolicy, _Compare>(__x1, __x2, __x3, __x4, __x5, __c);
} }
// Assumes size > 0 // Assumes size > 0
template <class _AlgPolicy, class _Compare, class _BidirectionalIterator> template <class _AlgPolicy, class _Compare, class _BidirectionalIterator>
_LIBCPP_CONSTEXPR_AFTER_CXX11 void __selection_sort(_BidirectionalIterator __first, _BidirectionalIterator __last, _LIBCPP_CONSTEXPR_CXX14 void __selection_sort(_BidirectionalIterator __first, _BidirectionalIterator __last,
_Compare __comp) { _Compare __comp) {
_BidirectionalIterator __lm1 = __last; _BidirectionalIterator __lm1 = __last;
for (--__lm1; __first != __lm1; ++__first) { for (--__lm1; __first != __lm1; ++__first) {
_BidirectionalIterator __i = std::__min_element<_Compare>(__first, __last, __comp); _BidirectionalIterator __i = std::__min_element<_Compare>(__first, __last, __comp);
if (__i != __first) if (__i != __first)
_IterOps<_AlgPolicy>::iter_swap(__first, __i); _IterOps<_AlgPolicy>::iter_swap(__first, __i);
} }
} }
▲ Show 20 Lines • Show All 374 Lines • ▼ Show 20 Lines
extern template _LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<unsigned long long>&, unsigned long long*>(unsigned long long*, unsigned long long*, __less<unsigned long long>&); extern template _LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<unsigned long long>&, unsigned long long*>(unsigned long long*, unsigned long long*, __less<unsigned long long>&);
extern template _LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<float>&, float*>(float*, float*, __less<float>&); extern template _LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<float>&, float*>(float*, float*, __less<float>&);
extern template _LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<double>&, double*>(double*, double*, __less<double>&); extern template _LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<double>&, double*>(double*, double*, __less<double>&);
extern template _LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<long double>&, long double*>(long double*, long double*, __less<long double>&); extern template _LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<long double>&, long double*>(long double*, long double*, __less<long double>&);
extern template _LIBCPP_FUNC_VIS unsigned __sort5<__less<long double>&, long double*>(long double*, long double*, long double*, long double*, long double*, __less<long double>&); extern template _LIBCPP_FUNC_VIS unsigned __sort5<__less<long double>&, long double*>(long double*, long double*, long double*, long double*, long double*, __less<long double>&);
template <class _AlgPolicy, class _RandomAccessIterator, class _Comp> template <class _AlgPolicy, class _RandomAccessIterator, class _Comp>
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
void __sort_impl(_RandomAccessIterator __first, _RandomAccessIterator __last, _Comp& __comp) { void __sort_impl(_RandomAccessIterator __first, _RandomAccessIterator __last, _Comp& __comp) {
std::__debug_randomize_range<_AlgPolicy>(__first, __last); std::__debug_randomize_range<_AlgPolicy>(__first, __last);
using _Comp_ref = typename __comp_ref_type<_Comp>::type; using _Comp_ref = typename __comp_ref_type<_Comp>::type;
if (__libcpp_is_constant_evaluated()) { if (__libcpp_is_constant_evaluated()) {
std::__partial_sort<_AlgPolicy>(__first, __last, __last, __comp); std::__partial_sort<_AlgPolicy>(__first, __last, __last, __comp);
} else { } else {
using _WrappedComp = typename _WrapAlgPolicy<_AlgPolicy, _Comp_ref>::type; using _WrappedComp = typename _WrapAlgPolicy<_AlgPolicy, _Comp_ref>::type;
_Comp_ref __comp_ref(__comp); _Comp_ref __comp_ref(__comp);
_WrappedComp __wrapped_comp(__comp_ref); _WrappedComp __wrapped_comp(__comp_ref);
std::__sort<_WrappedComp>(std::__unwrap_iter(__first), std::__unwrap_iter(__last), __wrapped_comp); std::__sort<_WrappedComp>(std::__unwrap_iter(__first), std::__unwrap_iter(__last), __wrapped_comp);
} }
} }
template <class _RandomAccessIterator, class _Comp> template <class _RandomAccessIterator, class _Comp>
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
void sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Comp __comp) { void sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Comp __comp) {
std::__sort_impl<_ClassicAlgPolicy>(std::move(__first), std::move(__last), __comp); std::__sort_impl<_ClassicAlgPolicy>(std::move(__first), std::move(__last), __comp);
} }
template <class _RandomAccessIterator> template <class _RandomAccessIterator>
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
void sort(_RandomAccessIterator __first, _RandomAccessIterator __last) { void sort(_RandomAccessIterator __first, _RandomAccessIterator __last) {
std::sort(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>()); std::sort(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_SORT_H #endif // _LIBCPP___ALGORITHM_SORT_H

libcxx/include/__algorithm/sort_heap.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 _AlgPolicy, class _Compare, class _RandomAccessIterator> template <class _AlgPolicy, class _Compare, class _RandomAccessIterator>
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14
void __sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare&& __comp) { void __sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare&& __comp) {
using _CompRef = typename __comp_ref_type<_Compare>::type; using _CompRef = typename __comp_ref_type<_Compare>::type;
_CompRef __comp_ref = __comp; _CompRef __comp_ref = __comp;
using difference_type = typename iterator_traits<_RandomAccessIterator>::difference_type; using difference_type = typename iterator_traits<_RandomAccessIterator>::difference_type;
for (difference_type __n = __last - __first; __n > 1; --__last, (void) --__n) for (difference_type __n = __last - __first; __n > 1; --__last, (void) --__n)
std::__pop_heap<_AlgPolicy>(__first, __last, __comp_ref, __n); std::__pop_heap<_AlgPolicy>(__first, __last, __comp_ref, __n);
} }
template <class _RandomAccessIterator, class _Compare> template <class _RandomAccessIterator, class _Compare>
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
void sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) { void sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) {
static_assert(std::is_copy_constructible<_RandomAccessIterator>::value, "Iterators must be copy constructible."); static_assert(std::is_copy_constructible<_RandomAccessIterator>::value, "Iterators must be copy constructible.");
static_assert(std::is_copy_assignable<_RandomAccessIterator>::value, "Iterators must be copy assignable."); static_assert(std::is_copy_assignable<_RandomAccessIterator>::value, "Iterators must be copy assignable.");
std::__sort_heap<_ClassicAlgPolicy>(std::move(__first), std::move(__last), __comp); std::__sort_heap<_ClassicAlgPolicy>(std::move(__first), std::move(__last), __comp);
} }
template <class _RandomAccessIterator> template <class _RandomAccessIterator>
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
void sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) { void sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) {
std::sort_heap(std::move(__first), std::move(__last), std::sort_heap(std::move(__first), std::move(__last),
__less<typename iterator_traits<_RandomAccessIterator>::value_type>()); __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_SORT_HEAP_H #endif // _LIBCPP___ALGORITHM_SORT_HEAP_H

libcxx/include/__algorithm/swap_ranges.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
// 2+2 iterators: the shorter size will be used. // 2+2 iterators: the shorter size will be used.
template <class _AlgPolicy, class _ForwardIterator1, class _Sentinel1, class _ForwardIterator2, class _Sentinel2> template <class _AlgPolicy, class _ForwardIterator1, class _Sentinel1, class _ForwardIterator2, class _Sentinel2>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
pair<_ForwardIterator1, _ForwardIterator2> pair<_ForwardIterator1, _ForwardIterator2>
__swap_ranges(_ForwardIterator1 __first1, _Sentinel1 __last1, _ForwardIterator2 __first2, _Sentinel2 __last2) { __swap_ranges(_ForwardIterator1 __first1, _Sentinel1 __last1, _ForwardIterator2 __first2, _Sentinel2 __last2) {
while (__first1 != __last1 && __first2 != __last2) { while (__first1 != __last1 && __first2 != __last2) {
_IterOps<_AlgPolicy>::iter_swap(__first1, __first2); _IterOps<_AlgPolicy>::iter_swap(__first1, __first2);
++__first1; ++__first1;
++__first2; ++__first2;
} }
return pair<_ForwardIterator1, _ForwardIterator2>(std::move(__first1), std::move(__first2)); return pair<_ForwardIterator1, _ForwardIterator2>(std::move(__first1), std::move(__first2));
} }
// 2+1 iterators: size2 >= size1. // 2+1 iterators: size2 >= size1.
template <class _AlgPolicy, class _ForwardIterator1, class _Sentinel1, class _ForwardIterator2> template <class _AlgPolicy, class _ForwardIterator1, class _Sentinel1, class _ForwardIterator2>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
pair<_ForwardIterator1, _ForwardIterator2> pair<_ForwardIterator1, _ForwardIterator2>
__swap_ranges(_ForwardIterator1 __first1, _Sentinel1 __last1, _ForwardIterator2 __first2) { __swap_ranges(_ForwardIterator1 __first1, _Sentinel1 __last1, _ForwardIterator2 __first2) {
while (__first1 != __last1) { while (__first1 != __last1) {
_IterOps<_AlgPolicy>::iter_swap(__first1, __first2); _IterOps<_AlgPolicy>::iter_swap(__first1, __first2);
++__first1; ++__first1;
++__first2; ++__first2;
} }
return pair<_ForwardIterator1, _ForwardIterator2>(std::move(__first1), std::move(__first2)); return pair<_ForwardIterator1, _ForwardIterator2>(std::move(__first1), std::move(__first2));
} }
template <class _ForwardIterator1, class _ForwardIterator2> template <class _ForwardIterator1, class _ForwardIterator2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _ForwardIterator2 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 _ForwardIterator2
swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2) { swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2) {
return std::__swap_ranges<_ClassicAlgPolicy>( return std::__swap_ranges<_ClassicAlgPolicy>(
std::move(__first1), std::move(__last1), std::move(__first2)).second; std::move(__first1), std::move(__last1), std::move(__first2)).second;
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_SWAP_RANGES_H #endif // _LIBCPP___ALGORITHM_SWAP_RANGES_H

libcxx/include/__algorithm/transform.h

Show All 12 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 _InputIterator, class _OutputIterator, class _UnaryOperation> template <class _InputIterator, class _OutputIterator, class _UnaryOperation>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
_OutputIterator _OutputIterator
transform(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _UnaryOperation __op) transform(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _UnaryOperation __op)
{ {
for (; __first != __last; ++__first, (void) ++__result) for (; __first != __last; ++__first, (void) ++__result)
*__result = __op(*__first); *__result = __op(*__first);
return __result; return __result;
} }
template <class _InputIterator1, class _InputIterator2, class _OutputIterator, class _BinaryOperation> template <class _InputIterator1, class _InputIterator2, class _OutputIterator, class _BinaryOperation>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
_OutputIterator _OutputIterator
transform(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, transform(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2,
_OutputIterator __result, _BinaryOperation __binary_op) _OutputIterator __result, _BinaryOperation __binary_op)
{ {
for (; __first1 != __last1; ++__first1, (void) ++__first2, ++__result) for (; __first1 != __last1; ++__first1, (void) ++__first2, ++__result)
*__result = __binary_op(*__first1, *__first2); *__result = __binary_op(*__first1, *__first2);
return __result; return __result;
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_TRANSFORM_H #endif // _LIBCPP___ALGORITHM_TRANSFORM_H

libcxx/include/__algorithm/unique.h

Show All 20 Lines
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
// unique // unique
template <class _AlgPolicy, class _Iter, class _Sent, class _BinaryPredicate> template <class _AlgPolicy, class _Iter, class _Sent, class _BinaryPredicate>
_LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 std::pair<_Iter, _Iter> _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20 std::pair<_Iter, _Iter>
__unique(_Iter __first, _Sent __last, _BinaryPredicate&& __pred) { __unique(_Iter __first, _Sent __last, _BinaryPredicate&& __pred) {
__first = std::__adjacent_find(__first, __last, __pred); __first = std::__adjacent_find(__first, __last, __pred);
if (__first != __last) { if (__first != __last) {
// ... a a ? ... // ... a a ? ...
// f i // f i
_Iter __i = __first; _Iter __i = __first;
for (++__i; ++__i != __last;) for (++__i; ++__i != __last;)
if (!__pred(*__first, *__i)) if (!__pred(*__first, *__i))
*++__first = _IterOps<_AlgPolicy>::__iter_move(__i); *++__first = _IterOps<_AlgPolicy>::__iter_move(__i);
++__first; ++__first;
return std::pair<_Iter, _Iter>(std::move(__first), std::move(__i)); return std::pair<_Iter, _Iter>(std::move(__first), std::move(__i));
} }
return std::pair<_Iter, _Iter>(__first, __first); return std::pair<_Iter, _Iter>(__first, __first);
} }
template <class _ForwardIterator, class _BinaryPredicate> template <class _ForwardIterator, class _BinaryPredicate>
_LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _ForwardIterator _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20 _ForwardIterator
unique(_ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred) { unique(_ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred) {
return std::__unique<_ClassicAlgPolicy>(std::move(__first), std::move(__last), __pred).first; return std::__unique<_ClassicAlgPolicy>(std::move(__first), std::move(__last), __pred).first;
} }
template <class _ForwardIterator> template <class _ForwardIterator>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _ForwardIterator _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20 _ForwardIterator
unique(_ForwardIterator __first, _ForwardIterator __last) { unique(_ForwardIterator __first, _ForwardIterator __last) {
typedef typename iterator_traits<_ForwardIterator>::value_type __v; typedef typename iterator_traits<_ForwardIterator>::value_type __v;
return std::unique(__first, __last, __equal_to<__v>()); return std::unique(__first, __last, __equal_to<__v>());
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_UNIQUE_H #endif // _LIBCPP___ALGORITHM_UNIQUE_H

libcxx/include/__algorithm/unique_copy.h

Show All 28 Lines
struct __reread_from_input_tag {}; struct __reread_from_input_tag {};
struct __reread_from_output_tag {}; struct __reread_from_output_tag {};
struct __read_from_tmp_value_tag {}; struct __read_from_tmp_value_tag {};
} // namespace __unique_copy_tags } // namespace __unique_copy_tags
template <class _AlgPolicy, class _BinaryPredicate, class _InputIterator, class _Sent, class _OutputIterator> template <class _AlgPolicy, class _BinaryPredicate, class _InputIterator, class _Sent, class _OutputIterator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI pair<_InputIterator, _OutputIterator> _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_HIDE_FROM_ABI pair<_InputIterator, _OutputIterator>
__unique_copy(_InputIterator __first, __unique_copy(_InputIterator __first,
_Sent __last, _Sent __last,
_OutputIterator __result, _OutputIterator __result,
_BinaryPredicate&& __pred, _BinaryPredicate&& __pred,
__unique_copy_tags::__read_from_tmp_value_tag) { __unique_copy_tags::__read_from_tmp_value_tag) {
if (__first != __last) { if (__first != __last) {
typename _IterOps<_AlgPolicy>::template __value_type<_InputIterator> __t(*__first); typename _IterOps<_AlgPolicy>::template __value_type<_InputIterator> __t(*__first);
*__result = __t; *__result = __t;
++__result; ++__result;
while (++__first != __last) { while (++__first != __last) {
if (!__pred(__t, *__first)) { if (!__pred(__t, *__first)) {
__t = *__first; __t = *__first;
*__result = __t; *__result = __t;
++__result; ++__result;
} }
} }
} }
return pair<_InputIterator, _OutputIterator>(std::move(__first), std::move(__result)); return pair<_InputIterator, _OutputIterator>(std::move(__first), std::move(__result));
} }
template <class _AlgPolicy, class _BinaryPredicate, class _ForwardIterator, class _Sent, class _OutputIterator> template <class _AlgPolicy, class _BinaryPredicate, class _ForwardIterator, class _Sent, class _OutputIterator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI pair<_ForwardIterator, _OutputIterator> _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_HIDE_FROM_ABI pair<_ForwardIterator, _OutputIterator>
__unique_copy(_ForwardIterator __first, __unique_copy(_ForwardIterator __first,
_Sent __last, _Sent __last,
_OutputIterator __result, _OutputIterator __result,
_BinaryPredicate&& __pred, _BinaryPredicate&& __pred,
__unique_copy_tags::__reread_from_input_tag) { __unique_copy_tags::__reread_from_input_tag) {
if (__first != __last) { if (__first != __last) {
_ForwardIterator __i = __first; _ForwardIterator __i = __first;
*__result = *__i; *__result = *__i;
++__result; ++__result;
while (++__first != __last) { while (++__first != __last) {
if (!__pred(*__i, *__first)) { if (!__pred(*__i, *__first)) {
*__result = *__first; *__result = *__first;
++__result; ++__result;
__i = __first; __i = __first;
} }
} }
} }
return pair<_ForwardIterator, _OutputIterator>(std::move(__first), std::move(__result)); return pair<_ForwardIterator, _OutputIterator>(std::move(__first), std::move(__result));
} }
template <class _AlgPolicy, class _BinaryPredicate, class _InputIterator, class _Sent, class _InputAndOutputIterator> template <class _AlgPolicy, class _BinaryPredicate, class _InputIterator, class _Sent, class _InputAndOutputIterator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI pair<_InputIterator, _InputAndOutputIterator> _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_HIDE_FROM_ABI pair<_InputIterator, _InputAndOutputIterator>
__unique_copy(_InputIterator __first, __unique_copy(_InputIterator __first,
_Sent __last, _Sent __last,
_InputAndOutputIterator __result, _InputAndOutputIterator __result,
_BinaryPredicate&& __pred, _BinaryPredicate&& __pred,
__unique_copy_tags::__reread_from_output_tag) { __unique_copy_tags::__reread_from_output_tag) {
if (__first != __last) { if (__first != __last) {
*__result = *__first; *__result = *__first;
while (++__first != __last) while (++__first != __last)
if (!__pred(*__result, *__first)) if (!__pred(*__result, *__first))
*++__result = *__first; *++__result = *__first;
++__result; ++__result;
} }
return pair<_InputIterator, _InputAndOutputIterator>(std::move(__first), std::move(__result)); return pair<_InputIterator, _InputAndOutputIterator>(std::move(__first), std::move(__result));
} }
template <class _InputIterator, class _OutputIterator, class _BinaryPredicate> template <class _InputIterator, class _OutputIterator, class _BinaryPredicate>
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _OutputIterator inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20 _OutputIterator
unique_copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _BinaryPredicate __pred) { unique_copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _BinaryPredicate __pred) {
using __algo_tag = typename conditional< using __algo_tag = typename conditional<
is_base_of<forward_iterator_tag, typename iterator_traits<_InputIterator>::iterator_category>::value, is_base_of<forward_iterator_tag, typename iterator_traits<_InputIterator>::iterator_category>::value,
__unique_copy_tags::__reread_from_input_tag, __unique_copy_tags::__reread_from_input_tag,
typename conditional< typename conditional<
is_base_of<forward_iterator_tag, typename iterator_traits<_OutputIterator>::iterator_category>::value && is_base_of<forward_iterator_tag, typename iterator_traits<_OutputIterator>::iterator_category>::value &&
is_same< typename iterator_traits<_InputIterator>::value_type, is_same< typename iterator_traits<_InputIterator>::value_type,
typename iterator_traits<_OutputIterator>::value_type>::value, typename iterator_traits<_OutputIterator>::value_type>::value,
__unique_copy_tags::__reread_from_output_tag, __unique_copy_tags::__reread_from_output_tag,
__unique_copy_tags::__read_from_tmp_value_tag>::type >::type; __unique_copy_tags::__read_from_tmp_value_tag>::type >::type;
return std::__unique_copy<_ClassicAlgPolicy>( return std::__unique_copy<_ClassicAlgPolicy>(
std::move(__first), std::move(__last), std::move(__result), __pred, __algo_tag()) std::move(__first), std::move(__last), std::move(__result), __pred, __algo_tag())
.second; .second;
} }
template <class _InputIterator, class _OutputIterator> template <class _InputIterator, class _OutputIterator>
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _OutputIterator inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20 _OutputIterator
unique_copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result) { unique_copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result) {
typedef typename iterator_traits<_InputIterator>::value_type __v; typedef typename iterator_traits<_InputIterator>::value_type __v;
return std::unique_copy(std::move(__first), std::move(__last), std::move(__result), __equal_to<__v>()); return std::unique_copy(std::move(__first), std::move(__last), std::move(__result), __equal_to<__v>());
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_UNIQUE_COPY_H #endif // _LIBCPP___ALGORITHM_UNIQUE_COPY_H

libcxx/include/__algorithm/unwrap_iter.h

Show First 20 Lines • Show All 51 Lines • ▼ Show 20 Linesstruct __unwrap_iter_impl<_Iter, true> {
} }
}; };
#endif // !_LIBCPP_ENABLE_DEBUG_MODE #endif // !_LIBCPP_ENABLE_DEBUG_MODE
template<class _Iter, template<class _Iter,
class _Impl = __unwrap_iter_impl<_Iter>, class _Impl = __unwrap_iter_impl<_Iter>,
__enable_if_t<is_copy_constructible<_Iter>::value, int> = 0> __enable_if_t<is_copy_constructible<_Iter>::value, int> = 0>
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14
decltype(_Impl::__unwrap(std::declval<_Iter>())) __unwrap_iter(_Iter __i) _NOEXCEPT { decltype(_Impl::__unwrap(std::declval<_Iter>())) __unwrap_iter(_Iter __i) _NOEXCEPT {
return _Impl::__unwrap(__i); return _Impl::__unwrap(__i);
} }
template <class _OrigIter, class _Iter, class _Impl = __unwrap_iter_impl<_OrigIter> > template <class _OrigIter, class _Iter, class _Impl = __unwrap_iter_impl<_OrigIter> >
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR _OrigIter __rewrap_iter(_OrigIter __orig_iter, _Iter __iter) _NOEXCEPT { _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR _OrigIter __rewrap_iter(_OrigIter __orig_iter, _Iter __iter) _NOEXCEPT {
return _Impl::__rewrap(std::move(__orig_iter), std::move(__iter)); return _Impl::__rewrap(std::move(__orig_iter), std::move(__iter));
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_UNWRAP_ITER_H #endif // _LIBCPP___ALGORITHM_UNWRAP_ITER_H

libcxx/include/__algorithm/upper_bound.h

Show All 22 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 _AlgPolicy, class _Compare, class _Iter, class _Sent, class _Tp, class _Proj> template <class _AlgPolicy, class _Compare, class _Iter, class _Sent, class _Tp, class _Proj>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _Iter _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20 _Iter
__upper_bound(_Iter __first, _Sent __last, const _Tp& __value, _Compare&& __comp, _Proj&& __proj) { __upper_bound(_Iter __first, _Sent __last, const _Tp& __value, _Compare&& __comp, _Proj&& __proj) {
auto __len = _IterOps<_AlgPolicy>::distance(__first, __last); auto __len = _IterOps<_AlgPolicy>::distance(__first, __last);
while (__len != 0) { while (__len != 0) {
auto __half_len = std::__half_positive(__len); auto __half_len = std::__half_positive(__len);
auto __mid = _IterOps<_AlgPolicy>::next(__first, __half_len); auto __mid = _IterOps<_AlgPolicy>::next(__first, __half_len);
if (std::__invoke(__comp, __value, std::__invoke(__proj, *__mid))) if (std::__invoke(__comp, __value, std::__invoke(__proj, *__mid)))
__len = __half_len; __len = __half_len;
else { else {
__first = ++__mid; __first = ++__mid;
__len -= __half_len + 1; __len -= __half_len + 1;
} }
} }
return __first; return __first;
} }
template <class _ForwardIterator, class _Tp, class _Compare> template <class _ForwardIterator, class _Tp, class _Compare>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _ForwardIterator _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20 _ForwardIterator
upper_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value, _Compare __comp) { upper_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value, _Compare __comp) {
static_assert(is_copy_constructible<_ForwardIterator>::value, static_assert(is_copy_constructible<_ForwardIterator>::value,
"Iterator has to be copy constructible"); "Iterator has to be copy constructible");
return std::__upper_bound<_ClassicAlgPolicy>( return std::__upper_bound<_ClassicAlgPolicy>(
std::move(__first), std::move(__last), __value, std::move(__comp), std::__identity()); std::move(__first), std::move(__last), __value, std::move(__comp), std::__identity());
} }
template <class _ForwardIterator, class _Tp> template <class _ForwardIterator, class _Tp>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _ForwardIterator _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20 _ForwardIterator
upper_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) { upper_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) {
return std::upper_bound( return std::upper_bound(
std::move(__first), std::move(__first),
std::move(__last), std::move(__last),
__value, __value,
__less<_Tp, typename iterator_traits<_ForwardIterator>::value_type>()); __less<_Tp, typename iterator_traits<_ForwardIterator>::value_type>());
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_UPPER_BOUND_H #endif // _LIBCPP___ALGORITHM_UPPER_BOUND_H

libcxx/include/__bit_reference

Show First 20 Lines • Show All 48 Lines • ▼ Show 20 Linesclass __bit_reference
__storage_pointer __seg_; __storage_pointer __seg_;
__storage_type __mask_; __storage_type __mask_;
friend typename _Cp::__self; friend typename _Cp::__self;
friend class __bit_const_reference<_Cp>; friend class __bit_const_reference<_Cp>;
friend class __bit_iterator<_Cp, false>; friend class __bit_iterator<_Cp, false>;
public: public:
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
__bit_reference(const __bit_reference&) = default; __bit_reference(const __bit_reference&) = default;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 operator bool() const _NOEXCEPT _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 operator bool() const _NOEXCEPT
{return static_cast<bool>(*__seg_ & __mask_);} {return static_cast<bool>(*__seg_ & __mask_);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 bool operator ~() const _NOEXCEPT _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 bool operator ~() const _NOEXCEPT
{return !static_cast<bool>(*this);} {return !static_cast<bool>(*this);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
__bit_reference& operator=(bool __x) _NOEXCEPT __bit_reference& operator=(bool __x) _NOEXCEPT
{ {
if (__x) if (__x)
*__seg_ |= __mask_; *__seg_ |= __mask_;
else else
*__seg_ &= ~__mask_; *__seg_ &= ~__mask_;
return *this; return *this;
} }
#if _LIBCPP_STD_VER > 20 #if _LIBCPP_STD_VER > 20
_LIBCPP_HIDE_FROM_ABI constexpr const __bit_reference& operator=(bool __x) const noexcept { _LIBCPP_HIDE_FROM_ABI constexpr const __bit_reference& operator=(bool __x) const noexcept {
if (__x) if (__x)
*__seg_ |= __mask_; *__seg_ |= __mask_;
else else
*__seg_ &= ~__mask_; *__seg_ &= ~__mask_;
return *this; return *this;
} }
#endif #endif
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
__bit_reference& operator=(const __bit_reference& __x) _NOEXCEPT __bit_reference& operator=(const __bit_reference& __x) _NOEXCEPT
{return operator=(static_cast<bool>(__x));} {return operator=(static_cast<bool>(__x));}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 void flip() _NOEXCEPT {*__seg_ ^= __mask_;} _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 void flip() _NOEXCEPT {*__seg_ ^= __mask_;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 __bit_iterator<_Cp, false> operator&() const _NOEXCEPT _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 __bit_iterator<_Cp, false> operator&() const _NOEXCEPT
{return __bit_iterator<_Cp, false>(__seg_, static_cast<unsigned>(__libcpp_ctz(__mask_)));} {return __bit_iterator<_Cp, false>(__seg_, static_cast<unsigned>(__libcpp_ctz(__mask_)));}
private: private:
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
explicit __bit_reference(__storage_pointer __s, __storage_type __m) _NOEXCEPT explicit __bit_reference(__storage_pointer __s, __storage_type __m) _NOEXCEPT
: __seg_(__s), __mask_(__m) {} : __seg_(__s), __mask_(__m) {}
}; };
template <class _Cp> template <class _Cp>
class __bit_reference<_Cp, false> class __bit_reference<_Cp, false>
{ {
}; };
template <class _Cp> template <class _Cp>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
void void
swap(__bit_reference<_Cp> __x, __bit_reference<_Cp> __y) _NOEXCEPT swap(__bit_reference<_Cp> __x, __bit_reference<_Cp> __y) _NOEXCEPT
{ {
bool __t = __x; bool __t = __x;
__x = __y; __x = __y;
__y = __t; __y = __t;
} }
template <class _Cp, class _Dp> template <class _Cp, class _Dp>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
void void
swap(__bit_reference<_Cp> __x, __bit_reference<_Dp> __y) _NOEXCEPT swap(__bit_reference<_Cp> __x, __bit_reference<_Dp> __y) _NOEXCEPT
{ {
bool __t = __x; bool __t = __x;
__x = __y; __x = __y;
__y = __t; __y = __t;
} }
template <class _Cp> template <class _Cp>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
void void
swap(__bit_reference<_Cp> __x, bool& __y) _NOEXCEPT swap(__bit_reference<_Cp> __x, bool& __y) _NOEXCEPT
{ {
bool __t = __x; bool __t = __x;
__x = __y; __x = __y;
__y = __t; __y = __t;
} }
template <class _Cp> template <class _Cp>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
void void
swap(bool& __x, __bit_reference<_Cp> __y) _NOEXCEPT swap(bool& __x, __bit_reference<_Cp> __y) _NOEXCEPT
{ {
bool __t = __x; bool __t = __x;
__x = __y; __x = __y;
__y = __t; __y = __t;
} }
template <class _Cp> template <class _Cp>
class __bit_const_reference class __bit_const_reference
{ {
typedef typename _Cp::__storage_type __storage_type; typedef typename _Cp::__storage_type __storage_type;
typedef typename _Cp::__const_storage_pointer __storage_pointer; typedef typename _Cp::__const_storage_pointer __storage_pointer;
__storage_pointer __seg_; __storage_pointer __seg_;
__storage_type __mask_; __storage_type __mask_;
friend typename _Cp::__self; friend typename _Cp::__self;
friend class __bit_iterator<_Cp, true>; friend class __bit_iterator<_Cp, true>;
public: public:
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
__bit_const_reference(const __bit_const_reference&) = default; __bit_const_reference(const __bit_const_reference&) = default;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
__bit_const_reference(const __bit_reference<_Cp>& __x) _NOEXCEPT __bit_const_reference(const __bit_reference<_Cp>& __x) _NOEXCEPT
: __seg_(__x.__seg_), __mask_(__x.__mask_) {} : __seg_(__x.__seg_), __mask_(__x.__mask_) {}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR operator bool() const _NOEXCEPT _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR operator bool() const _NOEXCEPT
{return static_cast<bool>(*__seg_ & __mask_);} {return static_cast<bool>(*__seg_ & __mask_);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 __bit_iterator<_Cp, true> operator&() const _NOEXCEPT _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 __bit_iterator<_Cp, true> operator&() const _NOEXCEPT
{return __bit_iterator<_Cp, true>(__seg_, static_cast<unsigned>(__libcpp_ctz(__mask_)));} {return __bit_iterator<_Cp, true>(__seg_, static_cast<unsigned>(__libcpp_ctz(__mask_)));}
private: private:
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR _LIBCPP_CONSTEXPR
explicit __bit_const_reference(__storage_pointer __s, __storage_type __m) _NOEXCEPT explicit __bit_const_reference(__storage_pointer __s, __storage_type __m) _NOEXCEPT
: __seg_(__s), __mask_(__m) {} : __seg_(__s), __mask_(__m) {}
__bit_const_reference& operator=(const __bit_const_reference&) = delete; __bit_const_reference& operator=(const __bit_const_reference&) = delete;
}; };
// find // find
template <class _Cp, bool _IsConst> template <class _Cp, bool _IsConst>
_LIBCPP_CONSTEXPR_AFTER_CXX17 __bit_iterator<_Cp, _IsConst> _LIBCPP_CONSTEXPR_CXX20 __bit_iterator<_Cp, _IsConst>
__find_bool_true(__bit_iterator<_Cp, _IsConst> __first, typename _Cp::size_type __n) __find_bool_true(__bit_iterator<_Cp, _IsConst> __first, typename _Cp::size_type __n)
{ {
typedef __bit_iterator<_Cp, _IsConst> _It; typedef __bit_iterator<_Cp, _IsConst> _It;
typedef typename _It::__storage_type __storage_type; typedef typename _It::__storage_type __storage_type;
const int __bits_per_word = _It::__bits_per_word; const int __bits_per_word = _It::__bits_per_word;
// do first partial word // do first partial word
if (__first.__ctz_ != 0) if (__first.__ctz_ != 0)
{ {
Show All 19 Lines if (__n > 0)
__storage_type __b = *__first.__seg_ & __m; __storage_type __b = *__first.__seg_ & __m;
if (__b) if (__b)
return _It(__first.__seg_, static_cast<unsigned>(_VSTD::__libcpp_ctz(__b))); return _It(__first.__seg_, static_cast<unsigned>(_VSTD::__libcpp_ctz(__b)));
} }
return _It(__first.__seg_, static_cast<unsigned>(__n)); return _It(__first.__seg_, static_cast<unsigned>(__n));
} }
template <class _Cp, bool _IsConst> template <class _Cp, bool _IsConst>
_LIBCPP_CONSTEXPR_AFTER_CXX17 __bit_iterator<_Cp, _IsConst> _LIBCPP_CONSTEXPR_CXX20 __bit_iterator<_Cp, _IsConst>
__find_bool_false(__bit_iterator<_Cp, _IsConst> __first, typename _Cp::size_type __n) __find_bool_false(__bit_iterator<_Cp, _IsConst> __first, typename _Cp::size_type __n)
{ {
typedef __bit_iterator<_Cp, _IsConst> _It; typedef __bit_iterator<_Cp, _IsConst> _It;
typedef typename _It::__storage_type __storage_type; typedef typename _It::__storage_type __storage_type;
const int __bits_per_word = _It::__bits_per_word; const int __bits_per_word = _It::__bits_per_word;
// do first partial word // do first partial word
if (__first.__ctz_ != 0) if (__first.__ctz_ != 0)
{ {
Show All 22 Lines if (__n > 0)
__storage_type __b = ~*__first.__seg_ & __m; __storage_type __b = ~*__first.__seg_ & __m;
if (__b) if (__b)
return _It(__first.__seg_, static_cast<unsigned>(_VSTD::__libcpp_ctz(__b))); return _It(__first.__seg_, static_cast<unsigned>(_VSTD::__libcpp_ctz(__b)));
} }
return _It(__first.__seg_, static_cast<unsigned>(__n)); return _It(__first.__seg_, static_cast<unsigned>(__n));
} }
template <class _Cp, bool _IsConst, class _Tp> template <class _Cp, bool _IsConst, class _Tp>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
__bit_iterator<_Cp, _IsConst> __bit_iterator<_Cp, _IsConst>
find(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last, const _Tp& __value) find(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last, const _Tp& __value)
{ {
if (static_cast<bool>(__value)) if (static_cast<bool>(__value))
return _VSTD::__find_bool_true(__first, static_cast<typename _Cp::size_type>(__last - __first)); return _VSTD::__find_bool_true(__first, static_cast<typename _Cp::size_type>(__last - __first));
return _VSTD::__find_bool_false(__first, static_cast<typename _Cp::size_type>(__last - __first)); return _VSTD::__find_bool_false(__first, static_cast<typename _Cp::size_type>(__last - __first));
} }
▲ Show 20 Lines • Show All 69 Lines • ▼ Show 20 Linescount(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last, const _Tp& __value)
if (static_cast<bool>(__value)) if (static_cast<bool>(__value))
return _VSTD::__count_bool_true(__first, static_cast<typename _Cp::size_type>(__last - __first)); return _VSTD::__count_bool_true(__first, static_cast<typename _Cp::size_type>(__last - __first));
return _VSTD::__count_bool_false(__first, static_cast<typename _Cp::size_type>(__last - __first)); return _VSTD::__count_bool_false(__first, static_cast<typename _Cp::size_type>(__last - __first));
} }
// fill_n // fill_n
template <class _Cp> template <class _Cp>
_LIBCPP_CONSTEXPR_AFTER_CXX17 void _LIBCPP_CONSTEXPR_CXX20 void
__fill_n_false(__bit_iterator<_Cp, false> __first, typename _Cp::size_type __n) __fill_n_false(__bit_iterator<_Cp, false> __first, typename _Cp::size_type __n)
{ {
typedef __bit_iterator<_Cp, false> _It; typedef __bit_iterator<_Cp, false> _It;
typedef typename _It::__storage_type __storage_type; typedef typename _It::__storage_type __storage_type;
const int __bits_per_word = _It::__bits_per_word; const int __bits_per_word = _It::__bits_per_word;
// do first partial word // do first partial word
if (__first.__ctz_ != 0) if (__first.__ctz_ != 0)
{ {
Show All 13 Lines__fill_n_false(__bit_iterator<_Cp, false> __first, typename _Cp::size_type __n)
{ {
__first.__seg_ += __nw; __first.__seg_ += __nw;
__storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n); __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);
*__first.__seg_ &= ~__m; *__first.__seg_ &= ~__m;
} }
} }
template <class _Cp> template <class _Cp>
_LIBCPP_CONSTEXPR_AFTER_CXX17 void _LIBCPP_CONSTEXPR_CXX20 void
__fill_n_true(__bit_iterator<_Cp, false> __first, typename _Cp::size_type __n) __fill_n_true(__bit_iterator<_Cp, false> __first, typename _Cp::size_type __n)
{ {
typedef __bit_iterator<_Cp, false> _It; typedef __bit_iterator<_Cp, false> _It;
typedef typename _It::__storage_type __storage_type; typedef typename _It::__storage_type __storage_type;
const int __bits_per_word = _It::__bits_per_word; const int __bits_per_word = _It::__bits_per_word;
// do first partial word // do first partial word
if (__first.__ctz_ != 0) if (__first.__ctz_ != 0)
{ {
Show All 14 Lines__fill_n_true(__bit_iterator<_Cp, false> __first, typename _Cp::size_type __n)
{ {
__first.__seg_ += __nw; __first.__seg_ += __nw;
__storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n); __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);
*__first.__seg_ |= __m; *__first.__seg_ |= __m;
} }
} }
template <class _Cp> template <class _Cp>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
void void
fill_n(__bit_iterator<_Cp, false> __first, typename _Cp::size_type __n, bool __value) fill_n(__bit_iterator<_Cp, false> __first, typename _Cp::size_type __n, bool __value)
{ {
if (__n > 0) if (__n > 0)
{ {
if (__value) if (__value)
_VSTD::__fill_n_true(__first, __n); _VSTD::__fill_n_true(__first, __n);
else else
_VSTD::__fill_n_false(__first, __n); _VSTD::__fill_n_false(__first, __n);
} }
} }
// fill // fill
template <class _Cp> template <class _Cp>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
void void
fill(__bit_iterator<_Cp, false> __first, __bit_iterator<_Cp, false> __last, bool __value) fill(__bit_iterator<_Cp, false> __first, __bit_iterator<_Cp, false> __last, bool __value)
{ {
_VSTD::fill_n(__first, static_cast<typename _Cp::size_type>(__last - __first), __value); _VSTD::fill_n(__first, static_cast<typename _Cp::size_type>(__last - __first), __value);
} }
// copy // copy
template <class _Cp, bool _IsConst> template <class _Cp, bool _IsConst>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
__bit_iterator<_Cp, false> __bit_iterator<_Cp, false>
__copy_aligned(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last, __copy_aligned(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last,
__bit_iterator<_Cp, false> __result) __bit_iterator<_Cp, false> __result)
{ {
typedef __bit_iterator<_Cp, _IsConst> _In; typedef __bit_iterator<_Cp, _IsConst> _In;
typedef typename _In::difference_type difference_type; typedef typename _In::difference_type difference_type;
typedef typename _In::__storage_type __storage_type; typedef typename _In::__storage_type __storage_type;
const int __bits_per_word = _In::__bits_per_word; const int __bits_per_word = _In::__bits_per_word;
Show All 31 Lines if (__n > 0)
*__result.__seg_ |= __b; *__result.__seg_ |= __b;
__result.__ctz_ = static_cast<unsigned>(__n); __result.__ctz_ = static_cast<unsigned>(__n);
} }
} }
return __result; return __result;
} }
template <class _Cp, bool _IsConst> template <class _Cp, bool _IsConst>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
__bit_iterator<_Cp, false> __bit_iterator<_Cp, false>
__copy_unaligned(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last, __copy_unaligned(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last,
__bit_iterator<_Cp, false> __result) __bit_iterator<_Cp, false> __result)
{ {
typedef __bit_iterator<_Cp, _IsConst> _In; typedef __bit_iterator<_Cp, _IsConst> _In;
typedef typename _In::difference_type difference_type; typedef typename _In::difference_type difference_type;
typedef typename _In::__storage_type __storage_type; typedef typename _In::__storage_type __storage_type;
const int __bits_per_word = _In::__bits_per_word; const int __bits_per_word = _In::__bits_per_word;
▲ Show 20 Lines • Show All 62 Lines • ▼ Show 20 Lines if (__n > 0)
__result.__ctz_ = static_cast<unsigned>(__n); __result.__ctz_ = static_cast<unsigned>(__n);
} }
} }
} }
return __result; return __result;
} }
template <class _Cp, bool _IsConst> template <class _Cp, bool _IsConst>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
__bit_iterator<_Cp, false> __bit_iterator<_Cp, false>
copy(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last, __bit_iterator<_Cp, false> __result) copy(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last, __bit_iterator<_Cp, false> __result)
{ {
if (__first.__ctz_ == __result.__ctz_) if (__first.__ctz_ == __result.__ctz_)
return _VSTD::__copy_aligned(__first, __last, __result); return _VSTD::__copy_aligned(__first, __last, __result);
return _VSTD::__copy_unaligned(__first, __last, __result); return _VSTD::__copy_unaligned(__first, __last, __result);
} }
// copy_backward // copy_backward
template <class _Cp, bool _IsConst> template <class _Cp, bool _IsConst>
_LIBCPP_CONSTEXPR_AFTER_CXX17 __bit_iterator<_Cp, false> _LIBCPP_CONSTEXPR_CXX20 __bit_iterator<_Cp, false>
__copy_backward_aligned(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last, __copy_backward_aligned(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last,
__bit_iterator<_Cp, false> __result) __bit_iterator<_Cp, false> __result)
{ {
typedef __bit_iterator<_Cp, _IsConst> _In; typedef __bit_iterator<_Cp, _IsConst> _In;
typedef typename _In::difference_type difference_type; typedef typename _In::difference_type difference_type;
typedef typename _In::__storage_type __storage_type; typedef typename _In::__storage_type __storage_type;
const int __bits_per_word = _In::__bits_per_word; const int __bits_per_word = _In::__bits_per_word;
difference_type __n = __last - __first; difference_type __n = __last - __first;
Show All 30 Lines if (__n > 0)
*__result.__seg_ |= __b; *__result.__seg_ |= __b;
__result.__ctz_ = static_cast<unsigned>(-__n & (__bits_per_word - 1)); __result.__ctz_ = static_cast<unsigned>(-__n & (__bits_per_word - 1));
} }
} }
return __result; return __result;
} }
template <class _Cp, bool _IsConst> template <class _Cp, bool _IsConst>
_LIBCPP_CONSTEXPR_AFTER_CXX17 __bit_iterator<_Cp, false> _LIBCPP_CONSTEXPR_CXX20 __bit_iterator<_Cp, false>
__copy_backward_unaligned(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last, __copy_backward_unaligned(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last,
__bit_iterator<_Cp, false> __result) __bit_iterator<_Cp, false> __result)
{ {
typedef __bit_iterator<_Cp, _IsConst> _In; typedef __bit_iterator<_Cp, _IsConst> _In;
typedef typename _In::difference_type difference_type; typedef typename _In::difference_type difference_type;
typedef typename _In::__storage_type __storage_type; typedef typename _In::__storage_type __storage_type;
const int __bits_per_word = _In::__bits_per_word; const int __bits_per_word = _In::__bits_per_word;
difference_type __n = __last - __first; difference_type __n = __last - __first;
▲ Show 20 Lines • Show All 69 Lines • ▼ Show 20 Lines if (__n > 0)
*__result.__seg_ |= __b << (__result.__ctz_ - (__bits_per_word - __n - __dn)); *__result.__seg_ |= __b << (__result.__ctz_ - (__bits_per_word - __n - __dn));
} }
} }
} }
return __result; return __result;
} }
template <class _Cp, bool _IsConst> template <class _Cp, bool _IsConst>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
__bit_iterator<_Cp, false> __bit_iterator<_Cp, false>
copy_backward(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last, __bit_iterator<_Cp, false> __result) copy_backward(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last, __bit_iterator<_Cp, false> __result)
{ {
if (__last.__ctz_ == __result.__ctz_) if (__last.__ctz_ == __result.__ctz_)
return _VSTD::__copy_backward_aligned(__first, __last, __result); return _VSTD::__copy_backward_aligned(__first, __last, __result);
return _VSTD::__copy_backward_unaligned(__first, __last, __result); return _VSTD::__copy_backward_unaligned(__first, __last, __result);
} }
▲ Show 20 Lines • Show All 190 Lines • ▼ Show 20 Linesstruct __bit_array
typedef typename _Cp::__storage_pointer __storage_pointer; typedef typename _Cp::__storage_pointer __storage_pointer;
typedef typename _Cp::iterator iterator; typedef typename _Cp::iterator iterator;
static const unsigned __bits_per_word = _Cp::__bits_per_word; static const unsigned __bits_per_word = _Cp::__bits_per_word;
static const unsigned _Np = 4; static const unsigned _Np = 4;
difference_type __size_; difference_type __size_;
__storage_type __word_[_Np]; __storage_type __word_[_Np];
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 static difference_type capacity() _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 static difference_type capacity()
{return static_cast<difference_type>(_Np * __bits_per_word);} {return static_cast<difference_type>(_Np * __bits_per_word);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 explicit __bit_array(difference_type __s) : __size_(__s) { _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 explicit __bit_array(difference_type __s) : __size_(__s) {
if (__libcpp_is_constant_evaluated()) { if (__libcpp_is_constant_evaluated()) {
for (size_t __i = 0; __i != __bit_array<_Cp>::_Np; ++__i) for (size_t __i = 0; __i != __bit_array<_Cp>::_Np; ++__i)
std::__construct_at(__word_ + __i, 0); std::__construct_at(__word_ + __i, 0);
} }
} }
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 iterator begin() _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 iterator begin()
{ {
return iterator(pointer_traits<__storage_pointer>::pointer_to(__word_[0]), 0); return iterator(pointer_traits<__storage_pointer>::pointer_to(__word_[0]), 0);
} }
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 iterator end() _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 iterator end()
{ {
return iterator(pointer_traits<__storage_pointer>::pointer_to(__word_[0]) + __size_ / __bits_per_word, return iterator(pointer_traits<__storage_pointer>::pointer_to(__word_[0]) + __size_ / __bits_per_word,
static_cast<unsigned>(__size_ % __bits_per_word)); static_cast<unsigned>(__size_ % __bits_per_word));
} }
}; };
template <class _Cp> template <class _Cp>
_LIBCPP_CONSTEXPR_AFTER_CXX17 __bit_iterator<_Cp, false> _LIBCPP_CONSTEXPR_CXX20 __bit_iterator<_Cp, false>
rotate(__bit_iterator<_Cp, false> __first, __bit_iterator<_Cp, false> __middle, __bit_iterator<_Cp, false> __last) rotate(__bit_iterator<_Cp, false> __first, __bit_iterator<_Cp, false> __middle, __bit_iterator<_Cp, false> __last)
{ {
typedef __bit_iterator<_Cp, false> _I1; typedef __bit_iterator<_Cp, false> _I1;
typedef typename _I1::difference_type difference_type; typedef typename _I1::difference_type difference_type;
difference_type __d1 = __middle - __first; difference_type __d1 = __middle - __first;
difference_type __d2 = __last - __middle; difference_type __d2 = __last - __middle;
_I1 __r = __first + __d2; _I1 __r = __first + __d2;
while (__d1 != 0 && __d2 != 0) while (__d1 != 0 && __d2 != 0)
Show All 34 Lines while (__d1 != 0 && __d2 != 0)
} }
} }
return __r; return __r;
} }
// equal // equal
template <class _Cp, bool _IC1, bool _IC2> template <class _Cp, bool _IC1, bool _IC2>
_LIBCPP_CONSTEXPR_AFTER_CXX17 bool _LIBCPP_CONSTEXPR_CXX20 bool
__equal_unaligned(__bit_iterator<_Cp, _IC1> __first1, __bit_iterator<_Cp, _IC1> __last1, __equal_unaligned(__bit_iterator<_Cp, _IC1> __first1, __bit_iterator<_Cp, _IC1> __last1,
__bit_iterator<_Cp, _IC2> __first2) __bit_iterator<_Cp, _IC2> __first2)
{ {
typedef __bit_iterator<_Cp, _IC1> _It; typedef __bit_iterator<_Cp, _IC1> _It;
typedef typename _It::difference_type difference_type; typedef typename _It::difference_type difference_type;
typedef typename _It::__storage_type __storage_type; typedef typename _It::__storage_type __storage_type;
const int __bits_per_word = _It::__bits_per_word; const int __bits_per_word = _It::__bits_per_word;
difference_type __n = __last1 - __first1; difference_type __n = __last1 - __first1;
▲ Show 20 Lines • Show All 65 Lines • ▼ Show 20 Lines if (__n > 0)
return false; return false;
} }
} }
} }
return true; return true;
} }
template <class _Cp, bool _IC1, bool _IC2> template <class _Cp, bool _IC1, bool _IC2>
_LIBCPP_CONSTEXPR_AFTER_CXX17 bool _LIBCPP_CONSTEXPR_CXX20 bool
__equal_aligned(__bit_iterator<_Cp, _IC1> __first1, __bit_iterator<_Cp, _IC1> __last1, __equal_aligned(__bit_iterator<_Cp, _IC1> __first1, __bit_iterator<_Cp, _IC1> __last1,
__bit_iterator<_Cp, _IC2> __first2) __bit_iterator<_Cp, _IC2> __first2)
{ {
typedef __bit_iterator<_Cp, _IC1> _It; typedef __bit_iterator<_Cp, _IC1> _It;
typedef typename _It::difference_type difference_type; typedef typename _It::difference_type difference_type;
typedef typename _It::__storage_type __storage_type; typedef typename _It::__storage_type __storage_type;
const int __bits_per_word = _It::__bits_per_word; const int __bits_per_word = _It::__bits_per_word;
difference_type __n = __last1 - __first1; difference_type __n = __last1 - __first1;
Show All 26 Lines if (__n > 0)
if ((*__first2.__seg_ & __m) != (*__first1.__seg_ & __m)) if ((*__first2.__seg_ & __m) != (*__first1.__seg_ & __m))
return false; return false;
} }
} }
return true; return true;
} }
template <class _Cp, bool _IC1, bool _IC2> template <class _Cp, bool _IC1, bool _IC2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
bool bool
equal(__bit_iterator<_Cp, _IC1> __first1, __bit_iterator<_Cp, _IC1> __last1, __bit_iterator<_Cp, _IC2> __first2) equal(__bit_iterator<_Cp, _IC1> __first1, __bit_iterator<_Cp, _IC1> __last1, __bit_iterator<_Cp, _IC2> __first2)
{ {
if (__first1.__ctz_ == __first2.__ctz_) if (__first1.__ctz_ == __first2.__ctz_)
return _VSTD::__equal_aligned(__first1, __last1, __first2); return _VSTD::__equal_aligned(__first1, __last1, __first2);
return _VSTD::__equal_unaligned(__first1, __last1, __first2); return _VSTD::__equal_unaligned(__first1, __last1, __first2);
} }
Show All 17 Linesprivate:
typedef typename conditional<_IsConst, typename _Cp::__const_storage_pointer, typedef typename conditional<_IsConst, typename _Cp::__const_storage_pointer,
typename _Cp::__storage_pointer>::type __storage_pointer; typename _Cp::__storage_pointer>::type __storage_pointer;
static const unsigned __bits_per_word = _Cp::__bits_per_word; static const unsigned __bits_per_word = _Cp::__bits_per_word;
__storage_pointer __seg_; __storage_pointer __seg_;
unsigned __ctz_; unsigned __ctz_;
public: public:
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 __bit_iterator() _NOEXCEPT _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 __bit_iterator() _NOEXCEPT
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER > 11
: __seg_(nullptr), __ctz_(0) : __seg_(nullptr), __ctz_(0)
#endif #endif
{} {}
// When _IsConst=false, this is the copy constructor. // When _IsConst=false, this is the copy constructor.
// It is non-trivial. Making it trivial would break ABI. // It is non-trivial. Making it trivial would break ABI.
// When _IsConst=true, this is a converting constructor; // When _IsConst=true, this is a converting constructor;
// the copy and move constructors are implicitly generated // the copy and move constructors are implicitly generated
// and trivial. // and trivial.
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
__bit_iterator(const __bit_iterator<_Cp, false>& __it) _NOEXCEPT __bit_iterator(const __bit_iterator<_Cp, false>& __it) _NOEXCEPT
: __seg_(__it.__seg_), __ctz_(__it.__ctz_) {} : __seg_(__it.__seg_), __ctz_(__it.__ctz_) {}
// When _IsConst=false, we have a user-provided copy constructor, // When _IsConst=false, we have a user-provided copy constructor,
// so we must also provide a copy assignment operator because // so we must also provide a copy assignment operator because
// the implicit generation of a defaulted one is deprecated. // the implicit generation of a defaulted one is deprecated.
// When _IsConst=true, the assignment operators are // When _IsConst=true, the assignment operators are
// implicitly generated and trivial. // implicitly generated and trivial.
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
__bit_iterator& operator=(const _If<_IsConst, struct __private_nat, __bit_iterator>& __it) { __bit_iterator& operator=(const _If<_IsConst, struct __private_nat, __bit_iterator>& __it) {
__seg_ = __it.__seg_; __seg_ = __it.__seg_;
__ctz_ = __it.__ctz_; __ctz_ = __it.__ctz_;
return *this; return *this;
} }
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 reference operator*() const _NOEXCEPT { _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 reference operator*() const _NOEXCEPT {
return typename conditional<_IsConst, __bit_const_reference<_Cp>, __bit_reference<_Cp> > return typename conditional<_IsConst, __bit_const_reference<_Cp>, __bit_reference<_Cp> >
::type(__seg_, __storage_type(1) << __ctz_); ::type(__seg_, __storage_type(1) << __ctz_);
} }
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 __bit_iterator& operator++() _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 __bit_iterator& operator++()
{ {
if (__ctz_ != __bits_per_word-1) if (__ctz_ != __bits_per_word-1)
++__ctz_; ++__ctz_;
else else
{ {
__ctz_ = 0; __ctz_ = 0;
++__seg_; ++__seg_;
} }
return *this; return *this;
} }
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 __bit_iterator operator++(int) _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 __bit_iterator operator++(int)
{ {
__bit_iterator __tmp = *this; __bit_iterator __tmp = *this;
++(*this); ++(*this);
return __tmp; return __tmp;
} }
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 __bit_iterator& operator--() _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 __bit_iterator& operator--()
{ {
if (__ctz_ != 0) if (__ctz_ != 0)
--__ctz_; --__ctz_;
else else
{ {
__ctz_ = __bits_per_word - 1; __ctz_ = __bits_per_word - 1;
--__seg_; --__seg_;
} }
return *this; return *this;
} }
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 __bit_iterator operator--(int) _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 __bit_iterator operator--(int)
{ {
__bit_iterator __tmp = *this; __bit_iterator __tmp = *this;
--(*this); --(*this);
return __tmp; return __tmp;
} }
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 __bit_iterator& operator+=(difference_type __n) _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 __bit_iterator& operator+=(difference_type __n)
{ {
if (__n >= 0) if (__n >= 0)
__seg_ += (__n + __ctz_) / __bits_per_word; __seg_ += (__n + __ctz_) / __bits_per_word;
else else
__seg_ += static_cast<difference_type>(__n - __bits_per_word + __ctz_ + 1) __seg_ += static_cast<difference_type>(__n - __bits_per_word + __ctz_ + 1)
/ static_cast<difference_type>(__bits_per_word); / static_cast<difference_type>(__bits_per_word);
__n &= (__bits_per_word - 1); __n &= (__bits_per_word - 1);
__ctz_ = static_cast<unsigned>((__n + __ctz_) % __bits_per_word); __ctz_ = static_cast<unsigned>((__n + __ctz_) % __bits_per_word);
return *this; return *this;
} }
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 __bit_iterator& operator-=(difference_type __n) _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 __bit_iterator& operator-=(difference_type __n)
{ {
return *this += -__n; return *this += -__n;
} }
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 __bit_iterator operator+(difference_type __n) const _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 __bit_iterator operator+(difference_type __n) const
{ {
__bit_iterator __t(*this); __bit_iterator __t(*this);
__t += __n; __t += __n;
return __t; return __t;
} }
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 __bit_iterator operator-(difference_type __n) const _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 __bit_iterator operator-(difference_type __n) const
{ {
__bit_iterator __t(*this); __bit_iterator __t(*this);
__t -= __n; __t -= __n;
return __t; return __t;
} }
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
friend __bit_iterator operator+(difference_type __n, const __bit_iterator& __it) {return __it + __n;} friend __bit_iterator operator+(difference_type __n, const __bit_iterator& __it) {return __it + __n;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
friend difference_type operator-(const __bit_iterator& __x, const __bit_iterator& __y) friend difference_type operator-(const __bit_iterator& __x, const __bit_iterator& __y)
{return (__x.__seg_ - __y.__seg_) * __bits_per_word + __x.__ctz_ - __y.__ctz_;} {return (__x.__seg_ - __y.__seg_) * __bits_per_word + __x.__ctz_ - __y.__ctz_;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 reference operator[](difference_type __n) const {return *(*this + __n);} _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 reference operator[](difference_type __n) const {return *(*this + __n);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 friend bool operator==(const __bit_iterator& __x, const __bit_iterator& __y) _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 friend bool operator==(const __bit_iterator& __x, const __bit_iterator& __y)
{return __x.__seg_ == __y.__seg_ && __x.__ctz_ == __y.__ctz_;} {return __x.__seg_ == __y.__seg_ && __x.__ctz_ == __y.__ctz_;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 friend bool operator!=(const __bit_iterator& __x, const __bit_iterator& __y) _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 friend bool operator!=(const __bit_iterator& __x, const __bit_iterator& __y)
{return !(__x == __y);} {return !(__x == __y);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 friend bool operator<(const __bit_iterator& __x, const __bit_iterator& __y) _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 friend bool operator<(const __bit_iterator& __x, const __bit_iterator& __y)
{return __x.__seg_ < __y.__seg_ || (__x.__seg_ == __y.__seg_ && __x.__ctz_ < __y.__ctz_);} {return __x.__seg_ < __y.__seg_ || (__x.__seg_ == __y.__seg_ && __x.__ctz_ < __y.__ctz_);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 friend bool operator>(const __bit_iterator& __x, const __bit_iterator& __y) _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 friend bool operator>(const __bit_iterator& __x, const __bit_iterator& __y)
{return __y < __x;} {return __y < __x;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 friend bool operator<=(const __bit_iterator& __x, const __bit_iterator& __y) _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 friend bool operator<=(const __bit_iterator& __x, const __bit_iterator& __y)
{return !(__y < __x);} {return !(__y < __x);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 friend bool operator>=(const __bit_iterator& __x, const __bit_iterator& __y) _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 friend bool operator>=(const __bit_iterator& __x, const __bit_iterator& __y)
{return !(__x < __y);} {return !(__x < __y);}
private: private:
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
explicit __bit_iterator(__storage_pointer __s, unsigned __ctz) _NOEXCEPT explicit __bit_iterator(__storage_pointer __s, unsigned __ctz) _NOEXCEPT
: __seg_(__s), __ctz_(__ctz) {} : __seg_(__s), __ctz_(__ctz) {}
friend typename _Cp::__self; friend typename _Cp::__self;
friend class __bit_reference<_Cp>; friend class __bit_reference<_Cp>;
friend class __bit_const_reference<_Cp>; friend class __bit_const_reference<_Cp>;
friend class __bit_iterator<_Cp, true>; friend class __bit_iterator<_Cp, true>;
template <class _Dp> friend struct __bit_array; template <class _Dp> friend struct __bit_array;
template <class _Dp> template <class _Dp>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
friend void __fill_n_false(__bit_iterator<_Dp, false> __first, typename _Dp::size_type __n); friend void __fill_n_false(__bit_iterator<_Dp, false> __first, typename _Dp::size_type __n);
template <class _Dp> template <class _Dp>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
friend void __fill_n_true(__bit_iterator<_Dp, false> __first, typename _Dp::size_type __n); friend void __fill_n_true(__bit_iterator<_Dp, false> __first, typename _Dp::size_type __n);
template <class _Dp, bool _IC> template <class _Dp, bool _IC>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
friend __bit_iterator<_Dp, false> __copy_aligned(__bit_iterator<_Dp, _IC> __first, friend __bit_iterator<_Dp, false> __copy_aligned(__bit_iterator<_Dp, _IC> __first,
__bit_iterator<_Dp, _IC> __last, __bit_iterator<_Dp, _IC> __last,
__bit_iterator<_Dp, false> __result); __bit_iterator<_Dp, false> __result);
template <class _Dp, bool _IC> template <class _Dp, bool _IC>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
friend __bit_iterator<_Dp, false> __copy_unaligned(__bit_iterator<_Dp, _IC> __first, friend __bit_iterator<_Dp, false> __copy_unaligned(__bit_iterator<_Dp, _IC> __first,
__bit_iterator<_Dp, _IC> __last, __bit_iterator<_Dp, _IC> __last,
__bit_iterator<_Dp, false> __result); __bit_iterator<_Dp, false> __result);
template <class _Dp, bool _IC> template <class _Dp, bool _IC>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
friend __bit_iterator<_Dp, false> copy(__bit_iterator<_Dp, _IC> __first, friend __bit_iterator<_Dp, false> copy(__bit_iterator<_Dp, _IC> __first,
__bit_iterator<_Dp, _IC> __last, __bit_iterator<_Dp, _IC> __last,
__bit_iterator<_Dp, false> __result); __bit_iterator<_Dp, false> __result);
template <class _Dp, bool _IC> template <class _Dp, bool _IC>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
friend __bit_iterator<_Dp, false> __copy_backward_aligned(__bit_iterator<_Dp, _IC> __first, friend __bit_iterator<_Dp, false> __copy_backward_aligned(__bit_iterator<_Dp, _IC> __first,
__bit_iterator<_Dp, _IC> __last, __bit_iterator<_Dp, _IC> __last,
__bit_iterator<_Dp, false> __result); __bit_iterator<_Dp, false> __result);
template <class _Dp, bool _IC> template <class _Dp, bool _IC>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
friend __bit_iterator<_Dp, false> __copy_backward_unaligned(__bit_iterator<_Dp, _IC> __first, friend __bit_iterator<_Dp, false> __copy_backward_unaligned(__bit_iterator<_Dp, _IC> __first,
__bit_iterator<_Dp, _IC> __last, __bit_iterator<_Dp, _IC> __last,
__bit_iterator<_Dp, false> __result); __bit_iterator<_Dp, false> __result);
template <class _Dp, bool _IC> template <class _Dp, bool _IC>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
friend __bit_iterator<_Dp, false> copy_backward(__bit_iterator<_Dp, _IC> __first, friend __bit_iterator<_Dp, false> copy_backward(__bit_iterator<_Dp, _IC> __first,
__bit_iterator<_Dp, _IC> __last, __bit_iterator<_Dp, _IC> __last,
__bit_iterator<_Dp, false> __result); __bit_iterator<_Dp, false> __result);
template <class __C1, class __C2>friend __bit_iterator<__C2, false> __swap_ranges_aligned(__bit_iterator<__C1, false>, template <class __C1, class __C2>friend __bit_iterator<__C2, false> __swap_ranges_aligned(__bit_iterator<__C1, false>,
__bit_iterator<__C1, false>, __bit_iterator<__C1, false>,
__bit_iterator<__C2, false>); __bit_iterator<__C2, false>);
template <class __C1, class __C2>friend __bit_iterator<__C2, false> __swap_ranges_unaligned(__bit_iterator<__C1, false>, template <class __C1, class __C2>friend __bit_iterator<__C2, false> __swap_ranges_unaligned(__bit_iterator<__C1, false>,
__bit_iterator<__C1, false>, __bit_iterator<__C1, false>,
__bit_iterator<__C2, false>); __bit_iterator<__C2, false>);
template <class __C1, class __C2>friend __bit_iterator<__C2, false> swap_ranges(__bit_iterator<__C1, false>, template <class __C1, class __C2>friend __bit_iterator<__C2, false> swap_ranges(__bit_iterator<__C1, false>,
__bit_iterator<__C1, false>, __bit_iterator<__C1, false>,
__bit_iterator<__C2, false>); __bit_iterator<__C2, false>);
template <class _Dp> template <class _Dp>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
friend __bit_iterator<_Dp, false> rotate(__bit_iterator<_Dp, false>, friend __bit_iterator<_Dp, false> rotate(__bit_iterator<_Dp, false>,
__bit_iterator<_Dp, false>, __bit_iterator<_Dp, false>,
__bit_iterator<_Dp, false>); __bit_iterator<_Dp, false>);
template <class _Dp, bool _IC1, bool _IC2> template <class _Dp, bool _IC1, bool _IC2>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
friend bool __equal_aligned(__bit_iterator<_Dp, _IC1>, friend bool __equal_aligned(__bit_iterator<_Dp, _IC1>,
__bit_iterator<_Dp, _IC1>, __bit_iterator<_Dp, _IC1>,
__bit_iterator<_Dp, _IC2>); __bit_iterator<_Dp, _IC2>);
template <class _Dp, bool _IC1, bool _IC2> template <class _Dp, bool _IC1, bool _IC2>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
friend bool __equal_unaligned(__bit_iterator<_Dp, _IC1>, friend bool __equal_unaligned(__bit_iterator<_Dp, _IC1>,
__bit_iterator<_Dp, _IC1>, __bit_iterator<_Dp, _IC1>,
__bit_iterator<_Dp, _IC2>); __bit_iterator<_Dp, _IC2>);
template <class _Dp, bool _IC1, bool _IC2> template <class _Dp, bool _IC1, bool _IC2>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
friend bool equal(__bit_iterator<_Dp, _IC1>, friend bool equal(__bit_iterator<_Dp, _IC1>,
__bit_iterator<_Dp, _IC1>, __bit_iterator<_Dp, _IC1>,
__bit_iterator<_Dp, _IC2>); __bit_iterator<_Dp, _IC2>);
template <class _Dp, bool _IC> template <class _Dp, bool _IC>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
friend __bit_iterator<_Dp, _IC> __find_bool_true(__bit_iterator<_Dp, _IC>, typename _Dp::size_type); friend __bit_iterator<_Dp, _IC> __find_bool_true(__bit_iterator<_Dp, _IC>, typename _Dp::size_type);
template <class _Dp, bool _IC> template <class _Dp, bool _IC>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
friend __bit_iterator<_Dp, _IC> __find_bool_false(__bit_iterator<_Dp, _IC>, typename _Dp::size_type); friend __bit_iterator<_Dp, _IC> __find_bool_false(__bit_iterator<_Dp, _IC>, typename _Dp::size_type);
template <class _Dp, bool _IC> friend typename __bit_iterator<_Dp, _IC>::difference_type template <class _Dp, bool _IC> friend typename __bit_iterator<_Dp, _IC>::difference_type
__count_bool_true(__bit_iterator<_Dp, _IC>, typename _Dp::size_type); __count_bool_true(__bit_iterator<_Dp, _IC>, typename _Dp::size_type);
template <class _Dp, bool _IC> friend typename __bit_iterator<_Dp, _IC>::difference_type template <class _Dp, bool _IC> friend typename __bit_iterator<_Dp, _IC>::difference_type
__count_bool_false(__bit_iterator<_Dp, _IC>, typename _Dp::size_type); __count_bool_false(__bit_iterator<_Dp, _IC>, typename _Dp::size_type);
}; };
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
_LIBCPP_POP_MACROS _LIBCPP_POP_MACROS
#endif // _LIBCPP___BIT_REFERENCE #endif // _LIBCPP___BIT_REFERENCE

libcxx/include/__charconv/chars_format.h

Show First 20 Lines • Show All 46 Lines • ▼ Show 20 Lines
} }
inline _LIBCPP_INLINE_VISIBILITY constexpr chars_format inline _LIBCPP_INLINE_VISIBILITY constexpr chars_format
operator^(chars_format __x, chars_format __y) { operator^(chars_format __x, chars_format __y) {
return chars_format(_VSTD::__to_underlying(__x) ^ return chars_format(_VSTD::__to_underlying(__x) ^
_VSTD::__to_underlying(__y)); _VSTD::__to_underlying(__y));
} }
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 chars_format& inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 chars_format&
operator&=(chars_format& __x, chars_format __y) { operator&=(chars_format& __x, chars_format __y) {
__x = __x & __y; __x = __x & __y;
return __x; return __x;
} }
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 chars_format& inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 chars_format&
operator|=(chars_format& __x, chars_format __y) { operator|=(chars_format& __x, chars_format __y) {
__x = __x | __y; __x = __x | __y;
return __x; return __x;
} }
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 chars_format& inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 chars_format&
operator^=(chars_format& __x, chars_format __y) { operator^=(chars_format& __x, chars_format __y) {
__x = __x ^ __y; __x = __x ^ __y;
return __x; return __x;
} }
#endif // _LIBCPP_CXX03_LANG #endif // _LIBCPP_CXX03_LANG
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___CHARCONV_CHARS_FORMAT_H #endif // _LIBCPP___CHARCONV_CHARS_FORMAT_H

libcxx/include/__chrono/duration.h

Show First 20 Lines • Show All 272 Lines • ▼ Show 20 Lines#endif
// observer // observer
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR rep count() const {return __rep_;} _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR rep count() const {return __rep_;}
// arithmetic // arithmetic
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR typename common_type<duration>::type operator+() const {return typename common_type<duration>::type(*this);} _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR typename common_type<duration>::type operator+() const {return typename common_type<duration>::type(*this);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR typename common_type<duration>::type operator-() const {return typename common_type<duration>::type(-__rep_);} _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR typename common_type<duration>::type operator-() const {return typename common_type<duration>::type(-__rep_);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator++() {++__rep_; return *this;} _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17 duration& operator++() {++__rep_; return *this;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration operator++(int) {return duration(__rep_++);} _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17 duration operator++(int) {return duration(__rep_++);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator--() {--__rep_; return *this;} _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17 duration& operator--() {--__rep_; return *this;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration operator--(int) {return duration(__rep_--);} _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17 duration operator--(int) {return duration(__rep_--);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator+=(const duration& __d) {__rep_ += __d.count(); return *this;} _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17 duration& operator+=(const duration& __d) {__rep_ += __d.count(); return *this;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator-=(const duration& __d) {__rep_ -= __d.count(); return *this;} _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17 duration& operator-=(const duration& __d) {__rep_ -= __d.count(); return *this;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator*=(const rep& __rhs) {__rep_ *= __rhs; return *this;} _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17 duration& operator*=(const rep& __rhs) {__rep_ *= __rhs; return *this;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator/=(const rep& __rhs) {__rep_ /= __rhs; return *this;} _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17 duration& operator/=(const rep& __rhs) {__rep_ /= __rhs; return *this;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator%=(const rep& __rhs) {__rep_ %= __rhs; return *this;} _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17 duration& operator%=(const rep& __rhs) {__rep_ %= __rhs; return *this;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator%=(const duration& __rhs) {__rep_ %= __rhs.count(); return *this;} _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17 duration& operator%=(const duration& __rhs) {__rep_ %= __rhs.count(); return *this;}
// special values // special values
_LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR duration zero() _NOEXCEPT {return duration(duration_values<rep>::zero());} _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR duration zero() _NOEXCEPT {return duration(duration_values<rep>::zero());}
_LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR duration min() _NOEXCEPT {return duration(duration_values<rep>::min());} _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR duration min() _NOEXCEPT {return duration(duration_values<rep>::min());}
_LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR duration max() _NOEXCEPT {return duration(duration_values<rep>::max());} _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR duration max() _NOEXCEPT {return duration(duration_values<rep>::max());}
}; };
▲ Show 20 Lines • Show All 315 Lines • Show Last 20 Lines

libcxx/include/__chrono/file_clock.h

Show First 20 Lines • Show All 55 Lines • ▼ Show 20 Lines#else
typedef long long rep; typedef long long rep;
typedef nano period; typedef nano period;
#endif #endif
typedef chrono::duration<rep, period> duration; typedef chrono::duration<rep, period> duration;
typedef chrono::time_point<_FilesystemClock> time_point; typedef chrono::time_point<_FilesystemClock> time_point;
_LIBCPP_EXPORTED_FROM_ABI _LIBCPP_EXPORTED_FROM_ABI
static _LIBCPP_CONSTEXPR_AFTER_CXX11 const bool is_steady = false; static _LIBCPP_CONSTEXPR_CXX14 const bool is_steady = false;
_LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_FUNC_VIS static time_point now() noexcept; _LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_FUNC_VIS static time_point now() noexcept;
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER > 17
template <class _Duration> template <class _Duration>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
static chrono::sys_time<_Duration> to_sys(const chrono::file_time<_Duration>& __t) { static chrono::sys_time<_Duration> to_sys(const chrono::file_time<_Duration>& __t) {
return chrono::sys_time<_Duration>(__t.time_since_epoch()); return chrono::sys_time<_Duration>(__t.time_since_epoch());
Show All 13 Lines

libcxx/include/__chrono/steady_clock.h

Show All 25 Lines
#ifndef _LIBCPP_HAS_NO_MONOTONIC_CLOCK #ifndef _LIBCPP_HAS_NO_MONOTONIC_CLOCK
class _LIBCPP_TYPE_VIS steady_clock class _LIBCPP_TYPE_VIS steady_clock
{ {
public: public:
typedef nanoseconds duration; typedef nanoseconds duration;
typedef duration::rep rep; typedef duration::rep rep;
typedef duration::period period; typedef duration::period period;
typedef chrono::time_point<steady_clock, duration> time_point; typedef chrono::time_point<steady_clock, duration> time_point;
static _LIBCPP_CONSTEXPR_AFTER_CXX11 const bool is_steady = true; static _LIBCPP_CONSTEXPR_CXX14 const bool is_steady = true;
static time_point now() _NOEXCEPT; static time_point now() _NOEXCEPT;
}; };
#endif #endif
} // namespace chrono } // namespace chrono
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___CHRONO_STEADY_CLOCK_H #endif // _LIBCPP___CHRONO_STEADY_CLOCK_H

libcxx/include/__chrono/system_clock.h

Show All 25 Lines
class _LIBCPP_TYPE_VIS system_clock class _LIBCPP_TYPE_VIS system_clock
{ {
public: public:
typedef microseconds duration; typedef microseconds duration;
typedef duration::rep rep; typedef duration::rep rep;
typedef duration::period period; typedef duration::period period;
typedef chrono::time_point<system_clock> time_point; typedef chrono::time_point<system_clock> time_point;
static _LIBCPP_CONSTEXPR_AFTER_CXX11 const bool is_steady = false; static _LIBCPP_CONSTEXPR_CXX14 const bool is_steady = false;
static time_point now() _NOEXCEPT; static time_point now() _NOEXCEPT;
static time_t to_time_t (const time_point& __t) _NOEXCEPT; static time_t to_time_t (const time_point& __t) _NOEXCEPT;
static time_point from_time_t(time_t __t) _NOEXCEPT; static time_point from_time_t(time_t __t) _NOEXCEPT;
}; };
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER > 17
Show All 12 Lines

libcxx/include/__chrono/time_point.h

Show All 35 Linespublic:
typedef _Clock clock; typedef _Clock clock;
typedef _Duration duration; typedef _Duration duration;
typedef typename duration::rep rep; typedef typename duration::rep rep;
typedef typename duration::period period; typedef typename duration::period period;
private: private:
duration __d_; duration __d_;
public: public:
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 time_point() : __d_(duration::zero()) {} _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 time_point() : __d_(duration::zero()) {}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 explicit time_point(const duration& __d) : __d_(__d) {} _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 explicit time_point(const duration& __d) : __d_(__d) {}
// conversions // conversions
template <class _Duration2> template <class _Duration2>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
time_point(const time_point<clock, _Duration2>& __t, time_point(const time_point<clock, _Duration2>& __t,
typename enable_if typename enable_if
< <
is_convertible<_Duration2, duration>::value is_convertible<_Duration2, duration>::value
>::type* = nullptr) >::type* = nullptr)
: __d_(__t.time_since_epoch()) {} : __d_(__t.time_since_epoch()) {}
// observer // observer
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 duration time_since_epoch() const {return __d_;} _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 duration time_since_epoch() const {return __d_;}
// arithmetic // arithmetic
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 time_point& operator+=(const duration& __d) {__d_ += __d; return *this;} _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17 time_point& operator+=(const duration& __d) {__d_ += __d; return *this;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 time_point& operator-=(const duration& __d) {__d_ -= __d; return *this;} _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17 time_point& operator-=(const duration& __d) {__d_ -= __d; return *this;}
// special values // special values
_LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR time_point min() _NOEXCEPT {return time_point(duration::min());} _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR time_point min() _NOEXCEPT {return time_point(duration::min());}
_LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR time_point max() _NOEXCEPT {return time_point(duration::max());} _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR time_point max() _NOEXCEPT {return time_point(duration::max());}
}; };
} // namespace chrono } // namespace chrono
template <class _Clock, class _Duration1, class _Duration2> template <class _Clock, class _Duration1, class _Duration2>
struct _LIBCPP_TEMPLATE_VIS common_type<chrono::time_point<_Clock, _Duration1>, struct _LIBCPP_TEMPLATE_VIS common_type<chrono::time_point<_Clock, _Duration1>,
chrono::time_point<_Clock, _Duration2> > chrono::time_point<_Clock, _Duration2> >
{ {
typedef chrono::time_point<_Clock, typename common_type<_Duration1, _Duration2>::type> type; typedef chrono::time_point<_Clock, typename common_type<_Duration1, _Duration2>::type> type;
}; };
namespace chrono { namespace chrono {
template <class _ToDuration, class _Clock, class _Duration> template <class _ToDuration, class _Clock, class _Duration>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
time_point<_Clock, _ToDuration> time_point<_Clock, _ToDuration>
time_point_cast(const time_point<_Clock, _Duration>& __t) time_point_cast(const time_point<_Clock, _Duration>& __t)
{ {
return time_point<_Clock, _ToDuration>(chrono::duration_cast<_ToDuration>(__t.time_since_epoch())); return time_point<_Clock, _ToDuration>(chrono::duration_cast<_ToDuration>(__t.time_since_epoch()));
} }
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER > 14
template <class _ToDuration, class _Clock, class _Duration> template <class _ToDuration, class _Clock, class _Duration>
▲ Show 20 Lines • Show All 43 Lines • ▼ Show 20 Lines
{ {
return __d >= __d.zero() ? +__d : -__d; return __d >= __d.zero() ? +__d : -__d;
} }
#endif // _LIBCPP_STD_VER > 14 #endif // _LIBCPP_STD_VER > 14
// time_point == // time_point ==
template <class _Clock, class _Duration1, class _Duration2> template <class _Clock, class _Duration1, class _Duration2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
bool bool
operator==(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs) operator==(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs)
{ {
return __lhs.time_since_epoch() == __rhs.time_since_epoch(); return __lhs.time_since_epoch() == __rhs.time_since_epoch();
} }
// time_point != // time_point !=
template <class _Clock, class _Duration1, class _Duration2> template <class _Clock, class _Duration1, class _Duration2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
bool bool
operator!=(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs) operator!=(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs)
{ {
return !(__lhs == __rhs); return !(__lhs == __rhs);
} }
// time_point < // time_point <
template <class _Clock, class _Duration1, class _Duration2> template <class _Clock, class _Duration1, class _Duration2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
bool bool
operator<(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs) operator<(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs)
{ {
return __lhs.time_since_epoch() < __rhs.time_since_epoch(); return __lhs.time_since_epoch() < __rhs.time_since_epoch();
} }
// time_point > // time_point >
template <class _Clock, class _Duration1, class _Duration2> template <class _Clock, class _Duration1, class _Duration2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
bool bool
operator>(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs) operator>(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs)
{ {
return __rhs < __lhs; return __rhs < __lhs;
} }
// time_point <= // time_point <=
template <class _Clock, class _Duration1, class _Duration2> template <class _Clock, class _Duration1, class _Duration2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
bool bool
operator<=(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs) operator<=(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs)
{ {
return !(__rhs < __lhs); return !(__rhs < __lhs);
} }
// time_point >= // time_point >=
template <class _Clock, class _Duration1, class _Duration2> template <class _Clock, class _Duration1, class _Duration2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
bool bool
operator>=(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs) operator>=(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs)
{ {
return !(__lhs < __rhs); return !(__lhs < __rhs);
} }
// time_point operator+(time_point x, duration y); // time_point operator+(time_point x, duration y);
template <class _Clock, class _Duration1, class _Rep2, class _Period2> template <class _Clock, class _Duration1, class _Rep2, class _Period2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
time_point<_Clock, typename common_type<_Duration1, duration<_Rep2, _Period2> >::type> time_point<_Clock, typename common_type<_Duration1, duration<_Rep2, _Period2> >::type>
operator+(const time_point<_Clock, _Duration1>& __lhs, const duration<_Rep2, _Period2>& __rhs) operator+(const time_point<_Clock, _Duration1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
{ {
typedef time_point<_Clock, typename common_type<_Duration1, duration<_Rep2, _Period2> >::type> _Tr; typedef time_point<_Clock, typename common_type<_Duration1, duration<_Rep2, _Period2> >::type> _Tr;
return _Tr (__lhs.time_since_epoch() + __rhs); return _Tr (__lhs.time_since_epoch() + __rhs);
} }
// time_point operator+(duration x, time_point y); // time_point operator+(duration x, time_point y);
template <class _Rep1, class _Period1, class _Clock, class _Duration2> template <class _Rep1, class _Period1, class _Clock, class _Duration2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
time_point<_Clock, typename common_type<duration<_Rep1, _Period1>, _Duration2>::type> time_point<_Clock, typename common_type<duration<_Rep1, _Period1>, _Duration2>::type>
operator+(const duration<_Rep1, _Period1>& __lhs, const time_point<_Clock, _Duration2>& __rhs) operator+(const duration<_Rep1, _Period1>& __lhs, const time_point<_Clock, _Duration2>& __rhs)
{ {
return __rhs + __lhs; return __rhs + __lhs;
} }
// time_point operator-(time_point x, duration y); // time_point operator-(time_point x, duration y);
template <class _Clock, class _Duration1, class _Rep2, class _Period2> template <class _Clock, class _Duration1, class _Rep2, class _Period2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
time_point<_Clock, typename common_type<_Duration1, duration<_Rep2, _Period2> >::type> time_point<_Clock, typename common_type<_Duration1, duration<_Rep2, _Period2> >::type>
operator-(const time_point<_Clock, _Duration1>& __lhs, const duration<_Rep2, _Period2>& __rhs) operator-(const time_point<_Clock, _Duration1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
{ {
typedef time_point<_Clock, typename common_type<_Duration1, duration<_Rep2, _Period2> >::type> _Ret; typedef time_point<_Clock, typename common_type<_Duration1, duration<_Rep2, _Period2> >::type> _Ret;
return _Ret(__lhs.time_since_epoch() -__rhs); return _Ret(__lhs.time_since_epoch() -__rhs);
} }
// duration operator-(time_point x, time_point y); // duration operator-(time_point x, time_point y);
template <class _Clock, class _Duration1, class _Duration2> template <class _Clock, class _Duration1, class _Duration2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
typename common_type<_Duration1, _Duration2>::type typename common_type<_Duration1, _Duration2>::type
operator-(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs) operator-(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs)
{ {
return __lhs.time_since_epoch() - __rhs.time_since_epoch(); return __lhs.time_since_epoch() - __rhs.time_since_epoch();
} }
} // namespace chrono } // namespace chrono
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
_LIBCPP_POP_MACROS _LIBCPP_POP_MACROS
#endif // _LIBCPP___CHRONO_TIME_POINT_H #endif // _LIBCPP___CHRONO_TIME_POINT_H

libcxx/include/__config

Show First 20 Lines • Show All 826 Lines • ▼ Show 20 Lines
# if _LIBCPP_STD_VER <= 11 # if _LIBCPP_STD_VER <= 11
# define _LIBCPP_EXPLICIT_AFTER_CXX11 # define _LIBCPP_EXPLICIT_AFTER_CXX11
# else # else
# define _LIBCPP_EXPLICIT_AFTER_CXX11 explicit # define _LIBCPP_EXPLICIT_AFTER_CXX11 explicit
# endif # endif
# if _LIBCPP_STD_VER > 11 # if _LIBCPP_STD_VER > 11
# define _LIBCPP_CONSTEXPR_AFTER_CXX11 constexpr # define _LIBCPP_CONSTEXPR_CXX14 constexpr
huixie90Unsubmitted
Done
ReplyInline Actions

I am ok with the name in your patch. But have you considered
_LIBCPP_CONSTEXPR_SINCE_CXX14
The reason why I like this name is because in the synopsis it is exact these words "// constexpr since C++14"

huixie90: I am ok with the name in your patch. But have you considered `_LIBCPP_CONSTEXPR_SINCE_CXX14`…
jloserUnsubmitted
Done
ReplyInline Actions

I quite like the naming convention of using "since", e.g. _LIBCPP_CONSTEXPR_SINCE_CXX14 as you proposed, @huixie90. I'm also not opposed to @philnik current proposed rename as I do like it better than the status quo on top of tree.

jloser: I quite like the naming convention of using "since", e.g. `_LIBCPP_CONSTEXPR_SINCE_CXX14` as…
philnikAuthorUnsubmitted
Done
ReplyInline Actions

I have considered the name, but I think that _LIBCPP_CONSTEXPR_SINCE_CXXab is unnecessarily verbose. We already use TEST_CONSTEXPR_CXXab in the tests and AFAIK nobody ever complained about it. @ldionne also proposed _LIBCPP_CONSTEXPR_IN_CXXab, but there the same applies.

philnik: I have considered the name, but I think that `_LIBCPP_CONSTEXPR_SINCE_CXXab` is unnecessarily…
MordanteUnsubmitted
Not Done
ReplyInline Actions

+1 for using the same naming style in our main code and our tests.

Mordante: +1 for using the same naming style in our main code and our tests.
ldionneUnsubmitted
Done
ReplyInline Actions

My preference is also _LIBCPP_CONSTEXPR_SINCE_CXX14. If we want full consistency, I would actually rename the test macros to TEST_CONSTEXPR_SINCE_CXX14. I think that SINCE expresses the intent of the macro much better, i.e. "this API is constexpr since C++xy". Without SINCE, one could imagine that this instead represents e.g. the constexpr capabilities of the compiler, which is not the case (we assume those capabilities, instead). So yeah, big +1 for using SINCE.

In fact, I think we really have two macros here. Once of them is _LIBCPP_CONSTEXPR_SINCE_CXXYZ, aimed towards our API, and the other one is _LIBCPP_CXXYZ_CONSTEXPR_SUPPORTED, aimed for implementation detail functions that essentially want to be constexpr as early as the language supports it. I am not sure it makes sense to introduce that macro, though, but it illustrates why I like the SINCE variant better.

ldionne: My preference is also `_LIBCPP_CONSTEXPR_SINCE_CXX14`. If we want full consistency, I would…
# else # else
# define _LIBCPP_CONSTEXPR_AFTER_CXX11 # define _LIBCPP_CONSTEXPR_CXX14
# endif # endif
# if _LIBCPP_STD_VER > 14 # if _LIBCPP_STD_VER > 14
# define _LIBCPP_CONSTEXPR_AFTER_CXX14 constexpr # define _LIBCPP_CONSTEXPR_CXX17 constexpr
# else # else
# define _LIBCPP_CONSTEXPR_AFTER_CXX14 # define _LIBCPP_CONSTEXPR_CXX17
# endif # endif
# if _LIBCPP_STD_VER > 17 # if _LIBCPP_STD_VER > 17
# define _LIBCPP_CONSTEXPR_AFTER_CXX17 constexpr # define _LIBCPP_CONSTEXPR_CXX20 constexpr
# else # else
# define _LIBCPP_CONSTEXPR_AFTER_CXX17 # define _LIBCPP_CONSTEXPR_CXX20
# endif # endif
# if __has_cpp_attribute(nodiscard) || defined(_LIBCPP_COMPILER_MSVC) # if __has_cpp_attribute(nodiscard) || defined(_LIBCPP_COMPILER_MSVC)
# define _LIBCPP_NODISCARD [[nodiscard]] # define _LIBCPP_NODISCARD [[nodiscard]]
# elif defined(_LIBCPP_COMPILER_CLANG_BASED) && !defined(_LIBCPP_CXX03_LANG) # elif defined(_LIBCPP_COMPILER_CLANG_BASED) && !defined(_LIBCPP_CXX03_LANG)
# define _LIBCPP_NODISCARD [[clang::warn_unused_result]] # define _LIBCPP_NODISCARD [[clang::warn_unused_result]]
# else # else
// We can't use GCC's [[gnu::warn_unused_result]] and // We can't use GCC's [[gnu::warn_unused_result]] and
▲ Show 20 Lines • Show All 367 Lines • Show Last 20 Lines

libcxx/include/__debug

Show First 20 Lines • Show All 206 Lines • ▼ Show 20 Lines
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // defined(_LIBCPP_ENABLE_DEBUG_MODE) || defined(_LIBCPP_BUILDING_LIBRARY) #endif // defined(_LIBCPP_ENABLE_DEBUG_MODE) || defined(_LIBCPP_BUILDING_LIBRARY)
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp> template <class _Tp>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 inline void __debug_db_insert_c(_Tp* __c) { _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14 inline void __debug_db_insert_c(_Tp* __c) {
#ifdef _LIBCPP_ENABLE_DEBUG_MODE #ifdef _LIBCPP_ENABLE_DEBUG_MODE
if (!__libcpp_is_constant_evaluated()) if (!__libcpp_is_constant_evaluated())
__get_db()->__insert_c(__c); __get_db()->__insert_c(__c);
#else #else
(void)(__c); (void)(__c);
#endif #endif
} }
template <class _Tp> template <class _Tp>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 inline void __debug_db_insert_i(_Tp* __i) { _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14 inline void __debug_db_insert_i(_Tp* __i) {
#ifdef _LIBCPP_ENABLE_DEBUG_MODE #ifdef _LIBCPP_ENABLE_DEBUG_MODE
if (!__libcpp_is_constant_evaluated()) if (!__libcpp_is_constant_evaluated())
__get_db()->__insert_i(__i); __get_db()->__insert_i(__i);
#else #else
(void)(__i); (void)(__i);
#endif #endif
} }
template <class _Tp> template <class _Tp>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 inline void __debug_db_erase_c(_Tp* __c) { _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14 inline void __debug_db_erase_c(_Tp* __c) {
#ifdef _LIBCPP_ENABLE_DEBUG_MODE #ifdef _LIBCPP_ENABLE_DEBUG_MODE
if (!__libcpp_is_constant_evaluated()) if (!__libcpp_is_constant_evaluated())
__get_db()->__erase_c(__c); __get_db()->__erase_c(__c);
#else #else
(void)(__c); (void)(__c);
#endif #endif
} }
template <class _Tp> template <class _Tp>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 inline void __debug_db_swap(_Tp* __lhs, _Tp* __rhs) { _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14 inline void __debug_db_swap(_Tp* __lhs, _Tp* __rhs) {
#ifdef _LIBCPP_ENABLE_DEBUG_MODE #ifdef _LIBCPP_ENABLE_DEBUG_MODE
if (!__libcpp_is_constant_evaluated()) if (!__libcpp_is_constant_evaluated())
__get_db()->swap(__lhs, __rhs); __get_db()->swap(__lhs, __rhs);
#else #else
(void)(__lhs); (void)(__lhs);
(void)(__rhs); (void)(__rhs);
#endif #endif
} }
template <class _Tp> template <class _Tp>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 inline void __debug_db_invalidate_all(_Tp* __c) { _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14 inline void __debug_db_invalidate_all(_Tp* __c) {
#ifdef _LIBCPP_ENABLE_DEBUG_MODE #ifdef _LIBCPP_ENABLE_DEBUG_MODE
if (!__libcpp_is_constant_evaluated()) if (!__libcpp_is_constant_evaluated())
__get_db()->__invalidate_all(__c); __get_db()->__invalidate_all(__c);
#else #else
(void)(__c); (void)(__c);
#endif #endif
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___DEBUG #endif // _LIBCPP___DEBUG

libcxx/include/__debug_utils/randomize_range.h

Show All 17 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 _AlgPolicy, class _Iterator, class _Sentinel> template <class _AlgPolicy, class _Iterator, class _Sentinel>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14
void __debug_randomize_range(_Iterator __first, _Sentinel __last) { void __debug_randomize_range(_Iterator __first, _Sentinel __last) {
#ifdef _LIBCPP_DEBUG_RANDOMIZE_UNSPECIFIED_STABILITY #ifdef _LIBCPP_DEBUG_RANDOMIZE_UNSPECIFIED_STABILITY
# ifdef _LIBCPP_CXX03_LANG # ifdef _LIBCPP_CXX03_LANG
# error Support for unspecified stability is only for C++11 and higher # error Support for unspecified stability is only for C++11 and higher
# endif # endif
if (!__libcpp_is_constant_evaluated()) if (!__libcpp_is_constant_evaluated())
std::__shuffle<_AlgPolicy>(__first, __last, __libcpp_debug_randomizer()); std::__shuffle<_AlgPolicy>(__first, __last, __libcpp_debug_randomizer());
Show All 9 Lines

libcxx/include/__functional/binary_negate.h

Show All 23 Lines
template <class _Predicate> template <class _Predicate>
class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX17 binary_negate class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX17 binary_negate
: public __binary_function<typename _Predicate::first_argument_type, : public __binary_function<typename _Predicate::first_argument_type,
typename _Predicate::second_argument_type, typename _Predicate::second_argument_type,
bool> bool>
{ {
_Predicate __pred_; _Predicate __pred_;
public: public:
_LIBCPP_INLINE_VISIBILITY explicit _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY explicit _LIBCPP_CONSTEXPR_CXX14
binary_negate(const _Predicate& __pred) : __pred_(__pred) {} binary_negate(const _Predicate& __pred) : __pred_(__pred) {}
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
bool operator()(const typename _Predicate::first_argument_type& __x, bool operator()(const typename _Predicate::first_argument_type& __x,
const typename _Predicate::second_argument_type& __y) const const typename _Predicate::second_argument_type& __y) const
{return !__pred_(__x, __y);} {return !__pred_(__x, __y);}
}; };
template <class _Predicate> template <class _Predicate>
_LIBCPP_DEPRECATED_IN_CXX17 inline _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_DEPRECATED_IN_CXX17 inline _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
binary_negate<_Predicate> binary_negate<_Predicate>
not2(const _Predicate& __pred) {return binary_negate<_Predicate>(__pred);} not2(const _Predicate& __pred) {return binary_negate<_Predicate>(__pred);}
#endif // _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_NEGATORS) #endif // _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_NEGATORS)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___FUNCTIONAL_BINARY_NEGATE_H #endif // _LIBCPP___FUNCTIONAL_BINARY_NEGATE_H

libcxx/include/__functional/bind.h

Show First 20 Lines • Show All 276 Lines • ▼ Show 20 Lines
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<typename remove_reference<_Gp>::type,
__bind>::value __bind>::value
>::type> >::type>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_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>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
typename __bind_return<_Fd, _Td, tuple<_Args&&...> >::type typename __bind_return<_Fd, _Td, tuple<_Args&&...> >::type
operator()(_Args&& ...__args) operator()(_Args&& ...__args)
{ {
return _VSTD::__apply_functor(__f_, __bound_args_, __indices(), return _VSTD::__apply_functor(__f_, __bound_args_, __indices(),
tuple<_Args&&...>(_VSTD::forward<_Args>(__args)...)); tuple<_Args&&...>(_VSTD::forward<_Args>(__args)...));
} }
template <class ..._Args> template <class ..._Args>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
typename __bind_return<const _Fd, const _Td, tuple<_Args&&...> >::type typename __bind_return<const _Fd, const _Td, tuple<_Args&&...> >::type
operator()(_Args&& ...__args) const operator()(_Args&& ...__args) const
{ {
return _VSTD::__apply_functor(__f_, __bound_args_, __indices(), return _VSTD::__apply_functor(__f_, __bound_args_, __indices(),
tuple<_Args&&...>(_VSTD::forward<_Args>(__args)...)); tuple<_Args&&...>(_VSTD::forward<_Args>(__args)...));
} }
}; };
Show All 13 Linespublic:
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<typename remove_reference<_Gp>::type,
__bind_r>::value __bind_r>::value
>::type> >::type>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_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>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
typename enable_if typename enable_if
< <
is_convertible<typename __bind_return<_Fd, _Td, tuple<_Args&&...> >::type, is_convertible<typename __bind_return<_Fd, _Td, tuple<_Args&&...> >::type,
result_type>::value || is_void<_Rp>::value, result_type>::value || is_void<_Rp>::value,
result_type result_type
>::type >::type
operator()(_Args&& ...__args) operator()(_Args&& ...__args)
{ {
typedef __invoke_void_return_wrapper<_Rp> _Invoker; typedef __invoke_void_return_wrapper<_Rp> _Invoker;
return _Invoker::__call(static_cast<base&>(*this), _VSTD::forward<_Args>(__args)...); return _Invoker::__call(static_cast<base&>(*this), _VSTD::forward<_Args>(__args)...);
} }
template <class ..._Args> template <class ..._Args>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
typename enable_if typename enable_if
< <
is_convertible<typename __bind_return<const _Fd, const _Td, tuple<_Args&&...> >::type, is_convertible<typename __bind_return<const _Fd, const _Td, tuple<_Args&&...> >::type,
result_type>::value || is_void<_Rp>::value, result_type>::value || is_void<_Rp>::value,
result_type result_type
>::type >::type
operator()(_Args&& ...__args) const operator()(_Args&& ...__args) const
{ {
typedef __invoke_void_return_wrapper<_Rp> _Invoker; typedef __invoke_void_return_wrapper<_Rp> _Invoker;
return _Invoker::__call(static_cast<base const&>(*this), _VSTD::forward<_Args>(__args)...); return _Invoker::__call(static_cast<base const&>(*this), _VSTD::forward<_Args>(__args)...);
} }
}; };
template<class _Rp, class _Fp, class ..._BoundArgs> template<class _Rp, class _Fp, class ..._BoundArgs>
struct is_bind_expression<__bind_r<_Rp, _Fp, _BoundArgs...> > : public true_type {}; struct is_bind_expression<__bind_r<_Rp, _Fp, _BoundArgs...> > : public true_type {};
template<class _Fp, class ..._BoundArgs> template<class _Fp, class ..._BoundArgs>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
__bind<_Fp, _BoundArgs...> __bind<_Fp, _BoundArgs...>
bind(_Fp&& __f, _BoundArgs&&... __bound_args) bind(_Fp&& __f, _BoundArgs&&... __bound_args)
{ {
typedef __bind<_Fp, _BoundArgs...> type; typedef __bind<_Fp, _BoundArgs...> type;
return type(_VSTD::forward<_Fp>(__f), _VSTD::forward<_BoundArgs>(__bound_args)...); return type(_VSTD::forward<_Fp>(__f), _VSTD::forward<_BoundArgs>(__bound_args)...);
} }
template<class _Rp, class _Fp, class ..._BoundArgs> template<class _Rp, class _Fp, class ..._BoundArgs>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
__bind_r<_Rp, _Fp, _BoundArgs...> __bind_r<_Rp, _Fp, _BoundArgs...>
bind(_Fp&& __f, _BoundArgs&&... __bound_args) bind(_Fp&& __f, _BoundArgs&&... __bound_args)
{ {
typedef __bind_r<_Rp, _Fp, _BoundArgs...> type; typedef __bind_r<_Rp, _Fp, _BoundArgs...> type;
return type(_VSTD::forward<_Fp>(__f), _VSTD::forward<_BoundArgs>(__bound_args)...); return type(_VSTD::forward<_Fp>(__f), _VSTD::forward<_BoundArgs>(__bound_args)...);
} }
#endif // _LIBCPP_CXX03_LANG #endif // _LIBCPP_CXX03_LANG
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___FUNCTIONAL_BIND_H #endif // _LIBCPP___FUNCTIONAL_BIND_H

libcxx/include/__functional/default_searcher.h

Show All 23 Lines
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER > 14
// default searcher // default searcher
template<class _ForwardIterator, class _BinaryPredicate = equal_to<>> template<class _ForwardIterator, class _BinaryPredicate = equal_to<>>
class _LIBCPP_TEMPLATE_VIS default_searcher { class _LIBCPP_TEMPLATE_VIS default_searcher {
public: public:
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
default_searcher(_ForwardIterator __f, _ForwardIterator __l, default_searcher(_ForwardIterator __f, _ForwardIterator __l,
_BinaryPredicate __p = _BinaryPredicate()) _BinaryPredicate __p = _BinaryPredicate())
: __first_(__f), __last_(__l), __pred_(__p) {} : __first_(__f), __last_(__l), __pred_(__p) {}
template <typename _ForwardIterator2> template <typename _ForwardIterator2>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
pair<_ForwardIterator2, _ForwardIterator2> pair<_ForwardIterator2, _ForwardIterator2>
operator () (_ForwardIterator2 __f, _ForwardIterator2 __l) const operator () (_ForwardIterator2 __f, _ForwardIterator2 __l) const
{ {
auto __proj = __identity(); auto __proj = __identity();
return std::__search_impl(__f, __l, __first_, __last_, __pred_, __proj, __proj); return std::__search_impl(__f, __l, __first_, __last_, __pred_, __proj, __proj);
} }
private: private:
Show All 10 Lines

libcxx/include/__functional/invoke.h

Show First 20 Lines • Show All 518 Lines • ▼ Show 20 Linesstruct _LIBCPP_TEMPLATE_VIS invoke_result
: __invoke_of<_Fn, _Args...> : __invoke_of<_Fn, _Args...>
{ {
}; };
template <class _Fn, class... _Args> template <class _Fn, class... _Args>
using invoke_result_t = typename invoke_result<_Fn, _Args...>::type; using invoke_result_t = typename invoke_result<_Fn, _Args...>::type;
template <class _Fn, class ..._Args> template <class _Fn, class ..._Args>
_LIBCPP_CONSTEXPR_AFTER_CXX17 invoke_result_t<_Fn, _Args...> _LIBCPP_CONSTEXPR_CXX20 invoke_result_t<_Fn, _Args...>
invoke(_Fn&& __f, _Args&&... __args) invoke(_Fn&& __f, _Args&&... __args)
noexcept(is_nothrow_invocable_v<_Fn, _Args...>) noexcept(is_nothrow_invocable_v<_Fn, _Args...>)
{ {
return _VSTD::__invoke(_VSTD::forward<_Fn>(__f), _VSTD::forward<_Args>(__args)...); return _VSTD::__invoke(_VSTD::forward<_Fn>(__f), _VSTD::forward<_Args>(__args)...);
} }
#endif // _LIBCPP_STD_VER > 14 #endif // _LIBCPP_STD_VER > 14
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___FUNCTIONAL_INVOKE_H #endif // _LIBCPP___FUNCTIONAL_INVOKE_H

libcxx/include/__functional/mem_fn.h

Show All 27 Lines
{ {
public: public:
// types // types
typedef _Tp type; typedef _Tp type;
private: private:
type __f_; type __f_;
public: public:
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
__mem_fn(type __f) _NOEXCEPT : __f_(__f) {} __mem_fn(type __f) _NOEXCEPT : __f_(__f) {}
// invoke // invoke
template <class... _ArgTypes> template <class... _ArgTypes>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
typename __invoke_return<type, _ArgTypes...>::type typename __invoke_return<type, _ArgTypes...>::type
operator() (_ArgTypes&&... __args) const { operator() (_ArgTypes&&... __args) const {
return std::__invoke(__f_, std::forward<_ArgTypes>(__args)...); return std::__invoke(__f_, std::forward<_ArgTypes>(__args)...);
} }
}; };
template<class _Rp, class _Tp> template<class _Rp, class _Tp>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
__mem_fn<_Rp _Tp::*> __mem_fn<_Rp _Tp::*>
mem_fn(_Rp _Tp::* __pm) _NOEXCEPT mem_fn(_Rp _Tp::* __pm) _NOEXCEPT
{ {
return __mem_fn<_Rp _Tp::*>(__pm); return __mem_fn<_Rp _Tp::*>(__pm);
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___FUNCTIONAL_MEM_FN_H #endif // _LIBCPP___FUNCTIONAL_MEM_FN_H

libcxx/include/__functional/not_fn.h

Show All 21 Lines
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER > 14
struct __not_fn_op { struct __not_fn_op {
template <class... _Args> template <class... _Args>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
_LIBCPP_CONSTEXPR_AFTER_CXX17 auto operator()(_Args&&... __args) const _LIBCPP_CONSTEXPR_CXX20 auto operator()(_Args&&... __args) const
noexcept(noexcept(!_VSTD::invoke(_VSTD::forward<_Args>(__args)...))) noexcept(noexcept(!_VSTD::invoke(_VSTD::forward<_Args>(__args)...)))
-> decltype( !_VSTD::invoke(_VSTD::forward<_Args>(__args)...)) -> decltype( !_VSTD::invoke(_VSTD::forward<_Args>(__args)...))
{ return !_VSTD::invoke(_VSTD::forward<_Args>(__args)...); } { return !_VSTD::invoke(_VSTD::forward<_Args>(__args)...); }
}; };
template <class _Fn> template <class _Fn>
struct __not_fn_t : __perfect_forward<__not_fn_op, _Fn> { struct __not_fn_t : __perfect_forward<__not_fn_op, _Fn> {
using __perfect_forward<__not_fn_op, _Fn>::__perfect_forward; using __perfect_forward<__not_fn_op, _Fn>::__perfect_forward;
}; };
template <class _Fn, class = enable_if_t< template <class _Fn, class = enable_if_t<
is_constructible_v<decay_t<_Fn>, _Fn> && is_constructible_v<decay_t<_Fn>, _Fn> &&
is_move_constructible_v<decay_t<_Fn>> is_move_constructible_v<decay_t<_Fn>>
>> >>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
_LIBCPP_CONSTEXPR_AFTER_CXX17 auto not_fn(_Fn&& __f) { _LIBCPP_CONSTEXPR_CXX20 auto not_fn(_Fn&& __f) {
return __not_fn_t<decay_t<_Fn>>(_VSTD::forward<_Fn>(__f)); return __not_fn_t<decay_t<_Fn>>(_VSTD::forward<_Fn>(__f));
} }
#endif // _LIBCPP_STD_VER > 14 #endif // _LIBCPP_STD_VER > 14
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___FUNCTIONAL_NOT_FN_H #endif // _LIBCPP___FUNCTIONAL_NOT_FN_H

libcxx/include/__functional/operations.h

Show All 26 Lines
template <class _Tp = void> template <class _Tp = void>
#else #else
template <class _Tp> template <class _Tp>
#endif #endif
struct _LIBCPP_TEMPLATE_VIS plus struct _LIBCPP_TEMPLATE_VIS plus
: __binary_function<_Tp, _Tp, _Tp> : __binary_function<_Tp, _Tp, _Tp>
{ {
typedef _Tp __result_type; // used by valarray typedef _Tp __result_type; // used by valarray
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
_Tp operator()(const _Tp& __x, const _Tp& __y) const _Tp operator()(const _Tp& __x, const _Tp& __y) const
{return __x + __y;} {return __x + __y;}
}; };
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER > 11
template <> template <>
struct _LIBCPP_TEMPLATE_VIS plus<void> struct _LIBCPP_TEMPLATE_VIS plus<void>
{ {
template <class _T1, class _T2> template <class _T1, class _T2>
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
auto operator()(_T1&& __t, _T2&& __u) const auto operator()(_T1&& __t, _T2&& __u) const
noexcept(noexcept(_VSTD::forward<_T1>(__t) + _VSTD::forward<_T2>(__u))) noexcept(noexcept(_VSTD::forward<_T1>(__t) + _VSTD::forward<_T2>(__u)))
-> decltype( _VSTD::forward<_T1>(__t) + _VSTD::forward<_T2>(__u)) -> decltype( _VSTD::forward<_T1>(__t) + _VSTD::forward<_T2>(__u))
{ return _VSTD::forward<_T1>(__t) + _VSTD::forward<_T2>(__u); } { return _VSTD::forward<_T1>(__t) + _VSTD::forward<_T2>(__u); }
typedef void is_transparent; typedef void is_transparent;
}; };
#endif #endif
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER > 11
template <class _Tp = void> template <class _Tp = void>
#else #else
template <class _Tp> template <class _Tp>
#endif #endif
struct _LIBCPP_TEMPLATE_VIS minus struct _LIBCPP_TEMPLATE_VIS minus
: __binary_function<_Tp, _Tp, _Tp> : __binary_function<_Tp, _Tp, _Tp>
{ {
typedef _Tp __result_type; // used by valarray typedef _Tp __result_type; // used by valarray
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
_Tp operator()(const _Tp& __x, const _Tp& __y) const _Tp operator()(const _Tp& __x, const _Tp& __y) const
{return __x - __y;} {return __x - __y;}
}; };
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER > 11
template <> template <>
struct _LIBCPP_TEMPLATE_VIS minus<void> struct _LIBCPP_TEMPLATE_VIS minus<void>
{ {
template <class _T1, class _T2> template <class _T1, class _T2>
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
auto operator()(_T1&& __t, _T2&& __u) const auto operator()(_T1&& __t, _T2&& __u) const
noexcept(noexcept(_VSTD::forward<_T1>(__t) - _VSTD::forward<_T2>(__u))) noexcept(noexcept(_VSTD::forward<_T1>(__t) - _VSTD::forward<_T2>(__u)))
-> decltype( _VSTD::forward<_T1>(__t) - _VSTD::forward<_T2>(__u)) -> decltype( _VSTD::forward<_T1>(__t) - _VSTD::forward<_T2>(__u))
{ return _VSTD::forward<_T1>(__t) - _VSTD::forward<_T2>(__u); } { return _VSTD::forward<_T1>(__t) - _VSTD::forward<_T2>(__u); }
typedef void is_transparent; typedef void is_transparent;
}; };
#endif #endif
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER > 11
template <class _Tp = void> template <class _Tp = void>
#else #else
template <class _Tp> template <class _Tp>
#endif #endif
struct _LIBCPP_TEMPLATE_VIS multiplies struct _LIBCPP_TEMPLATE_VIS multiplies
: __binary_function<_Tp, _Tp, _Tp> : __binary_function<_Tp, _Tp, _Tp>
{ {
typedef _Tp __result_type; // used by valarray typedef _Tp __result_type; // used by valarray
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
_Tp operator()(const _Tp& __x, const _Tp& __y) const _Tp operator()(const _Tp& __x, const _Tp& __y) const
{return __x * __y;} {return __x * __y;}
}; };
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER > 11
template <> template <>
struct _LIBCPP_TEMPLATE_VIS multiplies<void> struct _LIBCPP_TEMPLATE_VIS multiplies<void>
{ {
template <class _T1, class _T2> template <class _T1, class _T2>
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
auto operator()(_T1&& __t, _T2&& __u) const auto operator()(_T1&& __t, _T2&& __u) const
noexcept(noexcept(_VSTD::forward<_T1>(__t) * _VSTD::forward<_T2>(__u))) noexcept(noexcept(_VSTD::forward<_T1>(__t) * _VSTD::forward<_T2>(__u)))
-> decltype( _VSTD::forward<_T1>(__t) * _VSTD::forward<_T2>(__u)) -> decltype( _VSTD::forward<_T1>(__t) * _VSTD::forward<_T2>(__u))
{ return _VSTD::forward<_T1>(__t) * _VSTD::forward<_T2>(__u); } { return _VSTD::forward<_T1>(__t) * _VSTD::forward<_T2>(__u); }
typedef void is_transparent; typedef void is_transparent;
}; };
#endif #endif
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER > 11
template <class _Tp = void> template <class _Tp = void>
#else #else
template <class _Tp> template <class _Tp>
#endif #endif
struct _LIBCPP_TEMPLATE_VIS divides struct _LIBCPP_TEMPLATE_VIS divides
: __binary_function<_Tp, _Tp, _Tp> : __binary_function<_Tp, _Tp, _Tp>
{ {
typedef _Tp __result_type; // used by valarray typedef _Tp __result_type; // used by valarray
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
_Tp operator()(const _Tp& __x, const _Tp& __y) const _Tp operator()(const _Tp& __x, const _Tp& __y) const
{return __x / __y;} {return __x / __y;}
}; };
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER > 11
template <> template <>
struct _LIBCPP_TEMPLATE_VIS divides<void> struct _LIBCPP_TEMPLATE_VIS divides<void>
{ {
template <class _T1, class _T2> template <class _T1, class _T2>
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
auto operator()(_T1&& __t, _T2&& __u) const auto operator()(_T1&& __t, _T2&& __u) const
noexcept(noexcept(_VSTD::forward<_T1>(__t) / _VSTD::forward<_T2>(__u))) noexcept(noexcept(_VSTD::forward<_T1>(__t) / _VSTD::forward<_T2>(__u)))
-> decltype( _VSTD::forward<_T1>(__t) / _VSTD::forward<_T2>(__u)) -> decltype( _VSTD::forward<_T1>(__t) / _VSTD::forward<_T2>(__u))
{ return _VSTD::forward<_T1>(__t) / _VSTD::forward<_T2>(__u); } { return _VSTD::forward<_T1>(__t) / _VSTD::forward<_T2>(__u); }
typedef void is_transparent; typedef void is_transparent;
}; };
#endif #endif
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER > 11
template <class _Tp = void> template <class _Tp = void>
#else #else
template <class _Tp> template <class _Tp>
#endif #endif
struct _LIBCPP_TEMPLATE_VIS modulus struct _LIBCPP_TEMPLATE_VIS modulus
: __binary_function<_Tp, _Tp, _Tp> : __binary_function<_Tp, _Tp, _Tp>
{ {
typedef _Tp __result_type; // used by valarray typedef _Tp __result_type; // used by valarray
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
_Tp operator()(const _Tp& __x, const _Tp& __y) const _Tp operator()(const _Tp& __x, const _Tp& __y) const
{return __x % __y;} {return __x % __y;}
}; };
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER > 11
template <> template <>
struct _LIBCPP_TEMPLATE_VIS modulus<void> struct _LIBCPP_TEMPLATE_VIS modulus<void>
{ {
template <class _T1, class _T2> template <class _T1, class _T2>
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
auto operator()(_T1&& __t, _T2&& __u) const auto operator()(_T1&& __t, _T2&& __u) const
noexcept(noexcept(_VSTD::forward<_T1>(__t) % _VSTD::forward<_T2>(__u))) noexcept(noexcept(_VSTD::forward<_T1>(__t) % _VSTD::forward<_T2>(__u)))
-> decltype( _VSTD::forward<_T1>(__t) % _VSTD::forward<_T2>(__u)) -> decltype( _VSTD::forward<_T1>(__t) % _VSTD::forward<_T2>(__u))
{ return _VSTD::forward<_T1>(__t) % _VSTD::forward<_T2>(__u); } { return _VSTD::forward<_T1>(__t) % _VSTD::forward<_T2>(__u); }
typedef void is_transparent; typedef void is_transparent;
}; };
#endif #endif
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER > 11
template <class _Tp = void> template <class _Tp = void>
#else #else
template <class _Tp> template <class _Tp>
#endif #endif
struct _LIBCPP_TEMPLATE_VIS negate struct _LIBCPP_TEMPLATE_VIS negate
: __unary_function<_Tp, _Tp> : __unary_function<_Tp, _Tp>
{ {
typedef _Tp __result_type; // used by valarray typedef _Tp __result_type; // used by valarray
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
_Tp operator()(const _Tp& __x) const _Tp operator()(const _Tp& __x) const
{return -__x;} {return -__x;}
}; };
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER > 11
template <> template <>
struct _LIBCPP_TEMPLATE_VIS negate<void> struct _LIBCPP_TEMPLATE_VIS negate<void>
{ {
template <class _Tp> template <class _Tp>
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
auto operator()(_Tp&& __x) const auto operator()(_Tp&& __x) const
noexcept(noexcept(- _VSTD::forward<_Tp>(__x))) noexcept(noexcept(- _VSTD::forward<_Tp>(__x)))
-> decltype( - _VSTD::forward<_Tp>(__x)) -> decltype( - _VSTD::forward<_Tp>(__x))
{ return - _VSTD::forward<_Tp>(__x); } { return - _VSTD::forward<_Tp>(__x); }
typedef void is_transparent; typedef void is_transparent;
}; };
#endif #endif
// Bitwise operations // Bitwise operations
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER > 11
template <class _Tp = void> template <class _Tp = void>
#else #else
template <class _Tp> template <class _Tp>
#endif #endif
struct _LIBCPP_TEMPLATE_VIS bit_and struct _LIBCPP_TEMPLATE_VIS bit_and
: __binary_function<_Tp, _Tp, _Tp> : __binary_function<_Tp, _Tp, _Tp>
{ {
typedef _Tp __result_type; // used by valarray typedef _Tp __result_type; // used by valarray
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
_Tp operator()(const _Tp& __x, const _Tp& __y) const _Tp operator()(const _Tp& __x, const _Tp& __y) const
{return __x & __y;} {return __x & __y;}
}; };
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER > 11
template <> template <>
struct _LIBCPP_TEMPLATE_VIS bit_and<void> struct _LIBCPP_TEMPLATE_VIS bit_and<void>
{ {
template <class _T1, class _T2> template <class _T1, class _T2>
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
auto operator()(_T1&& __t, _T2&& __u) const auto operator()(_T1&& __t, _T2&& __u) const
noexcept(noexcept(_VSTD::forward<_T1>(__t) & _VSTD::forward<_T2>(__u))) noexcept(noexcept(_VSTD::forward<_T1>(__t) & _VSTD::forward<_T2>(__u)))
-> decltype( _VSTD::forward<_T1>(__t) & _VSTD::forward<_T2>(__u)) -> decltype( _VSTD::forward<_T1>(__t) & _VSTD::forward<_T2>(__u))
{ return _VSTD::forward<_T1>(__t) & _VSTD::forward<_T2>(__u); } { return _VSTD::forward<_T1>(__t) & _VSTD::forward<_T2>(__u); }
typedef void is_transparent; typedef void is_transparent;
}; };
#endif #endif
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER > 11
template <class _Tp = void> template <class _Tp = void>
struct _LIBCPP_TEMPLATE_VIS bit_not struct _LIBCPP_TEMPLATE_VIS bit_not
: __unary_function<_Tp, _Tp> : __unary_function<_Tp, _Tp>
{ {
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
_Tp operator()(const _Tp& __x) const _Tp operator()(const _Tp& __x) const
{return ~__x;} {return ~__x;}
}; };
template <> template <>
struct _LIBCPP_TEMPLATE_VIS bit_not<void> struct _LIBCPP_TEMPLATE_VIS bit_not<void>
{ {
template <class _Tp> template <class _Tp>
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
auto operator()(_Tp&& __x) const auto operator()(_Tp&& __x) const
noexcept(noexcept(~_VSTD::forward<_Tp>(__x))) noexcept(noexcept(~_VSTD::forward<_Tp>(__x)))
-> decltype( ~_VSTD::forward<_Tp>(__x)) -> decltype( ~_VSTD::forward<_Tp>(__x))
{ return ~_VSTD::forward<_Tp>(__x); } { return ~_VSTD::forward<_Tp>(__x); }
typedef void is_transparent; typedef void is_transparent;
}; };
#endif #endif
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER > 11
template <class _Tp = void> template <class _Tp = void>
#else #else
template <class _Tp> template <class _Tp>
#endif #endif
struct _LIBCPP_TEMPLATE_VIS bit_or struct _LIBCPP_TEMPLATE_VIS bit_or
: __binary_function<_Tp, _Tp, _Tp> : __binary_function<_Tp, _Tp, _Tp>
{ {
typedef _Tp __result_type; // used by valarray typedef _Tp __result_type; // used by valarray
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
_Tp operator()(const _Tp& __x, const _Tp& __y) const _Tp operator()(const _Tp& __x, const _Tp& __y) const
{return __x | __y;} {return __x | __y;}
}; };
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER > 11
template <> template <>
struct _LIBCPP_TEMPLATE_VIS bit_or<void> struct _LIBCPP_TEMPLATE_VIS bit_or<void>
{ {
template <class _T1, class _T2> template <class _T1, class _T2>
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
auto operator()(_T1&& __t, _T2&& __u) const auto operator()(_T1&& __t, _T2&& __u) const
noexcept(noexcept(_VSTD::forward<_T1>(__t) | _VSTD::forward<_T2>(__u))) noexcept(noexcept(_VSTD::forward<_T1>(__t) | _VSTD::forward<_T2>(__u)))
-> decltype( _VSTD::forward<_T1>(__t) | _VSTD::forward<_T2>(__u)) -> decltype( _VSTD::forward<_T1>(__t) | _VSTD::forward<_T2>(__u))
{ return _VSTD::forward<_T1>(__t) | _VSTD::forward<_T2>(__u); } { return _VSTD::forward<_T1>(__t) | _VSTD::forward<_T2>(__u); }
typedef void is_transparent; typedef void is_transparent;
}; };
#endif #endif
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER > 11
template <class _Tp = void> template <class _Tp = void>
#else #else
template <class _Tp> template <class _Tp>
#endif #endif
struct _LIBCPP_TEMPLATE_VIS bit_xor struct _LIBCPP_TEMPLATE_VIS bit_xor
: __binary_function<_Tp, _Tp, _Tp> : __binary_function<_Tp, _Tp, _Tp>
{ {
typedef _Tp __result_type; // used by valarray typedef _Tp __result_type; // used by valarray
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
_Tp operator()(const _Tp& __x, const _Tp& __y) const _Tp operator()(const _Tp& __x, const _Tp& __y) const
{return __x ^ __y;} {return __x ^ __y;}
}; };
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER > 11
template <> template <>
struct _LIBCPP_TEMPLATE_VIS bit_xor<void> struct _LIBCPP_TEMPLATE_VIS bit_xor<void>
{ {
template <class _T1, class _T2> template <class _T1, class _T2>
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
auto operator()(_T1&& __t, _T2&& __u) const auto operator()(_T1&& __t, _T2&& __u) const
noexcept(noexcept(_VSTD::forward<_T1>(__t) ^ _VSTD::forward<_T2>(__u))) noexcept(noexcept(_VSTD::forward<_T1>(__t) ^ _VSTD::forward<_T2>(__u)))
-> decltype( _VSTD::forward<_T1>(__t) ^ _VSTD::forward<_T2>(__u)) -> decltype( _VSTD::forward<_T1>(__t) ^ _VSTD::forward<_T2>(__u))
{ return _VSTD::forward<_T1>(__t) ^ _VSTD::forward<_T2>(__u); } { return _VSTD::forward<_T1>(__t) ^ _VSTD::forward<_T2>(__u); }
typedef void is_transparent; typedef void is_transparent;
}; };
#endif #endif
// Comparison operations // Comparison operations
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER > 11
template <class _Tp = void> template <class _Tp = void>
#else #else
template <class _Tp> template <class _Tp>
#endif #endif
struct _LIBCPP_TEMPLATE_VIS equal_to struct _LIBCPP_TEMPLATE_VIS equal_to
: __binary_function<_Tp, _Tp, bool> : __binary_function<_Tp, _Tp, bool>
{ {
typedef bool __result_type; // used by valarray typedef bool __result_type; // used by valarray
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
bool operator()(const _Tp& __x, const _Tp& __y) const bool operator()(const _Tp& __x, const _Tp& __y) const
{return __x == __y;} {return __x == __y;}
}; };
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER > 11
template <> template <>
struct _LIBCPP_TEMPLATE_VIS equal_to<void> struct _LIBCPP_TEMPLATE_VIS equal_to<void>
{ {
template <class _T1, class _T2> template <class _T1, class _T2>
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
auto operator()(_T1&& __t, _T2&& __u) const auto operator()(_T1&& __t, _T2&& __u) const
noexcept(noexcept(_VSTD::forward<_T1>(__t) == _VSTD::forward<_T2>(__u))) noexcept(noexcept(_VSTD::forward<_T1>(__t) == _VSTD::forward<_T2>(__u)))
-> decltype( _VSTD::forward<_T1>(__t) == _VSTD::forward<_T2>(__u)) -> decltype( _VSTD::forward<_T1>(__t) == _VSTD::forward<_T2>(__u))
{ return _VSTD::forward<_T1>(__t) == _VSTD::forward<_T2>(__u); } { return _VSTD::forward<_T1>(__t) == _VSTD::forward<_T2>(__u); }
typedef void is_transparent; typedef void is_transparent;
}; };
#endif #endif
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER > 11
template <class _Tp = void> template <class _Tp = void>
#else #else
template <class _Tp> template <class _Tp>
#endif #endif
struct _LIBCPP_TEMPLATE_VIS not_equal_to struct _LIBCPP_TEMPLATE_VIS not_equal_to
: __binary_function<_Tp, _Tp, bool> : __binary_function<_Tp, _Tp, bool>
{ {
typedef bool __result_type; // used by valarray typedef bool __result_type; // used by valarray
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
bool operator()(const _Tp& __x, const _Tp& __y) const bool operator()(const _Tp& __x, const _Tp& __y) const
{return __x != __y;} {return __x != __y;}
}; };
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER > 11
template <> template <>
struct _LIBCPP_TEMPLATE_VIS not_equal_to<void> struct _LIBCPP_TEMPLATE_VIS not_equal_to<void>
{ {
template <class _T1, class _T2> template <class _T1, class _T2>
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
auto operator()(_T1&& __t, _T2&& __u) const auto operator()(_T1&& __t, _T2&& __u) const
noexcept(noexcept(_VSTD::forward<_T1>(__t) != _VSTD::forward<_T2>(__u))) noexcept(noexcept(_VSTD::forward<_T1>(__t) != _VSTD::forward<_T2>(__u)))
-> decltype( _VSTD::forward<_T1>(__t) != _VSTD::forward<_T2>(__u)) -> decltype( _VSTD::forward<_T1>(__t) != _VSTD::forward<_T2>(__u))
{ return _VSTD::forward<_T1>(__t) != _VSTD::forward<_T2>(__u); } { return _VSTD::forward<_T1>(__t) != _VSTD::forward<_T2>(__u); }
typedef void is_transparent; typedef void is_transparent;
}; };
#endif #endif
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER > 11
template <class _Tp = void> template <class _Tp = void>
#else #else
template <class _Tp> template <class _Tp>
#endif #endif
struct _LIBCPP_TEMPLATE_VIS less struct _LIBCPP_TEMPLATE_VIS less
: __binary_function<_Tp, _Tp, bool> : __binary_function<_Tp, _Tp, bool>
{ {
typedef bool __result_type; // used by valarray typedef bool __result_type; // used by valarray
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
bool operator()(const _Tp& __x, const _Tp& __y) const bool operator()(const _Tp& __x, const _Tp& __y) const
{return __x < __y;} {return __x < __y;}
}; };
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER > 11
template <> template <>
struct _LIBCPP_TEMPLATE_VIS less<void> struct _LIBCPP_TEMPLATE_VIS less<void>
{ {
template <class _T1, class _T2> template <class _T1, class _T2>
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
auto operator()(_T1&& __t, _T2&& __u) const auto operator()(_T1&& __t, _T2&& __u) const
noexcept(noexcept(_VSTD::forward<_T1>(__t) < _VSTD::forward<_T2>(__u))) noexcept(noexcept(_VSTD::forward<_T1>(__t) < _VSTD::forward<_T2>(__u)))
-> decltype( _VSTD::forward<_T1>(__t) < _VSTD::forward<_T2>(__u)) -> decltype( _VSTD::forward<_T1>(__t) < _VSTD::forward<_T2>(__u))
{ return _VSTD::forward<_T1>(__t) < _VSTD::forward<_T2>(__u); } { return _VSTD::forward<_T1>(__t) < _VSTD::forward<_T2>(__u); }
typedef void is_transparent; typedef void is_transparent;
}; };
#endif #endif
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER > 11
template <class _Tp = void> template <class _Tp = void>
#else #else
template <class _Tp> template <class _Tp>
#endif #endif
struct _LIBCPP_TEMPLATE_VIS less_equal struct _LIBCPP_TEMPLATE_VIS less_equal
: __binary_function<_Tp, _Tp, bool> : __binary_function<_Tp, _Tp, bool>
{ {
typedef bool __result_type; // used by valarray typedef bool __result_type; // used by valarray
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
bool operator()(const _Tp& __x, const _Tp& __y) const bool operator()(const _Tp& __x, const _Tp& __y) const
{return __x <= __y;} {return __x <= __y;}
}; };
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER > 11
template <> template <>
struct _LIBCPP_TEMPLATE_VIS less_equal<void> struct _LIBCPP_TEMPLATE_VIS less_equal<void>
{ {
template <class _T1, class _T2> template <class _T1, class _T2>
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
auto operator()(_T1&& __t, _T2&& __u) const auto operator()(_T1&& __t, _T2&& __u) const
noexcept(noexcept(_VSTD::forward<_T1>(__t) <= _VSTD::forward<_T2>(__u))) noexcept(noexcept(_VSTD::forward<_T1>(__t) <= _VSTD::forward<_T2>(__u)))
-> decltype( _VSTD::forward<_T1>(__t) <= _VSTD::forward<_T2>(__u)) -> decltype( _VSTD::forward<_T1>(__t) <= _VSTD::forward<_T2>(__u))
{ return _VSTD::forward<_T1>(__t) <= _VSTD::forward<_T2>(__u); } { return _VSTD::forward<_T1>(__t) <= _VSTD::forward<_T2>(__u); }
typedef void is_transparent; typedef void is_transparent;
}; };
#endif #endif
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER > 11
template <class _Tp = void> template <class _Tp = void>
#else #else
template <class _Tp> template <class _Tp>
#endif #endif
struct _LIBCPP_TEMPLATE_VIS greater_equal struct _LIBCPP_TEMPLATE_VIS greater_equal
: __binary_function<_Tp, _Tp, bool> : __binary_function<_Tp, _Tp, bool>
{ {
typedef bool __result_type; // used by valarray typedef bool __result_type; // used by valarray
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
bool operator()(const _Tp& __x, const _Tp& __y) const bool operator()(const _Tp& __x, const _Tp& __y) const
{return __x >= __y;} {return __x >= __y;}
}; };
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER > 11
template <> template <>
struct _LIBCPP_TEMPLATE_VIS greater_equal<void> struct _LIBCPP_TEMPLATE_VIS greater_equal<void>
{ {
template <class _T1, class _T2> template <class _T1, class _T2>
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
auto operator()(_T1&& __t, _T2&& __u) const auto operator()(_T1&& __t, _T2&& __u) const
noexcept(noexcept(_VSTD::forward<_T1>(__t) >= _VSTD::forward<_T2>(__u))) noexcept(noexcept(_VSTD::forward<_T1>(__t) >= _VSTD::forward<_T2>(__u)))
-> decltype( _VSTD::forward<_T1>(__t) >= _VSTD::forward<_T2>(__u)) -> decltype( _VSTD::forward<_T1>(__t) >= _VSTD::forward<_T2>(__u))
{ return _VSTD::forward<_T1>(__t) >= _VSTD::forward<_T2>(__u); } { return _VSTD::forward<_T1>(__t) >= _VSTD::forward<_T2>(__u); }
typedef void is_transparent; typedef void is_transparent;
}; };
#endif #endif
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER > 11
template <class _Tp = void> template <class _Tp = void>
#else #else
template <class _Tp> template <class _Tp>
#endif #endif
struct _LIBCPP_TEMPLATE_VIS greater struct _LIBCPP_TEMPLATE_VIS greater
: __binary_function<_Tp, _Tp, bool> : __binary_function<_Tp, _Tp, bool>
{ {
typedef bool __result_type; // used by valarray typedef bool __result_type; // used by valarray
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
bool operator()(const _Tp& __x, const _Tp& __y) const bool operator()(const _Tp& __x, const _Tp& __y) const
{return __x > __y;} {return __x > __y;}
}; };
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER > 11
template <> template <>
struct _LIBCPP_TEMPLATE_VIS greater<void> struct _LIBCPP_TEMPLATE_VIS greater<void>
{ {
template <class _T1, class _T2> template <class _T1, class _T2>
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
auto operator()(_T1&& __t, _T2&& __u) const auto operator()(_T1&& __t, _T2&& __u) const
noexcept(noexcept(_VSTD::forward<_T1>(__t) > _VSTD::forward<_T2>(__u))) noexcept(noexcept(_VSTD::forward<_T1>(__t) > _VSTD::forward<_T2>(__u)))
-> decltype( _VSTD::forward<_T1>(__t) > _VSTD::forward<_T2>(__u)) -> decltype( _VSTD::forward<_T1>(__t) > _VSTD::forward<_T2>(__u))
{ return _VSTD::forward<_T1>(__t) > _VSTD::forward<_T2>(__u); } { return _VSTD::forward<_T1>(__t) > _VSTD::forward<_T2>(__u); }
typedef void is_transparent; typedef void is_transparent;
}; };
#endif #endif
// Logical operations // Logical operations
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER > 11
template <class _Tp = void> template <class _Tp = void>
#else #else
template <class _Tp> template <class _Tp>
#endif #endif
struct _LIBCPP_TEMPLATE_VIS logical_and struct _LIBCPP_TEMPLATE_VIS logical_and
: __binary_function<_Tp, _Tp, bool> : __binary_function<_Tp, _Tp, bool>
{ {
typedef bool __result_type; // used by valarray typedef bool __result_type; // used by valarray
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
bool operator()(const _Tp& __x, const _Tp& __y) const bool operator()(const _Tp& __x, const _Tp& __y) const
{return __x && __y;} {return __x && __y;}
}; };
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER > 11
template <> template <>
struct _LIBCPP_TEMPLATE_VIS logical_and<void> struct _LIBCPP_TEMPLATE_VIS logical_and<void>
{ {
template <class _T1, class _T2> template <class _T1, class _T2>
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
auto operator()(_T1&& __t, _T2&& __u) const auto operator()(_T1&& __t, _T2&& __u) const
noexcept(noexcept(_VSTD::forward<_T1>(__t) && _VSTD::forward<_T2>(__u))) noexcept(noexcept(_VSTD::forward<_T1>(__t) && _VSTD::forward<_T2>(__u)))
-> decltype( _VSTD::forward<_T1>(__t) && _VSTD::forward<_T2>(__u)) -> decltype( _VSTD::forward<_T1>(__t) && _VSTD::forward<_T2>(__u))
{ return _VSTD::forward<_T1>(__t) && _VSTD::forward<_T2>(__u); } { return _VSTD::forward<_T1>(__t) && _VSTD::forward<_T2>(__u); }
typedef void is_transparent; typedef void is_transparent;
}; };
#endif #endif
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER > 11
template <class _Tp = void> template <class _Tp = void>
#else #else
template <class _Tp> template <class _Tp>
#endif #endif
struct _LIBCPP_TEMPLATE_VIS logical_not struct _LIBCPP_TEMPLATE_VIS logical_not
: __unary_function<_Tp, bool> : __unary_function<_Tp, bool>
{ {
typedef bool __result_type; // used by valarray typedef bool __result_type; // used by valarray
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
bool operator()(const _Tp& __x) const bool operator()(const _Tp& __x) const
{return !__x;} {return !__x;}
}; };
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER > 11
template <> template <>
struct _LIBCPP_TEMPLATE_VIS logical_not<void> struct _LIBCPP_TEMPLATE_VIS logical_not<void>
{ {
template <class _Tp> template <class _Tp>
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
auto operator()(_Tp&& __x) const auto operator()(_Tp&& __x) const
noexcept(noexcept(!_VSTD::forward<_Tp>(__x))) noexcept(noexcept(!_VSTD::forward<_Tp>(__x)))
-> decltype( !_VSTD::forward<_Tp>(__x)) -> decltype( !_VSTD::forward<_Tp>(__x))
{ return !_VSTD::forward<_Tp>(__x); } { return !_VSTD::forward<_Tp>(__x); }
typedef void is_transparent; typedef void is_transparent;
}; };
#endif #endif
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER > 11
template <class _Tp = void> template <class _Tp = void>
#else #else
template <class _Tp> template <class _Tp>
#endif #endif
struct _LIBCPP_TEMPLATE_VIS logical_or struct _LIBCPP_TEMPLATE_VIS logical_or
: __binary_function<_Tp, _Tp, bool> : __binary_function<_Tp, _Tp, bool>
{ {
typedef bool __result_type; // used by valarray typedef bool __result_type; // used by valarray
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
bool operator()(const _Tp& __x, const _Tp& __y) const bool operator()(const _Tp& __x, const _Tp& __y) const
{return __x || __y;} {return __x || __y;}
}; };
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER > 11
template <> template <>
struct _LIBCPP_TEMPLATE_VIS logical_or<void> struct _LIBCPP_TEMPLATE_VIS logical_or<void>
{ {
template <class _T1, class _T2> template <class _T1, class _T2>
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
auto operator()(_T1&& __t, _T2&& __u) const auto operator()(_T1&& __t, _T2&& __u) const
noexcept(noexcept(_VSTD::forward<_T1>(__t) || _VSTD::forward<_T2>(__u))) noexcept(noexcept(_VSTD::forward<_T1>(__t) || _VSTD::forward<_T2>(__u)))
-> decltype( _VSTD::forward<_T1>(__t) || _VSTD::forward<_T2>(__u)) -> decltype( _VSTD::forward<_T1>(__t) || _VSTD::forward<_T2>(__u))
{ return _VSTD::forward<_T1>(__t) || _VSTD::forward<_T2>(__u); } { return _VSTD::forward<_T1>(__t) || _VSTD::forward<_T2>(__u); }
typedef void is_transparent; typedef void is_transparent;
}; };
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___FUNCTIONAL_OPERATIONS_H #endif // _LIBCPP___FUNCTIONAL_OPERATIONS_H

libcxx/include/__functional/reference_wrapper.h

Show All 30 Lines
private: private:
type* __f_; type* __f_;
static void __fun(_Tp&) _NOEXCEPT; static void __fun(_Tp&) _NOEXCEPT;
static void __fun(_Tp&&) = delete; static void __fun(_Tp&&) = delete;
public: public:
template <class _Up, class = __enable_if_t<!__is_same_uncvref<_Up, reference_wrapper>::value, decltype(__fun(declval<_Up>())) > > template <class _Up, class = __enable_if_t<!__is_same_uncvref<_Up, reference_wrapper>::value, decltype(__fun(declval<_Up>())) > >
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
reference_wrapper(_Up&& __u) _NOEXCEPT_(noexcept(__fun(declval<_Up>()))) { reference_wrapper(_Up&& __u) _NOEXCEPT_(noexcept(__fun(declval<_Up>()))) {
type& __f = static_cast<_Up&&>(__u); type& __f = static_cast<_Up&&>(__u);
__f_ = _VSTD::addressof(__f); __f_ = _VSTD::addressof(__f);
} }
// access // access
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
operator type&() const _NOEXCEPT {return *__f_;} operator type&() const _NOEXCEPT {return *__f_;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
type& get() const _NOEXCEPT {return *__f_;} type& get() const _NOEXCEPT {return *__f_;}
// invoke // invoke
template <class... _ArgTypes> template <class... _ArgTypes>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
typename __invoke_of<type&, _ArgTypes...>::type typename __invoke_of<type&, _ArgTypes...>::type
operator() (_ArgTypes&&... __args) const { operator() (_ArgTypes&&... __args) const {
return std::__invoke(get(), std::forward<_ArgTypes>(__args)...); return std::__invoke(get(), std::forward<_ArgTypes>(__args)...);
} }
}; };
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER > 14
template <class _Tp> template <class _Tp>
reference_wrapper(_Tp&) -> reference_wrapper<_Tp>; reference_wrapper(_Tp&) -> reference_wrapper<_Tp>;
#endif #endif
template <class _Tp> template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
reference_wrapper<_Tp> reference_wrapper<_Tp>
ref(_Tp& __t) _NOEXCEPT ref(_Tp& __t) _NOEXCEPT
{ {
return reference_wrapper<_Tp>(__t); return reference_wrapper<_Tp>(__t);
} }
template <class _Tp> template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
reference_wrapper<_Tp> reference_wrapper<_Tp>
ref(reference_wrapper<_Tp> __t) _NOEXCEPT ref(reference_wrapper<_Tp> __t) _NOEXCEPT
{ {
return __t; return __t;
} }
template <class _Tp> template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
reference_wrapper<const _Tp> reference_wrapper<const _Tp>
cref(const _Tp& __t) _NOEXCEPT cref(const _Tp& __t) _NOEXCEPT
{ {
return reference_wrapper<const _Tp>(__t); return reference_wrapper<const _Tp>(__t);
} }
template <class _Tp> template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
reference_wrapper<const _Tp> reference_wrapper<const _Tp>
cref(reference_wrapper<_Tp> __t) _NOEXCEPT cref(reference_wrapper<_Tp> __t) _NOEXCEPT
{ {
return __t; return __t;
} }
template <class _Tp> void ref(const _Tp&&) = delete; template <class _Tp> void ref(const _Tp&&) = delete;
template <class _Tp> void cref(const _Tp&&) = delete; template <class _Tp> void cref(const _Tp&&) = delete;
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___FUNCTIONAL_REFERENCE_WRAPPER_H #endif // _LIBCPP___FUNCTIONAL_REFERENCE_WRAPPER_H

libcxx/include/__functional/unary_negate.h

Show All 21 Lines
#if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_NEGATORS) #if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_NEGATORS)
template <class _Predicate> template <class _Predicate>
class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX17 unary_negate class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX17 unary_negate
: public __unary_function<typename _Predicate::argument_type, bool> : public __unary_function<typename _Predicate::argument_type, bool>
{ {
_Predicate __pred_; _Predicate __pred_;
public: public:
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
explicit unary_negate(const _Predicate& __pred) explicit unary_negate(const _Predicate& __pred)
: __pred_(__pred) {} : __pred_(__pred) {}
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
bool operator()(const typename _Predicate::argument_type& __x) const bool operator()(const typename _Predicate::argument_type& __x) const
{return !__pred_(__x);} {return !__pred_(__x);}
}; };
template <class _Predicate> template <class _Predicate>
_LIBCPP_DEPRECATED_IN_CXX17 inline _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_DEPRECATED_IN_CXX17 inline _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
unary_negate<_Predicate> unary_negate<_Predicate>
not1(const _Predicate& __pred) {return unary_negate<_Predicate>(__pred);} not1(const _Predicate& __pred) {return unary_negate<_Predicate>(__pred);}
#endif // _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_NEGATORS) #endif // _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_NEGATORS)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___FUNCTIONAL_UNARY_NEGATE_H #endif // _LIBCPP___FUNCTIONAL_UNARY_NEGATE_H

libcxx/include/__hash_table

Show First 20 Lines • Show All 2,273 Lines • ▼ Show 20 Lines if (__nbc > 0)
{ {
__bucket_list_[__chash] = __pp; __bucket_list_[__chash] = __pp;
__pp = __cp; __pp = __cp;
__phash = __chash; __phash = __chash;
} }
else else
{ {
__next_pointer __np = __cp; __next_pointer __np = __cp;
if _LIBCPP_CONSTEXPR_AFTER_CXX14 (!_UniqueKeys) if _LIBCPP_CONSTEXPR_CXX17 (!_UniqueKeys)
{ {
for (; __np->__next_ != nullptr && for (; __np->__next_ != nullptr &&
key_eq()(__cp->__upcast()->__value_, key_eq()(__cp->__upcast()->__value_,
__np->__next_->__upcast()->__value_); __np->__next_->__upcast()->__value_);
__np = __np->__next_) __np = __np->__next_)
; ;
} }
__pp->__next_ = __np->__next_; __pp->__next_ = __np->__next_;
▲ Show 20 Lines • Show All 420 Lines • Show Last 20 Lines

libcxx/include/__iterator/access.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, size_t _Np> template <class _Tp, size_t _Np>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
_Tp* _Tp*
begin(_Tp (&__array)[_Np]) begin(_Tp (&__array)[_Np])
{ {
return __array; return __array;
} }
template <class _Tp, size_t _Np> template <class _Tp, size_t _Np>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
_Tp* _Tp*
end(_Tp (&__array)[_Np]) end(_Tp (&__array)[_Np])
{ {
return __array + _Np; return __array + _Np;
} }
#if !defined(_LIBCPP_CXX03_LANG) #if !defined(_LIBCPP_CXX03_LANG)
template <class _Cp> template <class _Cp>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
auto auto
begin(_Cp& __c) -> decltype(__c.begin()) begin(_Cp& __c) -> decltype(__c.begin())
{ {
return __c.begin(); return __c.begin();
} }
template <class _Cp> template <class _Cp>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
auto auto
begin(const _Cp& __c) -> decltype(__c.begin()) begin(const _Cp& __c) -> decltype(__c.begin())
{ {
return __c.begin(); return __c.begin();
} }
template <class _Cp> template <class _Cp>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
auto auto
end(_Cp& __c) -> decltype(__c.end()) end(_Cp& __c) -> decltype(__c.end())
{ {
return __c.end(); return __c.end();
} }
template <class _Cp> template <class _Cp>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
auto auto
end(const _Cp& __c) -> decltype(__c.end()) end(const _Cp& __c) -> decltype(__c.end())
{ {
return __c.end(); return __c.end();
} }
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER > 11
template <class _Cp> template <class _Cp>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
auto cbegin(const _Cp& __c) -> decltype(_VSTD::begin(__c)) auto cbegin(const _Cp& __c) -> decltype(_VSTD::begin(__c))
{ {
return _VSTD::begin(__c); return _VSTD::begin(__c);
} }
template <class _Cp> template <class _Cp>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
auto cend(const _Cp& __c) -> decltype(_VSTD::end(__c)) auto cend(const _Cp& __c) -> decltype(_VSTD::end(__c))
{ {
return _VSTD::end(__c); return _VSTD::end(__c);
} }
#endif #endif
Show All 39 Lines

libcxx/include/__iterator/advance.h

Show All 23 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 _InputIter> template <class _InputIter>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX17
void __advance(_InputIter& __i, typename iterator_traits<_InputIter>::difference_type __n, input_iterator_tag) { void __advance(_InputIter& __i, typename iterator_traits<_InputIter>::difference_type __n, input_iterator_tag) {
for (; __n > 0; --__n) for (; __n > 0; --__n)
++__i; ++__i;
} }
template <class _BiDirIter> template <class _BiDirIter>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX17
void __advance(_BiDirIter& __i, typename iterator_traits<_BiDirIter>::difference_type __n, bidirectional_iterator_tag) { void __advance(_BiDirIter& __i, typename iterator_traits<_BiDirIter>::difference_type __n, bidirectional_iterator_tag) {
if (__n >= 0) if (__n >= 0)
for (; __n > 0; --__n) for (; __n > 0; --__n)
++__i; ++__i;
else else
for (; __n < 0; ++__n) for (; __n < 0; ++__n)
--__i; --__i;
} }
template <class _RandIter> template <class _RandIter>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX17
void __advance(_RandIter& __i, typename iterator_traits<_RandIter>::difference_type __n, random_access_iterator_tag) { void __advance(_RandIter& __i, typename iterator_traits<_RandIter>::difference_type __n, random_access_iterator_tag) {
__i += __n; __i += __n;
} }
template < template <
class _InputIter, class _Distance, class _InputIter, class _Distance,
class _IntegralDistance = decltype(_VSTD::__convert_to_integral(declval<_Distance>())), class _IntegralDistance = decltype(_VSTD::__convert_to_integral(declval<_Distance>())),
class = __enable_if_t<is_integral<_IntegralDistance>::value> > class = __enable_if_t<is_integral<_IntegralDistance>::value> >
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX17
void advance(_InputIter& __i, _Distance __orig_n) { void advance(_InputIter& __i, _Distance __orig_n) {
typedef typename iterator_traits<_InputIter>::difference_type _Difference; typedef typename iterator_traits<_InputIter>::difference_type _Difference;
_Difference __n = static_cast<_Difference>(_VSTD::__convert_to_integral(__orig_n)); _Difference __n = static_cast<_Difference>(_VSTD::__convert_to_integral(__orig_n));
_LIBCPP_ASSERT(__n >= 0 || __is_cpp17_bidirectional_iterator<_InputIter>::value, _LIBCPP_ASSERT(__n >= 0 || __is_cpp17_bidirectional_iterator<_InputIter>::value,
"Attempt to advance(it, n) with negative n on a non-bidirectional iterator"); "Attempt to advance(it, n) with negative n on a non-bidirectional iterator");
_VSTD::__advance(__i, __n, typename iterator_traits<_InputIter>::iterator_category()); _VSTD::__advance(__i, __n, typename iterator_traits<_InputIter>::iterator_category());
} }
▲ Show 20 Lines • Show All 132 Lines • Show Last 20 Lines

libcxx/include/__iterator/back_insert_iterator.h

Show All 39 Lines#if _LIBCPP_STD_VER > 17
typedef ptrdiff_t difference_type; typedef ptrdiff_t difference_type;
#else #else
typedef void difference_type; typedef void difference_type;
#endif #endif
typedef void pointer; typedef void pointer;
typedef void reference; typedef void reference;
typedef _Container container_type; typedef _Container container_type;
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 explicit back_insert_iterator(_Container& __x) : container(_VSTD::addressof(__x)) {} _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20 explicit back_insert_iterator(_Container& __x) : container(_VSTD::addressof(__x)) {}
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 back_insert_iterator& operator=(const typename _Container::value_type& __value) _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20 back_insert_iterator& operator=(const typename _Container::value_type& __value)
{container->push_back(__value); return *this;} {container->push_back(__value); return *this;}
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 back_insert_iterator& operator=(typename _Container::value_type&& __value) _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20 back_insert_iterator& operator=(typename _Container::value_type&& __value)
{container->push_back(_VSTD::move(__value)); return *this;} {container->push_back(_VSTD::move(__value)); return *this;}
#endif // _LIBCPP_CXX03_LANG #endif // _LIBCPP_CXX03_LANG
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 back_insert_iterator& operator*() {return *this;} _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20 back_insert_iterator& operator*() {return *this;}
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 back_insert_iterator& operator++() {return *this;} _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20 back_insert_iterator& operator++() {return *this;}
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 back_insert_iterator operator++(int) {return *this;} _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20 back_insert_iterator operator++(int) {return *this;}
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _Container* __get_container() const { return container; } _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20 _Container* __get_container() const { return container; }
}; };
template <class _Container> template <class _Container>
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
back_insert_iterator<_Container> back_insert_iterator<_Container>
back_inserter(_Container& __x) back_inserter(_Container& __x)
{ {
return back_insert_iterator<_Container>(__x); return back_insert_iterator<_Container>(__x);
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ITERATOR_BACK_INSERT_ITERATOR_H #endif // _LIBCPP___ITERATOR_BACK_INSERT_ITERATOR_H

libcxx/include/__iterator/bounded_iter.h

Show First 20 Lines • Show All 67 Lines • ▼ Show 20 Linesprivate:
// by the provided [begin, end) range. // by the provided [begin, end) range.
// //
// This constructor does not check whether the resulting iterator is within its bounds. // This constructor does not check whether the resulting iterator is within its bounds.
// However, it does check that the provided [begin, end) range is a valid range (that // However, it does check that the provided [begin, end) range is a valid range (that
// is, begin <= end). // is, begin <= end).
// //
// Since it is non-standard for iterators to have this constructor, __bounded_iter must // Since it is non-standard for iterators to have this constructor, __bounded_iter must
// be created via `std::__make_bounded_iter`. // be created via `std::__make_bounded_iter`.
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 explicit __bounded_iter( _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14 explicit __bounded_iter(
_Iterator __current, _Iterator __begin, _Iterator __end) _Iterator __current, _Iterator __begin, _Iterator __end)
: __current_(__current), __begin_(__begin), __end_(__end) { : __current_(__current), __begin_(__begin), __end_(__end) {
_LIBCPP_ASSERT(__begin <= __end, "__bounded_iter(current, begin, end): [begin, end) is not a valid range"); _LIBCPP_ASSERT(__begin <= __end, "__bounded_iter(current, begin, end): [begin, end) is not a valid range");
} }
template <class _It> template <class _It>
friend _LIBCPP_CONSTEXPR __bounded_iter<_It> __make_bounded_iter(_It, _It, _It); friend _LIBCPP_CONSTEXPR __bounded_iter<_It> __make_bounded_iter(_It, _It, _It);
public: public:
// Dereference and indexing operations. // Dereference and indexing operations.
// //
// These operations check that the iterator is dereferenceable, that is within [begin, end). // These operations check that the iterator is dereferenceable, that is within [begin, end).
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 reference operator*() const _NOEXCEPT { _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14 reference operator*() const _NOEXCEPT {
_LIBCPP_ASSERT( _LIBCPP_ASSERT(
__in_bounds(__current_), "__bounded_iter::operator*: Attempt to dereference an out-of-range iterator"); __in_bounds(__current_), "__bounded_iter::operator*: Attempt to dereference an out-of-range iterator");
return *__current_; return *__current_;
} }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 pointer operator->() const _NOEXCEPT { _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14 pointer operator->() const _NOEXCEPT {
_LIBCPP_ASSERT( _LIBCPP_ASSERT(
__in_bounds(__current_), "__bounded_iter::operator->: Attempt to dereference an out-of-range iterator"); __in_bounds(__current_), "__bounded_iter::operator->: Attempt to dereference an out-of-range iterator");
return std::__to_address(__current_); return std::__to_address(__current_);
} }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 reference operator[](difference_type __n) const _NOEXCEPT { _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14 reference operator[](difference_type __n) const _NOEXCEPT {
_LIBCPP_ASSERT( _LIBCPP_ASSERT(
__in_bounds(__current_ + __n), "__bounded_iter::operator[]: Attempt to index an iterator out-of-range"); __in_bounds(__current_ + __n), "__bounded_iter::operator[]: Attempt to index an iterator out-of-range");
return __current_[__n]; return __current_[__n];
} }
// Arithmetic operations. // Arithmetic operations.
// //
// These operations do not check that the resulting iterator is within the bounds, since that // These operations do not check that the resulting iterator is within the bounds, since that
// would make it impossible to create a past-the-end iterator. // would make it impossible to create a past-the-end iterator.
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 __bounded_iter& operator++() _NOEXCEPT { _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14 __bounded_iter& operator++() _NOEXCEPT {
++__current_; ++__current_;
return *this; return *this;
} }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 __bounded_iter operator++(int) _NOEXCEPT { _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14 __bounded_iter operator++(int) _NOEXCEPT {
__bounded_iter __tmp(*this); __bounded_iter __tmp(*this);
++*this; ++*this;
return __tmp; return __tmp;
} }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 __bounded_iter& operator--() _NOEXCEPT { _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14 __bounded_iter& operator--() _NOEXCEPT {
--__current_; --__current_;
return *this; return *this;
} }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 __bounded_iter operator--(int) _NOEXCEPT { _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14 __bounded_iter operator--(int) _NOEXCEPT {
__bounded_iter __tmp(*this); __bounded_iter __tmp(*this);
--*this; --*this;
return __tmp; return __tmp;
} }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 __bounded_iter& operator+=(difference_type __n) _NOEXCEPT { _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14 __bounded_iter& operator+=(difference_type __n) _NOEXCEPT {
__current_ += __n; __current_ += __n;
return *this; return *this;
} }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 friend __bounded_iter _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14 friend __bounded_iter
operator+(__bounded_iter const& __self, difference_type __n) _NOEXCEPT { operator+(__bounded_iter const& __self, difference_type __n) _NOEXCEPT {
__bounded_iter __tmp(__self); __bounded_iter __tmp(__self);
__tmp += __n; __tmp += __n;
return __tmp; return __tmp;
} }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 friend __bounded_iter _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14 friend __bounded_iter
operator+(difference_type __n, __bounded_iter const& __self) _NOEXCEPT { operator+(difference_type __n, __bounded_iter const& __self) _NOEXCEPT {
__bounded_iter __tmp(__self); __bounded_iter __tmp(__self);
__tmp += __n; __tmp += __n;
return __tmp; return __tmp;
} }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 __bounded_iter& operator-=(difference_type __n) _NOEXCEPT { _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14 __bounded_iter& operator-=(difference_type __n) _NOEXCEPT {
__current_ -= __n; __current_ -= __n;
return *this; return *this;
} }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 friend __bounded_iter _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14 friend __bounded_iter
operator-(__bounded_iter const& __self, difference_type __n) _NOEXCEPT { operator-(__bounded_iter const& __self, difference_type __n) _NOEXCEPT {
__bounded_iter __tmp(__self); __bounded_iter __tmp(__self);
__tmp -= __n; __tmp -= __n;
return __tmp; return __tmp;
} }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 friend difference_type _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14 friend difference_type
operator-(__bounded_iter const& __x, __bounded_iter const& __y) _NOEXCEPT { operator-(__bounded_iter const& __x, __bounded_iter const& __y) _NOEXCEPT {
return __x.__current_ - __y.__current_; return __x.__current_ - __y.__current_;
} }
// Comparison operations. // Comparison operations.
// //
// These operations do not check whether the iterators are within their bounds. // These operations do not check whether the iterators are within their bounds.
// The valid range for each iterator is also not considered as part of the comparison, // The valid range for each iterator is also not considered as part of the comparison,
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines

libcxx/include/__iterator/distance.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
template <class _InputIter> template <class _InputIter>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
typename iterator_traits<_InputIter>::difference_type typename iterator_traits<_InputIter>::difference_type
__distance(_InputIter __first, _InputIter __last, input_iterator_tag) __distance(_InputIter __first, _InputIter __last, input_iterator_tag)
{ {
typename iterator_traits<_InputIter>::difference_type __r(0); typename iterator_traits<_InputIter>::difference_type __r(0);
for (; __first != __last; ++__first) for (; __first != __last; ++__first)
++__r; ++__r;
return __r; return __r;
} }
template <class _RandIter> template <class _RandIter>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
typename iterator_traits<_RandIter>::difference_type typename iterator_traits<_RandIter>::difference_type
__distance(_RandIter __first, _RandIter __last, random_access_iterator_tag) __distance(_RandIter __first, _RandIter __last, random_access_iterator_tag)
{ {
return __last - __first; return __last - __first;
} }
template <class _InputIter> template <class _InputIter>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
typename iterator_traits<_InputIter>::difference_type typename iterator_traits<_InputIter>::difference_type
distance(_InputIter __first, _InputIter __last) distance(_InputIter __first, _InputIter __last)
{ {
return _VSTD::__distance(__first, __last, typename iterator_traits<_InputIter>::iterator_category()); return _VSTD::__distance(__first, __last, typename iterator_traits<_InputIter>::iterator_category());
} }
#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES) #if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

libcxx/include/__iterator/front_insert_iterator.h

Show All 39 Lines#if _LIBCPP_STD_VER > 17
typedef ptrdiff_t difference_type; typedef ptrdiff_t difference_type;
#else #else
typedef void difference_type; typedef void difference_type;
#endif #endif
typedef void pointer; typedef void pointer;
typedef void reference; typedef void reference;
typedef _Container container_type; typedef _Container container_type;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 explicit front_insert_iterator(_Container& __x) : container(_VSTD::addressof(__x)) {} _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 explicit front_insert_iterator(_Container& __x) : container(_VSTD::addressof(__x)) {}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 front_insert_iterator& operator=(const typename _Container::value_type& __value) _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 front_insert_iterator& operator=(const typename _Container::value_type& __value)
{container->push_front(__value); return *this;} {container->push_front(__value); return *this;}
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 front_insert_iterator& operator=(typename _Container::value_type&& __value) _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 front_insert_iterator& operator=(typename _Container::value_type&& __value)
{container->push_front(_VSTD::move(__value)); return *this;} {container->push_front(_VSTD::move(__value)); return *this;}
#endif // _LIBCPP_CXX03_LANG #endif // _LIBCPP_CXX03_LANG
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 front_insert_iterator& operator*() {return *this;} _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 front_insert_iterator& operator*() {return *this;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 front_insert_iterator& operator++() {return *this;} _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 front_insert_iterator& operator++() {return *this;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 front_insert_iterator operator++(int) {return *this;} _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 front_insert_iterator operator++(int) {return *this;}
}; };
template <class _Container> template <class _Container>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
front_insert_iterator<_Container> front_insert_iterator<_Container>
front_inserter(_Container& __x) front_inserter(_Container& __x)
{ {
return front_insert_iterator<_Container>(__x); return front_insert_iterator<_Container>(__x);
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ITERATOR_FRONT_INSERT_ITERATOR_H #endif // _LIBCPP___ITERATOR_FRONT_INSERT_ITERATOR_H

libcxx/include/__iterator/insert_iterator.h

Show First 20 Lines • Show All 49 Lines • ▼ Show 20 Lines#if _LIBCPP_STD_VER > 17
typedef ptrdiff_t difference_type; typedef ptrdiff_t difference_type;
#else #else
typedef void difference_type; typedef void difference_type;
#endif #endif
typedef void pointer; typedef void pointer;
typedef void reference; typedef void reference;
typedef _Container container_type; typedef _Container container_type;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 insert_iterator(_Container& __x, __insert_iterator_iter_t<_Container> __i) _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 insert_iterator(_Container& __x, __insert_iterator_iter_t<_Container> __i)
: container(_VSTD::addressof(__x)), iter(__i) {} : container(_VSTD::addressof(__x)), iter(__i) {}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 insert_iterator& operator=(const typename _Container::value_type& __value) _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 insert_iterator& operator=(const typename _Container::value_type& __value)
{iter = container->insert(iter, __value); ++iter; return *this;} {iter = container->insert(iter, __value); ++iter; return *this;}
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 insert_iterator& operator=(typename _Container::value_type&& __value) _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 insert_iterator& operator=(typename _Container::value_type&& __value)
{iter = container->insert(iter, _VSTD::move(__value)); ++iter; return *this;} {iter = container->insert(iter, _VSTD::move(__value)); ++iter; return *this;}
#endif // _LIBCPP_CXX03_LANG #endif // _LIBCPP_CXX03_LANG
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 insert_iterator& operator*() {return *this;} _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 insert_iterator& operator*() {return *this;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 insert_iterator& operator++() {return *this;} _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 insert_iterator& operator++() {return *this;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 insert_iterator& operator++(int) {return *this;} _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 insert_iterator& operator++(int) {return *this;}
}; };
template <class _Container> template <class _Container>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
insert_iterator<_Container> insert_iterator<_Container>
inserter(_Container& __x, __insert_iterator_iter_t<_Container> __i) inserter(_Container& __x, __insert_iterator_iter_t<_Container> __i)
{ {
return insert_iterator<_Container>(__x, __i); return insert_iterator<_Container>(__x, __i);
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ITERATOR_INSERT_ITERATOR_H #endif // _LIBCPP___ITERATOR_INSERT_ITERATOR_H

libcxx/include/__iterator/move_iterator.h

Show First 20 Lines • Show All 81 Lines • ▼ Show 20 Lines#else
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&&, typename remove_reference<__reference>::type&&,
__reference __reference
>::type reference; >::type reference;
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER > 17
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_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_AFTER_CXX14 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX17
move_iterator& operator++() { ++__current_; return *this; } move_iterator& operator++() { ++__current_; return *this; }
_LIBCPP_DEPRECATED_IN_CXX20 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_DEPRECATED_IN_CXX20 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX17
pointer operator->() const { return __current_; } pointer operator->() const { return __current_; }
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER > 17
_LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_HIDE_FROM_ABI constexpr
move_iterator() requires is_constructible_v<_Iter> : __current_() {} move_iterator() requires is_constructible_v<_Iter> : __current_() {}
template <class _Up> template <class _Up>
requires (!_IsSame<_Up, _Iter>::value) && convertible_to<const _Up&, _Iter> requires (!_IsSame<_Up, _Iter>::value) && convertible_to<const _Up&, _Iter>
Show All 23 Lines auto operator++(int)
requires forward_iterator<_Iter> requires forward_iterator<_Iter>
{ {
move_iterator __tmp(*this); ++__current_; return __tmp; move_iterator __tmp(*this); ++__current_; return __tmp;
} }
_LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_HIDE_FROM_ABI constexpr
void operator++(int) { ++__current_; } void operator++(int) { ++__current_; }
#else #else
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX17
move_iterator() : __current_() {} move_iterator() : __current_() {}
template <class _Up, class = __enable_if_t< template <class _Up, class = __enable_if_t<
!is_same<_Up, _Iter>::value && is_convertible<const _Up&, _Iter>::value !is_same<_Up, _Iter>::value && is_convertible<const _Up&, _Iter>::value
> > > >
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX17
move_iterator(const move_iterator<_Up>& __u) : __current_(__u.base()) {} move_iterator(const move_iterator<_Up>& __u) : __current_(__u.base()) {}
template <class _Up, class = __enable_if_t< template <class _Up, class = __enable_if_t<
!is_same<_Up, _Iter>::value && !is_same<_Up, _Iter>::value &&
is_convertible<const _Up&, _Iter>::value && is_convertible<const _Up&, _Iter>::value &&
is_assignable<_Iter&, const _Up&>::value is_assignable<_Iter&, const _Up&>::value
> > > >
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX17
move_iterator& operator=(const move_iterator<_Up>& __u) { move_iterator& operator=(const move_iterator<_Up>& __u) {
__current_ = __u.base(); __current_ = __u.base();
return *this; return *this;
} }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX17
_Iter base() const { return __current_; } _Iter base() const { return __current_; }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX17
reference operator*() const { return static_cast<reference>(*__current_); } reference operator*() const { return static_cast<reference>(*__current_); }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX17
reference operator[](difference_type __n) const { return static_cast<reference>(__current_[__n]); } reference operator[](difference_type __n) const { return static_cast<reference>(__current_[__n]); }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX17
move_iterator operator++(int) { move_iterator __tmp(*this); ++__current_; return __tmp; } move_iterator operator++(int) { move_iterator __tmp(*this); ++__current_; return __tmp; }
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER > 17
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX17
move_iterator& operator--() { --__current_; return *this; } move_iterator& operator--() { --__current_; return *this; }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX17
move_iterator operator--(int) { move_iterator __tmp(*this); --__current_; return __tmp; } move_iterator operator--(int) { move_iterator __tmp(*this); --__current_; return __tmp; }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX17
move_iterator operator+(difference_type __n) const { return move_iterator(__current_ + __n); } move_iterator operator+(difference_type __n) const { return move_iterator(__current_ + __n); }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX17
move_iterator& operator+=(difference_type __n) { __current_ += __n; return *this; } move_iterator& operator+=(difference_type __n) { __current_ += __n; return *this; }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX17
move_iterator operator-(difference_type __n) const { return move_iterator(__current_ - __n); } move_iterator operator-(difference_type __n) const { return move_iterator(__current_ - __n); }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX17
move_iterator& operator-=(difference_type __n) { __current_ -= __n; return *this; } move_iterator& operator-=(difference_type __n) { __current_ -= __n; return *this; }
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER > 17
template<sentinel_for<_Iter> _Sent> template<sentinel_for<_Iter> _Sent>
friend _LIBCPP_HIDE_FROM_ABI constexpr friend _LIBCPP_HIDE_FROM_ABI constexpr
bool operator==(const move_iterator& __x, const move_sentinel<_Sent>& __y) bool operator==(const move_iterator& __x, const move_sentinel<_Sent>& __y)
requires __move_iter_comparable<_Iter, _Sent> requires __move_iter_comparable<_Iter, _Sent>
{ {
Show All 32 Lines
private: private:
template<class _It2> friend class move_iterator; template<class _It2> friend class move_iterator;
_Iter __current_; _Iter __current_;
}; };
template <class _Iter1, class _Iter2> template <class _Iter1, class _Iter2>
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX14 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX17
bool operator==(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y) bool operator==(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
{ {
return __x.base() == __y.base(); return __x.base() == __y.base();
} }
#if _LIBCPP_STD_VER <= 17 #if _LIBCPP_STD_VER <= 17
template <class _Iter1, class _Iter2> template <class _Iter1, class _Iter2>
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX14 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX17
bool operator!=(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y) bool operator!=(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
{ {
return __x.base() != __y.base(); return __x.base() != __y.base();
} }
#endif // _LIBCPP_STD_VER <= 17 #endif // _LIBCPP_STD_VER <= 17
template <class _Iter1, class _Iter2> template <class _Iter1, class _Iter2>
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX14 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX17
bool operator<(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y) bool operator<(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
{ {
return __x.base() < __y.base(); return __x.base() < __y.base();
} }
template <class _Iter1, class _Iter2> template <class _Iter1, class _Iter2>
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX14 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX17
bool operator>(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y) bool operator>(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
{ {
return __x.base() > __y.base(); return __x.base() > __y.base();
} }
template <class _Iter1, class _Iter2> template <class _Iter1, class _Iter2>
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX14 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX17
bool operator<=(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y) bool operator<=(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
{ {
return __x.base() <= __y.base(); return __x.base() <= __y.base();
} }
template <class _Iter1, class _Iter2> template <class _Iter1, class _Iter2>
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX14 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX17
bool operator>=(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y) bool operator>=(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
{ {
return __x.base() >= __y.base(); return __x.base() >= __y.base();
} }
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER > 17
template <class _Iter1, three_way_comparable_with<_Iter1> _Iter2> template <class _Iter1, three_way_comparable_with<_Iter1> _Iter2>
inline _LIBCPP_HIDE_FROM_ABI constexpr inline _LIBCPP_HIDE_FROM_ABI constexpr
auto operator<=>(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y) auto operator<=>(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
-> compare_three_way_result_t<_Iter1, _Iter2> -> compare_three_way_result_t<_Iter1, _Iter2>
{ {
return __x.base() <=> __y.base(); return __x.base() <=> __y.base();
} }
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER > 17
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
template <class _Iter1, class _Iter2> template <class _Iter1, class _Iter2>
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX14 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX17
auto operator-(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y) auto operator-(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
-> decltype(__x.base() - __y.base()) -> decltype(__x.base() - __y.base())
{ {
return __x.base() - __y.base(); return __x.base() - __y.base();
} }
#else #else
template <class _Iter1, class _Iter2> template <class _Iter1, class _Iter2>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI
Show All 9 Lines
inline _LIBCPP_HIDE_FROM_ABI constexpr inline _LIBCPP_HIDE_FROM_ABI constexpr
move_iterator<_Iter> operator+(iter_difference_t<_Iter> __n, const move_iterator<_Iter>& __x) move_iterator<_Iter> operator+(iter_difference_t<_Iter> __n, const move_iterator<_Iter>& __x)
requires requires { { __x.base() + __n } -> same_as<_Iter>; } requires requires { { __x.base() + __n } -> same_as<_Iter>; }
{ {
return __x + __n; return __x + __n;
} }
#else #else
template <class _Iter> template <class _Iter>
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX14 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX17
move_iterator<_Iter> move_iterator<_Iter>
operator+(typename move_iterator<_Iter>::difference_type __n, const move_iterator<_Iter>& __x) operator+(typename move_iterator<_Iter>::difference_type __n, const move_iterator<_Iter>& __x)
{ {
return move_iterator<_Iter>(__x.base() + __n); return move_iterator<_Iter>(__x.base() + __n);
} }
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER > 17
template <class _Iter> template <class _Iter>
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX14 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX17
move_iterator<_Iter> move_iterator<_Iter>
make_move_iterator(_Iter __i) make_move_iterator(_Iter __i)
{ {
return move_iterator<_Iter>(std::move(__i)); return move_iterator<_Iter>(std::move(__i));
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ITERATOR_MOVE_ITERATOR_H #endif // _LIBCPP___ITERATOR_MOVE_ITERATOR_H

libcxx/include/__iterator/next.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 _InputIter> template <class _InputIter>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
typename enable_if<__is_cpp17_input_iterator<_InputIter>::value, _InputIter>::type typename enable_if<__is_cpp17_input_iterator<_InputIter>::value, _InputIter>::type
next(_InputIter __x, typename iterator_traits<_InputIter>::difference_type __n = 1) { next(_InputIter __x, typename iterator_traits<_InputIter>::difference_type __n = 1) {
_LIBCPP_ASSERT(__n >= 0 || __is_cpp17_bidirectional_iterator<_InputIter>::value, _LIBCPP_ASSERT(__n >= 0 || __is_cpp17_bidirectional_iterator<_InputIter>::value,
"Attempt to next(it, n) with negative n on a non-bidirectional iterator"); "Attempt to next(it, n) with negative n on a non-bidirectional iterator");
_VSTD::advance(__x, __n); _VSTD::advance(__x, __n);
return __x; return __x;
} }
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

libcxx/include/__iterator/prev.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 _InputIter> template <class _InputIter>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
typename enable_if<__is_cpp17_input_iterator<_InputIter>::value, _InputIter>::type typename enable_if<__is_cpp17_input_iterator<_InputIter>::value, _InputIter>::type
prev(_InputIter __x, typename iterator_traits<_InputIter>::difference_type __n = 1) { prev(_InputIter __x, typename iterator_traits<_InputIter>::difference_type __n = 1) {
_LIBCPP_ASSERT(__n <= 0 || __is_cpp17_bidirectional_iterator<_InputIter>::value, _LIBCPP_ASSERT(__n <= 0 || __is_cpp17_bidirectional_iterator<_InputIter>::value,
"Attempt to prev(it, n) with a positive n on a non-bidirectional iterator"); "Attempt to prev(it, n) with a positive n on a non-bidirectional iterator");
_VSTD::advance(__x, -__n); _VSTD::advance(__x, -__n);
return __x; return __x;
} }
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

libcxx/include/__iterator/reverse_access.h

Show All 18 Lines
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER > 11
template <class _Tp, size_t _Np> template <class _Tp, size_t _Np>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
reverse_iterator<_Tp*> rbegin(_Tp (&__array)[_Np]) reverse_iterator<_Tp*> rbegin(_Tp (&__array)[_Np])
{ {
return reverse_iterator<_Tp*>(__array + _Np); return reverse_iterator<_Tp*>(__array + _Np);
} }
template <class _Tp, size_t _Np> template <class _Tp, size_t _Np>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
reverse_iterator<_Tp*> rend(_Tp (&__array)[_Np]) reverse_iterator<_Tp*> rend(_Tp (&__array)[_Np])
{ {
return reverse_iterator<_Tp*>(__array); return reverse_iterator<_Tp*>(__array);
} }
template <class _Ep> template <class _Ep>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
reverse_iterator<const _Ep*> rbegin(initializer_list<_Ep> __il) reverse_iterator<const _Ep*> rbegin(initializer_list<_Ep> __il)
{ {
return reverse_iterator<const _Ep*>(__il.end()); return reverse_iterator<const _Ep*>(__il.end());
} }
template <class _Ep> template <class _Ep>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
reverse_iterator<const _Ep*> rend(initializer_list<_Ep> __il) reverse_iterator<const _Ep*> rend(initializer_list<_Ep> __il)
{ {
return reverse_iterator<const _Ep*>(__il.begin()); return reverse_iterator<const _Ep*>(__il.begin());
} }
template <class _Cp> template <class _Cp>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
auto rbegin(_Cp& __c) -> decltype(__c.rbegin()) auto rbegin(_Cp& __c) -> decltype(__c.rbegin())
{ {
return __c.rbegin(); return __c.rbegin();
} }
template <class _Cp> template <class _Cp>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
auto rbegin(const _Cp& __c) -> decltype(__c.rbegin()) auto rbegin(const _Cp& __c) -> decltype(__c.rbegin())
{ {
return __c.rbegin(); return __c.rbegin();
} }
template <class _Cp> template <class _Cp>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
auto rend(_Cp& __c) -> decltype(__c.rend()) auto rend(_Cp& __c) -> decltype(__c.rend())
{ {
return __c.rend(); return __c.rend();
} }
template <class _Cp> template <class _Cp>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
auto rend(const _Cp& __c) -> decltype(__c.rend()) auto rend(const _Cp& __c) -> decltype(__c.rend())
{ {
return __c.rend(); return __c.rend();
} }
template <class _Cp> template <class _Cp>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
auto crbegin(const _Cp& __c) -> decltype(_VSTD::rbegin(__c)) auto crbegin(const _Cp& __c) -> decltype(_VSTD::rbegin(__c))
{ {
return _VSTD::rbegin(__c); return _VSTD::rbegin(__c);
} }
template <class _Cp> template <class _Cp>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
auto crend(const _Cp& __c) -> decltype(_VSTD::rend(__c)) auto crend(const _Cp& __c) -> decltype(_VSTD::rend(__c))
{ {
return _VSTD::rend(__c); return _VSTD::rend(__c);
} }
#endif // _LIBCPP_STD_VER > 11 #endif // _LIBCPP_STD_VER > 11
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ITERATOR_REVERSE_ACCESS_H #endif // _LIBCPP___ITERATOR_REVERSE_ACCESS_H

libcxx/include/__iterator/reverse_iterator.h

Show First 20 Lines • Show All 75 Lines • ▼ Show 20 Lines#if _LIBCPP_STD_VER > 17
using reference = iter_reference_t<_Iter>; using reference = iter_reference_t<_Iter>;
#else #else
using value_type = typename iterator_traits<_Iter>::value_type; using value_type = typename iterator_traits<_Iter>::value_type;
using difference_type = typename iterator_traits<_Iter>::difference_type; using difference_type = typename iterator_traits<_Iter>::difference_type;
using reference = typename iterator_traits<_Iter>::reference; using reference = typename iterator_traits<_Iter>::reference;
#endif #endif
#ifndef _LIBCPP_ABI_NO_ITERATOR_BASES #ifndef _LIBCPP_ABI_NO_ITERATOR_BASES
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
reverse_iterator() : __t(), current() {} reverse_iterator() : __t(), current() {}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
explicit reverse_iterator(_Iter __x) : __t(__x), current(__x) {} explicit reverse_iterator(_Iter __x) : __t(__x), current(__x) {}
template <class _Up, class = __enable_if_t< template <class _Up, class = __enable_if_t<
!is_same<_Up, _Iter>::value && is_convertible<_Up const&, _Iter>::value !is_same<_Up, _Iter>::value && is_convertible<_Up const&, _Iter>::value
> > > >
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
reverse_iterator(const reverse_iterator<_Up>& __u) reverse_iterator(const reverse_iterator<_Up>& __u)
: __t(__u.base()), current(__u.base()) : __t(__u.base()), current(__u.base())
{ } { }
template <class _Up, class = __enable_if_t< template <class _Up, class = __enable_if_t<
!is_same<_Up, _Iter>::value && !is_same<_Up, _Iter>::value &&
is_convertible<_Up const&, _Iter>::value && is_convertible<_Up const&, _Iter>::value &&
is_assignable<_Iter&, _Up const&>::value is_assignable<_Iter&, _Up const&>::value
> > > >
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
reverse_iterator& operator=(const reverse_iterator<_Up>& __u) { reverse_iterator& operator=(const reverse_iterator<_Up>& __u) {
__t = current = __u.base(); __t = current = __u.base();
return *this; return *this;
} }
#else #else
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
reverse_iterator() : current() {} reverse_iterator() : current() {}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
explicit reverse_iterator(_Iter __x) : current(__x) {} explicit reverse_iterator(_Iter __x) : current(__x) {}
template <class _Up, class = __enable_if_t< template <class _Up, class = __enable_if_t<
!is_same<_Up, _Iter>::value && is_convertible<_Up const&, _Iter>::value !is_same<_Up, _Iter>::value && is_convertible<_Up const&, _Iter>::value
> > > >
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
reverse_iterator(const reverse_iterator<_Up>& __u) reverse_iterator(const reverse_iterator<_Up>& __u)
: current(__u.base()) : current(__u.base())
{ } { }
template <class _Up, class = __enable_if_t< template <class _Up, class = __enable_if_t<
!is_same<_Up, _Iter>::value && !is_same<_Up, _Iter>::value &&
is_convertible<_Up const&, _Iter>::value && is_convertible<_Up const&, _Iter>::value &&
is_assignable<_Iter&, _Up const&>::value is_assignable<_Iter&, _Up const&>::value
> > > >
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
reverse_iterator& operator=(const reverse_iterator<_Up>& __u) { reverse_iterator& operator=(const reverse_iterator<_Up>& __u) {
current = __u.base(); current = __u.base();
return *this; return *this;
} }
#endif #endif
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
_Iter base() const {return current;} _Iter base() const {return current;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
reference operator*() const {_Iter __tmp = current; return *--__tmp;} reference operator*() const {_Iter __tmp = current; return *--__tmp;}
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER > 17
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
constexpr pointer operator->() const constexpr pointer operator->() const
requires is_pointer_v<_Iter> || requires(const _Iter __i) { __i.operator->(); } requires is_pointer_v<_Iter> || requires(const _Iter __i) { __i.operator->(); }
{ {
if constexpr (is_pointer_v<_Iter>) { if constexpr (is_pointer_v<_Iter>) {
return std::prev(current); return std::prev(current);
} else { } else {
return std::prev(current).operator->(); return std::prev(current).operator->();
} }
} }
#else #else
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
pointer operator->() const { pointer operator->() const {
return std::addressof(operator*()); return std::addressof(operator*());
} }
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER > 17
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
reverse_iterator& operator++() {--current; return *this;} reverse_iterator& operator++() {--current; return *this;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
reverse_iterator operator++(int) {reverse_iterator __tmp(*this); --current; return __tmp;} reverse_iterator operator++(int) {reverse_iterator __tmp(*this); --current; return __tmp;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
reverse_iterator& operator--() {++current; return *this;} reverse_iterator& operator--() {++current; return *this;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
reverse_iterator operator--(int) {reverse_iterator __tmp(*this); ++current; return __tmp;} reverse_iterator operator--(int) {reverse_iterator __tmp(*this); ++current; return __tmp;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
reverse_iterator operator+(difference_type __n) const {return reverse_iterator(current - __n);} reverse_iterator operator+(difference_type __n) const {return reverse_iterator(current - __n);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
reverse_iterator& operator+=(difference_type __n) {current -= __n; return *this;} reverse_iterator& operator+=(difference_type __n) {current -= __n; return *this;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
reverse_iterator operator-(difference_type __n) const {return reverse_iterator(current + __n);} reverse_iterator operator-(difference_type __n) const {return reverse_iterator(current + __n);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
reverse_iterator& operator-=(difference_type __n) {current += __n; return *this;} reverse_iterator& operator-=(difference_type __n) {current += __n; return *this;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
reference operator[](difference_type __n) const {return *(*this + __n);} reference operator[](difference_type __n) const {return *(*this + __n);}
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER > 17
_LIBCPP_HIDE_FROM_ABI friend constexpr _LIBCPP_HIDE_FROM_ABI friend constexpr
iter_rvalue_reference_t<_Iter> iter_move(const reverse_iterator& __i) iter_rvalue_reference_t<_Iter> iter_move(const reverse_iterator& __i)
noexcept(is_nothrow_copy_constructible_v<_Iter> && noexcept(is_nothrow_copy_constructible_v<_Iter> &&
noexcept(ranges::iter_move(--declval<_Iter&>()))) { noexcept(ranges::iter_move(--declval<_Iter&>()))) {
auto __tmp = __i.base(); auto __tmp = __i.base();
Show All 15 Lines
template <class _Iter> template <class _Iter>
struct __is_reverse_iterator : false_type {}; struct __is_reverse_iterator : false_type {};
template <class _Iter> template <class _Iter>
struct __is_reverse_iterator<reverse_iterator<_Iter> > : true_type {}; struct __is_reverse_iterator<reverse_iterator<_Iter> > : true_type {};
template <class _Iter1, class _Iter2> template <class _Iter1, class _Iter2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
bool bool
operator==(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y) operator==(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER > 17
requires requires { requires requires {
{ __x.base() == __y.base() } -> convertible_to<bool>; { __x.base() == __y.base() } -> convertible_to<bool>;
} }
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER > 17
{ {
return __x.base() == __y.base(); return __x.base() == __y.base();
} }
template <class _Iter1, class _Iter2> template <class _Iter1, class _Iter2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
bool bool
operator<(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y) operator<(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER > 17
requires requires { requires requires {
{ __x.base() > __y.base() } -> convertible_to<bool>; { __x.base() > __y.base() } -> convertible_to<bool>;
} }
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER > 17
{ {
return __x.base() > __y.base(); return __x.base() > __y.base();
} }
template <class _Iter1, class _Iter2> template <class _Iter1, class _Iter2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
bool bool
operator!=(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y) operator!=(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER > 17
requires requires { requires requires {
{ __x.base() != __y.base() } -> convertible_to<bool>; { __x.base() != __y.base() } -> convertible_to<bool>;
} }
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER > 17
{ {
return __x.base() != __y.base(); return __x.base() != __y.base();
} }
template <class _Iter1, class _Iter2> template <class _Iter1, class _Iter2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
bool bool
operator>(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y) operator>(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER > 17
requires requires { requires requires {
{ __x.base() < __y.base() } -> convertible_to<bool>; { __x.base() < __y.base() } -> convertible_to<bool>;
} }
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER > 17
{ {
return __x.base() < __y.base(); return __x.base() < __y.base();
} }
template <class _Iter1, class _Iter2> template <class _Iter1, class _Iter2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
bool bool
operator>=(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y) operator>=(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER > 17
requires requires { requires requires {
{ __x.base() <= __y.base() } -> convertible_to<bool>; { __x.base() <= __y.base() } -> convertible_to<bool>;
} }
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER > 17
{ {
return __x.base() <= __y.base(); return __x.base() <= __y.base();
} }
template <class _Iter1, class _Iter2> template <class _Iter1, class _Iter2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
bool bool
operator<=(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y) operator<=(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER > 17
requires requires { requires requires {
{ __x.base() >= __y.base() } -> convertible_to<bool>; { __x.base() >= __y.base() } -> convertible_to<bool>;
} }
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER > 17
{ {
return __x.base() >= __y.base(); return __x.base() >= __y.base();
} }
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER > 17
template <class _Iter1, three_way_comparable_with<_Iter1> _Iter2> template <class _Iter1, three_way_comparable_with<_Iter1> _Iter2>
_LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_HIDE_FROM_ABI constexpr
compare_three_way_result_t<_Iter1, _Iter2> compare_three_way_result_t<_Iter1, _Iter2>
operator<=>(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y) operator<=>(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
{ {
return __y.base() <=> __x.base(); return __y.base() <=> __x.base();
} }
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER > 17
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
template <class _Iter1, class _Iter2> template <class _Iter1, class _Iter2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
auto auto
operator-(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y) operator-(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
-> decltype(__y.base() - __x.base()) -> decltype(__y.base() - __x.base())
{ {
return __y.base() - __x.base(); return __y.base() - __x.base();
} }
#else #else
template <class _Iter1, class _Iter2> template <class _Iter1, class _Iter2>
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
typename reverse_iterator<_Iter1>::difference_type typename reverse_iterator<_Iter1>::difference_type
operator-(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y) operator-(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
{ {
return __y.base() - __x.base(); return __y.base() - __x.base();
} }
#endif #endif
template <class _Iter> template <class _Iter>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
reverse_iterator<_Iter> reverse_iterator<_Iter>
operator+(typename reverse_iterator<_Iter>::difference_type __n, const reverse_iterator<_Iter>& __x) operator+(typename reverse_iterator<_Iter>::difference_type __n, const reverse_iterator<_Iter>& __x)
{ {
return reverse_iterator<_Iter>(__x.base() - __n); return reverse_iterator<_Iter>(__x.base() - __n);
} }
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER > 17
template <class _Iter1, class _Iter2> template <class _Iter1, class _Iter2>
requires (!sized_sentinel_for<_Iter1, _Iter2>) requires (!sized_sentinel_for<_Iter1, _Iter2>)
inline constexpr bool disable_sized_sentinel_for<reverse_iterator<_Iter1>, reverse_iterator<_Iter2>> = true; inline constexpr bool disable_sized_sentinel_for<reverse_iterator<_Iter1>, reverse_iterator<_Iter2>> = true;
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER > 17
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER > 11
template <class _Iter> template <class _Iter>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
reverse_iterator<_Iter> make_reverse_iterator(_Iter __i) reverse_iterator<_Iter> make_reverse_iterator(_Iter __i)
{ {
return reverse_iterator<_Iter>(__i); return reverse_iterator<_Iter>(__i);
} }
#endif #endif
#if _LIBCPP_STD_VER <= 17 #if _LIBCPP_STD_VER <= 17
template <class _Iter> template <class _Iter>
▲ Show 20 Lines • Show All 199 Lines • Show Last 20 Lines

libcxx/include/__iterator/wrap_iter.h

Show All 34 Linespublic:
typedef typename iterator_traits<iterator_type>::iterator_category iterator_category; typedef typename iterator_traits<iterator_type>::iterator_category 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
private: private:
iterator_type __i; iterator_type __i;
public: public:
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 __wrap_iter() _NOEXCEPT _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14 __wrap_iter() _NOEXCEPT
: __i() : __i()
{ {
_VSTD::__debug_db_insert_i(this); _VSTD::__debug_db_insert_i(this);
} }
template <class _Up> _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 template <class _Up> _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14
__wrap_iter(const __wrap_iter<_Up>& __u, __wrap_iter(const __wrap_iter<_Up>& __u,
typename enable_if<is_convertible<_Up, iterator_type>::value>::type* = nullptr) _NOEXCEPT typename enable_if<is_convertible<_Up, iterator_type>::value>::type* = nullptr) _NOEXCEPT
: __i(__u.base()) : __i(__u.base())
{ {
#ifdef _LIBCPP_ENABLE_DEBUG_MODE #ifdef _LIBCPP_ENABLE_DEBUG_MODE
if (!__libcpp_is_constant_evaluated()) if (!__libcpp_is_constant_evaluated())
__get_db()->__iterator_copy(this, _VSTD::addressof(__u)); __get_db()->__iterator_copy(this, _VSTD::addressof(__u));
#endif #endif
} }
#ifdef _LIBCPP_ENABLE_DEBUG_MODE #ifdef _LIBCPP_ENABLE_DEBUG_MODE
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14
__wrap_iter(const __wrap_iter& __x) __wrap_iter(const __wrap_iter& __x)
: __i(__x.base()) : __i(__x.base())
{ {
if (!__libcpp_is_constant_evaluated()) if (!__libcpp_is_constant_evaluated())
__get_db()->__iterator_copy(this, _VSTD::addressof(__x)); __get_db()->__iterator_copy(this, _VSTD::addressof(__x));
} }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14
__wrap_iter& operator=(const __wrap_iter& __x) __wrap_iter& operator=(const __wrap_iter& __x)
{ {
if (this != _VSTD::addressof(__x)) if (this != _VSTD::addressof(__x))
{ {
if (!__libcpp_is_constant_evaluated()) if (!__libcpp_is_constant_evaluated())
__get_db()->__iterator_copy(this, _VSTD::addressof(__x)); __get_db()->__iterator_copy(this, _VSTD::addressof(__x));
__i = __x.__i; __i = __x.__i;
} }
return *this; return *this;
} }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
~__wrap_iter() ~__wrap_iter()
{ {
if (!__libcpp_is_constant_evaluated()) if (!__libcpp_is_constant_evaluated())
__get_db()->__erase_i(this); __get_db()->__erase_i(this);
} }
#endif #endif
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 reference operator*() const _NOEXCEPT _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14 reference operator*() const _NOEXCEPT
{ {
_LIBCPP_DEBUG_ASSERT(__get_const_db()->__dereferenceable(this), _LIBCPP_DEBUG_ASSERT(__get_const_db()->__dereferenceable(this),
"Attempted to dereference a non-dereferenceable iterator"); "Attempted to dereference a non-dereferenceable iterator");
return *__i; return *__i;
} }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 pointer operator->() const _NOEXCEPT _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14 pointer operator->() const _NOEXCEPT
{ {
_LIBCPP_DEBUG_ASSERT(__get_const_db()->__dereferenceable(this), _LIBCPP_DEBUG_ASSERT(__get_const_db()->__dereferenceable(this),
"Attempted to dereference a non-dereferenceable iterator"); "Attempted to dereference a non-dereferenceable iterator");
return _VSTD::__to_address(__i); return _VSTD::__to_address(__i);
} }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 __wrap_iter& operator++() _NOEXCEPT _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14 __wrap_iter& operator++() _NOEXCEPT
{ {
_LIBCPP_DEBUG_ASSERT(__get_const_db()->__dereferenceable(this), _LIBCPP_DEBUG_ASSERT(__get_const_db()->__dereferenceable(this),
"Attempted to increment a non-incrementable iterator"); "Attempted to increment a non-incrementable iterator");
++__i; ++__i;
return *this; return *this;
} }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 __wrap_iter operator++(int) _NOEXCEPT _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14 __wrap_iter operator++(int) _NOEXCEPT
{__wrap_iter __tmp(*this); ++(*this); return __tmp;} {__wrap_iter __tmp(*this); ++(*this); return __tmp;}
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 __wrap_iter& operator--() _NOEXCEPT _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14 __wrap_iter& operator--() _NOEXCEPT
{ {
_LIBCPP_DEBUG_ASSERT(__get_const_db()->__decrementable(this), _LIBCPP_DEBUG_ASSERT(__get_const_db()->__decrementable(this),
"Attempted to decrement a non-decrementable iterator"); "Attempted to decrement a non-decrementable iterator");
--__i; --__i;
return *this; return *this;
} }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 __wrap_iter operator--(int) _NOEXCEPT _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14 __wrap_iter operator--(int) _NOEXCEPT
{__wrap_iter __tmp(*this); --(*this); return __tmp;} {__wrap_iter __tmp(*this); --(*this); return __tmp;}
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 __wrap_iter operator+ (difference_type __n) const _NOEXCEPT _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14 __wrap_iter operator+ (difference_type __n) const _NOEXCEPT
{__wrap_iter __w(*this); __w += __n; return __w;} {__wrap_iter __w(*this); __w += __n; return __w;}
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 __wrap_iter& operator+=(difference_type __n) _NOEXCEPT _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14 __wrap_iter& operator+=(difference_type __n) _NOEXCEPT
{ {
_LIBCPP_DEBUG_ASSERT(__get_const_db()->__addable(this, __n), _LIBCPP_DEBUG_ASSERT(__get_const_db()->__addable(this, __n),
"Attempted to add/subtract an iterator outside its valid range"); "Attempted to add/subtract an iterator outside its valid range");
__i += __n; __i += __n;
return *this; return *this;
} }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 __wrap_iter operator- (difference_type __n) const _NOEXCEPT _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14 __wrap_iter operator- (difference_type __n) const _NOEXCEPT
{return *this + (-__n);} {return *this + (-__n);}
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 __wrap_iter& operator-=(difference_type __n) _NOEXCEPT _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14 __wrap_iter& operator-=(difference_type __n) _NOEXCEPT
{*this += -__n; return *this;} {*this += -__n; return *this;}
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 reference operator[](difference_type __n) const _NOEXCEPT _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14 reference operator[](difference_type __n) const _NOEXCEPT
{ {
_LIBCPP_DEBUG_ASSERT(__get_const_db()->__subscriptable(this, __n), _LIBCPP_DEBUG_ASSERT(__get_const_db()->__subscriptable(this, __n),
"Attempted to subscript an iterator outside its valid range"); "Attempted to subscript an iterator outside its valid range");
return __i[__n]; return __i[__n];
} }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 iterator_type base() const _NOEXCEPT {return __i;} _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14 iterator_type base() const _NOEXCEPT {return __i;}
private: private:
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14
explicit __wrap_iter(const void* __p, iterator_type __x) _NOEXCEPT : __i(__x) explicit __wrap_iter(const void* __p, iterator_type __x) _NOEXCEPT : __i(__x)
{ {
(void)__p; (void)__p;
#ifdef _LIBCPP_ENABLE_DEBUG_MODE #ifdef _LIBCPP_ENABLE_DEBUG_MODE
if (!__libcpp_is_constant_evaluated()) if (!__libcpp_is_constant_evaluated())
__get_db()->__insert_ic(this, __p); __get_db()->__insert_ic(this, __p);
#endif #endif
} }
Show All 14 Lines
template <class _Iter1, class _Iter2> template <class _Iter1, class _Iter2>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR
bool operator==(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT bool operator==(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT
{ {
return __x.base() == __y.base(); return __x.base() == __y.base();
} }
template <class _Iter1> template <class _Iter1>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14
bool operator<(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter1>& __y) _NOEXCEPT bool operator<(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter1>& __y) _NOEXCEPT
{ {
_LIBCPP_DEBUG_ASSERT(__get_const_db()->__less_than_comparable(_VSTD::addressof(__x), _VSTD::addressof(__y)), _LIBCPP_DEBUG_ASSERT(__get_const_db()->__less_than_comparable(_VSTD::addressof(__x), _VSTD::addressof(__y)),
"Attempted to compare incomparable iterators"); "Attempted to compare incomparable iterators");
return __x.base() < __y.base(); return __x.base() < __y.base();
} }
template <class _Iter1, class _Iter2> template <class _Iter1, class _Iter2>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14
bool operator<(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT bool operator<(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT
{ {
_LIBCPP_DEBUG_ASSERT(__get_const_db()->__less_than_comparable(&__x, &__y), _LIBCPP_DEBUG_ASSERT(__get_const_db()->__less_than_comparable(&__x, &__y),
"Attempted to compare incomparable iterators"); "Attempted to compare incomparable iterators");
return __x.base() < __y.base(); return __x.base() < __y.base();
} }
template <class _Iter1> template <class _Iter1>
▲ Show 20 Lines • Show All 48 Lines • ▼ Show 20 Lines
template <class _Iter1, class _Iter2> template <class _Iter1, class _Iter2>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR
bool operator<=(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT bool operator<=(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT
{ {
return !(__y < __x); return !(__y < __x);
} }
template <class _Iter1, class _Iter2> template <class _Iter1, class _Iter2>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
auto operator-(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT auto operator-(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT
-> decltype(__x.base() - __y.base()) -> decltype(__x.base() - __y.base())
#else #else
typename __wrap_iter<_Iter1>::difference_type typename __wrap_iter<_Iter1>::difference_type
operator-(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT operator-(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT
#endif // C++03 #endif // C++03
{ {
_LIBCPP_DEBUG_ASSERT(__get_const_db()->__less_than_comparable(_VSTD::addressof(__x), _VSTD::addressof(__y)), _LIBCPP_DEBUG_ASSERT(__get_const_db()->__less_than_comparable(_VSTD::addressof(__x), _VSTD::addressof(__y)),
"Attempted to subtract incompatible iterators"); "Attempted to subtract incompatible iterators");
return __x.base() - __y.base(); return __x.base() - __y.base();
} }
template <class _Iter1> template <class _Iter1>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14
__wrap_iter<_Iter1> operator+(typename __wrap_iter<_Iter1>::difference_type __n, __wrap_iter<_Iter1> __x) _NOEXCEPT __wrap_iter<_Iter1> operator+(typename __wrap_iter<_Iter1>::difference_type __n, __wrap_iter<_Iter1> __x) _NOEXCEPT
{ {
__x += __n; __x += __n;
return __x; return __x;
} }
#if _LIBCPP_STD_VER <= 17 #if _LIBCPP_STD_VER <= 17
template <class _It> template <class _It>
Show All 19 Lines

libcxx/include/__memory/addressof.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>
inline _LIBCPP_CONSTEXPR_AFTER_CXX14 inline _LIBCPP_CONSTEXPR_CXX17
_LIBCPP_NO_CFI _LIBCPP_INLINE_VISIBILITY _LIBCPP_NO_CFI _LIBCPP_INLINE_VISIBILITY
_Tp* _Tp*
addressof(_Tp& __x) _NOEXCEPT addressof(_Tp& __x) _NOEXCEPT
{ {
return __builtin_addressof(__x); return __builtin_addressof(__x);
} }
#if defined(_LIBCPP_HAS_OBJC_ARC) && !defined(_LIBCPP_PREDEFINED_OBJC_ARC_ADDRESSOF) #if defined(_LIBCPP_HAS_OBJC_ARC) && !defined(_LIBCPP_PREDEFINED_OBJC_ARC_ADDRESSOF)
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

libcxx/include/__memory/allocator.h

Show First 20 Lines • Show All 89 Lines • ▼ Show 20 Linesclass _LIBCPP_TEMPLATE_VIS allocator
static_assert(!is_volatile<_Tp>::value, "std::allocator does not support volatile types"); static_assert(!is_volatile<_Tp>::value, "std::allocator does not support volatile types");
public: public:
typedef size_t size_type; typedef size_t size_type;
typedef ptrdiff_t difference_type; typedef ptrdiff_t difference_type;
typedef _Tp value_type; typedef _Tp value_type;
typedef true_type propagate_on_container_move_assignment; typedef true_type propagate_on_container_move_assignment;
typedef true_type is_always_equal; typedef true_type is_always_equal;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
allocator() _NOEXCEPT = default; allocator() _NOEXCEPT = default;
template <class _Up> template <class _Up>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
allocator(const allocator<_Up>&) _NOEXCEPT { } allocator(const allocator<_Up>&) _NOEXCEPT { }
_LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
_Tp* allocate(size_t __n) { _Tp* allocate(size_t __n) {
if (__n > allocator_traits<allocator>::max_size(*this)) if (__n > allocator_traits<allocator>::max_size(*this))
__throw_bad_array_new_length(); __throw_bad_array_new_length();
if (__libcpp_is_constant_evaluated()) { if (__libcpp_is_constant_evaluated()) {
return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp))); return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp)));
} else { } else {
return static_cast<_Tp*>(_VSTD::__libcpp_allocate(__n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp))); return static_cast<_Tp*>(_VSTD::__libcpp_allocate(__n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp)));
} }
} }
#if _LIBCPP_STD_VER > 20 #if _LIBCPP_STD_VER > 20
[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr
allocation_result<_Tp*> allocate_at_least(size_t __n) { allocation_result<_Tp*> allocate_at_least(size_t __n) {
return {allocate(__n), __n}; return {allocate(__n), __n};
} }
#endif #endif
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
void deallocate(_Tp* __p, size_t __n) _NOEXCEPT { void deallocate(_Tp* __p, size_t __n) _NOEXCEPT {
if (__libcpp_is_constant_evaluated()) { if (__libcpp_is_constant_evaluated()) {
::operator delete(__p); ::operator delete(__p);
} else { } else {
_VSTD::__libcpp_deallocate((void*)__p, __n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp)); _VSTD::__libcpp_deallocate((void*)__p, __n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp));
} }
} }
▲ Show 20 Lines • Show All 47 Lines • ▼ Show 20 Linesclass _LIBCPP_TEMPLATE_VIS allocator<const _Tp>
static_assert(!is_volatile<_Tp>::value, "std::allocator does not support volatile types"); static_assert(!is_volatile<_Tp>::value, "std::allocator does not support volatile types");
public: public:
typedef size_t size_type; typedef size_t size_type;
typedef ptrdiff_t difference_type; typedef ptrdiff_t difference_type;
typedef const _Tp value_type; typedef const _Tp value_type;
typedef true_type propagate_on_container_move_assignment; typedef true_type propagate_on_container_move_assignment;
typedef true_type is_always_equal; typedef true_type is_always_equal;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
allocator() _NOEXCEPT = default; allocator() _NOEXCEPT = default;
template <class _Up> template <class _Up>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
allocator(const allocator<_Up>&) _NOEXCEPT { } allocator(const allocator<_Up>&) _NOEXCEPT { }
_LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
const _Tp* allocate(size_t __n) { const _Tp* allocate(size_t __n) {
if (__n > allocator_traits<allocator>::max_size(*this)) if (__n > allocator_traits<allocator>::max_size(*this))
__throw_bad_array_new_length(); __throw_bad_array_new_length();
if (__libcpp_is_constant_evaluated()) { if (__libcpp_is_constant_evaluated()) {
return static_cast<const _Tp*>(::operator new(__n * sizeof(_Tp))); return static_cast<const _Tp*>(::operator new(__n * sizeof(_Tp)));
} else { } else {
return static_cast<const _Tp*>(_VSTD::__libcpp_allocate(__n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp))); return static_cast<const _Tp*>(_VSTD::__libcpp_allocate(__n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp)));
} }
} }
#if _LIBCPP_STD_VER > 20 #if _LIBCPP_STD_VER > 20
[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr
allocation_result<const _Tp*> allocate_at_least(size_t __n) { allocation_result<const _Tp*> allocate_at_least(size_t __n) {
return {allocate(__n), __n}; return {allocate(__n), __n};
} }
#endif #endif
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
void deallocate(const _Tp* __p, size_t __n) { void deallocate(const _Tp* __p, size_t __n) {
if (__libcpp_is_constant_evaluated()) { if (__libcpp_is_constant_evaluated()) {
::operator delete(const_cast<_Tp*>(__p)); ::operator delete(const_cast<_Tp*>(__p));
} else { } else {
_VSTD::__libcpp_deallocate((void*) const_cast<_Tp *>(__p), __n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp)); _VSTD::__libcpp_deallocate((void*) const_cast<_Tp *>(__p), __n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp));
} }
} }
Show All 32 Lines#if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS)
_LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_INLINE_VISIBILITY
void destroy(pointer __p) { void destroy(pointer __p) {
__p->~_Tp(); __p->~_Tp();
} }
#endif #endif
}; };
template <class _Tp, class _Up> template <class _Tp, class _Up>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
bool operator==(const allocator<_Tp>&, const allocator<_Up>&) _NOEXCEPT {return true;} bool operator==(const allocator<_Tp>&, const allocator<_Up>&) _NOEXCEPT {return true;}
template <class _Tp, class _Up> template <class _Tp, class _Up>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
bool operator!=(const allocator<_Tp>&, const allocator<_Up>&) _NOEXCEPT {return false;} bool operator!=(const allocator<_Tp>&, const allocator<_Up>&) _NOEXCEPT {return false;}
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___MEMORY_ALLOCATOR_H #endif // _LIBCPP___MEMORY_ALLOCATOR_H

libcxx/include/__memory/allocator_traits.h

Show First 20 Lines • Show All 251 Lines • ▼ Show 20 Lines struct rebind_alloc {
using other = __allocator_traits_rebind_t<allocator_type, _Tp>; using other = __allocator_traits_rebind_t<allocator_type, _Tp>;
}; };
template <class _Tp> template <class _Tp>
struct rebind_traits { struct rebind_traits {
using other = allocator_traits<typename rebind_alloc<_Tp>::other>; using other = allocator_traits<typename rebind_alloc<_Tp>::other>;
}; };
#endif // _LIBCPP_CXX03_LANG #endif // _LIBCPP_CXX03_LANG
_LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
static pointer allocate(allocator_type& __a, size_type __n) { static pointer allocate(allocator_type& __a, size_type __n) {
return __a.allocate(__n); return __a.allocate(__n);
} }
template <class _Ap = _Alloc, class = template <class _Ap = _Alloc, class =
__enable_if_t<__has_allocate_hint<_Ap, size_type, const_void_pointer>::value> > __enable_if_t<__has_allocate_hint<_Ap, size_type, const_void_pointer>::value> >
_LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
static pointer allocate(allocator_type& __a, size_type __n, const_void_pointer __hint) { static pointer allocate(allocator_type& __a, size_type __n, const_void_pointer __hint) {
_LIBCPP_SUPPRESS_DEPRECATED_PUSH _LIBCPP_SUPPRESS_DEPRECATED_PUSH
return __a.allocate(__n, __hint); return __a.allocate(__n, __hint);
_LIBCPP_SUPPRESS_DEPRECATED_POP _LIBCPP_SUPPRESS_DEPRECATED_POP
} }
template <class _Ap = _Alloc, class = void, class = template <class _Ap = _Alloc, class = void, class =
__enable_if_t<!__has_allocate_hint<_Ap, size_type, const_void_pointer>::value> > __enable_if_t<!__has_allocate_hint<_Ap, size_type, const_void_pointer>::value> >
_LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
static pointer allocate(allocator_type& __a, size_type __n, const_void_pointer) { static pointer allocate(allocator_type& __a, size_type __n, const_void_pointer) {
return __a.allocate(__n); return __a.allocate(__n);
} }
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
static void deallocate(allocator_type& __a, pointer __p, size_type __n) _NOEXCEPT { static void deallocate(allocator_type& __a, pointer __p, size_type __n) _NOEXCEPT {
__a.deallocate(__p, __n); __a.deallocate(__p, __n);
} }
template <class _Tp, class... _Args, class = template <class _Tp, class... _Args, class =
__enable_if_t<__has_construct<allocator_type, _Tp*, _Args...>::value> > __enable_if_t<__has_construct<allocator_type, _Tp*, _Args...>::value> >
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
static void construct(allocator_type& __a, _Tp* __p, _Args&&... __args) { static void construct(allocator_type& __a, _Tp* __p, _Args&&... __args) {
_LIBCPP_SUPPRESS_DEPRECATED_PUSH _LIBCPP_SUPPRESS_DEPRECATED_PUSH
__a.construct(__p, _VSTD::forward<_Args>(__args)...); __a.construct(__p, _VSTD::forward<_Args>(__args)...);
_LIBCPP_SUPPRESS_DEPRECATED_POP _LIBCPP_SUPPRESS_DEPRECATED_POP
} }
template <class _Tp, class... _Args, class = void, class = template <class _Tp, class... _Args, class = void, class =
__enable_if_t<!__has_construct<allocator_type, _Tp*, _Args...>::value> > __enable_if_t<!__has_construct<allocator_type, _Tp*, _Args...>::value> >
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
static void construct(allocator_type&, _Tp* __p, _Args&&... __args) { static void construct(allocator_type&, _Tp* __p, _Args&&... __args) {
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER > 17
_VSTD::construct_at(__p, _VSTD::forward<_Args>(__args)...); _VSTD::construct_at(__p, _VSTD::forward<_Args>(__args)...);
#else #else
::new ((void*)__p) _Tp(_VSTD::forward<_Args>(__args)...); ::new ((void*)__p) _Tp(_VSTD::forward<_Args>(__args)...);
#endif #endif
} }
template <class _Tp, class = template <class _Tp, class =
__enable_if_t<__has_destroy<allocator_type, _Tp*>::value> > __enable_if_t<__has_destroy<allocator_type, _Tp*>::value> >
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
static void destroy(allocator_type& __a, _Tp* __p) { static void destroy(allocator_type& __a, _Tp* __p) {
_LIBCPP_SUPPRESS_DEPRECATED_PUSH _LIBCPP_SUPPRESS_DEPRECATED_PUSH
__a.destroy(__p); __a.destroy(__p);
_LIBCPP_SUPPRESS_DEPRECATED_POP _LIBCPP_SUPPRESS_DEPRECATED_POP
} }
template <class _Tp, class = void, class = template <class _Tp, class = void, class =
__enable_if_t<!__has_destroy<allocator_type, _Tp*>::value> > __enable_if_t<!__has_destroy<allocator_type, _Tp*>::value> >
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
static void destroy(allocator_type&, _Tp* __p) { static void destroy(allocator_type&, _Tp* __p) {
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER > 17
_VSTD::destroy_at(__p); _VSTD::destroy_at(__p);
#else #else
__p->~_Tp(); __p->~_Tp();
#endif #endif
} }
template <class _Ap = _Alloc, class = template <class _Ap = _Alloc, class =
__enable_if_t<__has_max_size<const _Ap>::value> > __enable_if_t<__has_max_size<const _Ap>::value> >
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
static size_type max_size(const allocator_type& __a) _NOEXCEPT { static size_type max_size(const allocator_type& __a) _NOEXCEPT {
_LIBCPP_SUPPRESS_DEPRECATED_PUSH _LIBCPP_SUPPRESS_DEPRECATED_PUSH
return __a.max_size(); return __a.max_size();
_LIBCPP_SUPPRESS_DEPRECATED_POP _LIBCPP_SUPPRESS_DEPRECATED_POP
} }
template <class _Ap = _Alloc, class = void, class = template <class _Ap = _Alloc, class = void, class =
__enable_if_t<!__has_max_size<const _Ap>::value> > __enable_if_t<!__has_max_size<const _Ap>::value> >
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
static size_type max_size(const allocator_type&) _NOEXCEPT { static size_type max_size(const allocator_type&) _NOEXCEPT {
return numeric_limits<size_type>::max() / sizeof(value_type); return numeric_limits<size_type>::max() / sizeof(value_type);
} }
template <class _Ap = _Alloc, class = template <class _Ap = _Alloc, class =
__enable_if_t<__has_select_on_container_copy_construction<const _Ap>::value> > __enable_if_t<__has_select_on_container_copy_construction<const _Ap>::value> >
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
static allocator_type select_on_container_copy_construction(const allocator_type& __a) { static allocator_type select_on_container_copy_construction(const allocator_type& __a) {
return __a.select_on_container_copy_construction(); return __a.select_on_container_copy_construction();
} }
template <class _Ap = _Alloc, class = void, class = template <class _Ap = _Alloc, class = void, class =
__enable_if_t<!__has_select_on_container_copy_construction<const _Ap>::value> > __enable_if_t<!__has_select_on_container_copy_construction<const _Ap>::value> >
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
static allocator_type select_on_container_copy_construction(const allocator_type& __a) { static allocator_type select_on_container_copy_construction(const allocator_type& __a) {
return __a; return __a;
} }
}; };
template <class _Traits, class _Tp> template <class _Traits, class _Tp>
struct __rebind_alloc_helper { struct __rebind_alloc_helper {
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

libcxx/include/__memory/compressed_pair.h

Show All 35 Linesstruct __compressed_pair_elem {
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR explicit __compressed_pair_elem(__value_init_tag) : __value_() {} _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR explicit __compressed_pair_elem(__value_init_tag) : __value_() {}
template <class _Up, class = __enable_if_t<!is_same<__compressed_pair_elem, typename decay<_Up>::type>::value> > template <class _Up, class = __enable_if_t<!is_same<__compressed_pair_elem, typename decay<_Up>::type>::value> >
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR
explicit __compressed_pair_elem(_Up&& __u) : __value_(std::forward<_Up>(__u)) {} explicit __compressed_pair_elem(_Up&& __u) : __value_(std::forward<_Up>(__u)) {}
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
template <class... _Args, size_t... _Indices> template <class... _Args, size_t... _Indices>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX17
ldionneUnsubmitted
Not Done
ReplyInline Actions
template <class... _Args, size_t... _Indices>
- _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX17
+ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR
explicit __compressed_pair_elem(piecewise_construct_t, tuple<_Args...> __args, __tuple_indices<_Indices...>)

I think this should work? In fact we could just use constexpr, maybe.

ldionne: I think this should work? In fact we could just use `constexpr`, maybe.
explicit __compressed_pair_elem(piecewise_construct_t, tuple<_Args...> __args, __tuple_indices<_Indices...>) explicit __compressed_pair_elem(piecewise_construct_t, tuple<_Args...> __args, __tuple_indices<_Indices...>)
: __value_(std::forward<_Args>(std::get<_Indices>(__args))...) {} : __value_(std::forward<_Args>(std::get<_Indices>(__args))...) {}
#endif #endif
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 reference __get() _NOEXCEPT { return __value_; } _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14 reference __get() _NOEXCEPT { return __value_; }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR const_reference __get() const _NOEXCEPT { return __value_; } _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR const_reference __get() const _NOEXCEPT { return __value_; }
private: private:
_Tp __value_; _Tp __value_;
}; };
template <class _Tp, int _Idx> template <class _Tp, int _Idx>
struct __compressed_pair_elem<_Tp, _Idx, true> : private _Tp { struct __compressed_pair_elem<_Tp, _Idx, true> : private _Tp {
using _ParamT = _Tp; using _ParamT = _Tp;
using reference = _Tp&; using reference = _Tp&;
using const_reference = const _Tp&; using const_reference = const _Tp&;
using __value_type = _Tp; using __value_type = _Tp;
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR explicit __compressed_pair_elem() = default; _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR explicit __compressed_pair_elem() = default;
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR explicit __compressed_pair_elem(__default_init_tag) {} _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR explicit __compressed_pair_elem(__default_init_tag) {}
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR explicit __compressed_pair_elem(__value_init_tag) : __value_type() {} _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR explicit __compressed_pair_elem(__value_init_tag) : __value_type() {}
template <class _Up, class = __enable_if_t<!is_same<__compressed_pair_elem, typename decay<_Up>::type>::value> > template <class _Up, class = __enable_if_t<!is_same<__compressed_pair_elem, typename decay<_Up>::type>::value> >
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR
explicit __compressed_pair_elem(_Up&& __u) : __value_type(std::forward<_Up>(__u)) {} explicit __compressed_pair_elem(_Up&& __u) : __value_type(std::forward<_Up>(__u)) {}
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
template <class... _Args, size_t... _Indices> template <class... _Args, size_t... _Indices>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX17
__compressed_pair_elem(piecewise_construct_t, tuple<_Args...> __args, __tuple_indices<_Indices...>) __compressed_pair_elem(piecewise_construct_t, tuple<_Args...> __args, __tuple_indices<_Indices...>)
: __value_type(std::forward<_Args>(std::get<_Indices>(__args))...) {} : __value_type(std::forward<_Args>(std::get<_Indices>(__args))...) {}
#endif #endif
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 reference __get() _NOEXCEPT { return *this; } _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14 reference __get() _NOEXCEPT { return *this; }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR const_reference __get() const _NOEXCEPT { return *this; } _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR const_reference __get() const _NOEXCEPT { return *this; }
}; };
template <class _T1, class _T2> template <class _T1, class _T2>
class __compressed_pair : private __compressed_pair_elem<_T1, 0>, class __compressed_pair : private __compressed_pair_elem<_T1, 0>,
private __compressed_pair_elem<_T2, 1> { private __compressed_pair_elem<_T2, 1> {
public: public:
// NOTE: This static assert should never fire because __compressed_pair // NOTE: This static assert should never fire because __compressed_pair
Show All 17 Linespublic:
explicit __compressed_pair() : _Base1(__value_init_tag()), _Base2(__value_init_tag()) {} explicit __compressed_pair() : _Base1(__value_init_tag()), _Base2(__value_init_tag()) {}
template <class _U1, class _U2> template <class _U1, class _U2>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR
explicit __compressed_pair(_U1&& __t1, _U2&& __t2) : _Base1(std::forward<_U1>(__t1)), _Base2(std::forward<_U2>(__t2)) {} explicit __compressed_pair(_U1&& __t1, _U2&& __t2) : _Base1(std::forward<_U1>(__t1)), _Base2(std::forward<_U2>(__t2)) {}
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
template <class... _Args1, class... _Args2> template <class... _Args1, class... _Args2>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX17
explicit __compressed_pair(piecewise_construct_t __pc, tuple<_Args1...> __first_args, explicit __compressed_pair(piecewise_construct_t __pc, tuple<_Args1...> __first_args,
tuple<_Args2...> __second_args) tuple<_Args2...> __second_args)
: _Base1(__pc, std::move(__first_args), typename __make_tuple_indices<sizeof...(_Args1)>::type()), : _Base1(__pc, std::move(__first_args), typename __make_tuple_indices<sizeof...(_Args1)>::type()),
_Base2(__pc, std::move(__second_args), typename __make_tuple_indices<sizeof...(_Args2)>::type()) {} _Base2(__pc, std::move(__second_args), typename __make_tuple_indices<sizeof...(_Args2)>::type()) {}
#endif #endif
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14
typename _Base1::reference first() _NOEXCEPT { typename _Base1::reference first() _NOEXCEPT {
return static_cast<_Base1&>(*this).__get(); return static_cast<_Base1&>(*this).__get();
} }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR
typename _Base1::const_reference first() const _NOEXCEPT { typename _Base1::const_reference first() const _NOEXCEPT {
return static_cast<_Base1 const&>(*this).__get(); return static_cast<_Base1 const&>(*this).__get();
} }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14
typename _Base2::reference second() _NOEXCEPT { typename _Base2::reference second() _NOEXCEPT {
return static_cast<_Base2&>(*this).__get(); return static_cast<_Base2&>(*this).__get();
} }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR
typename _Base2::const_reference second() const _NOEXCEPT { typename _Base2::const_reference second() const _NOEXCEPT {
return static_cast<_Base2 const&>(*this).__get(); return static_cast<_Base2 const&>(*this).__get();
} }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR static _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR static
_Base1* __get_first_base(__compressed_pair* __pair) _NOEXCEPT { _Base1* __get_first_base(__compressed_pair* __pair) _NOEXCEPT {
return static_cast<_Base1*>(__pair); return static_cast<_Base1*>(__pair);
} }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR static _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR static
_Base2* __get_second_base(__compressed_pair* __pair) _NOEXCEPT { _Base2* __get_second_base(__compressed_pair* __pair) _NOEXCEPT {
return static_cast<_Base2*>(__pair); return static_cast<_Base2*>(__pair);
} }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14
void swap(__compressed_pair& __x) void swap(__compressed_pair& __x)
_NOEXCEPT_(__is_nothrow_swappable<_T1>::value && __is_nothrow_swappable<_T2>::value) { _NOEXCEPT_(__is_nothrow_swappable<_T1>::value && __is_nothrow_swappable<_T2>::value) {
using std::swap; using std::swap;
swap(first(), __x.first()); swap(first(), __x.first());
swap(second(), __x.second()); swap(second(), __x.second());
} }
}; };
template <class _T1, class _T2> template <class _T1, class _T2>
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14
void swap(__compressed_pair<_T1, _T2>& __x, __compressed_pair<_T1, _T2>& __y) void swap(__compressed_pair<_T1, _T2>& __x, __compressed_pair<_T1, _T2>& __y)
_NOEXCEPT_(__is_nothrow_swappable<_T1>::value && __is_nothrow_swappable<_T2>::value) { _NOEXCEPT_(__is_nothrow_swappable<_T1>::value && __is_nothrow_swappable<_T2>::value) {
__x.swap(__y); __x.swap(__y);
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___MEMORY_COMPRESSED_PAIR_H #endif // _LIBCPP___MEMORY_COMPRESSED_PAIR_H

libcxx/include/__memory/construct_at.h

Show First 20 Lines • Show All 47 Lines • ▼ Show 20 Lines
} }
// destroy_at // destroy_at
// The internal functions are available regardless of the language version (with the exception of the `__destroy_at` // The internal functions are available regardless of the language version (with the exception of the `__destroy_at`
// taking an array). // taking an array).
template <class _ForwardIterator> template <class _ForwardIterator>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
_ForwardIterator __destroy(_ForwardIterator, _ForwardIterator); _ForwardIterator __destroy(_ForwardIterator, _ForwardIterator);
template <class _Tp, typename enable_if<!is_array<_Tp>::value, int>::type = 0> template <class _Tp, typename enable_if<!is_array<_Tp>::value, int>::type = 0>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
void __destroy_at(_Tp* __loc) { void __destroy_at(_Tp* __loc) {
_LIBCPP_ASSERT(__loc != nullptr, "null pointer given to destroy_at"); _LIBCPP_ASSERT(__loc != nullptr, "null pointer given to destroy_at");
__loc->~_Tp(); __loc->~_Tp();
} }
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER > 17
template <class _Tp, typename enable_if<is_array<_Tp>::value, int>::type = 0> template <class _Tp, typename enable_if<is_array<_Tp>::value, int>::type = 0>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
void __destroy_at(_Tp* __loc) { void __destroy_at(_Tp* __loc) {
_LIBCPP_ASSERT(__loc != nullptr, "null pointer given to destroy_at"); _LIBCPP_ASSERT(__loc != nullptr, "null pointer given to destroy_at");
_VSTD::__destroy(_VSTD::begin(*__loc), _VSTD::end(*__loc)); _VSTD::__destroy(_VSTD::begin(*__loc), _VSTD::end(*__loc));
} }
#endif #endif
template <class _ForwardIterator> template <class _ForwardIterator>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
_ForwardIterator __destroy(_ForwardIterator __first, _ForwardIterator __last) { _ForwardIterator __destroy(_ForwardIterator __first, _ForwardIterator __last) {
for (; __first != __last; ++__first) for (; __first != __last; ++__first)
_VSTD::__destroy_at(_VSTD::addressof(*__first)); _VSTD::__destroy_at(_VSTD::addressof(*__first));
return __first; return __first;
} }
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER > 14
template <class _Tp, enable_if_t<!is_array_v<_Tp>, int> = 0> template <class _Tp, enable_if_t<!is_array_v<_Tp>, int> = 0>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
void destroy_at(_Tp* __loc) { void destroy_at(_Tp* __loc) {
_VSTD::__destroy_at(__loc); _VSTD::__destroy_at(__loc);
} }
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER > 17
template <class _Tp, enable_if_t<is_array_v<_Tp>, int> = 0> template <class _Tp, enable_if_t<is_array_v<_Tp>, int> = 0>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
void destroy_at(_Tp* __loc) { void destroy_at(_Tp* __loc) {
_VSTD::__destroy_at(__loc); _VSTD::__destroy_at(__loc);
} }
#endif #endif
template <class _ForwardIterator> template <class _ForwardIterator>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
void destroy(_ForwardIterator __first, _ForwardIterator __last) { void destroy(_ForwardIterator __first, _ForwardIterator __last) {
(void)_VSTD::__destroy(_VSTD::move(__first), _VSTD::move(__last)); (void)_VSTD::__destroy(_VSTD::move(__first), _VSTD::move(__last));
} }
template <class _ForwardIterator, class _Size> template <class _ForwardIterator, class _Size>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
_ForwardIterator destroy_n(_ForwardIterator __first, _Size __n) { _ForwardIterator destroy_n(_ForwardIterator __first, _Size __n) {
for (; __n > 0; (void)++__first, --__n) for (; __n > 0; (void)++__first, --__n)
_VSTD::__destroy_at(_VSTD::addressof(*__first)); _VSTD::__destroy_at(_VSTD::addressof(*__first));
return __first; return __first;
} }
#endif // _LIBCPP_STD_VER > 14 #endif // _LIBCPP_STD_VER > 14
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___MEMORY_CONSTRUCT_AT_H #endif // _LIBCPP___MEMORY_CONSTRUCT_AT_H

libcxx/include/__memory/pointer_traits.h

Show First 20 Lines • Show All 116 Lines • ▼ Show 20 Lines
#else #else
template <class _Up> struct rebind template <class _Up> struct rebind
{typedef typename __pointer_traits_rebind<pointer, _Up>::type other;}; {typedef typename __pointer_traits_rebind<pointer, _Up>::type other;};
#endif // _LIBCPP_CXX03_LANG #endif // _LIBCPP_CXX03_LANG
private: private:
struct __nat {}; struct __nat {};
public: public:
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_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) __nat, element_type>::type& __r)
{return pointer::pointer_to(__r);} {return pointer::pointer_to(__r);}
}; };
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS pointer_traits<_Tp*> struct _LIBCPP_TEMPLATE_VIS pointer_traits<_Tp*>
{ {
typedef _Tp* pointer; typedef _Tp* pointer;
typedef _Tp element_type; typedef _Tp element_type;
typedef ptrdiff_t difference_type; typedef ptrdiff_t difference_type;
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
template <class _Up> using rebind = _Up*; template <class _Up> using rebind = _Up*;
#else #else
template <class _Up> struct rebind {typedef _Up* other;}; template <class _Up> struct rebind {typedef _Up* other;};
#endif #endif
private: private:
struct __nat {}; struct __nat {};
public: public:
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_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> template <class _From, class _To>
struct __rebind_pointer { struct __rebind_pointer {
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
▲ Show 20 Lines • Show All 84 Lines • Show Last 20 Lines

libcxx/include/__memory/swap_allocator.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 <typename _Alloc> template <typename _Alloc>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 void __swap_allocator(_Alloc& __a1, _Alloc& __a2, true_type) _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14 void __swap_allocator(_Alloc& __a1, _Alloc& __a2, true_type)
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER > 11
_NOEXCEPT _NOEXCEPT
#else #else
_NOEXCEPT_(__is_nothrow_swappable<_Alloc>::value) _NOEXCEPT_(__is_nothrow_swappable<_Alloc>::value)
#endif #endif
{ {
using _VSTD::swap; using _VSTD::swap;
swap(__a1, __a2); swap(__a1, __a2);
} }
template <typename _Alloc> template <typename _Alloc>
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 void inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14 void
__swap_allocator(_Alloc&, _Alloc&, false_type) _NOEXCEPT {} __swap_allocator(_Alloc&, _Alloc&, false_type) _NOEXCEPT {}
template <typename _Alloc> template <typename _Alloc>
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 void __swap_allocator(_Alloc& __a1, _Alloc& __a2) inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14 void __swap_allocator(_Alloc& __a1, _Alloc& __a2)
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER > 11
_NOEXCEPT _NOEXCEPT
#else #else
_NOEXCEPT_(__is_nothrow_swappable<_Alloc>::value) _NOEXCEPT_(__is_nothrow_swappable<_Alloc>::value)
#endif #endif
{ {
_VSTD::__swap_allocator( _VSTD::__swap_allocator(
__a1, __a2, integral_constant<bool, allocator_traits<_Alloc>::propagate_on_container_swap::value>()); __a1, __a2, integral_constant<bool, allocator_traits<_Alloc>::propagate_on_container_swap::value>());
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___MEMORY_SWAP_ALLOCATOR_H #endif // _LIBCPP___MEMORY_SWAP_ALLOCATOR_H

libcxx/include/__memory/uninitialized_algorithms.h

Show First 20 Lines • Show All 494 Lines • ▼ Show 20 Linesconstexpr void __uninitialized_allocator_value_construct_n(_Alloc& __alloc, _BidirIter __it, _Size __n) {
} }
__guard.__complete(); __guard.__complete();
} }
#endif // _LIBCPP_STD_VER > 14 #endif // _LIBCPP_STD_VER > 14
// Destroy all elements in [__first, __last) from left to right using allocator destruction. // Destroy all elements in [__first, __last) from left to right using allocator destruction.
template <class _Alloc, class _Iter, class _Sent> template <class _Alloc, class _Iter, class _Sent>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 void _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20 void
__allocator_destroy(_Alloc& __alloc, _Iter __first, _Sent __last) { __allocator_destroy(_Alloc& __alloc, _Iter __first, _Sent __last) {
for (; __first != __last; ++__first) for (; __first != __last; ++__first)
allocator_traits<_Alloc>::destroy(__alloc, std::__to_address(__first)); allocator_traits<_Alloc>::destroy(__alloc, std::__to_address(__first));
} }
template <class _Alloc, class _Iter> template <class _Alloc, class _Iter>
class _AllocatorDestroyRangeReverse { class _AllocatorDestroyRangeReverse {
public: public:
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14
_AllocatorDestroyRangeReverse(_Alloc& __alloc, _Iter& __first, _Iter& __last) _AllocatorDestroyRangeReverse(_Alloc& __alloc, _Iter& __first, _Iter& __last)
: __alloc_(__alloc), __first_(__first), __last_(__last) {} : __alloc_(__alloc), __first_(__first), __last_(__last) {}
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 void operator()() const { _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14 void operator()() const {
std::__allocator_destroy(__alloc_, std::reverse_iterator<_Iter>(__last_), std::reverse_iterator<_Iter>(__first_)); std::__allocator_destroy(__alloc_, std::reverse_iterator<_Iter>(__last_), std::reverse_iterator<_Iter>(__first_));
} }
private: private:
_Alloc& __alloc_; _Alloc& __alloc_;
_Iter& __first_; _Iter& __first_;
_Iter& __last_; _Iter& __last_;
}; };
// Copy-construct [__first1, __last1) in [__first2, __first2 + N), where N is distance(__first1, __last1). // Copy-construct [__first1, __last1) in [__first2, __first2 + N), where N is distance(__first1, __last1).
// //
// The caller has to ensure that __first2 can hold at least N uninitialized elements. If an exception is thrown the // The caller has to ensure that __first2 can hold at least N uninitialized elements. If an exception is thrown the
// already copied elements are destroyed in reverse order of their construction. // already copied elements are destroyed in reverse order of their construction.
template <class _Alloc, class _Iter1, class _Sent1, class _Iter2> template <class _Alloc, class _Iter1, class _Sent1, class _Iter2>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _Iter2 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20 _Iter2
__uninitialized_allocator_copy(_Alloc& __alloc, _Iter1 __first1, _Sent1 __last1, _Iter2 __first2) { __uninitialized_allocator_copy(_Alloc& __alloc, _Iter1 __first1, _Sent1 __last1, _Iter2 __first2) {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_NO_EXCEPTIONS
auto __destruct_first = __first2; auto __destruct_first = __first2;
try { try {
#endif #endif
while (__first1 != __last1) { while (__first1 != __last1) {
allocator_traits<_Alloc>::construct(__alloc, std::__to_address(__first2), *__first1); allocator_traits<_Alloc>::construct(__alloc, std::__to_address(__first2), *__first1);
++__first1; ++__first1;
Show All 16 Lines
template <class _Alloc, template <class _Alloc,
class _Type, class _Type,
class _RawType = typename remove_const<_Type>::type, class _RawType = typename remove_const<_Type>::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_AFTER_CXX17 _Type* _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_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()) {
while (__first1 != __last1) { while (__first1 != __last1) {
std::__construct_at(std::__to_address(__first2), *__first1); std::__construct_at(std::__to_address(__first2), *__first1);
++__first1; ++__first1;
++__first2; ++__first2;
} }
return __first2; return __first2;
} else { } else {
return std::copy(__first1, __last1, const_cast<_RawType*>(__first2)); return std::copy(__first1, __last1, const_cast<_RawType*>(__first2));
} }
} }
// Move-construct the elements [__first1, __last1) into [__first2, __first2 + N) // Move-construct the elements [__first1, __last1) into [__first2, __first2 + N)
// if the move constructor is noexcept, where N is distance(__first1, __last1). // if the move constructor is noexcept, where N is distance(__first1, __last1).
// //
// Otherwise try to copy all elements. If an exception is thrown the already copied // Otherwise try to copy all elements. If an exception is thrown the already copied
// elements are destroyed in reverse order of their construction. // elements are destroyed in reverse order of their construction.
template <class _Alloc, class _Iter1, class _Sent1, class _Iter2> template <class _Alloc, class _Iter1, class _Sent1, class _Iter2>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _Iter2 __uninitialized_allocator_move_if_noexcept( _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20 _Iter2 __uninitialized_allocator_move_if_noexcept(
_Alloc& __alloc, _Iter1 __first1, _Sent1 __last1, _Iter2 __first2) { _Alloc& __alloc, _Iter1 __first1, _Sent1 __last1, _Iter2 __first2) {
static_assert(__is_cpp17_move_insertable<_Alloc>::value, static_assert(__is_cpp17_move_insertable<_Alloc>::value,
"The specified type does not meet the requirements of Cpp17MoveInsertable"); "The specified type does not meet the requirements of Cpp17MoveInsertable");
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_NO_EXCEPTIONS
auto __destruct_first = __first2; auto __destruct_first = __first2;
try { try {
#endif #endif
while (__first1 != __last1) { while (__first1 != __last1) {
Show All 23 Lines
#ifndef _LIBCPP_COMPILER_GCC #ifndef _LIBCPP_COMPILER_GCC
template < template <
class _Alloc, class _Alloc,
class _Iter1, class _Iter1,
class _Iter2, class _Iter2,
class _Type = typename iterator_traits<_Iter1>::value_type, class _Type = typename iterator_traits<_Iter1>::value_type,
class = __enable_if_t<is_trivially_move_constructible<_Type>::value && is_trivially_move_assignable<_Type>::value && class = __enable_if_t<is_trivially_move_constructible<_Type>::value && is_trivially_move_assignable<_Type>::value &&
__allocator_has_trivial_move_construct<_Alloc, _Type>::value> > __allocator_has_trivial_move_construct<_Alloc, _Type>::value> >
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _Iter2 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20 _Iter2
ldionneUnsubmitted
Not Done
ReplyInline Actions

For example, is there a reason why this is only constexpr in C++20? Maybe it should be marked as constexpr whenever we have support for C++14 generalized constexpr?

ldionne: For example, is there a reason why this is only constexpr in C++20? Maybe it should be marked…
var-constUnsubmitted
Done
ReplyInline Actions

General question -- for internal functions, should we make them constexpr in the lowest language mode possible, or just in the language mode where they are actually used? I'm slightly concerned about overconstraining the implementation, though we can probably always work around that if necessary.

var-const: General question -- for internal functions, should we make them `constexpr` in the lowest…
philnikAuthorUnsubmitted
Done
ReplyInline Actions

We normally use what works, i.e. the lowest language mode feasible. Don't try to make some function constexpr in C++11 just because it's technically possible. But you might as well do it when the function would work in C++11 constexpr.

philnik: We normally use what works, i.e. the lowest language mode feasible. Don't try to make some…
__uninitialized_allocator_move_if_noexcept(_Alloc&, _Iter1 __first1, _Iter1 __last1, _Iter2 __first2) { __uninitialized_allocator_move_if_noexcept(_Alloc&, _Iter1 __first1, _Iter1 __last1, _Iter2 __first2) {
if (__libcpp_is_constant_evaluated()) { if (__libcpp_is_constant_evaluated()) {
while (__first1 != __last1) { while (__first1 != __last1) {
std::__construct_at(std::__to_address(__first2), std::move(*__first1)); std::__construct_at(std::__to_address(__first2), std::move(*__first1));
++__first1; ++__first1;
++__first2; ++__first2;
} }
return __first2; return __first2;
Show All 9 Lines

libcxx/include/__memory/voidify.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 <typename _Tp> template <typename _Tp>
_LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 void* __voidify(_Tp& __from) { _LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20 void* __voidify(_Tp& __from) {
// Cast away cv-qualifiers to allow modifying elements of a range through const iterators. // Cast away cv-qualifiers to allow modifying elements of a range through const iterators.
return const_cast<void*>(static_cast<const volatile void*>(_VSTD::addressof(__from))); return const_cast<void*>(static_cast<const volatile void*>(_VSTD::addressof(__from)));
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___MEMORY_VOIDIFY_H #endif // _LIBCPP___MEMORY_VOIDIFY_H

libcxx/include/__numeric/accumulate.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 _InputIterator, class _Tp> template <class _InputIterator, class _Tp>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
_Tp _Tp
accumulate(_InputIterator __first, _InputIterator __last, _Tp __init) accumulate(_InputIterator __first, _InputIterator __last, _Tp __init)
{ {
for (; __first != __last; ++__first) for (; __first != __last; ++__first)
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER > 17
__init = _VSTD::move(__init) + *__first; __init = _VSTD::move(__init) + *__first;
#else #else
__init = __init + *__first; __init = __init + *__first;
#endif #endif
return __init; return __init;
} }
template <class _InputIterator, class _Tp, class _BinaryOperation> template <class _InputIterator, class _Tp, class _BinaryOperation>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
_Tp _Tp
accumulate(_InputIterator __first, _InputIterator __last, _Tp __init, _BinaryOperation __binary_op) accumulate(_InputIterator __first, _InputIterator __last, _Tp __init, _BinaryOperation __binary_op)
{ {
for (; __first != __last; ++__first) for (; __first != __last; ++__first)
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER > 17
__init = __binary_op(_VSTD::move(__init), *__first); __init = __binary_op(_VSTD::move(__init), *__first);
#else #else
__init = __binary_op(__init, *__first); __init = __binary_op(__init, *__first);
#endif #endif
return __init; return __init;
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___NUMERIC_ACCUMULATE_H #endif // _LIBCPP___NUMERIC_ACCUMULATE_H

libcxx/include/__numeric/adjacent_difference.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 _InputIterator, class _OutputIterator> template <class _InputIterator, class _OutputIterator>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
_OutputIterator _OutputIterator
adjacent_difference(_InputIterator __first, _InputIterator __last, _OutputIterator __result) adjacent_difference(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
{ {
if (__first != __last) if (__first != __last)
{ {
typename iterator_traits<_InputIterator>::value_type __acc(*__first); typename iterator_traits<_InputIterator>::value_type __acc(*__first);
*__result = __acc; *__result = __acc;
for (++__first, (void) ++__result; __first != __last; ++__first, (void) ++__result) for (++__first, (void) ++__result; __first != __last; ++__first, (void) ++__result)
{ {
typename iterator_traits<_InputIterator>::value_type __val(*__first); typename iterator_traits<_InputIterator>::value_type __val(*__first);
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER > 17
*__result = __val - _VSTD::move(__acc); *__result = __val - _VSTD::move(__acc);
#else #else
*__result = __val - __acc; *__result = __val - __acc;
#endif #endif
__acc = _VSTD::move(__val); __acc = _VSTD::move(__val);
} }
} }
return __result; return __result;
} }
template <class _InputIterator, class _OutputIterator, class _BinaryOperation> template <class _InputIterator, class _OutputIterator, class _BinaryOperation>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
_OutputIterator _OutputIterator
adjacent_difference(_InputIterator __first, _InputIterator __last, _OutputIterator __result, adjacent_difference(_InputIterator __first, _InputIterator __last, _OutputIterator __result,
_BinaryOperation __binary_op) _BinaryOperation __binary_op)
{ {
if (__first != __last) if (__first != __last)
{ {
typename iterator_traits<_InputIterator>::value_type __acc(*__first); typename iterator_traits<_InputIterator>::value_type __acc(*__first);
*__result = __acc; *__result = __acc;
Show All 17 Lines

libcxx/include/__numeric/exclusive_scan.h

Show All 17 Lines
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER > 14
template <class _InputIterator, class _OutputIterator, class _Tp, class _BinaryOp> template <class _InputIterator, class _OutputIterator, class _Tp, class _BinaryOp>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _OutputIterator _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 _OutputIterator
exclusive_scan(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _Tp __init, _BinaryOp __b) { exclusive_scan(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _Tp __init, _BinaryOp __b) {
if (__first != __last) { if (__first != __last) {
_Tp __tmp(__b(__init, *__first)); _Tp __tmp(__b(__init, *__first));
while (true) { while (true) {
*__result = _VSTD::move(__init); *__result = _VSTD::move(__init);
++__result; ++__result;
++__first; ++__first;
if (__first == __last) if (__first == __last)
break; break;
__init = _VSTD::move(__tmp); __init = _VSTD::move(__tmp);
__tmp = __b(__init, *__first); __tmp = __b(__init, *__first);
} }
} }
return __result; return __result;
} }
template <class _InputIterator, class _OutputIterator, class _Tp> template <class _InputIterator, class _OutputIterator, class _Tp>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _OutputIterator _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 _OutputIterator
exclusive_scan(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _Tp __init) { exclusive_scan(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _Tp __init) {
return _VSTD::exclusive_scan(__first, __last, __result, __init, _VSTD::plus<>()); return _VSTD::exclusive_scan(__first, __last, __result, __init, _VSTD::plus<>());
} }
#endif // _LIBCPP_STD_VER > 14 #endif // _LIBCPP_STD_VER > 14
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___NUMERIC_EXCLUSIVE_SCAN_H #endif // _LIBCPP___NUMERIC_EXCLUSIVE_SCAN_H

libcxx/include/__numeric/inclusive_scan.h

Show All 18 Lines
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER > 14
template <class _InputIterator, class _OutputIterator, class _Tp, class _BinaryOp> template <class _InputIterator, class _OutputIterator, class _Tp, class _BinaryOp>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _OutputIterator _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 _OutputIterator
inclusive_scan(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _BinaryOp __b, _Tp __init) { inclusive_scan(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _BinaryOp __b, _Tp __init) {
for (; __first != __last; ++__first, (void)++__result) { for (; __first != __last; ++__first, (void)++__result) {
__init = __b(__init, *__first); __init = __b(__init, *__first);
*__result = __init; *__result = __init;
} }
return __result; return __result;
} }
template <class _InputIterator, class _OutputIterator, class _BinaryOp> template <class _InputIterator, class _OutputIterator, class _BinaryOp>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _OutputIterator _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 _OutputIterator
inclusive_scan(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _BinaryOp __b) { inclusive_scan(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _BinaryOp __b) {
if (__first != __last) { if (__first != __last) {
typename iterator_traits<_InputIterator>::value_type __init = *__first; typename iterator_traits<_InputIterator>::value_type __init = *__first;
*__result++ = __init; *__result++ = __init;
if (++__first != __last) if (++__first != __last)
return _VSTD::inclusive_scan(__first, __last, __result, __b, __init); return _VSTD::inclusive_scan(__first, __last, __result, __b, __init);
} }
return __result; return __result;
} }
template <class _InputIterator, class _OutputIterator> template <class _InputIterator, class _OutputIterator>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _OutputIterator inclusive_scan(_InputIterator __first, _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 _OutputIterator inclusive_scan(_InputIterator __first,
_InputIterator __last, _InputIterator __last,
_OutputIterator __result) { _OutputIterator __result) {
return _VSTD::inclusive_scan(__first, __last, __result, _VSTD::plus<>()); return _VSTD::inclusive_scan(__first, __last, __result, _VSTD::plus<>());
} }
#endif // _LIBCPP_STD_VER > 14 #endif // _LIBCPP_STD_VER > 14
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___NUMERIC_INCLUSIVE_SCAN_H #endif // _LIBCPP___NUMERIC_INCLUSIVE_SCAN_H

libcxx/include/__numeric/inner_product.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 _InputIterator1, class _InputIterator2, class _Tp> template <class _InputIterator1, class _InputIterator2, class _Tp>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
_Tp _Tp
inner_product(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _Tp __init) inner_product(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _Tp __init)
{ {
for (; __first1 != __last1; ++__first1, (void) ++__first2) for (; __first1 != __last1; ++__first1, (void) ++__first2)
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER > 17
__init = _VSTD::move(__init) + *__first1 * *__first2; __init = _VSTD::move(__init) + *__first1 * *__first2;
#else #else
__init = __init + *__first1 * *__first2; __init = __init + *__first1 * *__first2;
#endif #endif
return __init; return __init;
} }
template <class _InputIterator1, class _InputIterator2, class _Tp, class _BinaryOperation1, class _BinaryOperation2> template <class _InputIterator1, class _InputIterator2, class _Tp, class _BinaryOperation1, class _BinaryOperation2>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
_Tp _Tp
inner_product(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, inner_product(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2,
_Tp __init, _BinaryOperation1 __binary_op1, _BinaryOperation2 __binary_op2) _Tp __init, _BinaryOperation1 __binary_op1, _BinaryOperation2 __binary_op2)
{ {
for (; __first1 != __last1; ++__first1, (void) ++__first2) for (; __first1 != __last1; ++__first1, (void) ++__first2)
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER > 17
__init = __binary_op1(_VSTD::move(__init), __binary_op2(*__first1, *__first2)); __init = __binary_op1(_VSTD::move(__init), __binary_op2(*__first1, *__first2));
#else #else
__init = __binary_op1(__init, __binary_op2(*__first1, *__first2)); __init = __binary_op1(__init, __binary_op2(*__first1, *__first2));
#endif #endif
return __init; return __init;
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___NUMERIC_INNER_PRODUCT_H #endif // _LIBCPP___NUMERIC_INNER_PRODUCT_H

libcxx/include/__numeric/iota.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 _ForwardIterator, class _Tp> template <class _ForwardIterator, class _Tp>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
void void
iota(_ForwardIterator __first, _ForwardIterator __last, _Tp __value) iota(_ForwardIterator __first, _ForwardIterator __last, _Tp __value)
{ {
for (; __first != __last; ++__first, (void) ++__value) for (; __first != __last; ++__first, (void) ++__value)
*__first = __value; *__first = __value;
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___NUMERIC_IOTA_H #endif // _LIBCPP___NUMERIC_IOTA_H

libcxx/include/__numeric/partial_sum.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 _InputIterator, class _OutputIterator> template <class _InputIterator, class _OutputIterator>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
_OutputIterator _OutputIterator
partial_sum(_InputIterator __first, _InputIterator __last, _OutputIterator __result) partial_sum(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
{ {
if (__first != __last) if (__first != __last)
{ {
typename iterator_traits<_InputIterator>::value_type __t(*__first); typename iterator_traits<_InputIterator>::value_type __t(*__first);
*__result = __t; *__result = __t;
for (++__first, (void) ++__result; __first != __last; ++__first, (void) ++__result) for (++__first, (void) ++__result; __first != __last; ++__first, (void) ++__result)
{ {
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER > 17
__t = _VSTD::move(__t) + *__first; __t = _VSTD::move(__t) + *__first;
#else #else
__t = __t + *__first; __t = __t + *__first;
#endif #endif
*__result = __t; *__result = __t;
} }
} }
return __result; return __result;
} }
template <class _InputIterator, class _OutputIterator, class _BinaryOperation> template <class _InputIterator, class _OutputIterator, class _BinaryOperation>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
_OutputIterator _OutputIterator
partial_sum(_InputIterator __first, _InputIterator __last, _OutputIterator __result, partial_sum(_InputIterator __first, _InputIterator __last, _OutputIterator __result,
_BinaryOperation __binary_op) _BinaryOperation __binary_op)
{ {
if (__first != __last) if (__first != __last)
{ {
typename iterator_traits<_InputIterator>::value_type __t(*__first); typename iterator_traits<_InputIterator>::value_type __t(*__first);
*__result = __t; *__result = __t;
Show All 16 Lines

libcxx/include/__numeric/reduce.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 _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER > 14
template <class _InputIterator, class _Tp, class _BinaryOp> template <class _InputIterator, class _Tp, class _BinaryOp>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _Tp reduce(_InputIterator __first, _InputIterator __last, _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 _Tp reduce(_InputIterator __first, _InputIterator __last,
_Tp __init, _BinaryOp __b) { _Tp __init, _BinaryOp __b) {
for (; __first != __last; ++__first) for (; __first != __last; ++__first)
__init = __b(__init, *__first); __init = __b(__init, *__first);
return __init; return __init;
} }
template <class _InputIterator, class _Tp> template <class _InputIterator, class _Tp>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _Tp reduce(_InputIterator __first, _InputIterator __last, _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 _Tp reduce(_InputIterator __first, _InputIterator __last,
_Tp __init) { _Tp __init) {
return _VSTD::reduce(__first, __last, __init, _VSTD::plus<>()); return _VSTD::reduce(__first, __last, __init, _VSTD::plus<>());
} }
template <class _InputIterator> template <class _InputIterator>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 typename iterator_traits<_InputIterator>::value_type _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 typename iterator_traits<_InputIterator>::value_type
reduce(_InputIterator __first, _InputIterator __last) { reduce(_InputIterator __first, _InputIterator __last) {
return _VSTD::reduce(__first, __last, typename iterator_traits<_InputIterator>::value_type{}); return _VSTD::reduce(__first, __last, typename iterator_traits<_InputIterator>::value_type{});
} }
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___NUMERIC_REDUCE_H #endif // _LIBCPP___NUMERIC_REDUCE_H

libcxx/include/__numeric/transform_exclusive_scan.h

Show All 16 Lines
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER > 14
template <class _InputIterator, class _OutputIterator, class _Tp, template <class _InputIterator, class _OutputIterator, class _Tp,
class _BinaryOp, class _UnaryOp> class _BinaryOp, class _UnaryOp>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
_OutputIterator _OutputIterator
transform_exclusive_scan(_InputIterator __first, _InputIterator __last, transform_exclusive_scan(_InputIterator __first, _InputIterator __last,
_OutputIterator __result, _Tp __init, _OutputIterator __result, _Tp __init,
_BinaryOp __b, _UnaryOp __u) _BinaryOp __b, _UnaryOp __u)
{ {
if (__first != __last) if (__first != __last)
{ {
_Tp __saved = __init; _Tp __saved = __init;
Show All 16 Lines

libcxx/include/__numeric/transform_inclusive_scan.h

Show All 16 Lines
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER > 14
template <class _InputIterator, class _OutputIterator, class _Tp, class _BinaryOp, class _UnaryOp> template <class _InputIterator, class _OutputIterator, class _Tp, class _BinaryOp, class _UnaryOp>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
_OutputIterator _OutputIterator
transform_inclusive_scan(_InputIterator __first, _InputIterator __last, transform_inclusive_scan(_InputIterator __first, _InputIterator __last,
_OutputIterator __result, _BinaryOp __b, _UnaryOp __u, _Tp __init) _OutputIterator __result, _BinaryOp __b, _UnaryOp __u, _Tp __init)
{ {
for (; __first != __last; ++__first, (void) ++__result) { for (; __first != __last; ++__first, (void) ++__result) {
__init = __b(__init, __u(*__first)); __init = __b(__init, __u(*__first));
*__result = __init; *__result = __init;
} }
return __result; return __result;
} }
template <class _InputIterator, class _OutputIterator, class _BinaryOp, class _UnaryOp> template <class _InputIterator, class _OutputIterator, class _BinaryOp, class _UnaryOp>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
_OutputIterator _OutputIterator
transform_inclusive_scan(_InputIterator __first, _InputIterator __last, transform_inclusive_scan(_InputIterator __first, _InputIterator __last,
_OutputIterator __result, _BinaryOp __b, _UnaryOp __u) _OutputIterator __result, _BinaryOp __b, _UnaryOp __u)
{ {
if (__first != __last) { if (__first != __last) {
typename iterator_traits<_InputIterator>::value_type __init = __u(*__first); typename iterator_traits<_InputIterator>::value_type __init = __u(*__first);
*__result++ = __init; *__result++ = __init;
if (++__first != __last) if (++__first != __last)
Show All 11 Lines

libcxx/include/__numeric/transform_reduce.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 _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER > 14
template <class _InputIterator, class _Tp, class _BinaryOp, class _UnaryOp> template <class _InputIterator, class _Tp, class _BinaryOp, class _UnaryOp>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _Tp transform_reduce(_InputIterator __first, _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 _Tp transform_reduce(_InputIterator __first,
_InputIterator __last, _Tp __init, _InputIterator __last, _Tp __init,
_BinaryOp __b, _UnaryOp __u) { _BinaryOp __b, _UnaryOp __u) {
for (; __first != __last; ++__first) for (; __first != __last; ++__first)
__init = __b(__init, __u(*__first)); __init = __b(__init, __u(*__first));
return __init; return __init;
} }
template <class _InputIterator1, class _InputIterator2, class _Tp, class _BinaryOp1, class _BinaryOp2> template <class _InputIterator1, class _InputIterator2, class _Tp, class _BinaryOp1, class _BinaryOp2>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _Tp transform_reduce(_InputIterator1 __first1, _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 _Tp transform_reduce(_InputIterator1 __first1,
_InputIterator1 __last1, _InputIterator1 __last1,
_InputIterator2 __first2, _Tp __init, _InputIterator2 __first2, _Tp __init,
_BinaryOp1 __b1, _BinaryOp2 __b2) { _BinaryOp1 __b1, _BinaryOp2 __b2) {
for (; __first1 != __last1; ++__first1, (void)++__first2) for (; __first1 != __last1; ++__first1, (void)++__first2)
__init = __b1(__init, __b2(*__first1, *__first2)); __init = __b1(__init, __b2(*__first1, *__first2));
return __init; return __init;
} }
template <class _InputIterator1, class _InputIterator2, class _Tp> template <class _InputIterator1, class _InputIterator2, class _Tp>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _Tp transform_reduce(_InputIterator1 __first1, _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 _Tp transform_reduce(_InputIterator1 __first1,
_InputIterator1 __last1, _InputIterator1 __last1,
_InputIterator2 __first2, _Tp __init) { _InputIterator2 __first2, _Tp __init) {
return _VSTD::transform_reduce(__first1, __last1, __first2, _VSTD::move(__init), _VSTD::plus<>(), return _VSTD::transform_reduce(__first1, __last1, __first2, _VSTD::move(__init), _VSTD::plus<>(),
_VSTD::multiplies<>()); _VSTD::multiplies<>());
} }
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___NUMERIC_TRANSFORM_REDUCE_H #endif // _LIBCPP___NUMERIC_TRANSFORM_REDUCE_H

libcxx/include/__split_buffer

Show First 20 Lines • Show All 56 Lines • ▼ Show 20 Linespublic:
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 typename add_lvalue_reference<allocator_type>::type __alloc_ref;
typedef typename add_lvalue_reference<allocator_type>::type __alloc_const_ref; typedef typename add_lvalue_reference<allocator_type>::type __alloc_const_ref;
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY __alloc_rr& __alloc() _NOEXCEPT {return __end_cap_.second();} _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY __alloc_rr& __alloc() _NOEXCEPT {return __end_cap_.second();}
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY const __alloc_rr& __alloc() const _NOEXCEPT {return __end_cap_.second();} _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY const __alloc_rr& __alloc() const _NOEXCEPT {return __end_cap_.second();}
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY pointer& __end_cap() _NOEXCEPT {return __end_cap_.first();} _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY pointer& __end_cap() _NOEXCEPT {return __end_cap_.first();}
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY const pointer& __end_cap() const _NOEXCEPT {return __end_cap_.first();} _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY const pointer& __end_cap() const _NOEXCEPT {return __end_cap_.first();}
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY
__split_buffer() __split_buffer()
_NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value); _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value);
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY
explicit __split_buffer(__alloc_rr& __a); explicit __split_buffer(__alloc_rr& __a);
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY
explicit __split_buffer(const __alloc_rr& __a); explicit __split_buffer(const __alloc_rr& __a);
_LIBCPP_CONSTEXPR_AFTER_CXX17 __split_buffer(size_type __cap, size_type __start, __alloc_rr& __a); _LIBCPP_CONSTEXPR_CXX20 __split_buffer(size_type __cap, size_type __start, __alloc_rr& __a);
_LIBCPP_CONSTEXPR_AFTER_CXX17 ~__split_buffer(); _LIBCPP_CONSTEXPR_CXX20 ~__split_buffer();
_LIBCPP_CONSTEXPR_AFTER_CXX17 __split_buffer(__split_buffer&& __c) _LIBCPP_CONSTEXPR_CXX20 __split_buffer(__split_buffer&& __c)
_NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value); _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value);
_LIBCPP_CONSTEXPR_AFTER_CXX17 __split_buffer(__split_buffer&& __c, const __alloc_rr& __a); _LIBCPP_CONSTEXPR_CXX20 __split_buffer(__split_buffer&& __c, const __alloc_rr& __a);
_LIBCPP_CONSTEXPR_AFTER_CXX17 __split_buffer& operator=(__split_buffer&& __c) _LIBCPP_CONSTEXPR_CXX20 __split_buffer& operator=(__split_buffer&& __c)
_NOEXCEPT_((__alloc_traits::propagate_on_container_move_assignment::value && _NOEXCEPT_((__alloc_traits::propagate_on_container_move_assignment::value &&
is_nothrow_move_assignable<allocator_type>::value) || is_nothrow_move_assignable<allocator_type>::value) ||
!__alloc_traits::propagate_on_container_move_assignment::value); !__alloc_traits::propagate_on_container_move_assignment::value);
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY iterator begin() _NOEXCEPT {return __begin_;} _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY iterator begin() _NOEXCEPT {return __begin_;}
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY const_iterator begin() const _NOEXCEPT {return __begin_;} _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY const_iterator begin() const _NOEXCEPT {return __begin_;}
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY iterator end() _NOEXCEPT {return __end_;} _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY iterator end() _NOEXCEPT {return __end_;}
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY const_iterator end() const _NOEXCEPT {return __end_;} _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY const_iterator end() const _NOEXCEPT {return __end_;}
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY
void clear() _NOEXCEPT void clear() _NOEXCEPT
{__destruct_at_end(__begin_);} {__destruct_at_end(__begin_);}
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY size_type size() const {return static_cast<size_type>(__end_ - __begin_);} _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY size_type size() const {return static_cast<size_type>(__end_ - __begin_);}
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY bool empty() const {return __end_ == __begin_;} _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY bool empty() const {return __end_ == __begin_;}
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY size_type capacity() const {return static_cast<size_type>(__end_cap() - __first_);} _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY size_type capacity() const {return static_cast<size_type>(__end_cap() - __first_);}
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY size_type __front_spare() const {return static_cast<size_type>(__begin_ - __first_);} _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY size_type __front_spare() const {return static_cast<size_type>(__begin_ - __first_);}
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY size_type __back_spare() const {return static_cast<size_type>(__end_cap() - __end_);} _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY size_type __back_spare() const {return static_cast<size_type>(__end_cap() - __end_);}
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY reference front() {return *__begin_;} _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY reference front() {return *__begin_;}
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY const_reference front() const {return *__begin_;} _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY const_reference front() const {return *__begin_;}
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY reference back() {return *(__end_ - 1);} _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY reference back() {return *(__end_ - 1);}
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY const_reference back() const {return *(__end_ - 1);} _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY const_reference back() const {return *(__end_ - 1);}
_LIBCPP_CONSTEXPR_AFTER_CXX17 void reserve(size_type __n); _LIBCPP_CONSTEXPR_CXX20 void reserve(size_type __n);
_LIBCPP_CONSTEXPR_AFTER_CXX17 void shrink_to_fit() _NOEXCEPT; _LIBCPP_CONSTEXPR_CXX20 void shrink_to_fit() _NOEXCEPT;
_LIBCPP_CONSTEXPR_AFTER_CXX17 void push_front(const_reference __x); _LIBCPP_CONSTEXPR_CXX20 void push_front(const_reference __x);
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY void push_back(const_reference __x); _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY void push_back(const_reference __x);
_LIBCPP_CONSTEXPR_AFTER_CXX17 void push_front(value_type&& __x); _LIBCPP_CONSTEXPR_CXX20 void push_front(value_type&& __x);
_LIBCPP_CONSTEXPR_AFTER_CXX17 void push_back(value_type&& __x); _LIBCPP_CONSTEXPR_CXX20 void push_back(value_type&& __x);
template <class... _Args> template <class... _Args>
_LIBCPP_CONSTEXPR_AFTER_CXX17 void emplace_back(_Args&&... __args); _LIBCPP_CONSTEXPR_CXX20 void emplace_back(_Args&&... __args);
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY void pop_front() {__destruct_at_begin(__begin_+1);} _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY void pop_front() {__destruct_at_begin(__begin_+1);}
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY void pop_back() {__destruct_at_end(__end_-1);} _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY void pop_back() {__destruct_at_end(__end_-1);}
_LIBCPP_CONSTEXPR_AFTER_CXX17 void __construct_at_end(size_type __n); _LIBCPP_CONSTEXPR_CXX20 void __construct_at_end(size_type __n);
_LIBCPP_CONSTEXPR_AFTER_CXX17 void __construct_at_end(size_type __n, const_reference __x); _LIBCPP_CONSTEXPR_CXX20 void __construct_at_end(size_type __n, const_reference __x);
template <class _InputIter> template <class _InputIter>
_LIBCPP_CONSTEXPR_AFTER_CXX17 __enable_if_t<__is_exactly_cpp17_input_iterator<_InputIter>::value> _LIBCPP_CONSTEXPR_CXX20 __enable_if_t<__is_exactly_cpp17_input_iterator<_InputIter>::value>
__construct_at_end(_InputIter __first, _InputIter __last); __construct_at_end(_InputIter __first, _InputIter __last);
template <class _ForwardIterator> template <class _ForwardIterator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 __enable_if_t<__is_cpp17_forward_iterator<_ForwardIterator>::value> _LIBCPP_CONSTEXPR_CXX20 __enable_if_t<__is_cpp17_forward_iterator<_ForwardIterator>::value>
__construct_at_end(_ForwardIterator __first, _ForwardIterator __last); __construct_at_end(_ForwardIterator __first, _ForwardIterator __last);
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY void __destruct_at_begin(pointer __new_begin) _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY void __destruct_at_begin(pointer __new_begin)
{__destruct_at_begin(__new_begin, is_trivially_destructible<value_type>());} {__destruct_at_begin(__new_begin, is_trivially_destructible<value_type>());}
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY
void __destruct_at_begin(pointer __new_begin, false_type); void __destruct_at_begin(pointer __new_begin, false_type);
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY
void __destruct_at_begin(pointer __new_begin, true_type); void __destruct_at_begin(pointer __new_begin, true_type);
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY
void __destruct_at_end(pointer __new_last) _NOEXCEPT void __destruct_at_end(pointer __new_last) _NOEXCEPT
{__destruct_at_end(__new_last, false_type());} {__destruct_at_end(__new_last, false_type());}
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY
void __destruct_at_end(pointer __new_last, false_type) _NOEXCEPT; void __destruct_at_end(pointer __new_last, false_type) _NOEXCEPT;
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY
void __destruct_at_end(pointer __new_last, true_type) _NOEXCEPT; void __destruct_at_end(pointer __new_last, true_type) _NOEXCEPT;
_LIBCPP_CONSTEXPR_AFTER_CXX17 void swap(__split_buffer& __x) _LIBCPP_CONSTEXPR_CXX20 void swap(__split_buffer& __x)
_NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value|| _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value||
__is_nothrow_swappable<__alloc_rr>::value); __is_nothrow_swappable<__alloc_rr>::value);
_LIBCPP_CONSTEXPR_AFTER_CXX17 bool __invariants() const; _LIBCPP_CONSTEXPR_CXX20 bool __invariants() const;
private: private:
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY
void __move_assign_alloc(__split_buffer& __c, true_type) void __move_assign_alloc(__split_buffer& __c, true_type)
_NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value) _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value)
{ {
__alloc() = _VSTD::move(__c.__alloc()); __alloc() = _VSTD::move(__c.__alloc());
} }
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY
void __move_assign_alloc(__split_buffer&, false_type) _NOEXCEPT void __move_assign_alloc(__split_buffer&, false_type) _NOEXCEPT
{} {}
struct _ConstructTransaction { struct _ConstructTransaction {
_LIBCPP_CONSTEXPR_AFTER_CXX17 explicit _ConstructTransaction(pointer* __p, size_type __n) _NOEXCEPT _LIBCPP_CONSTEXPR_CXX20 explicit _ConstructTransaction(pointer* __p, size_type __n) _NOEXCEPT
: __pos_(*__p), __end_(*__p + __n), __dest_(__p) { : __pos_(*__p), __end_(*__p + __n), __dest_(__p) {
} }
_LIBCPP_CONSTEXPR_AFTER_CXX17 ~_ConstructTransaction() { _LIBCPP_CONSTEXPR_CXX20 ~_ConstructTransaction() {
*__dest_ = __pos_; *__dest_ = __pos_;
} }
pointer __pos_; pointer __pos_;
const pointer __end_; const pointer __end_;
private: private:
pointer *__dest_; pointer *__dest_;
}; };
}; };
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
bool bool
__split_buffer<_Tp, _Allocator>::__invariants() const __split_buffer<_Tp, _Allocator>::__invariants() const
{ {
if (__first_ == nullptr) if (__first_ == nullptr)
{ {
if (__begin_ != nullptr) if (__begin_ != nullptr)
return false; return false;
if (__end_ != nullptr) if (__end_ != nullptr)
Show All 14 Lines
} }
// Default constructs __n objects starting at __end_ // Default constructs __n objects starting at __end_
// throws if construction throws // throws if construction throws
// Precondition: __n > 0 // Precondition: __n > 0
// Precondition: size() + __n <= capacity() // Precondition: size() + __n <= capacity()
// Postcondition: size() == size() + __n // Postcondition: size() == size() + __n
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
void void
__split_buffer<_Tp, _Allocator>::__construct_at_end(size_type __n) __split_buffer<_Tp, _Allocator>::__construct_at_end(size_type __n)
{ {
_ConstructTransaction __tx(&this->__end_, __n); _ConstructTransaction __tx(&this->__end_, __n);
for (; __tx.__pos_ != __tx.__end_; ++__tx.__pos_) { for (; __tx.__pos_ != __tx.__end_; ++__tx.__pos_) {
__alloc_traits::construct(this->__alloc(), _VSTD::__to_address(__tx.__pos_)); __alloc_traits::construct(this->__alloc(), _VSTD::__to_address(__tx.__pos_));
} }
} }
// Copy constructs __n objects starting at __end_ from __x // Copy constructs __n objects starting at __end_ from __x
// throws if construction throws // throws if construction throws
// Precondition: __n > 0 // Precondition: __n > 0
// Precondition: size() + __n <= capacity() // Precondition: size() + __n <= capacity()
// Postcondition: size() == old size() + __n // Postcondition: size() == old size() + __n
// Postcondition: [i] == __x for all i in [size() - __n, __n) // Postcondition: [i] == __x for all i in [size() - __n, __n)
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
void void
__split_buffer<_Tp, _Allocator>::__construct_at_end(size_type __n, const_reference __x) __split_buffer<_Tp, _Allocator>::__construct_at_end(size_type __n, const_reference __x)
{ {
_ConstructTransaction __tx(&this->__end_, __n); _ConstructTransaction __tx(&this->__end_, __n);
for (; __tx.__pos_ != __tx.__end_; ++__tx.__pos_) { for (; __tx.__pos_ != __tx.__end_; ++__tx.__pos_) {
__alloc_traits::construct(this->__alloc(), __alloc_traits::construct(this->__alloc(),
_VSTD::__to_address(__tx.__pos_), __x); _VSTD::__to_address(__tx.__pos_), __x);
} }
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
template <class _InputIter> template <class _InputIter>
_LIBCPP_CONSTEXPR_AFTER_CXX17 __enable_if_t<__is_exactly_cpp17_input_iterator<_InputIter>::value> _LIBCPP_CONSTEXPR_CXX20 __enable_if_t<__is_exactly_cpp17_input_iterator<_InputIter>::value>
__split_buffer<_Tp, _Allocator>::__construct_at_end(_InputIter __first, _InputIter __last) __split_buffer<_Tp, _Allocator>::__construct_at_end(_InputIter __first, _InputIter __last)
{ {
__alloc_rr& __a = this->__alloc(); __alloc_rr& __a = this->__alloc();
for (; __first != __last; ++__first) for (; __first != __last; ++__first)
{ {
if (__end_ == __end_cap()) if (__end_ == __end_cap())
{ {
size_type __old_cap = __end_cap() - __first_; size_type __old_cap = __end_cap() - __first_;
size_type __new_cap = _VSTD::max<size_type>(2 * __old_cap, 8); size_type __new_cap = _VSTD::max<size_type>(2 * __old_cap, 8);
__split_buffer __buf(__new_cap, 0, __a); __split_buffer __buf(__new_cap, 0, __a);
for (pointer __p = __begin_; __p != __end_; ++__p, (void) ++__buf.__end_) for (pointer __p = __begin_; __p != __end_; ++__p, (void) ++__buf.__end_)
__alloc_traits::construct(__buf.__alloc(), __alloc_traits::construct(__buf.__alloc(),
_VSTD::__to_address(__buf.__end_), _VSTD::move(*__p)); _VSTD::__to_address(__buf.__end_), _VSTD::move(*__p));
swap(__buf); swap(__buf);
} }
__alloc_traits::construct(__a, _VSTD::__to_address(this->__end_), *__first); __alloc_traits::construct(__a, _VSTD::__to_address(this->__end_), *__first);
++this->__end_; ++this->__end_;
} }
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
template <class _ForwardIterator> template <class _ForwardIterator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 __enable_if_t<__is_cpp17_forward_iterator<_ForwardIterator>::value> _LIBCPP_CONSTEXPR_CXX20 __enable_if_t<__is_cpp17_forward_iterator<_ForwardIterator>::value>
__split_buffer<_Tp, _Allocator>::__construct_at_end(_ForwardIterator __first, _ForwardIterator __last) __split_buffer<_Tp, _Allocator>::__construct_at_end(_ForwardIterator __first, _ForwardIterator __last)
{ {
_ConstructTransaction __tx(&this->__end_, _VSTD::distance(__first, __last)); _ConstructTransaction __tx(&this->__end_, _VSTD::distance(__first, __last));
for (; __tx.__pos_ != __tx.__end_; ++__tx.__pos_, (void) ++__first) { for (; __tx.__pos_ != __tx.__end_; ++__tx.__pos_, (void) ++__first) {
__alloc_traits::construct(this->__alloc(), __alloc_traits::construct(this->__alloc(),
_VSTD::__to_address(__tx.__pos_), *__first); _VSTD::__to_address(__tx.__pos_), *__first);
} }
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
inline inline
void void
__split_buffer<_Tp, _Allocator>::__destruct_at_begin(pointer __new_begin, false_type) __split_buffer<_Tp, _Allocator>::__destruct_at_begin(pointer __new_begin, false_type)
{ {
while (__begin_ != __new_begin) while (__begin_ != __new_begin)
__alloc_traits::destroy(__alloc(), _VSTD::__to_address(__begin_++)); __alloc_traits::destroy(__alloc(), _VSTD::__to_address(__begin_++));
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
inline inline
void void
__split_buffer<_Tp, _Allocator>::__destruct_at_begin(pointer __new_begin, true_type) __split_buffer<_Tp, _Allocator>::__destruct_at_begin(pointer __new_begin, true_type)
{ {
__begin_ = __new_begin; __begin_ = __new_begin;
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
void void
__split_buffer<_Tp, _Allocator>::__destruct_at_end(pointer __new_last, false_type) _NOEXCEPT __split_buffer<_Tp, _Allocator>::__destruct_at_end(pointer __new_last, false_type) _NOEXCEPT
{ {
while (__new_last != __end_) while (__new_last != __end_)
__alloc_traits::destroy(__alloc(), _VSTD::__to_address(--__end_)); __alloc_traits::destroy(__alloc(), _VSTD::__to_address(--__end_));
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
void void
__split_buffer<_Tp, _Allocator>::__destruct_at_end(pointer __new_last, true_type) _NOEXCEPT __split_buffer<_Tp, _Allocator>::__destruct_at_end(pointer __new_last, true_type) _NOEXCEPT
{ {
__end_ = __new_last; __end_ = __new_last;
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
__split_buffer<_Tp, _Allocator>::__split_buffer(size_type __cap, size_type __start, __alloc_rr& __a) __split_buffer<_Tp, _Allocator>::__split_buffer(size_type __cap, size_type __start, __alloc_rr& __a)
: __end_cap_(nullptr, __a) : __end_cap_(nullptr, __a)
{ {
if (__cap == 0) { if (__cap == 0) {
__first_ = nullptr; __first_ = nullptr;
} else { } else {
auto __allocation = std::__allocate_at_least(__alloc(), __cap); auto __allocation = std::__allocate_at_least(__alloc(), __cap);
__first_ = __allocation.ptr; __first_ = __allocation.ptr;
__cap = __allocation.count; __cap = __allocation.count;
} }
__begin_ = __end_ = __first_ + __start; __begin_ = __end_ = __first_ + __start;
__end_cap() = __first_ + __cap; __end_cap() = __first_ + __cap;
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
inline inline
__split_buffer<_Tp, _Allocator>::__split_buffer() __split_buffer<_Tp, _Allocator>::__split_buffer()
_NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value) _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value)
: __first_(nullptr), __begin_(nullptr), __end_(nullptr), __end_cap_(nullptr, __default_init_tag()) : __first_(nullptr), __begin_(nullptr), __end_(nullptr), __end_cap_(nullptr, __default_init_tag())
{ {
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
inline inline
__split_buffer<_Tp, _Allocator>::__split_buffer(__alloc_rr& __a) __split_buffer<_Tp, _Allocator>::__split_buffer(__alloc_rr& __a)
: __first_(nullptr), __begin_(nullptr), __end_(nullptr), __end_cap_(nullptr, __a) : __first_(nullptr), __begin_(nullptr), __end_(nullptr), __end_cap_(nullptr, __a)
{ {
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
inline inline
__split_buffer<_Tp, _Allocator>::__split_buffer(const __alloc_rr& __a) __split_buffer<_Tp, _Allocator>::__split_buffer(const __alloc_rr& __a)
: __first_(nullptr), __begin_(nullptr), __end_(nullptr), __end_cap_(nullptr, __a) : __first_(nullptr), __begin_(nullptr), __end_(nullptr), __end_cap_(nullptr, __a)
{ {
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
__split_buffer<_Tp, _Allocator>::~__split_buffer() __split_buffer<_Tp, _Allocator>::~__split_buffer()
{ {
clear(); clear();
if (__first_) if (__first_)
__alloc_traits::deallocate(__alloc(), __first_, capacity()); __alloc_traits::deallocate(__alloc(), __first_, capacity());
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
__split_buffer<_Tp, _Allocator>::__split_buffer(__split_buffer&& __c) __split_buffer<_Tp, _Allocator>::__split_buffer(__split_buffer&& __c)
_NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value) _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value)
: __first_(_VSTD::move(__c.__first_)), : __first_(_VSTD::move(__c.__first_)),
__begin_(_VSTD::move(__c.__begin_)), __begin_(_VSTD::move(__c.__begin_)),
__end_(_VSTD::move(__c.__end_)), __end_(_VSTD::move(__c.__end_)),
__end_cap_(_VSTD::move(__c.__end_cap_)) __end_cap_(_VSTD::move(__c.__end_cap_))
{ {
__c.__first_ = nullptr; __c.__first_ = nullptr;
__c.__begin_ = nullptr; __c.__begin_ = nullptr;
__c.__end_ = nullptr; __c.__end_ = nullptr;
__c.__end_cap() = nullptr; __c.__end_cap() = nullptr;
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
__split_buffer<_Tp, _Allocator>::__split_buffer(__split_buffer&& __c, const __alloc_rr& __a) __split_buffer<_Tp, _Allocator>::__split_buffer(__split_buffer&& __c, const __alloc_rr& __a)
: __end_cap_(nullptr, __a) : __end_cap_(nullptr, __a)
{ {
if (__a == __c.__alloc()) if (__a == __c.__alloc())
{ {
__first_ = __c.__first_; __first_ = __c.__first_;
__begin_ = __c.__begin_; __begin_ = __c.__begin_;
__end_ = __c.__end_; __end_ = __c.__end_;
Show All 10 Lines else
__begin_ = __end_ = __first_; __begin_ = __end_ = __first_;
__end_cap() = __first_ + __allocation.count; __end_cap() = __first_ + __allocation.count;
typedef move_iterator<iterator> _Ip; typedef move_iterator<iterator> _Ip;
__construct_at_end(_Ip(__c.begin()), _Ip(__c.end())); __construct_at_end(_Ip(__c.begin()), _Ip(__c.end()));
} }
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
__split_buffer<_Tp, _Allocator>& __split_buffer<_Tp, _Allocator>&
__split_buffer<_Tp, _Allocator>::operator=(__split_buffer&& __c) __split_buffer<_Tp, _Allocator>::operator=(__split_buffer&& __c)
_NOEXCEPT_((__alloc_traits::propagate_on_container_move_assignment::value && _NOEXCEPT_((__alloc_traits::propagate_on_container_move_assignment::value &&
is_nothrow_move_assignable<allocator_type>::value) || is_nothrow_move_assignable<allocator_type>::value) ||
!__alloc_traits::propagate_on_container_move_assignment::value) !__alloc_traits::propagate_on_container_move_assignment::value)
{ {
clear(); clear();
shrink_to_fit(); shrink_to_fit();
__first_ = __c.__first_; __first_ = __c.__first_;
__begin_ = __c.__begin_; __begin_ = __c.__begin_;
__end_ = __c.__end_; __end_ = __c.__end_;
__end_cap() = __c.__end_cap(); __end_cap() = __c.__end_cap();
__move_assign_alloc(__c, __move_assign_alloc(__c,
integral_constant<bool, integral_constant<bool,
__alloc_traits::propagate_on_container_move_assignment::value>()); __alloc_traits::propagate_on_container_move_assignment::value>());
__c.__first_ = __c.__begin_ = __c.__end_ = __c.__end_cap() = nullptr; __c.__first_ = __c.__begin_ = __c.__end_ = __c.__end_cap() = nullptr;
return *this; return *this;
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
void void
__split_buffer<_Tp, _Allocator>::swap(__split_buffer& __x) __split_buffer<_Tp, _Allocator>::swap(__split_buffer& __x)
_NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value|| _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value||
__is_nothrow_swappable<__alloc_rr>::value) __is_nothrow_swappable<__alloc_rr>::value)
{ {
_VSTD::swap(__first_, __x.__first_); _VSTD::swap(__first_, __x.__first_);
_VSTD::swap(__begin_, __x.__begin_); _VSTD::swap(__begin_, __x.__begin_);
_VSTD::swap(__end_, __x.__end_); _VSTD::swap(__end_, __x.__end_);
_VSTD::swap(__end_cap(), __x.__end_cap()); _VSTD::swap(__end_cap(), __x.__end_cap());
_VSTD::__swap_allocator(__alloc(), __x.__alloc()); _VSTD::__swap_allocator(__alloc(), __x.__alloc());
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
void void
__split_buffer<_Tp, _Allocator>::reserve(size_type __n) __split_buffer<_Tp, _Allocator>::reserve(size_type __n)
{ {
if (__n < capacity()) if (__n < capacity())
{ {
__split_buffer<value_type, __alloc_rr&> __t(__n, 0, __alloc()); __split_buffer<value_type, __alloc_rr&> __t(__n, 0, __alloc());
__t.__construct_at_end(move_iterator<pointer>(__begin_), __t.__construct_at_end(move_iterator<pointer>(__begin_),
move_iterator<pointer>(__end_)); move_iterator<pointer>(__end_));
_VSTD::swap(__first_, __t.__first_); _VSTD::swap(__first_, __t.__first_);
_VSTD::swap(__begin_, __t.__begin_); _VSTD::swap(__begin_, __t.__begin_);
_VSTD::swap(__end_, __t.__end_); _VSTD::swap(__end_, __t.__end_);
_VSTD::swap(__end_cap(), __t.__end_cap()); _VSTD::swap(__end_cap(), __t.__end_cap());
} }
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
void void
__split_buffer<_Tp, _Allocator>::shrink_to_fit() _NOEXCEPT __split_buffer<_Tp, _Allocator>::shrink_to_fit() _NOEXCEPT
{ {
if (capacity() > size()) if (capacity() > size())
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_NO_EXCEPTIONS
try try
{ {
Show All 11 Lines#ifndef _LIBCPP_NO_EXCEPTIONS
catch (...) catch (...)
{ {
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_NO_EXCEPTIONS
} }
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
void void
__split_buffer<_Tp, _Allocator>::push_front(const_reference __x) __split_buffer<_Tp, _Allocator>::push_front(const_reference __x)
{ {
if (__begin_ == __first_) if (__begin_ == __first_)
{ {
if (__end_ < __end_cap()) if (__end_ < __end_cap())
{ {
difference_type __d = __end_cap() - __end_; difference_type __d = __end_cap() - __end_;
Show All 13 Lines if (__begin_ == __first_)
_VSTD::swap(__end_cap(), __t.__end_cap()); _VSTD::swap(__end_cap(), __t.__end_cap());
} }
} }
__alloc_traits::construct(__alloc(), _VSTD::__to_address(__begin_-1), __x); __alloc_traits::construct(__alloc(), _VSTD::__to_address(__begin_-1), __x);
--__begin_; --__begin_;
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
void void
__split_buffer<_Tp, _Allocator>::push_front(value_type&& __x) __split_buffer<_Tp, _Allocator>::push_front(value_type&& __x)
{ {
if (__begin_ == __first_) if (__begin_ == __first_)
{ {
if (__end_ < __end_cap()) if (__end_ < __end_cap())
{ {
difference_type __d = __end_cap() - __end_; difference_type __d = __end_cap() - __end_;
Show All 14 Lines if (__begin_ == __first_)
} }
} }
__alloc_traits::construct(__alloc(), _VSTD::__to_address(__begin_-1), __alloc_traits::construct(__alloc(), _VSTD::__to_address(__begin_-1),
_VSTD::move(__x)); _VSTD::move(__x));
--__begin_; --__begin_;
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
void void
__split_buffer<_Tp, _Allocator>::push_back(const_reference __x) __split_buffer<_Tp, _Allocator>::push_back(const_reference __x)
{ {
if (__end_ == __end_cap()) if (__end_ == __end_cap())
{ {
if (__begin_ > __first_) if (__begin_ > __first_)
{ {
Show All 14 Lines if (__end_ == __end_cap())
_VSTD::swap(__end_cap(), __t.__end_cap()); _VSTD::swap(__end_cap(), __t.__end_cap());
} }
} }
__alloc_traits::construct(__alloc(), _VSTD::__to_address(__end_), __x); __alloc_traits::construct(__alloc(), _VSTD::__to_address(__end_), __x);
++__end_; ++__end_;
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
void void
__split_buffer<_Tp, _Allocator>::push_back(value_type&& __x) __split_buffer<_Tp, _Allocator>::push_back(value_type&& __x)
{ {
if (__end_ == __end_cap()) if (__end_ == __end_cap())
{ {
if (__begin_ > __first_) if (__begin_ > __first_)
{ {
difference_type __d = __begin_ - __first_; difference_type __d = __begin_ - __first_;
Show All 15 Lines__split_buffer<_Tp, _Allocator>::push_back(value_type&& __x)
} }
__alloc_traits::construct(__alloc(), _VSTD::__to_address(__end_), __alloc_traits::construct(__alloc(), _VSTD::__to_address(__end_),
_VSTD::move(__x)); _VSTD::move(__x));
++__end_; ++__end_;
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
template <class... _Args> template <class... _Args>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
void void
__split_buffer<_Tp, _Allocator>::emplace_back(_Args&&... __args) __split_buffer<_Tp, _Allocator>::emplace_back(_Args&&... __args)
{ {
if (__end_ == __end_cap()) if (__end_ == __end_cap())
{ {
if (__begin_ > __first_) if (__begin_ > __first_)
{ {
difference_type __d = __begin_ - __first_; difference_type __d = __begin_ - __first_;
Show All 14 Lines if (__end_ == __end_cap())
} }
} }
__alloc_traits::construct(__alloc(), _VSTD::__to_address(__end_), __alloc_traits::construct(__alloc(), _VSTD::__to_address(__end_),
_VSTD::forward<_Args>(__args)...); _VSTD::forward<_Args>(__args)...);
++__end_; ++__end_;
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
void void
swap(__split_buffer<_Tp, _Allocator>& __x, __split_buffer<_Tp, _Allocator>& __y) swap(__split_buffer<_Tp, _Allocator>& __x, __split_buffer<_Tp, _Allocator>& __y)
_NOEXCEPT_(_NOEXCEPT_(__x.swap(__y))) _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
{ {
__x.swap(__y); __x.swap(__y);
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
_LIBCPP_POP_MACROS _LIBCPP_POP_MACROS
#endif // _LIBCPP___SPLIT_BUFFER #endif // _LIBCPP___SPLIT_BUFFER

libcxx/include/__string/char_traits.h

Show All 40 Lines
struct _LIBCPP_TEMPLATE_VIS char_traits struct _LIBCPP_TEMPLATE_VIS char_traits
{ {
typedef _CharT char_type; typedef _CharT char_type;
typedef int int_type; typedef int int_type;
typedef streamoff off_type; typedef streamoff off_type;
typedef streampos pos_type; typedef streampos pos_type;
typedef mbstate_t state_type; typedef mbstate_t state_type;
static inline void _LIBCPP_CONSTEXPR_AFTER_CXX14 static inline void _LIBCPP_CONSTEXPR_CXX17
assign(char_type& __c1, const char_type& __c2) _NOEXCEPT {__c1 = __c2;} assign(char_type& __c1, const char_type& __c2) _NOEXCEPT {__c1 = __c2;}
static inline _LIBCPP_CONSTEXPR bool eq(char_type __c1, char_type __c2) _NOEXCEPT static inline _LIBCPP_CONSTEXPR bool eq(char_type __c1, char_type __c2) _NOEXCEPT
{return __c1 == __c2;} {return __c1 == __c2;}
static inline _LIBCPP_CONSTEXPR bool lt(char_type __c1, char_type __c2) _NOEXCEPT static inline _LIBCPP_CONSTEXPR bool lt(char_type __c1, char_type __c2) _NOEXCEPT
{return __c1 < __c2;} {return __c1 < __c2;}
static _LIBCPP_CONSTEXPR_AFTER_CXX14 static _LIBCPP_CONSTEXPR_CXX17
int compare(const char_type* __s1, const char_type* __s2, size_t __n); int compare(const char_type* __s1, const char_type* __s2, size_t __n);
_LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR_CXX17
size_t length(const char_type* __s); size_t length(const char_type* __s);
_LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR_CXX17
const char_type* find(const char_type* __s, size_t __n, const char_type& __a); const char_type* find(const char_type* __s, size_t __n, const char_type& __a);
static _LIBCPP_CONSTEXPR_AFTER_CXX17 static _LIBCPP_CONSTEXPR_CXX20
char_type* move(char_type* __s1, const char_type* __s2, size_t __n); char_type* move(char_type* __s1, const char_type* __s2, size_t __n);
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
static _LIBCPP_CONSTEXPR_AFTER_CXX17 static _LIBCPP_CONSTEXPR_CXX20
char_type* copy(char_type* __s1, const char_type* __s2, size_t __n); char_type* copy(char_type* __s1, const char_type* __s2, size_t __n);
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
static _LIBCPP_CONSTEXPR_AFTER_CXX17 static _LIBCPP_CONSTEXPR_CXX20
char_type* assign(char_type* __s, size_t __n, char_type __a); char_type* assign(char_type* __s, size_t __n, char_type __a);
static inline _LIBCPP_CONSTEXPR int_type not_eof(int_type __c) _NOEXCEPT static inline _LIBCPP_CONSTEXPR int_type not_eof(int_type __c) _NOEXCEPT
{return eq_int_type(__c, eof()) ? ~eof() : __c;} {return eq_int_type(__c, eof()) ? ~eof() : __c;}
static inline _LIBCPP_CONSTEXPR char_type to_char_type(int_type __c) _NOEXCEPT static inline _LIBCPP_CONSTEXPR char_type to_char_type(int_type __c) _NOEXCEPT
{return char_type(__c);} {return char_type(__c);}
static inline _LIBCPP_CONSTEXPR int_type to_int_type(char_type __c) _NOEXCEPT static inline _LIBCPP_CONSTEXPR int_type to_int_type(char_type __c) _NOEXCEPT
{return int_type(__c);} {return int_type(__c);}
static inline _LIBCPP_CONSTEXPR bool eq_int_type(int_type __c1, int_type __c2) _NOEXCEPT static inline _LIBCPP_CONSTEXPR bool eq_int_type(int_type __c1, int_type __c2) _NOEXCEPT
{return __c1 == __c2;} {return __c1 == __c2;}
static inline _LIBCPP_CONSTEXPR int_type eof() _NOEXCEPT static inline _LIBCPP_CONSTEXPR int_type eof() _NOEXCEPT
{return int_type(EOF);} {return int_type(EOF);}
}; };
template <class _CharT> template <class _CharT>
_LIBCPP_CONSTEXPR_AFTER_CXX14 int _LIBCPP_CONSTEXPR_CXX17 int
char_traits<_CharT>::compare(const char_type* __s1, const char_type* __s2, size_t __n) char_traits<_CharT>::compare(const char_type* __s1, const char_type* __s2, size_t __n)
{ {
for (; __n; --__n, ++__s1, ++__s2) for (; __n; --__n, ++__s1, ++__s2)
{ {
if (lt(*__s1, *__s2)) if (lt(*__s1, *__s2))
return -1; return -1;
if (lt(*__s2, *__s1)) if (lt(*__s2, *__s1))
return 1; return 1;
} }
return 0; return 0;
} }
template <class _CharT> template <class _CharT>
inline inline
_LIBCPP_CONSTEXPR_AFTER_CXX14 size_t _LIBCPP_CONSTEXPR_CXX17 size_t
char_traits<_CharT>::length(const char_type* __s) char_traits<_CharT>::length(const char_type* __s)
{ {
size_t __len = 0; size_t __len = 0;
for (; !eq(*__s, char_type(0)); ++__s) for (; !eq(*__s, char_type(0)); ++__s)
++__len; ++__len;
return __len; return __len;
} }
template <class _CharT> template <class _CharT>
inline inline
_LIBCPP_CONSTEXPR_AFTER_CXX14 const _CharT* _LIBCPP_CONSTEXPR_CXX17 const _CharT*
char_traits<_CharT>::find(const char_type* __s, size_t __n, const char_type& __a) char_traits<_CharT>::find(const char_type* __s, size_t __n, const char_type& __a)
{ {
for (; __n; --__n) for (; __n; --__n)
{ {
if (eq(*__s, __a)) if (eq(*__s, __a))
return __s; return __s;
++__s; ++__s;
} }
return nullptr; return nullptr;
} }
template <class _CharT> template <class _CharT>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _CharT* _LIBCPP_CONSTEXPR_CXX20 _CharT*
char_traits<_CharT>::move(char_type* __s1, const char_type* __s2, size_t __n) char_traits<_CharT>::move(char_type* __s1, const char_type* __s2, size_t __n)
{ {
if (__n == 0) return __s1; if (__n == 0) return __s1;
char_type* __r = __s1; char_type* __r = __s1;
if (__s1 < __s2) if (__s1 < __s2)
{ {
for (; __n; --__n, ++__s1, ++__s2) for (; __n; --__n, ++__s1, ++__s2)
assign(*__s1, *__s2); assign(*__s1, *__s2);
} }
else if (__s2 < __s1) else if (__s2 < __s1)
{ {
__s1 += __n; __s1 += __n;
__s2 += __n; __s2 += __n;
for (; __n; --__n) for (; __n; --__n)
assign(*--__s1, *--__s2); assign(*--__s1, *--__s2);
} }
return __r; return __r;
} }
template <class _CharT> template <class _CharT>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_CONSTEXPR_CXX20
_CharT* _CharT*
char_traits<_CharT>::copy(char_type* __s1, const char_type* __s2, size_t __n) char_traits<_CharT>::copy(char_type* __s1, const char_type* __s2, size_t __n)
{ {
if (!__libcpp_is_constant_evaluated()) { if (!__libcpp_is_constant_evaluated()) {
_LIBCPP_ASSERT(__s2 < __s1 || __s2 >= __s1+__n, "char_traits::copy overlapped range"); _LIBCPP_ASSERT(__s2 < __s1 || __s2 >= __s1+__n, "char_traits::copy overlapped range");
} }
char_type* __r = __s1; char_type* __r = __s1;
for (; __n; --__n, ++__s1, ++__s2) for (; __n; --__n, ++__s1, ++__s2)
assign(*__s1, *__s2); assign(*__s1, *__s2);
return __r; return __r;
} }
template <class _CharT> template <class _CharT>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_CONSTEXPR_CXX20
_CharT* _CharT*
char_traits<_CharT>::assign(char_type* __s, size_t __n, char_type __a) char_traits<_CharT>::assign(char_type* __s, size_t __n, char_type __a)
{ {
char_type* __r = __s; char_type* __r = __s;
for (; __n; --__n, ++__s) for (; __n; --__n, ++__s)
assign(*__s, __a); assign(*__s, __a);
return __r; return __r;
} }
template <class _CharT> template <class _CharT>
static inline _LIBCPP_CONSTEXPR_AFTER_CXX17 static inline _LIBCPP_CONSTEXPR_CXX20
_CharT* __char_traits_move(_CharT* __dest, const _CharT* __source, size_t __n) _NOEXCEPT _CharT* __char_traits_move(_CharT* __dest, const _CharT* __source, size_t __n) _NOEXCEPT
{ {
#ifdef _LIBCPP_COMPILER_GCC #ifdef _LIBCPP_COMPILER_GCC
if (__libcpp_is_constant_evaluated()) { if (__libcpp_is_constant_evaluated()) {
if (__n == 0) if (__n == 0)
return __dest; return __dest;
_CharT* __allocation = new _CharT[__n]; _CharT* __allocation = new _CharT[__n];
std::copy_n(__source, __n, __allocation); std::copy_n(__source, __n, __allocation);
Show All 15 Linesstruct _LIBCPP_TEMPLATE_VIS char_traits<char>
typedef int int_type; typedef int int_type;
typedef streamoff off_type; typedef streamoff off_type;
typedef streampos pos_type; typedef streampos pos_type;
typedef mbstate_t state_type; typedef mbstate_t state_type;
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER > 17
using comparison_category = strong_ordering; using comparison_category = strong_ordering;
#endif #endif
static inline _LIBCPP_CONSTEXPR_AFTER_CXX14 static inline _LIBCPP_CONSTEXPR_CXX17
void assign(char_type& __c1, const char_type& __c2) _NOEXCEPT {__c1 = __c2;} void assign(char_type& __c1, const char_type& __c2) _NOEXCEPT {__c1 = __c2;}
static inline _LIBCPP_CONSTEXPR bool eq(char_type __c1, char_type __c2) _NOEXCEPT static inline _LIBCPP_CONSTEXPR bool eq(char_type __c1, char_type __c2) _NOEXCEPT
{return __c1 == __c2;} {return __c1 == __c2;}
static inline _LIBCPP_CONSTEXPR bool lt(char_type __c1, char_type __c2) _NOEXCEPT static inline _LIBCPP_CONSTEXPR bool lt(char_type __c1, char_type __c2) _NOEXCEPT
{return (unsigned char)__c1 < (unsigned char)__c2;} {return (unsigned char)__c1 < (unsigned char)__c2;}
static _LIBCPP_CONSTEXPR_AFTER_CXX14 static _LIBCPP_CONSTEXPR_CXX17
int compare(const char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT; int compare(const char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT;
static inline size_t _LIBCPP_CONSTEXPR_AFTER_CXX14 length(const char_type* __s) _NOEXCEPT { static inline size_t _LIBCPP_CONSTEXPR_CXX17 length(const char_type* __s) _NOEXCEPT {
// GCC currently does not support __builtin_strlen during constant evaluation. // GCC currently does not support __builtin_strlen during constant evaluation.
// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=70816 // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=70816
#ifdef _LIBCPP_COMPILER_GCC #ifdef _LIBCPP_COMPILER_GCC
if (__libcpp_is_constant_evaluated()) { if (__libcpp_is_constant_evaluated()) {
size_t __i = 0; size_t __i = 0;
for (; __s[__i] != char_type('\0'); ++__i) for (; __s[__i] != char_type('\0'); ++__i)
; ;
return __i; return __i;
} }
#endif #endif
return __builtin_strlen(__s); return __builtin_strlen(__s);
} }
static _LIBCPP_CONSTEXPR_AFTER_CXX14 static _LIBCPP_CONSTEXPR_CXX17
const char_type* find(const char_type* __s, size_t __n, const char_type& __a) _NOEXCEPT; const char_type* find(const char_type* __s, size_t __n, const char_type& __a) _NOEXCEPT;
static inline _LIBCPP_CONSTEXPR_AFTER_CXX17 static inline _LIBCPP_CONSTEXPR_CXX20
char_type* move(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT { char_type* move(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT {
return std::__char_traits_move(__s1, __s2, __n); return std::__char_traits_move(__s1, __s2, __n);
} }
static inline _LIBCPP_CONSTEXPR_AFTER_CXX17 static inline _LIBCPP_CONSTEXPR_CXX20
char_type* copy(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT { char_type* copy(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT {
if (!__libcpp_is_constant_evaluated()) if (!__libcpp_is_constant_evaluated())
_LIBCPP_ASSERT(__s2 < __s1 || __s2 >= __s1+__n, "char_traits::copy overlapped range"); _LIBCPP_ASSERT(__s2 < __s1 || __s2 >= __s1+__n, "char_traits::copy overlapped range");
std::copy_n(__s2, __n, __s1); std::copy_n(__s2, __n, __s1);
return __s1; return __s1;
} }
static inline _LIBCPP_CONSTEXPR_AFTER_CXX17 static inline _LIBCPP_CONSTEXPR_CXX20
char_type* assign(char_type* __s, size_t __n, char_type __a) _NOEXCEPT { char_type* assign(char_type* __s, size_t __n, char_type __a) _NOEXCEPT {
std::fill_n(__s, __n, __a); std::fill_n(__s, __n, __a);
return __s; return __s;
} }
static inline _LIBCPP_CONSTEXPR int_type not_eof(int_type __c) _NOEXCEPT static inline _LIBCPP_CONSTEXPR int_type not_eof(int_type __c) _NOEXCEPT
{return eq_int_type(__c, eof()) ? ~eof() : __c;} {return eq_int_type(__c, eof()) ? ~eof() : __c;}
static inline _LIBCPP_CONSTEXPR char_type to_char_type(int_type __c) _NOEXCEPT static inline _LIBCPP_CONSTEXPR char_type to_char_type(int_type __c) _NOEXCEPT
{return char_type(__c);} {return char_type(__c);}
static inline _LIBCPP_CONSTEXPR int_type to_int_type(char_type __c) _NOEXCEPT static inline _LIBCPP_CONSTEXPR int_type to_int_type(char_type __c) _NOEXCEPT
{return int_type((unsigned char)__c);} {return int_type((unsigned char)__c);}
static inline _LIBCPP_CONSTEXPR bool eq_int_type(int_type __c1, int_type __c2) _NOEXCEPT static inline _LIBCPP_CONSTEXPR bool eq_int_type(int_type __c1, int_type __c2) _NOEXCEPT
{return __c1 == __c2;} {return __c1 == __c2;}
static inline _LIBCPP_CONSTEXPR int_type eof() _NOEXCEPT static inline _LIBCPP_CONSTEXPR int_type eof() _NOEXCEPT
{return int_type(EOF);} {return int_type(EOF);}
}; };
inline _LIBCPP_CONSTEXPR_AFTER_CXX14 inline _LIBCPP_CONSTEXPR_CXX17
int int
char_traits<char>::compare(const char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT char_traits<char>::compare(const char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT
{ {
if (__n == 0) if (__n == 0)
return 0; return 0;
#if __has_feature(cxx_constexpr_string_builtins) #if __has_feature(cxx_constexpr_string_builtins)
return __builtin_memcmp(__s1, __s2, __n); return __builtin_memcmp(__s1, __s2, __n);
#elif _LIBCPP_STD_VER <= 14 #elif _LIBCPP_STD_VER <= 14
return _VSTD::memcmp(__s1, __s2, __n); return _VSTD::memcmp(__s1, __s2, __n);
#else #else
for (; __n; --__n, ++__s1, ++__s2) for (; __n; --__n, ++__s1, ++__s2)
{ {
if (lt(*__s1, *__s2)) if (lt(*__s1, *__s2))
return -1; return -1;
if (lt(*__s2, *__s1)) if (lt(*__s2, *__s1))
return 1; return 1;
} }
return 0; return 0;
#endif #endif
} }
inline _LIBCPP_CONSTEXPR_AFTER_CXX14 inline _LIBCPP_CONSTEXPR_CXX17
const char* const char*
char_traits<char>::find(const char_type* __s, size_t __n, const char_type& __a) _NOEXCEPT char_traits<char>::find(const char_type* __s, size_t __n, const char_type& __a) _NOEXCEPT
{ {
if (__n == 0) if (__n == 0)
return nullptr; return nullptr;
#if __has_feature(cxx_constexpr_string_builtins) #if __has_feature(cxx_constexpr_string_builtins)
return __builtin_char_memchr(__s, to_int_type(__a), __n); return __builtin_char_memchr(__s, to_int_type(__a), __n);
#elif _LIBCPP_STD_VER <= 14 #elif _LIBCPP_STD_VER <= 14
Show All 20 Linesstruct _LIBCPP_TEMPLATE_VIS char_traits<wchar_t>
typedef wint_t int_type; typedef wint_t int_type;
typedef streamoff off_type; typedef streamoff off_type;
typedef streampos pos_type; typedef streampos pos_type;
typedef mbstate_t state_type; typedef mbstate_t state_type;
# if _LIBCPP_STD_VER > 17 # if _LIBCPP_STD_VER > 17
using comparison_category = strong_ordering; using comparison_category = strong_ordering;
# endif # endif
static inline _LIBCPP_CONSTEXPR_AFTER_CXX14 static inline _LIBCPP_CONSTEXPR_CXX17
void assign(char_type& __c1, const char_type& __c2) _NOEXCEPT {__c1 = __c2;} void assign(char_type& __c1, const char_type& __c2) _NOEXCEPT {__c1 = __c2;}
static inline _LIBCPP_CONSTEXPR bool eq(char_type __c1, char_type __c2) _NOEXCEPT static inline _LIBCPP_CONSTEXPR bool eq(char_type __c1, char_type __c2) _NOEXCEPT
{return __c1 == __c2;} {return __c1 == __c2;}
static inline _LIBCPP_CONSTEXPR bool lt(char_type __c1, char_type __c2) _NOEXCEPT static inline _LIBCPP_CONSTEXPR bool lt(char_type __c1, char_type __c2) _NOEXCEPT
{return __c1 < __c2;} {return __c1 < __c2;}
static _LIBCPP_CONSTEXPR_AFTER_CXX14 static _LIBCPP_CONSTEXPR_CXX17
int compare(const char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT; int compare(const char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT;
static _LIBCPP_CONSTEXPR_AFTER_CXX14 static _LIBCPP_CONSTEXPR_CXX17
size_t length(const char_type* __s) _NOEXCEPT; size_t length(const char_type* __s) _NOEXCEPT;
static _LIBCPP_CONSTEXPR_AFTER_CXX14 static _LIBCPP_CONSTEXPR_CXX17
const char_type* find(const char_type* __s, size_t __n, const char_type& __a) _NOEXCEPT; const char_type* find(const char_type* __s, size_t __n, const char_type& __a) _NOEXCEPT;
static inline _LIBCPP_CONSTEXPR_AFTER_CXX17 static inline _LIBCPP_CONSTEXPR_CXX20
char_type* move(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT { char_type* move(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT {
return std::__char_traits_move(__s1, __s2, __n); return std::__char_traits_move(__s1, __s2, __n);
} }
static inline _LIBCPP_CONSTEXPR_AFTER_CXX17 static inline _LIBCPP_CONSTEXPR_CXX20
char_type* copy(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT { char_type* copy(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT {
if (!__libcpp_is_constant_evaluated()) if (!__libcpp_is_constant_evaluated())
_LIBCPP_ASSERT(__s2 < __s1 || __s2 >= __s1+__n, "char_traits::copy overlapped range"); _LIBCPP_ASSERT(__s2 < __s1 || __s2 >= __s1+__n, "char_traits::copy overlapped range");
std::copy_n(__s2, __n, __s1); std::copy_n(__s2, __n, __s1);
return __s1; return __s1;
} }
static inline _LIBCPP_CONSTEXPR_AFTER_CXX17 static inline _LIBCPP_CONSTEXPR_CXX20
char_type* assign(char_type* __s, size_t __n, char_type __a) _NOEXCEPT { char_type* assign(char_type* __s, size_t __n, char_type __a) _NOEXCEPT {
std::fill_n(__s, __n, __a); std::fill_n(__s, __n, __a);
return __s; return __s;
} }
static inline _LIBCPP_CONSTEXPR int_type not_eof(int_type __c) _NOEXCEPT static inline _LIBCPP_CONSTEXPR int_type not_eof(int_type __c) _NOEXCEPT
{return eq_int_type(__c, eof()) ? ~eof() : __c;} {return eq_int_type(__c, eof()) ? ~eof() : __c;}
static inline _LIBCPP_CONSTEXPR char_type to_char_type(int_type __c) _NOEXCEPT static inline _LIBCPP_CONSTEXPR char_type to_char_type(int_type __c) _NOEXCEPT
{return char_type(__c);} {return char_type(__c);}
static inline _LIBCPP_CONSTEXPR int_type to_int_type(char_type __c) _NOEXCEPT static inline _LIBCPP_CONSTEXPR int_type to_int_type(char_type __c) _NOEXCEPT
{return int_type(__c);} {return int_type(__c);}
static inline _LIBCPP_CONSTEXPR bool eq_int_type(int_type __c1, int_type __c2) _NOEXCEPT static inline _LIBCPP_CONSTEXPR bool eq_int_type(int_type __c1, int_type __c2) _NOEXCEPT
{return __c1 == __c2;} {return __c1 == __c2;}
static inline _LIBCPP_CONSTEXPR int_type eof() _NOEXCEPT static inline _LIBCPP_CONSTEXPR int_type eof() _NOEXCEPT
{return int_type(WEOF);} {return int_type(WEOF);}
}; };
inline _LIBCPP_CONSTEXPR_AFTER_CXX14 inline _LIBCPP_CONSTEXPR_CXX17
int int
char_traits<wchar_t>::compare(const char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT char_traits<wchar_t>::compare(const char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT
{ {
if (__n == 0) if (__n == 0)
return 0; return 0;
#if __has_feature(cxx_constexpr_string_builtins) #if __has_feature(cxx_constexpr_string_builtins)
return __builtin_wmemcmp(__s1, __s2, __n); return __builtin_wmemcmp(__s1, __s2, __n);
#elif _LIBCPP_STD_VER <= 14 #elif _LIBCPP_STD_VER <= 14
return _VSTD::wmemcmp(__s1, __s2, __n); return _VSTD::wmemcmp(__s1, __s2, __n);
#else #else
for (; __n; --__n, ++__s1, ++__s2) for (; __n; --__n, ++__s1, ++__s2)
{ {
if (lt(*__s1, *__s2)) if (lt(*__s1, *__s2))
return -1; return -1;
if (lt(*__s2, *__s1)) if (lt(*__s2, *__s1))
return 1; return 1;
} }
return 0; return 0;
#endif #endif
} }
inline _LIBCPP_CONSTEXPR_AFTER_CXX14 inline _LIBCPP_CONSTEXPR_CXX17
size_t size_t
char_traits<wchar_t>::length(const char_type* __s) _NOEXCEPT char_traits<wchar_t>::length(const char_type* __s) _NOEXCEPT
{ {
#if __has_feature(cxx_constexpr_string_builtins) #if __has_feature(cxx_constexpr_string_builtins)
return __builtin_wcslen(__s); return __builtin_wcslen(__s);
#elif _LIBCPP_STD_VER <= 14 #elif _LIBCPP_STD_VER <= 14
return _VSTD::wcslen(__s); return _VSTD::wcslen(__s);
#else #else
size_t __len = 0; size_t __len = 0;
for (; !eq(*__s, char_type(0)); ++__s) for (; !eq(*__s, char_type(0)); ++__s)
++__len; ++__len;
return __len; return __len;
#endif #endif
} }
inline _LIBCPP_CONSTEXPR_AFTER_CXX14 inline _LIBCPP_CONSTEXPR_CXX17
const wchar_t* const wchar_t*
char_traits<wchar_t>::find(const char_type* __s, size_t __n, const char_type& __a) _NOEXCEPT char_traits<wchar_t>::find(const char_type* __s, size_t __n, const char_type& __a) _NOEXCEPT
{ {
if (__n == 0) if (__n == 0)
return nullptr; return nullptr;
#if __has_feature(cxx_constexpr_string_builtins) #if __has_feature(cxx_constexpr_string_builtins)
return __builtin_wmemchr(__s, __a, __n); return __builtin_wmemchr(__s, __a, __n);
#elif _LIBCPP_STD_VER <= 14 #elif _LIBCPP_STD_VER <= 14
Show All 35 Lines# endif
int compare(const char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT; int compare(const char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT;
static constexpr static constexpr
size_t length(const char_type* __s) _NOEXCEPT; size_t length(const char_type* __s) _NOEXCEPT;
_LIBCPP_INLINE_VISIBILITY static constexpr _LIBCPP_INLINE_VISIBILITY static constexpr
const char_type* find(const char_type* __s, size_t __n, const char_type& __a) _NOEXCEPT; const char_type* find(const char_type* __s, size_t __n, const char_type& __a) _NOEXCEPT;
static _LIBCPP_CONSTEXPR_AFTER_CXX17 static _LIBCPP_CONSTEXPR_CXX20
char_type* move(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT { char_type* move(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT {
return std::__char_traits_move(__s1, __s2, __n); return std::__char_traits_move(__s1, __s2, __n);
} }
static _LIBCPP_CONSTEXPR_AFTER_CXX17 static _LIBCPP_CONSTEXPR_CXX20
char_type* copy(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT { char_type* copy(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT {
if (!__libcpp_is_constant_evaluated()) if (!__libcpp_is_constant_evaluated())
_LIBCPP_ASSERT(__s2 < __s1 || __s2 >= __s1+__n, "char_traits::copy overlapped range"); _LIBCPP_ASSERT(__s2 < __s1 || __s2 >= __s1+__n, "char_traits::copy overlapped range");
std::copy_n(__s2, __n, __s1); std::copy_n(__s2, __n, __s1);
return __s1; return __s1;
} }
static _LIBCPP_CONSTEXPR_AFTER_CXX17 static _LIBCPP_CONSTEXPR_CXX20
char_type* assign(char_type* __s, size_t __n, char_type __a) _NOEXCEPT { char_type* assign(char_type* __s, size_t __n, char_type __a) _NOEXCEPT {
std::fill_n(__s, __n, __a); std::fill_n(__s, __n, __a);
return __s; return __s;
} }
static inline constexpr int_type not_eof(int_type __c) noexcept static inline constexpr int_type not_eof(int_type __c) noexcept
{return eq_int_type(__c, eof()) ? ~eof() : __c;} {return eq_int_type(__c, eof()) ? ~eof() : __c;}
static inline constexpr char_type to_char_type(int_type __c) noexcept static inline constexpr char_type to_char_type(int_type __c) noexcept
▲ Show 20 Lines • Show All 58 Lines • ▼ Show 20 Linesstruct _LIBCPP_TEMPLATE_VIS char_traits<char16_t>
typedef uint_least16_t int_type; typedef uint_least16_t int_type;
typedef streamoff off_type; typedef streamoff off_type;
typedef u16streampos pos_type; typedef u16streampos pos_type;
typedef mbstate_t state_type; typedef mbstate_t state_type;
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER > 17
using comparison_category = strong_ordering; using comparison_category = strong_ordering;
#endif #endif
static inline _LIBCPP_CONSTEXPR_AFTER_CXX14 static inline _LIBCPP_CONSTEXPR_CXX17
void assign(char_type& __c1, const char_type& __c2) _NOEXCEPT {__c1 = __c2;} void assign(char_type& __c1, const char_type& __c2) _NOEXCEPT {__c1 = __c2;}
static inline _LIBCPP_CONSTEXPR bool eq(char_type __c1, char_type __c2) _NOEXCEPT static inline _LIBCPP_CONSTEXPR bool eq(char_type __c1, char_type __c2) _NOEXCEPT
{return __c1 == __c2;} {return __c1 == __c2;}
static inline _LIBCPP_CONSTEXPR bool lt(char_type __c1, char_type __c2) _NOEXCEPT static inline _LIBCPP_CONSTEXPR bool lt(char_type __c1, char_type __c2) _NOEXCEPT
{return __c1 < __c2;} {return __c1 < __c2;}
_LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR_CXX17
int compare(const char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT; int compare(const char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT;
_LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR_CXX17
size_t length(const char_type* __s) _NOEXCEPT; size_t length(const char_type* __s) _NOEXCEPT;
_LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR_CXX17
const char_type* find(const char_type* __s, size_t __n, const char_type& __a) _NOEXCEPT; const char_type* find(const char_type* __s, size_t __n, const char_type& __a) _NOEXCEPT;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
static char_type* move(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT { static char_type* move(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT {
return std::__char_traits_move(__s1, __s2, __n); return std::__char_traits_move(__s1, __s2, __n);
} }
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
static char_type* copy(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT { static char_type* copy(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT {
if (!__libcpp_is_constant_evaluated()) if (!__libcpp_is_constant_evaluated())
_LIBCPP_ASSERT(__s2 < __s1 || __s2 >= __s1+__n, "char_traits::copy overlapped range"); _LIBCPP_ASSERT(__s2 < __s1 || __s2 >= __s1+__n, "char_traits::copy overlapped range");
std::copy_n(__s2, __n, __s1); std::copy_n(__s2, __n, __s1);
return __s1; return __s1;
} }
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
static char_type* assign(char_type* __s, size_t __n, char_type __a) _NOEXCEPT { static char_type* assign(char_type* __s, size_t __n, char_type __a) _NOEXCEPT {
std::fill_n(__s, __n, __a); std::fill_n(__s, __n, __a);
return __s; return __s;
} }
static inline _LIBCPP_CONSTEXPR int_type not_eof(int_type __c) _NOEXCEPT static inline _LIBCPP_CONSTEXPR int_type not_eof(int_type __c) _NOEXCEPT
{return eq_int_type(__c, eof()) ? ~eof() : __c;} {return eq_int_type(__c, eof()) ? ~eof() : __c;}
static inline _LIBCPP_CONSTEXPR char_type to_char_type(int_type __c) _NOEXCEPT static inline _LIBCPP_CONSTEXPR char_type to_char_type(int_type __c) _NOEXCEPT
{return char_type(__c);} {return char_type(__c);}
static inline _LIBCPP_CONSTEXPR int_type to_int_type(char_type __c) _NOEXCEPT static inline _LIBCPP_CONSTEXPR int_type to_int_type(char_type __c) _NOEXCEPT
{return int_type(__c);} {return int_type(__c);}
static inline _LIBCPP_CONSTEXPR bool eq_int_type(int_type __c1, int_type __c2) _NOEXCEPT static inline _LIBCPP_CONSTEXPR bool eq_int_type(int_type __c1, int_type __c2) _NOEXCEPT
{return __c1 == __c2;} {return __c1 == __c2;}
static inline _LIBCPP_CONSTEXPR int_type eof() _NOEXCEPT static inline _LIBCPP_CONSTEXPR int_type eof() _NOEXCEPT
{return int_type(0xFFFF);} {return int_type(0xFFFF);}
}; };
inline _LIBCPP_CONSTEXPR_AFTER_CXX14 inline _LIBCPP_CONSTEXPR_CXX17
int int
char_traits<char16_t>::compare(const char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT char_traits<char16_t>::compare(const char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT
{ {
for (; __n; --__n, ++__s1, ++__s2) for (; __n; --__n, ++__s1, ++__s2)
{ {
if (lt(*__s1, *__s2)) if (lt(*__s1, *__s2))
return -1; return -1;
if (lt(*__s2, *__s1)) if (lt(*__s2, *__s1))
return 1; return 1;
} }
return 0; return 0;
} }
inline _LIBCPP_CONSTEXPR_AFTER_CXX14 inline _LIBCPP_CONSTEXPR_CXX17
size_t size_t
char_traits<char16_t>::length(const char_type* __s) _NOEXCEPT char_traits<char16_t>::length(const char_type* __s) _NOEXCEPT
{ {
size_t __len = 0; size_t __len = 0;
for (; !eq(*__s, char_type(0)); ++__s) for (; !eq(*__s, char_type(0)); ++__s)
++__len; ++__len;
return __len; return __len;
} }
inline _LIBCPP_CONSTEXPR_AFTER_CXX14 inline _LIBCPP_CONSTEXPR_CXX17
const char16_t* const char16_t*
char_traits<char16_t>::find(const char_type* __s, size_t __n, const char_type& __a) _NOEXCEPT char_traits<char16_t>::find(const char_type* __s, size_t __n, const char_type& __a) _NOEXCEPT
{ {
for (; __n; --__n) for (; __n; --__n)
{ {
if (eq(*__s, __a)) if (eq(*__s, __a))
return __s; return __s;
++__s; ++__s;
} }
return nullptr; return nullptr;
} }
template <> template <>
struct _LIBCPP_TEMPLATE_VIS char_traits<char32_t> struct _LIBCPP_TEMPLATE_VIS char_traits<char32_t>
{ {
typedef char32_t char_type; typedef char32_t char_type;
typedef uint_least32_t int_type; typedef uint_least32_t int_type;
typedef streamoff off_type; typedef streamoff off_type;
typedef u32streampos pos_type; typedef u32streampos pos_type;
typedef mbstate_t state_type; typedef mbstate_t state_type;
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER > 17
using comparison_category = strong_ordering; using comparison_category = strong_ordering;
#endif #endif
static inline _LIBCPP_CONSTEXPR_AFTER_CXX14 static inline _LIBCPP_CONSTEXPR_CXX17
void assign(char_type& __c1, const char_type& __c2) _NOEXCEPT {__c1 = __c2;} void assign(char_type& __c1, const char_type& __c2) _NOEXCEPT {__c1 = __c2;}
static inline _LIBCPP_CONSTEXPR bool eq(char_type __c1, char_type __c2) _NOEXCEPT static inline _LIBCPP_CONSTEXPR bool eq(char_type __c1, char_type __c2) _NOEXCEPT
{return __c1 == __c2;} {return __c1 == __c2;}
static inline _LIBCPP_CONSTEXPR bool lt(char_type __c1, char_type __c2) _NOEXCEPT static inline _LIBCPP_CONSTEXPR bool lt(char_type __c1, char_type __c2) _NOEXCEPT
{return __c1 < __c2;} {return __c1 < __c2;}
_LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR_CXX17
int compare(const char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT; int compare(const char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT;
_LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR_CXX17
size_t length(const char_type* __s) _NOEXCEPT; size_t length(const char_type* __s) _NOEXCEPT;
_LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR_CXX17
const char_type* find(const char_type* __s, size_t __n, const char_type& __a) _NOEXCEPT; const char_type* find(const char_type* __s, size_t __n, const char_type& __a) _NOEXCEPT;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
static char_type* move(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT { static char_type* move(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT {
return std::__char_traits_move(__s1, __s2, __n); return std::__char_traits_move(__s1, __s2, __n);
} }
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
static char_type* copy(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT { static char_type* copy(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT {
std::copy_n(__s2, __n, __s1); std::copy_n(__s2, __n, __s1);
return __s1; return __s1;
} }
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
static char_type* assign(char_type* __s, size_t __n, char_type __a) _NOEXCEPT { static char_type* assign(char_type* __s, size_t __n, char_type __a) _NOEXCEPT {
std::fill_n(__s, __n, __a); std::fill_n(__s, __n, __a);
return __s; return __s;
} }
static inline _LIBCPP_CONSTEXPR int_type not_eof(int_type __c) _NOEXCEPT static inline _LIBCPP_CONSTEXPR int_type not_eof(int_type __c) _NOEXCEPT
{return eq_int_type(__c, eof()) ? ~eof() : __c;} {return eq_int_type(__c, eof()) ? ~eof() : __c;}
static inline _LIBCPP_CONSTEXPR char_type to_char_type(int_type __c) _NOEXCEPT static inline _LIBCPP_CONSTEXPR char_type to_char_type(int_type __c) _NOEXCEPT
{return char_type(__c);} {return char_type(__c);}
static inline _LIBCPP_CONSTEXPR int_type to_int_type(char_type __c) _NOEXCEPT static inline _LIBCPP_CONSTEXPR int_type to_int_type(char_type __c) _NOEXCEPT
{return int_type(__c);} {return int_type(__c);}
static inline _LIBCPP_CONSTEXPR bool eq_int_type(int_type __c1, int_type __c2) _NOEXCEPT static inline _LIBCPP_CONSTEXPR bool eq_int_type(int_type __c1, int_type __c2) _NOEXCEPT
{return __c1 == __c2;} {return __c1 == __c2;}
static inline _LIBCPP_CONSTEXPR int_type eof() _NOEXCEPT static inline _LIBCPP_CONSTEXPR int_type eof() _NOEXCEPT
{return int_type(0xFFFFFFFF);} {return int_type(0xFFFFFFFF);}
}; };
inline _LIBCPP_CONSTEXPR_AFTER_CXX14 inline _LIBCPP_CONSTEXPR_CXX17
int int
char_traits<char32_t>::compare(const char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT char_traits<char32_t>::compare(const char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT
{ {
for (; __n; --__n, ++__s1, ++__s2) for (; __n; --__n, ++__s1, ++__s2)
{ {
if (lt(*__s1, *__s2)) if (lt(*__s1, *__s2))
return -1; return -1;
if (lt(*__s2, *__s1)) if (lt(*__s2, *__s1))
return 1; return 1;
} }
return 0; return 0;
} }
inline _LIBCPP_CONSTEXPR_AFTER_CXX14 inline _LIBCPP_CONSTEXPR_CXX17
size_t size_t
char_traits<char32_t>::length(const char_type* __s) _NOEXCEPT char_traits<char32_t>::length(const char_type* __s) _NOEXCEPT
{ {
size_t __len = 0; size_t __len = 0;
for (; !eq(*__s, char_type(0)); ++__s) for (; !eq(*__s, char_type(0)); ++__s)
++__len; ++__len;
return __len; return __len;
} }
inline _LIBCPP_CONSTEXPR_AFTER_CXX14 inline _LIBCPP_CONSTEXPR_CXX17
const char32_t* const char32_t*
char_traits<char32_t>::find(const char_type* __s, size_t __n, const char_type& __a) _NOEXCEPT char_traits<char32_t>::find(const char_type* __s, size_t __n, const char_type& __a) _NOEXCEPT
{ {
for (; __n; --__n) for (; __n; --__n)
{ {
if (eq(*__s, __a)) if (eq(*__s, __a))
return __s; return __s;
++__s; ++__s;
} }
return nullptr; return nullptr;
} }
// helper fns for basic_string and string_view // helper fns for basic_string and string_view
// __str_find // __str_find
template<class _CharT, class _SizeT, class _Traits, _SizeT __npos> template<class _CharT, class _SizeT, class _Traits, _SizeT __npos>
inline _SizeT _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY inline _SizeT _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
__str_find(const _CharT *__p, _SizeT __sz, __str_find(const _CharT *__p, _SizeT __sz,
_CharT __c, _SizeT __pos) _NOEXCEPT _CharT __c, _SizeT __pos) _NOEXCEPT
{ {
if (__pos >= __sz) if (__pos >= __sz)
return __npos; return __npos;
const _CharT* __r = _Traits::find(__p + __pos, __sz - __pos, __c); const _CharT* __r = _Traits::find(__p + __pos, __sz - __pos, __c);
if (__r == nullptr) if (__r == nullptr)
return __npos; return __npos;
return static_cast<_SizeT>(__r - __p); return static_cast<_SizeT>(__r - __p);
} }
template <class _CharT, class _Traits> template <class _CharT, class _Traits>
inline _LIBCPP_CONSTEXPR_AFTER_CXX11 const _CharT * inline _LIBCPP_CONSTEXPR_CXX14 const _CharT *
__search_substring(const _CharT *__first1, const _CharT *__last1, __search_substring(const _CharT *__first1, const _CharT *__last1,
const _CharT *__first2, const _CharT *__last2) _NOEXCEPT { const _CharT *__first2, const _CharT *__last2) _NOEXCEPT {
// Take advantage of knowing source and pattern lengths. // Take advantage of knowing source and pattern lengths.
// Stop short when source is smaller than pattern. // Stop short when source is smaller than pattern.
const ptrdiff_t __len2 = __last2 - __first2; const ptrdiff_t __len2 = __last2 - __first2;
if (__len2 == 0) if (__len2 == 0)
return __first1; return __first1;
Show All 22 Lines while (true) {
if (_Traits::compare(__first1, __first2, __len2) == 0) if (_Traits::compare(__first1, __first2, __len2) == 0)
return __first1; return __first1;
++__first1; ++__first1;
} }
} }
template<class _CharT, class _SizeT, class _Traits, _SizeT __npos> template<class _CharT, class _SizeT, class _Traits, _SizeT __npos>
inline _SizeT _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY inline _SizeT _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
__str_find(const _CharT *__p, _SizeT __sz, __str_find(const _CharT *__p, _SizeT __sz,
const _CharT* __s, _SizeT __pos, _SizeT __n) _NOEXCEPT const _CharT* __s, _SizeT __pos, _SizeT __n) _NOEXCEPT
{ {
if (__pos > __sz) if (__pos > __sz)
return __npos; return __npos;
if (__n == 0) // There is nothing to search, just return __pos. if (__n == 0) // There is nothing to search, just return __pos.
return __pos; return __pos;
const _CharT *__r = __search_substring<_CharT, _Traits>( const _CharT *__r = __search_substring<_CharT, _Traits>(
__p + __pos, __p + __sz, __s, __s + __n); __p + __pos, __p + __sz, __s, __s + __n);
if (__r == __p + __sz) if (__r == __p + __sz)
return __npos; return __npos;
return static_cast<_SizeT>(__r - __p); return static_cast<_SizeT>(__r - __p);
} }
// __str_rfind // __str_rfind
template<class _CharT, class _SizeT, class _Traits, _SizeT __npos> template<class _CharT, class _SizeT, class _Traits, _SizeT __npos>
inline _SizeT _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY inline _SizeT _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
__str_rfind(const _CharT *__p, _SizeT __sz, __str_rfind(const _CharT *__p, _SizeT __sz,
_CharT __c, _SizeT __pos) _NOEXCEPT _CharT __c, _SizeT __pos) _NOEXCEPT
{ {
if (__sz < 1) if (__sz < 1)
return __npos; return __npos;
if (__pos < __sz) if (__pos < __sz)
++__pos; ++__pos;
else else
__pos = __sz; __pos = __sz;
for (const _CharT* __ps = __p + __pos; __ps != __p;) for (const _CharT* __ps = __p + __pos; __ps != __p;)
{ {
if (_Traits::eq(*--__ps, __c)) if (_Traits::eq(*--__ps, __c))
return static_cast<_SizeT>(__ps - __p); return static_cast<_SizeT>(__ps - __p);
} }
return __npos; return __npos;
} }
template<class _CharT, class _SizeT, class _Traits, _SizeT __npos> template<class _CharT, class _SizeT, class _Traits, _SizeT __npos>
inline _SizeT _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY inline _SizeT _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
__str_rfind(const _CharT *__p, _SizeT __sz, __str_rfind(const _CharT *__p, _SizeT __sz,
const _CharT* __s, _SizeT __pos, _SizeT __n) _NOEXCEPT const _CharT* __s, _SizeT __pos, _SizeT __n) _NOEXCEPT
{ {
__pos = _VSTD::min(__pos, __sz); __pos = _VSTD::min(__pos, __sz);
if (__n < __sz - __pos) if (__n < __sz - __pos)
__pos += __n; __pos += __n;
else else
__pos = __sz; __pos = __sz;
const _CharT* __r = std::__find_end_classic(__p, __p + __pos, __s, __s + __n, _Traits::eq); const _CharT* __r = std::__find_end_classic(__p, __p + __pos, __s, __s + __n, _Traits::eq);
if (__n > 0 && __r == __p + __pos) if (__n > 0 && __r == __p + __pos)
return __npos; return __npos;
return static_cast<_SizeT>(__r - __p); return static_cast<_SizeT>(__r - __p);
} }
// __str_find_first_of // __str_find_first_of
template<class _CharT, class _SizeT, class _Traits, _SizeT __npos> template<class _CharT, class _SizeT, class _Traits, _SizeT __npos>
inline _SizeT _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY inline _SizeT _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
__str_find_first_of(const _CharT *__p, _SizeT __sz, __str_find_first_of(const _CharT *__p, _SizeT __sz,
const _CharT* __s, _SizeT __pos, _SizeT __n) _NOEXCEPT const _CharT* __s, _SizeT __pos, _SizeT __n) _NOEXCEPT
{ {
if (__pos >= __sz || __n == 0) if (__pos >= __sz || __n == 0)
return __npos; return __npos;
const _CharT* __r = _VSTD::__find_first_of_ce const _CharT* __r = _VSTD::__find_first_of_ce
(__p + __pos, __p + __sz, __s, __s + __n, _Traits::eq ); (__p + __pos, __p + __sz, __s, __s + __n, _Traits::eq );
if (__r == __p + __sz) if (__r == __p + __sz)
return __npos; return __npos;
return static_cast<_SizeT>(__r - __p); return static_cast<_SizeT>(__r - __p);
} }
// __str_find_last_of // __str_find_last_of
template<class _CharT, class _SizeT, class _Traits, _SizeT __npos> template<class _CharT, class _SizeT, class _Traits, _SizeT __npos>
inline _SizeT _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY inline _SizeT _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
__str_find_last_of(const _CharT *__p, _SizeT __sz, __str_find_last_of(const _CharT *__p, _SizeT __sz,
const _CharT* __s, _SizeT __pos, _SizeT __n) _NOEXCEPT const _CharT* __s, _SizeT __pos, _SizeT __n) _NOEXCEPT
{ {
if (__n != 0) if (__n != 0)
{ {
if (__pos < __sz) if (__pos < __sz)
++__pos; ++__pos;
else else
__pos = __sz; __pos = __sz;
for (const _CharT* __ps = __p + __pos; __ps != __p;) for (const _CharT* __ps = __p + __pos; __ps != __p;)
{ {
const _CharT* __r = _Traits::find(__s, __n, *--__ps); const _CharT* __r = _Traits::find(__s, __n, *--__ps);
if (__r) if (__r)
return static_cast<_SizeT>(__ps - __p); return static_cast<_SizeT>(__ps - __p);
} }
} }
return __npos; return __npos;
} }
// __str_find_first_not_of // __str_find_first_not_of
template<class _CharT, class _SizeT, class _Traits, _SizeT __npos> template<class _CharT, class _SizeT, class _Traits, _SizeT __npos>
inline _SizeT _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY inline _SizeT _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
__str_find_first_not_of(const _CharT *__p, _SizeT __sz, __str_find_first_not_of(const _CharT *__p, _SizeT __sz,
const _CharT* __s, _SizeT __pos, _SizeT __n) _NOEXCEPT const _CharT* __s, _SizeT __pos, _SizeT __n) _NOEXCEPT
{ {
if (__pos < __sz) if (__pos < __sz)
{ {
const _CharT* __pe = __p + __sz; const _CharT* __pe = __p + __sz;
for (const _CharT* __ps = __p + __pos; __ps != __pe; ++__ps) for (const _CharT* __ps = __p + __pos; __ps != __pe; ++__ps)
if (_Traits::find(__s, __n, *__ps) == nullptr) if (_Traits::find(__s, __n, *__ps) == nullptr)
return static_cast<_SizeT>(__ps - __p); return static_cast<_SizeT>(__ps - __p);
} }
return __npos; return __npos;
} }
template<class _CharT, class _SizeT, class _Traits, _SizeT __npos> template<class _CharT, class _SizeT, class _Traits, _SizeT __npos>
inline _SizeT _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY inline _SizeT _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
__str_find_first_not_of(const _CharT *__p, _SizeT __sz, __str_find_first_not_of(const _CharT *__p, _SizeT __sz,
_CharT __c, _SizeT __pos) _NOEXCEPT _CharT __c, _SizeT __pos) _NOEXCEPT
{ {
if (__pos < __sz) if (__pos < __sz)
{ {
const _CharT* __pe = __p + __sz; const _CharT* __pe = __p + __sz;
for (const _CharT* __ps = __p + __pos; __ps != __pe; ++__ps) for (const _CharT* __ps = __p + __pos; __ps != __pe; ++__ps)
if (!_Traits::eq(*__ps, __c)) if (!_Traits::eq(*__ps, __c))
return static_cast<_SizeT>(__ps - __p); return static_cast<_SizeT>(__ps - __p);
} }
return __npos; return __npos;
} }
// __str_find_last_not_of // __str_find_last_not_of
template<class _CharT, class _SizeT, class _Traits, _SizeT __npos> template<class _CharT, class _SizeT, class _Traits, _SizeT __npos>
inline _SizeT _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY inline _SizeT _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
__str_find_last_not_of(const _CharT *__p, _SizeT __sz, __str_find_last_not_of(const _CharT *__p, _SizeT __sz,
const _CharT* __s, _SizeT __pos, _SizeT __n) _NOEXCEPT const _CharT* __s, _SizeT __pos, _SizeT __n) _NOEXCEPT
{ {
if (__pos < __sz) if (__pos < __sz)
++__pos; ++__pos;
else else
__pos = __sz; __pos = __sz;
for (const _CharT* __ps = __p + __pos; __ps != __p;) for (const _CharT* __ps = __p + __pos; __ps != __p;)
if (_Traits::find(__s, __n, *--__ps) == nullptr) if (_Traits::find(__s, __n, *--__ps) == nullptr)
return static_cast<_SizeT>(__ps - __p); return static_cast<_SizeT>(__ps - __p);
return __npos; return __npos;
} }
template<class _CharT, class _SizeT, class _Traits, _SizeT __npos> template<class _CharT, class _SizeT, class _Traits, _SizeT __npos>
inline _SizeT _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY inline _SizeT _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
__str_find_last_not_of(const _CharT *__p, _SizeT __sz, __str_find_last_not_of(const _CharT *__p, _SizeT __sz,
_CharT __c, _SizeT __pos) _NOEXCEPT _CharT __c, _SizeT __pos) _NOEXCEPT
{ {
if (__pos < __sz) if (__pos < __sz)
++__pos; ++__pos;
else else
__pos = __sz; __pos = __sz;
for (const _CharT* __ps = __p + __pos; __ps != __p;) for (const _CharT* __ps = __p + __pos; __ps != __p;)
Show All 18 Lines

libcxx/include/__tuple

Show First 20 Lines • Show All 161 Lines • ▼ Show 20 Lines
template <class ..._Tp> template <class ..._Tp>
struct _LIBCPP_TEMPLATE_VIS tuple_size<tuple<_Tp...> > struct _LIBCPP_TEMPLATE_VIS tuple_size<tuple<_Tp...> >
: public integral_constant<size_t, sizeof...(_Tp)> : public integral_constant<size_t, sizeof...(_Tp)>
{ {
}; };
template <size_t _Ip, class ..._Tp> template <size_t _Ip, class ..._Tp>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
typename tuple_element<_Ip, tuple<_Tp...> >::type& typename tuple_element<_Ip, tuple<_Tp...> >::type&
get(tuple<_Tp...>&) _NOEXCEPT; get(tuple<_Tp...>&) _NOEXCEPT;
template <size_t _Ip, class ..._Tp> template <size_t _Ip, class ..._Tp>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
const typename tuple_element<_Ip, tuple<_Tp...> >::type& const typename tuple_element<_Ip, tuple<_Tp...> >::type&
get(const tuple<_Tp...>&) _NOEXCEPT; get(const tuple<_Tp...>&) _NOEXCEPT;
template <size_t _Ip, class ..._Tp> template <size_t _Ip, class ..._Tp>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
typename tuple_element<_Ip, tuple<_Tp...> >::type&& typename tuple_element<_Ip, tuple<_Tp...> >::type&&
get(tuple<_Tp...>&&) _NOEXCEPT; get(tuple<_Tp...>&&) _NOEXCEPT;
template <size_t _Ip, class ..._Tp> template <size_t _Ip, class ..._Tp>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
const typename tuple_element<_Ip, tuple<_Tp...> >::type&& const typename tuple_element<_Ip, tuple<_Tp...> >::type&&
get(const tuple<_Tp...>&&) _NOEXCEPT; get(const tuple<_Tp...>&&) _NOEXCEPT;
#endif // !defined(_LIBCPP_CXX03_LANG) #endif // !defined(_LIBCPP_CXX03_LANG)
// pair specializations // pair specializations
template <class _T1, class _T2> struct __tuple_like<pair<_T1, _T2> > : true_type {}; template <class _T1, class _T2> struct __tuple_like<pair<_T1, _T2> > : true_type {};
template <size_t _Ip, class _T1, class _T2> template <size_t _Ip, class _T1, class _T2>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
typename tuple_element<_Ip, pair<_T1, _T2> >::type& typename tuple_element<_Ip, pair<_T1, _T2> >::type&
get(pair<_T1, _T2>&) _NOEXCEPT; get(pair<_T1, _T2>&) _NOEXCEPT;
template <size_t _Ip, class _T1, class _T2> template <size_t _Ip, class _T1, class _T2>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
const typename tuple_element<_Ip, pair<_T1, _T2> >::type& const typename tuple_element<_Ip, pair<_T1, _T2> >::type&
get(const pair<_T1, _T2>&) _NOEXCEPT; get(const pair<_T1, _T2>&) _NOEXCEPT;
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
template <size_t _Ip, class _T1, class _T2> template <size_t _Ip, class _T1, class _T2>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
typename tuple_element<_Ip, pair<_T1, _T2> >::type&& typename tuple_element<_Ip, pair<_T1, _T2> >::type&&
get(pair<_T1, _T2>&&) _NOEXCEPT; get(pair<_T1, _T2>&&) _NOEXCEPT;
template <size_t _Ip, class _T1, class _T2> template <size_t _Ip, class _T1, class _T2>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
const typename tuple_element<_Ip, pair<_T1, _T2> >::type&& const typename tuple_element<_Ip, pair<_T1, _T2> >::type&&
get(const pair<_T1, _T2>&&) _NOEXCEPT; get(const pair<_T1, _T2>&&) _NOEXCEPT;
#endif #endif
// array specializations // array specializations
template <class _Tp, size_t _Size> struct _LIBCPP_TEMPLATE_VIS array; template <class _Tp, size_t _Size> struct _LIBCPP_TEMPLATE_VIS array;
template <class _Tp, size_t _Size> struct __tuple_like<array<_Tp, _Size> > : true_type {}; template <class _Tp, size_t _Size> struct __tuple_like<array<_Tp, _Size> > : true_type {};
template <size_t _Ip, class _Tp, size_t _Size> template <size_t _Ip, class _Tp, size_t _Size>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
_Tp& _Tp&
get(array<_Tp, _Size>&) _NOEXCEPT; get(array<_Tp, _Size>&) _NOEXCEPT;
template <size_t _Ip, class _Tp, size_t _Size> template <size_t _Ip, class _Tp, size_t _Size>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
const _Tp& const _Tp&
get(const array<_Tp, _Size>&) _NOEXCEPT; get(const array<_Tp, _Size>&) _NOEXCEPT;
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
template <size_t _Ip, class _Tp, size_t _Size> template <size_t _Ip, class _Tp, size_t _Size>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
_Tp&& _Tp&&
get(array<_Tp, _Size>&&) _NOEXCEPT; get(array<_Tp, _Size>&&) _NOEXCEPT;
template <size_t _Ip, class _Tp, size_t _Size> template <size_t _Ip, class _Tp, size_t _Size>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
const _Tp&& const _Tp&&
get(const array<_Tp, _Size>&&) _NOEXCEPT; get(const array<_Tp, _Size>&&) _NOEXCEPT;
#endif #endif
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
// __tuple_types // __tuple_types
▲ Show 20 Lines • Show All 302 Lines • Show Last 20 Lines

libcxx/include/__utility/exchange.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 _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER > 11
template<class _T1, class _T2 = _T1> template<class _T1, class _T2 = _T1>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
_T1 exchange(_T1& __obj, _T2&& __new_value) _T1 exchange(_T1& __obj, _T2&& __new_value)
noexcept(is_nothrow_move_constructible<_T1>::value && is_nothrow_assignable<_T1&, _T2>::value) noexcept(is_nothrow_move_constructible<_T1>::value && is_nothrow_assignable<_T1&, _T2>::value)
{ {
_T1 __old_value = _VSTD::move(__obj); _T1 __old_value = _VSTD::move(__obj);
__obj = _VSTD::forward<_T2>(__new_value); __obj = _VSTD::forward<_T2>(__new_value);
return __old_value; return __old_value;
} }
#endif // _LIBCPP_STD_VER > 11 #endif // _LIBCPP_STD_VER > 11
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___UTILITY_EXCHANGE_H #endif // _LIBCPP___UTILITY_EXCHANGE_H

libcxx/include/__utility/move.h

Show All 26 Lines
} }
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;
template <class _Tp> template <class _Tp>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 __move_if_noexcept_result_t<_Tp> _LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 __move_if_noexcept_result_t<_Tp>
move_if_noexcept(_Tp& __x) _NOEXCEPT { move_if_noexcept(_Tp& __x) _NOEXCEPT {
return _VSTD::move(__x); return _VSTD::move(__x);
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___UTILITY_MOVE_H #endif // _LIBCPP___UTILITY_MOVE_H

libcxx/include/__utility/pair.h

Show All 25 Lines
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if defined(_LIBCPP_DEPRECATED_ABI_DISABLE_PAIR_TRIVIAL_COPY_CTOR) #if defined(_LIBCPP_DEPRECATED_ABI_DISABLE_PAIR_TRIVIAL_COPY_CTOR)
template <class, class> template <class, class>
struct __non_trivially_copyable_base { struct __non_trivially_copyable_base {
_LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
__non_trivially_copyable_base() _NOEXCEPT {} __non_trivially_copyable_base() _NOEXCEPT {}
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
__non_trivially_copyable_base(__non_trivially_copyable_base const&) _NOEXCEPT {} __non_trivially_copyable_base(__non_trivially_copyable_base const&) _NOEXCEPT {}
}; };
#endif #endif
template <class _T1, class _T2> template <class _T1, class _T2>
struct _LIBCPP_TEMPLATE_VIS pair struct _LIBCPP_TEMPLATE_VIS pair
#if defined(_LIBCPP_DEPRECATED_ABI_DISABLE_PAIR_TRIVIAL_COPY_CTOR) #if defined(_LIBCPP_DEPRECATED_ABI_DISABLE_PAIR_TRIVIAL_COPY_CTOR)
: private __non_trivially_copyable_base<_T1, _T2> : private __non_trivially_copyable_base<_T1, _T2>
▲ Show 20 Lines • Show All 105 Lines • ▼ Show 20 Lines#else
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
pair() _NOEXCEPT_(is_nothrow_default_constructible<first_type>::value && pair() _NOEXCEPT_(is_nothrow_default_constructible<first_type>::value &&
is_nothrow_default_constructible<second_type>::value) is_nothrow_default_constructible<second_type>::value)
: first(), second() {} : first(), second() {}
template <bool _Dummy = true, typename enable_if< template <bool _Dummy = true, typename enable_if<
_CheckArgsDep<_Dummy>::template __enable_explicit<_T1 const&, _T2 const&>() _CheckArgsDep<_Dummy>::template __enable_explicit<_T1 const&, _T2 const&>()
>::type* = nullptr> >::type* = nullptr>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
explicit pair(_T1 const& __t1, _T2 const& __t2) explicit pair(_T1 const& __t1, _T2 const& __t2)
_NOEXCEPT_(is_nothrow_copy_constructible<first_type>::value && _NOEXCEPT_(is_nothrow_copy_constructible<first_type>::value &&
is_nothrow_copy_constructible<second_type>::value) is_nothrow_copy_constructible<second_type>::value)
: first(__t1), second(__t2) {} : first(__t1), second(__t2) {}
template<bool _Dummy = true, typename enable_if< template<bool _Dummy = true, typename enable_if<
_CheckArgsDep<_Dummy>::template __enable_implicit<_T1 const&, _T2 const&>() _CheckArgsDep<_Dummy>::template __enable_implicit<_T1 const&, _T2 const&>()
>::type* = nullptr> >::type* = nullptr>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
pair(_T1 const& __t1, _T2 const& __t2) pair(_T1 const& __t1, _T2 const& __t2)
_NOEXCEPT_(is_nothrow_copy_constructible<first_type>::value && _NOEXCEPT_(is_nothrow_copy_constructible<first_type>::value &&
is_nothrow_copy_constructible<second_type>::value) is_nothrow_copy_constructible<second_type>::value)
: first(__t1), second(__t2) {} : first(__t1), second(__t2) {}
template < template <
#if _LIBCPP_STD_VER > 20 // http://wg21.link/P1951 #if _LIBCPP_STD_VER > 20 // http://wg21.link/P1951
class _U1 = _T1, class _U2 = _T2, class _U1 = _T1, class _U2 = _T2,
#else #else
class _U1, class _U2, class _U1, class _U2,
#endif #endif
typename enable_if<_CheckArgs::template __enable_explicit<_U1, _U2>()>::type* = nullptr typename enable_if<_CheckArgs::template __enable_explicit<_U1, _U2>()>::type* = nullptr
> >
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
explicit pair(_U1&& __u1, _U2&& __u2) explicit pair(_U1&& __u1, _U2&& __u2)
_NOEXCEPT_((is_nothrow_constructible<first_type, _U1>::value && _NOEXCEPT_((is_nothrow_constructible<first_type, _U1>::value &&
is_nothrow_constructible<second_type, _U2>::value)) is_nothrow_constructible<second_type, _U2>::value))
: first(_VSTD::forward<_U1>(__u1)), second(_VSTD::forward<_U2>(__u2)) {} : first(_VSTD::forward<_U1>(__u1)), second(_VSTD::forward<_U2>(__u2)) {}
template < template <
#if _LIBCPP_STD_VER > 20 // http://wg21.link/P1951 #if _LIBCPP_STD_VER > 20 // http://wg21.link/P1951
class _U1 = _T1, class _U2 = _T2, class _U1 = _T1, class _U2 = _T2,
#else #else
class _U1, class _U2, class _U1, class _U2,
#endif #endif
typename enable_if<_CheckArgs::template __enable_implicit<_U1, _U2>()>::type* = nullptr typename enable_if<_CheckArgs::template __enable_implicit<_U1, _U2>()>::type* = nullptr
> >
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
pair(_U1&& __u1, _U2&& __u2) pair(_U1&& __u1, _U2&& __u2)
_NOEXCEPT_((is_nothrow_constructible<first_type, _U1>::value && _NOEXCEPT_((is_nothrow_constructible<first_type, _U1>::value &&
is_nothrow_constructible<second_type, _U2>::value)) is_nothrow_constructible<second_type, _U2>::value))
: first(_VSTD::forward<_U1>(__u1)), second(_VSTD::forward<_U2>(__u2)) {} : first(_VSTD::forward<_U1>(__u1)), second(_VSTD::forward<_U2>(__u2)) {}
template<class _U1, class _U2, typename enable_if< template<class _U1, class _U2, typename enable_if<
_CheckArgs::template __enable_explicit<_U1 const&, _U2 const&>() _CheckArgs::template __enable_explicit<_U1 const&, _U2 const&>()
>::type* = nullptr> >::type* = nullptr>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
explicit pair(pair<_U1, _U2> const& __p) explicit pair(pair<_U1, _U2> const& __p)
_NOEXCEPT_((is_nothrow_constructible<first_type, _U1 const&>::value && _NOEXCEPT_((is_nothrow_constructible<first_type, _U1 const&>::value &&
is_nothrow_constructible<second_type, _U2 const&>::value)) is_nothrow_constructible<second_type, _U2 const&>::value))
: first(__p.first), second(__p.second) {} : first(__p.first), second(__p.second) {}
template<class _U1, class _U2, typename enable_if< template<class _U1, class _U2, typename enable_if<
_CheckArgs::template __enable_implicit<_U1 const&, _U2 const&>() _CheckArgs::template __enable_implicit<_U1 const&, _U2 const&>()
>::type* = nullptr> >::type* = nullptr>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
pair(pair<_U1, _U2> const& __p) pair(pair<_U1, _U2> const& __p)
_NOEXCEPT_((is_nothrow_constructible<first_type, _U1 const&>::value && _NOEXCEPT_((is_nothrow_constructible<first_type, _U1 const&>::value &&
is_nothrow_constructible<second_type, _U2 const&>::value)) is_nothrow_constructible<second_type, _U2 const&>::value))
: first(__p.first), second(__p.second) {} : first(__p.first), second(__p.second) {}
template<class _U1, class _U2, typename enable_if< template<class _U1, class _U2, typename enable_if<
_CheckArgs::template __enable_explicit<_U1, _U2>() _CheckArgs::template __enable_explicit<_U1, _U2>()
>::type* = nullptr> >::type* = nullptr>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
explicit pair(pair<_U1, _U2>&&__p) explicit pair(pair<_U1, _U2>&&__p)
_NOEXCEPT_((is_nothrow_constructible<first_type, _U1&&>::value && _NOEXCEPT_((is_nothrow_constructible<first_type, _U1&&>::value &&
is_nothrow_constructible<second_type, _U2&&>::value)) is_nothrow_constructible<second_type, _U2&&>::value))
: first(_VSTD::forward<_U1>(__p.first)), second(_VSTD::forward<_U2>(__p.second)) {} : first(_VSTD::forward<_U1>(__p.first)), second(_VSTD::forward<_U2>(__p.second)) {}
template<class _U1, class _U2, typename enable_if< template<class _U1, class _U2, typename enable_if<
_CheckArgs::template __enable_implicit<_U1, _U2>() _CheckArgs::template __enable_implicit<_U1, _U2>()
>::type* = nullptr> >::type* = nullptr>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
pair(pair<_U1, _U2>&& __p) pair(pair<_U1, _U2>&& __p)
_NOEXCEPT_((is_nothrow_constructible<first_type, _U1&&>::value && _NOEXCEPT_((is_nothrow_constructible<first_type, _U1&&>::value &&
is_nothrow_constructible<second_type, _U2&&>::value)) is_nothrow_constructible<second_type, _U2&&>::value))
: first(_VSTD::forward<_U1>(__p.first)), second(_VSTD::forward<_U2>(__p.second)) {} : first(_VSTD::forward<_U1>(__p.first)), second(_VSTD::forward<_U2>(__p.second)) {}
template<class _Tuple, typename enable_if< template<class _Tuple, typename enable_if<
_CheckTLC<_Tuple>::template __enable_explicit<_Tuple>() _CheckTLC<_Tuple>::template __enable_explicit<_Tuple>()
>::type* = nullptr> >::type* = nullptr>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
explicit pair(_Tuple&& __p) explicit pair(_Tuple&& __p)
: first(_VSTD::get<0>(_VSTD::forward<_Tuple>(__p))), : first(_VSTD::get<0>(_VSTD::forward<_Tuple>(__p))),
second(_VSTD::get<1>(_VSTD::forward<_Tuple>(__p))) {} second(_VSTD::get<1>(_VSTD::forward<_Tuple>(__p))) {}
template<class _Tuple, typename enable_if< template<class _Tuple, typename enable_if<
_CheckTLC<_Tuple>::template __enable_implicit<_Tuple>() _CheckTLC<_Tuple>::template __enable_implicit<_Tuple>()
>::type* = nullptr> >::type* = nullptr>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
pair(_Tuple&& __p) pair(_Tuple&& __p)
: first(_VSTD::get<0>(_VSTD::forward<_Tuple>(__p))), : first(_VSTD::get<0>(_VSTD::forward<_Tuple>(__p))),
second(_VSTD::get<1>(_VSTD::forward<_Tuple>(__p))) {} second(_VSTD::get<1>(_VSTD::forward<_Tuple>(__p))) {}
template <class... _Args1, class... _Args2> template <class... _Args1, class... _Args2>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
pair(piecewise_construct_t __pc, pair(piecewise_construct_t __pc,
tuple<_Args1...> __first_args, tuple<_Args2...> __second_args) tuple<_Args1...> __first_args, tuple<_Args2...> __second_args)
_NOEXCEPT_((is_nothrow_constructible<first_type, _Args1...>::value && _NOEXCEPT_((is_nothrow_constructible<first_type, _Args1...>::value &&
is_nothrow_constructible<second_type, _Args2...>::value)) is_nothrow_constructible<second_type, _Args2...>::value))
: pair(__pc, __first_args, __second_args, : pair(__pc, __first_args, __second_args,
typename __make_tuple_indices<sizeof...(_Args1)>::type(), typename __make_tuple_indices<sizeof...(_Args1)>::type(),
typename __make_tuple_indices<sizeof...(_Args2) >::type()) {} typename __make_tuple_indices<sizeof...(_Args2) >::type()) {}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
pair& operator=(typename conditional< pair& operator=(typename conditional<
is_copy_assignable<first_type>::value && is_copy_assignable<first_type>::value &&
is_copy_assignable<second_type>::value, is_copy_assignable<second_type>::value,
pair, __nat>::type const& __p) pair, __nat>::type const& __p)
_NOEXCEPT_(is_nothrow_copy_assignable<first_type>::value && _NOEXCEPT_(is_nothrow_copy_assignable<first_type>::value &&
is_nothrow_copy_assignable<second_type>::value) is_nothrow_copy_assignable<second_type>::value)
{ {
first = __p.first; first = __p.first;
second = __p.second; second = __p.second;
return *this; return *this;
} }
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
pair& operator=(typename conditional< pair& operator=(typename conditional<
is_move_assignable<first_type>::value && is_move_assignable<first_type>::value &&
is_move_assignable<second_type>::value, is_move_assignable<second_type>::value,
pair, __nat>::type&& __p) pair, __nat>::type&& __p)
_NOEXCEPT_(is_nothrow_move_assignable<first_type>::value && _NOEXCEPT_(is_nothrow_move_assignable<first_type>::value &&
is_nothrow_move_assignable<second_type>::value) is_nothrow_move_assignable<second_type>::value)
{ {
first = _VSTD::forward<first_type>(__p.first); first = _VSTD::forward<first_type>(__p.first);
second = _VSTD::forward<second_type>(__p.second); second = _VSTD::forward<second_type>(__p.second);
return *this; return *this;
} }
template <class _Tuple, typename enable_if< template <class _Tuple, typename enable_if<
_CheckTLC<_Tuple>::template __enable_assign<_Tuple>() _CheckTLC<_Tuple>::template __enable_assign<_Tuple>()
>::type* = nullptr> >::type* = nullptr>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
pair& operator=(_Tuple&& __p) { pair& operator=(_Tuple&& __p) {
first = _VSTD::get<0>(_VSTD::forward<_Tuple>(__p)); first = _VSTD::get<0>(_VSTD::forward<_Tuple>(__p));
second = _VSTD::get<1>(_VSTD::forward<_Tuple>(__p)); second = _VSTD::get<1>(_VSTD::forward<_Tuple>(__p));
return *this; return *this;
} }
#endif #endif
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
void void
swap(pair& __p) _NOEXCEPT_(__is_nothrow_swappable<first_type>::value && swap(pair& __p) _NOEXCEPT_(__is_nothrow_swappable<first_type>::value &&
__is_nothrow_swappable<second_type>::value) __is_nothrow_swappable<second_type>::value)
{ {
using _VSTD::swap; using _VSTD::swap;
swap(first, __p.first); swap(first, __p.first);
swap(second, __p.second); swap(second, __p.second);
} }
private: private:
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
template <class... _Args1, class... _Args2, size_t... _I1, size_t... _I2> template <class... _Args1, class... _Args2, size_t... _I1, size_t... _I2>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
pair(piecewise_construct_t, pair(piecewise_construct_t,
tuple<_Args1...>& __first_args, tuple<_Args2...>& __second_args, tuple<_Args1...>& __first_args, tuple<_Args2...>& __second_args,
__tuple_indices<_I1...>, __tuple_indices<_I2...>); __tuple_indices<_I1...>, __tuple_indices<_I2...>);
#endif #endif
}; };
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER > 14
template<class _T1, class _T2> template<class _T1, class _T2>
pair(_T1, _T2) -> pair<_T1, _T2>; pair(_T1, _T2) -> pair<_T1, _T2>;
#endif #endif
// [pairs.spec], specialized algorithms // [pairs.spec], specialized algorithms
template <class _T1, class _T2> template <class _T1, class _T2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
bool bool
operator==(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y) operator==(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
{ {
return __x.first == __y.first && __x.second == __y.second; return __x.first == __y.first && __x.second == __y.second;
} }
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER > 17
template <class _T1, class _T2> template <class _T1, class _T2>
_LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_HIDE_FROM_ABI constexpr
common_comparison_category_t< common_comparison_category_t<
__synth_three_way_result<_T1>, __synth_three_way_result<_T1>,
__synth_three_way_result<_T2> > __synth_three_way_result<_T2> >
operator<=>(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y) operator<=>(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
{ {
if (auto __c = _VSTD::__synth_three_way(__x.first, __y.first); __c != 0) { if (auto __c = _VSTD::__synth_three_way(__x.first, __y.first); __c != 0) {
return __c; return __c;
} }
return _VSTD::__synth_three_way(__x.second, __y.second); return _VSTD::__synth_three_way(__x.second, __y.second);
} }
#else // _LIBCPP_STD_VER > 17 #else // _LIBCPP_STD_VER > 17
template <class _T1, class _T2> template <class _T1, class _T2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
bool bool
operator!=(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y) operator!=(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
{ {
return !(__x == __y); return !(__x == __y);
} }
template <class _T1, class _T2> template <class _T1, class _T2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
bool bool
operator< (const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y) operator< (const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
{ {
return __x.first < __y.first || (!(__y.first < __x.first) && __x.second < __y.second); return __x.first < __y.first || (!(__y.first < __x.first) && __x.second < __y.second);
} }
template <class _T1, class _T2> template <class _T1, class _T2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
bool bool
operator> (const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y) operator> (const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
{ {
return __y < __x; return __y < __x;
} }
template <class _T1, class _T2> template <class _T1, class _T2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
bool bool
operator>=(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y) operator>=(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
{ {
return !(__x < __y); return !(__x < __y);
} }
template <class _T1, class _T2> template <class _T1, class _T2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
bool bool
operator<=(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y) operator<=(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
{ {
return !(__y < __x); return !(__y < __x);
} }
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER > 17
Show All 9 Lines
template <class _T1, class _T2, class _U1, class _U2> template <class _T1, class _T2, class _U1, class _U2>
requires requires { typename pair<common_type_t<_T1, _U1>, common_type_t<_T2, _U2>>; } requires requires { typename pair<common_type_t<_T1, _U1>, common_type_t<_T2, _U2>>; }
struct common_type<pair<_T1, _T2>, pair<_U1, _U2>> { struct common_type<pair<_T1, _T2>, pair<_U1, _U2>> {
using type = pair<common_type_t<_T1, _U1>, common_type_t<_T2, _U2>>; using type = pair<common_type_t<_T1, _U1>, common_type_t<_T2, _U2>>;
}; };
#endif // _LIBCPP_STD_VER > 20 #endif // _LIBCPP_STD_VER > 20
template <class _T1, class _T2> template <class _T1, class _T2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
typename enable_if typename enable_if
< <
__is_swappable<_T1>::value && __is_swappable<_T1>::value &&
__is_swappable<_T2>::value, __is_swappable<_T2>::value,
void void
>::type >::type
swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y) swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y)
_NOEXCEPT_((__is_nothrow_swappable<_T1>::value && _NOEXCEPT_((__is_nothrow_swappable<_T1>::value &&
__is_nothrow_swappable<_T2>::value)) __is_nothrow_swappable<_T2>::value))
{ {
__x.swap(__y); __x.swap(__y);
} }
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
template <class _T1, class _T2> template <class _T1, class _T2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
pair<typename __unwrap_ref_decay<_T1>::type, typename __unwrap_ref_decay<_T2>::type> pair<typename __unwrap_ref_decay<_T1>::type, typename __unwrap_ref_decay<_T2>::type>
make_pair(_T1&& __t1, _T2&& __t2) make_pair(_T1&& __t1, _T2&& __t2)
{ {
return pair<typename __unwrap_ref_decay<_T1>::type, typename __unwrap_ref_decay<_T2>::type> return pair<typename __unwrap_ref_decay<_T1>::type, typename __unwrap_ref_decay<_T2>::type>
(_VSTD::forward<_T1>(__t1), _VSTD::forward<_T2>(__t2)); (_VSTD::forward<_T1>(__t1), _VSTD::forward<_T2>(__t2));
} }
#else // _LIBCPP_CXX03_LANG #else // _LIBCPP_CXX03_LANG
Show All 32 Lines
template <size_t _Ip> struct __get_pair; template <size_t _Ip> struct __get_pair;
template <> template <>
struct __get_pair<0> struct __get_pair<0>
{ {
template <class _T1, class _T2> template <class _T1, class _T2>
static static
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
_T1& _T1&
get(pair<_T1, _T2>& __p) _NOEXCEPT {return __p.first;} get(pair<_T1, _T2>& __p) _NOEXCEPT {return __p.first;}
template <class _T1, class _T2> template <class _T1, class _T2>
static static
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
const _T1& const _T1&
get(const pair<_T1, _T2>& __p) _NOEXCEPT {return __p.first;} get(const pair<_T1, _T2>& __p) _NOEXCEPT {return __p.first;}
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
template <class _T1, class _T2> template <class _T1, class _T2>
static static
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
_T1&& _T1&&
get(pair<_T1, _T2>&& __p) _NOEXCEPT {return _VSTD::forward<_T1>(__p.first);} get(pair<_T1, _T2>&& __p) _NOEXCEPT {return _VSTD::forward<_T1>(__p.first);}
template <class _T1, class _T2> template <class _T1, class _T2>
static static
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
const _T1&& const _T1&&
get(const pair<_T1, _T2>&& __p) _NOEXCEPT {return _VSTD::forward<const _T1>(__p.first);} get(const pair<_T1, _T2>&& __p) _NOEXCEPT {return _VSTD::forward<const _T1>(__p.first);}
#endif // _LIBCPP_CXX03_LANG #endif // _LIBCPP_CXX03_LANG
}; };
template <> template <>
struct __get_pair<1> struct __get_pair<1>
{ {
template <class _T1, class _T2> template <class _T1, class _T2>
static static
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
_T2& _T2&
get(pair<_T1, _T2>& __p) _NOEXCEPT {return __p.second;} get(pair<_T1, _T2>& __p) _NOEXCEPT {return __p.second;}
template <class _T1, class _T2> template <class _T1, class _T2>
static static
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
const _T2& const _T2&
get(const pair<_T1, _T2>& __p) _NOEXCEPT {return __p.second;} get(const pair<_T1, _T2>& __p) _NOEXCEPT {return __p.second;}
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
template <class _T1, class _T2> template <class _T1, class _T2>
static static
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
_T2&& _T2&&
get(pair<_T1, _T2>&& __p) _NOEXCEPT {return _VSTD::forward<_T2>(__p.second);} get(pair<_T1, _T2>&& __p) _NOEXCEPT {return _VSTD::forward<_T2>(__p.second);}
template <class _T1, class _T2> template <class _T1, class _T2>
static static
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
const _T2&& const _T2&&
get(const pair<_T1, _T2>&& __p) _NOEXCEPT {return _VSTD::forward<const _T2>(__p.second);} get(const pair<_T1, _T2>&& __p) _NOEXCEPT {return _VSTD::forward<const _T2>(__p.second);}
#endif // _LIBCPP_CXX03_LANG #endif // _LIBCPP_CXX03_LANG
}; };
template <size_t _Ip, class _T1, class _T2> template <size_t _Ip, class _T1, class _T2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
typename tuple_element<_Ip, pair<_T1, _T2> >::type& typename tuple_element<_Ip, pair<_T1, _T2> >::type&
get(pair<_T1, _T2>& __p) _NOEXCEPT get(pair<_T1, _T2>& __p) _NOEXCEPT
{ {
return __get_pair<_Ip>::get(__p); return __get_pair<_Ip>::get(__p);
} }
template <size_t _Ip, class _T1, class _T2> template <size_t _Ip, class _T1, class _T2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
const typename tuple_element<_Ip, pair<_T1, _T2> >::type& const typename tuple_element<_Ip, pair<_T1, _T2> >::type&
get(const pair<_T1, _T2>& __p) _NOEXCEPT get(const pair<_T1, _T2>& __p) _NOEXCEPT
{ {
return __get_pair<_Ip>::get(__p); return __get_pair<_Ip>::get(__p);
} }
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
template <size_t _Ip, class _T1, class _T2> template <size_t _Ip, class _T1, class _T2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
typename tuple_element<_Ip, pair<_T1, _T2> >::type&& typename tuple_element<_Ip, pair<_T1, _T2> >::type&&
get(pair<_T1, _T2>&& __p) _NOEXCEPT get(pair<_T1, _T2>&& __p) _NOEXCEPT
{ {
return __get_pair<_Ip>::get(_VSTD::move(__p)); return __get_pair<_Ip>::get(_VSTD::move(__p));
} }
template <size_t _Ip, class _T1, class _T2> template <size_t _Ip, class _T1, class _T2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
const typename tuple_element<_Ip, pair<_T1, _T2> >::type&& const typename tuple_element<_Ip, pair<_T1, _T2> >::type&&
get(const pair<_T1, _T2>&& __p) _NOEXCEPT get(const pair<_T1, _T2>&& __p) _NOEXCEPT
{ {
return __get_pair<_Ip>::get(_VSTD::move(__p)); return __get_pair<_Ip>::get(_VSTD::move(__p));
} }
#endif // _LIBCPP_CXX03_LANG #endif // _LIBCPP_CXX03_LANG
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER > 11
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

libcxx/include/__utility/swap.h

Show All 24 Lines
template <class _Tp> template <class _Tp>
using __swap_result_t = typename enable_if<is_move_constructible<_Tp>::value && is_move_assignable<_Tp>::value>::type; using __swap_result_t = typename enable_if<is_move_constructible<_Tp>::value && is_move_assignable<_Tp>::value>::type;
#else #else
template <class> template <class>
using __swap_result_t = void; using __swap_result_t = void;
#endif #endif
template <class _Tp> template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY __swap_result_t<_Tp> _LIBCPP_CONSTEXPR_AFTER_CXX17 swap(_Tp& __x, _Tp& __y) inline _LIBCPP_INLINE_VISIBILITY __swap_result_t<_Tp> _LIBCPP_CONSTEXPR_CXX20 swap(_Tp& __x, _Tp& __y)
_NOEXCEPT_(is_nothrow_move_constructible<_Tp>::value&& is_nothrow_move_assignable<_Tp>::value) { _NOEXCEPT_(is_nothrow_move_constructible<_Tp>::value&& is_nothrow_move_assignable<_Tp>::value) {
_Tp __t(_VSTD::move(__x)); _Tp __t(_VSTD::move(__x));
__x = _VSTD::move(__y); __x = _VSTD::move(__y);
__y = _VSTD::move(__t); __y = _VSTD::move(__t);
} }
template <class _Tp, size_t _Np> template <class _Tp, size_t _Np>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 typename enable_if<__is_swappable<_Tp>::value>::type inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 typename enable_if<__is_swappable<_Tp>::value>::type
swap(_Tp (&__a)[_Np], _Tp (&__b)[_Np]) _NOEXCEPT_(__is_nothrow_swappable<_Tp>::value) { swap(_Tp (&__a)[_Np], _Tp (&__b)[_Np]) _NOEXCEPT_(__is_nothrow_swappable<_Tp>::value) {
for (size_t __i = 0; __i != _Np; ++__i) { for (size_t __i = 0; __i != _Np; ++__i) {
swap(__a[__i], __b[__i]); swap(__a[__i], __b[__i]);
} }
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___UTILITY_SWAP_H #endif // _LIBCPP___UTILITY_SWAP_H

libcxx/include/__utility/transaction.h

Show First 20 Lines • Show All 46 Lines • ▼ Show 20 Lines
// return out; // return out;
// } // }
// //
template <class _Rollback> template <class _Rollback>
struct __transaction { struct __transaction {
__transaction() = delete; __transaction() = delete;
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
_LIBCPP_CONSTEXPR_AFTER_CXX17 explicit __transaction(_Rollback __rollback) _LIBCPP_CONSTEXPR_CXX20 explicit __transaction(_Rollback __rollback)
: __rollback_(_VSTD::move(__rollback)) : __rollback_(_VSTD::move(__rollback))
, __completed_(false) , __completed_(false)
{ } { }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
_LIBCPP_CONSTEXPR_AFTER_CXX17 __transaction(__transaction&& __other) _LIBCPP_CONSTEXPR_CXX20 __transaction(__transaction&& __other)
_NOEXCEPT_(is_nothrow_move_constructible<_Rollback>::value) _NOEXCEPT_(is_nothrow_move_constructible<_Rollback>::value)
: __rollback_(_VSTD::move(__other.__rollback_)) : __rollback_(_VSTD::move(__other.__rollback_))
, __completed_(__other.__completed_) , __completed_(__other.__completed_)
{ {
__other.__completed_ = true; __other.__completed_ = true;
} }
__transaction(__transaction const&) = delete; __transaction(__transaction const&) = delete;
__transaction& operator=(__transaction const&) = delete; __transaction& operator=(__transaction const&) = delete;
__transaction& operator=(__transaction&&) = delete; __transaction& operator=(__transaction&&) = delete;
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
_LIBCPP_CONSTEXPR_AFTER_CXX17 void __complete() _NOEXCEPT { _LIBCPP_CONSTEXPR_CXX20 void __complete() _NOEXCEPT {
__completed_ = true; __completed_ = true;
} }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
_LIBCPP_CONSTEXPR_AFTER_CXX17 ~__transaction() { _LIBCPP_CONSTEXPR_CXX20 ~__transaction() {
if (!__completed_) if (!__completed_)
__rollback_(); __rollback_();
} }
private: private:
_Rollback __rollback_; _Rollback __rollback_;
bool __completed_; bool __completed_;
}; };
Show All 9 Lines

libcxx/include/array

Show First 20 Lines • Show All 162 Lines • ▼ Show 20 Linesstruct _LIBCPP_TEMPLATE_VIS array
typedef size_t size_type; typedef size_t size_type;
typedef ptrdiff_t difference_type; typedef ptrdiff_t difference_type;
typedef _VSTD::reverse_iterator<iterator> reverse_iterator; typedef _VSTD::reverse_iterator<iterator> reverse_iterator;
typedef _VSTD::reverse_iterator<const_iterator> const_reverse_iterator; typedef _VSTD::reverse_iterator<const_iterator> const_reverse_iterator;
_Tp __elems_[_Size]; _Tp __elems_[_Size];
// No explicit construct/copy/destroy for aggregate type // No explicit construct/copy/destroy for aggregate type
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
void fill(const value_type& __u) { void fill(const value_type& __u) {
_VSTD::fill_n(data(), _Size, __u); _VSTD::fill_n(data(), _Size, __u);
} }
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
void swap(array& __a) _NOEXCEPT_(__is_nothrow_swappable<_Tp>::value) { void swap(array& __a) _NOEXCEPT_(__is_nothrow_swappable<_Tp>::value) {
_VSTD::swap_ranges(data(), data() + _Size, __a.data()); _VSTD::swap_ranges(data(), data() + _Size, __a.data());
} }
// iterators: // iterators:
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
iterator begin() _NOEXCEPT {return iterator(data());} iterator begin() _NOEXCEPT {return iterator(data());}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
const_iterator begin() const _NOEXCEPT {return const_iterator(data());} const_iterator begin() const _NOEXCEPT {return const_iterator(data());}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
iterator end() _NOEXCEPT {return iterator(data() + _Size);} iterator end() _NOEXCEPT {return iterator(data() + _Size);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
const_iterator end() const _NOEXCEPT {return const_iterator(data() + _Size);} const_iterator end() const _NOEXCEPT {return const_iterator(data() + _Size);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
reverse_iterator rbegin() _NOEXCEPT {return reverse_iterator(end());} reverse_iterator rbegin() _NOEXCEPT {return reverse_iterator(end());}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
const_reverse_iterator rbegin() const _NOEXCEPT {return const_reverse_iterator(end());} const_reverse_iterator rbegin() const _NOEXCEPT {return const_reverse_iterator(end());}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
reverse_iterator rend() _NOEXCEPT {return reverse_iterator(begin());} reverse_iterator rend() _NOEXCEPT {return reverse_iterator(begin());}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
const_reverse_iterator rend() const _NOEXCEPT {return const_reverse_iterator(begin());} const_reverse_iterator rend() const _NOEXCEPT {return const_reverse_iterator(begin());}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
const_iterator cbegin() const _NOEXCEPT {return begin();} const_iterator cbegin() const _NOEXCEPT {return begin();}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
const_iterator cend() const _NOEXCEPT {return end();} const_iterator cend() const _NOEXCEPT {return end();}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
const_reverse_iterator crbegin() const _NOEXCEPT {return rbegin();} const_reverse_iterator crbegin() const _NOEXCEPT {return rbegin();}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
const_reverse_iterator crend() const _NOEXCEPT {return rend();} const_reverse_iterator crend() const _NOEXCEPT {return rend();}
// capacity: // capacity:
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR size_type size() const _NOEXCEPT {return _Size;} _LIBCPP_CONSTEXPR size_type size() const _NOEXCEPT {return _Size;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR size_type max_size() const _NOEXCEPT {return _Size;} _LIBCPP_CONSTEXPR size_type max_size() const _NOEXCEPT {return _Size;}
_LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR bool empty() const _NOEXCEPT {return _Size == 0;} _LIBCPP_CONSTEXPR bool empty() const _NOEXCEPT {return _Size == 0;}
// element access: // element access:
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
reference operator[](size_type __n) _NOEXCEPT { reference operator[](size_type __n) _NOEXCEPT {
_LIBCPP_ASSERT(__n < _Size, "out-of-bounds access in std::array<T, N>"); _LIBCPP_ASSERT(__n < _Size, "out-of-bounds access in std::array<T, N>");
return __elems_[__n]; return __elems_[__n];
} }
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
const_reference operator[](size_type __n) const _NOEXCEPT { const_reference operator[](size_type __n) const _NOEXCEPT {
_LIBCPP_ASSERT(__n < _Size, "out-of-bounds access in std::array<T, N>"); _LIBCPP_ASSERT(__n < _Size, "out-of-bounds access in std::array<T, N>");
return __elems_[__n]; return __elems_[__n];
} }
_LIBCPP_CONSTEXPR_AFTER_CXX14 reference at(size_type __n) _LIBCPP_CONSTEXPR_CXX17 reference at(size_type __n)
{ {
if (__n >= _Size) if (__n >= _Size)
__throw_out_of_range("array::at"); __throw_out_of_range("array::at");
return __elems_[__n]; return __elems_[__n];
} }
_LIBCPP_CONSTEXPR_AFTER_CXX11 const_reference at(size_type __n) const _LIBCPP_CONSTEXPR_CXX14 const_reference at(size_type __n) const
{ {
if (__n >= _Size) if (__n >= _Size)
__throw_out_of_range("array::at"); __throw_out_of_range("array::at");
return __elems_[__n]; return __elems_[__n];
} }
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 reference front() _NOEXCEPT {return (*this)[0];} _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17 reference front() _NOEXCEPT {return (*this)[0];}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 const_reference front() const _NOEXCEPT {return (*this)[0];} _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 const_reference front() const _NOEXCEPT {return (*this)[0];}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 reference back() _NOEXCEPT {return (*this)[_Size - 1];} _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17 reference back() _NOEXCEPT {return (*this)[_Size - 1];}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 const_reference back() const _NOEXCEPT {return (*this)[_Size - 1];} _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 const_reference back() const _NOEXCEPT {return (*this)[_Size - 1];}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
value_type* data() _NOEXCEPT {return __elems_;} value_type* data() _NOEXCEPT {return __elems_;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
const value_type* data() const _NOEXCEPT {return __elems_;} const value_type* data() const _NOEXCEPT {return __elems_;}
}; };
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS array<_Tp, 0> struct _LIBCPP_TEMPLATE_VIS array<_Tp, 0>
{ {
// types: // types:
typedef array __self; typedef array __self;
Show All 10 Linesstruct _LIBCPP_TEMPLATE_VIS array<_Tp, 0>
typedef _VSTD::reverse_iterator<const_iterator> const_reverse_iterator; typedef _VSTD::reverse_iterator<const_iterator> const_reverse_iterator;
typedef typename conditional<is_const<_Tp>::value, const char, typedef typename conditional<is_const<_Tp>::value, const char,
char>::type _CharType; char>::type _CharType;
struct _ArrayInStructT { _Tp __data_[1]; }; struct _ArrayInStructT { _Tp __data_[1]; };
_ALIGNAS_TYPE(_ArrayInStructT) _CharType __elems_[sizeof(_ArrayInStructT)]; _ALIGNAS_TYPE(_ArrayInStructT) _CharType __elems_[sizeof(_ArrayInStructT)];
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
value_type* data() _NOEXCEPT {return nullptr;} value_type* data() _NOEXCEPT {return nullptr;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
const value_type* data() const _NOEXCEPT {return nullptr;} const value_type* data() const _NOEXCEPT {return nullptr;}
// No explicit construct/copy/destroy for aggregate type // No explicit construct/copy/destroy for aggregate type
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
void fill(const value_type&) { void fill(const value_type&) {
static_assert(!is_const<_Tp>::value, static_assert(!is_const<_Tp>::value,
"cannot fill zero-sized array of type 'const T'"); "cannot fill zero-sized array of type 'const T'");
} }
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
void swap(array&) _NOEXCEPT { void swap(array&) _NOEXCEPT {
static_assert(!is_const<_Tp>::value, static_assert(!is_const<_Tp>::value,
"cannot swap zero-sized array of type 'const T'"); "cannot swap zero-sized array of type 'const T'");
} }
// iterators: // iterators:
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
iterator begin() _NOEXCEPT {return iterator(data());} iterator begin() _NOEXCEPT {return iterator(data());}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
const_iterator begin() const _NOEXCEPT {return const_iterator(data());} const_iterator begin() const _NOEXCEPT {return const_iterator(data());}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
iterator end() _NOEXCEPT {return iterator(data());} iterator end() _NOEXCEPT {return iterator(data());}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
const_iterator end() const _NOEXCEPT {return const_iterator(data());} const_iterator end() const _NOEXCEPT {return const_iterator(data());}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
reverse_iterator rbegin() _NOEXCEPT {return reverse_iterator(end());} reverse_iterator rbegin() _NOEXCEPT {return reverse_iterator(end());}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
const_reverse_iterator rbegin() const _NOEXCEPT {return const_reverse_iterator(end());} const_reverse_iterator rbegin() const _NOEXCEPT {return const_reverse_iterator(end());}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
reverse_iterator rend() _NOEXCEPT {return reverse_iterator(begin());} reverse_iterator rend() _NOEXCEPT {return reverse_iterator(begin());}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
const_reverse_iterator rend() const _NOEXCEPT {return const_reverse_iterator(begin());} const_reverse_iterator rend() const _NOEXCEPT {return const_reverse_iterator(begin());}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
const_iterator cbegin() const _NOEXCEPT {return begin();} const_iterator cbegin() const _NOEXCEPT {return begin();}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
const_iterator cend() const _NOEXCEPT {return end();} const_iterator cend() const _NOEXCEPT {return end();}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
const_reverse_iterator crbegin() const _NOEXCEPT {return rbegin();} const_reverse_iterator crbegin() const _NOEXCEPT {return rbegin();}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
const_reverse_iterator crend() const _NOEXCEPT {return rend();} const_reverse_iterator crend() const _NOEXCEPT {return rend();}
// capacity: // capacity:
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR size_type size() const _NOEXCEPT {return 0; } _LIBCPP_CONSTEXPR size_type size() const _NOEXCEPT {return 0; }
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR size_type max_size() const _NOEXCEPT {return 0;} _LIBCPP_CONSTEXPR size_type max_size() const _NOEXCEPT {return 0;}
_LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR bool empty() const _NOEXCEPT {return true;} _LIBCPP_CONSTEXPR bool empty() const _NOEXCEPT {return true;}
// element access: // element access:
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
reference operator[](size_type) _NOEXCEPT { reference operator[](size_type) _NOEXCEPT {
_LIBCPP_ASSERT(false, "cannot call array<T, 0>::operator[] on a zero-sized array"); _LIBCPP_ASSERT(false, "cannot call array<T, 0>::operator[] on a zero-sized array");
__libcpp_unreachable(); __libcpp_unreachable();
} }
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
const_reference operator[](size_type) const _NOEXCEPT { const_reference operator[](size_type) const _NOEXCEPT {
_LIBCPP_ASSERT(false, "cannot call array<T, 0>::operator[] on a zero-sized array"); _LIBCPP_ASSERT(false, "cannot call array<T, 0>::operator[] on a zero-sized array");
__libcpp_unreachable(); __libcpp_unreachable();
} }
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
reference at(size_type) { reference at(size_type) {
__throw_out_of_range("array<T, 0>::at"); __throw_out_of_range("array<T, 0>::at");
__libcpp_unreachable(); __libcpp_unreachable();
} }
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
const_reference at(size_type) const { const_reference at(size_type) const {
__throw_out_of_range("array<T, 0>::at"); __throw_out_of_range("array<T, 0>::at");
__libcpp_unreachable(); __libcpp_unreachable();
} }
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
reference front() _NOEXCEPT { reference front() _NOEXCEPT {
_LIBCPP_ASSERT(false, "cannot call array<T, 0>::front() on a zero-sized array"); _LIBCPP_ASSERT(false, "cannot call array<T, 0>::front() on a zero-sized array");
__libcpp_unreachable(); __libcpp_unreachable();
} }
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
const_reference front() const _NOEXCEPT { const_reference front() const _NOEXCEPT {
_LIBCPP_ASSERT(false, "cannot call array<T, 0>::front() on a zero-sized array"); _LIBCPP_ASSERT(false, "cannot call array<T, 0>::front() on a zero-sized array");
__libcpp_unreachable(); __libcpp_unreachable();
} }
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17
reference back() _NOEXCEPT { reference back() _NOEXCEPT {
_LIBCPP_ASSERT(false, "cannot call array<T, 0>::back() on a zero-sized array"); _LIBCPP_ASSERT(false, "cannot call array<T, 0>::back() on a zero-sized array");
__libcpp_unreachable(); __libcpp_unreachable();
} }
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
const_reference back() const _NOEXCEPT { const_reference back() const _NOEXCEPT {
_LIBCPP_ASSERT(false, "cannot call array<T, 0>::back() on a zero-sized array"); _LIBCPP_ASSERT(false, "cannot call array<T, 0>::back() on a zero-sized array");
__libcpp_unreachable(); __libcpp_unreachable();
} }
}; };
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER > 14
template<class _Tp, class... _Args, template<class _Tp, class... _Args,
class = enable_if_t<__all<_IsSame<_Tp, _Args>::value...>::value> class = enable_if_t<__all<_IsSame<_Tp, _Args>::value...>::value>
> >
array(_Tp, _Args...) array(_Tp, _Args...)
-> array<_Tp, 1 + sizeof...(_Args)>; -> array<_Tp, 1 + sizeof...(_Args)>;
#endif #endif
template <class _Tp, size_t _Size> template <class _Tp, size_t _Size>
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR_AFTER_CXX17 bool _LIBCPP_CONSTEXPR_CXX20 bool
operator==(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y) operator==(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y)
{ {
return _VSTD::equal(__x.begin(), __x.end(), __y.begin()); return _VSTD::equal(__x.begin(), __x.end(), __y.begin());
} }
template <class _Tp, size_t _Size> template <class _Tp, size_t _Size>
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR_AFTER_CXX17 bool _LIBCPP_CONSTEXPR_CXX20 bool
operator!=(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y) operator!=(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y)
{ {
return !(__x == __y); return !(__x == __y);
} }
template <class _Tp, size_t _Size> template <class _Tp, size_t _Size>
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR_AFTER_CXX17 bool _LIBCPP_CONSTEXPR_CXX20 bool
operator<(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y) operator<(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y)
{ {
return _VSTD::lexicographical_compare(__x.begin(), __x.end(), return _VSTD::lexicographical_compare(__x.begin(), __x.end(),
__y.begin(), __y.end()); __y.begin(), __y.end());
} }
template <class _Tp, size_t _Size> template <class _Tp, size_t _Size>
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR_AFTER_CXX17 bool _LIBCPP_CONSTEXPR_CXX20 bool
operator>(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y) operator>(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y)
{ {
return __y < __x; return __y < __x;
} }
template <class _Tp, size_t _Size> template <class _Tp, size_t _Size>
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR_AFTER_CXX17 bool _LIBCPP_CONSTEXPR_CXX20 bool
operator<=(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y) operator<=(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y)
{ {
return !(__y < __x); return !(__y < __x);
} }
template <class _Tp, size_t _Size> template <class _Tp, size_t _Size>
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR_AFTER_CXX17 bool _LIBCPP_CONSTEXPR_CXX20 bool
operator>=(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y) operator>=(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y)
{ {
return !(__x < __y); return !(__x < __y);
} }
template <class _Tp, size_t _Size> template <class _Tp, size_t _Size>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
__enable_if_t<_Size == 0 || __is_swappable<_Tp>::value, void> __enable_if_t<_Size == 0 || __is_swappable<_Tp>::value, void>
swap(array<_Tp, _Size>& __x, array<_Tp, _Size>& __y) swap(array<_Tp, _Size>& __x, array<_Tp, _Size>& __y)
_NOEXCEPT_(noexcept(__x.swap(__y))) _NOEXCEPT_(noexcept(__x.swap(__y)))
{ {
__x.swap(__y); __x.swap(__y);
} }
template <class _Tp, size_t _Size> template <class _Tp, size_t _Size>
struct _LIBCPP_TEMPLATE_VIS tuple_size<array<_Tp, _Size> > struct _LIBCPP_TEMPLATE_VIS tuple_size<array<_Tp, _Size> >
: public integral_constant<size_t, _Size> {}; : public integral_constant<size_t, _Size> {};
template <size_t _Ip, class _Tp, size_t _Size> template <size_t _Ip, class _Tp, size_t _Size>
struct _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, array<_Tp, _Size> > struct _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, array<_Tp, _Size> >
{ {
static_assert(_Ip < _Size, "Index out of bounds in std::tuple_element<> (std::array)"); static_assert(_Ip < _Size, "Index out of bounds in std::tuple_element<> (std::array)");
typedef _Tp type; typedef _Tp type;
}; };
template <size_t _Ip, class _Tp, size_t _Size> template <size_t _Ip, class _Tp, size_t _Size>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
_Tp& _Tp&
get(array<_Tp, _Size>& __a) _NOEXCEPT get(array<_Tp, _Size>& __a) _NOEXCEPT
{ {
static_assert(_Ip < _Size, "Index out of bounds in std::get<> (std::array)"); static_assert(_Ip < _Size, "Index out of bounds in std::get<> (std::array)");
return __a.__elems_[_Ip]; return __a.__elems_[_Ip];
} }
template <size_t _Ip, class _Tp, size_t _Size> template <size_t _Ip, class _Tp, size_t _Size>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
const _Tp& const _Tp&
get(const array<_Tp, _Size>& __a) _NOEXCEPT get(const array<_Tp, _Size>& __a) _NOEXCEPT
{ {
static_assert(_Ip < _Size, "Index out of bounds in std::get<> (const std::array)"); static_assert(_Ip < _Size, "Index out of bounds in std::get<> (const std::array)");
return __a.__elems_[_Ip]; return __a.__elems_[_Ip];
} }
template <size_t _Ip, class _Tp, size_t _Size> template <size_t _Ip, class _Tp, size_t _Size>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
_Tp&& _Tp&&
get(array<_Tp, _Size>&& __a) _NOEXCEPT get(array<_Tp, _Size>&& __a) _NOEXCEPT
{ {
static_assert(_Ip < _Size, "Index out of bounds in std::get<> (std::array &&)"); static_assert(_Ip < _Size, "Index out of bounds in std::get<> (std::array &&)");
return _VSTD::move(__a.__elems_[_Ip]); return _VSTD::move(__a.__elems_[_Ip]);
} }
template <size_t _Ip, class _Tp, size_t _Size> template <size_t _Ip, class _Tp, size_t _Size>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
const _Tp&& const _Tp&&
get(const array<_Tp, _Size>&& __a) _NOEXCEPT get(const array<_Tp, _Size>&& __a) _NOEXCEPT
{ {
static_assert(_Ip < _Size, "Index out of bounds in std::get<> (const std::array &&)"); static_assert(_Ip < _Size, "Index out of bounds in std::get<> (const std::array &&)");
return _VSTD::move(__a.__elems_[_Ip]); return _VSTD::move(__a.__elems_[_Ip]);
} }
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER > 17
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

libcxx/include/atomic

Show First 20 Lines • Show All 1,667 Lines • ▼ Show 20 Lines
// atomic<Integral> // atomic<Integral>
template <class _Tp> template <class _Tp>
struct __atomic_base<_Tp, true> struct __atomic_base<_Tp, true>
: public __atomic_base<_Tp, false> : public __atomic_base<_Tp, false>
{ {
typedef __atomic_base<_Tp, false> __base; typedef __atomic_base<_Tp, false> __base;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
__atomic_base() _NOEXCEPT = default; __atomic_base() _NOEXCEPT = default;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR __atomic_base(_Tp __d) _NOEXCEPT : __base(__d) {} _LIBCPP_CONSTEXPR __atomic_base(_Tp __d) _NOEXCEPT : __base(__d) {}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
_Tp fetch_add(_Tp __op, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT _Tp fetch_add(_Tp __op, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT
{return __cxx_atomic_fetch_add(&this->__a_, __op, __m);} {return __cxx_atomic_fetch_add(&this->__a_, __op, __m);}
▲ Show 20 Lines • Show All 1,021 Lines • Show Last 20 Lines

libcxx/include/bit

Show First 20 Lines • Show All 83 Lines • ▼ Show 20 Lines
#endif #endif
_LIBCPP_PUSH_MACROS _LIBCPP_PUSH_MACROS
#include <__undef_macros> #include <__undef_macros>
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template<class _Tp> template<class _Tp>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14
_Tp __rotr(_Tp __t, unsigned int __cnt) _NOEXCEPT _Tp __rotr(_Tp __t, unsigned int __cnt) _NOEXCEPT
{ {
static_assert(__libcpp_is_unsigned_integer<_Tp>::value, "__rotr requires an unsigned integer type"); static_assert(__libcpp_is_unsigned_integer<_Tp>::value, "__rotr requires an unsigned integer type");
const unsigned int __dig = numeric_limits<_Tp>::digits; const unsigned int __dig = numeric_limits<_Tp>::digits;
if ((__cnt % __dig) == 0) if ((__cnt % __dig) == 0)
return __t; return __t;
return (__t >> (__cnt % __dig)) | (__t << (__dig - (__cnt % __dig))); return (__t >> (__cnt % __dig)) | (__t << (__dig - (__cnt % __dig)));
} }
template<class _Tp> template<class _Tp>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14
int __countl_zero(_Tp __t) _NOEXCEPT int __countl_zero(_Tp __t) _NOEXCEPT
{ {
static_assert(__libcpp_is_unsigned_integer<_Tp>::value, "__countl_zero requires an unsigned integer type"); static_assert(__libcpp_is_unsigned_integer<_Tp>::value, "__countl_zero requires an unsigned integer type");
if (__t == 0) if (__t == 0)
return numeric_limits<_Tp>::digits; return numeric_limits<_Tp>::digits;
if (sizeof(_Tp) <= sizeof(unsigned int)) if (sizeof(_Tp) <= sizeof(unsigned int))
return std::__libcpp_clz(static_cast<unsigned int>(__t)) return std::__libcpp_clz(static_cast<unsigned int>(__t))
▲ Show 20 Lines • Show All 148 Lines • Show Last 20 Lines

libcxx/include/complex

Show First 20 Lines • Show All 257 Lines • ▼ Show 20 Lines
class _LIBCPP_TEMPLATE_VIS complex class _LIBCPP_TEMPLATE_VIS complex
{ {
public: public:
typedef _Tp value_type; typedef _Tp value_type;
private: private:
value_type __re_; value_type __re_;
value_type __im_; value_type __im_;
public: public:
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
complex(const value_type& __re = value_type(), const value_type& __im = value_type()) complex(const value_type& __re = value_type(), const value_type& __im = value_type())
: __re_(__re), __im_(__im) {} : __re_(__re), __im_(__im) {}
template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
complex(const complex<_Xp>& __c) complex(const complex<_Xp>& __c)
: __re_(__c.real()), __im_(__c.imag()) {} : __re_(__c.real()), __im_(__c.imag()) {}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 value_type real() const {return __re_;} _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 value_type real() const {return __re_;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 value_type imag() const {return __im_;} _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 value_type imag() const {return __im_;}
_LIBCPP_INLINE_VISIBILITY void real(value_type __re) {__re_ = __re;} _LIBCPP_INLINE_VISIBILITY void real(value_type __re) {__re_ = __re;}
_LIBCPP_INLINE_VISIBILITY void imag(value_type __im) {__im_ = __im;} _LIBCPP_INLINE_VISIBILITY void imag(value_type __im) {__im_ = __im;}
_LIBCPP_INLINE_VISIBILITY complex& operator= (const value_type& __re) _LIBCPP_INLINE_VISIBILITY complex& operator= (const value_type& __re)
{__re_ = __re; __im_ = value_type(); return *this;} {__re_ = __re; __im_ = value_type(); return *this;}
_LIBCPP_INLINE_VISIBILITY complex& operator+=(const value_type& __re) {__re_ += __re; return *this;} _LIBCPP_INLINE_VISIBILITY complex& operator+=(const value_type& __re) {__re_ += __re; return *this;}
_LIBCPP_INLINE_VISIBILITY complex& operator-=(const value_type& __re) {__re_ -= __re; return *this;} _LIBCPP_INLINE_VISIBILITY complex& operator-=(const value_type& __re) {__re_ -= __re; return *this;}
▲ Show 20 Lines • Show All 452 Lines • ▼ Show 20 Lines
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
complex<_Tp> complex<_Tp>
operator-(const complex<_Tp>& __x) operator-(const complex<_Tp>& __x)
{ {
return complex<_Tp>(-__x.real(), -__x.imag()); return complex<_Tp>(-__x.real(), -__x.imag());
} }
template<class _Tp> template<class _Tp>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
bool bool
operator==(const complex<_Tp>& __x, const complex<_Tp>& __y) operator==(const complex<_Tp>& __x, const complex<_Tp>& __y)
{ {
return __x.real() == __y.real() && __x.imag() == __y.imag(); return __x.real() == __y.real() && __x.imag() == __y.imag();
} }
template<class _Tp> template<class _Tp>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
bool bool
operator==(const complex<_Tp>& __x, const _Tp& __y) operator==(const complex<_Tp>& __x, const _Tp& __y)
{ {
return __x.real() == __y && __x.imag() == 0; return __x.real() == __y && __x.imag() == 0;
} }
template<class _Tp> template<class _Tp>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
bool bool
operator==(const _Tp& __x, const complex<_Tp>& __y) operator==(const _Tp& __x, const complex<_Tp>& __y)
{ {
return __x == __y.real() && 0 == __y.imag(); return __x == __y.real() && 0 == __y.imag();
} }
template<class _Tp> template<class _Tp>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
bool bool
operator!=(const complex<_Tp>& __x, const complex<_Tp>& __y) operator!=(const complex<_Tp>& __x, const complex<_Tp>& __y)
{ {
return !(__x == __y); return !(__x == __y);
} }
template<class _Tp> template<class _Tp>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
bool bool
operator!=(const complex<_Tp>& __x, const _Tp& __y) operator!=(const complex<_Tp>& __x, const _Tp& __y)
{ {
return !(__x == __y); return !(__x == __y);
} }
template<class _Tp> template<class _Tp>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
bool bool
operator!=(const _Tp& __x, const complex<_Tp>& __y) operator!=(const _Tp& __x, const complex<_Tp>& __y)
{ {
return !(__x == __y); return !(__x == __y);
} }
// 26.3.7 values: // 26.3.7 values:
Show All 16 Lines
{ {
typedef _Tp _ValueType; typedef _Tp _ValueType;
typedef complex<_Tp> _ComplexType; typedef complex<_Tp> _ComplexType;
}; };
// real // real
template<class _Tp> template<class _Tp>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
_Tp _Tp
real(const complex<_Tp>& __c) real(const complex<_Tp>& __c)
{ {
return __c.real(); return __c.real();
} }
template <class _Tp> template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
typename __libcpp_complex_overload_traits<_Tp>::_ValueType typename __libcpp_complex_overload_traits<_Tp>::_ValueType
real(_Tp __re) real(_Tp __re)
{ {
return __re; return __re;
} }
// imag // imag
template<class _Tp> template<class _Tp>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
_Tp _Tp
imag(const complex<_Tp>& __c) imag(const complex<_Tp>& __c)
{ {
return __c.imag(); return __c.imag();
} }
template <class _Tp> template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
typename __libcpp_complex_overload_traits<_Tp>::_ValueType typename __libcpp_complex_overload_traits<_Tp>::_ValueType
imag(_Tp) imag(_Tp)
{ {
return 0; return 0;
} }
// abs // abs
▲ Show 20 Lines • Show All 645 Lines • Show Last 20 Lines

libcxx/include/experimental/coroutine

Show First 20 Lines • Show All 263 Lines • ▼ Show 20 Linespublic:
_Promise& promise() const { _Promise& promise() const {
return *static_cast<_Promise*>( return *static_cast<_Promise*>(
__builtin_coro_promise(this->__handle_, _LIBCPP_ALIGNOF(_Promise), false)); __builtin_coro_promise(this->__handle_, _LIBCPP_ALIGNOF(_Promise), false));
} }
_LIBCPP_CONSTEXPR explicit operator bool() const _NOEXCEPT { return true; } _LIBCPP_CONSTEXPR explicit operator bool() const _NOEXCEPT { return true; }
_LIBCPP_CONSTEXPR bool done() const _NOEXCEPT { return false; } _LIBCPP_CONSTEXPR bool done() const _NOEXCEPT { return false; }
_LIBCPP_CONSTEXPR_AFTER_CXX17 void operator()() const _NOEXCEPT {} _LIBCPP_CONSTEXPR_CXX20 void operator()() const _NOEXCEPT {}
_LIBCPP_CONSTEXPR_AFTER_CXX17 void resume() const _NOEXCEPT {} _LIBCPP_CONSTEXPR_CXX20 void resume() const _NOEXCEPT {}
_LIBCPP_CONSTEXPR_AFTER_CXX17 void destroy() const _NOEXCEPT {} _LIBCPP_CONSTEXPR_CXX20 void destroy() const _NOEXCEPT {}
private: private:
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
friend coroutine_handle<noop_coroutine_promise> noop_coroutine() _NOEXCEPT; friend coroutine_handle<noop_coroutine_promise> noop_coroutine() _NOEXCEPT;
_LIBCPP_INLINE_VISIBILITY coroutine_handle() _NOEXCEPT { _LIBCPP_INLINE_VISIBILITY coroutine_handle() _NOEXCEPT {
this->__handle_ = __builtin_coro_noop(); this->__handle_ = __builtin_coro_noop();
} }
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

libcxx/include/initializer_list

Show First 20 Lines • Show All 56 Lines • ▼ Show 20 Lines
template<class _Ep> template<class _Ep>
class _LIBCPP_TEMPLATE_VIS initializer_list class _LIBCPP_TEMPLATE_VIS initializer_list
{ {
const _Ep* __begin_; const _Ep* __begin_;
size_t __size_; size_t __size_;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_CONSTEXPR_CXX14
initializer_list(const _Ep* __b, size_t __s) _NOEXCEPT initializer_list(const _Ep* __b, size_t __s) _NOEXCEPT
: __begin_(__b), : __begin_(__b),
__size_(__s) __size_(__s)
{} {}
public: public:
typedef _Ep value_type; typedef _Ep value_type;
typedef const _Ep& reference; typedef const _Ep& reference;
typedef const _Ep& const_reference; typedef const _Ep& const_reference;
typedef size_t size_type; typedef size_t size_type;
typedef const _Ep* iterator; typedef const _Ep* iterator;
typedef const _Ep* const_iterator; typedef const _Ep* const_iterator;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_CONSTEXPR_CXX14
initializer_list() _NOEXCEPT : __begin_(nullptr), __size_(0) {} initializer_list() _NOEXCEPT : __begin_(nullptr), __size_(0) {}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_CONSTEXPR_CXX14
size_t size() const _NOEXCEPT {return __size_;} size_t size() const _NOEXCEPT {return __size_;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_CONSTEXPR_CXX14
const _Ep* begin() const _NOEXCEPT {return __begin_;} const _Ep* begin() const _NOEXCEPT {return __begin_;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_CONSTEXPR_CXX14
const _Ep* end() const _NOEXCEPT {return __begin_ + __size_;} const _Ep* end() const _NOEXCEPT {return __begin_ + __size_;}
}; };
template<class _Ep> template<class _Ep>
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_CONSTEXPR_CXX14
const _Ep* const _Ep*
begin(initializer_list<_Ep> __il) _NOEXCEPT begin(initializer_list<_Ep> __il) _NOEXCEPT
{ {
return __il.begin(); return __il.begin();
} }
template<class _Ep> template<class _Ep>
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_CONSTEXPR_CXX14
const _Ep* const _Ep*
end(initializer_list<_Ep> __il) _NOEXCEPT end(initializer_list<_Ep> __il) _NOEXCEPT
{ {
return __il.end(); return __il.end();
} }
#endif // !defined(_LIBCPP_CXX03_LANG) #endif // !defined(_LIBCPP_CXX03_LANG)
} // namespace std } // namespace std
#endif // _LIBCPP_INITIALIZER_LIST #endif // _LIBCPP_INITIALIZER_LIST

libcxx/include/memory

Show First 20 Lines • Show All 958 Lines • ▼ Show 20 Lines
#ifdef _LIBCPP_CXX03_LANG #ifdef _LIBCPP_CXX03_LANG
typename aligned_storage<sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp)>::type __v; typename aligned_storage<sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp)>::type __v;
#else #else
union { _Tp __v; }; union { _Tp __v; };
#endif #endif
_Alloc &__a; _Alloc &__a;
_LIBCPP_CONSTEXPR_AFTER_CXX17 _Tp *__addr() { _LIBCPP_CONSTEXPR_CXX20 _Tp *__addr() {
#ifdef _LIBCPP_CXX03_LANG #ifdef _LIBCPP_CXX03_LANG
return reinterpret_cast<_Tp*>(std::addressof(__v)); return reinterpret_cast<_Tp*>(std::addressof(__v));
#else #else
return std::addressof(__v); return std::addressof(__v);
#endif #endif
} }
_LIBCPP_CONSTEXPR_AFTER_CXX17 _Tp & get() { return *__addr(); } _LIBCPP_CONSTEXPR_CXX20 _Tp & get() { return *__addr(); }
template<class... _Args> template<class... _Args>
_LIBCPP_NO_CFI _LIBCPP_NO_CFI
_LIBCPP_CONSTEXPR_AFTER_CXX17 __temp_value(_Alloc &__alloc, _Args&& ... __args) : __a(__alloc) { _LIBCPP_CONSTEXPR_CXX20 __temp_value(_Alloc &__alloc, _Args&& ... __args) : __a(__alloc) {
_Traits::construct(__a, __addr(), std::forward<_Args>(__args)...); _Traits::construct(__a, __addr(), std::forward<_Args>(__args)...);
} }
_LIBCPP_CONSTEXPR_AFTER_CXX17 ~__temp_value() { _Traits::destroy(__a, __addr()); } _LIBCPP_CONSTEXPR_CXX20 ~__temp_value() { _Traits::destroy(__a, __addr()); }
}; };
template<typename _Alloc, typename = void, typename = void> template<typename _Alloc, typename = void, typename = void>
struct __is_allocator : false_type {}; struct __is_allocator : false_type {};
template<typename _Alloc> template<typename _Alloc>
struct __is_allocator<_Alloc, struct __is_allocator<_Alloc,
typename __void_t<typename _Alloc::value_type>::type, typename __void_t<typename _Alloc::value_type>::type,
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

libcxx/include/optional

Show First 20 Lines • Show All 249 Lines • ▼ Show 20 Linesstruct __optional_destruct_base<_Tp, false>
union union
{ {
char __null_state_; char __null_state_;
value_type __val_; value_type __val_;
}; };
bool __engaged_; bool __engaged_;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR_AFTER_CXX17 ~__optional_destruct_base() _LIBCPP_CONSTEXPR_CXX20 ~__optional_destruct_base()
{ {
if (__engaged_) if (__engaged_)
__val_.~value_type(); __val_.~value_type();
} }
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
constexpr __optional_destruct_base() noexcept constexpr __optional_destruct_base() noexcept
: __null_state_(), : __null_state_(),
__engaged_(false) {} __engaged_(false) {}
template <class... _Args> template <class... _Args>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
constexpr explicit __optional_destruct_base(in_place_t, _Args&&... __args) constexpr explicit __optional_destruct_base(in_place_t, _Args&&... __args)
: __val_(_VSTD::forward<_Args>(__args)...), : __val_(_VSTD::forward<_Args>(__args)...),
__engaged_(true) {} __engaged_(true) {}
#if _LIBCPP_STD_VER > 20 #if _LIBCPP_STD_VER > 20
template <class _Fp, class... _Args> template <class _Fp, class... _Args>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
constexpr __optional_destruct_base(__optional_construct_from_invoke_tag, _Fp&& __f, _Args&&... __args) constexpr __optional_destruct_base(__optional_construct_from_invoke_tag, _Fp&& __f, _Args&&... __args)
: __val_(_VSTD::invoke(_VSTD::forward<_Fp>(__f), _VSTD::forward<_Args>(__args)...)), __engaged_(true) {} : __val_(_VSTD::invoke(_VSTD::forward<_Fp>(__f), _VSTD::forward<_Args>(__args)...)), __engaged_(true) {}
#endif #endif
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR_AFTER_CXX17 void reset() noexcept _LIBCPP_CONSTEXPR_CXX20 void reset() noexcept
{ {
if (__engaged_) if (__engaged_)
{ {
__val_.~value_type(); __val_.~value_type();
__engaged_ = false; __engaged_ = false;
} }
} }
}; };
Show All 25 Lines
#if _LIBCPP_STD_VER > 20 #if _LIBCPP_STD_VER > 20
template <class _Fp, class... _Args> template <class _Fp, class... _Args>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
constexpr __optional_destruct_base(__optional_construct_from_invoke_tag, _Fp&& __f, _Args&&... __args) constexpr __optional_destruct_base(__optional_construct_from_invoke_tag, _Fp&& __f, _Args&&... __args)
: __val_(_VSTD::invoke(_VSTD::forward<_Fp>(__f), _VSTD::forward<_Args>(__args)...)), __engaged_(true) {} : __val_(_VSTD::invoke(_VSTD::forward<_Fp>(__f), _VSTD::forward<_Args>(__args)...)), __engaged_(true) {}
#endif #endif
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR_AFTER_CXX17 void reset() noexcept _LIBCPP_CONSTEXPR_CXX20 void reset() noexcept
{ {
if (__engaged_) if (__engaged_)
{ {
__engaged_ = false; __engaged_ = false;
} }
} }
}; };
Show All 28 Linesstruct __optional_storage_base : __optional_destruct_base<_Tp>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
constexpr const value_type&& __get() const&& noexcept constexpr const value_type&& __get() const&& noexcept
{ {
return _VSTD::move(this->__val_); return _VSTD::move(this->__val_);
} }
template <class... _Args> template <class... _Args>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR_AFTER_CXX17 void __construct(_Args&&... __args) _LIBCPP_CONSTEXPR_CXX20 void __construct(_Args&&... __args)
{ {
_LIBCPP_ASSERT(!has_value(), "__construct called for engaged __optional_storage"); _LIBCPP_ASSERT(!has_value(), "__construct called for engaged __optional_storage");
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER > 17
_VSTD::construct_at(_VSTD::addressof(this->__val_), _VSTD::forward<_Args>(__args)...); _VSTD::construct_at(_VSTD::addressof(this->__val_), _VSTD::forward<_Args>(__args)...);
#else #else
::new ((void*)_VSTD::addressof(this->__val_)) value_type(_VSTD::forward<_Args>(__args)...); ::new ((void*)_VSTD::addressof(this->__val_)) value_type(_VSTD::forward<_Args>(__args)...);
#endif #endif
this->__engaged_ = true; this->__engaged_ = true;
} }
template <class _That> template <class _That>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR_AFTER_CXX17 void __construct_from(_That&& __opt) _LIBCPP_CONSTEXPR_CXX20 void __construct_from(_That&& __opt)
{ {
if (__opt.has_value()) if (__opt.has_value())
__construct(_VSTD::forward<_That>(__opt).__get()); __construct(_VSTD::forward<_That>(__opt).__get());
} }
template <class _That> template <class _That>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR_AFTER_CXX17 void __assign_from(_That&& __opt) _LIBCPP_CONSTEXPR_CXX20 void __assign_from(_That&& __opt)
{ {
if (this->__engaged_ == __opt.has_value()) if (this->__engaged_ == __opt.has_value())
{ {
if (this->__engaged_) if (this->__engaged_)
this->__val_ = _VSTD::forward<_That>(__opt).__get(); this->__val_ = _VSTD::forward<_That>(__opt).__get();
} }
else else
{ {
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Lines constexpr explicit __optional_storage_base(in_place_t, _UArg&& __uarg)
: __value_(_VSTD::addressof(__uarg)) : __value_(_VSTD::addressof(__uarg))
{ {
static_assert(__can_bind_reference<_UArg>(), static_assert(__can_bind_reference<_UArg>(),
"Attempted to construct a reference element in tuple from a " "Attempted to construct a reference element in tuple from a "
"possible temporary"); "possible temporary");
} }
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR_AFTER_CXX17 void reset() noexcept { __value_ = nullptr; } _LIBCPP_CONSTEXPR_CXX20 void reset() noexcept { __value_ = nullptr; }
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
constexpr bool has_value() const noexcept constexpr bool has_value() const noexcept
{ return __value_ != nullptr; } { return __value_ != nullptr; }
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
constexpr value_type& __get() const& noexcept constexpr value_type& __get() const& noexcept
{ return *__value_; } { return *__value_; }
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
constexpr value_type&& __get() const&& noexcept constexpr value_type&& __get() const&& noexcept
{ return _VSTD::forward<value_type>(*__value_); } { return _VSTD::forward<value_type>(*__value_); }
template <class _UArg> template <class _UArg>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR_AFTER_CXX17 void __construct(_UArg&& __val) _LIBCPP_CONSTEXPR_CXX20 void __construct(_UArg&& __val)
{ {
_LIBCPP_ASSERT(!has_value(), "__construct called for engaged __optional_storage"); _LIBCPP_ASSERT(!has_value(), "__construct called for engaged __optional_storage");
static_assert(__can_bind_reference<_UArg>(), static_assert(__can_bind_reference<_UArg>(),
"Attempted to construct a reference element in tuple from a " "Attempted to construct a reference element in tuple from a "
"possible temporary"); "possible temporary");
__value_ = _VSTD::addressof(__val); __value_ = _VSTD::addressof(__val);
} }
template <class _That> template <class _That>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR_AFTER_CXX17 void __construct_from(_That&& __opt) _LIBCPP_CONSTEXPR_CXX20 void __construct_from(_That&& __opt)
{ {
if (__opt.has_value()) if (__opt.has_value())
__construct(_VSTD::forward<_That>(__opt).__get()); __construct(_VSTD::forward<_That>(__opt).__get());
} }
template <class _That> template <class _That>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR_AFTER_CXX17 void __assign_from(_That&& __opt) _LIBCPP_CONSTEXPR_CXX20 void __assign_from(_That&& __opt)
{ {
if (has_value() == __opt.has_value()) if (has_value() == __opt.has_value())
{ {
if (has_value()) if (has_value())
*__value_ = _VSTD::forward<_That>(__opt).__get(); *__value_ = _VSTD::forward<_That>(__opt).__get();
} }
else else
{ {
Show All 15 Lines
struct __optional_copy_base<_Tp, false> : __optional_storage_base<_Tp> struct __optional_copy_base<_Tp, false> : __optional_storage_base<_Tp>
{ {
using __optional_storage_base<_Tp>::__optional_storage_base; using __optional_storage_base<_Tp>::__optional_storage_base;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
__optional_copy_base() = default; __optional_copy_base() = default;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR_AFTER_CXX17 __optional_copy_base(const __optional_copy_base& __opt) _LIBCPP_CONSTEXPR_CXX20 __optional_copy_base(const __optional_copy_base& __opt)
{ {
this->__construct_from(__opt); this->__construct_from(__opt);
} }
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
__optional_copy_base(__optional_copy_base&&) = default; __optional_copy_base(__optional_copy_base&&) = default;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
__optional_copy_base& operator=(const __optional_copy_base&) = default; __optional_copy_base& operator=(const __optional_copy_base&) = default;
Show All 14 Linesstruct __optional_move_base<_Tp, false> : __optional_copy_base<_Tp>
using __optional_copy_base<_Tp>::__optional_copy_base; using __optional_copy_base<_Tp>::__optional_copy_base;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
__optional_move_base() = default; __optional_move_base() = default;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
__optional_move_base(const __optional_move_base&) = default; __optional_move_base(const __optional_move_base&) = default;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR_AFTER_CXX17 __optional_move_base(__optional_move_base&& __opt) _LIBCPP_CONSTEXPR_CXX20 __optional_move_base(__optional_move_base&& __opt)
noexcept(is_nothrow_move_constructible_v<value_type>) noexcept(is_nothrow_move_constructible_v<value_type>)
{ {
this->__construct_from(_VSTD::move(__opt)); this->__construct_from(_VSTD::move(__opt));
} }
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
__optional_move_base& operator=(const __optional_move_base&) = default; __optional_move_base& operator=(const __optional_move_base&) = default;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
Show All 17 Linesstruct __optional_copy_assign_base<_Tp, false> : __optional_move_base<_Tp>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
__optional_copy_assign_base() = default; __optional_copy_assign_base() = default;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
__optional_copy_assign_base(const __optional_copy_assign_base&) = default; __optional_copy_assign_base(const __optional_copy_assign_base&) = default;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
__optional_copy_assign_base(__optional_copy_assign_base&&) = default; __optional_copy_assign_base(__optional_copy_assign_base&&) = default;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR_AFTER_CXX17 __optional_copy_assign_base& operator=(const __optional_copy_assign_base& __opt) _LIBCPP_CONSTEXPR_CXX20 __optional_copy_assign_base& operator=(const __optional_copy_assign_base& __opt)
{ {
this->__assign_from(__opt); this->__assign_from(__opt);
return *this; return *this;
} }
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
__optional_copy_assign_base& operator=(__optional_copy_assign_base&&) = default; __optional_copy_assign_base& operator=(__optional_copy_assign_base&&) = default;
}; };
Show All 18 Linesstruct __optional_move_assign_base<_Tp, false> : __optional_copy_assign_base<_Tp>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
__optional_move_assign_base(const __optional_move_assign_base& __opt) = default; __optional_move_assign_base(const __optional_move_assign_base& __opt) = default;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
__optional_move_assign_base(__optional_move_assign_base&&) = default; __optional_move_assign_base(__optional_move_assign_base&&) = default;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
__optional_move_assign_base& operator=(const __optional_move_assign_base&) = default; __optional_move_assign_base& operator=(const __optional_move_assign_base&) = default;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR_AFTER_CXX17 __optional_move_assign_base& operator=(__optional_move_assign_base&& __opt) _LIBCPP_CONSTEXPR_CXX20 __optional_move_assign_base& operator=(__optional_move_assign_base&& __opt)
noexcept(is_nothrow_move_assignable_v<value_type> && noexcept(is_nothrow_move_assignable_v<value_type> &&
is_nothrow_move_constructible_v<value_type>) is_nothrow_move_constructible_v<value_type>)
{ {
this->__assign_from(_VSTD::move(__opt)); this->__assign_from(_VSTD::move(__opt));
return *this; return *this;
} }
}; };
▲ Show 20 Lines • Show All 157 Lines • ▼ Show 20 Linespublic:
constexpr explicit optional(_Up&& __v) constexpr explicit optional(_Up&& __v)
: __base(in_place, _VSTD::forward<_Up>(__v)) {} : __base(in_place, _VSTD::forward<_Up>(__v)) {}
// LWG2756: conditionally explicit conversion from const optional<_Up>& // LWG2756: conditionally explicit conversion from const optional<_Up>&
template <class _Up, enable_if_t< template <class _Up, enable_if_t<
_CheckOptionalLikeCtor<_Up, _Up const&>::template __enable_implicit<_Up>() _CheckOptionalLikeCtor<_Up, _Up const&>::template __enable_implicit<_Up>()
, int> = 0> , int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR_AFTER_CXX17 optional(const optional<_Up>& __v) _LIBCPP_CONSTEXPR_CXX20 optional(const optional<_Up>& __v)
{ {
this->__construct_from(__v); this->__construct_from(__v);
} }
template <class _Up, enable_if_t< template <class _Up, enable_if_t<
_CheckOptionalLikeCtor<_Up, _Up const&>::template __enable_explicit<_Up>() _CheckOptionalLikeCtor<_Up, _Up const&>::template __enable_explicit<_Up>()
, int> = 0> , int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR_AFTER_CXX17 explicit optional(const optional<_Up>& __v) _LIBCPP_CONSTEXPR_CXX20 explicit optional(const optional<_Up>& __v)
{ {
this->__construct_from(__v); this->__construct_from(__v);
} }
// LWG2756: conditionally explicit conversion from optional<_Up>&& // LWG2756: conditionally explicit conversion from optional<_Up>&&
template <class _Up, enable_if_t< template <class _Up, enable_if_t<
_CheckOptionalLikeCtor<_Up, _Up &&>::template __enable_implicit<_Up>() _CheckOptionalLikeCtor<_Up, _Up &&>::template __enable_implicit<_Up>()
, int> = 0> , int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR_AFTER_CXX17 optional(optional<_Up>&& __v) _LIBCPP_CONSTEXPR_CXX20 optional(optional<_Up>&& __v)
{ {
this->__construct_from(_VSTD::move(__v)); this->__construct_from(_VSTD::move(__v));
} }
template <class _Up, enable_if_t< template <class _Up, enable_if_t<
_CheckOptionalLikeCtor<_Up, _Up &&>::template __enable_explicit<_Up>() _CheckOptionalLikeCtor<_Up, _Up &&>::template __enable_explicit<_Up>()
, int> = 0> , int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR_AFTER_CXX17 explicit optional(optional<_Up>&& __v) _LIBCPP_CONSTEXPR_CXX20 explicit optional(optional<_Up>&& __v)
{ {
this->__construct_from(_VSTD::move(__v)); this->__construct_from(_VSTD::move(__v));
} }
#if _LIBCPP_STD_VER > 20 #if _LIBCPP_STD_VER > 20
template<class _Fp, class... _Args> template<class _Fp, class... _Args>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
constexpr explicit optional(__optional_construct_from_invoke_tag, _Fp&& __f, _Args&&... __args) constexpr explicit optional(__optional_construct_from_invoke_tag, _Fp&& __f, _Args&&... __args)
: __base(__optional_construct_from_invoke_tag{}, _VSTD::forward<_Fp>(__f), _VSTD::forward<_Args>(__args)...) { : __base(__optional_construct_from_invoke_tag{}, _VSTD::forward<_Fp>(__f), _VSTD::forward<_Args>(__args)...) {
} }
#endif #endif
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR_AFTER_CXX17 optional& operator=(nullopt_t) noexcept _LIBCPP_CONSTEXPR_CXX20 optional& operator=(nullopt_t) noexcept
{ {
reset(); reset();
return *this; return *this;
} }
_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<__uncvref_t<_Up>, optional>,
_Or< _Or<
_IsNotSame<__uncvref_t<_Up>, value_type>, _IsNotSame<__uncvref_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_AFTER_CXX17 optional& _LIBCPP_CONSTEXPR_CXX20 optional&
operator=(_Up&& __v) operator=(_Up&& __v)
{ {
if (this->has_value()) if (this->has_value())
this->__get() = _VSTD::forward<_Up>(__v); this->__get() = _VSTD::forward<_Up>(__v);
else else
this->__construct(_VSTD::forward<_Up>(__v)); this->__construct(_VSTD::forward<_Up>(__v));
return *this; return *this;
} }
// LWG2756 // LWG2756
template <class _Up, enable_if_t< template <class _Up, enable_if_t<
_CheckOptionalLikeAssign<_Up, _Up const&>::template __enable_assign<_Up>() _CheckOptionalLikeAssign<_Up, _Up const&>::template __enable_assign<_Up>()
, int> = 0> , int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR_AFTER_CXX17 optional& _LIBCPP_CONSTEXPR_CXX20 optional&
operator=(const optional<_Up>& __v) operator=(const optional<_Up>& __v)
{ {
this->__assign_from(__v); this->__assign_from(__v);
return *this; return *this;
} }
// LWG2756 // LWG2756
template <class _Up, enable_if_t< template <class _Up, enable_if_t<
_CheckOptionalLikeCtor<_Up, _Up &&>::template __enable_assign<_Up>() _CheckOptionalLikeCtor<_Up, _Up &&>::template __enable_assign<_Up>()
, int> = 0> , int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR_AFTER_CXX17 optional& _LIBCPP_CONSTEXPR_CXX20 optional&
operator=(optional<_Up>&& __v) operator=(optional<_Up>&& __v)
{ {
this->__assign_from(_VSTD::move(__v)); this->__assign_from(_VSTD::move(__v));
return *this; return *this;
} }
template <class... _Args, template <class... _Args,
class = enable_if_t class = enable_if_t
< <
is_constructible_v<value_type, _Args...> is_constructible_v<value_type, _Args...>
> >
> >
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR_AFTER_CXX17 _Tp & _LIBCPP_CONSTEXPR_CXX20 _Tp &
emplace(_Args&&... __args) emplace(_Args&&... __args)
{ {
reset(); reset();
this->__construct(_VSTD::forward<_Args>(__args)...); this->__construct(_VSTD::forward<_Args>(__args)...);
return this->__get(); return this->__get();
} }
template <class _Up, class... _Args, template <class _Up, class... _Args,
class = enable_if_t class = enable_if_t
< <
is_constructible_v<value_type, initializer_list<_Up>&, _Args...> is_constructible_v<value_type, initializer_list<_Up>&, _Args...>
> >
> >
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR_AFTER_CXX17 _Tp & _LIBCPP_CONSTEXPR_CXX20 _Tp &
emplace(initializer_list<_Up> __il, _Args&&... __args) emplace(initializer_list<_Up> __il, _Args&&... __args)
{ {
reset(); reset();
this->__construct(__il, _VSTD::forward<_Args>(__args)...); this->__construct(__il, _VSTD::forward<_Args>(__args)...);
return this->__get(); return this->__get();
} }
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR_AFTER_CXX17 void swap(optional& __opt) _LIBCPP_CONSTEXPR_CXX20 void swap(optional& __opt)
noexcept(is_nothrow_move_constructible_v<value_type> && noexcept(is_nothrow_move_constructible_v<value_type> &&
is_nothrow_swappable_v<value_type>) is_nothrow_swappable_v<value_type>)
{ {
if (this->has_value() == __opt.has_value()) if (this->has_value() == __opt.has_value())
{ {
using _VSTD::swap; using _VSTD::swap;
if (this->has_value()) if (this->has_value())
swap(this->__get(), __opt.__get()); swap(this->__get(), __opt.__get());
▲ Show 20 Lines • Show All 603 Lines • ▼ Show 20 Lines
> >
operator>=(const _Tp& __v, const optional<_Up>& __x) operator>=(const _Tp& __v, const optional<_Up>& __x)
{ {
return static_cast<bool>(__x) ? __v >= *__x : true; return static_cast<bool>(__x) ? __v >= *__x : true;
} }
template <class _Tp> template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
enable_if_t< enable_if_t<
is_move_constructible_v<_Tp> && is_swappable_v<_Tp>, is_move_constructible_v<_Tp> && is_swappable_v<_Tp>,
void void
> >
swap(optional<_Tp>& __x, optional<_Tp>& __y) noexcept(noexcept(__x.swap(__y))) swap(optional<_Tp>& __x, optional<_Tp>& __y) noexcept(noexcept(__x.swap(__y)))
{ {
__x.swap(__y); __x.swap(__y);
} }
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

libcxx/include/string

Show First 20 Lines • Show All 587 Lines • ▼ Show 20 Lines
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
// basic_string // basic_string
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
basic_string<_CharT, _Traits, _Allocator> basic_string<_CharT, _Traits, _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
operator+(const basic_string<_CharT, _Traits, _Allocator>& __x, operator+(const basic_string<_CharT, _Traits, _Allocator>& __x,
const basic_string<_CharT, _Traits, _Allocator>& __y); const basic_string<_CharT, _Traits, _Allocator>& __y);
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
basic_string<_CharT, _Traits, _Allocator> basic_string<_CharT, _Traits, _Allocator>
operator+(const _CharT* __x, const basic_string<_CharT,_Traits,_Allocator>& __y); operator+(const _CharT* __x, const basic_string<_CharT,_Traits,_Allocator>& __y);
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
basic_string<_CharT, _Traits, _Allocator> basic_string<_CharT, _Traits, _Allocator>
operator+(_CharT __x, const basic_string<_CharT,_Traits,_Allocator>& __y); operator+(_CharT __x, const basic_string<_CharT,_Traits,_Allocator>& __y);
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
basic_string<_CharT, _Traits, _Allocator> basic_string<_CharT, _Traits, _Allocator>
operator+(const basic_string<_CharT, _Traits, _Allocator>& __x, const _CharT* __y); operator+(const basic_string<_CharT, _Traits, _Allocator>& __x, const _CharT* __y);
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
basic_string<_CharT, _Traits, _Allocator> basic_string<_CharT, _Traits, _Allocator>
operator+(const basic_string<_CharT, _Traits, _Allocator>& __x, _CharT __y); operator+(const basic_string<_CharT, _Traits, _Allocator>& __x, _CharT __y);
extern template _LIBCPP_FUNC_VIS string operator+<char, char_traits<char>, allocator<char> >(char const*, string const&); extern template _LIBCPP_FUNC_VIS string operator+<char, char_traits<char>, allocator<char> >(char const*, string const&);
template <class _Iter> template <class _Iter>
struct __string_is_trivial_iterator : public false_type {}; struct __string_is_trivial_iterator : public false_type {};
▲ Show 20 Lines • Show All 157 Lines • ▼ Show 20 Lines struct __rep
}; };
}; };
__compressed_pair<__rep, allocator_type> __r_; __compressed_pair<__rep, allocator_type> __r_;
// Construct a string with the given allocator and enough storage to hold `__size` characters, but // Construct a string with the given allocator and enough storage to hold `__size` characters, but
// don't initialize the characters. The contents of the string, including the null terminator, must be // don't initialize the characters. The contents of the string, including the null terminator, must be
// initialized separately. // initialized separately.
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
explicit basic_string(__uninitialized_size_tag, size_type __size, const allocator_type& __a) explicit basic_string(__uninitialized_size_tag, size_type __size, const allocator_type& __a)
: __r_(__default_init_tag(), __a) { : __r_(__default_init_tag(), __a) {
if (__size > max_size()) if (__size > max_size())
__throw_length_error(); __throw_length_error();
if (__fits_in_sso(__size)) { if (__fits_in_sso(__size)) {
__zero(); __zero();
__set_short_size(__size); __set_short_size(__size);
} else { } else {
auto __capacity = __recommend(__size) + 1; auto __capacity = __recommend(__size) + 1;
auto __allocation = __alloc_traits::allocate(__alloc(), __capacity); auto __allocation = __alloc_traits::allocate(__alloc(), __capacity);
__begin_lifetime(__allocation, __capacity); __begin_lifetime(__allocation, __capacity);
__set_long_cap(__capacity); __set_long_cap(__capacity);
__set_long_pointer(__allocation); __set_long_pointer(__allocation);
__set_long_size(__size); __set_long_size(__size);
} }
std::__debug_db_insert_c(this); std::__debug_db_insert_c(this);
} }
public: public:
_LIBCPP_TEMPLATE_DATA_VIS _LIBCPP_TEMPLATE_DATA_VIS
static const size_type npos = -1; static const size_type npos = -1;
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 basic_string() _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20 basic_string()
_NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value); _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value);
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 explicit basic_string(const allocator_type& __a) _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20 explicit basic_string(const allocator_type& __a)
#if _LIBCPP_STD_VER <= 14 #if _LIBCPP_STD_VER <= 14
_NOEXCEPT_(is_nothrow_copy_constructible<allocator_type>::value); _NOEXCEPT_(is_nothrow_copy_constructible<allocator_type>::value);
#else #else
_NOEXCEPT; _NOEXCEPT;
#endif #endif
_LIBCPP_CONSTEXPR_AFTER_CXX17 basic_string(const basic_string& __str); _LIBCPP_CONSTEXPR_CXX20 basic_string(const basic_string& __str);
_LIBCPP_CONSTEXPR_AFTER_CXX17 basic_string(const basic_string& __str, const allocator_type& __a); _LIBCPP_CONSTEXPR_CXX20 basic_string(const basic_string& __str, const allocator_type& __a);
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
basic_string(basic_string&& __str) basic_string(basic_string&& __str)
#if _LIBCPP_STD_VER <= 14 #if _LIBCPP_STD_VER <= 14
_NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value); _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value);
#else #else
_NOEXCEPT; _NOEXCEPT;
#endif #endif
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
basic_string(basic_string&& __str, const allocator_type& __a); basic_string(basic_string&& __str, const allocator_type& __a);
#endif // _LIBCPP_CXX03_LANG #endif // _LIBCPP_CXX03_LANG
template <class = __enable_if_t<__is_allocator<_Allocator>::value, nullptr_t> > template <class = __enable_if_t<__is_allocator<_Allocator>::value, nullptr_t> >
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
basic_string(const _CharT* __s) : __r_(__default_init_tag(), __default_init_tag()) { basic_string(const _CharT* __s) : __r_(__default_init_tag(), __default_init_tag()) {
_LIBCPP_ASSERT(__s != nullptr, "basic_string(const char*) detected nullptr"); _LIBCPP_ASSERT(__s != nullptr, "basic_string(const char*) detected nullptr");
__init(__s, traits_type::length(__s)); __init(__s, traits_type::length(__s));
std::__debug_db_insert_c(this); std::__debug_db_insert_c(this);
} }
template <class = __enable_if_t<__is_allocator<_Allocator>::value, nullptr_t> > template <class = __enable_if_t<__is_allocator<_Allocator>::value, nullptr_t> >
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
basic_string(const _CharT* __s, const _Allocator& __a); basic_string(const _CharT* __s, const _Allocator& __a);
#if _LIBCPP_STD_VER > 20 #if _LIBCPP_STD_VER > 20
basic_string(nullptr_t) = delete; basic_string(nullptr_t) = delete;
#endif #endif
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
basic_string(const _CharT* __s, size_type __n); basic_string(const _CharT* __s, size_type __n);
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
basic_string(const _CharT* __s, size_type __n, const _Allocator& __a); basic_string(const _CharT* __s, size_type __n, const _Allocator& __a);
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
basic_string(size_type __n, _CharT __c); basic_string(size_type __n, _CharT __c);
template <class = __enable_if_t<__is_allocator<_Allocator>::value, nullptr_t> > template <class = __enable_if_t<__is_allocator<_Allocator>::value, nullptr_t> >
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
basic_string(size_type __n, _CharT __c, const _Allocator& __a); basic_string(size_type __n, _CharT __c, const _Allocator& __a);
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
basic_string(const basic_string& __str, size_type __pos, size_type __n, basic_string(const basic_string& __str, size_type __pos, size_type __n,
const _Allocator& __a = _Allocator()); const _Allocator& __a = _Allocator());
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
basic_string(const basic_string& __str, size_type __pos, basic_string(const basic_string& __str, size_type __pos,
const _Allocator& __a = _Allocator()); const _Allocator& __a = _Allocator());
template<class _Tp, class = __enable_if_t<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value && !__is_same_uncvref<_Tp, basic_string>::value> > template<class _Tp, class = __enable_if_t<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value && !__is_same_uncvref<_Tp, basic_string>::value> >
_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_CXX20
basic_string(const _Tp& __t, size_type __pos, size_type __n, basic_string(const _Tp& __t, size_type __pos, size_type __n,
const allocator_type& __a = allocator_type()); const allocator_type& __a = allocator_type());
template<class _Tp, class = __enable_if_t<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value && template<class _Tp, class = __enable_if_t<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value &&
!__is_same_uncvref<_Tp, basic_string>::value> > !__is_same_uncvref<_Tp, basic_string>::value> >
_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_CXX20
explicit basic_string(const _Tp& __t); explicit basic_string(const _Tp& __t);
template<class _Tp, class = __enable_if_t<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value && !__is_same_uncvref<_Tp, basic_string>::value> > template<class _Tp, class = __enable_if_t<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value && !__is_same_uncvref<_Tp, basic_string>::value> >
_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_CXX20
explicit basic_string(const _Tp& __t, const allocator_type& __a); explicit basic_string(const _Tp& __t, const allocator_type& __a);
template<class _InputIterator, class = __enable_if_t<__is_cpp17_input_iterator<_InputIterator>::value> > template<class _InputIterator, class = __enable_if_t<__is_cpp17_input_iterator<_InputIterator>::value> >
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
basic_string(_InputIterator __first, _InputIterator __last); basic_string(_InputIterator __first, _InputIterator __last);
template<class _InputIterator, class = __enable_if_t<__is_cpp17_input_iterator<_InputIterator>::value> > template<class _InputIterator, class = __enable_if_t<__is_cpp17_input_iterator<_InputIterator>::value> >
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
basic_string(_InputIterator __first, _InputIterator __last, const allocator_type& __a); basic_string(_InputIterator __first, _InputIterator __last, const allocator_type& __a);
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
basic_string(initializer_list<_CharT> __il); basic_string(initializer_list<_CharT> __il);
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
basic_string(initializer_list<_CharT> __il, const _Allocator& __a); basic_string(initializer_list<_CharT> __il, const _Allocator& __a);
#endif // _LIBCPP_CXX03_LANG #endif // _LIBCPP_CXX03_LANG
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 ~basic_string(); inline _LIBCPP_CONSTEXPR_CXX20 ~basic_string();
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
operator __self_view() const _NOEXCEPT { return __self_view(data(), size()); } operator __self_view() const _NOEXCEPT { return __self_view(data(), size()); }
_LIBCPP_CONSTEXPR_AFTER_CXX17 basic_string& operator=(const basic_string& __str); _LIBCPP_CONSTEXPR_CXX20 basic_string& operator=(const basic_string& __str);
template <class _Tp, class = __enable_if_t<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value && template <class _Tp, class = __enable_if_t<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value &&
!__is_same_uncvref<_Tp, basic_string>::value> > !__is_same_uncvref<_Tp, basic_string>::value> >
_LIBCPP_CONSTEXPR_AFTER_CXX17 basic_string& operator=(const _Tp& __t) { _LIBCPP_CONSTEXPR_CXX20 basic_string& operator=(const _Tp& __t) {
__self_view __sv = __t; __self_view __sv = __t;
return assign(__sv); return assign(__sv);
} }
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
basic_string& operator=(basic_string&& __str) basic_string& operator=(basic_string&& __str)
_NOEXCEPT_((__noexcept_move_assign_container<_Allocator, __alloc_traits>::value)); _NOEXCEPT_((__noexcept_move_assign_container<_Allocator, __alloc_traits>::value));
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
basic_string& operator=(initializer_list<value_type> __il) {return assign(__il.begin(), __il.size());} basic_string& operator=(initializer_list<value_type> __il) {return assign(__il.begin(), __il.size());}
#endif #endif
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
basic_string& operator=(const value_type* __s) {return assign(__s);} basic_string& operator=(const value_type* __s) {return assign(__s);}
#if _LIBCPP_STD_VER > 20 #if _LIBCPP_STD_VER > 20
basic_string& operator=(nullptr_t) = delete; basic_string& operator=(nullptr_t) = delete;
#endif #endif
_LIBCPP_CONSTEXPR_AFTER_CXX17 basic_string& operator=(value_type __c); _LIBCPP_CONSTEXPR_CXX20 basic_string& operator=(value_type __c);
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
iterator begin() _NOEXCEPT iterator begin() _NOEXCEPT
{return iterator(this, __get_pointer());} {return iterator(this, __get_pointer());}
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
const_iterator begin() const _NOEXCEPT const_iterator begin() const _NOEXCEPT
{return const_iterator(this, __get_pointer());} {return const_iterator(this, __get_pointer());}
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
iterator end() _NOEXCEPT iterator end() _NOEXCEPT
{return iterator(this, __get_pointer() + size());} {return iterator(this, __get_pointer() + size());}
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
const_iterator end() const _NOEXCEPT const_iterator end() const _NOEXCEPT
{return const_iterator(this, __get_pointer() + size());} {return const_iterator(this, __get_pointer() + size());}
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
reverse_iterator rbegin() _NOEXCEPT reverse_iterator rbegin() _NOEXCEPT
{return reverse_iterator(end());} {return reverse_iterator(end());}
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
const_reverse_iterator rbegin() const _NOEXCEPT const_reverse_iterator rbegin() const _NOEXCEPT
{return const_reverse_iterator(end());} {return const_reverse_iterator(end());}
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
reverse_iterator rend() _NOEXCEPT reverse_iterator rend() _NOEXCEPT
{return reverse_iterator(begin());} {return reverse_iterator(begin());}
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
const_reverse_iterator rend() const _NOEXCEPT const_reverse_iterator rend() const _NOEXCEPT
{return const_reverse_iterator(begin());} {return const_reverse_iterator(begin());}
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
const_iterator cbegin() const _NOEXCEPT const_iterator cbegin() const _NOEXCEPT
{return begin();} {return begin();}
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
const_iterator cend() const _NOEXCEPT const_iterator cend() const _NOEXCEPT
{return end();} {return end();}
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
const_reverse_iterator crbegin() const _NOEXCEPT const_reverse_iterator crbegin() const _NOEXCEPT
{return rbegin();} {return rbegin();}
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
const_reverse_iterator crend() const _NOEXCEPT const_reverse_iterator crend() const _NOEXCEPT
{return rend();} {return rend();}
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 size_type size() const _NOEXCEPT _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20 size_type size() const _NOEXCEPT
{return __is_long() ? __get_long_size() : __get_short_size();} {return __is_long() ? __get_long_size() : __get_short_size();}
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 size_type length() const _NOEXCEPT {return size();} _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20 size_type length() const _NOEXCEPT {return size();}
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 size_type max_size() const _NOEXCEPT; _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20 size_type max_size() const _NOEXCEPT;
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 size_type capacity() const _NOEXCEPT { _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20 size_type capacity() const _NOEXCEPT {
return (__is_long() ? __get_long_cap() : static_cast<size_type>(__min_cap)) - 1; return (__is_long() ? __get_long_cap() : static_cast<size_type>(__min_cap)) - 1;
} }
_LIBCPP_CONSTEXPR_AFTER_CXX17 void resize(size_type __n, value_type __c); _LIBCPP_CONSTEXPR_CXX20 void resize(size_type __n, value_type __c);
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 void resize(size_type __n) { resize(__n, value_type()); } _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20 void resize(size_type __n) { resize(__n, value_type()); }
_LIBCPP_CONSTEXPR_AFTER_CXX17 void reserve(size_type __requested_capacity); _LIBCPP_CONSTEXPR_CXX20 void reserve(size_type __requested_capacity);
#if _LIBCPP_STD_VER > 20 #if _LIBCPP_STD_VER > 20
template <class _Op> template <class _Op>
_LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_HIDE_FROM_ABI constexpr
void resize_and_overwrite(size_type __n, _Op __op) { void resize_and_overwrite(size_type __n, _Op __op) {
__resize_default_init(__n); __resize_default_init(__n);
__erase_to_end(std::move(__op)(data(), _LIBCPP_AUTO_CAST(__n))); __erase_to_end(std::move(__op)(data(), _LIBCPP_AUTO_CAST(__n)));
} }
#endif #endif
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 void __resize_default_init(size_type __n); _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20 void __resize_default_init(size_type __n);
_LIBCPP_DEPRECATED_IN_CXX20 _LIBCPP_HIDE_FROM_ABI void reserve() _NOEXCEPT { shrink_to_fit(); } _LIBCPP_DEPRECATED_IN_CXX20 _LIBCPP_HIDE_FROM_ABI void reserve() _NOEXCEPT { shrink_to_fit(); }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 void shrink_to_fit() _NOEXCEPT; _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20 void shrink_to_fit() _NOEXCEPT;
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 void clear() _NOEXCEPT; _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20 void clear() _NOEXCEPT;
_LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
bool empty() const _NOEXCEPT {return size() == 0;} bool empty() const _NOEXCEPT {return size() == 0;}
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
const_reference operator[](size_type __pos) const _NOEXCEPT; const_reference operator[](size_type __pos) const _NOEXCEPT;
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 reference operator[](size_type __pos) _NOEXCEPT; _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20 reference operator[](size_type __pos) _NOEXCEPT;
_LIBCPP_CONSTEXPR_AFTER_CXX17 const_reference at(size_type __n) const; _LIBCPP_CONSTEXPR_CXX20 const_reference at(size_type __n) const;
_LIBCPP_CONSTEXPR_AFTER_CXX17 reference at(size_type __n); _LIBCPP_CONSTEXPR_CXX20 reference at(size_type __n);
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 basic_string& operator+=(const basic_string& __str) { _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20 basic_string& operator+=(const basic_string& __str) {
return append(__str); return append(__str);
} }
template <class _Tp> template <class _Tp>
_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_CXX20
__enable_if_t __enable_if_t
< <
__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value
&& !__is_same_uncvref<_Tp, basic_string >::value, && !__is_same_uncvref<_Tp, basic_string >::value,
basic_string& basic_string&
> >
operator+=(const _Tp& __t) { operator+=(const _Tp& __t) {
__self_view __sv = __t; return append(__sv); __self_view __sv = __t; return append(__sv);
} }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 basic_string& operator+=(const value_type* __s) { _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20 basic_string& operator+=(const value_type* __s) {
return append(__s); return append(__s);
} }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 basic_string& operator+=(value_type __c) { _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20 basic_string& operator+=(value_type __c) {
push_back(__c); push_back(__c);
return *this; return *this;
} }
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
basic_string& operator+=(initializer_list<value_type> __il) { return append(__il); } basic_string& operator+=(initializer_list<value_type> __il) { return append(__il); }
#endif // _LIBCPP_CXX03_LANG #endif // _LIBCPP_CXX03_LANG
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
basic_string& append(const basic_string& __str); basic_string& append(const basic_string& __str);
template <class _Tp> template <class _Tp>
_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_CXX20
__enable_if_t< __enable_if_t<
__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value
&& !__is_same_uncvref<_Tp, basic_string>::value, && !__is_same_uncvref<_Tp, basic_string>::value,
basic_string& basic_string&
> >
append(const _Tp& __t) { __self_view __sv = __t; return append(__sv.data(), __sv.size()); } append(const _Tp& __t) { __self_view __sv = __t; return append(__sv.data(), __sv.size()); }
_LIBCPP_CONSTEXPR_AFTER_CXX17 basic_string& append(const basic_string& __str, size_type __pos, size_type __n=npos); _LIBCPP_CONSTEXPR_CXX20 basic_string& append(const basic_string& __str, size_type __pos, size_type __n=npos);
template <class _Tp> template <class _Tp>
_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_CXX20
__enable_if_t __enable_if_t
< <
__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value
&& !__is_same_uncvref<_Tp, basic_string>::value, && !__is_same_uncvref<_Tp, basic_string>::value,
basic_string& basic_string&
> >
append(const _Tp& __t, size_type __pos, size_type __n=npos); append(const _Tp& __t, size_type __pos, size_type __n=npos);
_LIBCPP_CONSTEXPR_AFTER_CXX17 basic_string& append(const value_type* __s, size_type __n); _LIBCPP_CONSTEXPR_CXX20 basic_string& append(const value_type* __s, size_type __n);
_LIBCPP_CONSTEXPR_AFTER_CXX17 basic_string& append(const value_type* __s); _LIBCPP_CONSTEXPR_CXX20 basic_string& append(const value_type* __s);
_LIBCPP_CONSTEXPR_AFTER_CXX17 basic_string& append(size_type __n, value_type __c); _LIBCPP_CONSTEXPR_CXX20 basic_string& append(size_type __n, value_type __c);
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
void __append_default_init(size_type __n); void __append_default_init(size_type __n);
template<class _InputIterator> template<class _InputIterator>
_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
__enable_if_t __enable_if_t
< <
__is_exactly_cpp17_input_iterator<_InputIterator>::value, __is_exactly_cpp17_input_iterator<_InputIterator>::value,
basic_string& basic_string&
> >
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
append(_InputIterator __first, _InputIterator __last) { append(_InputIterator __first, _InputIterator __last) {
const basic_string __temp(__first, __last, __alloc()); const basic_string __temp(__first, __last, __alloc());
append(__temp.data(), __temp.size()); append(__temp.data(), __temp.size());
return *this; return *this;
} }
template<class _ForwardIterator> template<class _ForwardIterator>
_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
__enable_if_t __enable_if_t
< <
__is_cpp17_forward_iterator<_ForwardIterator>::value, __is_cpp17_forward_iterator<_ForwardIterator>::value,
basic_string& basic_string&
> >
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
append(_ForwardIterator __first, _ForwardIterator __last); append(_ForwardIterator __first, _ForwardIterator __last);
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
basic_string& append(initializer_list<value_type> __il) {return append(__il.begin(), __il.size());} basic_string& append(initializer_list<value_type> __il) {return append(__il.begin(), __il.size());}
#endif // _LIBCPP_CXX03_LANG #endif // _LIBCPP_CXX03_LANG
_LIBCPP_CONSTEXPR_AFTER_CXX17 void push_back(value_type __c); _LIBCPP_CONSTEXPR_CXX20 void push_back(value_type __c);
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 void pop_back(); _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20 void pop_back();
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 reference front() _NOEXCEPT; _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20 reference front() _NOEXCEPT;
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 const_reference front() const _NOEXCEPT; _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20 const_reference front() const _NOEXCEPT;
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 reference back() _NOEXCEPT; _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20 reference back() _NOEXCEPT;
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 const_reference back() const _NOEXCEPT; _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20 const_reference back() const _NOEXCEPT;
template <class _Tp> template <class _Tp>
_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_CXX20
__enable_if_t __enable_if_t
< <
__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
basic_string& basic_string&
> >
assign(const _Tp & __t) { __self_view __sv = __t; return assign(__sv.data(), __sv.size()); } assign(const _Tp & __t) { __self_view __sv = __t; return assign(__sv.data(), __sv.size()); }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
basic_string& assign(const basic_string& __str) { return *this = __str; } basic_string& assign(const basic_string& __str) { return *this = __str; }
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
basic_string& assign(basic_string&& __str) basic_string& assign(basic_string&& __str)
_NOEXCEPT_((__noexcept_move_assign_container<_Allocator, __alloc_traits>::value)) _NOEXCEPT_((__noexcept_move_assign_container<_Allocator, __alloc_traits>::value))
{*this = std::move(__str); return *this;} {*this = std::move(__str); return *this;}
#endif #endif
_LIBCPP_CONSTEXPR_AFTER_CXX17 basic_string& assign(const basic_string& __str, size_type __pos, size_type __n=npos); _LIBCPP_CONSTEXPR_CXX20 basic_string& assign(const basic_string& __str, size_type __pos, size_type __n=npos);
template <class _Tp> template <class _Tp>
_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_CXX20
__enable_if_t __enable_if_t
< <
__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value
&& !__is_same_uncvref<_Tp, basic_string>::value, && !__is_same_uncvref<_Tp, basic_string>::value,
basic_string& basic_string&
> >
assign(const _Tp & __t, size_type __pos, size_type __n=npos); assign(const _Tp & __t, size_type __pos, size_type __n=npos);
_LIBCPP_CONSTEXPR_AFTER_CXX17 basic_string& assign(const value_type* __s, size_type __n); _LIBCPP_CONSTEXPR_CXX20 basic_string& assign(const value_type* __s, size_type __n);
_LIBCPP_CONSTEXPR_AFTER_CXX17 basic_string& assign(const value_type* __s); _LIBCPP_CONSTEXPR_CXX20 basic_string& assign(const value_type* __s);
_LIBCPP_CONSTEXPR_AFTER_CXX17 basic_string& assign(size_type __n, value_type __c); _LIBCPP_CONSTEXPR_CXX20 basic_string& assign(size_type __n, value_type __c);
template<class _InputIterator> template<class _InputIterator>
_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_CXX20
__enable_if_t __enable_if_t
< <
__is_exactly_cpp17_input_iterator<_InputIterator>::value, __is_exactly_cpp17_input_iterator<_InputIterator>::value,
basic_string& basic_string&
> >
assign(_InputIterator __first, _InputIterator __last); assign(_InputIterator __first, _InputIterator __last);
template<class _ForwardIterator> template<class _ForwardIterator>
_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_CXX20
__enable_if_t __enable_if_t
< <
__is_cpp17_forward_iterator<_ForwardIterator>::value, __is_cpp17_forward_iterator<_ForwardIterator>::value,
basic_string& basic_string&
> >
assign(_ForwardIterator __first, _ForwardIterator __last); assign(_ForwardIterator __first, _ForwardIterator __last);
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
basic_string& assign(initializer_list<value_type> __il) {return assign(__il.begin(), __il.size());} basic_string& assign(initializer_list<value_type> __il) {return assign(__il.begin(), __il.size());}
#endif // _LIBCPP_CXX03_LANG #endif // _LIBCPP_CXX03_LANG
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
basic_string& insert(size_type __pos1, const basic_string& __str); basic_string& insert(size_type __pos1, const basic_string& __str);
template <class _Tp> template <class _Tp>
_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_CXX20
__enable_if_t __enable_if_t
< <
__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
basic_string& basic_string&
> >
insert(size_type __pos1, const _Tp& __t) insert(size_type __pos1, const _Tp& __t)
{ __self_view __sv = __t; return insert(__pos1, __sv.data(), __sv.size()); } { __self_view __sv = __t; return insert(__pos1, __sv.data(), __sv.size()); }
template <class _Tp> template <class _Tp>
_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_CXX20
__enable_if_t __enable_if_t
< <
__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value && !__is_same_uncvref<_Tp, basic_string>::value, __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value && !__is_same_uncvref<_Tp, basic_string>::value,
basic_string& basic_string&
> >
insert(size_type __pos1, const _Tp& __t, size_type __pos2, size_type __n=npos); insert(size_type __pos1, const _Tp& __t, size_type __pos2, size_type __n=npos);
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
basic_string& insert(size_type __pos1, const basic_string& __str, size_type __pos2, size_type __n=npos); basic_string& insert(size_type __pos1, const basic_string& __str, size_type __pos2, size_type __n=npos);
_LIBCPP_CONSTEXPR_AFTER_CXX17 basic_string& insert(size_type __pos, const value_type* __s, size_type __n); _LIBCPP_CONSTEXPR_CXX20 basic_string& insert(size_type __pos, const value_type* __s, size_type __n);
_LIBCPP_CONSTEXPR_AFTER_CXX17 basic_string& insert(size_type __pos, const value_type* __s); _LIBCPP_CONSTEXPR_CXX20 basic_string& insert(size_type __pos, const value_type* __s);
_LIBCPP_CONSTEXPR_AFTER_CXX17 basic_string& insert(size_type __pos, size_type __n, value_type __c); _LIBCPP_CONSTEXPR_CXX20 basic_string& insert(size_type __pos, size_type __n, value_type __c);
_LIBCPP_CONSTEXPR_AFTER_CXX17 iterator insert(const_iterator __pos, value_type __c); _LIBCPP_CONSTEXPR_CXX20 iterator insert(const_iterator __pos, value_type __c);
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
iterator insert(const_iterator __pos, size_type __n, value_type __c); iterator insert(const_iterator __pos, size_type __n, value_type __c);
template<class _InputIterator> template<class _InputIterator>
_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_CXX20
__enable_if_t __enable_if_t
< <
__is_exactly_cpp17_input_iterator<_InputIterator>::value, __is_exactly_cpp17_input_iterator<_InputIterator>::value,
iterator iterator
> >
insert(const_iterator __pos, _InputIterator __first, _InputIterator __last); insert(const_iterator __pos, _InputIterator __first, _InputIterator __last);
template<class _ForwardIterator> template<class _ForwardIterator>
_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_CXX20
__enable_if_t __enable_if_t
< <
__is_cpp17_forward_iterator<_ForwardIterator>::value, __is_cpp17_forward_iterator<_ForwardIterator>::value,
iterator iterator
> >
insert(const_iterator __pos, _ForwardIterator __first, _ForwardIterator __last); insert(const_iterator __pos, _ForwardIterator __first, _ForwardIterator __last);
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
iterator insert(const_iterator __pos, initializer_list<value_type> __il) iterator insert(const_iterator __pos, initializer_list<value_type> __il)
{return insert(__pos, __il.begin(), __il.end());} {return insert(__pos, __il.begin(), __il.end());}
#endif // _LIBCPP_CXX03_LANG #endif // _LIBCPP_CXX03_LANG
_LIBCPP_CONSTEXPR_AFTER_CXX17 basic_string& erase(size_type __pos = 0, size_type __n = npos); _LIBCPP_CONSTEXPR_CXX20 basic_string& erase(size_type __pos = 0, size_type __n = npos);
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
iterator erase(const_iterator __pos); iterator erase(const_iterator __pos);
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
iterator erase(const_iterator __first, const_iterator __last); iterator erase(const_iterator __first, const_iterator __last);
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
basic_string& replace(size_type __pos1, size_type __n1, const basic_string& __str); basic_string& replace(size_type __pos1, size_type __n1, const basic_string& __str);
template <class _Tp> template <class _Tp>
_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_CXX20
__enable_if_t __enable_if_t
< <
__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
basic_string& basic_string&
> >
replace(size_type __pos1, size_type __n1, const _Tp& __t) { __self_view __sv = __t; return replace(__pos1, __n1, __sv.data(), __sv.size()); } replace(size_type __pos1, size_type __n1, const _Tp& __t) { __self_view __sv = __t; return replace(__pos1, __n1, __sv.data(), __sv.size()); }
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
basic_string& replace(size_type __pos1, size_type __n1, const basic_string& __str, size_type __pos2, size_type __n2=npos); basic_string& replace(size_type __pos1, size_type __n1, const basic_string& __str, size_type __pos2, size_type __n2=npos);
template <class _Tp> template <class _Tp>
_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_CXX20
__enable_if_t __enable_if_t
< <
__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value && !__is_same_uncvref<_Tp, basic_string>::value, __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value && !__is_same_uncvref<_Tp, basic_string>::value,
basic_string& basic_string&
> >
replace(size_type __pos1, size_type __n1, const _Tp& __t, size_type __pos2, size_type __n2=npos); replace(size_type __pos1, size_type __n1, const _Tp& __t, size_type __pos2, size_type __n2=npos);
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
basic_string& replace(size_type __pos, size_type __n1, const value_type* __s, size_type __n2); basic_string& replace(size_type __pos, size_type __n1, const value_type* __s, size_type __n2);
_LIBCPP_CONSTEXPR_AFTER_CXX17 basic_string& replace(size_type __pos, size_type __n1, const value_type* __s); _LIBCPP_CONSTEXPR_CXX20 basic_string& replace(size_type __pos, size_type __n1, const value_type* __s);
_LIBCPP_CONSTEXPR_AFTER_CXX17 basic_string& replace(size_type __pos, size_type __n1, size_type __n2, value_type __c); _LIBCPP_CONSTEXPR_CXX20 basic_string& replace(size_type __pos, size_type __n1, size_type __n2, value_type __c);
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
basic_string& replace(const_iterator __i1, const_iterator __i2, const basic_string& __str); basic_string& replace(const_iterator __i1, const_iterator __i2, const basic_string& __str);
template <class _Tp> template <class _Tp>
_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_CXX20
__enable_if_t __enable_if_t
< <
__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
basic_string& basic_string&
> >
replace(const_iterator __i1, const_iterator __i2, const _Tp& __t) { __self_view __sv = __t; return replace(__i1 - begin(), __i2 - __i1, __sv); } replace(const_iterator __i1, const_iterator __i2, const _Tp& __t) { __self_view __sv = __t; return replace(__i1 - begin(), __i2 - __i1, __sv); }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
basic_string& replace(const_iterator __i1, const_iterator __i2, const value_type* __s, size_type __n); basic_string& replace(const_iterator __i1, const_iterator __i2, const value_type* __s, size_type __n);
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
basic_string& replace(const_iterator __i1, const_iterator __i2, const value_type* __s); basic_string& replace(const_iterator __i1, const_iterator __i2, const value_type* __s);
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
basic_string& replace(const_iterator __i1, const_iterator __i2, size_type __n, value_type __c); basic_string& replace(const_iterator __i1, const_iterator __i2, size_type __n, value_type __c);
template<class _InputIterator> template<class _InputIterator>
_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_CXX20
__enable_if_t __enable_if_t
< <
__is_cpp17_input_iterator<_InputIterator>::value, __is_cpp17_input_iterator<_InputIterator>::value,
basic_string& basic_string&
> >
replace(const_iterator __i1, const_iterator __i2, _InputIterator __j1, _InputIterator __j2); replace(const_iterator __i1, const_iterator __i2, _InputIterator __j1, _InputIterator __j2);
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
basic_string& replace(const_iterator __i1, const_iterator __i2, initializer_list<value_type> __il) basic_string& replace(const_iterator __i1, const_iterator __i2, initializer_list<value_type> __il)
{return replace(__i1, __i2, __il.begin(), __il.end());} {return replace(__i1, __i2, __il.begin(), __il.end());}
#endif // _LIBCPP_CXX03_LANG #endif // _LIBCPP_CXX03_LANG
_LIBCPP_CONSTEXPR_AFTER_CXX17 size_type copy(value_type* __s, size_type __n, size_type __pos = 0) const; _LIBCPP_CONSTEXPR_CXX20 size_type copy(value_type* __s, size_type __n, size_type __pos = 0) const;
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
basic_string substr(size_type __pos = 0, size_type __n = npos) const; basic_string substr(size_type __pos = 0, size_type __n = npos) const;
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
void swap(basic_string& __str) void swap(basic_string& __str)
#if _LIBCPP_STD_VER >= 14 #if _LIBCPP_STD_VER >= 14
_NOEXCEPT; _NOEXCEPT;
#else #else
_NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value || _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value ||
__is_nothrow_swappable<allocator_type>::value); __is_nothrow_swappable<allocator_type>::value);
#endif #endif
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
const value_type* c_str() const _NOEXCEPT {return data();} const value_type* c_str() const _NOEXCEPT {return data();}
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
const value_type* data() const _NOEXCEPT {return std::__to_address(__get_pointer());} const value_type* data() const _NOEXCEPT {return std::__to_address(__get_pointer());}
#if _LIBCPP_STD_VER > 14 || defined(_LIBCPP_BUILDING_LIBRARY) #if _LIBCPP_STD_VER > 14 || defined(_LIBCPP_BUILDING_LIBRARY)
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
value_type* data() _NOEXCEPT {return std::__to_address(__get_pointer());} value_type* data() _NOEXCEPT {return std::__to_address(__get_pointer());}
#endif #endif
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
allocator_type get_allocator() const _NOEXCEPT {return __alloc();} allocator_type get_allocator() const _NOEXCEPT {return __alloc();}
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
size_type find(const basic_string& __str, size_type __pos = 0) const _NOEXCEPT; size_type find(const basic_string& __str, size_type __pos = 0) const _NOEXCEPT;
template <class _Tp> template <class _Tp>
_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_CXX20
__enable_if_t __enable_if_t
< <
__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
size_type size_type
> >
find(const _Tp& __t, size_type __pos = 0) const _NOEXCEPT; find(const _Tp& __t, size_type __pos = 0) const _NOEXCEPT;
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
size_type find(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT; size_type find(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT;
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
size_type find(const value_type* __s, size_type __pos = 0) const _NOEXCEPT; size_type find(const value_type* __s, size_type __pos = 0) const _NOEXCEPT;
_LIBCPP_CONSTEXPR_AFTER_CXX17 size_type find(value_type __c, size_type __pos = 0) const _NOEXCEPT; _LIBCPP_CONSTEXPR_CXX20 size_type find(value_type __c, size_type __pos = 0) const _NOEXCEPT;
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
size_type rfind(const basic_string& __str, size_type __pos = npos) const _NOEXCEPT; size_type rfind(const basic_string& __str, size_type __pos = npos) const _NOEXCEPT;
template <class _Tp> template <class _Tp>
_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_CXX20
__enable_if_t __enable_if_t
< <
__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
size_type size_type
> >
rfind(const _Tp& __t, size_type __pos = npos) const _NOEXCEPT; rfind(const _Tp& __t, size_type __pos = npos) const _NOEXCEPT;
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
size_type rfind(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT; size_type rfind(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT;
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
size_type rfind(const value_type* __s, size_type __pos = npos) const _NOEXCEPT; size_type rfind(const value_type* __s, size_type __pos = npos) const _NOEXCEPT;
_LIBCPP_CONSTEXPR_AFTER_CXX17 size_type rfind(value_type __c, size_type __pos = npos) const _NOEXCEPT; _LIBCPP_CONSTEXPR_CXX20 size_type rfind(value_type __c, size_type __pos = npos) const _NOEXCEPT;
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
size_type find_first_of(const basic_string& __str, size_type __pos = 0) const _NOEXCEPT; size_type find_first_of(const basic_string& __str, size_type __pos = 0) const _NOEXCEPT;
template <class _Tp> template <class _Tp>
_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_CXX20
__enable_if_t __enable_if_t
< <
__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
size_type size_type
> >
find_first_of(const _Tp& __t, size_type __pos = 0) const _NOEXCEPT; find_first_of(const _Tp& __t, size_type __pos = 0) const _NOEXCEPT;
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
size_type find_first_of(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT; size_type find_first_of(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT;
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
size_type find_first_of(const value_type* __s, size_type __pos = 0) const _NOEXCEPT; size_type find_first_of(const value_type* __s, size_type __pos = 0) const _NOEXCEPT;
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
size_type find_first_of(value_type __c, size_type __pos = 0) const _NOEXCEPT; size_type find_first_of(value_type __c, size_type __pos = 0) const _NOEXCEPT;
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
size_type find_last_of(const basic_string& __str, size_type __pos = npos) const _NOEXCEPT; size_type find_last_of(const basic_string& __str, size_type __pos = npos) const _NOEXCEPT;
template <class _Tp> template <class _Tp>
_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_CXX20
__enable_if_t __enable_if_t
< <
__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
size_type size_type
> >
find_last_of(const _Tp& __t, size_type __pos = npos) const _NOEXCEPT; find_last_of(const _Tp& __t, size_type __pos = npos) const _NOEXCEPT;
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
size_type find_last_of(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT; size_type find_last_of(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT;
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
size_type find_last_of(const value_type* __s, size_type __pos = npos) const _NOEXCEPT; size_type find_last_of(const value_type* __s, size_type __pos = npos) const _NOEXCEPT;
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
size_type find_last_of(value_type __c, size_type __pos = npos) const _NOEXCEPT; size_type find_last_of(value_type __c, size_type __pos = npos) const _NOEXCEPT;
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
size_type find_first_not_of(const basic_string& __str, size_type __pos = 0) const _NOEXCEPT; size_type find_first_not_of(const basic_string& __str, size_type __pos = 0) const _NOEXCEPT;
template <class _Tp> template <class _Tp>
_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_CXX20
__enable_if_t __enable_if_t
< <
__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
size_type size_type
> >
find_first_not_of(const _Tp &__t, size_type __pos = 0) const _NOEXCEPT; find_first_not_of(const _Tp &__t, size_type __pos = 0) const _NOEXCEPT;
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
size_type find_first_not_of(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT; size_type find_first_not_of(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT;
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
size_type find_first_not_of(const value_type* __s, size_type __pos = 0) const _NOEXCEPT; size_type find_first_not_of(const value_type* __s, size_type __pos = 0) const _NOEXCEPT;
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
size_type find_first_not_of(value_type __c, size_type __pos = 0) const _NOEXCEPT; size_type find_first_not_of(value_type __c, size_type __pos = 0) const _NOEXCEPT;
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
size_type find_last_not_of(const basic_string& __str, size_type __pos = npos) const _NOEXCEPT; size_type find_last_not_of(const basic_string& __str, size_type __pos = npos) const _NOEXCEPT;
template <class _Tp> template <class _Tp>
_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_CXX20
__enable_if_t __enable_if_t
< <
__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
size_type size_type
> >
find_last_not_of(const _Tp& __t, size_type __pos = npos) const _NOEXCEPT; find_last_not_of(const _Tp& __t, size_type __pos = npos) const _NOEXCEPT;
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
size_type find_last_not_of(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT; size_type find_last_not_of(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT;
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
size_type find_last_not_of(const value_type* __s, size_type __pos = npos) const _NOEXCEPT; size_type find_last_not_of(const value_type* __s, size_type __pos = npos) const _NOEXCEPT;
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
size_type find_last_not_of(value_type __c, size_type __pos = npos) const _NOEXCEPT; size_type find_last_not_of(value_type __c, size_type __pos = npos) const _NOEXCEPT;
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
int compare(const basic_string& __str) const _NOEXCEPT; int compare(const basic_string& __str) const _NOEXCEPT;
template <class _Tp> template <class _Tp>
_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_CXX20
__enable_if_t __enable_if_t
< <
__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
int int
> >
compare(const _Tp &__t) const _NOEXCEPT; compare(const _Tp &__t) const _NOEXCEPT;
template <class _Tp> template <class _Tp>
_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_CXX20
__enable_if_t __enable_if_t
< <
__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
int int
> >
compare(size_type __pos1, size_type __n1, const _Tp& __t) const; compare(size_type __pos1, size_type __n1, const _Tp& __t) const;
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
int compare(size_type __pos1, size_type __n1, const basic_string& __str) const; int compare(size_type __pos1, size_type __n1, const basic_string& __str) const;
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
int compare(size_type __pos1, size_type __n1, const basic_string& __str, size_type __pos2, int compare(size_type __pos1, size_type __n1, const basic_string& __str, size_type __pos2,
size_type __n2 = npos) const; size_type __n2 = npos) const;
template <class _Tp> template <class _Tp>
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
__enable_if_t __enable_if_t
< <
__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value && !__is_same_uncvref<_Tp, basic_string>::value, __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value && !__is_same_uncvref<_Tp, basic_string>::value,
int int
> >
compare(size_type __pos1, size_type __n1, const _Tp& __t, size_type __pos2, size_type __n2=npos) const; compare(size_type __pos1, size_type __n1, const _Tp& __t, size_type __pos2, size_type __n2=npos) const;
_LIBCPP_CONSTEXPR_AFTER_CXX17 int compare(const value_type* __s) const _NOEXCEPT; _LIBCPP_CONSTEXPR_CXX20 int compare(const value_type* __s) const _NOEXCEPT;
_LIBCPP_CONSTEXPR_AFTER_CXX17 int compare(size_type __pos1, size_type __n1, const value_type* __s) const; _LIBCPP_CONSTEXPR_CXX20 int compare(size_type __pos1, size_type __n1, const value_type* __s) const;
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
int compare(size_type __pos1, size_type __n1, const value_type* __s, size_type __n2) const; int compare(size_type __pos1, size_type __n1, const value_type* __s, size_type __n2) const;
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER > 17
constexpr _LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_HIDE_FROM_ABI
bool starts_with(__self_view __sv) const noexcept bool starts_with(__self_view __sv) const noexcept
{ return __self_view(data(), size()).starts_with(__sv); } { return __self_view(data(), size()).starts_with(__sv); }
constexpr _LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_HIDE_FROM_ABI
Show All 26 Lines#if _LIBCPP_STD_VER > 20
bool contains(value_type __c) const noexcept bool contains(value_type __c) const noexcept
{ return __self_view(data(), size()).contains(__c); } { return __self_view(data(), size()).contains(__c); }
constexpr _LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_HIDE_FROM_ABI
bool contains(const value_type* __s) const bool contains(const value_type* __s) const
{ return __self_view(data(), size()).contains(__s); } { return __self_view(data(), size()).contains(__s); }
#endif #endif
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 bool __invariants() const; _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20 bool __invariants() const;
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 void __clear_and_shrink() _NOEXCEPT; _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20 void __clear_and_shrink() _NOEXCEPT;
#ifdef _LIBCPP_ENABLE_DEBUG_MODE #ifdef _LIBCPP_ENABLE_DEBUG_MODE
bool __dereferenceable(const const_iterator* __i) const; bool __dereferenceable(const const_iterator* __i) const;
bool __decrementable(const const_iterator* __i) const; bool __decrementable(const const_iterator* __i) const;
bool __addable(const const_iterator* __i, ptrdiff_t __n) const; bool __addable(const const_iterator* __i, ptrdiff_t __n) const;
bool __subscriptable(const const_iterator* __i, ptrdiff_t __n) const; bool __subscriptable(const const_iterator* __i, ptrdiff_t __n) const;
#endif // _LIBCPP_ENABLE_DEBUG_MODE #endif // _LIBCPP_ENABLE_DEBUG_MODE
private: private:
template<class _Alloc> template<class _Alloc>
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
bool friend operator==(const basic_string<char, char_traits<char>, _Alloc>& __lhs, bool friend operator==(const basic_string<char, char_traits<char>, _Alloc>& __lhs,
const basic_string<char, char_traits<char>, _Alloc>& __rhs) _NOEXCEPT; const basic_string<char, char_traits<char>, _Alloc>& __rhs) _NOEXCEPT;
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 void __shrink_or_extend(size_type __target_capacity); _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20 void __shrink_or_extend(size_type __target_capacity);
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
bool __is_long() const _NOEXCEPT { bool __is_long() const _NOEXCEPT {
if (__libcpp_is_constant_evaluated()) if (__libcpp_is_constant_evaluated())
return true; return true;
return __r_.first().__s.__is_long_; return __r_.first().__s.__is_long_;
} }
static _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 void __begin_lifetime(pointer __begin, size_type __n) { static _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20 void __begin_lifetime(pointer __begin, size_type __n) {
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER > 17
if (__libcpp_is_constant_evaluated()) { if (__libcpp_is_constant_evaluated()) {
for (size_type __i = 0; __i != __n; ++__i) for (size_type __i = 0; __i != __n; ++__i)
std::construct_at(std::addressof(__begin[__i])); std::construct_at(std::addressof(__begin[__i]));
} }
#else #else
(void)__begin; (void)__begin;
(void)__n; (void)__n;
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER > 17
} }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 void __default_init() { _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20 void __default_init() {
__zero(); __zero();
if (__libcpp_is_constant_evaluated()) { if (__libcpp_is_constant_evaluated()) {
size_type __sz = __recommend(0) + 1; size_type __sz = __recommend(0) + 1;
pointer __ptr = __alloc_traits::allocate(__alloc(), __sz); pointer __ptr = __alloc_traits::allocate(__alloc(), __sz);
__begin_lifetime(__ptr, __sz); __begin_lifetime(__ptr, __sz);
__set_long_pointer(__ptr); __set_long_pointer(__ptr);
__set_long_cap(__sz); __set_long_cap(__sz);
__set_long_size(0); __set_long_size(0);
} }
} }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 void __deallocate_constexpr() { _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20 void __deallocate_constexpr() {
if (__libcpp_is_constant_evaluated() && __get_pointer() != nullptr) if (__libcpp_is_constant_evaluated() && __get_pointer() != nullptr)
__alloc_traits::deallocate(__alloc(), __get_pointer(), __get_long_cap()); __alloc_traits::deallocate(__alloc(), __get_pointer(), __get_long_cap());
} }
_LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI static bool __fits_in_sso(size_type __sz) { _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI static bool __fits_in_sso(size_type __sz) {
// SSO is disabled during constant evaluation because `__is_long` isn't constexpr friendly // SSO is disabled during constant evaluation because `__is_long` isn't constexpr friendly
return !__libcpp_is_constant_evaluated() && (__sz < __min_cap); return !__libcpp_is_constant_evaluated() && (__sz < __min_cap);
} }
template <class _ForwardIterator> template <class _ForwardIterator>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14
iterator __insert_from_safe_copy(size_type __n, size_type __ip, _ForwardIterator __first, _ForwardIterator __last) { iterator __insert_from_safe_copy(size_type __n, size_type __ip, _ForwardIterator __first, _ForwardIterator __last) {
size_type __sz = size(); size_type __sz = size();
size_type __cap = capacity(); size_type __cap = capacity();
value_type* __p; value_type* __p;
if (__cap - __sz >= __n) if (__cap - __sz >= __n)
{ {
__p = std::__to_address(__get_pointer()); __p = std::__to_address(__get_pointer());
size_type __n_move = __sz - __ip; size_type __n_move = __sz - __ip;
Show All 9 Lines iterator __insert_from_safe_copy(size_type __n, size_type __ip, _ForwardIterator __first, _ForwardIterator __last) {
__set_size(__sz); __set_size(__sz);
traits_type::assign(__p[__sz], value_type()); traits_type::assign(__p[__sz], value_type());
for (__p += __ip; __first != __last; ++__p, ++__first) for (__p += __ip; __first != __last; ++__p, ++__first)
traits_type::assign(*__p, *__first); traits_type::assign(*__p, *__first);
return begin() + __ip; return begin() + __ip;
} }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 allocator_type& __alloc() _NOEXCEPT { return __r_.second(); } _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14 allocator_type& __alloc() _NOEXCEPT { return __r_.second(); }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR const allocator_type& __alloc() const _NOEXCEPT { return __r_.second(); } _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR const allocator_type& __alloc() const _NOEXCEPT { return __r_.second(); }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
void __set_short_size(size_type __s) _NOEXCEPT { void __set_short_size(size_type __s) _NOEXCEPT {
_LIBCPP_ASSERT(__s < __min_cap, "__s should never be greater than or equal to the short string capacity"); _LIBCPP_ASSERT(__s < __min_cap, "__s should never be greater than or equal to the short string capacity");
__r_.first().__s.__size_ = __s; __r_.first().__s.__size_ = __s;
__r_.first().__s.__is_long_ = false; __r_.first().__s.__is_long_ = false;
} }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
size_type __get_short_size() const _NOEXCEPT { size_type __get_short_size() const _NOEXCEPT {
_LIBCPP_ASSERT(!__r_.first().__s.__is_long_, "String has to be short when trying to get the short size"); _LIBCPP_ASSERT(!__r_.first().__s.__is_long_, "String has to be short when trying to get the short size");
return __r_.first().__s.__size_; return __r_.first().__s.__size_;
} }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
void __set_long_size(size_type __s) _NOEXCEPT void __set_long_size(size_type __s) _NOEXCEPT
{__r_.first().__l.__size_ = __s;} {__r_.first().__l.__size_ = __s;}
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
size_type __get_long_size() const _NOEXCEPT size_type __get_long_size() const _NOEXCEPT
{return __r_.first().__l.__size_;} {return __r_.first().__l.__size_;}
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
void __set_size(size_type __s) _NOEXCEPT void __set_size(size_type __s) _NOEXCEPT
{if (__is_long()) __set_long_size(__s); else __set_short_size(__s);} {if (__is_long()) __set_long_size(__s); else __set_short_size(__s);}
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
void __set_long_cap(size_type __s) _NOEXCEPT { void __set_long_cap(size_type __s) _NOEXCEPT {
__r_.first().__l.__cap_ = __s / __endian_factor; __r_.first().__l.__cap_ = __s / __endian_factor;
__r_.first().__l.__is_long_ = true; __r_.first().__l.__is_long_ = true;
} }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
size_type __get_long_cap() const _NOEXCEPT { size_type __get_long_cap() const _NOEXCEPT {
return __r_.first().__l.__cap_ * __endian_factor; return __r_.first().__l.__cap_ * __endian_factor;
} }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
void __set_long_pointer(pointer __p) _NOEXCEPT void __set_long_pointer(pointer __p) _NOEXCEPT
{__r_.first().__l.__data_ = __p;} {__r_.first().__l.__data_ = __p;}
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
pointer __get_long_pointer() _NOEXCEPT pointer __get_long_pointer() _NOEXCEPT
{return __r_.first().__l.__data_;} {return __r_.first().__l.__data_;}
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
const_pointer __get_long_pointer() const _NOEXCEPT const_pointer __get_long_pointer() const _NOEXCEPT
{return __r_.first().__l.__data_;} {return __r_.first().__l.__data_;}
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
pointer __get_short_pointer() _NOEXCEPT pointer __get_short_pointer() _NOEXCEPT
{return pointer_traits<pointer>::pointer_to(__r_.first().__s.__data_[0]);} {return pointer_traits<pointer>::pointer_to(__r_.first().__s.__data_[0]);}
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
const_pointer __get_short_pointer() const _NOEXCEPT const_pointer __get_short_pointer() const _NOEXCEPT
{return pointer_traits<const_pointer>::pointer_to(__r_.first().__s.__data_[0]);} {return pointer_traits<const_pointer>::pointer_to(__r_.first().__s.__data_[0]);}
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
pointer __get_pointer() _NOEXCEPT pointer __get_pointer() _NOEXCEPT
{return __is_long() ? __get_long_pointer() : __get_short_pointer();} {return __is_long() ? __get_long_pointer() : __get_short_pointer();}
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
const_pointer __get_pointer() const _NOEXCEPT const_pointer __get_pointer() const _NOEXCEPT
{return __is_long() ? __get_long_pointer() : __get_short_pointer();} {return __is_long() ? __get_long_pointer() : __get_short_pointer();}
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
void __zero() _NOEXCEPT { void __zero() _NOEXCEPT {
__r_.first() = __rep(); __r_.first() = __rep();
} }
template <size_type __a> static template <size_type __a> static
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
size_type __align_it(size_type __s) _NOEXCEPT size_type __align_it(size_type __s) _NOEXCEPT
{return (__s + (__a-1)) & ~(__a-1);} {return (__s + (__a-1)) & ~(__a-1);}
enum {__alignment = 16}; enum {__alignment = 16};
static _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 static _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
size_type __recommend(size_type __s) _NOEXCEPT size_type __recommend(size_type __s) _NOEXCEPT
{ {
if (__s < __min_cap) { if (__s < __min_cap) {
if (__libcpp_is_constant_evaluated()) if (__libcpp_is_constant_evaluated())
return static_cast<size_type>(__min_cap); return static_cast<size_type>(__min_cap);
else else
return static_cast<size_type>(__min_cap) - 1; return static_cast<size_type>(__min_cap) - 1;
} }
size_type __guess = __align_it<sizeof(value_type) < __alignment ? size_type __guess = __align_it<sizeof(value_type) < __alignment ?
__alignment/sizeof(value_type) : 1 > (__s+1) - 1; __alignment/sizeof(value_type) : 1 > (__s+1) - 1;
if (__guess == __min_cap) ++__guess; if (__guess == __min_cap) ++__guess;
return __guess; return __guess;
} }
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_CONSTEXPR_CXX20
void __init(const value_type* __s, size_type __sz, size_type __reserve); void __init(const value_type* __s, size_type __sz, size_type __reserve);
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_CONSTEXPR_CXX20
void __init(const value_type* __s, size_type __sz); void __init(const value_type* __s, size_type __sz);
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_CONSTEXPR_CXX20
void __init(size_type __n, value_type __c); void __init(size_type __n, value_type __c);
// Slow path for the (inlined) copy constructor for 'long' strings. // Slow path for the (inlined) copy constructor for 'long' strings.
// Always externally instantiated and not inlined. // Always externally instantiated and not inlined.
// Requires that __s is zero terminated. // Requires that __s is zero terminated.
// The main reason for this function to exist is because for unstable, we // The main reason for this function to exist is because for unstable, we
// want to allow inlining of the copy constructor. However, we don't want // want to allow inlining of the copy constructor. However, we don't want
// to call the __init() functions as those are marked as inline which may // to call the __init() functions as those are marked as inline which may
// result in over-aggressive inlining by the compiler, where our aim is // result in over-aggressive inlining by the compiler, where our aim is
// to only inline the fast path code directly in the ctor. // to only inline the fast path code directly in the ctor.
_LIBCPP_CONSTEXPR_AFTER_CXX17 void __init_copy_ctor_external(const value_type* __s, size_type __sz); _LIBCPP_CONSTEXPR_CXX20 void __init_copy_ctor_external(const value_type* __s, size_type __sz);
template <class _InputIterator> template <class _InputIterator>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_CONSTEXPR_CXX20
__enable_if_t __enable_if_t
< <
__is_exactly_cpp17_input_iterator<_InputIterator>::value __is_exactly_cpp17_input_iterator<_InputIterator>::value
> >
__init(_InputIterator __first, _InputIterator __last); __init(_InputIterator __first, _InputIterator __last);
template <class _ForwardIterator> template <class _ForwardIterator>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_CONSTEXPR_CXX20
__enable_if_t __enable_if_t
< <
__is_cpp17_forward_iterator<_ForwardIterator>::value __is_cpp17_forward_iterator<_ForwardIterator>::value
> >
__init(_ForwardIterator __first, _ForwardIterator __last); __init(_ForwardIterator __first, _ForwardIterator __last);
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
void __grow_by(size_type __old_cap, size_type __delta_cap, size_type __old_sz, void __grow_by(size_type __old_cap, size_type __delta_cap, size_type __old_sz,
size_type __n_copy, size_type __n_del, size_type __n_add = 0); size_type __n_copy, size_type __n_del, size_type __n_add = 0);
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
void __grow_by_and_replace(size_type __old_cap, size_type __delta_cap, size_type __old_sz, void __grow_by_and_replace(size_type __old_cap, size_type __delta_cap, size_type __old_sz,
size_type __n_copy, size_type __n_del, size_type __n_copy, size_type __n_del,
size_type __n_add, const value_type* __p_new_stuff); size_type __n_add, const value_type* __p_new_stuff);
// __assign_no_alias is invoked for assignment operations where we // __assign_no_alias is invoked for assignment operations where we
// have proof that the input does not alias the current instance. // have proof that the input does not alias the current instance.
// For example, operator=(basic_string) performs a 'self' check. // For example, operator=(basic_string) performs a 'self' check.
template <bool __is_short> template <bool __is_short>
_LIBCPP_CONSTEXPR_AFTER_CXX17 basic_string& __assign_no_alias(const value_type* __s, size_type __n); _LIBCPP_CONSTEXPR_CXX20 basic_string& __assign_no_alias(const value_type* __s, size_type __n);
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
void __erase_to_end(size_type __pos); void __erase_to_end(size_type __pos);
// __erase_external_with_move is invoked for erase() invocations where // __erase_external_with_move is invoked for erase() invocations where
// `n ~= npos`, likely requiring memory moves on the string data. // `n ~= npos`, likely requiring memory moves on the string data.
_LIBCPP_CONSTEXPR_AFTER_CXX17 void __erase_external_with_move(size_type __pos, size_type __n); _LIBCPP_CONSTEXPR_CXX20 void __erase_external_with_move(size_type __pos, size_type __n);
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
void __copy_assign_alloc(const basic_string& __str) void __copy_assign_alloc(const basic_string& __str)
{__copy_assign_alloc(__str, integral_constant<bool, {__copy_assign_alloc(__str, integral_constant<bool,
__alloc_traits::propagate_on_container_copy_assignment::value>());} __alloc_traits::propagate_on_container_copy_assignment::value>());}
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
void __copy_assign_alloc(const basic_string& __str, true_type) void __copy_assign_alloc(const basic_string& __str, true_type)
{ {
if (__alloc() == __str.__alloc()) if (__alloc() == __str.__alloc())
__alloc() = __str.__alloc(); __alloc() = __str.__alloc();
else else
{ {
if (!__str.__is_long()) if (!__str.__is_long())
{ {
Show All 9 Lines void __copy_assign_alloc(const basic_string& __str, true_type)
__alloc() = std::move(__a); __alloc() = std::move(__a);
__set_long_pointer(__allocation.ptr); __set_long_pointer(__allocation.ptr);
__set_long_cap(__allocation.count); __set_long_cap(__allocation.count);
__set_long_size(__str.size()); __set_long_size(__str.size());
} }
} }
} }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
void __copy_assign_alloc(const basic_string&, false_type) _NOEXCEPT void __copy_assign_alloc(const basic_string&, false_type) _NOEXCEPT
{} {}
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
void __move_assign(basic_string& __str, false_type) void __move_assign(basic_string& __str, false_type)
_NOEXCEPT_(__alloc_traits::is_always_equal::value); _NOEXCEPT_(__alloc_traits::is_always_equal::value);
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
void __move_assign(basic_string& __str, true_type) void __move_assign(basic_string& __str, true_type)
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER > 14
_NOEXCEPT; _NOEXCEPT;
#else #else
_NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value); _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value);
#endif #endif
#endif #endif
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
void void
__move_assign_alloc(basic_string& __str) __move_assign_alloc(basic_string& __str)
_NOEXCEPT_( _NOEXCEPT_(
!__alloc_traits::propagate_on_container_move_assignment::value || !__alloc_traits::propagate_on_container_move_assignment::value ||
is_nothrow_move_assignable<allocator_type>::value) is_nothrow_move_assignable<allocator_type>::value)
{__move_assign_alloc(__str, integral_constant<bool, {__move_assign_alloc(__str, integral_constant<bool,
__alloc_traits::propagate_on_container_move_assignment::value>());} __alloc_traits::propagate_on_container_move_assignment::value>());}
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
void __move_assign_alloc(basic_string& __c, true_type) void __move_assign_alloc(basic_string& __c, true_type)
_NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value) _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value)
{ {
__alloc() = std::move(__c.__alloc()); __alloc() = std::move(__c.__alloc());
} }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
void __move_assign_alloc(basic_string&, false_type) void __move_assign_alloc(basic_string&, false_type)
_NOEXCEPT _NOEXCEPT
{} {}
_LIBCPP_CONSTEXPR_AFTER_CXX17 basic_string& __assign_external(const value_type* __s); _LIBCPP_CONSTEXPR_CXX20 basic_string& __assign_external(const value_type* __s);
_LIBCPP_CONSTEXPR_AFTER_CXX17 basic_string& __assign_external(const value_type* __s, size_type __n); _LIBCPP_CONSTEXPR_CXX20 basic_string& __assign_external(const value_type* __s, size_type __n);
// Assigns the value in __s, guaranteed to be __n < __min_cap in length. // Assigns the value in __s, guaranteed to be __n < __min_cap in length.
inline basic_string& __assign_short(const value_type* __s, size_type __n) { inline basic_string& __assign_short(const value_type* __s, size_type __n) {
pointer __p = __is_long() pointer __p = __is_long()
? (__set_long_size(__n), __get_long_pointer()) ? (__set_long_size(__n), __get_long_pointer())
: (__set_short_size(__n), __get_short_pointer()); : (__set_short_size(__n), __get_short_pointer());
traits_type::move(std::__to_address(__p), __s, __n); traits_type::move(std::__to_address(__p), __s, __n);
traits_type::assign(__p[__n], value_type()); traits_type::assign(__p[__n], value_type());
return *this; return *this;
} }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
basic_string& __null_terminate_at(value_type* __p, size_type __newsz) { basic_string& __null_terminate_at(value_type* __p, size_type __newsz) {
__set_size(__newsz); __set_size(__newsz);
__invalidate_iterators_past(__newsz); __invalidate_iterators_past(__newsz);
traits_type::assign(__p[__newsz], value_type()); traits_type::assign(__p[__newsz], value_type());
return *this; return *this;
} }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 void __invalidate_iterators_past(size_type); _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20 void __invalidate_iterators_past(size_type);
template<class _Tp> template<class _Tp>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
bool __addr_in_range(_Tp&& __t) const { bool __addr_in_range(_Tp&& __t) const {
// assume that the ranges overlap, because we can't check during constant evaluation // assume that the ranges overlap, because we can't check during constant evaluation
if (__libcpp_is_constant_evaluated()) if (__libcpp_is_constant_evaluated())
return true; return true;
const volatile void *__p = std::addressof(__t); const volatile void *__p = std::addressof(__t);
return data() <= __p && __p <= data() + size(); return data() <= __p && __p <= data() + size();
} }
_LIBCPP_NORETURN _LIBCPP_HIDE_FROM_ABI _LIBCPP_NORETURN _LIBCPP_HIDE_FROM_ABI
void __throw_length_error() const { void __throw_length_error() const {
std::__throw_length_error("basic_string"); std::__throw_length_error("basic_string");
} }
_LIBCPP_NORETURN _LIBCPP_HIDE_FROM_ABI _LIBCPP_NORETURN _LIBCPP_HIDE_FROM_ABI
void __throw_out_of_range() const { void __throw_out_of_range() const {
std::__throw_out_of_range("basic_string"); std::__throw_out_of_range("basic_string");
} }
friend _LIBCPP_CONSTEXPR_AFTER_CXX17 basic_string operator+<>(const basic_string&, const basic_string&); friend _LIBCPP_CONSTEXPR_CXX20 basic_string operator+<>(const basic_string&, const basic_string&);
friend _LIBCPP_CONSTEXPR_AFTER_CXX17 basic_string operator+<>(const value_type*, const basic_string&); friend _LIBCPP_CONSTEXPR_CXX20 basic_string operator+<>(const value_type*, const basic_string&);
friend _LIBCPP_CONSTEXPR_AFTER_CXX17 basic_string operator+<>(value_type, const basic_string&); friend _LIBCPP_CONSTEXPR_CXX20 basic_string operator+<>(value_type, const basic_string&);
friend _LIBCPP_CONSTEXPR_AFTER_CXX17 basic_string operator+<>(const basic_string&, const value_type*); friend _LIBCPP_CONSTEXPR_CXX20 basic_string operator+<>(const basic_string&, const value_type*);
friend _LIBCPP_CONSTEXPR_AFTER_CXX17 basic_string operator+<>(const basic_string&, value_type); friend _LIBCPP_CONSTEXPR_CXX20 basic_string operator+<>(const basic_string&, value_type);
}; };
// These declarations must appear before any functions are implicitly used // These declarations must appear before any functions are implicitly used
// so that they have the correct visibility specifier. // so that they have the correct visibility specifier.
#define _LIBCPP_DECLARE(...) extern template __VA_ARGS__; #define _LIBCPP_DECLARE(...) extern template __VA_ARGS__;
#ifdef _LIBCPP_ABI_STRING_OPTIMIZED_EXTERNAL_INSTANTIATION #ifdef _LIBCPP_ABI_STRING_OPTIMIZED_EXTERNAL_INSTANTIATION
_LIBCPP_STRING_UNSTABLE_EXTERN_TEMPLATE_LIST(_LIBCPP_DECLARE, char) _LIBCPP_STRING_UNSTABLE_EXTERN_TEMPLATE_LIST(_LIBCPP_DECLARE, char)
# ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS # ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
Show All 32 Linestemplate<class _CharT,
class = enable_if_t<__is_allocator<_Allocator>::value>, class = enable_if_t<__is_allocator<_Allocator>::value>,
class _Sz = typename allocator_traits<_Allocator>::size_type class _Sz = typename allocator_traits<_Allocator>::size_type
> >
basic_string(basic_string_view<_CharT, _Traits>, _Sz, _Sz, const _Allocator& = _Allocator()) basic_string(basic_string_view<_CharT, _Traits>, _Sz, _Sz, const _Allocator& = _Allocator())
-> basic_string<_CharT, _Traits, _Allocator>; -> basic_string<_CharT, _Traits, _Allocator>;
#endif #endif
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_CONSTEXPR_CXX20
void void
basic_string<_CharT, _Traits, _Allocator>::__invalidate_iterators_past(size_type __pos) basic_string<_CharT, _Traits, _Allocator>::__invalidate_iterators_past(size_type __pos)
{ {
#ifdef _LIBCPP_ENABLE_DEBUG_MODE #ifdef _LIBCPP_ENABLE_DEBUG_MODE
if (!__libcpp_is_constant_evaluated()) { if (!__libcpp_is_constant_evaluated()) {
__c_node* __c = __get_db()->__find_c_and_lock(this); __c_node* __c = __get_db()->__find_c_and_lock(this);
if (__c) if (__c)
{ {
Show All 13 Lines if (!__libcpp_is_constant_evaluated()) {
} }
} }
#else #else
(void)__pos; (void)__pos;
#endif // _LIBCPP_ENABLE_DEBUG_MODE #endif // _LIBCPP_ENABLE_DEBUG_MODE
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_CONSTEXPR_CXX20
basic_string<_CharT, _Traits, _Allocator>::basic_string() basic_string<_CharT, _Traits, _Allocator>::basic_string()
_NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value) _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value)
: __r_(__default_init_tag(), __default_init_tag()) : __r_(__default_init_tag(), __default_init_tag())
{ {
std::__debug_db_insert_c(this); std::__debug_db_insert_c(this);
__default_init(); __default_init();
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_CONSTEXPR_CXX20
basic_string<_CharT, _Traits, _Allocator>::basic_string(const allocator_type& __a) basic_string<_CharT, _Traits, _Allocator>::basic_string(const allocator_type& __a)
#if _LIBCPP_STD_VER <= 14 #if _LIBCPP_STD_VER <= 14
_NOEXCEPT_(is_nothrow_copy_constructible<allocator_type>::value) _NOEXCEPT_(is_nothrow_copy_constructible<allocator_type>::value)
#else #else
_NOEXCEPT _NOEXCEPT
#endif #endif
: __r_(__default_init_tag(), __a) : __r_(__default_init_tag(), __a)
{ {
std::__debug_db_insert_c(this); std::__debug_db_insert_c(this);
__default_init(); __default_init();
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
void basic_string<_CharT, _Traits, _Allocator>::__init(const value_type* __s, void basic_string<_CharT, _Traits, _Allocator>::__init(const value_type* __s,
size_type __sz, size_type __sz,
size_type __reserve) size_type __reserve)
{ {
if (__libcpp_is_constant_evaluated()) if (__libcpp_is_constant_evaluated())
__zero(); __zero();
if (__reserve > max_size()) if (__reserve > max_size())
__throw_length_error(); __throw_length_error();
Show All 12 Lines else
__set_long_cap(__allocation.count); __set_long_cap(__allocation.count);
__set_long_size(__sz); __set_long_size(__sz);
} }
traits_type::copy(std::__to_address(__p), __s, __sz); traits_type::copy(std::__to_address(__p), __s, __sz);
traits_type::assign(__p[__sz], value_type()); traits_type::assign(__p[__sz], value_type());
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
void void
basic_string<_CharT, _Traits, _Allocator>::__init(const value_type* __s, size_type __sz) basic_string<_CharT, _Traits, _Allocator>::__init(const value_type* __s, size_type __sz)
{ {
if (__libcpp_is_constant_evaluated()) if (__libcpp_is_constant_evaluated())
__zero(); __zero();
if (__sz > max_size()) if (__sz > max_size())
__throw_length_error(); __throw_length_error();
pointer __p; pointer __p;
Show All 12 Lines else
__set_long_size(__sz); __set_long_size(__sz);
} }
traits_type::copy(std::__to_address(__p), __s, __sz); traits_type::copy(std::__to_address(__p), __s, __sz);
traits_type::assign(__p[__sz], value_type()); traits_type::assign(__p[__sz], value_type());
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
template <class> template <class>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
basic_string<_CharT, _Traits, _Allocator>::basic_string(const _CharT* __s, const _Allocator& __a) basic_string<_CharT, _Traits, _Allocator>::basic_string(const _CharT* __s, const _Allocator& __a)
: __r_(__default_init_tag(), __a) : __r_(__default_init_tag(), __a)
{ {
_LIBCPP_ASSERT(__s != nullptr, "basic_string(const char*, allocator) detected nullptr"); _LIBCPP_ASSERT(__s != nullptr, "basic_string(const char*, allocator) detected nullptr");
__init(__s, traits_type::length(__s)); __init(__s, traits_type::length(__s));
std::__debug_db_insert_c(this); std::__debug_db_insert_c(this);
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_CONSTEXPR_CXX20
basic_string<_CharT, _Traits, _Allocator>::basic_string(const _CharT* __s, size_type __n) basic_string<_CharT, _Traits, _Allocator>::basic_string(const _CharT* __s, size_type __n)
: __r_(__default_init_tag(), __default_init_tag()) : __r_(__default_init_tag(), __default_init_tag())
{ {
_LIBCPP_ASSERT(__n == 0 || __s != nullptr, "basic_string(const char*, n) detected nullptr"); _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "basic_string(const char*, n) detected nullptr");
__init(__s, __n); __init(__s, __n);
std::__debug_db_insert_c(this); std::__debug_db_insert_c(this);
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_CONSTEXPR_CXX20
basic_string<_CharT, _Traits, _Allocator>::basic_string(const _CharT* __s, size_type __n, const _Allocator& __a) basic_string<_CharT, _Traits, _Allocator>::basic_string(const _CharT* __s, size_type __n, const _Allocator& __a)
: __r_(__default_init_tag(), __a) : __r_(__default_init_tag(), __a)
{ {
_LIBCPP_ASSERT(__n == 0 || __s != nullptr, "basic_string(const char*, n, allocator) detected nullptr"); _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "basic_string(const char*, n, allocator) detected nullptr");
__init(__s, __n); __init(__s, __n);
std::__debug_db_insert_c(this); std::__debug_db_insert_c(this);
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
basic_string<_CharT, _Traits, _Allocator>::basic_string(const basic_string& __str) basic_string<_CharT, _Traits, _Allocator>::basic_string(const basic_string& __str)
: __r_(__default_init_tag(), __alloc_traits::select_on_container_copy_construction(__str.__alloc())) : __r_(__default_init_tag(), __alloc_traits::select_on_container_copy_construction(__str.__alloc()))
{ {
if (!__str.__is_long()) if (!__str.__is_long())
__r_.first().__r = __str.__r_.first().__r; __r_.first().__r = __str.__r_.first().__r;
else else
__init_copy_ctor_external(std::__to_address(__str.__get_long_pointer()), __init_copy_ctor_external(std::__to_address(__str.__get_long_pointer()),
__str.__get_long_size()); __str.__get_long_size());
std::__debug_db_insert_c(this); std::__debug_db_insert_c(this);
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
basic_string<_CharT, _Traits, _Allocator>::basic_string( basic_string<_CharT, _Traits, _Allocator>::basic_string(
const basic_string& __str, const allocator_type& __a) const basic_string& __str, const allocator_type& __a)
: __r_(__default_init_tag(), __a) : __r_(__default_init_tag(), __a)
{ {
if (!__str.__is_long()) if (!__str.__is_long())
__r_.first().__r = __str.__r_.first().__r; __r_.first().__r = __str.__r_.first().__r;
else else
__init_copy_ctor_external(std::__to_address(__str.__get_long_pointer()), __init_copy_ctor_external(std::__to_address(__str.__get_long_pointer()),
__str.__get_long_size()); __str.__get_long_size());
std::__debug_db_insert_c(this); std::__debug_db_insert_c(this);
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
void basic_string<_CharT, _Traits, _Allocator>::__init_copy_ctor_external( void basic_string<_CharT, _Traits, _Allocator>::__init_copy_ctor_external(
const value_type* __s, size_type __sz) { const value_type* __s, size_type __sz) {
if (__libcpp_is_constant_evaluated()) if (__libcpp_is_constant_evaluated())
__zero(); __zero();
pointer __p; pointer __p;
if (__fits_in_sso(__sz)) { if (__fits_in_sso(__sz)) {
__p = __get_short_pointer(); __p = __get_short_pointer();
__set_short_size(__sz); __set_short_size(__sz);
} else { } else {
if (__sz > max_size()) if (__sz > max_size())
__throw_length_error(); __throw_length_error();
auto __allocation = std::__allocate_at_least(__alloc(), __recommend(__sz) + 1); auto __allocation = std::__allocate_at_least(__alloc(), __recommend(__sz) + 1);
__p = __allocation.ptr; __p = __allocation.ptr;
__begin_lifetime(__p, __allocation.count); __begin_lifetime(__p, __allocation.count);
__set_long_pointer(__p); __set_long_pointer(__p);
__set_long_cap(__allocation.count); __set_long_cap(__allocation.count);
__set_long_size(__sz); __set_long_size(__sz);
} }
traits_type::copy(std::__to_address(__p), __s, __sz + 1); traits_type::copy(std::__to_address(__p), __s, __sz + 1);
} }
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_CONSTEXPR_CXX20
basic_string<_CharT, _Traits, _Allocator>::basic_string(basic_string&& __str) basic_string<_CharT, _Traits, _Allocator>::basic_string(basic_string&& __str)
#if _LIBCPP_STD_VER <= 14 #if _LIBCPP_STD_VER <= 14
_NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value) _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value)
#else #else
_NOEXCEPT _NOEXCEPT
#endif #endif
: __r_(std::move(__str.__r_)) : __r_(std::move(__str.__r_))
{ {
__str.__default_init(); __str.__default_init();
std::__debug_db_insert_c(this); std::__debug_db_insert_c(this);
if (__is_long()) if (__is_long())
std::__debug_db_swap(this, &__str); std::__debug_db_swap(this, &__str);
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_CONSTEXPR_CXX20
basic_string<_CharT, _Traits, _Allocator>::basic_string(basic_string&& __str, const allocator_type& __a) basic_string<_CharT, _Traits, _Allocator>::basic_string(basic_string&& __str, const allocator_type& __a)
: __r_(__default_init_tag(), __a) : __r_(__default_init_tag(), __a)
{ {
if (__str.__is_long() && __a != __str.__alloc()) // copy, not move if (__str.__is_long() && __a != __str.__alloc()) // copy, not move
__init(std::__to_address(__str.__get_long_pointer()), __str.__get_long_size()); __init(std::__to_address(__str.__get_long_pointer()), __str.__get_long_size());
else else
{ {
if (__libcpp_is_constant_evaluated()) { if (__libcpp_is_constant_evaluated()) {
__zero(); __zero();
__r_.first().__l = __str.__r_.first().__l; __r_.first().__l = __str.__r_.first().__l;
} else { } else {
__r_.first().__r = __str.__r_.first().__r; __r_.first().__r = __str.__r_.first().__r;
} }
__str.__default_init(); __str.__default_init();
} }
std::__debug_db_insert_c(this); std::__debug_db_insert_c(this);
if (__is_long()) if (__is_long())
std::__debug_db_swap(this, &__str); std::__debug_db_swap(this, &__str);
} }
#endif // _LIBCPP_CXX03_LANG #endif // _LIBCPP_CXX03_LANG
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
void void
basic_string<_CharT, _Traits, _Allocator>::__init(size_type __n, value_type __c) basic_string<_CharT, _Traits, _Allocator>::__init(size_type __n, value_type __c)
{ {
if (__libcpp_is_constant_evaluated()) if (__libcpp_is_constant_evaluated())
__zero(); __zero();
if (__n > max_size()) if (__n > max_size())
__throw_length_error(); __throw_length_error();
pointer __p; pointer __p;
Show All 11 Lines else
__set_long_cap(__allocation.count); __set_long_cap(__allocation.count);
__set_long_size(__n); __set_long_size(__n);
} }
traits_type::assign(std::__to_address(__p), __n, __c); traits_type::assign(std::__to_address(__p), __n, __c);
traits_type::assign(__p[__n], value_type()); traits_type::assign(__p[__n], value_type());
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_CONSTEXPR_CXX20
basic_string<_CharT, _Traits, _Allocator>::basic_string(size_type __n, _CharT __c) basic_string<_CharT, _Traits, _Allocator>::basic_string(size_type __n, _CharT __c)
: __r_(__default_init_tag(), __default_init_tag()) : __r_(__default_init_tag(), __default_init_tag())
{ {
__init(__n, __c); __init(__n, __c);
std::__debug_db_insert_c(this); std::__debug_db_insert_c(this);
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
template <class> template <class>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
basic_string<_CharT, _Traits, _Allocator>::basic_string(size_type __n, _CharT __c, const _Allocator& __a) basic_string<_CharT, _Traits, _Allocator>::basic_string(size_type __n, _CharT __c, const _Allocator& __a)
: __r_(__default_init_tag(), __a) : __r_(__default_init_tag(), __a)
{ {
__init(__n, __c); __init(__n, __c);
std::__debug_db_insert_c(this); std::__debug_db_insert_c(this);
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
basic_string<_CharT, _Traits, _Allocator>::basic_string(const basic_string& __str, basic_string<_CharT, _Traits, _Allocator>::basic_string(const basic_string& __str,
size_type __pos, size_type __n, size_type __pos, size_type __n,
const _Allocator& __a) const _Allocator& __a)
: __r_(__default_init_tag(), __a) : __r_(__default_init_tag(), __a)
{ {
size_type __str_sz = __str.size(); size_type __str_sz = __str.size();
if (__pos > __str_sz) if (__pos > __str_sz)
__throw_out_of_range(); __throw_out_of_range();
__init(__str.data() + __pos, std::min(__n, __str_sz - __pos)); __init(__str.data() + __pos, std::min(__n, __str_sz - __pos));
std::__debug_db_insert_c(this); std::__debug_db_insert_c(this);
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_CONSTEXPR_CXX20
basic_string<_CharT, _Traits, _Allocator>::basic_string(const basic_string& __str, size_type __pos, basic_string<_CharT, _Traits, _Allocator>::basic_string(const basic_string& __str, size_type __pos,
const _Allocator& __a) const _Allocator& __a)
: __r_(__default_init_tag(), __a) : __r_(__default_init_tag(), __a)
{ {
size_type __str_sz = __str.size(); size_type __str_sz = __str.size();
if (__pos > __str_sz) if (__pos > __str_sz)
__throw_out_of_range(); __throw_out_of_range();
__init(__str.data() + __pos, __str_sz - __pos); __init(__str.data() + __pos, __str_sz - __pos);
std::__debug_db_insert_c(this); std::__debug_db_insert_c(this);
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
template <class _Tp, class> template <class _Tp, class>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
basic_string<_CharT, _Traits, _Allocator>::basic_string( basic_string<_CharT, _Traits, _Allocator>::basic_string(
const _Tp& __t, size_type __pos, size_type __n, const allocator_type& __a) const _Tp& __t, size_type __pos, size_type __n, const allocator_type& __a)
: __r_(__default_init_tag(), __a) : __r_(__default_init_tag(), __a)
{ {
__self_view __sv0 = __t; __self_view __sv0 = __t;
__self_view __sv = __sv0.substr(__pos, __n); __self_view __sv = __sv0.substr(__pos, __n);
__init(__sv.data(), __sv.size()); __init(__sv.data(), __sv.size());
std::__debug_db_insert_c(this); std::__debug_db_insert_c(this);
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
template <class _Tp, class> template <class _Tp, class>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
basic_string<_CharT, _Traits, _Allocator>::basic_string(const _Tp & __t) basic_string<_CharT, _Traits, _Allocator>::basic_string(const _Tp & __t)
: __r_(__default_init_tag(), __default_init_tag()) : __r_(__default_init_tag(), __default_init_tag())
{ {
__self_view __sv = __t; __self_view __sv = __t;
__init(__sv.data(), __sv.size()); __init(__sv.data(), __sv.size());
std::__debug_db_insert_c(this); std::__debug_db_insert_c(this);
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
template <class _Tp, class> template <class _Tp, class>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
basic_string<_CharT, _Traits, _Allocator>::basic_string(const _Tp & __t, const _Allocator& __a) basic_string<_CharT, _Traits, _Allocator>::basic_string(const _Tp & __t, const _Allocator& __a)
: __r_(__default_init_tag(), __a) : __r_(__default_init_tag(), __a)
{ {
__self_view __sv = __t; __self_view __sv = __t;
__init(__sv.data(), __sv.size()); __init(__sv.data(), __sv.size());
std::__debug_db_insert_c(this); std::__debug_db_insert_c(this);
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
template <class _InputIterator> template <class _InputIterator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
__enable_if_t __enable_if_t
< <
__is_exactly_cpp17_input_iterator<_InputIterator>::value __is_exactly_cpp17_input_iterator<_InputIterator>::value
> >
basic_string<_CharT, _Traits, _Allocator>::__init(_InputIterator __first, _InputIterator __last) basic_string<_CharT, _Traits, _Allocator>::__init(_InputIterator __first, _InputIterator __last)
{ {
__default_init(); __default_init();
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_NO_EXCEPTIONS
Show All 10 Lines catch (...)
__alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap());
throw; throw;
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_NO_EXCEPTIONS
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
template <class _ForwardIterator> template <class _ForwardIterator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
__enable_if_t __enable_if_t
< <
__is_cpp17_forward_iterator<_ForwardIterator>::value __is_cpp17_forward_iterator<_ForwardIterator>::value
> >
basic_string<_CharT, _Traits, _Allocator>::__init(_ForwardIterator __first, _ForwardIterator __last) basic_string<_CharT, _Traits, _Allocator>::__init(_ForwardIterator __first, _ForwardIterator __last)
{ {
if (__libcpp_is_constant_evaluated()) if (__libcpp_is_constant_evaluated())
__zero(); __zero();
Show All 31 Lines catch (...)
__alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap());
throw; throw;
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_NO_EXCEPTIONS
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
template<class _InputIterator, class> template<class _InputIterator, class>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_CONSTEXPR_CXX20
basic_string<_CharT, _Traits, _Allocator>::basic_string(_InputIterator __first, _InputIterator __last) basic_string<_CharT, _Traits, _Allocator>::basic_string(_InputIterator __first, _InputIterator __last)
: __r_(__default_init_tag(), __default_init_tag()) : __r_(__default_init_tag(), __default_init_tag())
{ {
__init(__first, __last); __init(__first, __last);
std::__debug_db_insert_c(this); std::__debug_db_insert_c(this);
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
template<class _InputIterator, class> template<class _InputIterator, class>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_CONSTEXPR_CXX20
basic_string<_CharT, _Traits, _Allocator>::basic_string(_InputIterator __first, _InputIterator __last, basic_string<_CharT, _Traits, _Allocator>::basic_string(_InputIterator __first, _InputIterator __last,
const allocator_type& __a) const allocator_type& __a)
: __r_(__default_init_tag(), __a) : __r_(__default_init_tag(), __a)
{ {
__init(__first, __last); __init(__first, __last);
std::__debug_db_insert_c(this); std::__debug_db_insert_c(this);
} }
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_CONSTEXPR_CXX20
basic_string<_CharT, _Traits, _Allocator>::basic_string( basic_string<_CharT, _Traits, _Allocator>::basic_string(
initializer_list<_CharT> __il) initializer_list<_CharT> __il)
: __r_(__default_init_tag(), __default_init_tag()) : __r_(__default_init_tag(), __default_init_tag())
{ {
__init(__il.begin(), __il.end()); __init(__il.begin(), __il.end());
std::__debug_db_insert_c(this); std::__debug_db_insert_c(this);
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_CONSTEXPR_CXX20
basic_string<_CharT, _Traits, _Allocator>::basic_string( basic_string<_CharT, _Traits, _Allocator>::basic_string(
initializer_list<_CharT> __il, const _Allocator& __a) initializer_list<_CharT> __il, const _Allocator& __a)
: __r_(__default_init_tag(), __a) : __r_(__default_init_tag(), __a)
{ {
__init(__il.begin(), __il.end()); __init(__il.begin(), __il.end());
std::__debug_db_insert_c(this); std::__debug_db_insert_c(this);
} }
#endif // _LIBCPP_CXX03_LANG #endif // _LIBCPP_CXX03_LANG
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
basic_string<_CharT, _Traits, _Allocator>::~basic_string() basic_string<_CharT, _Traits, _Allocator>::~basic_string()
{ {
std::__debug_db_erase_c(this); std::__debug_db_erase_c(this);
if (__is_long()) if (__is_long())
__alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap());
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
void void
basic_string<_CharT, _Traits, _Allocator>::__grow_by_and_replace basic_string<_CharT, _Traits, _Allocator>::__grow_by_and_replace
(size_type __old_cap, size_type __delta_cap, size_type __old_sz, (size_type __old_cap, size_type __delta_cap, size_type __old_sz,
size_type __n_copy, size_type __n_del, size_type __n_add, const value_type* __p_new_stuff) size_type __n_copy, size_type __n_del, size_type __n_add, const value_type* __p_new_stuff)
{ {
size_type __ms = max_size(); size_type __ms = max_size();
if (__delta_cap > __ms - __old_cap - 1) if (__delta_cap > __ms - __old_cap - 1)
__throw_length_error(); __throw_length_error();
Show All 20 Linesbasic_string<_CharT, _Traits, _Allocator>::__grow_by_and_replace
__set_long_cap(__allocation.count); __set_long_cap(__allocation.count);
__old_sz = __n_copy + __n_add + __sec_cp_sz; __old_sz = __n_copy + __n_add + __sec_cp_sz;
__set_long_size(__old_sz); __set_long_size(__old_sz);
traits_type::assign(__p[__old_sz], value_type()); traits_type::assign(__p[__old_sz], value_type());
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
void void
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
basic_string<_CharT, _Traits, _Allocator>::__grow_by(size_type __old_cap, size_type __delta_cap, size_type __old_sz, basic_string<_CharT, _Traits, _Allocator>::__grow_by(size_type __old_cap, size_type __delta_cap, size_type __old_sz,
size_type __n_copy, size_type __n_del, size_type __n_add) size_type __n_copy, size_type __n_del, size_type __n_add)
{ {
size_type __ms = max_size(); size_type __ms = max_size();
if (__delta_cap > __ms - __old_cap) if (__delta_cap > __ms - __old_cap)
__throw_length_error(); __throw_length_error();
pointer __old_p = __get_pointer(); pointer __old_p = __get_pointer();
size_type __cap = __old_cap < __ms / 2 - __alignment ? size_type __cap = __old_cap < __ms / 2 - __alignment ?
Show All 16 Linesbasic_string<_CharT, _Traits, _Allocator>::__grow_by(size_type __old_cap, size_type __delta_cap, size_type __old_sz,
__set_long_pointer(__p); __set_long_pointer(__p);
__set_long_cap(__allocation.count); __set_long_cap(__allocation.count);
} }
// assign // assign
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
template <bool __is_short> template <bool __is_short>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
basic_string<_CharT, _Traits, _Allocator>& basic_string<_CharT, _Traits, _Allocator>&
basic_string<_CharT, _Traits, _Allocator>::__assign_no_alias( basic_string<_CharT, _Traits, _Allocator>::__assign_no_alias(
const value_type* __s, size_type __n) { const value_type* __s, size_type __n) {
size_type __cap = __is_short ? static_cast<size_type>(__min_cap) : __get_long_cap(); size_type __cap = __is_short ? static_cast<size_type>(__min_cap) : __get_long_cap();
if (__n < __cap) { if (__n < __cap) {
pointer __p = __is_short ? __get_short_pointer() : __get_long_pointer(); pointer __p = __is_short ? __get_short_pointer() : __get_long_pointer();
__is_short ? __set_short_size(__n) : __set_long_size(__n); __is_short ? __set_short_size(__n) : __set_long_size(__n);
traits_type::copy(std::__to_address(__p), __s, __n); traits_type::copy(std::__to_address(__p), __s, __n);
traits_type::assign(__p[__n], value_type()); traits_type::assign(__p[__n], value_type());
__invalidate_iterators_past(__n); __invalidate_iterators_past(__n);
} else { } else {
size_type __sz = __is_short ? __get_short_size() : __get_long_size(); size_type __sz = __is_short ? __get_short_size() : __get_long_size();
__grow_by_and_replace(__cap - 1, __n - __cap + 1, __sz, 0, __sz, __n, __s); __grow_by_and_replace(__cap - 1, __n - __cap + 1, __sz, 0, __sz, __n, __s);
} }
return *this; return *this;
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
basic_string<_CharT, _Traits, _Allocator>& basic_string<_CharT, _Traits, _Allocator>&
basic_string<_CharT, _Traits, _Allocator>::__assign_external( basic_string<_CharT, _Traits, _Allocator>::__assign_external(
const value_type* __s, size_type __n) { const value_type* __s, size_type __n) {
size_type __cap = capacity(); size_type __cap = capacity();
if (__cap >= __n) { if (__cap >= __n) {
value_type* __p = std::__to_address(__get_pointer()); value_type* __p = std::__to_address(__get_pointer());
traits_type::move(__p, __s, __n); traits_type::move(__p, __s, __n);
return __null_terminate_at(__p, __n); return __null_terminate_at(__p, __n);
} else { } else {
size_type __sz = size(); size_type __sz = size();
__grow_by_and_replace(__cap, __n - __cap, __sz, 0, __sz, __n, __s); __grow_by_and_replace(__cap, __n - __cap, __sz, 0, __sz, __n, __s);
return *this; return *this;
} }
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
basic_string<_CharT, _Traits, _Allocator>& basic_string<_CharT, _Traits, _Allocator>&
basic_string<_CharT, _Traits, _Allocator>::assign(const value_type* __s, size_type __n) basic_string<_CharT, _Traits, _Allocator>::assign(const value_type* __s, size_type __n)
{ {
_LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::assign received nullptr"); _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::assign received nullptr");
return (__builtin_constant_p(__n) && __fits_in_sso(__n)) return (__builtin_constant_p(__n) && __fits_in_sso(__n))
? __assign_short(__s, __n) ? __assign_short(__s, __n)
: __assign_external(__s, __n); : __assign_external(__s, __n);
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
basic_string<_CharT, _Traits, _Allocator>& basic_string<_CharT, _Traits, _Allocator>&
basic_string<_CharT, _Traits, _Allocator>::assign(size_type __n, value_type __c) basic_string<_CharT, _Traits, _Allocator>::assign(size_type __n, value_type __c)
{ {
size_type __cap = capacity(); size_type __cap = capacity();
if (__cap < __n) if (__cap < __n)
{ {
size_type __sz = size(); size_type __sz = size();
__grow_by(__cap, __n - __cap, __sz, 0, __sz); __grow_by(__cap, __n - __cap, __sz, 0, __sz);
} }
value_type* __p = std::__to_address(__get_pointer()); value_type* __p = std::__to_address(__get_pointer());
traits_type::assign(__p, __n, __c); traits_type::assign(__p, __n, __c);
return __null_terminate_at(__p, __n); return __null_terminate_at(__p, __n);
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
basic_string<_CharT, _Traits, _Allocator>& basic_string<_CharT, _Traits, _Allocator>&
basic_string<_CharT, _Traits, _Allocator>::operator=(value_type __c) basic_string<_CharT, _Traits, _Allocator>::operator=(value_type __c)
{ {
pointer __p; pointer __p;
if (__is_long()) if (__is_long())
{ {
__p = __get_long_pointer(); __p = __get_long_pointer();
__set_long_size(1); __set_long_size(1);
} }
else else
{ {
__p = __get_short_pointer(); __p = __get_short_pointer();
__set_short_size(1); __set_short_size(1);
} }
traits_type::assign(*__p, __c); traits_type::assign(*__p, __c);
traits_type::assign(*++__p, value_type()); traits_type::assign(*++__p, value_type());
__invalidate_iterators_past(1); __invalidate_iterators_past(1);
return *this; return *this;
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
basic_string<_CharT, _Traits, _Allocator>& basic_string<_CharT, _Traits, _Allocator>&
basic_string<_CharT, _Traits, _Allocator>::operator=(const basic_string& __str) basic_string<_CharT, _Traits, _Allocator>::operator=(const basic_string& __str)
{ {
if (this != &__str) { if (this != &__str) {
__copy_assign_alloc(__str); __copy_assign_alloc(__str);
if (!__is_long()) { if (!__is_long()) {
if (!__str.__is_long()) { if (!__str.__is_long()) {
__r_.first().__r = __str.__r_.first().__r; __r_.first().__r = __str.__r_.first().__r;
} else { } else {
return __assign_no_alias<true>(__str.data(), __str.size()); return __assign_no_alias<true>(__str.data(), __str.size());
} }
} else { } else {
return __assign_no_alias<false>(__str.data(), __str.size()); return __assign_no_alias<false>(__str.data(), __str.size());
} }
} }
return *this; return *this;
} }
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_CONSTEXPR_CXX20
void void
basic_string<_CharT, _Traits, _Allocator>::__move_assign(basic_string& __str, false_type) basic_string<_CharT, _Traits, _Allocator>::__move_assign(basic_string& __str, false_type)
_NOEXCEPT_(__alloc_traits::is_always_equal::value) _NOEXCEPT_(__alloc_traits::is_always_equal::value)
{ {
if (__alloc() != __str.__alloc()) if (__alloc() != __str.__alloc())
assign(__str); assign(__str);
else else
__move_assign(__str, true_type()); __move_assign(__str, true_type());
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_CONSTEXPR_CXX20
void void
basic_string<_CharT, _Traits, _Allocator>::__move_assign(basic_string& __str, true_type) basic_string<_CharT, _Traits, _Allocator>::__move_assign(basic_string& __str, true_type)
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER > 14
_NOEXCEPT _NOEXCEPT
#else #else
_NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value) _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value)
#endif #endif
{ {
Show All 13 Lines if (__libcpp_is_constant_evaluated()) {
__str.__default_init(); __str.__default_init();
} else { } else {
__str.__set_short_size(0); __str.__set_short_size(0);
traits_type::assign(__str.__get_short_pointer()[0], value_type()); traits_type::assign(__str.__get_short_pointer()[0], value_type());
} }
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_CONSTEXPR_CXX20
basic_string<_CharT, _Traits, _Allocator>& basic_string<_CharT, _Traits, _Allocator>&
basic_string<_CharT, _Traits, _Allocator>::operator=(basic_string&& __str) basic_string<_CharT, _Traits, _Allocator>::operator=(basic_string&& __str)
_NOEXCEPT_((__noexcept_move_assign_container<_Allocator, __alloc_traits>::value)) _NOEXCEPT_((__noexcept_move_assign_container<_Allocator, __alloc_traits>::value))
{ {
__move_assign(__str, integral_constant<bool, __move_assign(__str, integral_constant<bool,
__alloc_traits::propagate_on_container_move_assignment::value>()); __alloc_traits::propagate_on_container_move_assignment::value>());
return *this; return *this;
} }
#endif #endif
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
template<class _InputIterator> template<class _InputIterator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
__enable_if_t __enable_if_t
< <
__is_exactly_cpp17_input_iterator<_InputIterator>::value, __is_exactly_cpp17_input_iterator<_InputIterator>::value,
basic_string<_CharT, _Traits, _Allocator>& basic_string<_CharT, _Traits, _Allocator>&
> >
basic_string<_CharT, _Traits, _Allocator>::assign(_InputIterator __first, _InputIterator __last) basic_string<_CharT, _Traits, _Allocator>::assign(_InputIterator __first, _InputIterator __last)
{ {
const basic_string __temp(__first, __last, __alloc()); const basic_string __temp(__first, __last, __alloc());
assign(__temp.data(), __temp.size()); assign(__temp.data(), __temp.size());
return *this; return *this;
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
template<class _ForwardIterator> template<class _ForwardIterator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
__enable_if_t __enable_if_t
< <
__is_cpp17_forward_iterator<_ForwardIterator>::value, __is_cpp17_forward_iterator<_ForwardIterator>::value,
basic_string<_CharT, _Traits, _Allocator>& basic_string<_CharT, _Traits, _Allocator>&
> >
basic_string<_CharT, _Traits, _Allocator>::assign(_ForwardIterator __first, _ForwardIterator __last) basic_string<_CharT, _Traits, _Allocator>::assign(_ForwardIterator __first, _ForwardIterator __last)
{ {
size_type __cap = capacity(); size_type __cap = capacity();
Show All 19 Linesbasic_string<_CharT, _Traits, _Allocator>::assign(_ForwardIterator __first, _ForwardIterator __last)
{ {
const basic_string __temp(__first, __last, __alloc()); const basic_string __temp(__first, __last, __alloc());
assign(__temp.data(), __temp.size()); assign(__temp.data(), __temp.size());
} }
return *this; return *this;
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
basic_string<_CharT, _Traits, _Allocator>& basic_string<_CharT, _Traits, _Allocator>&
basic_string<_CharT, _Traits, _Allocator>::assign(const basic_string& __str, size_type __pos, size_type __n) basic_string<_CharT, _Traits, _Allocator>::assign(const basic_string& __str, size_type __pos, size_type __n)
{ {
size_type __sz = __str.size(); size_type __sz = __str.size();
if (__pos > __sz) if (__pos > __sz)
__throw_out_of_range(); __throw_out_of_range();
return assign(__str.data() + __pos, std::min(__n, __sz - __pos)); return assign(__str.data() + __pos, std::min(__n, __sz - __pos));
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
template <class _Tp> template <class _Tp>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
__enable_if_t __enable_if_t
< <
__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value
&& !__is_same_uncvref<_Tp, basic_string<_CharT, _Traits, _Allocator> >::value, && !__is_same_uncvref<_Tp, basic_string<_CharT, _Traits, _Allocator> >::value,
basic_string<_CharT, _Traits, _Allocator>& basic_string<_CharT, _Traits, _Allocator>&
> >
basic_string<_CharT, _Traits, _Allocator>::assign(const _Tp & __t, size_type __pos, size_type __n) basic_string<_CharT, _Traits, _Allocator>::assign(const _Tp & __t, size_type __pos, size_type __n)
{ {
__self_view __sv = __t; __self_view __sv = __t;
size_type __sz = __sv.size(); size_type __sz = __sv.size();
if (__pos > __sz) if (__pos > __sz)
__throw_out_of_range(); __throw_out_of_range();
return assign(__sv.data() + __pos, std::min(__n, __sz - __pos)); return assign(__sv.data() + __pos, std::min(__n, __sz - __pos));
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
basic_string<_CharT, _Traits, _Allocator>& basic_string<_CharT, _Traits, _Allocator>&
basic_string<_CharT, _Traits, _Allocator>::__assign_external(const value_type* __s) { basic_string<_CharT, _Traits, _Allocator>::__assign_external(const value_type* __s) {
return __assign_external(__s, traits_type::length(__s)); return __assign_external(__s, traits_type::length(__s));
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
basic_string<_CharT, _Traits, _Allocator>& basic_string<_CharT, _Traits, _Allocator>&
basic_string<_CharT, _Traits, _Allocator>::assign(const value_type* __s) basic_string<_CharT, _Traits, _Allocator>::assign(const value_type* __s)
{ {
_LIBCPP_ASSERT(__s != nullptr, "string::assign received nullptr"); _LIBCPP_ASSERT(__s != nullptr, "string::assign received nullptr");
return __builtin_constant_p(*__s) return __builtin_constant_p(*__s)
? (__fits_in_sso(traits_type::length(__s)) ? (__fits_in_sso(traits_type::length(__s))
? __assign_short(__s, traits_type::length(__s)) ? __assign_short(__s, traits_type::length(__s))
: __assign_external(__s, traits_type::length(__s))) : __assign_external(__s, traits_type::length(__s)))
: __assign_external(__s); : __assign_external(__s);
} }
// append // append
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
basic_string<_CharT, _Traits, _Allocator>& basic_string<_CharT, _Traits, _Allocator>&
basic_string<_CharT, _Traits, _Allocator>::append(const value_type* __s, size_type __n) basic_string<_CharT, _Traits, _Allocator>::append(const value_type* __s, size_type __n)
{ {
_LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::append received nullptr"); _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::append received nullptr");
size_type __cap = capacity(); size_type __cap = capacity();
size_type __sz = size(); size_type __sz = size();
if (__cap - __sz >= __n) if (__cap - __sz >= __n)
{ {
if (__n) if (__n)
{ {
value_type* __p = std::__to_address(__get_pointer()); value_type* __p = std::__to_address(__get_pointer());
traits_type::copy(__p + __sz, __s, __n); traits_type::copy(__p + __sz, __s, __n);
__sz += __n; __sz += __n;
__set_size(__sz); __set_size(__sz);
traits_type::assign(__p[__sz], value_type()); traits_type::assign(__p[__sz], value_type());
} }
} }
else else
__grow_by_and_replace(__cap, __sz + __n - __cap, __sz, __sz, 0, __n, __s); __grow_by_and_replace(__cap, __sz + __n - __cap, __sz, __sz, 0, __n, __s);
return *this; return *this;
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
basic_string<_CharT, _Traits, _Allocator>& basic_string<_CharT, _Traits, _Allocator>&
basic_string<_CharT, _Traits, _Allocator>::append(size_type __n, value_type __c) basic_string<_CharT, _Traits, _Allocator>::append(size_type __n, value_type __c)
{ {
if (__n) if (__n)
{ {
size_type __cap = capacity(); size_type __cap = capacity();
size_type __sz = size(); size_type __sz = size();
if (__cap - __sz < __n) if (__cap - __sz < __n)
__grow_by(__cap, __sz + __n - __cap, __sz, __sz, 0); __grow_by(__cap, __sz + __n - __cap, __sz, __sz, 0);
pointer __p = __get_pointer(); pointer __p = __get_pointer();
traits_type::assign(std::__to_address(__p) + __sz, __n, __c); traits_type::assign(std::__to_address(__p) + __sz, __n, __c);
__sz += __n; __sz += __n;
__set_size(__sz); __set_size(__sz);
traits_type::assign(__p[__sz], value_type()); traits_type::assign(__p[__sz], value_type());
} }
return *this; return *this;
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 inline void _LIBCPP_CONSTEXPR_CXX20 inline void
basic_string<_CharT, _Traits, _Allocator>::__append_default_init(size_type __n) basic_string<_CharT, _Traits, _Allocator>::__append_default_init(size_type __n)
{ {
if (__n) if (__n)
{ {
size_type __cap = capacity(); size_type __cap = capacity();
size_type __sz = size(); size_type __sz = size();
if (__cap - __sz < __n) if (__cap - __sz < __n)
__grow_by(__cap, __sz + __n - __cap, __sz, __sz, 0); __grow_by(__cap, __sz + __n - __cap, __sz, __sz, 0);
pointer __p = __get_pointer(); pointer __p = __get_pointer();
__sz += __n; __sz += __n;
__set_size(__sz); __set_size(__sz);
traits_type::assign(__p[__sz], value_type()); traits_type::assign(__p[__sz], value_type());
} }
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
void void
basic_string<_CharT, _Traits, _Allocator>::push_back(value_type __c) basic_string<_CharT, _Traits, _Allocator>::push_back(value_type __c)
{ {
bool __is_short = !__is_long(); bool __is_short = !__is_long();
size_type __cap; size_type __cap;
size_type __sz; size_type __sz;
if (__is_short) if (__is_short)
{ {
Show All 22 Lines else
__set_long_size(__sz+1); __set_long_size(__sz+1);
} }
traits_type::assign(*__p, __c); traits_type::assign(*__p, __c);
traits_type::assign(*++__p, value_type()); traits_type::assign(*++__p, value_type());
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
template<class _ForwardIterator> template<class _ForwardIterator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
__enable_if_t __enable_if_t
< <
__is_cpp17_forward_iterator<_ForwardIterator>::value, __is_cpp17_forward_iterator<_ForwardIterator>::value,
basic_string<_CharT, _Traits, _Allocator>& basic_string<_CharT, _Traits, _Allocator>&
> >
basic_string<_CharT, _Traits, _Allocator>::append( basic_string<_CharT, _Traits, _Allocator>::append(
_ForwardIterator __first, _ForwardIterator __last) _ForwardIterator __first, _ForwardIterator __last)
{ {
Show All 18 Lines if (__n)
const basic_string __temp(__first, __last, __alloc()); const basic_string __temp(__first, __last, __alloc());
append(__temp.data(), __temp.size()); append(__temp.data(), __temp.size());
} }
} }
return *this; return *this;
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_CONSTEXPR_CXX20
basic_string<_CharT, _Traits, _Allocator>& basic_string<_CharT, _Traits, _Allocator>&
basic_string<_CharT, _Traits, _Allocator>::append(const basic_string& __str) basic_string<_CharT, _Traits, _Allocator>::append(const basic_string& __str)
{ {
return append(__str.data(), __str.size()); return append(__str.data(), __str.size());
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
basic_string<_CharT, _Traits, _Allocator>& basic_string<_CharT, _Traits, _Allocator>&
basic_string<_CharT, _Traits, _Allocator>::append(const basic_string& __str, size_type __pos, size_type __n) basic_string<_CharT, _Traits, _Allocator>::append(const basic_string& __str, size_type __pos, size_type __n)
{ {
size_type __sz = __str.size(); size_type __sz = __str.size();
if (__pos > __sz) if (__pos > __sz)
__throw_out_of_range(); __throw_out_of_range();
return append(__str.data() + __pos, std::min(__n, __sz - __pos)); return append(__str.data() + __pos, std::min(__n, __sz - __pos));
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
template <class _Tp> template <class _Tp>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
__enable_if_t __enable_if_t
< <
__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value && !__is_same_uncvref<_Tp, basic_string<_CharT, _Traits, _Allocator> >::value, __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value && !__is_same_uncvref<_Tp, basic_string<_CharT, _Traits, _Allocator> >::value,
basic_string<_CharT, _Traits, _Allocator>& basic_string<_CharT, _Traits, _Allocator>&
> >
basic_string<_CharT, _Traits, _Allocator>::append(const _Tp & __t, size_type __pos, size_type __n) basic_string<_CharT, _Traits, _Allocator>::append(const _Tp & __t, size_type __pos, size_type __n)
{ {
__self_view __sv = __t; __self_view __sv = __t;
size_type __sz = __sv.size(); size_type __sz = __sv.size();
if (__pos > __sz) if (__pos > __sz)
__throw_out_of_range(); __throw_out_of_range();
return append(__sv.data() + __pos, std::min(__n, __sz - __pos)); return append(__sv.data() + __pos, std::min(__n, __sz - __pos));
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
basic_string<_CharT, _Traits, _Allocator>& basic_string<_CharT, _Traits, _Allocator>&
basic_string<_CharT, _Traits, _Allocator>::append(const value_type* __s) basic_string<_CharT, _Traits, _Allocator>::append(const value_type* __s)
{ {
_LIBCPP_ASSERT(__s != nullptr, "string::append received nullptr"); _LIBCPP_ASSERT(__s != nullptr, "string::append received nullptr");
return append(__s, traits_type::length(__s)); return append(__s, traits_type::length(__s));
} }
// insert // insert
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
basic_string<_CharT, _Traits, _Allocator>& basic_string<_CharT, _Traits, _Allocator>&
basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos, const value_type* __s, size_type __n) basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos, const value_type* __s, size_type __n)
{ {
_LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::insert received nullptr"); _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::insert received nullptr");
size_type __sz = size(); size_type __sz = size();
if (__pos > __sz) if (__pos > __sz)
__throw_out_of_range(); __throw_out_of_range();
size_type __cap = capacity(); size_type __cap = capacity();
Show All 23 Lines if (__cap - __sz >= __n)
} }
} }
else else
__grow_by_and_replace(__cap, __sz + __n - __cap, __sz, __pos, 0, __n, __s); __grow_by_and_replace(__cap, __sz + __n - __cap, __sz, __pos, 0, __n, __s);
return *this; return *this;
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
basic_string<_CharT, _Traits, _Allocator>& basic_string<_CharT, _Traits, _Allocator>&
basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos, size_type __n, value_type __c) basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos, size_type __n, value_type __c)
{ {
size_type __sz = size(); size_type __sz = size();
if (__pos > __sz) if (__pos > __sz)
__throw_out_of_range(); __throw_out_of_range();
if (__n) if (__n)
{ {
Show All 16 Lines if (__n)
__set_size(__sz); __set_size(__sz);
traits_type::assign(__p[__sz], value_type()); traits_type::assign(__p[__sz], value_type());
} }
return *this; return *this;
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
template<class _InputIterator> template<class _InputIterator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
__enable_if_t __enable_if_t
< <
__is_exactly_cpp17_input_iterator<_InputIterator>::value, __is_exactly_cpp17_input_iterator<_InputIterator>::value,
typename basic_string<_CharT, _Traits, _Allocator>::iterator typename basic_string<_CharT, _Traits, _Allocator>::iterator
> >
basic_string<_CharT, _Traits, _Allocator>::insert(const_iterator __pos, _InputIterator __first, _InputIterator __last) basic_string<_CharT, _Traits, _Allocator>::insert(const_iterator __pos, _InputIterator __first, _InputIterator __last)
{ {
_LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(&__pos) == this, _LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(&__pos) == this,
"string::insert(iterator, range) called with an iterator not" "string::insert(iterator, range) called with an iterator not"
" referring to this string"); " referring to this string");
const basic_string __temp(__first, __last, __alloc()); const basic_string __temp(__first, __last, __alloc());
return insert(__pos, __temp.data(), __temp.data() + __temp.size()); return insert(__pos, __temp.data(), __temp.data() + __temp.size());
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
template<class _ForwardIterator> template<class _ForwardIterator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
__enable_if_t __enable_if_t
< <
__is_cpp17_forward_iterator<_ForwardIterator>::value, __is_cpp17_forward_iterator<_ForwardIterator>::value,
typename basic_string<_CharT, _Traits, _Allocator>::iterator typename basic_string<_CharT, _Traits, _Allocator>::iterator
> >
basic_string<_CharT, _Traits, _Allocator>::insert(const_iterator __pos, _ForwardIterator __first, _ForwardIterator __last) basic_string<_CharT, _Traits, _Allocator>::insert(const_iterator __pos, _ForwardIterator __first, _ForwardIterator __last)
{ {
_LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(&__pos) == this, _LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(&__pos) == this,
Show All 11 Linesbasic_string<_CharT, _Traits, _Allocator>::insert(const_iterator __pos, _ForwardIterator __first, _ForwardIterator __last)
else else
{ {
const basic_string __temp(__first, __last, __alloc()); const basic_string __temp(__first, __last, __alloc());
return __insert_from_safe_copy(__n, __ip, __temp.begin(), __temp.end()); return __insert_from_safe_copy(__n, __ip, __temp.begin(), __temp.end());
} }
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_CONSTEXPR_CXX20
basic_string<_CharT, _Traits, _Allocator>& basic_string<_CharT, _Traits, _Allocator>&
basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos1, const basic_string& __str) basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos1, const basic_string& __str)
{ {
return insert(__pos1, __str.data(), __str.size()); return insert(__pos1, __str.data(), __str.size());
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
basic_string<_CharT, _Traits, _Allocator>& basic_string<_CharT, _Traits, _Allocator>&
basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos1, const basic_string& __str, basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos1, const basic_string& __str,
size_type __pos2, size_type __n) size_type __pos2, size_type __n)
{ {
size_type __str_sz = __str.size(); size_type __str_sz = __str.size();
if (__pos2 > __str_sz) if (__pos2 > __str_sz)
__throw_out_of_range(); __throw_out_of_range();
return insert(__pos1, __str.data() + __pos2, std::min(__n, __str_sz - __pos2)); return insert(__pos1, __str.data() + __pos2, std::min(__n, __str_sz - __pos2));
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
template <class _Tp> template <class _Tp>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
__enable_if_t __enable_if_t
< <
__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value && !__is_same_uncvref<_Tp, basic_string<_CharT, _Traits, _Allocator> >::value, __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value && !__is_same_uncvref<_Tp, basic_string<_CharT, _Traits, _Allocator> >::value,
basic_string<_CharT, _Traits, _Allocator>& basic_string<_CharT, _Traits, _Allocator>&
> >
basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos1, const _Tp& __t, basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos1, const _Tp& __t,
size_type __pos2, size_type __n) size_type __pos2, size_type __n)
{ {
__self_view __sv = __t; __self_view __sv = __t;
size_type __str_sz = __sv.size(); size_type __str_sz = __sv.size();
if (__pos2 > __str_sz) if (__pos2 > __str_sz)
__throw_out_of_range(); __throw_out_of_range();
return insert(__pos1, __sv.data() + __pos2, std::min(__n, __str_sz - __pos2)); return insert(__pos1, __sv.data() + __pos2, std::min(__n, __str_sz - __pos2));
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
basic_string<_CharT, _Traits, _Allocator>& basic_string<_CharT, _Traits, _Allocator>&
basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos, const value_type* __s) basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos, const value_type* __s)
{ {
_LIBCPP_ASSERT(__s != nullptr, "string::insert received nullptr"); _LIBCPP_ASSERT(__s != nullptr, "string::insert received nullptr");
return insert(__pos, __s, traits_type::length(__s)); return insert(__pos, __s, traits_type::length(__s));
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
typename basic_string<_CharT, _Traits, _Allocator>::iterator typename basic_string<_CharT, _Traits, _Allocator>::iterator
basic_string<_CharT, _Traits, _Allocator>::insert(const_iterator __pos, value_type __c) basic_string<_CharT, _Traits, _Allocator>::insert(const_iterator __pos, value_type __c)
{ {
_LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(&__pos) == this, _LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(&__pos) == this,
"string::insert(iterator, character) called with an iterator not" "string::insert(iterator, character) called with an iterator not"
" referring to this string"); " referring to this string");
size_type __ip = static_cast<size_type>(__pos - begin()); size_type __ip = static_cast<size_type>(__pos - begin());
Show All 14 Linesbasic_string<_CharT, _Traits, _Allocator>::insert(const_iterator __pos, value_type __c)
} }
traits_type::assign(__p[__ip], __c); traits_type::assign(__p[__ip], __c);
traits_type::assign(__p[++__sz], value_type()); traits_type::assign(__p[++__sz], value_type());
__set_size(__sz); __set_size(__sz);
return begin() + static_cast<difference_type>(__ip); return begin() + static_cast<difference_type>(__ip);
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_CONSTEXPR_CXX20
typename basic_string<_CharT, _Traits, _Allocator>::iterator typename basic_string<_CharT, _Traits, _Allocator>::iterator
basic_string<_CharT, _Traits, _Allocator>::insert(const_iterator __pos, size_type __n, value_type __c) basic_string<_CharT, _Traits, _Allocator>::insert(const_iterator __pos, size_type __n, value_type __c)
{ {
_LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(&__pos) == this, _LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(&__pos) == this,
"string::insert(iterator, n, value) called with an iterator not" "string::insert(iterator, n, value) called with an iterator not"
" referring to this string"); " referring to this string");
difference_type __p = __pos - begin(); difference_type __p = __pos - begin();
insert(static_cast<size_type>(__p), __n, __c); insert(static_cast<size_type>(__p), __n, __c);
return begin() + __p; return begin() + __p;
} }
// replace // replace
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
basic_string<_CharT, _Traits, _Allocator>& basic_string<_CharT, _Traits, _Allocator>&
basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos, size_type __n1, const value_type* __s, size_type __n2) basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos, size_type __n1, const value_type* __s, size_type __n2)
_LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK
{ {
_LIBCPP_ASSERT(__n2 == 0 || __s != nullptr, "string::replace received nullptr"); _LIBCPP_ASSERT(__n2 == 0 || __s != nullptr, "string::replace received nullptr");
size_type __sz = size(); size_type __sz = size();
if (__pos > __sz) if (__pos > __sz)
__throw_out_of_range(); __throw_out_of_range();
Show All 37 Lines if (__cap - __sz + __n1 >= __n2)
return __null_terminate_at(__p, __sz + (__n2 - __n1)); return __null_terminate_at(__p, __sz + (__n2 - __n1));
} }
else else
__grow_by_and_replace(__cap, __sz - __n1 + __n2 - __cap, __sz, __pos, __n1, __n2, __s); __grow_by_and_replace(__cap, __sz - __n1 + __n2 - __cap, __sz, __pos, __n1, __n2, __s);
return *this; return *this;
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
basic_string<_CharT, _Traits, _Allocator>& basic_string<_CharT, _Traits, _Allocator>&
basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos, size_type __n1, size_type __n2, value_type __c) basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos, size_type __n1, size_type __n2, value_type __c)
{ {
size_type __sz = size(); size_type __sz = size();
if (__pos > __sz) if (__pos > __sz)
__throw_out_of_range(); __throw_out_of_range();
__n1 = std::min(__n1, __sz - __pos); __n1 = std::min(__n1, __sz - __pos);
size_type __cap = capacity(); size_type __cap = capacity();
Show All 14 Lines else
__p = std::__to_address(__get_long_pointer()); __p = std::__to_address(__get_long_pointer());
} }
traits_type::assign(__p + __pos, __n2, __c); traits_type::assign(__p + __pos, __n2, __c);
return __null_terminate_at(__p, __sz - (__n1 - __n2)); return __null_terminate_at(__p, __sz - (__n1 - __n2));
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
template<class _InputIterator> template<class _InputIterator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
__enable_if_t __enable_if_t
< <
__is_cpp17_input_iterator<_InputIterator>::value, __is_cpp17_input_iterator<_InputIterator>::value,
basic_string<_CharT, _Traits, _Allocator>& basic_string<_CharT, _Traits, _Allocator>&
> >
basic_string<_CharT, _Traits, _Allocator>::replace(const_iterator __i1, const_iterator __i2, basic_string<_CharT, _Traits, _Allocator>::replace(const_iterator __i1, const_iterator __i2,
_InputIterator __j1, _InputIterator __j2) _InputIterator __j1, _InputIterator __j2)
{ {
const basic_string __temp(__j1, __j2, __alloc()); const basic_string __temp(__j1, __j2, __alloc());
return replace(__i1, __i2, __temp); return replace(__i1, __i2, __temp);
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_CONSTEXPR_CXX20
basic_string<_CharT, _Traits, _Allocator>& basic_string<_CharT, _Traits, _Allocator>&
basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos1, size_type __n1, const basic_string& __str) basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos1, size_type __n1, const basic_string& __str)
{ {
return replace(__pos1, __n1, __str.data(), __str.size()); return replace(__pos1, __n1, __str.data(), __str.size());
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
basic_string<_CharT, _Traits, _Allocator>& basic_string<_CharT, _Traits, _Allocator>&
basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos1, size_type __n1, const basic_string& __str, basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos1, size_type __n1, const basic_string& __str,
size_type __pos2, size_type __n2) size_type __pos2, size_type __n2)
{ {
size_type __str_sz = __str.size(); size_type __str_sz = __str.size();
if (__pos2 > __str_sz) if (__pos2 > __str_sz)
__throw_out_of_range(); __throw_out_of_range();
return replace(__pos1, __n1, __str.data() + __pos2, std::min(__n2, __str_sz - __pos2)); return replace(__pos1, __n1, __str.data() + __pos2, std::min(__n2, __str_sz - __pos2));
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
template <class _Tp> template <class _Tp>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
__enable_if_t __enable_if_t
< <
__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value && !__is_same_uncvref<_Tp, basic_string<_CharT, _Traits, _Allocator> >::value, __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value && !__is_same_uncvref<_Tp, basic_string<_CharT, _Traits, _Allocator> >::value,
basic_string<_CharT, _Traits, _Allocator>& basic_string<_CharT, _Traits, _Allocator>&
> >
basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos1, size_type __n1, const _Tp& __t, basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos1, size_type __n1, const _Tp& __t,
size_type __pos2, size_type __n2) size_type __pos2, size_type __n2)
{ {
__self_view __sv = __t; __self_view __sv = __t;
size_type __str_sz = __sv.size(); size_type __str_sz = __sv.size();
if (__pos2 > __str_sz) if (__pos2 > __str_sz)
__throw_out_of_range(); __throw_out_of_range();
return replace(__pos1, __n1, __sv.data() + __pos2, std::min(__n2, __str_sz - __pos2)); return replace(__pos1, __n1, __sv.data() + __pos2, std::min(__n2, __str_sz - __pos2));
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
basic_string<_CharT, _Traits, _Allocator>& basic_string<_CharT, _Traits, _Allocator>&
basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos, size_type __n1, const value_type* __s) basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos, size_type __n1, const value_type* __s)
{ {
_LIBCPP_ASSERT(__s != nullptr, "string::replace received nullptr"); _LIBCPP_ASSERT(__s != nullptr, "string::replace received nullptr");
return replace(__pos, __n1, __s, traits_type::length(__s)); return replace(__pos, __n1, __s, traits_type::length(__s));
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_CONSTEXPR_CXX20
basic_string<_CharT, _Traits, _Allocator>& basic_string<_CharT, _Traits, _Allocator>&
basic_string<_CharT, _Traits, _Allocator>::replace(const_iterator __i1, const_iterator __i2, const basic_string& __str) basic_string<_CharT, _Traits, _Allocator>::replace(const_iterator __i1, const_iterator __i2, const basic_string& __str)
{ {
return replace(static_cast<size_type>(__i1 - begin()), static_cast<size_type>(__i2 - __i1), return replace(static_cast<size_type>(__i1 - begin()), static_cast<size_type>(__i2 - __i1),
__str.data(), __str.size()); __str.data(), __str.size());
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_CONSTEXPR_CXX20
basic_string<_CharT, _Traits, _Allocator>& basic_string<_CharT, _Traits, _Allocator>&
basic_string<_CharT, _Traits, _Allocator>::replace(const_iterator __i1, const_iterator __i2, const value_type* __s, size_type __n) basic_string<_CharT, _Traits, _Allocator>::replace(const_iterator __i1, const_iterator __i2, const value_type* __s, size_type __n)
{ {
return replace(static_cast<size_type>(__i1 - begin()), static_cast<size_type>(__i2 - __i1), __s, __n); return replace(static_cast<size_type>(__i1 - begin()), static_cast<size_type>(__i2 - __i1), __s, __n);
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_CONSTEXPR_CXX20
basic_string<_CharT, _Traits, _Allocator>& basic_string<_CharT, _Traits, _Allocator>&
basic_string<_CharT, _Traits, _Allocator>::replace(const_iterator __i1, const_iterator __i2, const value_type* __s) basic_string<_CharT, _Traits, _Allocator>::replace(const_iterator __i1, const_iterator __i2, const value_type* __s)
{ {
return replace(static_cast<size_type>(__i1 - begin()), static_cast<size_type>(__i2 - __i1), __s); return replace(static_cast<size_type>(__i1 - begin()), static_cast<size_type>(__i2 - __i1), __s);
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_CONSTEXPR_CXX20
basic_string<_CharT, _Traits, _Allocator>& basic_string<_CharT, _Traits, _Allocator>&
basic_string<_CharT, _Traits, _Allocator>::replace(const_iterator __i1, const_iterator __i2, size_type __n, value_type __c) basic_string<_CharT, _Traits, _Allocator>::replace(const_iterator __i1, const_iterator __i2, size_type __n, value_type __c)
{ {
return replace(static_cast<size_type>(__i1 - begin()), static_cast<size_type>(__i2 - __i1), __n, __c); return replace(static_cast<size_type>(__i1 - begin()), static_cast<size_type>(__i2 - __i1), __n, __c);
} }
// erase // erase
// 'externally instantiated' erase() implementation, called when __n != npos. // 'externally instantiated' erase() implementation, called when __n != npos.
// Does not check __pos against size() // Does not check __pos against size()
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
void void
basic_string<_CharT, _Traits, _Allocator>::__erase_external_with_move( basic_string<_CharT, _Traits, _Allocator>::__erase_external_with_move(
size_type __pos, size_type __n) size_type __pos, size_type __n)
{ {
if (__n) if (__n)
{ {
size_type __sz = size(); size_type __sz = size();
value_type* __p = std::__to_address(__get_pointer()); value_type* __p = std::__to_address(__get_pointer());
__n = std::min(__n, __sz - __pos); __n = std::min(__n, __sz - __pos);
size_type __n_move = __sz - __pos - __n; size_type __n_move = __sz - __pos - __n;
if (__n_move != 0) if (__n_move != 0)
traits_type::move(__p + __pos, __p + __pos + __n, __n_move); traits_type::move(__p + __pos, __p + __pos + __n, __n_move);
__null_terminate_at(__p, __sz - __n); __null_terminate_at(__p, __sz - __n);
} }
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
basic_string<_CharT, _Traits, _Allocator>& basic_string<_CharT, _Traits, _Allocator>&
basic_string<_CharT, _Traits, _Allocator>::erase(size_type __pos, basic_string<_CharT, _Traits, _Allocator>::erase(size_type __pos,
size_type __n) { size_type __n) {
if (__pos > size()) if (__pos > size())
__throw_out_of_range(); __throw_out_of_range();
if (__n == npos) { if (__n == npos) {
__erase_to_end(__pos); __erase_to_end(__pos);
} else { } else {
__erase_external_with_move(__pos, __n); __erase_external_with_move(__pos, __n);
} }
return *this; return *this;
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_CONSTEXPR_CXX20
typename basic_string<_CharT, _Traits, _Allocator>::iterator typename basic_string<_CharT, _Traits, _Allocator>::iterator
basic_string<_CharT, _Traits, _Allocator>::erase(const_iterator __pos) basic_string<_CharT, _Traits, _Allocator>::erase(const_iterator __pos)
{ {
_LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(&__pos) == this, _LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(&__pos) == this,
"string::erase(iterator) called with an iterator not" "string::erase(iterator) called with an iterator not"
" referring to this string"); " referring to this string");
_LIBCPP_ASSERT(__pos != end(), "string::erase(iterator) called with a non-dereferenceable iterator"); _LIBCPP_ASSERT(__pos != end(), "string::erase(iterator) called with a non-dereferenceable iterator");
iterator __b = begin(); iterator __b = begin();
size_type __r = static_cast<size_type>(__pos - __b); size_type __r = static_cast<size_type>(__pos - __b);
erase(__r, 1); erase(__r, 1);
return __b + static_cast<difference_type>(__r); return __b + static_cast<difference_type>(__r);
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_CONSTEXPR_CXX20
typename basic_string<_CharT, _Traits, _Allocator>::iterator typename basic_string<_CharT, _Traits, _Allocator>::iterator
basic_string<_CharT, _Traits, _Allocator>::erase(const_iterator __first, const_iterator __last) basic_string<_CharT, _Traits, _Allocator>::erase(const_iterator __first, const_iterator __last)
{ {
_LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(&__first) == this, _LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(&__first) == this,
"string::erase(iterator, iterator) called with an iterator not" "string::erase(iterator, iterator) called with an iterator not"
" referring to this string"); " referring to this string");
_LIBCPP_ASSERT(__first <= __last, "string::erase(first, last) called with invalid range"); _LIBCPP_ASSERT(__first <= __last, "string::erase(first, last) called with invalid range");
iterator __b = begin(); iterator __b = begin();
size_type __r = static_cast<size_type>(__first - __b); size_type __r = static_cast<size_type>(__first - __b);
erase(__r, static_cast<size_type>(__last - __first)); erase(__r, static_cast<size_type>(__last - __first));
return __b + static_cast<difference_type>(__r); return __b + static_cast<difference_type>(__r);
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_CONSTEXPR_CXX20
void void
basic_string<_CharT, _Traits, _Allocator>::pop_back() basic_string<_CharT, _Traits, _Allocator>::pop_back()
{ {
_LIBCPP_ASSERT(!empty(), "string::pop_back(): string is already empty"); _LIBCPP_ASSERT(!empty(), "string::pop_back(): string is already empty");
__erase_to_end(size() - 1); __erase_to_end(size() - 1);
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_CONSTEXPR_CXX20
void void
basic_string<_CharT, _Traits, _Allocator>::clear() _NOEXCEPT basic_string<_CharT, _Traits, _Allocator>::clear() _NOEXCEPT
{ {
std::__debug_db_invalidate_all(this); std::__debug_db_invalidate_all(this);
if (__is_long()) if (__is_long())
{ {
traits_type::assign(*__get_long_pointer(), value_type()); traits_type::assign(*__get_long_pointer(), value_type());
__set_long_size(0); __set_long_size(0);
} }
else else
{ {
traits_type::assign(*__get_short_pointer(), value_type()); traits_type::assign(*__get_short_pointer(), value_type());
__set_short_size(0); __set_short_size(0);
} }
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_CONSTEXPR_CXX20
void void
basic_string<_CharT, _Traits, _Allocator>::__erase_to_end(size_type __pos) basic_string<_CharT, _Traits, _Allocator>::__erase_to_end(size_type __pos)
{ {
__null_terminate_at(std::__to_address(__get_pointer()), __pos); __null_terminate_at(std::__to_address(__get_pointer()), __pos);
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
void void
basic_string<_CharT, _Traits, _Allocator>::resize(size_type __n, value_type __c) basic_string<_CharT, _Traits, _Allocator>::resize(size_type __n, value_type __c)
{ {
size_type __sz = size(); size_type __sz = size();
if (__n > __sz) if (__n > __sz)
append(__n - __sz, __c); append(__n - __sz, __c);
else else
__erase_to_end(__n); __erase_to_end(__n);
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 inline void _LIBCPP_CONSTEXPR_CXX20 inline void
basic_string<_CharT, _Traits, _Allocator>::__resize_default_init(size_type __n) basic_string<_CharT, _Traits, _Allocator>::__resize_default_init(size_type __n)
{ {
size_type __sz = size(); size_type __sz = size();
if (__n > __sz) { if (__n > __sz) {
__append_default_init(__n - __sz); __append_default_init(__n - __sz);
} else } else
__erase_to_end(__n); __erase_to_end(__n);
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_CONSTEXPR_CXX20
typename basic_string<_CharT, _Traits, _Allocator>::size_type typename basic_string<_CharT, _Traits, _Allocator>::size_type
basic_string<_CharT, _Traits, _Allocator>::max_size() const _NOEXCEPT basic_string<_CharT, _Traits, _Allocator>::max_size() const _NOEXCEPT
{ {
size_type __m = __alloc_traits::max_size(__alloc()); size_type __m = __alloc_traits::max_size(__alloc());
if (__m <= std::numeric_limits<size_type>::max() / 2) { if (__m <= std::numeric_limits<size_type>::max() / 2) {
return __m - __alignment; return __m - __alignment;
} else { } else {
bool __uses_lsb = __endian_factor == 2; bool __uses_lsb = __endian_factor == 2;
return __uses_lsb ? __m - __alignment : (__m / 2) - __alignment; return __uses_lsb ? __m - __alignment : (__m / 2) - __alignment;
} }
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
void void
basic_string<_CharT, _Traits, _Allocator>::reserve(size_type __requested_capacity) basic_string<_CharT, _Traits, _Allocator>::reserve(size_type __requested_capacity)
{ {
if (__requested_capacity > max_size()) if (__requested_capacity > max_size())
__throw_length_error(); __throw_length_error();
// Make sure reserve(n) never shrinks. This is technically only required in C++20 // Make sure reserve(n) never shrinks. This is technically only required in C++20
// and later (since P0966R1), however we provide consistent behavior in all Standard // and later (since P0966R1), however we provide consistent behavior in all Standard
// modes because this function is instantiated in the shared library. // modes because this function is instantiated in the shared library.
if (__requested_capacity <= capacity()) if (__requested_capacity <= capacity())
return; return;
size_type __target_capacity = std::max(__requested_capacity, size()); size_type __target_capacity = std::max(__requested_capacity, size());
__target_capacity = __recommend(__target_capacity); __target_capacity = __recommend(__target_capacity);
if (__target_capacity == capacity()) return; if (__target_capacity == capacity()) return;
__shrink_or_extend(__target_capacity); __shrink_or_extend(__target_capacity);
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_CONSTEXPR_CXX20
void void
basic_string<_CharT, _Traits, _Allocator>::shrink_to_fit() _NOEXCEPT basic_string<_CharT, _Traits, _Allocator>::shrink_to_fit() _NOEXCEPT
{ {
size_type __target_capacity = __recommend(size()); size_type __target_capacity = __recommend(size());
if (__target_capacity == capacity()) return; if (__target_capacity == capacity()) return;
__shrink_or_extend(__target_capacity); __shrink_or_extend(__target_capacity);
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_CONSTEXPR_CXX20
void void
basic_string<_CharT, _Traits, _Allocator>::__shrink_or_extend(size_type __target_capacity) basic_string<_CharT, _Traits, _Allocator>::__shrink_or_extend(size_type __target_capacity)
{ {
size_type __cap = capacity(); size_type __cap = capacity();
size_type __sz = size(); size_type __sz = size();
pointer __new_data, __p; pointer __new_data, __p;
bool __was_long, __now_long; bool __was_long, __now_long;
▲ Show 20 Lines • Show All 47 Lines • ▼ Show 20 Lines if (__now_long)
__set_long_pointer(__new_data); __set_long_pointer(__new_data);
} }
else else
__set_short_size(__sz); __set_short_size(__sz);
std::__debug_db_invalidate_all(this); std::__debug_db_invalidate_all(this);
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_CONSTEXPR_CXX20
typename basic_string<_CharT, _Traits, _Allocator>::const_reference typename basic_string<_CharT, _Traits, _Allocator>::const_reference
basic_string<_CharT, _Traits, _Allocator>::operator[](size_type __pos) const _NOEXCEPT basic_string<_CharT, _Traits, _Allocator>::operator[](size_type __pos) const _NOEXCEPT
{ {
_LIBCPP_ASSERT(__pos <= size(), "string index out of bounds"); _LIBCPP_ASSERT(__pos <= size(), "string index out of bounds");
return *(data() + __pos); return *(data() + __pos);
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_CONSTEXPR_CXX20
typename basic_string<_CharT, _Traits, _Allocator>::reference typename basic_string<_CharT, _Traits, _Allocator>::reference
basic_string<_CharT, _Traits, _Allocator>::operator[](size_type __pos) _NOEXCEPT basic_string<_CharT, _Traits, _Allocator>::operator[](size_type __pos) _NOEXCEPT
{ {
_LIBCPP_ASSERT(__pos <= size(), "string index out of bounds"); _LIBCPP_ASSERT(__pos <= size(), "string index out of bounds");
return *(__get_pointer() + __pos); return *(__get_pointer() + __pos);
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
typename basic_string<_CharT, _Traits, _Allocator>::const_reference typename basic_string<_CharT, _Traits, _Allocator>::const_reference
basic_string<_CharT, _Traits, _Allocator>::at(size_type __n) const basic_string<_CharT, _Traits, _Allocator>::at(size_type __n) const
{ {
if (__n >= size()) if (__n >= size())
__throw_out_of_range(); __throw_out_of_range();
return (*this)[__n]; return (*this)[__n];
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
typename basic_string<_CharT, _Traits, _Allocator>::reference typename basic_string<_CharT, _Traits, _Allocator>::reference
basic_string<_CharT, _Traits, _Allocator>::at(size_type __n) basic_string<_CharT, _Traits, _Allocator>::at(size_type __n)
{ {
if (__n >= size()) if (__n >= size())
__throw_out_of_range(); __throw_out_of_range();
return (*this)[__n]; return (*this)[__n];
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_CONSTEXPR_CXX20
typename basic_string<_CharT, _Traits, _Allocator>::reference typename basic_string<_CharT, _Traits, _Allocator>::reference
basic_string<_CharT, _Traits, _Allocator>::front() _NOEXCEPT basic_string<_CharT, _Traits, _Allocator>::front() _NOEXCEPT
{ {
_LIBCPP_ASSERT(!empty(), "string::front(): string is empty"); _LIBCPP_ASSERT(!empty(), "string::front(): string is empty");
return *__get_pointer(); return *__get_pointer();
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_CONSTEXPR_CXX20
typename basic_string<_CharT, _Traits, _Allocator>::const_reference typename basic_string<_CharT, _Traits, _Allocator>::const_reference
basic_string<_CharT, _Traits, _Allocator>::front() const _NOEXCEPT basic_string<_CharT, _Traits, _Allocator>::front() const _NOEXCEPT
{ {
_LIBCPP_ASSERT(!empty(), "string::front(): string is empty"); _LIBCPP_ASSERT(!empty(), "string::front(): string is empty");
return *data(); return *data();
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_CONSTEXPR_CXX20
typename basic_string<_CharT, _Traits, _Allocator>::reference typename basic_string<_CharT, _Traits, _Allocator>::reference
basic_string<_CharT, _Traits, _Allocator>::back() _NOEXCEPT basic_string<_CharT, _Traits, _Allocator>::back() _NOEXCEPT
{ {
_LIBCPP_ASSERT(!empty(), "string::back(): string is empty"); _LIBCPP_ASSERT(!empty(), "string::back(): string is empty");
return *(__get_pointer() + size() - 1); return *(__get_pointer() + size() - 1);
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_CONSTEXPR_CXX20
typename basic_string<_CharT, _Traits, _Allocator>::const_reference typename basic_string<_CharT, _Traits, _Allocator>::const_reference
basic_string<_CharT, _Traits, _Allocator>::back() const _NOEXCEPT basic_string<_CharT, _Traits, _Allocator>::back() const _NOEXCEPT
{ {
_LIBCPP_ASSERT(!empty(), "string::back(): string is empty"); _LIBCPP_ASSERT(!empty(), "string::back(): string is empty");
return *(data() + size() - 1); return *(data() + size() - 1);
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
typename basic_string<_CharT, _Traits, _Allocator>::size_type typename basic_string<_CharT, _Traits, _Allocator>::size_type
basic_string<_CharT, _Traits, _Allocator>::copy(value_type* __s, size_type __n, size_type __pos) const basic_string<_CharT, _Traits, _Allocator>::copy(value_type* __s, size_type __n, size_type __pos) const
{ {
size_type __sz = size(); size_type __sz = size();
if (__pos > __sz) if (__pos > __sz)
__throw_out_of_range(); __throw_out_of_range();
size_type __rlen = std::min(__n, __sz - __pos); size_type __rlen = std::min(__n, __sz - __pos);
traits_type::copy(__s, data() + __pos, __rlen); traits_type::copy(__s, data() + __pos, __rlen);
return __rlen; return __rlen;
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_CONSTEXPR_CXX20
basic_string<_CharT, _Traits, _Allocator> basic_string<_CharT, _Traits, _Allocator>
basic_string<_CharT, _Traits, _Allocator>::substr(size_type __pos, size_type __n) const basic_string<_CharT, _Traits, _Allocator>::substr(size_type __pos, size_type __n) const
{ {
return basic_string(*this, __pos, __n, __alloc()); return basic_string(*this, __pos, __n, __alloc());
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_CONSTEXPR_CXX20
void void
basic_string<_CharT, _Traits, _Allocator>::swap(basic_string& __str) basic_string<_CharT, _Traits, _Allocator>::swap(basic_string& __str)
#if _LIBCPP_STD_VER >= 14 #if _LIBCPP_STD_VER >= 14
_NOEXCEPT _NOEXCEPT
#else #else
_NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value || _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value ||
__is_nothrow_swappable<allocator_type>::value) __is_nothrow_swappable<allocator_type>::value)
#endif #endif
Show All 19 Lines
{ {
typedef typename _Traits::char_type char_type; typedef typename _Traits::char_type char_type;
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
bool operator()(const char_type& __x, const char_type& __y) _NOEXCEPT bool operator()(const char_type& __x, const char_type& __y) _NOEXCEPT
{return _Traits::eq(__x, __y);} {return _Traits::eq(__x, __y);}
}; };
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
typename basic_string<_CharT, _Traits, _Allocator>::size_type typename basic_string<_CharT, _Traits, _Allocator>::size_type
basic_string<_CharT, _Traits, _Allocator>::find(const value_type* __s, basic_string<_CharT, _Traits, _Allocator>::find(const value_type* __s,
size_type __pos, size_type __pos,
size_type __n) const _NOEXCEPT size_type __n) const _NOEXCEPT
{ {
_LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::find(): received nullptr"); _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::find(): received nullptr");
return __str_find<value_type, size_type, traits_type, npos> return __str_find<value_type, size_type, traits_type, npos>
(data(), size(), __s, __pos, __n); (data(), size(), __s, __pos, __n);
} }
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_CONSTEXPR_CXX20
typename basic_string<_CharT, _Traits, _Allocator>::size_type typename basic_string<_CharT, _Traits, _Allocator>::size_type
basic_string<_CharT, _Traits, _Allocator>::find(const basic_string& __str, basic_string<_CharT, _Traits, _Allocator>::find(const basic_string& __str,
size_type __pos) const _NOEXCEPT size_type __pos) const _NOEXCEPT
{ {
return __str_find<value_type, size_type, traits_type, npos> return __str_find<value_type, size_type, traits_type, npos>
(data(), size(), __str.data(), __pos, __str.size()); (data(), size(), __str.data(), __pos, __str.size());
} }
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
template <class _Tp> template <class _Tp>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
__enable_if_t __enable_if_t
< <
__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
typename basic_string<_CharT, _Traits, _Allocator>::size_type typename basic_string<_CharT, _Traits, _Allocator>::size_type
> >
basic_string<_CharT, _Traits, _Allocator>::find(const _Tp &__t, basic_string<_CharT, _Traits, _Allocator>::find(const _Tp &__t,
size_type __pos) const _NOEXCEPT size_type __pos) const _NOEXCEPT
{ {
__self_view __sv = __t; __self_view __sv = __t;
return __str_find<value_type, size_type, traits_type, npos> return __str_find<value_type, size_type, traits_type, npos>
(data(), size(), __sv.data(), __pos, __sv.size()); (data(), size(), __sv.data(), __pos, __sv.size());
} }
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_CONSTEXPR_CXX20
typename basic_string<_CharT, _Traits, _Allocator>::size_type typename basic_string<_CharT, _Traits, _Allocator>::size_type
basic_string<_CharT, _Traits, _Allocator>::find(const value_type* __s, basic_string<_CharT, _Traits, _Allocator>::find(const value_type* __s,
size_type __pos) const _NOEXCEPT size_type __pos) const _NOEXCEPT
{ {
_LIBCPP_ASSERT(__s != nullptr, "string::find(): received nullptr"); _LIBCPP_ASSERT(__s != nullptr, "string::find(): received nullptr");
return __str_find<value_type, size_type, traits_type, npos> return __str_find<value_type, size_type, traits_type, npos>
(data(), size(), __s, __pos, traits_type::length(__s)); (data(), size(), __s, __pos, traits_type::length(__s));
} }
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
typename basic_string<_CharT, _Traits, _Allocator>::size_type typename basic_string<_CharT, _Traits, _Allocator>::size_type
basic_string<_CharT, _Traits, _Allocator>::find(value_type __c, basic_string<_CharT, _Traits, _Allocator>::find(value_type __c,
size_type __pos) const _NOEXCEPT size_type __pos) const _NOEXCEPT
{ {
return __str_find<value_type, size_type, traits_type, npos> return __str_find<value_type, size_type, traits_type, npos>
(data(), size(), __c, __pos); (data(), size(), __c, __pos);
} }
// rfind // rfind
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
typename basic_string<_CharT, _Traits, _Allocator>::size_type typename basic_string<_CharT, _Traits, _Allocator>::size_type
basic_string<_CharT, _Traits, _Allocator>::rfind(const value_type* __s, basic_string<_CharT, _Traits, _Allocator>::rfind(const value_type* __s,
size_type __pos, size_type __pos,
size_type __n) const _NOEXCEPT size_type __n) const _NOEXCEPT
{ {
_LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::rfind(): received nullptr"); _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::rfind(): received nullptr");
return __str_rfind<value_type, size_type, traits_type, npos> return __str_rfind<value_type, size_type, traits_type, npos>
(data(), size(), __s, __pos, __n); (data(), size(), __s, __pos, __n);
} }
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_CONSTEXPR_CXX20
typename basic_string<_CharT, _Traits, _Allocator>::size_type typename basic_string<_CharT, _Traits, _Allocator>::size_type
basic_string<_CharT, _Traits, _Allocator>::rfind(const basic_string& __str, basic_string<_CharT, _Traits, _Allocator>::rfind(const basic_string& __str,
size_type __pos) const _NOEXCEPT size_type __pos) const _NOEXCEPT
{ {
return __str_rfind<value_type, size_type, traits_type, npos> return __str_rfind<value_type, size_type, traits_type, npos>
(data(), size(), __str.data(), __pos, __str.size()); (data(), size(), __str.data(), __pos, __str.size());
} }
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
template <class _Tp> template <class _Tp>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
__enable_if_t __enable_if_t
< <
__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
typename basic_string<_CharT, _Traits, _Allocator>::size_type typename basic_string<_CharT, _Traits, _Allocator>::size_type
> >
basic_string<_CharT, _Traits, _Allocator>::rfind(const _Tp& __t, basic_string<_CharT, _Traits, _Allocator>::rfind(const _Tp& __t,
size_type __pos) const _NOEXCEPT size_type __pos) const _NOEXCEPT
{ {
__self_view __sv = __t; __self_view __sv = __t;
return __str_rfind<value_type, size_type, traits_type, npos> return __str_rfind<value_type, size_type, traits_type, npos>
(data(), size(), __sv.data(), __pos, __sv.size()); (data(), size(), __sv.data(), __pos, __sv.size());
} }
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_CONSTEXPR_CXX20
typename basic_string<_CharT, _Traits, _Allocator>::size_type typename basic_string<_CharT, _Traits, _Allocator>::size_type
basic_string<_CharT, _Traits, _Allocator>::rfind(const value_type* __s, basic_string<_CharT, _Traits, _Allocator>::rfind(const value_type* __s,
size_type __pos) const _NOEXCEPT size_type __pos) const _NOEXCEPT
{ {
_LIBCPP_ASSERT(__s != nullptr, "string::rfind(): received nullptr"); _LIBCPP_ASSERT(__s != nullptr, "string::rfind(): received nullptr");
return __str_rfind<value_type, size_type, traits_type, npos> return __str_rfind<value_type, size_type, traits_type, npos>
(data(), size(), __s, __pos, traits_type::length(__s)); (data(), size(), __s, __pos, traits_type::length(__s));
} }
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
typename basic_string<_CharT, _Traits, _Allocator>::size_type typename basic_string<_CharT, _Traits, _Allocator>::size_type
basic_string<_CharT, _Traits, _Allocator>::rfind(value_type __c, basic_string<_CharT, _Traits, _Allocator>::rfind(value_type __c,
size_type __pos) const _NOEXCEPT size_type __pos) const _NOEXCEPT
{ {
return __str_rfind<value_type, size_type, traits_type, npos> return __str_rfind<value_type, size_type, traits_type, npos>
(data(), size(), __c, __pos); (data(), size(), __c, __pos);
} }
// find_first_of // find_first_of
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
typename basic_string<_CharT, _Traits, _Allocator>::size_type typename basic_string<_CharT, _Traits, _Allocator>::size_type
basic_string<_CharT, _Traits, _Allocator>::find_first_of(const value_type* __s, basic_string<_CharT, _Traits, _Allocator>::find_first_of(const value_type* __s,
size_type __pos, size_type __pos,
size_type __n) const _NOEXCEPT size_type __n) const _NOEXCEPT
{ {
_LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::find_first_of(): received nullptr"); _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::find_first_of(): received nullptr");
return __str_find_first_of<value_type, size_type, traits_type, npos> return __str_find_first_of<value_type, size_type, traits_type, npos>
(data(), size(), __s, __pos, __n); (data(), size(), __s, __pos, __n);
} }
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_CONSTEXPR_CXX20
typename basic_string<_CharT, _Traits, _Allocator>::size_type typename basic_string<_CharT, _Traits, _Allocator>::size_type
basic_string<_CharT, _Traits, _Allocator>::find_first_of(const basic_string& __str, basic_string<_CharT, _Traits, _Allocator>::find_first_of(const basic_string& __str,
size_type __pos) const _NOEXCEPT size_type __pos) const _NOEXCEPT
{ {
return __str_find_first_of<value_type, size_type, traits_type, npos> return __str_find_first_of<value_type, size_type, traits_type, npos>
(data(), size(), __str.data(), __pos, __str.size()); (data(), size(), __str.data(), __pos, __str.size());
} }
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
template <class _Tp> template <class _Tp>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
__enable_if_t __enable_if_t
< <
__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
typename basic_string<_CharT, _Traits, _Allocator>::size_type typename basic_string<_CharT, _Traits, _Allocator>::size_type
> >
basic_string<_CharT, _Traits, _Allocator>::find_first_of(const _Tp& __t, basic_string<_CharT, _Traits, _Allocator>::find_first_of(const _Tp& __t,
size_type __pos) const _NOEXCEPT size_type __pos) const _NOEXCEPT
{ {
__self_view __sv = __t; __self_view __sv = __t;
return __str_find_first_of<value_type, size_type, traits_type, npos> return __str_find_first_of<value_type, size_type, traits_type, npos>
(data(), size(), __sv.data(), __pos, __sv.size()); (data(), size(), __sv.data(), __pos, __sv.size());
} }
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_CONSTEXPR_CXX20
typename basic_string<_CharT, _Traits, _Allocator>::size_type typename basic_string<_CharT, _Traits, _Allocator>::size_type
basic_string<_CharT, _Traits, _Allocator>::find_first_of(const value_type* __s, basic_string<_CharT, _Traits, _Allocator>::find_first_of(const value_type* __s,
size_type __pos) const _NOEXCEPT size_type __pos) const _NOEXCEPT
{ {
_LIBCPP_ASSERT(__s != nullptr, "string::find_first_of(): received nullptr"); _LIBCPP_ASSERT(__s != nullptr, "string::find_first_of(): received nullptr");
return __str_find_first_of<value_type, size_type, traits_type, npos> return __str_find_first_of<value_type, size_type, traits_type, npos>
(data(), size(), __s, __pos, traits_type::length(__s)); (data(), size(), __s, __pos, traits_type::length(__s));
} }
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_CONSTEXPR_CXX20
typename basic_string<_CharT, _Traits, _Allocator>::size_type typename basic_string<_CharT, _Traits, _Allocator>::size_type
basic_string<_CharT, _Traits, _Allocator>::find_first_of(value_type __c, basic_string<_CharT, _Traits, _Allocator>::find_first_of(value_type __c,
size_type __pos) const _NOEXCEPT size_type __pos) const _NOEXCEPT
{ {
return find(__c, __pos); return find(__c, __pos);
} }
// find_last_of // find_last_of
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_CONSTEXPR_CXX20
typename basic_string<_CharT, _Traits, _Allocator>::size_type typename basic_string<_CharT, _Traits, _Allocator>::size_type
basic_string<_CharT, _Traits, _Allocator>::find_last_of(const value_type* __s, basic_string<_CharT, _Traits, _Allocator>::find_last_of(const value_type* __s,
size_type __pos, size_type __pos,
size_type __n) const _NOEXCEPT size_type __n) const _NOEXCEPT
{ {
_LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::find_last_of(): received nullptr"); _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::find_last_of(): received nullptr");
return __str_find_last_of<value_type, size_type, traits_type, npos> return __str_find_last_of<value_type, size_type, traits_type, npos>
(data(), size(), __s, __pos, __n); (data(), size(), __s, __pos, __n);
} }
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_CONSTEXPR_CXX20
typename basic_string<_CharT, _Traits, _Allocator>::size_type typename basic_string<_CharT, _Traits, _Allocator>::size_type
basic_string<_CharT, _Traits, _Allocator>::find_last_of(const basic_string& __str, basic_string<_CharT, _Traits, _Allocator>::find_last_of(const basic_string& __str,
size_type __pos) const _NOEXCEPT size_type __pos) const _NOEXCEPT
{ {
return __str_find_last_of<value_type, size_type, traits_type, npos> return __str_find_last_of<value_type, size_type, traits_type, npos>
(data(), size(), __str.data(), __pos, __str.size()); (data(), size(), __str.data(), __pos, __str.size());
} }
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
template <class _Tp> template <class _Tp>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
__enable_if_t __enable_if_t
< <
__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
typename basic_string<_CharT, _Traits, _Allocator>::size_type typename basic_string<_CharT, _Traits, _Allocator>::size_type
> >
basic_string<_CharT, _Traits, _Allocator>::find_last_of(const _Tp& __t, basic_string<_CharT, _Traits, _Allocator>::find_last_of(const _Tp& __t,
size_type __pos) const _NOEXCEPT size_type __pos) const _NOEXCEPT
{ {
__self_view __sv = __t; __self_view __sv = __t;
return __str_find_last_of<value_type, size_type, traits_type, npos> return __str_find_last_of<value_type, size_type, traits_type, npos>
(data(), size(), __sv.data(), __pos, __sv.size()); (data(), size(), __sv.data(), __pos, __sv.size());
} }
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_CONSTEXPR_CXX20
typename basic_string<_CharT, _Traits, _Allocator>::size_type typename basic_string<_CharT, _Traits, _Allocator>::size_type
basic_string<_CharT, _Traits, _Allocator>::find_last_of(const value_type* __s, basic_string<_CharT, _Traits, _Allocator>::find_last_of(const value_type* __s,
size_type __pos) const _NOEXCEPT size_type __pos) const _NOEXCEPT
{ {
_LIBCPP_ASSERT(__s != nullptr, "string::find_last_of(): received nullptr"); _LIBCPP_ASSERT(__s != nullptr, "string::find_last_of(): received nullptr");
return __str_find_last_of<value_type, size_type, traits_type, npos> return __str_find_last_of<value_type, size_type, traits_type, npos>
(data(), size(), __s, __pos, traits_type::length(__s)); (data(), size(), __s, __pos, traits_type::length(__s));
} }
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_CONSTEXPR_CXX20
typename basic_string<_CharT, _Traits, _Allocator>::size_type typename basic_string<_CharT, _Traits, _Allocator>::size_type
basic_string<_CharT, _Traits, _Allocator>::find_last_of(value_type __c, basic_string<_CharT, _Traits, _Allocator>::find_last_of(value_type __c,
size_type __pos) const _NOEXCEPT size_type __pos) const _NOEXCEPT
{ {
return rfind(__c, __pos); return rfind(__c, __pos);
} }
// find_first_not_of // find_first_not_of
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
typename basic_string<_CharT, _Traits, _Allocator>::size_type typename basic_string<_CharT, _Traits, _Allocator>::size_type
basic_string<_CharT, _Traits, _Allocator>::find_first_not_of(const value_type* __s, basic_string<_CharT, _Traits, _Allocator>::find_first_not_of(const value_type* __s,
size_type __pos, size_type __pos,
size_type __n) const _NOEXCEPT size_type __n) const _NOEXCEPT
{ {
_LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::find_first_not_of(): received nullptr"); _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::find_first_not_of(): received nullptr");
return __str_find_first_not_of<value_type, size_type, traits_type, npos> return __str_find_first_not_of<value_type, size_type, traits_type, npos>
(data(), size(), __s, __pos, __n); (data(), size(), __s, __pos, __n);
} }
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_CONSTEXPR_CXX20
typename basic_string<_CharT, _Traits, _Allocator>::size_type typename basic_string<_CharT, _Traits, _Allocator>::size_type
basic_string<_CharT, _Traits, _Allocator>::find_first_not_of(const basic_string& __str, basic_string<_CharT, _Traits, _Allocator>::find_first_not_of(const basic_string& __str,
size_type __pos) const _NOEXCEPT size_type __pos) const _NOEXCEPT
{ {
return __str_find_first_not_of<value_type, size_type, traits_type, npos> return __str_find_first_not_of<value_type, size_type, traits_type, npos>
(data(), size(), __str.data(), __pos, __str.size()); (data(), size(), __str.data(), __pos, __str.size());
} }
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
template <class _Tp> template <class _Tp>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
__enable_if_t __enable_if_t
< <
__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
typename basic_string<_CharT, _Traits, _Allocator>::size_type typename basic_string<_CharT, _Traits, _Allocator>::size_type
> >
basic_string<_CharT, _Traits, _Allocator>::find_first_not_of(const _Tp& __t, basic_string<_CharT, _Traits, _Allocator>::find_first_not_of(const _Tp& __t,
size_type __pos) const _NOEXCEPT size_type __pos) const _NOEXCEPT
{ {
__self_view __sv = __t; __self_view __sv = __t;
return __str_find_first_not_of<value_type, size_type, traits_type, npos> return __str_find_first_not_of<value_type, size_type, traits_type, npos>
(data(), size(), __sv.data(), __pos, __sv.size()); (data(), size(), __sv.data(), __pos, __sv.size());
} }
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_CONSTEXPR_CXX20
typename basic_string<_CharT, _Traits, _Allocator>::size_type typename basic_string<_CharT, _Traits, _Allocator>::size_type
basic_string<_CharT, _Traits, _Allocator>::find_first_not_of(const value_type* __s, basic_string<_CharT, _Traits, _Allocator>::find_first_not_of(const value_type* __s,
size_type __pos) const _NOEXCEPT size_type __pos) const _NOEXCEPT
{ {
_LIBCPP_ASSERT(__s != nullptr, "string::find_first_not_of(): received nullptr"); _LIBCPP_ASSERT(__s != nullptr, "string::find_first_not_of(): received nullptr");
return __str_find_first_not_of<value_type, size_type, traits_type, npos> return __str_find_first_not_of<value_type, size_type, traits_type, npos>
(data(), size(), __s, __pos, traits_type::length(__s)); (data(), size(), __s, __pos, traits_type::length(__s));
} }
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_CONSTEXPR_CXX20
typename basic_string<_CharT, _Traits, _Allocator>::size_type typename basic_string<_CharT, _Traits, _Allocator>::size_type
basic_string<_CharT, _Traits, _Allocator>::find_first_not_of(value_type __c, basic_string<_CharT, _Traits, _Allocator>::find_first_not_of(value_type __c,
size_type __pos) const _NOEXCEPT size_type __pos) const _NOEXCEPT
{ {
return __str_find_first_not_of<value_type, size_type, traits_type, npos> return __str_find_first_not_of<value_type, size_type, traits_type, npos>
(data(), size(), __c, __pos); (data(), size(), __c, __pos);
} }
// find_last_not_of // find_last_not_of
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
typename basic_string<_CharT, _Traits, _Allocator>::size_type typename basic_string<_CharT, _Traits, _Allocator>::size_type
basic_string<_CharT, _Traits, _Allocator>::find_last_not_of(const value_type* __s, basic_string<_CharT, _Traits, _Allocator>::find_last_not_of(const value_type* __s,
size_type __pos, size_type __pos,
size_type __n) const _NOEXCEPT size_type __n) const _NOEXCEPT
{ {
_LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::find_last_not_of(): received nullptr"); _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::find_last_not_of(): received nullptr");
return __str_find_last_not_of<value_type, size_type, traits_type, npos> return __str_find_last_not_of<value_type, size_type, traits_type, npos>
(data(), size(), __s, __pos, __n); (data(), size(), __s, __pos, __n);
} }
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_CONSTEXPR_CXX20
typename basic_string<_CharT, _Traits, _Allocator>::size_type typename basic_string<_CharT, _Traits, _Allocator>::size_type
basic_string<_CharT, _Traits, _Allocator>::find_last_not_of(const basic_string& __str, basic_string<_CharT, _Traits, _Allocator>::find_last_not_of(const basic_string& __str,
size_type __pos) const _NOEXCEPT size_type __pos) const _NOEXCEPT
{ {
return __str_find_last_not_of<value_type, size_type, traits_type, npos> return __str_find_last_not_of<value_type, size_type, traits_type, npos>
(data(), size(), __str.data(), __pos, __str.size()); (data(), size(), __str.data(), __pos, __str.size());
} }
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
template <class _Tp> template <class _Tp>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
__enable_if_t __enable_if_t
< <
__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
typename basic_string<_CharT, _Traits, _Allocator>::size_type typename basic_string<_CharT, _Traits, _Allocator>::size_type
> >
basic_string<_CharT, _Traits, _Allocator>::find_last_not_of(const _Tp& __t, basic_string<_CharT, _Traits, _Allocator>::find_last_not_of(const _Tp& __t,
size_type __pos) const _NOEXCEPT size_type __pos) const _NOEXCEPT
{ {
__self_view __sv = __t; __self_view __sv = __t;
return __str_find_last_not_of<value_type, size_type, traits_type, npos> return __str_find_last_not_of<value_type, size_type, traits_type, npos>
(data(), size(), __sv.data(), __pos, __sv.size()); (data(), size(), __sv.data(), __pos, __sv.size());
} }
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_CONSTEXPR_CXX20
typename basic_string<_CharT, _Traits, _Allocator>::size_type typename basic_string<_CharT, _Traits, _Allocator>::size_type
basic_string<_CharT, _Traits, _Allocator>::find_last_not_of(const value_type* __s, basic_string<_CharT, _Traits, _Allocator>::find_last_not_of(const value_type* __s,
size_type __pos) const _NOEXCEPT size_type __pos) const _NOEXCEPT
{ {
_LIBCPP_ASSERT(__s != nullptr, "string::find_last_not_of(): received nullptr"); _LIBCPP_ASSERT(__s != nullptr, "string::find_last_not_of(): received nullptr");
return __str_find_last_not_of<value_type, size_type, traits_type, npos> return __str_find_last_not_of<value_type, size_type, traits_type, npos>
(data(), size(), __s, __pos, traits_type::length(__s)); (data(), size(), __s, __pos, traits_type::length(__s));
} }
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_CONSTEXPR_CXX20
typename basic_string<_CharT, _Traits, _Allocator>::size_type typename basic_string<_CharT, _Traits, _Allocator>::size_type
basic_string<_CharT, _Traits, _Allocator>::find_last_not_of(value_type __c, basic_string<_CharT, _Traits, _Allocator>::find_last_not_of(value_type __c,
size_type __pos) const _NOEXCEPT size_type __pos) const _NOEXCEPT
{ {
return __str_find_last_not_of<value_type, size_type, traits_type, npos> return __str_find_last_not_of<value_type, size_type, traits_type, npos>
(data(), size(), __c, __pos); (data(), size(), __c, __pos);
} }
// compare // compare
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
template <class _Tp> template <class _Tp>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
__enable_if_t __enable_if_t
< <
__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
int int
> >
basic_string<_CharT, _Traits, _Allocator>::compare(const _Tp& __t) const _NOEXCEPT basic_string<_CharT, _Traits, _Allocator>::compare(const _Tp& __t) const _NOEXCEPT
{ {
__self_view __sv = __t; __self_view __sv = __t;
size_t __lhs_sz = size(); size_t __lhs_sz = size();
size_t __rhs_sz = __sv.size(); size_t __rhs_sz = __sv.size();
int __result = traits_type::compare(data(), __sv.data(), int __result = traits_type::compare(data(), __sv.data(),
std::min(__lhs_sz, __rhs_sz)); std::min(__lhs_sz, __rhs_sz));
if (__result != 0) if (__result != 0)
return __result; return __result;
if (__lhs_sz < __rhs_sz) if (__lhs_sz < __rhs_sz)
return -1; return -1;
if (__lhs_sz > __rhs_sz) if (__lhs_sz > __rhs_sz)
return 1; return 1;
return 0; return 0;
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_CONSTEXPR_CXX20
int int
basic_string<_CharT, _Traits, _Allocator>::compare(const basic_string& __str) const _NOEXCEPT basic_string<_CharT, _Traits, _Allocator>::compare(const basic_string& __str) const _NOEXCEPT
{ {
return compare(__self_view(__str)); return compare(__self_view(__str));
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_CONSTEXPR_CXX20
int int
basic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1, basic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1,
size_type __n1, size_type __n1,
const value_type* __s, const value_type* __s,
size_type __n2) const size_type __n2) const
{ {
_LIBCPP_ASSERT(__n2 == 0 || __s != nullptr, "string::compare(): received nullptr"); _LIBCPP_ASSERT(__n2 == 0 || __s != nullptr, "string::compare(): received nullptr");
size_type __sz = size(); size_type __sz = size();
if (__pos1 > __sz || __n2 == npos) if (__pos1 > __sz || __n2 == npos)
__throw_out_of_range(); __throw_out_of_range();
size_type __rlen = std::min(__n1, __sz - __pos1); size_type __rlen = std::min(__n1, __sz - __pos1);
int __r = traits_type::compare(data() + __pos1, __s, std::min(__rlen, __n2)); int __r = traits_type::compare(data() + __pos1, __s, std::min(__rlen, __n2));
if (__r == 0) if (__r == 0)
{ {
if (__rlen < __n2) if (__rlen < __n2)
__r = -1; __r = -1;
else if (__rlen > __n2) else if (__rlen > __n2)
__r = 1; __r = 1;
} }
return __r; return __r;
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
template <class _Tp> template <class _Tp>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
__enable_if_t __enable_if_t
< <
__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
int int
> >
basic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1, basic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1,
size_type __n1, size_type __n1,
const _Tp& __t) const const _Tp& __t) const
{ {
__self_view __sv = __t; __self_view __sv = __t;
return compare(__pos1, __n1, __sv.data(), __sv.size()); return compare(__pos1, __n1, __sv.data(), __sv.size());
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_CONSTEXPR_CXX20
int int
basic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1, basic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1,
size_type __n1, size_type __n1,
const basic_string& __str) const const basic_string& __str) const
{ {
return compare(__pos1, __n1, __str.data(), __str.size()); return compare(__pos1, __n1, __str.data(), __str.size());
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
template <class _Tp> template <class _Tp>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
__enable_if_t __enable_if_t
< <
__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value
&& !__is_same_uncvref<_Tp, basic_string<_CharT, _Traits, _Allocator> >::value, && !__is_same_uncvref<_Tp, basic_string<_CharT, _Traits, _Allocator> >::value,
int int
> >
basic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1, basic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1,
size_type __n1, size_type __n1,
const _Tp& __t, const _Tp& __t,
size_type __pos2, size_type __pos2,
size_type __n2) const size_type __n2) const
{ {
__self_view __sv = __t; __self_view __sv = __t;
return __self_view(*this).substr(__pos1, __n1).compare(__sv.substr(__pos2, __n2)); return __self_view(*this).substr(__pos1, __n1).compare(__sv.substr(__pos2, __n2));
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
int int
basic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1, basic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1,
size_type __n1, size_type __n1,
const basic_string& __str, const basic_string& __str,
size_type __pos2, size_type __pos2,
size_type __n2) const size_type __n2) const
{ {
return compare(__pos1, __n1, __self_view(__str), __pos2, __n2); return compare(__pos1, __n1, __self_view(__str), __pos2, __n2);
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
int int
basic_string<_CharT, _Traits, _Allocator>::compare(const value_type* __s) const _NOEXCEPT basic_string<_CharT, _Traits, _Allocator>::compare(const value_type* __s) const _NOEXCEPT
{ {
_LIBCPP_ASSERT(__s != nullptr, "string::compare(): received nullptr"); _LIBCPP_ASSERT(__s != nullptr, "string::compare(): received nullptr");
return compare(0, npos, __s, traits_type::length(__s)); return compare(0, npos, __s, traits_type::length(__s));
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
int int
basic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1, basic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1,
size_type __n1, size_type __n1,
const value_type* __s) const const value_type* __s) const
{ {
_LIBCPP_ASSERT(__s != nullptr, "string::compare(): received nullptr"); _LIBCPP_ASSERT(__s != nullptr, "string::compare(): received nullptr");
return compare(__pos1, __n1, __s, traits_type::length(__s)); return compare(__pos1, __n1, __s, traits_type::length(__s));
} }
// __invariants // __invariants
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_CONSTEXPR_CXX20
bool bool
basic_string<_CharT, _Traits, _Allocator>::__invariants() const basic_string<_CharT, _Traits, _Allocator>::__invariants() const
{ {
if (size() > capacity()) if (size() > capacity())
return false; return false;
if (capacity() < __min_cap - 1) if (capacity() < __min_cap - 1)
return false; return false;
if (data() == nullptr) if (data() == nullptr)
return false; return false;
if (data()[size()] != value_type()) if (data()[size()] != value_type())
return false; return false;
return true; return true;
} }
// __clear_and_shrink // __clear_and_shrink
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_CONSTEXPR_CXX20
void void
basic_string<_CharT, _Traits, _Allocator>::__clear_and_shrink() _NOEXCEPT basic_string<_CharT, _Traits, _Allocator>::__clear_and_shrink() _NOEXCEPT
{ {
clear(); clear();
if(__is_long()) if(__is_long())
{ {
__alloc_traits::deallocate(__alloc(), __get_long_pointer(), capacity() + 1); __alloc_traits::deallocate(__alloc(), __get_long_pointer(), capacity() + 1);
__set_long_cap(0); __set_long_cap(0);
__set_short_size(0); __set_short_size(0);
traits_type::assign(*__get_short_pointer(), value_type()); traits_type::assign(*__get_short_pointer(), value_type());
} }
} }
// operator== // operator==
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_HIDE_FROM_ABI
bool bool
operator==(const basic_string<_CharT, _Traits, _Allocator>& __lhs, operator==(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
{ {
size_t __lhs_sz = __lhs.size(); size_t __lhs_sz = __lhs.size();
return __lhs_sz == __rhs.size() && _Traits::compare(__lhs.data(), return __lhs_sz == __rhs.size() && _Traits::compare(__lhs.data(),
__rhs.data(), __rhs.data(),
__lhs_sz) == 0; __lhs_sz) == 0;
} }
template<class _Allocator> template<class _Allocator>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_HIDE_FROM_ABI
bool bool
operator==(const basic_string<char, char_traits<char>, _Allocator>& __lhs, operator==(const basic_string<char, char_traits<char>, _Allocator>& __lhs,
const basic_string<char, char_traits<char>, _Allocator>& __rhs) _NOEXCEPT const basic_string<char, char_traits<char>, _Allocator>& __rhs) _NOEXCEPT
{ {
size_t __lhs_sz = __lhs.size(); size_t __lhs_sz = __lhs.size();
if (__lhs_sz != __rhs.size()) if (__lhs_sz != __rhs.size())
return false; return false;
const char* __lp = __lhs.data(); const char* __lp = __lhs.data();
const char* __rp = __rhs.data(); const char* __rp = __rhs.data();
if (__lhs.__is_long()) if (__lhs.__is_long())
return char_traits<char>::compare(__lp, __rp, __lhs_sz) == 0; return char_traits<char>::compare(__lp, __rp, __lhs_sz) == 0;
for (; __lhs_sz != 0; --__lhs_sz, ++__lp, ++__rp) for (; __lhs_sz != 0; --__lhs_sz, ++__lp, ++__rp)
if (*__lp != *__rp) if (*__lp != *__rp)
return false; return false;
return true; return true;
} }
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_HIDE_FROM_ABI
bool bool
operator==(const _CharT* __lhs, operator==(const _CharT* __lhs,
const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
{ {
typedef basic_string<_CharT, _Traits, _Allocator> _String; typedef basic_string<_CharT, _Traits, _Allocator> _String;
_LIBCPP_ASSERT(__lhs != nullptr, "operator==(char*, basic_string): received nullptr"); _LIBCPP_ASSERT(__lhs != nullptr, "operator==(char*, basic_string): received nullptr");
size_t __lhs_len = _Traits::length(__lhs); size_t __lhs_len = _Traits::length(__lhs);
if (__lhs_len != __rhs.size()) return false; if (__lhs_len != __rhs.size()) return false;
return __rhs.compare(0, _String::npos, __lhs, __lhs_len) == 0; return __rhs.compare(0, _String::npos, __lhs, __lhs_len) == 0;
} }
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_HIDE_FROM_ABI
bool bool
operator==(const basic_string<_CharT,_Traits,_Allocator>& __lhs, operator==(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
const _CharT* __rhs) _NOEXCEPT const _CharT* __rhs) _NOEXCEPT
{ {
typedef basic_string<_CharT, _Traits, _Allocator> _String; typedef basic_string<_CharT, _Traits, _Allocator> _String;
_LIBCPP_ASSERT(__rhs != nullptr, "operator==(basic_string, char*): received nullptr"); _LIBCPP_ASSERT(__rhs != nullptr, "operator==(basic_string, char*): received nullptr");
size_t __rhs_len = _Traits::length(__rhs); size_t __rhs_len = _Traits::length(__rhs);
if (__rhs_len != __lhs.size()) return false; if (__rhs_len != __lhs.size()) return false;
return __lhs.compare(0, _String::npos, __rhs, __rhs_len) == 0; return __lhs.compare(0, _String::npos, __rhs, __rhs_len) == 0;
} }
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_HIDE_FROM_ABI
bool bool
operator!=(const basic_string<_CharT,_Traits,_Allocator>& __lhs, operator!=(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
{ {
return !(__lhs == __rhs); return !(__lhs == __rhs);
} }
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_HIDE_FROM_ABI
bool bool
operator!=(const _CharT* __lhs, operator!=(const _CharT* __lhs,
const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
{ {
return !(__lhs == __rhs); return !(__lhs == __rhs);
} }
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_HIDE_FROM_ABI
bool bool
operator!=(const basic_string<_CharT, _Traits, _Allocator>& __lhs, operator!=(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
const _CharT* __rhs) _NOEXCEPT const _CharT* __rhs) _NOEXCEPT
{ {
return !(__lhs == __rhs); return !(__lhs == __rhs);
} }
// operator< // operator<
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_HIDE_FROM_ABI
bool bool
operator< (const basic_string<_CharT, _Traits, _Allocator>& __lhs, operator< (const basic_string<_CharT, _Traits, _Allocator>& __lhs,
const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
{ {
return __lhs.compare(__rhs) < 0; return __lhs.compare(__rhs) < 0;
} }
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_HIDE_FROM_ABI
bool bool
operator< (const basic_string<_CharT, _Traits, _Allocator>& __lhs, operator< (const basic_string<_CharT, _Traits, _Allocator>& __lhs,
const _CharT* __rhs) _NOEXCEPT const _CharT* __rhs) _NOEXCEPT
{ {
return __lhs.compare(__rhs) < 0; return __lhs.compare(__rhs) < 0;
} }
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_HIDE_FROM_ABI
bool bool
operator< (const _CharT* __lhs, operator< (const _CharT* __lhs,
const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
{ {
return __rhs.compare(__lhs) > 0; return __rhs.compare(__lhs) > 0;
} }
// operator> // operator>
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_HIDE_FROM_ABI
bool bool
operator> (const basic_string<_CharT, _Traits, _Allocator>& __lhs, operator> (const basic_string<_CharT, _Traits, _Allocator>& __lhs,
const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
{ {
return __rhs < __lhs; return __rhs < __lhs;
} }
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_HIDE_FROM_ABI
bool bool
operator> (const basic_string<_CharT, _Traits, _Allocator>& __lhs, operator> (const basic_string<_CharT, _Traits, _Allocator>& __lhs,
const _CharT* __rhs) _NOEXCEPT const _CharT* __rhs) _NOEXCEPT
{ {
return __rhs < __lhs; return __rhs < __lhs;
} }
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_HIDE_FROM_ABI
bool bool
operator> (const _CharT* __lhs, operator> (const _CharT* __lhs,
const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
{ {
return __rhs < __lhs; return __rhs < __lhs;
} }
// operator<= // operator<=
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_HIDE_FROM_ABI
bool bool
operator<=(const basic_string<_CharT, _Traits, _Allocator>& __lhs, operator<=(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
{ {
return !(__rhs < __lhs); return !(__rhs < __lhs);
} }
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_HIDE_FROM_ABI
bool bool
operator<=(const basic_string<_CharT, _Traits, _Allocator>& __lhs, operator<=(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
const _CharT* __rhs) _NOEXCEPT const _CharT* __rhs) _NOEXCEPT
{ {
return !(__rhs < __lhs); return !(__rhs < __lhs);
} }
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_HIDE_FROM_ABI
bool bool
operator<=(const _CharT* __lhs, operator<=(const _CharT* __lhs,
const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
{ {
return !(__rhs < __lhs); return !(__rhs < __lhs);
} }
// operator>= // operator>=
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_HIDE_FROM_ABI
bool bool
operator>=(const basic_string<_CharT, _Traits, _Allocator>& __lhs, operator>=(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
{ {
return !(__lhs < __rhs); return !(__lhs < __rhs);
} }
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_HIDE_FROM_ABI
bool bool
operator>=(const basic_string<_CharT, _Traits, _Allocator>& __lhs, operator>=(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
const _CharT* __rhs) _NOEXCEPT const _CharT* __rhs) _NOEXCEPT
{ {
return !(__lhs < __rhs); return !(__lhs < __rhs);
} }
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_HIDE_FROM_ABI
bool bool
operator>=(const _CharT* __lhs, operator>=(const _CharT* __lhs,
const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
{ {
return !(__lhs < __rhs); return !(__lhs < __rhs);
} }
// operator + // operator +
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
basic_string<_CharT, _Traits, _Allocator> basic_string<_CharT, _Traits, _Allocator>
operator+(const basic_string<_CharT, _Traits, _Allocator>& __lhs, operator+(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
const basic_string<_CharT, _Traits, _Allocator>& __rhs) const basic_string<_CharT, _Traits, _Allocator>& __rhs)
{ {
using _String = basic_string<_CharT, _Traits, _Allocator>; using _String = basic_string<_CharT, _Traits, _Allocator>;
auto __lhs_sz = __lhs.size(); auto __lhs_sz = __lhs.size();
auto __rhs_sz = __rhs.size(); auto __rhs_sz = __rhs.size();
_String __r(__uninitialized_size_tag(), _String __r(__uninitialized_size_tag(),
__lhs_sz + __rhs_sz, __lhs_sz + __rhs_sz,
_String::__alloc_traits::select_on_container_copy_construction(__lhs.get_allocator())); _String::__alloc_traits::select_on_container_copy_construction(__lhs.get_allocator()));
auto __ptr = std::__to_address(__r.__get_pointer()); auto __ptr = std::__to_address(__r.__get_pointer());
_Traits::copy(__ptr, __lhs.data(), __lhs_sz); _Traits::copy(__ptr, __lhs.data(), __lhs_sz);
_Traits::copy(__ptr + __lhs_sz, __rhs.data(), __rhs_sz); _Traits::copy(__ptr + __lhs_sz, __rhs.data(), __rhs_sz);
_Traits::assign(__ptr + __lhs_sz + __rhs_sz, 1, _CharT()); _Traits::assign(__ptr + __lhs_sz + __rhs_sz, 1, _CharT());
return __r; return __r;
} }
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
basic_string<_CharT, _Traits, _Allocator> basic_string<_CharT, _Traits, _Allocator>
operator+(const _CharT* __lhs , const basic_string<_CharT,_Traits,_Allocator>& __rhs) operator+(const _CharT* __lhs , const basic_string<_CharT,_Traits,_Allocator>& __rhs)
{ {
using _String = basic_string<_CharT, _Traits, _Allocator>; using _String = basic_string<_CharT, _Traits, _Allocator>;
auto __lhs_sz = _Traits::length(__lhs); auto __lhs_sz = _Traits::length(__lhs);
auto __rhs_sz = __rhs.size(); auto __rhs_sz = __rhs.size();
_String __r(__uninitialized_size_tag(), _String __r(__uninitialized_size_tag(),
__lhs_sz + __rhs_sz, __lhs_sz + __rhs_sz,
_String::__alloc_traits::select_on_container_copy_construction(__rhs.get_allocator())); _String::__alloc_traits::select_on_container_copy_construction(__rhs.get_allocator()));
auto __ptr = std::__to_address(__r.__get_pointer()); auto __ptr = std::__to_address(__r.__get_pointer());
_Traits::copy(__ptr, __lhs, __lhs_sz); _Traits::copy(__ptr, __lhs, __lhs_sz);
_Traits::copy(__ptr + __lhs_sz, __rhs.data(), __rhs_sz); _Traits::copy(__ptr + __lhs_sz, __rhs.data(), __rhs_sz);
_Traits::assign(__ptr + __lhs_sz + __rhs_sz, 1, _CharT()); _Traits::assign(__ptr + __lhs_sz + __rhs_sz, 1, _CharT());
return __r; return __r;
} }
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
basic_string<_CharT, _Traits, _Allocator> basic_string<_CharT, _Traits, _Allocator>
operator+(_CharT __lhs, const basic_string<_CharT,_Traits,_Allocator>& __rhs) operator+(_CharT __lhs, const basic_string<_CharT,_Traits,_Allocator>& __rhs)
{ {
using _String = basic_string<_CharT, _Traits, _Allocator>; using _String = basic_string<_CharT, _Traits, _Allocator>;
typename _String::size_type __rhs_sz = __rhs.size(); typename _String::size_type __rhs_sz = __rhs.size();
_String __r(__uninitialized_size_tag(), _String __r(__uninitialized_size_tag(),
__rhs_sz + 1, __rhs_sz + 1,
_String::__alloc_traits::select_on_container_copy_construction(__rhs.get_allocator())); _String::__alloc_traits::select_on_container_copy_construction(__rhs.get_allocator()));
auto __ptr = std::__to_address(__r.__get_pointer()); auto __ptr = std::__to_address(__r.__get_pointer());
_Traits::assign(__ptr, 1, __lhs); _Traits::assign(__ptr, 1, __lhs);
_Traits::copy(__ptr + 1, __rhs.data(), __rhs_sz); _Traits::copy(__ptr + 1, __rhs.data(), __rhs_sz);
_Traits::assign(__ptr + 1 + __rhs_sz, 1, _CharT()); _Traits::assign(__ptr + 1 + __rhs_sz, 1, _CharT());
return __r; return __r;
} }
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_CONSTEXPR_CXX20
basic_string<_CharT, _Traits, _Allocator> basic_string<_CharT, _Traits, _Allocator>
operator+(const basic_string<_CharT, _Traits, _Allocator>& __lhs, const _CharT* __rhs) operator+(const basic_string<_CharT, _Traits, _Allocator>& __lhs, const _CharT* __rhs)
{ {
using _String = basic_string<_CharT, _Traits, _Allocator>; using _String = basic_string<_CharT, _Traits, _Allocator>;
typename _String::size_type __lhs_sz = __lhs.size(); typename _String::size_type __lhs_sz = __lhs.size();
typename _String::size_type __rhs_sz = _Traits::length(__rhs); typename _String::size_type __rhs_sz = _Traits::length(__rhs);
_String __r(__uninitialized_size_tag(), _String __r(__uninitialized_size_tag(),
__lhs_sz + __rhs_sz, __lhs_sz + __rhs_sz,
_String::__alloc_traits::select_on_container_copy_construction(__lhs.get_allocator())); _String::__alloc_traits::select_on_container_copy_construction(__lhs.get_allocator()));
auto __ptr = std::__to_address(__r.__get_pointer()); auto __ptr = std::__to_address(__r.__get_pointer());
_Traits::copy(__ptr, __lhs.data(), __lhs_sz); _Traits::copy(__ptr, __lhs.data(), __lhs_sz);
_Traits::copy(__ptr + __lhs_sz, __rhs, __rhs_sz); _Traits::copy(__ptr + __lhs_sz, __rhs, __rhs_sz);
_Traits::assign(__ptr + __lhs_sz + __rhs_sz, 1, _CharT()); _Traits::assign(__ptr + __lhs_sz + __rhs_sz, 1, _CharT());
return __r; return __r;
} }
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
basic_string<_CharT, _Traits, _Allocator> basic_string<_CharT, _Traits, _Allocator>
operator+(const basic_string<_CharT, _Traits, _Allocator>& __lhs, _CharT __rhs) operator+(const basic_string<_CharT, _Traits, _Allocator>& __lhs, _CharT __rhs)
{ {
using _String = basic_string<_CharT, _Traits, _Allocator>; using _String = basic_string<_CharT, _Traits, _Allocator>;
typename _String::size_type __lhs_sz = __lhs.size(); typename _String::size_type __lhs_sz = __lhs.size();
_String __r(__uninitialized_size_tag(), _String __r(__uninitialized_size_tag(),
__lhs_sz + 1, __lhs_sz + 1,
_String::__alloc_traits::select_on_container_copy_construction(__lhs.get_allocator())); _String::__alloc_traits::select_on_container_copy_construction(__lhs.get_allocator()));
auto __ptr = std::__to_address(__r.__get_pointer()); auto __ptr = std::__to_address(__r.__get_pointer());
_Traits::copy(__ptr, __lhs.data(), __lhs_sz); _Traits::copy(__ptr, __lhs.data(), __lhs_sz);
_Traits::assign(__ptr + __lhs_sz, 1, __rhs); _Traits::assign(__ptr + __lhs_sz, 1, __rhs);
_Traits::assign(__ptr + 1 + __lhs_sz, 1, _CharT()); _Traits::assign(__ptr + 1 + __lhs_sz, 1, _CharT());
return __r; return __r;
} }
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
basic_string<_CharT, _Traits, _Allocator> basic_string<_CharT, _Traits, _Allocator>
operator+(basic_string<_CharT, _Traits, _Allocator>&& __lhs, const basic_string<_CharT, _Traits, _Allocator>& __rhs) operator+(basic_string<_CharT, _Traits, _Allocator>&& __lhs, const basic_string<_CharT, _Traits, _Allocator>& __rhs)
{ {
return std::move(__lhs.append(__rhs)); return std::move(__lhs.append(__rhs));
} }
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
basic_string<_CharT, _Traits, _Allocator> basic_string<_CharT, _Traits, _Allocator>
operator+(const basic_string<_CharT, _Traits, _Allocator>& __lhs, basic_string<_CharT, _Traits, _Allocator>&& __rhs) operator+(const basic_string<_CharT, _Traits, _Allocator>& __lhs, basic_string<_CharT, _Traits, _Allocator>&& __rhs)
{ {
return std::move(__rhs.insert(0, __lhs)); return std::move(__rhs.insert(0, __lhs));
} }
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
basic_string<_CharT, _Traits, _Allocator> basic_string<_CharT, _Traits, _Allocator>
operator+(basic_string<_CharT, _Traits, _Allocator>&& __lhs, basic_string<_CharT, _Traits, _Allocator>&& __rhs) operator+(basic_string<_CharT, _Traits, _Allocator>&& __lhs, basic_string<_CharT, _Traits, _Allocator>&& __rhs)
{ {
return std::move(__lhs.append(__rhs)); return std::move(__lhs.append(__rhs));
} }
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
basic_string<_CharT, _Traits, _Allocator> basic_string<_CharT, _Traits, _Allocator>
operator+(const _CharT* __lhs , basic_string<_CharT,_Traits,_Allocator>&& __rhs) operator+(const _CharT* __lhs , basic_string<_CharT,_Traits,_Allocator>&& __rhs)
{ {
return std::move(__rhs.insert(0, __lhs)); return std::move(__rhs.insert(0, __lhs));
} }
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
basic_string<_CharT, _Traits, _Allocator> basic_string<_CharT, _Traits, _Allocator>
operator+(_CharT __lhs, basic_string<_CharT,_Traits,_Allocator>&& __rhs) operator+(_CharT __lhs, basic_string<_CharT,_Traits,_Allocator>&& __rhs)
{ {
__rhs.insert(__rhs.begin(), __lhs); __rhs.insert(__rhs.begin(), __lhs);
return std::move(__rhs); return std::move(__rhs);
} }
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
basic_string<_CharT, _Traits, _Allocator> basic_string<_CharT, _Traits, _Allocator>
operator+(basic_string<_CharT, _Traits, _Allocator>&& __lhs, const _CharT* __rhs) operator+(basic_string<_CharT, _Traits, _Allocator>&& __lhs, const _CharT* __rhs)
{ {
return std::move(__lhs.append(__rhs)); return std::move(__lhs.append(__rhs));
} }
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
basic_string<_CharT, _Traits, _Allocator> basic_string<_CharT, _Traits, _Allocator>
operator+(basic_string<_CharT, _Traits, _Allocator>&& __lhs, _CharT __rhs) operator+(basic_string<_CharT, _Traits, _Allocator>&& __lhs, _CharT __rhs)
{ {
__lhs.push_back(__rhs); __lhs.push_back(__rhs);
return std::move(__lhs); return std::move(__lhs);
} }
#endif // _LIBCPP_CXX03_LANG #endif // _LIBCPP_CXX03_LANG
// swap // swap
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
void void
swap(basic_string<_CharT, _Traits, _Allocator>& __lhs, swap(basic_string<_CharT, _Traits, _Allocator>& __lhs,
basic_string<_CharT, _Traits, _Allocator>& __rhs) basic_string<_CharT, _Traits, _Allocator>& __rhs)
_NOEXCEPT_(_NOEXCEPT_(__lhs.swap(__rhs))) _NOEXCEPT_(_NOEXCEPT_(__lhs.swap(__rhs)))
{ {
__lhs.swap(__rhs); __lhs.swap(__rhs);
} }
▲ Show 20 Lines • Show All 146 Lines • ▼ Show 20 Lines
#endif // _LIBCPP_ENABLE_DEBUG_MODE #endif // _LIBCPP_ENABLE_DEBUG_MODE
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER > 11
// Literal suffixes for basic_string [basic.string.literals] // Literal suffixes for basic_string [basic.string.literals]
inline namespace literals inline namespace literals
{ {
inline namespace string_literals inline namespace string_literals
{ {
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
basic_string<char> operator "" s( const char *__str, size_t __len ) basic_string<char> operator "" s( const char *__str, size_t __len )
{ {
return basic_string<char> (__str, __len); return basic_string<char> (__str, __len);
} }
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
basic_string<wchar_t> operator "" s( const wchar_t *__str, size_t __len ) basic_string<wchar_t> operator "" s( const wchar_t *__str, size_t __len )
{ {
return basic_string<wchar_t> (__str, __len); return basic_string<wchar_t> (__str, __len);
} }
#endif #endif
#ifndef _LIBCPP_HAS_NO_CHAR8_T #ifndef _LIBCPP_HAS_NO_CHAR8_T
inline _LIBCPP_HIDE_FROM_ABI constexpr inline _LIBCPP_HIDE_FROM_ABI constexpr
basic_string<char8_t> operator "" s(const char8_t *__str, size_t __len) _NOEXCEPT basic_string<char8_t> operator "" s(const char8_t *__str, size_t __len) _NOEXCEPT
{ {
return basic_string<char8_t> (__str, __len); return basic_string<char8_t> (__str, __len);
} }
#endif #endif
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
basic_string<char16_t> operator "" s( const char16_t *__str, size_t __len ) basic_string<char16_t> operator "" s( const char16_t *__str, size_t __len )
{ {
return basic_string<char16_t> (__str, __len); return basic_string<char16_t> (__str, __len);
} }
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20
basic_string<char32_t> operator "" s( const char32_t *__str, size_t __len ) basic_string<char32_t> operator "" s( const char32_t *__str, size_t __len )
{ {
return basic_string<char32_t> (__str, __len); return basic_string<char32_t> (__str, __len);
} }
} // namespace string_literals } // namespace string_literals
} // namespace literals } // namespace literals
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER > 17
Show All 15 Lines

libcxx/include/string_view

Show First 20 Lines • Show All 356 Lines • ▼ Show 20 Lines#endif
const_iterator end() const _NOEXCEPT { return cend(); } const_iterator end() const _NOEXCEPT { return cend(); }
_LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
const_iterator cbegin() const _NOEXCEPT { return __data; } const_iterator cbegin() const _NOEXCEPT { return __data; }
_LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
const_iterator cend() const _NOEXCEPT { return __data + __size; } const_iterator cend() const _NOEXCEPT { return __data + __size; }
_LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17 _LIBCPP_INLINE_VISIBILITY
const_reverse_iterator rbegin() const _NOEXCEPT { return const_reverse_iterator(cend()); } const_reverse_iterator rbegin() const _NOEXCEPT { return const_reverse_iterator(cend()); }
_LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17 _LIBCPP_INLINE_VISIBILITY
const_reverse_iterator rend() const _NOEXCEPT { return const_reverse_iterator(cbegin()); } const_reverse_iterator rend() const _NOEXCEPT { return const_reverse_iterator(cbegin()); }
_LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17 _LIBCPP_INLINE_VISIBILITY
const_reverse_iterator crbegin() const _NOEXCEPT { return const_reverse_iterator(cend()); } const_reverse_iterator crbegin() const _NOEXCEPT { return const_reverse_iterator(cend()); }
_LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX17 _LIBCPP_INLINE_VISIBILITY
const_reverse_iterator crend() const _NOEXCEPT { return const_reverse_iterator(cbegin()); } const_reverse_iterator crend() const _NOEXCEPT { return const_reverse_iterator(cbegin()); }
// [string.view.capacity], capacity // [string.view.capacity], capacity
_LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
size_type size() const _NOEXCEPT { return __size; } size_type size() const _NOEXCEPT { return __size; }
_LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
size_type length() const _NOEXCEPT { return __size; } size_type length() const _NOEXCEPT { return __size; }
Show All 29 Lines#endif
{ {
return _LIBCPP_ASSERT(!empty(), "string_view::back(): string is empty"), __data[__size-1]; return _LIBCPP_ASSERT(!empty(), "string_view::back(): string is empty"), __data[__size-1];
} }
_LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
const_pointer data() const _NOEXCEPT { return __data; } const_pointer data() const _NOEXCEPT { return __data; }
// [string.view.modifiers], modifiers: // [string.view.modifiers], modifiers:
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
void remove_prefix(size_type __n) _NOEXCEPT void remove_prefix(size_type __n) _NOEXCEPT
{ {
_LIBCPP_ASSERT(__n <= size(), "remove_prefix() can't remove more than size()"); _LIBCPP_ASSERT(__n <= size(), "remove_prefix() can't remove more than size()");
__data += __n; __data += __n;
__size -= __n; __size -= __n;
} }
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
void remove_suffix(size_type __n) _NOEXCEPT void remove_suffix(size_type __n) _NOEXCEPT
{ {
_LIBCPP_ASSERT(__n <= size(), "remove_suffix() can't remove more than size()"); _LIBCPP_ASSERT(__n <= size(), "remove_suffix() can't remove more than size()");
__size -= __n; __size -= __n;
} }
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
void swap(basic_string_view& __other) _NOEXCEPT void swap(basic_string_view& __other) _NOEXCEPT
{ {
const value_type *__p = __data; const value_type *__p = __data;
__data = __other.__data; __data = __other.__data;
__other.__data = __p; __other.__data = __p;
size_type __sz = __size; size_type __sz = __size;
__size = __other.__size; __size = __other.__size;
__other.__size = __sz; __other.__size = __sz;
} }
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
size_type copy(_CharT* __s, size_type __n, size_type __pos = 0) const size_type copy(_CharT* __s, size_type __n, size_type __pos = 0) const
{ {
if (__pos > size()) if (__pos > size())
__throw_out_of_range("string_view::copy"); __throw_out_of_range("string_view::copy");
size_type __rlen = _VSTD::min(__n, size() - __pos); size_type __rlen = _VSTD::min(__n, size() - __pos);
_Traits::copy(__s, data() + __pos, __rlen); _Traits::copy(__s, data() + __pos, __rlen);
return __rlen; return __rlen;
} }
_LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
basic_string_view substr(size_type __pos = 0, size_type __n = npos) const basic_string_view substr(size_type __pos = 0, size_type __n = npos) const
{ {
return __pos > size() return __pos > size()
? (__throw_out_of_range("string_view::substr"), basic_string_view()) ? (__throw_out_of_range("string_view::substr"), basic_string_view())
: basic_string_view(data() + __pos, _VSTD::min(__n, size() - __pos)); : basic_string_view(data() + __pos, _VSTD::min(__n, size() - __pos));
} }
_LIBCPP_CONSTEXPR_AFTER_CXX11 int compare(basic_string_view __sv) const _NOEXCEPT _LIBCPP_CONSTEXPR_CXX14 int compare(basic_string_view __sv) const _NOEXCEPT
{ {
size_type __rlen = _VSTD::min( size(), __sv.size()); size_type __rlen = _VSTD::min( size(), __sv.size());
int __retval = _Traits::compare(data(), __sv.data(), __rlen); int __retval = _Traits::compare(data(), __sv.data(), __rlen);
if ( __retval == 0 ) // first __rlen chars matched if ( __retval == 0 ) // first __rlen chars matched
__retval = size() == __sv.size() ? 0 : ( size() < __sv.size() ? -1 : 1 ); __retval = size() == __sv.size() ? 0 : ( size() < __sv.size() ? -1 : 1 );
return __retval; return __retval;
} }
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
int compare(size_type __pos1, size_type __n1, basic_string_view __sv) const int compare(size_type __pos1, size_type __n1, basic_string_view __sv) const
{ {
return substr(__pos1, __n1).compare(__sv); return substr(__pos1, __n1).compare(__sv);
} }
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
int compare( size_type __pos1, size_type __n1, int compare( size_type __pos1, size_type __n1,
basic_string_view __sv, size_type __pos2, size_type __n2) const basic_string_view __sv, size_type __pos2, size_type __n2) const
{ {
return substr(__pos1, __n1).compare(__sv.substr(__pos2, __n2)); return substr(__pos1, __n1).compare(__sv.substr(__pos2, __n2));
} }
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
int compare(const _CharT* __s) const _NOEXCEPT int compare(const _CharT* __s) const _NOEXCEPT
{ {
return compare(basic_string_view(__s)); return compare(basic_string_view(__s));
} }
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
int compare(size_type __pos1, size_type __n1, const _CharT* __s) const int compare(size_type __pos1, size_type __n1, const _CharT* __s) const
{ {
return substr(__pos1, __n1).compare(basic_string_view(__s)); return substr(__pos1, __n1).compare(basic_string_view(__s));
} }
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
int compare(size_type __pos1, size_type __n1, const _CharT* __s, size_type __n2) const int compare(size_type __pos1, size_type __n1, const _CharT* __s, size_type __n2) const
{ {
return substr(__pos1, __n1).compare(basic_string_view(__s, __n2)); return substr(__pos1, __n1).compare(basic_string_view(__s, __n2));
} }
// find // find
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
size_type find(basic_string_view __s, size_type __pos = 0) const _NOEXCEPT size_type find(basic_string_view __s, size_type __pos = 0) const _NOEXCEPT
{ {
_LIBCPP_ASSERT(__s.size() == 0 || __s.data() != nullptr, "string_view::find(): received nullptr"); _LIBCPP_ASSERT(__s.size() == 0 || __s.data() != nullptr, "string_view::find(): received nullptr");
return __str_find<value_type, size_type, traits_type, npos> return __str_find<value_type, size_type, traits_type, npos>
(data(), size(), __s.data(), __pos, __s.size()); (data(), size(), __s.data(), __pos, __s.size());
} }
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
size_type find(_CharT __c, size_type __pos = 0) const _NOEXCEPT size_type find(_CharT __c, size_type __pos = 0) const _NOEXCEPT
{ {
return __str_find<value_type, size_type, traits_type, npos> return __str_find<value_type, size_type, traits_type, npos>
(data(), size(), __c, __pos); (data(), size(), __c, __pos);
} }
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
size_type find(const _CharT* __s, size_type __pos, size_type __n) const _NOEXCEPT size_type find(const _CharT* __s, size_type __pos, size_type __n) const _NOEXCEPT
{ {
_LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string_view::find(): received nullptr"); _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string_view::find(): received nullptr");
return __str_find<value_type, size_type, traits_type, npos> return __str_find<value_type, size_type, traits_type, npos>
(data(), size(), __s, __pos, __n); (data(), size(), __s, __pos, __n);
} }
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
size_type find(const _CharT* __s, size_type __pos = 0) const _NOEXCEPT size_type find(const _CharT* __s, size_type __pos = 0) const _NOEXCEPT
{ {
_LIBCPP_ASSERT(__s != nullptr, "string_view::find(): received nullptr"); _LIBCPP_ASSERT(__s != nullptr, "string_view::find(): received nullptr");
return __str_find<value_type, size_type, traits_type, npos> return __str_find<value_type, size_type, traits_type, npos>
(data(), size(), __s, __pos, traits_type::length(__s)); (data(), size(), __s, __pos, traits_type::length(__s));
} }
// rfind // rfind
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
size_type rfind(basic_string_view __s, size_type __pos = npos) const _NOEXCEPT size_type rfind(basic_string_view __s, size_type __pos = npos) const _NOEXCEPT
{ {
_LIBCPP_ASSERT(__s.size() == 0 || __s.data() != nullptr, "string_view::find(): received nullptr"); _LIBCPP_ASSERT(__s.size() == 0 || __s.data() != nullptr, "string_view::find(): received nullptr");
return __str_rfind<value_type, size_type, traits_type, npos> return __str_rfind<value_type, size_type, traits_type, npos>
(data(), size(), __s.data(), __pos, __s.size()); (data(), size(), __s.data(), __pos, __s.size());
} }
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
size_type rfind(_CharT __c, size_type __pos = npos) const _NOEXCEPT size_type rfind(_CharT __c, size_type __pos = npos) const _NOEXCEPT
{ {
return __str_rfind<value_type, size_type, traits_type, npos> return __str_rfind<value_type, size_type, traits_type, npos>
(data(), size(), __c, __pos); (data(), size(), __c, __pos);
} }
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
size_type rfind(const _CharT* __s, size_type __pos, size_type __n) const _NOEXCEPT size_type rfind(const _CharT* __s, size_type __pos, size_type __n) const _NOEXCEPT
{ {
_LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string_view::rfind(): received nullptr"); _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string_view::rfind(): received nullptr");
return __str_rfind<value_type, size_type, traits_type, npos> return __str_rfind<value_type, size_type, traits_type, npos>
(data(), size(), __s, __pos, __n); (data(), size(), __s, __pos, __n);
} }
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
size_type rfind(const _CharT* __s, size_type __pos=npos) const _NOEXCEPT size_type rfind(const _CharT* __s, size_type __pos=npos) const _NOEXCEPT
{ {
_LIBCPP_ASSERT(__s != nullptr, "string_view::rfind(): received nullptr"); _LIBCPP_ASSERT(__s != nullptr, "string_view::rfind(): received nullptr");
return __str_rfind<value_type, size_type, traits_type, npos> return __str_rfind<value_type, size_type, traits_type, npos>
(data(), size(), __s, __pos, traits_type::length(__s)); (data(), size(), __s, __pos, traits_type::length(__s));
} }
// find_first_of // find_first_of
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
size_type find_first_of(basic_string_view __s, size_type __pos = 0) const _NOEXCEPT size_type find_first_of(basic_string_view __s, size_type __pos = 0) const _NOEXCEPT
{ {
_LIBCPP_ASSERT(__s.size() == 0 || __s.data() != nullptr, "string_view::find_first_of(): received nullptr"); _LIBCPP_ASSERT(__s.size() == 0 || __s.data() != nullptr, "string_view::find_first_of(): received nullptr");
return __str_find_first_of<value_type, size_type, traits_type, npos> return __str_find_first_of<value_type, size_type, traits_type, npos>
(data(), size(), __s.data(), __pos, __s.size()); (data(), size(), __s.data(), __pos, __s.size());
} }
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
size_type find_first_of(_CharT __c, size_type __pos = 0) const _NOEXCEPT size_type find_first_of(_CharT __c, size_type __pos = 0) const _NOEXCEPT
{ return find(__c, __pos); } { return find(__c, __pos); }
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
size_type find_first_of(const _CharT* __s, size_type __pos, size_type __n) const _NOEXCEPT size_type find_first_of(const _CharT* __s, size_type __pos, size_type __n) const _NOEXCEPT
{ {
_LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string_view::find_first_of(): received nullptr"); _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string_view::find_first_of(): received nullptr");
return __str_find_first_of<value_type, size_type, traits_type, npos> return __str_find_first_of<value_type, size_type, traits_type, npos>
(data(), size(), __s, __pos, __n); (data(), size(), __s, __pos, __n);
} }
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
size_type find_first_of(const _CharT* __s, size_type __pos=0) const _NOEXCEPT size_type find_first_of(const _CharT* __s, size_type __pos=0) const _NOEXCEPT
{ {
_LIBCPP_ASSERT(__s != nullptr, "string_view::find_first_of(): received nullptr"); _LIBCPP_ASSERT(__s != nullptr, "string_view::find_first_of(): received nullptr");
return __str_find_first_of<value_type, size_type, traits_type, npos> return __str_find_first_of<value_type, size_type, traits_type, npos>
(data(), size(), __s, __pos, traits_type::length(__s)); (data(), size(), __s, __pos, traits_type::length(__s));
} }
// find_last_of // find_last_of
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
size_type find_last_of(basic_string_view __s, size_type __pos=npos) const _NOEXCEPT size_type find_last_of(basic_string_view __s, size_type __pos=npos) const _NOEXCEPT
{ {
_LIBCPP_ASSERT(__s.size() == 0 || __s.data() != nullptr, "string_view::find_last_of(): received nullptr"); _LIBCPP_ASSERT(__s.size() == 0 || __s.data() != nullptr, "string_view::find_last_of(): received nullptr");
return __str_find_last_of<value_type, size_type, traits_type, npos> return __str_find_last_of<value_type, size_type, traits_type, npos>
(data(), size(), __s.data(), __pos, __s.size()); (data(), size(), __s.data(), __pos, __s.size());
} }
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
size_type find_last_of(_CharT __c, size_type __pos = npos) const _NOEXCEPT size_type find_last_of(_CharT __c, size_type __pos = npos) const _NOEXCEPT
{ return rfind(__c, __pos); } { return rfind(__c, __pos); }
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
size_type find_last_of(const _CharT* __s, size_type __pos, size_type __n) const _NOEXCEPT size_type find_last_of(const _CharT* __s, size_type __pos, size_type __n) const _NOEXCEPT
{ {
_LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string_view::find_last_of(): received nullptr"); _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string_view::find_last_of(): received nullptr");
return __str_find_last_of<value_type, size_type, traits_type, npos> return __str_find_last_of<value_type, size_type, traits_type, npos>
(data(), size(), __s, __pos, __n); (data(), size(), __s, __pos, __n);
} }
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
size_type find_last_of(const _CharT* __s, size_type __pos=npos) const _NOEXCEPT size_type find_last_of(const _CharT* __s, size_type __pos=npos) const _NOEXCEPT
{ {
_LIBCPP_ASSERT(__s != nullptr, "string_view::find_last_of(): received nullptr"); _LIBCPP_ASSERT(__s != nullptr, "string_view::find_last_of(): received nullptr");
return __str_find_last_of<value_type, size_type, traits_type, npos> return __str_find_last_of<value_type, size_type, traits_type, npos>
(data(), size(), __s, __pos, traits_type::length(__s)); (data(), size(), __s, __pos, traits_type::length(__s));
} }
// find_first_not_of // find_first_not_of
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
size_type find_first_not_of(basic_string_view __s, size_type __pos=0) const _NOEXCEPT size_type find_first_not_of(basic_string_view __s, size_type __pos=0) const _NOEXCEPT
{ {
_LIBCPP_ASSERT(__s.size() == 0 || __s.data() != nullptr, "string_view::find_first_not_of(): received nullptr"); _LIBCPP_ASSERT(__s.size() == 0 || __s.data() != nullptr, "string_view::find_first_not_of(): received nullptr");
return __str_find_first_not_of<value_type, size_type, traits_type, npos> return __str_find_first_not_of<value_type, size_type, traits_type, npos>
(data(), size(), __s.data(), __pos, __s.size()); (data(), size(), __s.data(), __pos, __s.size());
} }
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
size_type find_first_not_of(_CharT __c, size_type __pos=0) const _NOEXCEPT size_type find_first_not_of(_CharT __c, size_type __pos=0) const _NOEXCEPT
{ {
return __str_find_first_not_of<value_type, size_type, traits_type, npos> return __str_find_first_not_of<value_type, size_type, traits_type, npos>
(data(), size(), __c, __pos); (data(), size(), __c, __pos);
} }
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
size_type find_first_not_of(const _CharT* __s, size_type __pos, size_type __n) const _NOEXCEPT size_type find_first_not_of(const _CharT* __s, size_type __pos, size_type __n) const _NOEXCEPT
{ {
_LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string_view::find_first_not_of(): received nullptr"); _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string_view::find_first_not_of(): received nullptr");
return __str_find_first_not_of<value_type, size_type, traits_type, npos> return __str_find_first_not_of<value_type, size_type, traits_type, npos>
(data(), size(), __s, __pos, __n); (data(), size(), __s, __pos, __n);
} }
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
size_type find_first_not_of(const _CharT* __s, size_type __pos=0) const _NOEXCEPT size_type find_first_not_of(const _CharT* __s, size_type __pos=0) const _NOEXCEPT
{ {
_LIBCPP_ASSERT(__s != nullptr, "string_view::find_first_not_of(): received nullptr"); _LIBCPP_ASSERT(__s != nullptr, "string_view::find_first_not_of(): received nullptr");
return __str_find_first_not_of<value_type, size_type, traits_type, npos> return __str_find_first_not_of<value_type, size_type, traits_type, npos>
(data(), size(), __s, __pos, traits_type::length(__s)); (data(), size(), __s, __pos, traits_type::length(__s));
} }
// find_last_not_of // find_last_not_of
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
size_type find_last_not_of(basic_string_view __s, size_type __pos=npos) const _NOEXCEPT size_type find_last_not_of(basic_string_view __s, size_type __pos=npos) const _NOEXCEPT
{ {
_LIBCPP_ASSERT(__s.size() == 0 || __s.data() != nullptr, "string_view::find_last_not_of(): received nullptr"); _LIBCPP_ASSERT(__s.size() == 0 || __s.data() != nullptr, "string_view::find_last_not_of(): received nullptr");
return __str_find_last_not_of<value_type, size_type, traits_type, npos> return __str_find_last_not_of<value_type, size_type, traits_type, npos>
(data(), size(), __s.data(), __pos, __s.size()); (data(), size(), __s.data(), __pos, __s.size());
} }
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
size_type find_last_not_of(_CharT __c, size_type __pos=npos) const _NOEXCEPT size_type find_last_not_of(_CharT __c, size_type __pos=npos) const _NOEXCEPT
{ {
return __str_find_last_not_of<value_type, size_type, traits_type, npos> return __str_find_last_not_of<value_type, size_type, traits_type, npos>
(data(), size(), __c, __pos); (data(), size(), __c, __pos);
} }
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
size_type find_last_not_of(const _CharT* __s, size_type __pos, size_type __n) const _NOEXCEPT size_type find_last_not_of(const _CharT* __s, size_type __pos, size_type __n) const _NOEXCEPT
{ {
_LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string_view::find_last_not_of(): received nullptr"); _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string_view::find_last_not_of(): received nullptr");
return __str_find_last_not_of<value_type, size_type, traits_type, npos> return __str_find_last_not_of<value_type, size_type, traits_type, npos>
(data(), size(), __s, __pos, __n); (data(), size(), __s, __pos, __n);
} }
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
size_type find_last_not_of(const _CharT* __s, size_type __pos=npos) const _NOEXCEPT size_type find_last_not_of(const _CharT* __s, size_type __pos=npos) const _NOEXCEPT
{ {
_LIBCPP_ASSERT(__s != nullptr, "string_view::find_last_not_of(): received nullptr"); _LIBCPP_ASSERT(__s != nullptr, "string_view::find_last_not_of(): received nullptr");
return __str_find_last_not_of<value_type, size_type, traits_type, npos> return __str_find_last_not_of<value_type, size_type, traits_type, npos>
(data(), size(), __s, __pos, traits_type::length(__s)); (data(), size(), __s, __pos, traits_type::length(__s));
} }
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER > 17
▲ Show 20 Lines • Show All 60 Lines • ▼ Show 20 Lines
#if _LIBCPP_STD_VER > 20 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES) #if _LIBCPP_STD_VER > 20 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
template <ranges::contiguous_range _Range> template <ranges::contiguous_range _Range>
basic_string_view(_Range) -> basic_string_view<ranges::range_value_t<_Range>>; basic_string_view(_Range) -> basic_string_view<ranges::range_value_t<_Range>>;
#endif // _LIBCPP_STD_VER > 20 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES) #endif // _LIBCPP_STD_VER > 20 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
// [string.view.comparison] // [string.view.comparison]
// operator == // operator ==
template<class _CharT, class _Traits> template<class _CharT, class _Traits>
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
bool operator==(basic_string_view<_CharT, _Traits> __lhs, bool operator==(basic_string_view<_CharT, _Traits> __lhs,
basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT
{ {
if ( __lhs.size() != __rhs.size()) return false; if ( __lhs.size() != __rhs.size()) return false;
return __lhs.compare(__rhs) == 0; return __lhs.compare(__rhs) == 0;
} }
// The dummy default template parameters are used to work around a MSVC issue with mangling, see VSO-409326 for details. // The dummy default template parameters are used to work around a MSVC issue with mangling, see VSO-409326 for details.
// This applies to the other sufficient overloads below for the other comparison operators. // This applies to the other sufficient overloads below for the other comparison operators.
template<class _CharT, class _Traits, int = 1> template<class _CharT, class _Traits, int = 1>
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
bool operator==(basic_string_view<_CharT, _Traits> __lhs, bool operator==(basic_string_view<_CharT, _Traits> __lhs,
typename common_type<basic_string_view<_CharT, _Traits> >::type __rhs) _NOEXCEPT typename common_type<basic_string_view<_CharT, _Traits> >::type __rhs) _NOEXCEPT
{ {
if ( __lhs.size() != __rhs.size()) return false; if ( __lhs.size() != __rhs.size()) return false;
return __lhs.compare(__rhs) == 0; return __lhs.compare(__rhs) == 0;
} }
#if _LIBCPP_STD_VER < 20 #if _LIBCPP_STD_VER < 20
// This overload is automatically generated in C++20. // This overload is automatically generated in C++20.
template<class _CharT, class _Traits, int = 2> template<class _CharT, class _Traits, int = 2>
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
bool operator==(typename common_type<basic_string_view<_CharT, _Traits> >::type __lhs, bool operator==(typename common_type<basic_string_view<_CharT, _Traits> >::type __lhs,
basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT
{ {
if ( __lhs.size() != __rhs.size()) return false; if ( __lhs.size() != __rhs.size()) return false;
return __lhs.compare(__rhs) == 0; return __lhs.compare(__rhs) == 0;
} }
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER > 17
Show All 28 Lines if constexpr (requires { typename _Traits::comparison_category; }) {
return static_cast<weak_ordering>(__lhs.compare(__rhs) <=> 0); return static_cast<weak_ordering>(__lhs.compare(__rhs) <=> 0);
} }
} }
#else // _LIBCPP_STD_VER > 17 #else // _LIBCPP_STD_VER > 17
// operator != // operator !=
template<class _CharT, class _Traits> template<class _CharT, class _Traits>
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
bool operator!=(basic_string_view<_CharT, _Traits> __lhs, basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT bool operator!=(basic_string_view<_CharT, _Traits> __lhs, basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT
{ {
if ( __lhs.size() != __rhs.size()) if ( __lhs.size() != __rhs.size())
return true; return true;
return __lhs.compare(__rhs) != 0; return __lhs.compare(__rhs) != 0;
} }
template<class _CharT, class _Traits, int = 1> template<class _CharT, class _Traits, int = 1>
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
bool operator!=(basic_string_view<_CharT, _Traits> __lhs, bool operator!=(basic_string_view<_CharT, _Traits> __lhs,
typename common_type<basic_string_view<_CharT, _Traits> >::type __rhs) _NOEXCEPT typename common_type<basic_string_view<_CharT, _Traits> >::type __rhs) _NOEXCEPT
{ {
if ( __lhs.size() != __rhs.size()) if ( __lhs.size() != __rhs.size())
return true; return true;
return __lhs.compare(__rhs) != 0; return __lhs.compare(__rhs) != 0;
} }
template<class _CharT, class _Traits, int = 2> template<class _CharT, class _Traits, int = 2>
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
bool operator!=(typename common_type<basic_string_view<_CharT, _Traits> >::type __lhs, bool operator!=(typename common_type<basic_string_view<_CharT, _Traits> >::type __lhs,
basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT
{ {
if ( __lhs.size() != __rhs.size()) if ( __lhs.size() != __rhs.size())
return true; return true;
return __lhs.compare(__rhs) != 0; return __lhs.compare(__rhs) != 0;
} }
// operator < // operator <
template<class _CharT, class _Traits> template<class _CharT, class _Traits>
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
bool operator<(basic_string_view<_CharT, _Traits> __lhs, basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT bool operator<(basic_string_view<_CharT, _Traits> __lhs, basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT
{ {
return __lhs.compare(__rhs) < 0; return __lhs.compare(__rhs) < 0;
} }
template<class _CharT, class _Traits, int = 1> template<class _CharT, class _Traits, int = 1>
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
bool operator<(basic_string_view<_CharT, _Traits> __lhs, bool operator<(basic_string_view<_CharT, _Traits> __lhs,
typename common_type<basic_string_view<_CharT, _Traits> >::type __rhs) _NOEXCEPT typename common_type<basic_string_view<_CharT, _Traits> >::type __rhs) _NOEXCEPT
{ {
return __lhs.compare(__rhs) < 0; return __lhs.compare(__rhs) < 0;
} }
template<class _CharT, class _Traits, int = 2> template<class _CharT, class _Traits, int = 2>
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
bool operator<(typename common_type<basic_string_view<_CharT, _Traits> >::type __lhs, bool operator<(typename common_type<basic_string_view<_CharT, _Traits> >::type __lhs,
basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT
{ {
return __lhs.compare(__rhs) < 0; return __lhs.compare(__rhs) < 0;
} }
// operator > // operator >
template<class _CharT, class _Traits> template<class _CharT, class _Traits>
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
bool operator> (basic_string_view<_CharT, _Traits> __lhs, basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT bool operator> (basic_string_view<_CharT, _Traits> __lhs, basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT
{ {
return __lhs.compare(__rhs) > 0; return __lhs.compare(__rhs) > 0;
} }
template<class _CharT, class _Traits, int = 1> template<class _CharT, class _Traits, int = 1>
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
bool operator>(basic_string_view<_CharT, _Traits> __lhs, bool operator>(basic_string_view<_CharT, _Traits> __lhs,
typename common_type<basic_string_view<_CharT, _Traits> >::type __rhs) _NOEXCEPT typename common_type<basic_string_view<_CharT, _Traits> >::type __rhs) _NOEXCEPT
{ {
return __lhs.compare(__rhs) > 0; return __lhs.compare(__rhs) > 0;
} }
template<class _CharT, class _Traits, int = 2> template<class _CharT, class _Traits, int = 2>
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
bool operator>(typename common_type<basic_string_view<_CharT, _Traits> >::type __lhs, bool operator>(typename common_type<basic_string_view<_CharT, _Traits> >::type __lhs,
basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT
{ {
return __lhs.compare(__rhs) > 0; return __lhs.compare(__rhs) > 0;
} }
// operator <= // operator <=
template<class _CharT, class _Traits> template<class _CharT, class _Traits>
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
bool operator<=(basic_string_view<_CharT, _Traits> __lhs, basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT bool operator<=(basic_string_view<_CharT, _Traits> __lhs, basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT
{ {
return __lhs.compare(__rhs) <= 0; return __lhs.compare(__rhs) <= 0;
} }
template<class _CharT, class _Traits, int = 1> template<class _CharT, class _Traits, int = 1>
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
bool operator<=(basic_string_view<_CharT, _Traits> __lhs, bool operator<=(basic_string_view<_CharT, _Traits> __lhs,
typename common_type<basic_string_view<_CharT, _Traits> >::type __rhs) _NOEXCEPT typename common_type<basic_string_view<_CharT, _Traits> >::type __rhs) _NOEXCEPT
{ {
return __lhs.compare(__rhs) <= 0; return __lhs.compare(__rhs) <= 0;
} }
template<class _CharT, class _Traits, int = 2> template<class _CharT, class _Traits, int = 2>
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
bool operator<=(typename common_type<basic_string_view<_CharT, _Traits> >::type __lhs, bool operator<=(typename common_type<basic_string_view<_CharT, _Traits> >::type __lhs,
basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT
{ {
return __lhs.compare(__rhs) <= 0; return __lhs.compare(__rhs) <= 0;
} }
// operator >= // operator >=
template<class _CharT, class _Traits> template<class _CharT, class _Traits>
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
bool operator>=(basic_string_view<_CharT, _Traits> __lhs, basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT bool operator>=(basic_string_view<_CharT, _Traits> __lhs, basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT
{ {
return __lhs.compare(__rhs) >= 0; return __lhs.compare(__rhs) >= 0;
} }
template<class _CharT, class _Traits, int = 1> template<class _CharT, class _Traits, int = 1>
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
bool operator>=(basic_string_view<_CharT, _Traits> __lhs, bool operator>=(basic_string_view<_CharT, _Traits> __lhs,
typename common_type<basic_string_view<_CharT, _Traits> >::type __rhs) _NOEXCEPT typename common_type<basic_string_view<_CharT, _Traits> >::type __rhs) _NOEXCEPT
{ {
return __lhs.compare(__rhs) >= 0; return __lhs.compare(__rhs) >= 0;
} }
template<class _CharT, class _Traits, int = 2> template<class _CharT, class _Traits, int = 2>
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _LIBCPP_INLINE_VISIBILITY
bool operator>=(typename common_type<basic_string_view<_CharT, _Traits> >::type __lhs, bool operator>=(typename common_type<basic_string_view<_CharT, _Traits> >::type __lhs,
basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT
{ {
return __lhs.compare(__rhs) >= 0; return __lhs.compare(__rhs) >= 0;
} }
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER > 17
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

libcxx/include/system_error

Show First 20 Lines • Show All 203 Lines • ▼ Show 20 Lines
{ {
public: public:
virtual ~error_category() _NOEXCEPT; virtual ~error_category() _NOEXCEPT;
#if defined(_LIBCPP_ERROR_CATEGORY_DEFINE_LEGACY_INLINE_FUNCTIONS) #if defined(_LIBCPP_ERROR_CATEGORY_DEFINE_LEGACY_INLINE_FUNCTIONS)
error_category() noexcept; error_category() noexcept;
#else #else
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR_AFTER_CXX11 error_category() _NOEXCEPT = default; _LIBCPP_CONSTEXPR_CXX14 error_category() _NOEXCEPT = default;
#endif #endif
error_category(const error_category&) = delete; error_category(const error_category&) = delete;
error_category& operator=(const error_category&) = delete; error_category& operator=(const error_category&) = delete;
virtual const char* name() const _NOEXCEPT = 0; virtual const char* name() const _NOEXCEPT = 0;
virtual error_condition default_error_condition(int __ev) const _NOEXCEPT; virtual error_condition default_error_condition(int __ev) const _NOEXCEPT;
virtual bool equivalent(int __code, const error_condition& __condition) const _NOEXCEPT; virtual bool equivalent(int __code, const error_condition& __condition) const _NOEXCEPT;
virtual bool equivalent(const error_code& __code, int __condition) const _NOEXCEPT; virtual bool equivalent(const error_code& __code, int __condition) const _NOEXCEPT;
▲ Show 20 Lines • Show All 269 Lines • Show Last 20 Lines

libcxx/include/tuple

Show First 20 Lines • Show All 241 Lines • ▼ Show 20 Lines
// __tuple_leaf // __tuple_leaf
template <size_t _Ip, class _Hp, template <size_t _Ip, class _Hp,
bool=is_empty<_Hp>::value && !__libcpp_is_final<_Hp>::value bool=is_empty<_Hp>::value && !__libcpp_is_final<_Hp>::value
> >
class __tuple_leaf; class __tuple_leaf;
template <size_t _Ip, class _Hp, bool _Ep> template <size_t _Ip, class _Hp, bool _Ep>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
void swap(__tuple_leaf<_Ip, _Hp, _Ep>& __x, __tuple_leaf<_Ip, _Hp, _Ep>& __y) void swap(__tuple_leaf<_Ip, _Hp, _Ep>& __x, __tuple_leaf<_Ip, _Hp, _Ep>& __y)
_NOEXCEPT_(__is_nothrow_swappable<_Hp>::value) _NOEXCEPT_(__is_nothrow_swappable<_Hp>::value)
{ {
swap(__x.get(), __y.get()); swap(__x.get(), __y.get());
} }
template <size_t _Ip, class _Hp, bool _Ep> template <size_t _Ip, class _Hp, bool _Ep>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX14
void swap(const __tuple_leaf<_Ip, _Hp, _Ep>& __x, const __tuple_leaf<_Ip, _Hp, _Ep>& __y) void swap(const __tuple_leaf<_Ip, _Hp, _Ep>& __x, const __tuple_leaf<_Ip, _Hp, _Ep>& __y)
_NOEXCEPT_(__is_nothrow_swappable<const _Hp>::value) { _NOEXCEPT_(__is_nothrow_swappable<const _Hp>::value) {
swap(__x.get(), __y.get()); swap(__x.get(), __y.get());
} }
template <size_t _Ip, class _Hp, bool> template <size_t _Ip, class _Hp, bool>
class __tuple_leaf class __tuple_leaf
{ {
_Hp __value_; _Hp __value_;
template <class _Tp> template <class _Tp>
static constexpr bool __can_bind_reference() { static constexpr bool __can_bind_reference() {
#if __has_keyword(__reference_binds_to_temporary) #if __has_keyword(__reference_binds_to_temporary)
return !__reference_binds_to_temporary(_Hp, _Tp); return !__reference_binds_to_temporary(_Hp, _Tp);
#else #else
return true; return true;
#endif #endif
} }
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_CONSTEXPR_CXX14
__tuple_leaf& operator=(const __tuple_leaf&); __tuple_leaf& operator=(const __tuple_leaf&);
public: public:
_LIBCPP_INLINE_VISIBILITY constexpr __tuple_leaf() _LIBCPP_INLINE_VISIBILITY constexpr __tuple_leaf()
_NOEXCEPT_(is_nothrow_default_constructible<_Hp>::value) : __value_() _NOEXCEPT_(is_nothrow_default_constructible<_Hp>::value) : __value_()
{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 _Alloc> template <class _Alloc>
Show All 20 Linespublic:
template <class _Tp, template <class _Tp,
class = __enable_if_t< class = __enable_if_t<
_And< _And<
_IsNotSame<__uncvref_t<_Tp>, __tuple_leaf>, _IsNotSame<__uncvref_t<_Tp>, __tuple_leaf>,
is_constructible<_Hp, _Tp> is_constructible<_Hp, _Tp>
>::value >::value
> >
> >
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_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&&>(),
"Attempted construction of reference element binds to a temporary whose lifetime has ended");} "Attempted construction of reference element binds to a temporary whose lifetime has ended");}
template <class _Tp, class _Alloc> template <class _Tp, class _Alloc>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
explicit __tuple_leaf(integral_constant<int, 0>, const _Alloc&, _Tp&& __t) explicit __tuple_leaf(integral_constant<int, 0>, const _Alloc&, _Tp&& __t)
: __value_(_VSTD::forward<_Tp>(__t)) : __value_(_VSTD::forward<_Tp>(__t))
{static_assert(__can_bind_reference<_Tp&&>(), {static_assert(__can_bind_reference<_Tp&&>(),
"Attempted construction of reference element binds to a temporary whose lifetime has ended");} "Attempted construction of reference element binds to a temporary whose lifetime has ended");}
template <class _Tp, class _Alloc> template <class _Tp, class _Alloc>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
explicit __tuple_leaf(integral_constant<int, 1>, const _Alloc& __a, _Tp&& __t) explicit __tuple_leaf(integral_constant<int, 1>, const _Alloc& __a, _Tp&& __t)
: __value_(allocator_arg_t(), __a, _VSTD::forward<_Tp>(__t)) : __value_(allocator_arg_t(), __a, _VSTD::forward<_Tp>(__t))
{static_assert(!is_reference<_Hp>::value, {static_assert(!is_reference<_Hp>::value,
"Attempted to uses-allocator construct a reference element in a tuple");} "Attempted to uses-allocator construct a reference element in a tuple");}
template <class _Tp, class _Alloc> template <class _Tp, class _Alloc>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
explicit __tuple_leaf(integral_constant<int, 2>, const _Alloc& __a, _Tp&& __t) explicit __tuple_leaf(integral_constant<int, 2>, const _Alloc& __a, _Tp&& __t)
: __value_(_VSTD::forward<_Tp>(__t), __a) : __value_(_VSTD::forward<_Tp>(__t), __a)
{static_assert(!is_reference<_Hp>::value, {static_assert(!is_reference<_Hp>::value,
"Attempted to uses-allocator construct a reference element in a tuple");} "Attempted to uses-allocator construct a reference element in a tuple");}
__tuple_leaf(const __tuple_leaf& __t) = default; __tuple_leaf(const __tuple_leaf& __t) = default;
__tuple_leaf(__tuple_leaf&& __t) = default; __tuple_leaf(__tuple_leaf&& __t) = default;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
int swap(__tuple_leaf& __t) _NOEXCEPT_(__is_nothrow_swappable<__tuple_leaf>::value) int swap(__tuple_leaf& __t) _NOEXCEPT_(__is_nothrow_swappable<__tuple_leaf>::value)
{ {
_VSTD::swap(*this, __t); _VSTD::swap(*this, __t);
return 0; return 0;
} }
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
int swap(const __tuple_leaf& __t) const _NOEXCEPT_(__is_nothrow_swappable<const __tuple_leaf>::value) { int swap(const __tuple_leaf& __t) const _NOEXCEPT_(__is_nothrow_swappable<const __tuple_leaf>::value) {
_VSTD::swap(*this, __t); _VSTD::swap(*this, __t);
return 0; return 0;
} }
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _Hp& get() _NOEXCEPT {return __value_;} _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _Hp& get() _NOEXCEPT {return __value_;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 const _Hp& get() const _NOEXCEPT {return __value_;} _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 const _Hp& get() const _NOEXCEPT {return __value_;}
}; };
template <size_t _Ip, class _Hp> template <size_t _Ip, class _Hp>
class __tuple_leaf<_Ip, _Hp, true> class __tuple_leaf<_Ip, _Hp, true>
: private _Hp : private _Hp
{ {
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_CONSTEXPR_CXX14
__tuple_leaf& operator=(const __tuple_leaf&); __tuple_leaf& operator=(const __tuple_leaf&);
public: public:
_LIBCPP_INLINE_VISIBILITY constexpr __tuple_leaf() _LIBCPP_INLINE_VISIBILITY constexpr __tuple_leaf()
_NOEXCEPT_(is_nothrow_default_constructible<_Hp>::value) {} _NOEXCEPT_(is_nothrow_default_constructible<_Hp>::value) {}
template <class _Alloc> template <class _Alloc>
_LIBCPP_INLINE_VISIBILITY constexpr _LIBCPP_INLINE_VISIBILITY constexpr
__tuple_leaf(integral_constant<int, 0>, const _Alloc&) {} __tuple_leaf(integral_constant<int, 0>, const _Alloc&) {}
Show All 11 Linespublic:
template <class _Tp, template <class _Tp,
class = __enable_if_t< class = __enable_if_t<
_And< _And<
_IsNotSame<__uncvref_t<_Tp>, __tuple_leaf>, _IsNotSame<__uncvref_t<_Tp>, __tuple_leaf>,
is_constructible<_Hp, _Tp> is_constructible<_Hp, _Tp>
>::value >::value
> >
> >
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_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)) {}
template <class _Tp, class _Alloc> template <class _Tp, class _Alloc>
_LIBCPP_INLINE_VISIBILITY constexpr _LIBCPP_INLINE_VISIBILITY constexpr
explicit __tuple_leaf(integral_constant<int, 0>, const _Alloc&, _Tp&& __t) explicit __tuple_leaf(integral_constant<int, 0>, const _Alloc&, _Tp&& __t)
: _Hp(_VSTD::forward<_Tp>(__t)) {} : _Hp(_VSTD::forward<_Tp>(__t)) {}
template <class _Tp, class _Alloc> template <class _Tp, class _Alloc>
_LIBCPP_INLINE_VISIBILITY constexpr _LIBCPP_INLINE_VISIBILITY constexpr
explicit __tuple_leaf(integral_constant<int, 1>, const _Alloc& __a, _Tp&& __t) explicit __tuple_leaf(integral_constant<int, 1>, const _Alloc& __a, _Tp&& __t)
: _Hp(allocator_arg_t(), __a, _VSTD::forward<_Tp>(__t)) {} : _Hp(allocator_arg_t(), __a, _VSTD::forward<_Tp>(__t)) {}
template <class _Tp, class _Alloc> template <class _Tp, class _Alloc>
_LIBCPP_INLINE_VISIBILITY constexpr _LIBCPP_INLINE_VISIBILITY constexpr
explicit __tuple_leaf(integral_constant<int, 2>, const _Alloc& __a, _Tp&& __t) explicit __tuple_leaf(integral_constant<int, 2>, const _Alloc& __a, _Tp&& __t)
: _Hp(_VSTD::forward<_Tp>(__t), __a) {} : _Hp(_VSTD::forward<_Tp>(__t), __a) {}
__tuple_leaf(__tuple_leaf const &) = default; __tuple_leaf(__tuple_leaf const &) = default;
__tuple_leaf(__tuple_leaf &&) = default; __tuple_leaf(__tuple_leaf &&) = default;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
int int
swap(__tuple_leaf& __t) _NOEXCEPT_(__is_nothrow_swappable<__tuple_leaf>::value) swap(__tuple_leaf& __t) _NOEXCEPT_(__is_nothrow_swappable<__tuple_leaf>::value)
{ {
_VSTD::swap(*this, __t); _VSTD::swap(*this, __t);
return 0; return 0;
} }
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
int swap(const __tuple_leaf& __rhs) const _NOEXCEPT_(__is_nothrow_swappable<const __tuple_leaf>::value) { int swap(const __tuple_leaf& __rhs) const _NOEXCEPT_(__is_nothrow_swappable<const __tuple_leaf>::value) {
_VSTD::swap(*this, __rhs); _VSTD::swap(*this, __rhs);
return 0; return 0;
} }
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _Hp& get() _NOEXCEPT {return static_cast<_Hp&>(*this);} _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 _Hp& get() _NOEXCEPT {return static_cast<_Hp&>(*this);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 const _Hp& get() const _NOEXCEPT {return static_cast<const _Hp&>(*this);} _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14 const _Hp& get() const _NOEXCEPT {return static_cast<const _Hp&>(*this);}
}; };
template <class ..._Tp> template <class ..._Tp>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
void __swallow(_Tp&&...) _NOEXCEPT {} void __swallow(_Tp&&...) _NOEXCEPT {}
template <class _Tp> template <class _Tp>
struct __all_default_constructible; struct __all_default_constructible;
template <class ..._Tp> template <class ..._Tp>
struct __all_default_constructible<__tuple_types<_Tp...>> struct __all_default_constructible<__tuple_types<_Tp...>>
: __all<is_default_constructible<_Tp>::value...> : __all<is_default_constructible<_Tp>::value...>
{ }; { };
// __tuple_impl // __tuple_impl
template<class _Indx, class ..._Tp> struct __tuple_impl; template<class _Indx, class ..._Tp> struct __tuple_impl;
template<size_t ..._Indx, class ..._Tp> template<size_t ..._Indx, class ..._Tp>
struct _LIBCPP_DECLSPEC_EMPTY_BASES __tuple_impl<__tuple_indices<_Indx...>, _Tp...> struct _LIBCPP_DECLSPEC_EMPTY_BASES __tuple_impl<__tuple_indices<_Indx...>, _Tp...>
: public __tuple_leaf<_Indx, _Tp>... : public __tuple_leaf<_Indx, _Tp>...
{ {
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
constexpr __tuple_impl() constexpr __tuple_impl()
_NOEXCEPT_(__all<is_nothrow_default_constructible<_Tp>::value...>::value) {} _NOEXCEPT_(__all<is_nothrow_default_constructible<_Tp>::value...>::value) {}
template <size_t ..._Uf, class ..._Tf, template <size_t ..._Uf, class ..._Tf,
size_t ..._Ul, class ..._Tl, class ..._Up> size_t ..._Ul, class ..._Tl, class ..._Up>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
explicit explicit
__tuple_impl(__tuple_indices<_Uf...>, __tuple_types<_Tf...>, __tuple_impl(__tuple_indices<_Uf...>, __tuple_types<_Tf...>,
__tuple_indices<_Ul...>, __tuple_types<_Tl...>, __tuple_indices<_Ul...>, __tuple_types<_Tl...>,
_Up&&... __u) _Up&&... __u)
_NOEXCEPT_((__all<is_nothrow_constructible<_Tf, _Up>::value...>::value && _NOEXCEPT_((__all<is_nothrow_constructible<_Tf, _Up>::value...>::value &&
__all<is_nothrow_default_constructible<_Tl>::value...>::value)) : __all<is_nothrow_default_constructible<_Tl>::value...>::value)) :
__tuple_leaf<_Uf, _Tf>(_VSTD::forward<_Up>(__u))..., __tuple_leaf<_Uf, _Tf>(_VSTD::forward<_Up>(__u))...,
__tuple_leaf<_Ul, _Tl>()... __tuple_leaf<_Ul, _Tl>()...
{} {}
template <class _Alloc, size_t ..._Uf, class ..._Tf, template <class _Alloc, size_t ..._Uf, class ..._Tf,
size_t ..._Ul, class ..._Tl, class ..._Up> size_t ..._Ul, class ..._Tl, class ..._Up>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
explicit explicit
__tuple_impl(allocator_arg_t, const _Alloc& __a, __tuple_impl(allocator_arg_t, const _Alloc& __a,
__tuple_indices<_Uf...>, __tuple_types<_Tf...>, __tuple_indices<_Uf...>, __tuple_types<_Tf...>,
__tuple_indices<_Ul...>, __tuple_types<_Tl...>, __tuple_indices<_Ul...>, __tuple_types<_Tl...>,
_Up&&... __u) : _Up&&... __u) :
__tuple_leaf<_Uf, _Tf>(__uses_alloc_ctor<_Tf, _Alloc, _Up>(), __a, __tuple_leaf<_Uf, _Tf>(__uses_alloc_ctor<_Tf, _Alloc, _Up>(), __a,
_VSTD::forward<_Up>(__u))..., _VSTD::forward<_Up>(__u))...,
__tuple_leaf<_Ul, _Tl>(__uses_alloc_ctor<_Tl, _Alloc>(), __a)... __tuple_leaf<_Ul, _Tl>(__uses_alloc_ctor<_Tl, _Alloc>(), __a)...
{} {}
template <class _Tuple, template <class _Tuple,
class = __enable_if_t<__tuple_constructible<_Tuple, tuple<_Tp...> >::value> class = __enable_if_t<__tuple_constructible<_Tuple, tuple<_Tp...> >::value>
> >
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
__tuple_impl(_Tuple&& __t) _NOEXCEPT_((__all<is_nothrow_constructible<_Tp, typename tuple_element<_Indx, __tuple_impl(_Tuple&& __t) _NOEXCEPT_((__all<is_nothrow_constructible<_Tp, typename tuple_element<_Indx,
typename __make_tuple_types<_Tuple>::type>::type>::value...>::value)) typename __make_tuple_types<_Tuple>::type>::type>::value...>::value))
: __tuple_leaf<_Indx, _Tp>(_VSTD::forward<typename tuple_element<_Indx, : __tuple_leaf<_Indx, _Tp>(_VSTD::forward<typename tuple_element<_Indx,
typename __make_tuple_types<_Tuple>::type>::type>(_VSTD::get<_Indx>(__t)))... typename __make_tuple_types<_Tuple>::type>::type>(_VSTD::get<_Indx>(__t)))...
{} {}
template <class _Alloc, class _Tuple, template <class _Alloc, class _Tuple,
class = __enable_if_t<__tuple_constructible<_Tuple, tuple<_Tp...> >::value> class = __enable_if_t<__tuple_constructible<_Tuple, tuple<_Tp...> >::value>
> >
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
__tuple_impl(allocator_arg_t, const _Alloc& __a, _Tuple&& __t) __tuple_impl(allocator_arg_t, const _Alloc& __a, _Tuple&& __t)
: __tuple_leaf<_Indx, _Tp>(__uses_alloc_ctor<_Tp, _Alloc, typename tuple_element<_Indx, : __tuple_leaf<_Indx, _Tp>(__uses_alloc_ctor<_Tp, _Alloc, typename tuple_element<_Indx,
typename __make_tuple_types<_Tuple>::type>::type>(), __a, typename __make_tuple_types<_Tuple>::type>::type>(), __a,
_VSTD::forward<typename tuple_element<_Indx, _VSTD::forward<typename tuple_element<_Indx,
typename __make_tuple_types<_Tuple>::type>::type>(_VSTD::get<_Indx>(__t)))... typename __make_tuple_types<_Tuple>::type>::type>(_VSTD::get<_Indx>(__t)))...
{} {}
__tuple_impl(const __tuple_impl&) = default; __tuple_impl(const __tuple_impl&) = default;
__tuple_impl(__tuple_impl&&) = default; __tuple_impl(__tuple_impl&&) = default;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
void swap(__tuple_impl& __t) void swap(__tuple_impl& __t)
_NOEXCEPT_(__all<__is_nothrow_swappable<_Tp>::value...>::value) _NOEXCEPT_(__all<__is_nothrow_swappable<_Tp>::value...>::value)
{ {
_VSTD::__swallow(__tuple_leaf<_Indx, _Tp>::swap(static_cast<__tuple_leaf<_Indx, _Tp>&>(__t))...); _VSTD::__swallow(__tuple_leaf<_Indx, _Tp>::swap(static_cast<__tuple_leaf<_Indx, _Tp>&>(__t))...);
} }
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
void swap(const __tuple_impl& __t) const void swap(const __tuple_impl& __t) const
_NOEXCEPT_(__all<__is_nothrow_swappable<const _Tp>::value...>::value) _NOEXCEPT_(__all<__is_nothrow_swappable<const _Tp>::value...>::value)
{ {
_VSTD::__swallow(__tuple_leaf<_Indx, _Tp>::swap(static_cast<const __tuple_leaf<_Indx, _Tp>&>(__t))...); _VSTD::__swallow(__tuple_leaf<_Indx, _Tp>::swap(static_cast<const __tuple_leaf<_Indx, _Tp>&>(__t))...);
} }
}; };
template<class _Dest, class _Source, size_t ..._Np> template<class _Dest, class _Source, size_t ..._Np>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
void __memberwise_copy_assign(_Dest& __dest, _Source const& __source, __tuple_indices<_Np...>) { void __memberwise_copy_assign(_Dest& __dest, _Source const& __source, __tuple_indices<_Np...>) {
_VSTD::__swallow(((_VSTD::get<_Np>(__dest) = _VSTD::get<_Np>(__source)), void(), 0)...); _VSTD::__swallow(((_VSTD::get<_Np>(__dest) = _VSTD::get<_Np>(__source)), void(), 0)...);
} }
template<class _Dest, class _Source, class ..._Up, size_t ..._Np> template<class _Dest, class _Source, class ..._Up, size_t ..._Np>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
void __memberwise_forward_assign(_Dest& __dest, _Source&& __source, __tuple_types<_Up...>, __tuple_indices<_Np...>) { void __memberwise_forward_assign(_Dest& __dest, _Source&& __source, __tuple_types<_Up...>, __tuple_indices<_Np...>) {
_VSTD::__swallow((( _VSTD::__swallow(((
_VSTD::get<_Np>(__dest) = _VSTD::forward<_Up>(_VSTD::get<_Np>(__source)) _VSTD::get<_Np>(__dest) = _VSTD::forward<_Up>(_VSTD::get<_Np>(__source))
), void(), 0)...); ), void(), 0)...);
} }
template <class ..._Tp> template <class ..._Tp>
class _LIBCPP_TEMPLATE_VIS tuple class _LIBCPP_TEMPLATE_VIS tuple
{ {
typedef __tuple_impl<typename __make_tuple_indices<sizeof...(_Tp)>::type, _Tp...> _BaseT; typedef __tuple_impl<typename __make_tuple_indices<sizeof...(_Tp)>::type, _Tp...> _BaseT;
_BaseT __base_; _BaseT __base_;
template <size_t _Jp, class ..._Up> friend _LIBCPP_CONSTEXPR_AFTER_CXX11 template <size_t _Jp, class ..._Up> friend _LIBCPP_CONSTEXPR_CXX14
typename tuple_element<_Jp, tuple<_Up...> >::type& get(tuple<_Up...>&) _NOEXCEPT; typename tuple_element<_Jp, tuple<_Up...> >::type& get(tuple<_Up...>&) _NOEXCEPT;
template <size_t _Jp, class ..._Up> friend _LIBCPP_CONSTEXPR_AFTER_CXX11 template <size_t _Jp, class ..._Up> friend _LIBCPP_CONSTEXPR_CXX14
const typename tuple_element<_Jp, tuple<_Up...> >::type& get(const tuple<_Up...>&) _NOEXCEPT; const typename tuple_element<_Jp, tuple<_Up...> >::type& get(const tuple<_Up...>&) _NOEXCEPT;
template <size_t _Jp, class ..._Up> friend _LIBCPP_CONSTEXPR_AFTER_CXX11 template <size_t _Jp, class ..._Up> friend _LIBCPP_CONSTEXPR_CXX14
typename tuple_element<_Jp, tuple<_Up...> >::type&& get(tuple<_Up...>&&) _NOEXCEPT; typename tuple_element<_Jp, tuple<_Up...> >::type&& get(tuple<_Up...>&&) _NOEXCEPT;
template <size_t _Jp, class ..._Up> friend _LIBCPP_CONSTEXPR_AFTER_CXX11 template <size_t _Jp, class ..._Up> friend _LIBCPP_CONSTEXPR_CXX14
const typename tuple_element<_Jp, tuple<_Up...> >::type&& get(const tuple<_Up...>&&) _NOEXCEPT; const typename tuple_element<_Jp, tuple<_Up...> >::type&& get(const tuple<_Up...>&&) _NOEXCEPT;
public: public:
// [tuple.cnstr] // [tuple.cnstr]
// tuple() constructors (including allocator_arg_t variants) // tuple() constructors (including allocator_arg_t variants)
template <template<class...> class _IsImpDefault = __is_implicitly_default_constructible, __enable_if_t< template <template<class...> class _IsImpDefault = __is_implicitly_default_constructible, __enable_if_t<
_And< _And<
_IsImpDefault<_Tp>... // explicit check _IsImpDefault<_Tp>... // explicit check
Show All 16 Lines explicit tuple()
_NOEXCEPT_(_And<is_nothrow_default_constructible<_Tp>...>::value) _NOEXCEPT_(_And<is_nothrow_default_constructible<_Tp>...>::value)
{ } { }
template <class _Alloc, template<class...> class _IsImpDefault = __is_implicitly_default_constructible, __enable_if_t< template <class _Alloc, template<class...> class _IsImpDefault = __is_implicitly_default_constructible, __enable_if_t<
_And< _And<
_IsImpDefault<_Tp>... // explicit check _IsImpDefault<_Tp>... // explicit check
>::value >::value
, int> = 0> , int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
tuple(allocator_arg_t, _Alloc const& __a) tuple(allocator_arg_t, _Alloc const& __a)
: __base_(allocator_arg_t(), __a, : __base_(allocator_arg_t(), __a,
__tuple_indices<>(), __tuple_types<>(), __tuple_indices<>(), __tuple_types<>(),
typename __make_tuple_indices<sizeof...(_Tp), 0>::type(), typename __make_tuple_indices<sizeof...(_Tp), 0>::type(),
__tuple_types<_Tp...>()) {} __tuple_types<_Tp...>()) {}
template <class _Alloc, template <class _Alloc,
template<class...> class _IsImpDefault = __is_implicitly_default_constructible, template<class...> class _IsImpDefault = __is_implicitly_default_constructible,
template<class...> class _IsDefault = is_default_constructible, __enable_if_t< template<class...> class _IsDefault = is_default_constructible, __enable_if_t<
_And< _And<
_IsDefault<_Tp>..., _IsDefault<_Tp>...,
_Not<_Lazy<_And, _IsImpDefault<_Tp>...> > // explicit check _Not<_Lazy<_And, _IsImpDefault<_Tp>...> > // explicit check
>::value >::value
, int> = 0> , int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
explicit tuple(allocator_arg_t, _Alloc const& __a) explicit tuple(allocator_arg_t, _Alloc const& __a)
: __base_(allocator_arg_t(), __a, : __base_(allocator_arg_t(), __a,
__tuple_indices<>(), __tuple_types<>(), __tuple_indices<>(), __tuple_types<>(),
typename __make_tuple_indices<sizeof...(_Tp), 0>::type(), typename __make_tuple_indices<sizeof...(_Tp), 0>::type(),
__tuple_types<_Tp...>()) {} __tuple_types<_Tp...>()) {}
// tuple(const T&...) constructors (including allocator_arg_t variants) // tuple(const T&...) constructors (including allocator_arg_t variants)
template <template<class...> class _And = _And, __enable_if_t< template <template<class...> class _And = _And, __enable_if_t<
_And< _And<
_BoolConstant<sizeof...(_Tp) >= 1>, _BoolConstant<sizeof...(_Tp) >= 1>,
is_copy_constructible<_Tp>..., is_copy_constructible<_Tp>...,
is_convertible<const _Tp&, _Tp>... // explicit check is_convertible<const _Tp&, _Tp>... // explicit check
>::value >::value
, int> = 0> , int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
tuple(const _Tp& ... __t) tuple(const _Tp& ... __t)
_NOEXCEPT_(_And<is_nothrow_copy_constructible<_Tp>...>::value) _NOEXCEPT_(_And<is_nothrow_copy_constructible<_Tp>...>::value)
: __base_(typename __make_tuple_indices<sizeof...(_Tp)>::type(), : __base_(typename __make_tuple_indices<sizeof...(_Tp)>::type(),
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...
) {} ) {}
template <template<class...> class _And = _And, __enable_if_t< template <template<class...> class _And = _And, __enable_if_t<
_And< _And<
_BoolConstant<sizeof...(_Tp) >= 1>, _BoolConstant<sizeof...(_Tp) >= 1>,
is_copy_constructible<_Tp>..., is_copy_constructible<_Tp>...,
_Not<_Lazy<_And, is_convertible<const _Tp&, _Tp>...> > // explicit check _Not<_Lazy<_And, is_convertible<const _Tp&, _Tp>...> > // explicit check
>::value >::value
, int> = 0> , int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
explicit tuple(const _Tp& ... __t) explicit tuple(const _Tp& ... __t)
_NOEXCEPT_(_And<is_nothrow_copy_constructible<_Tp>...>::value) _NOEXCEPT_(_And<is_nothrow_copy_constructible<_Tp>...>::value)
: __base_(typename __make_tuple_indices<sizeof...(_Tp)>::type(), : __base_(typename __make_tuple_indices<sizeof...(_Tp)>::type(),
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...
) {} ) {}
template <class _Alloc, template<class...> class _And = _And, __enable_if_t< template <class _Alloc, template<class...> class _And = _And, __enable_if_t<
_And< _And<
_BoolConstant<sizeof...(_Tp) >= 1>, _BoolConstant<sizeof...(_Tp) >= 1>,
is_copy_constructible<_Tp>..., is_copy_constructible<_Tp>...,
is_convertible<const _Tp&, _Tp>... // explicit check is_convertible<const _Tp&, _Tp>... // explicit check
>::value >::value
, int> = 0> , int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
tuple(allocator_arg_t, const _Alloc& __a, const _Tp& ... __t) tuple(allocator_arg_t, const _Alloc& __a, const _Tp& ... __t)
: __base_(allocator_arg_t(), __a, : __base_(allocator_arg_t(), __a,
typename __make_tuple_indices<sizeof...(_Tp)>::type(), typename __make_tuple_indices<sizeof...(_Tp)>::type(),
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...
) {} ) {}
template <class _Alloc, template<class...> class _And = _And, __enable_if_t< template <class _Alloc, template<class...> class _And = _And, __enable_if_t<
_And< _And<
_BoolConstant<sizeof...(_Tp) >= 1>, _BoolConstant<sizeof...(_Tp) >= 1>,
is_copy_constructible<_Tp>..., is_copy_constructible<_Tp>...,
_Not<_Lazy<_And, is_convertible<const _Tp&, _Tp>...> > // explicit check _Not<_Lazy<_And, is_convertible<const _Tp&, _Tp>...> > // explicit check
>::value >::value
, int> = 0> , int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
explicit tuple(allocator_arg_t, const _Alloc& __a, const _Tp& ... __t) explicit tuple(allocator_arg_t, const _Alloc& __a, const _Tp& ... __t)
: __base_(allocator_arg_t(), __a, : __base_(allocator_arg_t(), __a,
typename __make_tuple_indices<sizeof...(_Tp)>::type(), typename __make_tuple_indices<sizeof...(_Tp)>::type(),
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...
) {} ) {}
Show All 11 Linespublic:
template <class ..._Up, __enable_if_t< template <class ..._Up, __enable_if_t<
_And< _And<
_BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>, _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
_EnableUTypesCtor<_Up...>, _EnableUTypesCtor<_Up...>,
is_convertible<_Up, _Tp>... // explicit check is_convertible<_Up, _Tp>... // explicit check
>::value >::value
, int> = 0> , int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
tuple(_Up&&... __u) tuple(_Up&&... __u)
_NOEXCEPT_((_And<is_nothrow_constructible<_Tp, _Up>...>::value)) _NOEXCEPT_((_And<is_nothrow_constructible<_Tp, _Up>...>::value))
: __base_(typename __make_tuple_indices<sizeof...(_Up)>::type(), : __base_(typename __make_tuple_indices<sizeof...(_Up)>::type(),
typename __make_tuple_types<tuple, sizeof...(_Up)>::type(), typename __make_tuple_types<tuple, sizeof...(_Up)>::type(),
typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(), typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(),
typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(), typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(),
_VSTD::forward<_Up>(__u)...) {} _VSTD::forward<_Up>(__u)...) {}
template <class ..._Up, __enable_if_t< template <class ..._Up, __enable_if_t<
_And< _And<
_BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>, _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
_EnableUTypesCtor<_Up...>, _EnableUTypesCtor<_Up...>,
_Not<_Lazy<_And, is_convertible<_Up, _Tp>...> > // explicit check _Not<_Lazy<_And, is_convertible<_Up, _Tp>...> > // explicit check
>::value >::value
, int> = 0> , int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
explicit tuple(_Up&&... __u) explicit tuple(_Up&&... __u)
_NOEXCEPT_((_And<is_nothrow_constructible<_Tp, _Up>...>::value)) _NOEXCEPT_((_And<is_nothrow_constructible<_Tp, _Up>...>::value))
: __base_(typename __make_tuple_indices<sizeof...(_Up)>::type(), : __base_(typename __make_tuple_indices<sizeof...(_Up)>::type(),
typename __make_tuple_types<tuple, sizeof...(_Up)>::type(), typename __make_tuple_types<tuple, sizeof...(_Up)>::type(),
typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(), typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(),
typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(), typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(),
_VSTD::forward<_Up>(__u)...) {} _VSTD::forward<_Up>(__u)...) {}
template <class _Alloc, class ..._Up, __enable_if_t< template <class _Alloc, class ..._Up, __enable_if_t<
_And< _And<
_BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>, _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
_EnableUTypesCtor<_Up...>, _EnableUTypesCtor<_Up...>,
is_convertible<_Up, _Tp>... // explicit check is_convertible<_Up, _Tp>... // explicit check
>::value >::value
, int> = 0> , int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
tuple(allocator_arg_t, const _Alloc& __a, _Up&&... __u) tuple(allocator_arg_t, const _Alloc& __a, _Up&&... __u)
: __base_(allocator_arg_t(), __a, : __base_(allocator_arg_t(), __a,
typename __make_tuple_indices<sizeof...(_Up)>::type(), typename __make_tuple_indices<sizeof...(_Up)>::type(),
typename __make_tuple_types<tuple, sizeof...(_Up)>::type(), typename __make_tuple_types<tuple, sizeof...(_Up)>::type(),
typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(), typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(),
typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(), typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(),
_VSTD::forward<_Up>(__u)...) {} _VSTD::forward<_Up>(__u)...) {}
template <class _Alloc, class ..._Up, __enable_if_t< template <class _Alloc, class ..._Up, __enable_if_t<
_And< _And<
_BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>, _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
_EnableUTypesCtor<_Up...>, _EnableUTypesCtor<_Up...>,
_Not<_Lazy<_And, is_convertible<_Up, _Tp>...> > // explicit check _Not<_Lazy<_And, is_convertible<_Up, _Tp>...> > // explicit check
>::value >::value
, int> = 0> , int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
explicit tuple(allocator_arg_t, const _Alloc& __a, _Up&&... __u) explicit tuple(allocator_arg_t, const _Alloc& __a, _Up&&... __u)
: __base_(allocator_arg_t(), __a, : __base_(allocator_arg_t(), __a,
typename __make_tuple_indices<sizeof...(_Up)>::type(), typename __make_tuple_indices<sizeof...(_Up)>::type(),
typename __make_tuple_types<tuple, sizeof...(_Up)>::type(), typename __make_tuple_types<tuple, sizeof...(_Up)>::type(),
typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(), typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(),
typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(), typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(),
_VSTD::forward<_Up>(__u)...) {} _VSTD::forward<_Up>(__u)...) {}
// Copy and move constructors (including the allocator_arg_t variants) // Copy and move constructors (including the allocator_arg_t variants)
tuple(const tuple&) = default; tuple(const tuple&) = default;
tuple(tuple&&) = default; tuple(tuple&&) = default;
template <class _Alloc, template<class...> class _And = _And, __enable_if_t< template <class _Alloc, template<class...> class _And = _And, __enable_if_t<
_And<is_copy_constructible<_Tp>...>::value _And<is_copy_constructible<_Tp>...>::value
, int> = 0> , int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
tuple(allocator_arg_t, const _Alloc& __alloc, const tuple& __t) tuple(allocator_arg_t, const _Alloc& __alloc, const tuple& __t)
: __base_(allocator_arg_t(), __alloc, __t) : __base_(allocator_arg_t(), __alloc, __t)
{ } { }
template <class _Alloc, template<class...> class _And = _And, __enable_if_t< template <class _Alloc, template<class...> class _And = _And, __enable_if_t<
_And<is_move_constructible<_Tp>...>::value _And<is_move_constructible<_Tp>...>::value
, int> = 0> , int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_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 = __uncvref_t<_OtherTuple>, class = void>
struct _EnableCtorFromUTypesTuple : false_type {}; struct _EnableCtorFromUTypesTuple : false_type {};
Show All 19 Linespublic:
> {}; > {};
template <class ..._Up, __enable_if_t< template <class ..._Up, __enable_if_t<
_And< _And<
_EnableCtorFromUTypesTuple<const tuple<_Up...>&>, _EnableCtorFromUTypesTuple<const tuple<_Up...>&>,
is_convertible<const _Up&, _Tp>... // explicit check is_convertible<const _Up&, _Tp>... // explicit check
>::value >::value
, int> = 0> , int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
tuple(const tuple<_Up...>& __t) tuple(const tuple<_Up...>& __t)
_NOEXCEPT_((_And<is_nothrow_constructible<_Tp, const _Up&>...>::value)) _NOEXCEPT_((_And<is_nothrow_constructible<_Tp, const _Up&>...>::value))
: __base_(__t) : __base_(__t)
{ } { }
template <class ..._Up, __enable_if_t< template <class ..._Up, __enable_if_t<
_And< _And<
_EnableCtorFromUTypesTuple<const tuple<_Up...>&>, _EnableCtorFromUTypesTuple<const tuple<_Up...>&>,
_Not<_Lazy<_And, is_convertible<const _Up&, _Tp>...> > // explicit check _Not<_Lazy<_And, is_convertible<const _Up&, _Tp>...> > // explicit check
>::value >::value
, int> = 0> , int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
explicit tuple(const tuple<_Up...>& __t) explicit tuple(const tuple<_Up...>& __t)
_NOEXCEPT_((_And<is_nothrow_constructible<_Tp, const _Up&>...>::value)) _NOEXCEPT_((_And<is_nothrow_constructible<_Tp, const _Up&>...>::value))
: __base_(__t) : __base_(__t)
{ } { }
template <class ..._Up, class _Alloc, __enable_if_t< template <class ..._Up, class _Alloc, __enable_if_t<
_And< _And<
_EnableCtorFromUTypesTuple<const tuple<_Up...>&>, _EnableCtorFromUTypesTuple<const tuple<_Up...>&>,
is_convertible<const _Up&, _Tp>... // explicit check is_convertible<const _Up&, _Tp>... // explicit check
>::value >::value
, int> = 0> , int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
tuple(allocator_arg_t, const _Alloc& __a, const tuple<_Up...>& __t) tuple(allocator_arg_t, const _Alloc& __a, const tuple<_Up...>& __t)
: __base_(allocator_arg_t(), __a, __t) : __base_(allocator_arg_t(), __a, __t)
{ } { }
template <class ..._Up, class _Alloc, __enable_if_t< template <class ..._Up, class _Alloc, __enable_if_t<
_And< _And<
_EnableCtorFromUTypesTuple<const tuple<_Up...>&>, _EnableCtorFromUTypesTuple<const tuple<_Up...>&>,
_Not<_Lazy<_And, is_convertible<const _Up&, _Tp>...> > // explicit check _Not<_Lazy<_And, is_convertible<const _Up&, _Tp>...> > // explicit check
>::value >::value
, int> = 0> , int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
explicit tuple(allocator_arg_t, const _Alloc& __a, const tuple<_Up...>& __t) explicit tuple(allocator_arg_t, const _Alloc& __a, const tuple<_Up...>& __t)
: __base_(allocator_arg_t(), __a, __t) : __base_(allocator_arg_t(), __a, __t)
{ } { }
#if _LIBCPP_STD_VER > 20 #if _LIBCPP_STD_VER > 20
// tuple(tuple<U...>&) constructors (including allocator_arg_t variants) // tuple(tuple<U...>&) constructors (including allocator_arg_t variants)
template <class... _Up, enable_if_t< template <class... _Up, enable_if_t<
Show All 12 Lines#endif // _LIBCPP_STD_VER > 20
// tuple(tuple<U...>&&) constructors (including allocator_arg_t variants) // tuple(tuple<U...>&&) constructors (including allocator_arg_t variants)
template <class ..._Up, __enable_if_t< template <class ..._Up, __enable_if_t<
_And< _And<
_EnableCtorFromUTypesTuple<tuple<_Up...>&&>, _EnableCtorFromUTypesTuple<tuple<_Up...>&&>,
is_convertible<_Up, _Tp>... // explicit check is_convertible<_Up, _Tp>... // explicit check
>::value >::value
, int> = 0> , int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
tuple(tuple<_Up...>&& __t) tuple(tuple<_Up...>&& __t)
_NOEXCEPT_((_And<is_nothrow_constructible<_Tp, _Up>...>::value)) _NOEXCEPT_((_And<is_nothrow_constructible<_Tp, _Up>...>::value))
: __base_(_VSTD::move(__t)) : __base_(_VSTD::move(__t))
{ } { }
template <class ..._Up, __enable_if_t< template <class ..._Up, __enable_if_t<
_And< _And<
_EnableCtorFromUTypesTuple<tuple<_Up...>&&>, _EnableCtorFromUTypesTuple<tuple<_Up...>&&>,
_Not<_Lazy<_And, is_convertible<_Up, _Tp>...> > // explicit check _Not<_Lazy<_And, is_convertible<_Up, _Tp>...> > // explicit check
>::value >::value
, int> = 0> , int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
explicit tuple(tuple<_Up...>&& __t) explicit tuple(tuple<_Up...>&& __t)
_NOEXCEPT_((_And<is_nothrow_constructible<_Tp, _Up>...>::value)) _NOEXCEPT_((_And<is_nothrow_constructible<_Tp, _Up>...>::value))
: __base_(_VSTD::move(__t)) : __base_(_VSTD::move(__t))
{ } { }
template <class _Alloc, class ..._Up, __enable_if_t< template <class _Alloc, class ..._Up, __enable_if_t<
_And< _And<
_EnableCtorFromUTypesTuple<tuple<_Up...>&&>, _EnableCtorFromUTypesTuple<tuple<_Up...>&&>,
is_convertible<_Up, _Tp>... // explicit check is_convertible<_Up, _Tp>... // explicit check
>::value >::value
, int> = 0> , int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
tuple(allocator_arg_t, const _Alloc& __a, tuple<_Up...>&& __t) tuple(allocator_arg_t, const _Alloc& __a, tuple<_Up...>&& __t)
: __base_(allocator_arg_t(), __a, _VSTD::move(__t)) : __base_(allocator_arg_t(), __a, _VSTD::move(__t))
{ } { }
template <class _Alloc, class ..._Up, __enable_if_t< template <class _Alloc, class ..._Up, __enable_if_t<
_And< _And<
_EnableCtorFromUTypesTuple<tuple<_Up...>&&>, _EnableCtorFromUTypesTuple<tuple<_Up...>&&>,
_Not<_Lazy<_And, is_convertible<_Up, _Tp>...> > // explicit check _Not<_Lazy<_And, is_convertible<_Up, _Tp>...> > // explicit check
>::value >::value
, int> = 0> , int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
explicit tuple(allocator_arg_t, const _Alloc& __a, tuple<_Up...>&& __t) explicit tuple(allocator_arg_t, const _Alloc& __a, tuple<_Up...>&& __t)
: __base_(allocator_arg_t(), __a, _VSTD::move(__t)) : __base_(allocator_arg_t(), __a, _VSTD::move(__t))
{ } { }
#if _LIBCPP_STD_VER > 20 #if _LIBCPP_STD_VER > 20
// tuple(const tuple<U...>&&) constructors (including allocator_arg_t variants) // tuple(const tuple<U...>&&) constructors (including allocator_arg_t variants)
template <class... _Up, enable_if_t< template <class... _Up, enable_if_t<
Show All 37 Lines#endif // _LIBCPP_STD_VER > 20
> {}; > {};
template <class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t< template <class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
_And< _And<
_EnableCtorFromPair<const pair<_Up1, _Up2>&>, _EnableCtorFromPair<const pair<_Up1, _Up2>&>,
_BothImplicitlyConvertible<const pair<_Up1, _Up2>&> // explicit check _BothImplicitlyConvertible<const pair<_Up1, _Up2>&> // explicit check
>::value >::value
, int> = 0> , int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
tuple(const pair<_Up1, _Up2>& __p) tuple(const pair<_Up1, _Up2>& __p)
_NOEXCEPT_((_NothrowConstructibleFromPair<const pair<_Up1, _Up2>&>::value)) _NOEXCEPT_((_NothrowConstructibleFromPair<const pair<_Up1, _Up2>&>::value))
: __base_(__p) : __base_(__p)
{ } { }
template <class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t< template <class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
_And< _And<
_EnableCtorFromPair<const pair<_Up1, _Up2>&>, _EnableCtorFromPair<const pair<_Up1, _Up2>&>,
_Not<_BothImplicitlyConvertible<const pair<_Up1, _Up2>&> > // explicit check _Not<_BothImplicitlyConvertible<const pair<_Up1, _Up2>&> > // explicit check
>::value >::value
, int> = 0> , int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
explicit tuple(const pair<_Up1, _Up2>& __p) explicit tuple(const pair<_Up1, _Up2>& __p)
_NOEXCEPT_((_NothrowConstructibleFromPair<const pair<_Up1, _Up2>&>::value)) _NOEXCEPT_((_NothrowConstructibleFromPair<const pair<_Up1, _Up2>&>::value))
: __base_(__p) : __base_(__p)
{ } { }
template <class _Alloc, class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t< template <class _Alloc, class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
_And< _And<
_EnableCtorFromPair<const pair<_Up1, _Up2>&>, _EnableCtorFromPair<const pair<_Up1, _Up2>&>,
_BothImplicitlyConvertible<const pair<_Up1, _Up2>&> // explicit check _BothImplicitlyConvertible<const pair<_Up1, _Up2>&> // explicit check
>::value >::value
, int> = 0> , int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
tuple(allocator_arg_t, const _Alloc& __a, const pair<_Up1, _Up2>& __p) tuple(allocator_arg_t, const _Alloc& __a, const pair<_Up1, _Up2>& __p)
: __base_(allocator_arg_t(), __a, __p) : __base_(allocator_arg_t(), __a, __p)
{ } { }
template <class _Alloc, class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t< template <class _Alloc, class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
_And< _And<
_EnableCtorFromPair<const pair<_Up1, _Up2>&>, _EnableCtorFromPair<const pair<_Up1, _Up2>&>,
_Not<_BothImplicitlyConvertible<const pair<_Up1, _Up2>&> > // explicit check _Not<_BothImplicitlyConvertible<const pair<_Up1, _Up2>&> > // explicit check
>::value >::value
, int> = 0> , int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
explicit tuple(allocator_arg_t, const _Alloc& __a, const pair<_Up1, _Up2>& __p) explicit tuple(allocator_arg_t, const _Alloc& __a, const pair<_Up1, _Up2>& __p)
: __base_(allocator_arg_t(), __a, __p) : __base_(allocator_arg_t(), __a, __p)
{ } { }
#if _LIBCPP_STD_VER > 20 #if _LIBCPP_STD_VER > 20
// tuple(pair<U1, U2>&) constructors (including allocator_arg_t variants) // tuple(pair<U1, U2>&) constructors (including allocator_arg_t variants)
template <class _U1, class _U2, enable_if_t< template <class _U1, class _U2, enable_if_t<
Show All 12 Lines#endif
// tuple(pair<U1, U2>&&) constructors (including allocator_arg_t variants) // tuple(pair<U1, U2>&&) constructors (including allocator_arg_t variants)
template <class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t< template <class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
_And< _And<
_EnableCtorFromPair<pair<_Up1, _Up2>&&>, _EnableCtorFromPair<pair<_Up1, _Up2>&&>,
_BothImplicitlyConvertible<pair<_Up1, _Up2>&&> // explicit check _BothImplicitlyConvertible<pair<_Up1, _Up2>&&> // explicit check
>::value >::value
, int> = 0> , int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
tuple(pair<_Up1, _Up2>&& __p) tuple(pair<_Up1, _Up2>&& __p)
_NOEXCEPT_((_NothrowConstructibleFromPair<pair<_Up1, _Up2>&&>::value)) _NOEXCEPT_((_NothrowConstructibleFromPair<pair<_Up1, _Up2>&&>::value))
: __base_(_VSTD::move(__p)) : __base_(_VSTD::move(__p))
{ } { }
template <class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t< template <class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
_And< _And<
_EnableCtorFromPair<pair<_Up1, _Up2>&&>, _EnableCtorFromPair<pair<_Up1, _Up2>&&>,
_Not<_BothImplicitlyConvertible<pair<_Up1, _Up2>&&> > // explicit check _Not<_BothImplicitlyConvertible<pair<_Up1, _Up2>&&> > // explicit check
>::value >::value
, int> = 0> , int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
explicit tuple(pair<_Up1, _Up2>&& __p) explicit tuple(pair<_Up1, _Up2>&& __p)
_NOEXCEPT_((_NothrowConstructibleFromPair<pair<_Up1, _Up2>&&>::value)) _NOEXCEPT_((_NothrowConstructibleFromPair<pair<_Up1, _Up2>&&>::value))
: __base_(_VSTD::move(__p)) : __base_(_VSTD::move(__p))
{ } { }
template <class _Alloc, class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t< template <class _Alloc, class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
_And< _And<
_EnableCtorFromPair<pair<_Up1, _Up2>&&>, _EnableCtorFromPair<pair<_Up1, _Up2>&&>,
_BothImplicitlyConvertible<pair<_Up1, _Up2>&&> // explicit check _BothImplicitlyConvertible<pair<_Up1, _Up2>&&> // explicit check
>::value >::value
, int> = 0> , int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
tuple(allocator_arg_t, const _Alloc& __a, pair<_Up1, _Up2>&& __p) tuple(allocator_arg_t, const _Alloc& __a, pair<_Up1, _Up2>&& __p)
: __base_(allocator_arg_t(), __a, _VSTD::move(__p)) : __base_(allocator_arg_t(), __a, _VSTD::move(__p))
{ } { }
template <class _Alloc, class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t< template <class _Alloc, class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
_And< _And<
_EnableCtorFromPair<pair<_Up1, _Up2>&&>, _EnableCtorFromPair<pair<_Up1, _Up2>&&>,
_Not<_BothImplicitlyConvertible<pair<_Up1, _Up2>&&> > // explicit check _Not<_BothImplicitlyConvertible<pair<_Up1, _Up2>&&> > // explicit check
>::value >::value
, int> = 0> , int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
explicit tuple(allocator_arg_t, const _Alloc& __a, pair<_Up1, _Up2>&& __p) explicit tuple(allocator_arg_t, const _Alloc& __a, pair<_Up1, _Up2>&& __p)
: __base_(allocator_arg_t(), __a, _VSTD::move(__p)) : __base_(allocator_arg_t(), __a, _VSTD::move(__p))
{ } { }
#if _LIBCPP_STD_VER > 20 #if _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 <class _U1, class _U2, enable_if_t< template <class _U1, class _U2, enable_if_t<
_EnableCtorFromPair<const pair<_U1, _U2>&&>::value>* = nullptr> _EnableCtorFromPair<const pair<_U1, _U2>&&>::value>* = nullptr>
_LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_HIDE_FROM_ABI constexpr
explicit(!_BothImplicitlyConvertible<const pair<_U1, _U2>&&>::value) explicit(!_BothImplicitlyConvertible<const pair<_U1, _U2>&&>::value)
tuple(const pair<_U1, _U2>&& __p) : __base_(std::move(__p)) {} tuple(const pair<_U1, _U2>&& __p) : __base_(std::move(__p)) {}
template <class _Alloc, class _U1, class _U2, enable_if_t< template <class _Alloc, class _U1, class _U2, enable_if_t<
_EnableCtorFromPair<const pair<_U1, _U2>&&>::value>* = nullptr> _EnableCtorFromPair<const pair<_U1, _U2>&&>::value>* = nullptr>
_LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_HIDE_FROM_ABI constexpr
explicit(!_BothImplicitlyConvertible<const pair<_U1, _U2>&&>::value) explicit(!_BothImplicitlyConvertible<const pair<_U1, _U2>&&>::value)
tuple(allocator_arg_t, const _Alloc& __alloc, const pair<_U1, _U2>&& __p) tuple(allocator_arg_t, const _Alloc& __alloc, const pair<_U1, _U2>&& __p)
: __base_(allocator_arg_t(), __alloc, std::move(__p)) {} : __base_(allocator_arg_t(), __alloc, std::move(__p)) {}
#endif // _LIBCPP_STD_VER > 20 #endif // _LIBCPP_STD_VER > 20
// [tuple.assign] // [tuple.assign]
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
tuple& operator=(_If<_And<is_copy_assignable<_Tp>...>::value, tuple, __nat> const& __tuple) tuple& operator=(_If<_And<is_copy_assignable<_Tp>...>::value, tuple, __nat> const& __tuple)
_NOEXCEPT_((_And<is_nothrow_copy_assignable<_Tp>...>::value)) _NOEXCEPT_((_And<is_nothrow_copy_assignable<_Tp>...>::value))
{ {
_VSTD::__memberwise_copy_assign(*this, __tuple, _VSTD::__memberwise_copy_assign(*this, __tuple,
typename __make_tuple_indices<sizeof...(_Tp)>::type()); typename __make_tuple_indices<sizeof...(_Tp)>::type());
return *this; return *this;
} }
Show All 11 Lines const tuple& operator=(tuple&& __tuple) const
std::__memberwise_forward_assign(*this, std::__memberwise_forward_assign(*this,
std::move(__tuple), std::move(__tuple),
__tuple_types<_Tp...>(), __tuple_types<_Tp...>(),
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
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
tuple& operator=(_If<_And<is_move_assignable<_Tp>...>::value, tuple, __nat>&& __tuple) tuple& operator=(_If<_And<is_move_assignable<_Tp>...>::value, tuple, __nat>&& __tuple)
_NOEXCEPT_((_And<is_nothrow_move_assignable<_Tp>...>::value)) _NOEXCEPT_((_And<is_nothrow_move_assignable<_Tp>...>::value))
{ {
_VSTD::__memberwise_forward_assign(*this, _VSTD::move(__tuple), _VSTD::__memberwise_forward_assign(*this, _VSTD::move(__tuple),
__tuple_types<_Tp...>(), __tuple_types<_Tp...>(),
typename __make_tuple_indices<sizeof...(_Tp)>::type()); typename __make_tuple_indices<sizeof...(_Tp)>::type());
return *this; return *this;
} }
template<class... _Up, __enable_if_t< template<class... _Up, __enable_if_t<
_And< _And<
_BoolConstant<sizeof...(_Tp) == sizeof...(_Up)>, _BoolConstant<sizeof...(_Tp) == sizeof...(_Up)>,
is_assignable<_Tp&, _Up const&>... is_assignable<_Tp&, _Up const&>...
>::value >::value
,int> = 0> ,int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
tuple& operator=(tuple<_Up...> const& __tuple) tuple& operator=(tuple<_Up...> const& __tuple)
_NOEXCEPT_((_And<is_nothrow_assignable<_Tp&, _Up const&>...>::value)) _NOEXCEPT_((_And<is_nothrow_assignable<_Tp&, _Up const&>...>::value))
{ {
_VSTD::__memberwise_copy_assign(*this, __tuple, _VSTD::__memberwise_copy_assign(*this, __tuple,
typename __make_tuple_indices<sizeof...(_Tp)>::type()); typename __make_tuple_indices<sizeof...(_Tp)>::type());
return *this; return *this;
} }
template<class... _Up, __enable_if_t< template<class... _Up, __enable_if_t<
_And< _And<
_BoolConstant<sizeof...(_Tp) == sizeof...(_Up)>, _BoolConstant<sizeof...(_Tp) == sizeof...(_Up)>,
is_assignable<_Tp&, _Up>... is_assignable<_Tp&, _Up>...
>::value >::value
,int> = 0> ,int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
tuple& operator=(tuple<_Up...>&& __tuple) tuple& operator=(tuple<_Up...>&& __tuple)
_NOEXCEPT_((_And<is_nothrow_assignable<_Tp&, _Up>...>::value)) _NOEXCEPT_((_And<is_nothrow_assignable<_Tp&, _Up>...>::value))
{ {
_VSTD::__memberwise_forward_assign(*this, _VSTD::move(__tuple), _VSTD::__memberwise_forward_assign(*this, _VSTD::move(__tuple),
__tuple_types<_Up...>(), __tuple_types<_Up...>(),
typename __make_tuple_indices<sizeof...(_Tp)>::type()); typename __make_tuple_indices<sizeof...(_Tp)>::type());
return *this; return *this;
} }
▲ Show 20 Lines • Show All 61 Lines • ▼ Show 20 Lines const tuple& operator=(pair<_U1, _U2>&& __pair) const
std::get<1>(*this) = std::move(__pair.second); std::get<1>(*this) = std::move(__pair.second);
return *this; return *this;
} }
#endif // _LIBCPP_STD_VER > 20 #endif // _LIBCPP_STD_VER > 20
template<class _Up1, class _Up2, __enable_if_t< template<class _Up1, class _Up2, __enable_if_t<
_EnableAssignFromPair<false, pair<_Up1, _Up2> const&>::value _EnableAssignFromPair<false, pair<_Up1, _Up2> const&>::value
,int> = 0> ,int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
tuple& operator=(pair<_Up1, _Up2> const& __pair) tuple& operator=(pair<_Up1, _Up2> const& __pair)
_NOEXCEPT_((_NothrowAssignFromPair<false, pair<_Up1, _Up2> const&>::value)) _NOEXCEPT_((_NothrowAssignFromPair<false, pair<_Up1, _Up2> const&>::value))
{ {
_VSTD::get<0>(*this) = __pair.first; _VSTD::get<0>(*this) = __pair.first;
_VSTD::get<1>(*this) = __pair.second; _VSTD::get<1>(*this) = __pair.second;
return *this; return *this;
} }
template<class _Up1, class _Up2, __enable_if_t< template<class _Up1, class _Up2, __enable_if_t<
_EnableAssignFromPair<false, pair<_Up1, _Up2>&&>::value _EnableAssignFromPair<false, pair<_Up1, _Up2>&&>::value
,int> = 0> ,int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
tuple& operator=(pair<_Up1, _Up2>&& __pair) tuple& operator=(pair<_Up1, _Up2>&& __pair)
_NOEXCEPT_((_NothrowAssignFromPair<false, pair<_Up1, _Up2>&&>::value)) _NOEXCEPT_((_NothrowAssignFromPair<false, pair<_Up1, _Up2>&&>::value))
{ {
_VSTD::get<0>(*this) = _VSTD::forward<_Up1>(__pair.first); _VSTD::get<0>(*this) = _VSTD::forward<_Up1>(__pair.first);
_VSTD::get<1>(*this) = _VSTD::forward<_Up2>(__pair.second); _VSTD::get<1>(*this) = _VSTD::forward<_Up2>(__pair.second);
return *this; return *this;
} }
// EXTENSION // EXTENSION
template<class _Up, size_t _Np, class = __enable_if_t< template<class _Up, size_t _Np, class = __enable_if_t<
_And< _And<
_BoolConstant<_Np == sizeof...(_Tp)>, _BoolConstant<_Np == sizeof...(_Tp)>,
is_assignable<_Tp&, _Up const&>... is_assignable<_Tp&, _Up const&>...
>::value >::value
> > > >
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
tuple& operator=(array<_Up, _Np> const& __array) tuple& operator=(array<_Up, _Np> const& __array)
_NOEXCEPT_((_And<is_nothrow_assignable<_Tp&, _Up const&>...>::value)) _NOEXCEPT_((_And<is_nothrow_assignable<_Tp&, _Up const&>...>::value))
{ {
_VSTD::__memberwise_copy_assign(*this, __array, _VSTD::__memberwise_copy_assign(*this, __array,
typename __make_tuple_indices<sizeof...(_Tp)>::type()); typename __make_tuple_indices<sizeof...(_Tp)>::type());
return *this; return *this;
} }
// EXTENSION // EXTENSION
template<class _Up, size_t _Np, class = void, class = __enable_if_t< template<class _Up, size_t _Np, class = void, class = __enable_if_t<
_And< _And<
_BoolConstant<_Np == sizeof...(_Tp)>, _BoolConstant<_Np == sizeof...(_Tp)>,
is_assignable<_Tp&, _Up>... is_assignable<_Tp&, _Up>...
>::value >::value
> > > >
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
tuple& operator=(array<_Up, _Np>&& __array) tuple& operator=(array<_Up, _Np>&& __array)
_NOEXCEPT_((_And<is_nothrow_assignable<_Tp&, _Up>...>::value)) _NOEXCEPT_((_And<is_nothrow_assignable<_Tp&, _Up>...>::value))
{ {
_VSTD::__memberwise_forward_assign(*this, _VSTD::move(__array), _VSTD::__memberwise_forward_assign(*this, _VSTD::move(__array),
__tuple_types<_If<true, _Up, _Tp>...>(), __tuple_types<_If<true, _Up, _Tp>...>(),
typename __make_tuple_indices<sizeof...(_Tp)>::type()); typename __make_tuple_indices<sizeof...(_Tp)>::type());
return *this; return *this;
} }
// [tuple.swap] // [tuple.swap]
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
void swap(tuple& __t) _NOEXCEPT_(__all<__is_nothrow_swappable<_Tp>::value...>::value) void swap(tuple& __t) _NOEXCEPT_(__all<__is_nothrow_swappable<_Tp>::value...>::value)
{__base_.swap(__t.__base_);} {__base_.swap(__t.__base_);}
#if _LIBCPP_STD_VER > 20 #if _LIBCPP_STD_VER > 20
_LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_HIDE_FROM_ABI constexpr
void swap(const tuple& __t) const noexcept(__all<is_nothrow_swappable_v<const _Tp&>...>::value) { void swap(const tuple& __t) const noexcept(__all<is_nothrow_swappable_v<const _Tp&>...>::value) {
__base_.swap(__t.__base_); __base_.swap(__t.__base_);
} }
#endif // _LIBCPP_STD_VER > 20 #endif // _LIBCPP_STD_VER > 20
}; };
template <> template <>
class _LIBCPP_TEMPLATE_VIS tuple<> class _LIBCPP_TEMPLATE_VIS tuple<>
{ {
public: public:
_LIBCPP_INLINE_VISIBILITY constexpr _LIBCPP_INLINE_VISIBILITY constexpr
tuple() _NOEXCEPT = default; tuple() _NOEXCEPT = default;
template <class _Alloc> template <class _Alloc>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
tuple(allocator_arg_t, const _Alloc&) _NOEXCEPT {} tuple(allocator_arg_t, const _Alloc&) _NOEXCEPT {}
template <class _Alloc> template <class _Alloc>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
tuple(allocator_arg_t, const _Alloc&, const tuple&) _NOEXCEPT {} tuple(allocator_arg_t, const _Alloc&, const tuple&) _NOEXCEPT {}
template <class _Up> template <class _Up>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
tuple(array<_Up, 0>) _NOEXCEPT {} tuple(array<_Up, 0>) _NOEXCEPT {}
template <class _Alloc, class _Up> template <class _Alloc, class _Up>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
tuple(allocator_arg_t, const _Alloc&, array<_Up, 0>) _NOEXCEPT {} tuple(allocator_arg_t, const _Alloc&, array<_Up, 0>) _NOEXCEPT {}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
void swap(tuple&) _NOEXCEPT {} void swap(tuple&) _NOEXCEPT {}
#if _LIBCPP_STD_VER > 20 #if _LIBCPP_STD_VER > 20
_LIBCPP_HIDE_FROM_ABI constexpr void swap(const tuple&) const noexcept {} _LIBCPP_HIDE_FROM_ABI constexpr void swap(const tuple&) const noexcept {}
#endif #endif
}; };
#if _LIBCPP_STD_VER > 20 #if _LIBCPP_STD_VER > 20
template <class... _TTypes, class... _UTypes, template<class> class _TQual, template<class> class _UQual> template <class... _TTypes, class... _UTypes, template<class> class _TQual, template<class> class _UQual>
Show All 18 Lines
tuple(allocator_arg_t, _Alloc, _Tp...) -> tuple<_Tp...>; tuple(allocator_arg_t, _Alloc, _Tp...) -> tuple<_Tp...>;
template <class _Alloc, class _Tp1, class _Tp2> template <class _Alloc, class _Tp1, class _Tp2>
tuple(allocator_arg_t, _Alloc, pair<_Tp1, _Tp2>) -> tuple<_Tp1, _Tp2>; tuple(allocator_arg_t, _Alloc, pair<_Tp1, _Tp2>) -> tuple<_Tp1, _Tp2>;
template <class _Alloc, class ..._Tp> template <class _Alloc, class ..._Tp>
tuple(allocator_arg_t, _Alloc, tuple<_Tp...>) -> tuple<_Tp...>; tuple(allocator_arg_t, _Alloc, tuple<_Tp...>) -> tuple<_Tp...>;
#endif #endif
template <class ..._Tp> template <class ..._Tp>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
__enable_if_t<__all<__is_swappable<_Tp>::value...>::value, void> __enable_if_t<__all<__is_swappable<_Tp>::value...>::value, void>
swap(tuple<_Tp...>& __t, tuple<_Tp...>& __u) swap(tuple<_Tp...>& __t, tuple<_Tp...>& __u)
_NOEXCEPT_(__all<__is_nothrow_swappable<_Tp>::value...>::value) _NOEXCEPT_(__all<__is_nothrow_swappable<_Tp>::value...>::value)
{__t.swap(__u);} {__t.swap(__u);}
#if _LIBCPP_STD_VER > 20 #if _LIBCPP_STD_VER > 20
template <class... _Tp> template <class... _Tp>
_LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_HIDE_FROM_ABI constexpr
enable_if_t<__all<is_swappable_v<const _Tp>...>::value, void> enable_if_t<__all<is_swappable_v<const _Tp>...>::value, void>
swap(const tuple<_Tp...>& __lhs, const tuple<_Tp...>& __rhs) swap(const tuple<_Tp...>& __lhs, const tuple<_Tp...>& __rhs)
noexcept(__all<is_nothrow_swappable_v<const _Tp>...>::value) { noexcept(__all<is_nothrow_swappable_v<const _Tp>...>::value) {
__lhs.swap(__rhs); __lhs.swap(__rhs);
} }
#endif #endif
// get // get
template <size_t _Ip, class ..._Tp> template <size_t _Ip, class ..._Tp>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
typename tuple_element<_Ip, tuple<_Tp...> >::type& typename tuple_element<_Ip, tuple<_Tp...> >::type&
get(tuple<_Tp...>& __t) _NOEXCEPT get(tuple<_Tp...>& __t) _NOEXCEPT
{ {
typedef _LIBCPP_NODEBUG typename tuple_element<_Ip, tuple<_Tp...> >::type type; typedef _LIBCPP_NODEBUG typename tuple_element<_Ip, tuple<_Tp...> >::type type;
return static_cast<__tuple_leaf<_Ip, type>&>(__t.__base_).get(); return static_cast<__tuple_leaf<_Ip, type>&>(__t.__base_).get();
} }
template <size_t _Ip, class ..._Tp> template <size_t _Ip, class ..._Tp>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
const typename tuple_element<_Ip, tuple<_Tp...> >::type& const typename tuple_element<_Ip, tuple<_Tp...> >::type&
get(const tuple<_Tp...>& __t) _NOEXCEPT get(const tuple<_Tp...>& __t) _NOEXCEPT
{ {
typedef _LIBCPP_NODEBUG typename tuple_element<_Ip, tuple<_Tp...> >::type type; typedef _LIBCPP_NODEBUG typename tuple_element<_Ip, tuple<_Tp...> >::type type;
return static_cast<const __tuple_leaf<_Ip, type>&>(__t.__base_).get(); return static_cast<const __tuple_leaf<_Ip, type>&>(__t.__base_).get();
} }
template <size_t _Ip, class ..._Tp> template <size_t _Ip, class ..._Tp>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
typename tuple_element<_Ip, tuple<_Tp...> >::type&& typename tuple_element<_Ip, tuple<_Tp...> >::type&&
get(tuple<_Tp...>&& __t) _NOEXCEPT get(tuple<_Tp...>&& __t) _NOEXCEPT
{ {
typedef _LIBCPP_NODEBUG typename tuple_element<_Ip, tuple<_Tp...> >::type type; typedef _LIBCPP_NODEBUG typename tuple_element<_Ip, tuple<_Tp...> >::type type;
return static_cast<type&&>( return static_cast<type&&>(
static_cast<__tuple_leaf<_Ip, type>&&>(__t.__base_).get()); static_cast<__tuple_leaf<_Ip, type>&&>(__t.__base_).get());
} }
template <size_t _Ip, class ..._Tp> template <size_t _Ip, class ..._Tp>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
const typename tuple_element<_Ip, tuple<_Tp...> >::type&& const typename tuple_element<_Ip, tuple<_Tp...> >::type&&
get(const tuple<_Tp...>&& __t) _NOEXCEPT get(const tuple<_Tp...>&& __t) _NOEXCEPT
{ {
typedef _LIBCPP_NODEBUG typename tuple_element<_Ip, tuple<_Tp...> >::type type; typedef _LIBCPP_NODEBUG typename tuple_element<_Ip, tuple<_Tp...> >::type type;
return static_cast<const type&&>( return static_cast<const type&&>(
static_cast<const __tuple_leaf<_Ip, type>&&>(__t.__base_).get()); static_cast<const __tuple_leaf<_Ip, type>&&>(__t.__base_).get());
} }
▲ Show 20 Lines • Show All 65 Lines • ▼ Show 20 Linesconstexpr _T1 const&& get(tuple<_Args...> const&& __tup) noexcept
return _VSTD::get<__find_exactly_one_t<_T1, _Args...>::value>(_VSTD::move(__tup)); return _VSTD::get<__find_exactly_one_t<_T1, _Args...>::value>(_VSTD::move(__tup));
} }
#endif #endif
// tie // tie
template <class ..._Tp> template <class ..._Tp>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
tuple<_Tp&...> tuple<_Tp&...>
tie(_Tp&... __t) _NOEXCEPT tie(_Tp&... __t) _NOEXCEPT
{ {
return tuple<_Tp&...>(__t...); return tuple<_Tp&...>(__t...);
} }
template <class _Up> template <class _Up>
struct __ignore_t struct __ignore_t
{ {
template <class _Tp> template <class _Tp>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
const __ignore_t& operator=(_Tp&&) const {return *this;} const __ignore_t& operator=(_Tp&&) const {return *this;}
}; };
namespace { namespace {
constexpr __ignore_t<unsigned char> ignore = __ignore_t<unsigned char>(); constexpr __ignore_t<unsigned char> ignore = __ignore_t<unsigned char>();
} // namespace } // namespace
template <class... _Tp> template <class... _Tp>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
tuple<typename __unwrap_ref_decay<_Tp>::type...> tuple<typename __unwrap_ref_decay<_Tp>::type...>
make_tuple(_Tp&&... __t) make_tuple(_Tp&&... __t)
{ {
return tuple<typename __unwrap_ref_decay<_Tp>::type...>(_VSTD::forward<_Tp>(__t)...); return tuple<typename __unwrap_ref_decay<_Tp>::type...>(_VSTD::forward<_Tp>(__t)...);
} }
template <class... _Tp> template <class... _Tp>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
tuple<_Tp&&...> tuple<_Tp&&...>
forward_as_tuple(_Tp&&... __t) _NOEXCEPT forward_as_tuple(_Tp&&... __t) _NOEXCEPT
{ {
return tuple<_Tp&&...>(_VSTD::forward<_Tp>(__t)...); return tuple<_Tp&&...>(_VSTD::forward<_Tp>(__t)...);
} }
template <size_t _Ip> template <size_t _Ip>
struct __tuple_equal struct __tuple_equal
{ {
template <class _Tp, class _Up> template <class _Tp, class _Up>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
bool operator()(const _Tp& __x, const _Up& __y) bool operator()(const _Tp& __x, const _Up& __y)
{ {
return __tuple_equal<_Ip - 1>()(__x, __y) && _VSTD::get<_Ip-1>(__x) == _VSTD::get<_Ip-1>(__y); return __tuple_equal<_Ip - 1>()(__x, __y) && _VSTD::get<_Ip-1>(__x) == _VSTD::get<_Ip-1>(__y);
} }
}; };
template <> template <>
struct __tuple_equal<0> struct __tuple_equal<0>
{ {
template <class _Tp, class _Up> template <class _Tp, class _Up>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
bool operator()(const _Tp&, const _Up&) bool operator()(const _Tp&, const _Up&)
{ {
return true; return true;
} }
}; };
template <class ..._Tp, class ..._Up> template <class ..._Tp, class ..._Up>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
bool bool
operator==(const tuple<_Tp...>& __x, const tuple<_Up...>& __y) operator==(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
{ {
static_assert (sizeof...(_Tp) == sizeof...(_Up), "Can't compare tuples of different sizes"); static_assert (sizeof...(_Tp) == sizeof...(_Up), "Can't compare tuples of different sizes");
return __tuple_equal<sizeof...(_Tp)>()(__x, __y); return __tuple_equal<sizeof...(_Tp)>()(__x, __y);
} }
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER > 17
Show All 16 Lines
operator<=>(const tuple<_Tp...>& __x, const tuple<_Up...>& __y) operator<=>(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
{ {
return _VSTD::__tuple_compare_three_way(__x, __y, index_sequence_for<_Tp...>{}); return _VSTD::__tuple_compare_three_way(__x, __y, index_sequence_for<_Tp...>{});
} }
#else // _LIBCPP_STD_VER > 17 #else // _LIBCPP_STD_VER > 17
template <class ..._Tp, class ..._Up> template <class ..._Tp, class ..._Up>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
bool bool
operator!=(const tuple<_Tp...>& __x, const tuple<_Up...>& __y) operator!=(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
{ {
return !(__x == __y); return !(__x == __y);
} }
template <size_t _Ip> template <size_t _Ip>
struct __tuple_less struct __tuple_less
{ {
template <class _Tp, class _Up> template <class _Tp, class _Up>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
bool operator()(const _Tp& __x, const _Up& __y) bool operator()(const _Tp& __x, const _Up& __y)
{ {
const size_t __idx = tuple_size<_Tp>::value - _Ip; const size_t __idx = tuple_size<_Tp>::value - _Ip;
if (_VSTD::get<__idx>(__x) < _VSTD::get<__idx>(__y)) if (_VSTD::get<__idx>(__x) < _VSTD::get<__idx>(__y))
return true; return true;
if (_VSTD::get<__idx>(__y) < _VSTD::get<__idx>(__x)) if (_VSTD::get<__idx>(__y) < _VSTD::get<__idx>(__x))
return false; return false;
return __tuple_less<_Ip-1>()(__x, __y); return __tuple_less<_Ip-1>()(__x, __y);
} }
}; };
template <> template <>
struct __tuple_less<0> struct __tuple_less<0>
{ {
template <class _Tp, class _Up> template <class _Tp, class _Up>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
bool operator()(const _Tp&, const _Up&) bool operator()(const _Tp&, const _Up&)
{ {
return false; return false;
} }
}; };
template <class ..._Tp, class ..._Up> template <class ..._Tp, class ..._Up>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
bool bool
operator<(const tuple<_Tp...>& __x, const tuple<_Up...>& __y) operator<(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
{ {
static_assert (sizeof...(_Tp) == sizeof...(_Up), "Can't compare tuples of different sizes"); static_assert (sizeof...(_Tp) == sizeof...(_Up), "Can't compare tuples of different sizes");
return __tuple_less<sizeof...(_Tp)>()(__x, __y); return __tuple_less<sizeof...(_Tp)>()(__x, __y);
} }
template <class ..._Tp, class ..._Up> template <class ..._Tp, class ..._Up>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
bool bool
operator>(const tuple<_Tp...>& __x, const tuple<_Up...>& __y) operator>(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
{ {
return __y < __x; return __y < __x;
} }
template <class ..._Tp, class ..._Up> template <class ..._Tp, class ..._Up>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
bool bool
operator>=(const tuple<_Tp...>& __x, const tuple<_Up...>& __y) operator>=(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
{ {
return !(__x < __y); return !(__x < __y);
} }
template <class ..._Tp, class ..._Up> template <class ..._Tp, class ..._Up>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
bool bool
operator<=(const tuple<_Tp...>& __x, const tuple<_Up...>& __y) operator<=(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
{ {
return !(__y < __x); return !(__y < __x);
} }
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER > 17
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 Lines
}; };
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_AFTER_CXX11 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_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;
Show All 30 Lines
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>
struct __tuple_cat<tuple<_Types...>, __tuple_indices<_I0...>, __tuple_indices<_J0...> > struct __tuple_cat<tuple<_Types...>, __tuple_indices<_I0...>, __tuple_indices<_J0...> >
{ {
template <class _Tuple0> template <class _Tuple0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX14
typename __tuple_cat_return_ref<tuple<_Types...>&&, _Tuple0&&>::type typename __tuple_cat_return_ref<tuple<_Types...>&&, _Tuple0&&>::type
operator()(tuple<_Types...> __t, _Tuple0&& __t0) operator()(tuple<_Types...> __t, _Tuple0&& __t0)
{ {
(void)__t; // avoid unused parameter warning on GCC when _I0 is empty (void)__t; // avoid unused parameter warning on GCC when _I0 is empty
return _VSTD::forward_as_tuple( return _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))...);
} }
template <class _Tuple0, class _Tuple1, class ..._Tuples> template <class _Tuple0, class _Tuple1, class ..._Tuples>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_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 typename remove_reference<_Tuple0>::type _T0;
typedef _LIBCPP_NODEBUG typename remove_reference<_Tuple1>::type _T1; typedef _LIBCPP_NODEBUG typename remove_reference<_Tuple1>::type _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_AFTER_CXX11 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_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 typename remove_reference<_Tuple0>::type _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>
: true_type {}; : true_type {};
template <class _T1, class _T2> template <class _T1, class _T2>
template <class... _Args1, class... _Args2, size_t ..._I1, size_t ..._I2> template <class... _Args1, class... _Args2, size_t ..._I1, size_t ..._I2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
pair<_T1, _T2>::pair(piecewise_construct_t, pair<_T1, _T2>::pair(piecewise_construct_t,
tuple<_Args1...>& __first_args, tuple<_Args2...>& __second_args, tuple<_Args1...>& __first_args, tuple<_Args2...>& __second_args,
__tuple_indices<_I1...>, __tuple_indices<_I2...>) __tuple_indices<_I1...>, __tuple_indices<_I2...>)
: first(_VSTD::forward<_Args1>(_VSTD::get<_I1>( __first_args))...), : first(_VSTD::forward<_Args1>(_VSTD::get<_I1>( __first_args))...),
second(_VSTD::forward<_Args2>(_VSTD::get<_I2>(__second_args))...) second(_VSTD::forward<_Args2>(_VSTD::get<_I2>(__second_args))...)
{ {
} }
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

libcxx/include/type_traits

Show First 20 Lines • Show All 598 Lines • ▼ Show 20 Lines
using __swap_result_t = typename enable_if<is_move_constructible<_Tp>::value && is_move_assignable<_Tp>::value>::type; using __swap_result_t = typename enable_if<is_move_constructible<_Tp>::value && is_move_assignable<_Tp>::value>::type;
#else #else
template <class> template <class>
using __swap_result_t = void; using __swap_result_t = void;
#endif #endif
template <class _Tp> template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR_AFTER_CXX17 __swap_result_t<_Tp> _LIBCPP_CONSTEXPR_CXX20 __swap_result_t<_Tp>
swap(_Tp& __x, _Tp& __y) _NOEXCEPT_(is_nothrow_move_constructible<_Tp>::value && swap(_Tp& __x, _Tp& __y) _NOEXCEPT_(is_nothrow_move_constructible<_Tp>::value &&
is_nothrow_move_assignable<_Tp>::value); is_nothrow_move_assignable<_Tp>::value);
template<class _Tp, size_t _Np> template<class _Tp, size_t _Np>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
typename enable_if< typename enable_if<
__is_swappable<_Tp>::value __is_swappable<_Tp>::value
>::type >::type
swap(_Tp (&__a)[_Np], _Tp (&__b)[_Np]) _NOEXCEPT_(__is_nothrow_swappable<_Tp>::value); swap(_Tp (&__a)[_Np], _Tp (&__b)[_Np]) _NOEXCEPT_(__is_nothrow_swappable<_Tp>::value);
namespace __detail namespace __detail
{ {
// ALL generic swap overloads MUST already have a declaration available at this point. // ALL generic swap overloads MUST already have a declaration available at this point.
▲ Show 20 Lines • Show All 190 Lines • Show Last 20 Lines

libcxx/include/vector

Show First 20 Lines • Show All 354 Lines • ▼ Show 20 Linespublic:
typedef __wrap_iter<pointer> iterator; typedef __wrap_iter<pointer> iterator;
typedef __wrap_iter<const_pointer> const_iterator; typedef __wrap_iter<const_pointer> const_iterator;
typedef _VSTD::reverse_iterator<iterator> reverse_iterator; typedef _VSTD::reverse_iterator<iterator> reverse_iterator;
typedef _VSTD::reverse_iterator<const_iterator> const_reverse_iterator; typedef _VSTD::reverse_iterator<const_iterator> const_reverse_iterator;
static_assert((is_same<typename allocator_type::value_type, value_type>::value), static_assert((is_same<typename allocator_type::value_type, value_type>::value),
"Allocator::value_type must be same type as value_type"); "Allocator::value_type must be same type as value_type");
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY
vector() _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value) vector() _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value)
{ {
_VSTD::__debug_db_insert_c(this); _VSTD::__debug_db_insert_c(this);
} }
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY explicit vector(const allocator_type& __a) _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY explicit vector(const allocator_type& __a)
#if _LIBCPP_STD_VER <= 14 #if _LIBCPP_STD_VER <= 14
_NOEXCEPT_(is_nothrow_copy_constructible<allocator_type>::value) _NOEXCEPT_(is_nothrow_copy_constructible<allocator_type>::value)
#else #else
_NOEXCEPT _NOEXCEPT
#endif #endif
: __end_cap_(nullptr, __a) : __end_cap_(nullptr, __a)
{ {
_VSTD::__debug_db_insert_c(this); _VSTD::__debug_db_insert_c(this);
} }
_LIBCPP_CONSTEXPR_AFTER_CXX17 explicit vector(size_type __n); _LIBCPP_CONSTEXPR_CXX20 explicit vector(size_type __n);
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER > 11
_LIBCPP_CONSTEXPR_AFTER_CXX17 explicit vector(size_type __n, const allocator_type& __a); _LIBCPP_CONSTEXPR_CXX20 explicit vector(size_type __n, const allocator_type& __a);
#endif #endif
_LIBCPP_CONSTEXPR_AFTER_CXX17 vector(size_type __n, const value_type& __x); _LIBCPP_CONSTEXPR_CXX20 vector(size_type __n, const value_type& __x);
template <class = __enable_if_t<__is_allocator<_Allocator>::value> > template <class = __enable_if_t<__is_allocator<_Allocator>::value> >
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
vector(size_type __n, const value_type& __x, const allocator_type& __a) vector(size_type __n, const value_type& __x, const allocator_type& __a)
: __end_cap_(nullptr, __a) : __end_cap_(nullptr, __a)
{ {
_VSTD::__debug_db_insert_c(this); _VSTD::__debug_db_insert_c(this);
if (__n > 0) if (__n > 0)
{ {
__vallocate(__n); __vallocate(__n);
__construct_at_end(__n, __x); __construct_at_end(__n, __x);
} }
} }
template <class _InputIterator> template <class _InputIterator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
vector(_InputIterator __first, vector(_InputIterator __first,
typename enable_if<__is_exactly_cpp17_input_iterator<_InputIterator>::value && typename enable_if<__is_exactly_cpp17_input_iterator<_InputIterator>::value &&
is_constructible< is_constructible<
value_type, value_type,
typename iterator_traits<_InputIterator>::reference>::value, typename iterator_traits<_InputIterator>::reference>::value,
_InputIterator>::type __last); _InputIterator>::type __last);
template <class _InputIterator> template <class _InputIterator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
vector(_InputIterator __first, _InputIterator __last, const allocator_type& __a, vector(_InputIterator __first, _InputIterator __last, const allocator_type& __a,
typename enable_if<__is_exactly_cpp17_input_iterator<_InputIterator>::value && typename enable_if<__is_exactly_cpp17_input_iterator<_InputIterator>::value &&
is_constructible< is_constructible<
value_type, value_type,
typename iterator_traits<_InputIterator>::reference>::value>::type* = 0); typename iterator_traits<_InputIterator>::reference>::value>::type* = 0);
template <class _ForwardIterator> template <class _ForwardIterator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
vector(_ForwardIterator __first, vector(_ForwardIterator __first,
typename enable_if<__is_cpp17_forward_iterator<_ForwardIterator>::value && typename enable_if<__is_cpp17_forward_iterator<_ForwardIterator>::value &&
is_constructible< is_constructible<
value_type, value_type,
typename iterator_traits<_ForwardIterator>::reference>::value, typename iterator_traits<_ForwardIterator>::reference>::value,
_ForwardIterator>::type __last); _ForwardIterator>::type __last);
template <class _ForwardIterator> template <class _ForwardIterator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
vector(_ForwardIterator __first, _ForwardIterator __last, const allocator_type& __a, vector(_ForwardIterator __first, _ForwardIterator __last, const allocator_type& __a,
typename enable_if<__is_cpp17_forward_iterator<_ForwardIterator>::value && typename enable_if<__is_cpp17_forward_iterator<_ForwardIterator>::value &&
is_constructible< is_constructible<
value_type, value_type,
typename iterator_traits<_ForwardIterator>::reference>::value>::type* = 0); typename iterator_traits<_ForwardIterator>::reference>::value>::type* = 0);
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY
~vector() ~vector()
{ {
__annotate_delete(); __annotate_delete();
std::__debug_db_erase_c(this); std::__debug_db_erase_c(this);
if (this->__begin_ != nullptr) if (this->__begin_ != nullptr)
{ {
__clear(); __clear();
__alloc_traits::deallocate(__alloc(), this->__begin_, capacity()); __alloc_traits::deallocate(__alloc(), this->__begin_, capacity());
} }
} }
_LIBCPP_CONSTEXPR_AFTER_CXX17 vector(const vector& __x); _LIBCPP_CONSTEXPR_CXX20 vector(const vector& __x);
_LIBCPP_CONSTEXPR_AFTER_CXX17 vector(const vector& __x, const __type_identity_t<allocator_type>& __a); _LIBCPP_CONSTEXPR_CXX20 vector(const vector& __x, const __type_identity_t<allocator_type>& __a);
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY
vector& operator=(const vector& __x); vector& operator=(const vector& __x);
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY
vector(initializer_list<value_type> __il); vector(initializer_list<value_type> __il);
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY
vector(initializer_list<value_type> __il, const allocator_type& __a); vector(initializer_list<value_type> __il, const allocator_type& __a);
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY
vector& operator=(initializer_list<value_type> __il) vector& operator=(initializer_list<value_type> __il)
{assign(__il.begin(), __il.end()); return *this;} {assign(__il.begin(), __il.end()); return *this;}
#endif // !_LIBCPP_CXX03_LANG #endif // !_LIBCPP_CXX03_LANG
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY
vector(vector&& __x) vector(vector&& __x)
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER > 14
noexcept; noexcept;
#else #else
_NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value); _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value);
#endif #endif
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY
vector(vector&& __x, const __type_identity_t<allocator_type>& __a); vector(vector&& __x, const __type_identity_t<allocator_type>& __a);
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY
vector& operator=(vector&& __x) vector& operator=(vector&& __x)
_NOEXCEPT_((__noexcept_move_assign_container<_Allocator, __alloc_traits>::value)); _NOEXCEPT_((__noexcept_move_assign_container<_Allocator, __alloc_traits>::value));
template <class _InputIterator> template <class _InputIterator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 typename enable_if <__is_exactly_cpp17_input_iterator<_InputIterator>::value && _LIBCPP_CONSTEXPR_CXX20 typename enable_if <__is_exactly_cpp17_input_iterator<_InputIterator>::value &&
is_constructible< is_constructible<
value_type, value_type,
typename iterator_traits<_InputIterator>::reference>::value, typename iterator_traits<_InputIterator>::reference>::value,
void void
>::type >::type
assign(_InputIterator __first, _InputIterator __last); assign(_InputIterator __first, _InputIterator __last);
template <class _ForwardIterator> template <class _ForwardIterator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
typename enable_if typename enable_if
< <
__is_cpp17_forward_iterator<_ForwardIterator>::value && __is_cpp17_forward_iterator<_ForwardIterator>::value &&
is_constructible< is_constructible<
value_type, value_type,
typename iterator_traits<_ForwardIterator>::reference>::value, typename iterator_traits<_ForwardIterator>::reference>::value,
void void
>::type >::type
assign(_ForwardIterator __first, _ForwardIterator __last); assign(_ForwardIterator __first, _ForwardIterator __last);
_LIBCPP_CONSTEXPR_AFTER_CXX17 void assign(size_type __n, const_reference __u); _LIBCPP_CONSTEXPR_CXX20 void assign(size_type __n, const_reference __u);
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY
void assign(initializer_list<value_type> __il) void assign(initializer_list<value_type> __il)
{assign(__il.begin(), __il.end());} {assign(__il.begin(), __il.end());}
#endif #endif
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY
allocator_type get_allocator() const _NOEXCEPT allocator_type get_allocator() const _NOEXCEPT
{return this->__alloc();} {return this->__alloc();}
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY iterator begin() _NOEXCEPT; _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY iterator begin() _NOEXCEPT;
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY const_iterator begin() const _NOEXCEPT; _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY const_iterator begin() const _NOEXCEPT;
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY iterator end() _NOEXCEPT; _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY iterator end() _NOEXCEPT;
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY const_iterator end() const _NOEXCEPT; _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY const_iterator end() const _NOEXCEPT;
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY
reverse_iterator rbegin() _NOEXCEPT reverse_iterator rbegin() _NOEXCEPT
{return reverse_iterator(end());} {return reverse_iterator(end());}
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY
const_reverse_iterator rbegin() const _NOEXCEPT const_reverse_iterator rbegin() const _NOEXCEPT
{return const_reverse_iterator(end());} {return const_reverse_iterator(end());}
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY
reverse_iterator rend() _NOEXCEPT reverse_iterator rend() _NOEXCEPT
{return reverse_iterator(begin());} {return reverse_iterator(begin());}
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY
const_reverse_iterator rend() const _NOEXCEPT const_reverse_iterator rend() const _NOEXCEPT
{return const_reverse_iterator(begin());} {return const_reverse_iterator(begin());}
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY
const_iterator cbegin() const _NOEXCEPT const_iterator cbegin() const _NOEXCEPT
{return begin();} {return begin();}
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY
const_iterator cend() const _NOEXCEPT const_iterator cend() const _NOEXCEPT
{return end();} {return end();}
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY
const_reverse_iterator crbegin() const _NOEXCEPT const_reverse_iterator crbegin() const _NOEXCEPT
{return rbegin();} {return rbegin();}
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY
const_reverse_iterator crend() const _NOEXCEPT const_reverse_iterator crend() const _NOEXCEPT
{return rend();} {return rend();}
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY
size_type size() const _NOEXCEPT size_type size() const _NOEXCEPT
{return static_cast<size_type>(this->__end_ - this->__begin_);} {return static_cast<size_type>(this->__end_ - this->__begin_);}
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY
size_type capacity() const _NOEXCEPT size_type capacity() const _NOEXCEPT
{return static_cast<size_type>(__end_cap() - this->__begin_);} {return static_cast<size_type>(__end_cap() - this->__begin_);}
_LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY
bool empty() const _NOEXCEPT bool empty() const _NOEXCEPT
{return this->__begin_ == this->__end_;} {return this->__begin_ == this->__end_;}
_LIBCPP_CONSTEXPR_AFTER_CXX17 size_type max_size() const _NOEXCEPT; _LIBCPP_CONSTEXPR_CXX20 size_type max_size() const _NOEXCEPT;
_LIBCPP_CONSTEXPR_AFTER_CXX17 void reserve(size_type __n); _LIBCPP_CONSTEXPR_CXX20 void reserve(size_type __n);
_LIBCPP_CONSTEXPR_AFTER_CXX17 void shrink_to_fit() _NOEXCEPT; _LIBCPP_CONSTEXPR_CXX20 void shrink_to_fit() _NOEXCEPT;
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY reference operator[](size_type __n) _NOEXCEPT; _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY reference operator[](size_type __n) _NOEXCEPT;
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY const_reference operator[](size_type __n) const _NOEXCEPT; _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY const_reference operator[](size_type __n) const _NOEXCEPT;
_LIBCPP_CONSTEXPR_AFTER_CXX17 reference at(size_type __n); _LIBCPP_CONSTEXPR_CXX20 reference at(size_type __n);
_LIBCPP_CONSTEXPR_AFTER_CXX17 const_reference at(size_type __n) const; _LIBCPP_CONSTEXPR_CXX20 const_reference at(size_type __n) const;
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY reference front() _NOEXCEPT _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY reference front() _NOEXCEPT
{ {
_LIBCPP_ASSERT(!empty(), "front() called on an empty vector"); _LIBCPP_ASSERT(!empty(), "front() called on an empty vector");
return *this->__begin_; return *this->__begin_;
} }
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY const_reference front() const _NOEXCEPT _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY const_reference front() const _NOEXCEPT
{ {
_LIBCPP_ASSERT(!empty(), "front() called on an empty vector"); _LIBCPP_ASSERT(!empty(), "front() called on an empty vector");
return *this->__begin_; return *this->__begin_;
} }
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY reference back() _NOEXCEPT _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY reference back() _NOEXCEPT
{ {
_LIBCPP_ASSERT(!empty(), "back() called on an empty vector"); _LIBCPP_ASSERT(!empty(), "back() called on an empty vector");
return *(this->__end_ - 1); return *(this->__end_ - 1);
} }
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY const_reference back() const _NOEXCEPT _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY const_reference back() const _NOEXCEPT
{ {
_LIBCPP_ASSERT(!empty(), "back() called on an empty vector"); _LIBCPP_ASSERT(!empty(), "back() called on an empty vector");
return *(this->__end_ - 1); return *(this->__end_ - 1);
} }
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY
value_type* data() _NOEXCEPT value_type* data() _NOEXCEPT
{return _VSTD::__to_address(this->__begin_);} {return _VSTD::__to_address(this->__begin_);}
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY
const value_type* data() const _NOEXCEPT const value_type* data() const _NOEXCEPT
{return _VSTD::__to_address(this->__begin_);} {return _VSTD::__to_address(this->__begin_);}
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY void push_back(const_reference __x); _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY void push_back(const_reference __x);
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY void push_back(value_type&& __x); _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY void push_back(value_type&& __x);
template <class... _Args> template <class... _Args>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER > 14
reference emplace_back(_Args&&... __args); reference emplace_back(_Args&&... __args);
#else #else
void emplace_back(_Args&&... __args); void emplace_back(_Args&&... __args);
#endif #endif
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY
void pop_back(); void pop_back();
_LIBCPP_CONSTEXPR_AFTER_CXX17 iterator insert(const_iterator __position, const_reference __x); _LIBCPP_CONSTEXPR_CXX20 iterator insert(const_iterator __position, const_reference __x);
_LIBCPP_CONSTEXPR_AFTER_CXX17 iterator insert(const_iterator __position, value_type&& __x); _LIBCPP_CONSTEXPR_CXX20 iterator insert(const_iterator __position, value_type&& __x);
template <class... _Args> template <class... _Args>
_LIBCPP_CONSTEXPR_AFTER_CXX17 iterator emplace(const_iterator __position, _Args&&... __args); _LIBCPP_CONSTEXPR_CXX20 iterator emplace(const_iterator __position, _Args&&... __args);
_LIBCPP_CONSTEXPR_AFTER_CXX17 iterator insert(const_iterator __position, size_type __n, const_reference __x); _LIBCPP_CONSTEXPR_CXX20 iterator insert(const_iterator __position, size_type __n, const_reference __x);
template <class _InputIterator> template <class _InputIterator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 typename enable_if <__is_exactly_cpp17_input_iterator<_InputIterator>::value && _LIBCPP_CONSTEXPR_CXX20 typename enable_if <__is_exactly_cpp17_input_iterator<_InputIterator>::value &&
is_constructible< is_constructible<
value_type, value_type,
typename iterator_traits<_InputIterator>::reference>::value, typename iterator_traits<_InputIterator>::reference>::value,
iterator iterator
>::type >::type
insert(const_iterator __position, _InputIterator __first, _InputIterator __last); insert(const_iterator __position, _InputIterator __first, _InputIterator __last);
template <class _ForwardIterator> template <class _ForwardIterator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
typename enable_if typename enable_if
< <
__is_cpp17_forward_iterator<_ForwardIterator>::value && __is_cpp17_forward_iterator<_ForwardIterator>::value &&
is_constructible< is_constructible<
value_type, value_type,
typename iterator_traits<_ForwardIterator>::reference>::value, typename iterator_traits<_ForwardIterator>::reference>::value,
iterator iterator
>::type >::type
insert(const_iterator __position, _ForwardIterator __first, _ForwardIterator __last); insert(const_iterator __position, _ForwardIterator __first, _ForwardIterator __last);
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY
iterator insert(const_iterator __position, initializer_list<value_type> __il) iterator insert(const_iterator __position, initializer_list<value_type> __il)
{return insert(__position, __il.begin(), __il.end());} {return insert(__position, __il.begin(), __il.end());}
#endif #endif
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY iterator erase(const_iterator __position); _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY iterator erase(const_iterator __position);
_LIBCPP_CONSTEXPR_AFTER_CXX17 iterator erase(const_iterator __first, const_iterator __last); _LIBCPP_CONSTEXPR_CXX20 iterator erase(const_iterator __first, const_iterator __last);
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY
void clear() _NOEXCEPT void clear() _NOEXCEPT
{ {
size_type __old_size = size(); size_type __old_size = size();
__clear(); __clear();
__annotate_shrink(__old_size); __annotate_shrink(__old_size);
std::__debug_db_invalidate_all(this); std::__debug_db_invalidate_all(this);
} }
_LIBCPP_CONSTEXPR_AFTER_CXX17 void resize(size_type __sz); _LIBCPP_CONSTEXPR_CXX20 void resize(size_type __sz);
_LIBCPP_CONSTEXPR_AFTER_CXX17 void resize(size_type __sz, const_reference __x); _LIBCPP_CONSTEXPR_CXX20 void resize(size_type __sz, const_reference __x);
_LIBCPP_CONSTEXPR_AFTER_CXX17 void swap(vector&) _LIBCPP_CONSTEXPR_CXX20 void swap(vector&)
#if _LIBCPP_STD_VER >= 14 #if _LIBCPP_STD_VER >= 14
_NOEXCEPT; _NOEXCEPT;
#else #else
_NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value || _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value ||
__is_nothrow_swappable<allocator_type>::value); __is_nothrow_swappable<allocator_type>::value);
#endif #endif
_LIBCPP_CONSTEXPR_AFTER_CXX17 bool __invariants() const; _LIBCPP_CONSTEXPR_CXX20 bool __invariants() const;
#ifdef _LIBCPP_ENABLE_DEBUG_MODE #ifdef _LIBCPP_ENABLE_DEBUG_MODE
bool __dereferenceable(const const_iterator* __i) const; bool __dereferenceable(const const_iterator* __i) const;
bool __decrementable(const const_iterator* __i) const; bool __decrementable(const const_iterator* __i) const;
bool __addable(const const_iterator* __i, ptrdiff_t __n) const; bool __addable(const const_iterator* __i, ptrdiff_t __n) const;
bool __subscriptable(const const_iterator* __i, ptrdiff_t __n) const; bool __subscriptable(const const_iterator* __i, ptrdiff_t __n) const;
Show All 9 Linesprivate:
// Allocate space for __n objects // Allocate space for __n objects
// throws length_error if __n > max_size() // throws length_error if __n > max_size()
// throws (probably bad_alloc) if memory run out // throws (probably bad_alloc) if memory run out
// Precondition: __begin_ == __end_ == __end_cap() == 0 // Precondition: __begin_ == __end_ == __end_cap() == 0
// Precondition: __n > 0 // Precondition: __n > 0
// Postcondition: capacity() >= __n // Postcondition: capacity() >= __n
// Postcondition: size() == 0 // Postcondition: size() == 0
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI void __vallocate(size_type __n) { _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_HIDE_FROM_ABI void __vallocate(size_type __n) {
if (__n > max_size()) if (__n > max_size())
__throw_length_error(); __throw_length_error();
auto __allocation = std::__allocate_at_least(__alloc(), __n); auto __allocation = std::__allocate_at_least(__alloc(), __n);
__begin_ = __allocation.ptr; __begin_ = __allocation.ptr;
__end_ = __allocation.ptr; __end_ = __allocation.ptr;
__end_cap() = __begin_ + __allocation.count; __end_cap() = __begin_ + __allocation.count;
__annotate_new(0); __annotate_new(0);
} }
_LIBCPP_CONSTEXPR_AFTER_CXX17 void __vdeallocate() _NOEXCEPT; _LIBCPP_CONSTEXPR_CXX20 void __vdeallocate() _NOEXCEPT;
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY size_type __recommend(size_type __new_size) const; _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY size_type __recommend(size_type __new_size) const;
_LIBCPP_CONSTEXPR_AFTER_CXX17 void __construct_at_end(size_type __n); _LIBCPP_CONSTEXPR_CXX20 void __construct_at_end(size_type __n);
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY
void __construct_at_end(size_type __n, const_reference __x); void __construct_at_end(size_type __n, const_reference __x);
template <class _ForwardIterator> template <class _ForwardIterator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
typename enable_if typename enable_if
< <
__is_cpp17_forward_iterator<_ForwardIterator>::value, __is_cpp17_forward_iterator<_ForwardIterator>::value,
void void
>::type >::type
__construct_at_end(_ForwardIterator __first, _ForwardIterator __last, size_type __n); __construct_at_end(_ForwardIterator __first, _ForwardIterator __last, size_type __n);
_LIBCPP_CONSTEXPR_AFTER_CXX17 void __append(size_type __n); _LIBCPP_CONSTEXPR_CXX20 void __append(size_type __n);
_LIBCPP_CONSTEXPR_AFTER_CXX17 void __append(size_type __n, const_reference __x); _LIBCPP_CONSTEXPR_CXX20 void __append(size_type __n, const_reference __x);
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY
iterator __make_iter(pointer __p) _NOEXCEPT; iterator __make_iter(pointer __p) _NOEXCEPT;
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY
const_iterator __make_iter(const_pointer __p) const _NOEXCEPT; const_iterator __make_iter(const_pointer __p) const _NOEXCEPT;
_LIBCPP_CONSTEXPR_AFTER_CXX17 void __swap_out_circular_buffer(__split_buffer<value_type, allocator_type&>& __v); _LIBCPP_CONSTEXPR_CXX20 void __swap_out_circular_buffer(__split_buffer<value_type, allocator_type&>& __v);
_LIBCPP_CONSTEXPR_AFTER_CXX17 pointer __swap_out_circular_buffer(__split_buffer<value_type, allocator_type&>& __v, pointer __p); _LIBCPP_CONSTEXPR_CXX20 pointer __swap_out_circular_buffer(__split_buffer<value_type, allocator_type&>& __v, pointer __p);
_LIBCPP_CONSTEXPR_AFTER_CXX17 void __move_range(pointer __from_s, pointer __from_e, pointer __to); _LIBCPP_CONSTEXPR_CXX20 void __move_range(pointer __from_s, pointer __from_e, pointer __to);
_LIBCPP_CONSTEXPR_AFTER_CXX17 void __move_assign(vector& __c, true_type) _LIBCPP_CONSTEXPR_CXX20 void __move_assign(vector& __c, true_type)
_NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value); _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value);
_LIBCPP_CONSTEXPR_AFTER_CXX17 void __move_assign(vector& __c, false_type) _LIBCPP_CONSTEXPR_CXX20 void __move_assign(vector& __c, false_type)
_NOEXCEPT_(__alloc_traits::is_always_equal::value); _NOEXCEPT_(__alloc_traits::is_always_equal::value);
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY
void __destruct_at_end(pointer __new_last) _NOEXCEPT void __destruct_at_end(pointer __new_last) _NOEXCEPT
{ {
if (!__libcpp_is_constant_evaluated()) if (!__libcpp_is_constant_evaluated())
__invalidate_iterators_past(__new_last); __invalidate_iterators_past(__new_last);
size_type __old_size = size(); size_type __old_size = size();
__base_destruct_at_end(__new_last); __base_destruct_at_end(__new_last);
__annotate_shrink(__old_size); __annotate_shrink(__old_size);
} }
template <class _Up> template <class _Up>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY
inline void __push_back_slow_path(_Up&& __x); inline void __push_back_slow_path(_Up&& __x);
template <class... _Args> template <class... _Args>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY
inline void __emplace_back_slow_path(_Args&&... __args); inline void __emplace_back_slow_path(_Args&&... __args);
// The following functions are no-ops outside of AddressSanitizer mode. // The following functions are no-ops outside of AddressSanitizer mode.
// We call annotatations only for the default Allocator because other allocators // We call annotatations only for the default Allocator because other allocators
// may not meet the AddressSanitizer alignment constraints. // may not meet the AddressSanitizer alignment constraints.
// See the documentation for __sanitizer_annotate_contiguous_container for more details. // See the documentation for __sanitizer_annotate_contiguous_container for more details.
#ifndef _LIBCPP_HAS_NO_ASAN #ifndef _LIBCPP_HAS_NO_ASAN
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
void __annotate_contiguous_container(const void *__beg, const void *__end, void __annotate_contiguous_container(const void *__beg, const void *__end,
const void *__old_mid, const void *__old_mid,
const void *__new_mid) const const void *__new_mid) const
{ {
if (!__libcpp_is_constant_evaluated() && __beg && is_same<allocator_type, __default_allocator_type>::value) if (!__libcpp_is_constant_evaluated() && __beg && is_same<allocator_type, __default_allocator_type>::value)
__sanitizer_annotate_contiguous_container(__beg, __end, __old_mid, __new_mid); __sanitizer_annotate_contiguous_container(__beg, __end, __old_mid, __new_mid);
} }
#else #else
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY
void __annotate_contiguous_container(const void*, const void*, const void*, void __annotate_contiguous_container(const void*, const void*, const void*,
const void*) const _NOEXCEPT {} const void*) const _NOEXCEPT {}
#endif #endif
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY
void __annotate_new(size_type __current_size) const _NOEXCEPT { void __annotate_new(size_type __current_size) const _NOEXCEPT {
__annotate_contiguous_container(data(), data() + capacity(), __annotate_contiguous_container(data(), data() + capacity(),
data() + capacity(), data() + __current_size); data() + capacity(), data() + __current_size);
} }
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY
void __annotate_delete() const _NOEXCEPT { void __annotate_delete() const _NOEXCEPT {
__annotate_contiguous_container(data(), data() + capacity(), __annotate_contiguous_container(data(), data() + capacity(),
data() + size(), data() + capacity()); data() + size(), data() + capacity());
} }
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY
void __annotate_increase(size_type __n) const _NOEXCEPT void __annotate_increase(size_type __n) const _NOEXCEPT
{ {
__annotate_contiguous_container(data(), data() + capacity(), __annotate_contiguous_container(data(), data() + capacity(),
data() + size(), data() + size() + __n); data() + size(), data() + size() + __n);
} }
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY
void __annotate_shrink(size_type __old_size) const _NOEXCEPT void __annotate_shrink(size_type __old_size) const _NOEXCEPT
{ {
__annotate_contiguous_container(data(), data() + capacity(), __annotate_contiguous_container(data(), data() + capacity(),
data() + __old_size, data() + size()); data() + __old_size, data() + size());
} }
struct _ConstructTransaction { struct _ConstructTransaction {
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
explicit _ConstructTransaction(vector &__v, size_type __n) explicit _ConstructTransaction(vector &__v, size_type __n)
: __v_(__v), __pos_(__v.__end_), __new_end_(__v.__end_ + __n) { : __v_(__v), __pos_(__v.__end_), __new_end_(__v.__end_ + __n) {
#ifndef _LIBCPP_HAS_NO_ASAN #ifndef _LIBCPP_HAS_NO_ASAN
__v_.__annotate_increase(__n); __v_.__annotate_increase(__n);
#endif #endif
} }
_LIBCPP_CONSTEXPR_AFTER_CXX17 ~_ConstructTransaction() { _LIBCPP_CONSTEXPR_CXX20 ~_ConstructTransaction() {
__v_.__end_ = __pos_; __v_.__end_ = __pos_;
#ifndef _LIBCPP_HAS_NO_ASAN #ifndef _LIBCPP_HAS_NO_ASAN
if (__pos_ != __new_end_) { if (__pos_ != __new_end_) {
__v_.__annotate_shrink(__new_end_ - __v_.__begin_); __v_.__annotate_shrink(__new_end_ - __v_.__begin_);
} }
#endif #endif
} }
vector &__v_; vector &__v_;
pointer __pos_; pointer __pos_;
const_pointer const __new_end_; const_pointer const __new_end_;
private: private:
_ConstructTransaction(_ConstructTransaction const&) = delete; _ConstructTransaction(_ConstructTransaction const&) = delete;
_ConstructTransaction& operator=(_ConstructTransaction const&) = delete; _ConstructTransaction& operator=(_ConstructTransaction const&) = delete;
}; };
template <class ..._Args> template <class ..._Args>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY
void __construct_one_at_end(_Args&& ...__args) { void __construct_one_at_end(_Args&& ...__args) {
_ConstructTransaction __tx(*this, 1); _ConstructTransaction __tx(*this, 1);
__alloc_traits::construct(this->__alloc(), _VSTD::__to_address(__tx.__pos_), __alloc_traits::construct(this->__alloc(), _VSTD::__to_address(__tx.__pos_),
_VSTD::forward<_Args>(__args)...); _VSTD::forward<_Args>(__args)...);
++__tx.__pos_; ++__tx.__pos_;
} }
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY
allocator_type& __alloc() _NOEXCEPT allocator_type& __alloc() _NOEXCEPT
{return this->__end_cap_.second();} {return this->__end_cap_.second();}
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY
const allocator_type& __alloc() const _NOEXCEPT const allocator_type& __alloc() const _NOEXCEPT
{return this->__end_cap_.second();} {return this->__end_cap_.second();}
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY
pointer& __end_cap() _NOEXCEPT pointer& __end_cap() _NOEXCEPT
{return this->__end_cap_.first();} {return this->__end_cap_.first();}
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY
const pointer& __end_cap() const _NOEXCEPT const pointer& __end_cap() const _NOEXCEPT
{return this->__end_cap_.first();} {return this->__end_cap_.first();}
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY
void __clear() _NOEXCEPT {__base_destruct_at_end(this->__begin_);} void __clear() _NOEXCEPT {__base_destruct_at_end(this->__begin_);}
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY
void __base_destruct_at_end(pointer __new_last) _NOEXCEPT { void __base_destruct_at_end(pointer __new_last) _NOEXCEPT {
pointer __soon_to_be_end = this->__end_; pointer __soon_to_be_end = this->__end_;
while (__new_last != __soon_to_be_end) while (__new_last != __soon_to_be_end)
__alloc_traits::destroy(__alloc(), _VSTD::__to_address(--__soon_to_be_end)); __alloc_traits::destroy(__alloc(), _VSTD::__to_address(--__soon_to_be_end));
this->__end_ = __new_last; this->__end_ = __new_last;
} }
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY
void __copy_assign_alloc(const vector& __c) void __copy_assign_alloc(const vector& __c)
{__copy_assign_alloc(__c, integral_constant<bool, {__copy_assign_alloc(__c, integral_constant<bool,
__alloc_traits::propagate_on_container_copy_assignment::value>());} __alloc_traits::propagate_on_container_copy_assignment::value>());}
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY
void __move_assign_alloc(vector& __c) void __move_assign_alloc(vector& __c)
_NOEXCEPT_( _NOEXCEPT_(
!__alloc_traits::propagate_on_container_move_assignment::value || !__alloc_traits::propagate_on_container_move_assignment::value ||
is_nothrow_move_assignable<allocator_type>::value) is_nothrow_move_assignable<allocator_type>::value)
{__move_assign_alloc(__c, integral_constant<bool, {__move_assign_alloc(__c, integral_constant<bool,
__alloc_traits::propagate_on_container_move_assignment::value>());} __alloc_traits::propagate_on_container_move_assignment::value>());}
_LIBCPP_NORETURN _LIBCPP_HIDE_FROM_ABI _LIBCPP_NORETURN _LIBCPP_HIDE_FROM_ABI
void __throw_length_error() const { void __throw_length_error() const {
_VSTD::__throw_length_error("vector"); _VSTD::__throw_length_error("vector");
} }
_LIBCPP_NORETURN _LIBCPP_HIDE_FROM_ABI _LIBCPP_NORETURN _LIBCPP_HIDE_FROM_ABI
void __throw_out_of_range() const { void __throw_out_of_range() const {
_VSTD::__throw_out_of_range("vector"); _VSTD::__throw_out_of_range("vector");
} }
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY
void __copy_assign_alloc(const vector& __c, true_type) void __copy_assign_alloc(const vector& __c, true_type)
{ {
if (__alloc() != __c.__alloc()) if (__alloc() != __c.__alloc())
{ {
__clear(); __clear();
__alloc_traits::deallocate(__alloc(), this->__begin_, capacity()); __alloc_traits::deallocate(__alloc(), this->__begin_, capacity());
this->__begin_ = this->__end_ = __end_cap() = nullptr; this->__begin_ = this->__end_ = __end_cap() = nullptr;
} }
__alloc() = __c.__alloc(); __alloc() = __c.__alloc();
} }
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY
void __copy_assign_alloc(const vector&, false_type) void __copy_assign_alloc(const vector&, false_type)
{} {}
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY
void __move_assign_alloc(vector& __c, true_type) void __move_assign_alloc(vector& __c, true_type)
_NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value) _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value)
{ {
__alloc() = _VSTD::move(__c.__alloc()); __alloc() = _VSTD::move(__c.__alloc());
} }
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 _LIBCPP_INLINE_VISIBILITY
void __move_assign_alloc(vector&, false_type) void __move_assign_alloc(vector&, false_type)
_NOEXCEPT _NOEXCEPT
{} {}
}; };
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template<class _InputIterator, template<class _InputIterator,
class _Alloc = allocator<__iter_value_type<_InputIterator>>, class _Alloc = allocator<__iter_value_type<_InputIterator>>,
class = enable_if_t<__is_cpp17_input_iterator<_InputIterator>::value>, class = enable_if_t<__is_cpp17_input_iterator<_InputIterator>::value>,
class = enable_if_t<__is_allocator<_Alloc>::value> class = enable_if_t<__is_allocator<_Alloc>::value>
> >
vector(_InputIterator, _InputIterator) vector(_InputIterator, _InputIterator)
-> vector<__iter_value_type<_InputIterator>, _Alloc>; -> vector<__iter_value_type<_InputIterator>, _Alloc>;
template<class _InputIterator, template<class _InputIterator,
class _Alloc, class _Alloc,
class = enable_if_t<__is_cpp17_input_iterator<_InputIterator>::value>, class = enable_if_t<__is_cpp17_input_iterator<_InputIterator>::value>,
class = enable_if_t<__is_allocator<_Alloc>::value> class = enable_if_t<__is_allocator<_Alloc>::value>
> >
vector(_InputIterator, _InputIterator, _Alloc) vector(_InputIterator, _InputIterator, _Alloc)
-> vector<__iter_value_type<_InputIterator>, _Alloc>; -> vector<__iter_value_type<_InputIterator>, _Alloc>;
#endif #endif
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
void void
vector<_Tp, _Allocator>::__swap_out_circular_buffer(__split_buffer<value_type, allocator_type&>& __v) vector<_Tp, _Allocator>::__swap_out_circular_buffer(__split_buffer<value_type, allocator_type&>& __v)
{ {
__annotate_delete(); __annotate_delete();
using _RevIter = std::reverse_iterator<pointer>; using _RevIter = std::reverse_iterator<pointer>;
__v.__begin_ = std::__uninitialized_allocator_move_if_noexcept( __v.__begin_ = std::__uninitialized_allocator_move_if_noexcept(
__alloc(), _RevIter(__end_), _RevIter(__begin_), _RevIter(__v.__begin_)) __alloc(), _RevIter(__end_), _RevIter(__begin_), _RevIter(__v.__begin_))
.base(); .base();
_VSTD::swap(this->__begin_, __v.__begin_); _VSTD::swap(this->__begin_, __v.__begin_);
_VSTD::swap(this->__end_, __v.__end_); _VSTD::swap(this->__end_, __v.__end_);
_VSTD::swap(this->__end_cap(), __v.__end_cap()); _VSTD::swap(this->__end_cap(), __v.__end_cap());
__v.__first_ = __v.__begin_; __v.__first_ = __v.__begin_;
__annotate_new(size()); __annotate_new(size());
std::__debug_db_invalidate_all(this); std::__debug_db_invalidate_all(this);
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
typename vector<_Tp, _Allocator>::pointer typename vector<_Tp, _Allocator>::pointer
vector<_Tp, _Allocator>::__swap_out_circular_buffer(__split_buffer<value_type, allocator_type&>& __v, pointer __p) vector<_Tp, _Allocator>::__swap_out_circular_buffer(__split_buffer<value_type, allocator_type&>& __v, pointer __p)
{ {
__annotate_delete(); __annotate_delete();
pointer __r = __v.__begin_; pointer __r = __v.__begin_;
using _RevIter = std::reverse_iterator<pointer>; using _RevIter = std::reverse_iterator<pointer>;
__v.__begin_ = std::__uninitialized_allocator_move_if_noexcept( __v.__begin_ = std::__uninitialized_allocator_move_if_noexcept(
__alloc(), _RevIter(__p), _RevIter(__begin_), _RevIter(__v.__begin_)) __alloc(), _RevIter(__p), _RevIter(__begin_), _RevIter(__v.__begin_))
.base(); .base();
__v.__end_ = std::__uninitialized_allocator_move_if_noexcept(__alloc(), __p, __end_, __v.__end_); __v.__end_ = std::__uninitialized_allocator_move_if_noexcept(__alloc(), __p, __end_, __v.__end_);
_VSTD::swap(this->__begin_, __v.__begin_); _VSTD::swap(this->__begin_, __v.__begin_);
_VSTD::swap(this->__end_, __v.__end_); _VSTD::swap(this->__end_, __v.__end_);
_VSTD::swap(this->__end_cap(), __v.__end_cap()); _VSTD::swap(this->__end_cap(), __v.__end_cap());
__v.__first_ = __v.__begin_; __v.__first_ = __v.__begin_;
__annotate_new(size()); __annotate_new(size());
std::__debug_db_invalidate_all(this); std::__debug_db_invalidate_all(this);
return __r; return __r;
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
void void
vector<_Tp, _Allocator>::__vdeallocate() _NOEXCEPT vector<_Tp, _Allocator>::__vdeallocate() _NOEXCEPT
{ {
if (this->__begin_ != nullptr) if (this->__begin_ != nullptr)
{ {
clear(); clear();
__alloc_traits::deallocate(this->__alloc(), this->__begin_, capacity()); __alloc_traits::deallocate(this->__alloc(), this->__begin_, capacity());
this->__begin_ = this->__end_ = this->__end_cap() = nullptr; this->__begin_ = this->__end_ = this->__end_cap() = nullptr;
} }
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
typename vector<_Tp, _Allocator>::size_type typename vector<_Tp, _Allocator>::size_type
vector<_Tp, _Allocator>::max_size() const _NOEXCEPT vector<_Tp, _Allocator>::max_size() const _NOEXCEPT
{ {
return _VSTD::min<size_type>(__alloc_traits::max_size(this->__alloc()), return _VSTD::min<size_type>(__alloc_traits::max_size(this->__alloc()),
numeric_limits<difference_type>::max()); numeric_limits<difference_type>::max());
} }
// Precondition: __new_size > capacity() // Precondition: __new_size > capacity()
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
typename vector<_Tp, _Allocator>::size_type typename vector<_Tp, _Allocator>::size_type
vector<_Tp, _Allocator>::__recommend(size_type __new_size) const vector<_Tp, _Allocator>::__recommend(size_type __new_size) const
{ {
const size_type __ms = max_size(); const size_type __ms = max_size();
if (__new_size > __ms) if (__new_size > __ms)
this->__throw_length_error(); this->__throw_length_error();
const size_type __cap = capacity(); const size_type __cap = capacity();
if (__cap >= __ms / 2) if (__cap >= __ms / 2)
return __ms; return __ms;
return _VSTD::max<size_type>(2 * __cap, __new_size); return _VSTD::max<size_type>(2 * __cap, __new_size);
} }
// Default constructs __n objects starting at __end_ // Default constructs __n objects starting at __end_
// throws if construction throws // throws if construction throws
// Precondition: __n > 0 // Precondition: __n > 0
// Precondition: size() + __n <= capacity() // Precondition: size() + __n <= capacity()
// Postcondition: size() == size() + __n // Postcondition: size() == size() + __n
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
void void
vector<_Tp, _Allocator>::__construct_at_end(size_type __n) vector<_Tp, _Allocator>::__construct_at_end(size_type __n)
{ {
_ConstructTransaction __tx(*this, __n); _ConstructTransaction __tx(*this, __n);
const_pointer __new_end = __tx.__new_end_; const_pointer __new_end = __tx.__new_end_;
for (pointer __pos = __tx.__pos_; __pos != __new_end; __tx.__pos_ = ++__pos) { for (pointer __pos = __tx.__pos_; __pos != __new_end; __tx.__pos_ = ++__pos) {
__alloc_traits::construct(this->__alloc(), _VSTD::__to_address(__pos)); __alloc_traits::construct(this->__alloc(), _VSTD::__to_address(__pos));
} }
} }
// Copy constructs __n objects starting at __end_ from __x // Copy constructs __n objects starting at __end_ from __x
// throws if construction throws // throws if construction throws
// Precondition: __n > 0 // Precondition: __n > 0
// Precondition: size() + __n <= capacity() // Precondition: size() + __n <= capacity()
// Postcondition: size() == old size() + __n // Postcondition: size() == old size() + __n
// Postcondition: [i] == __x for all i in [size() - __n, __n) // Postcondition: [i] == __x for all i in [size() - __n, __n)
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
inline inline
void void
vector<_Tp, _Allocator>::__construct_at_end(size_type __n, const_reference __x) vector<_Tp, _Allocator>::__construct_at_end(size_type __n, const_reference __x)
{ {
_ConstructTransaction __tx(*this, __n); _ConstructTransaction __tx(*this, __n);
const_pointer __new_end = __tx.__new_end_; const_pointer __new_end = __tx.__new_end_;
for (pointer __pos = __tx.__pos_; __pos != __new_end; __tx.__pos_ = ++__pos) { for (pointer __pos = __tx.__pos_; __pos != __new_end; __tx.__pos_ = ++__pos) {
__alloc_traits::construct(this->__alloc(), _VSTD::__to_address(__pos), __x); __alloc_traits::construct(this->__alloc(), _VSTD::__to_address(__pos), __x);
} }
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
template <class _ForwardIterator> template <class _ForwardIterator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
typename enable_if typename enable_if
< <
__is_cpp17_forward_iterator<_ForwardIterator>::value, __is_cpp17_forward_iterator<_ForwardIterator>::value,
void void
>::type >::type
vector<_Tp, _Allocator>::__construct_at_end(_ForwardIterator __first, _ForwardIterator __last, size_type __n) vector<_Tp, _Allocator>::__construct_at_end(_ForwardIterator __first, _ForwardIterator __last, size_type __n)
{ {
_ConstructTransaction __tx(*this, __n); _ConstructTransaction __tx(*this, __n);
__tx.__pos_ = std::__uninitialized_allocator_copy(__alloc(), __first, __last, __tx.__pos_); __tx.__pos_ = std::__uninitialized_allocator_copy(__alloc(), __first, __last, __tx.__pos_);
} }
// Default constructs __n objects starting at __end_ // Default constructs __n objects starting at __end_
// throws if construction throws // throws if construction throws
// Postcondition: size() == size() + __n // Postcondition: size() == size() + __n
// Exception safety: strong. // Exception safety: strong.
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
void void
vector<_Tp, _Allocator>::__append(size_type __n) vector<_Tp, _Allocator>::__append(size_type __n)
{ {
if (static_cast<size_type>(this->__end_cap() - this->__end_) >= __n) if (static_cast<size_type>(this->__end_cap() - this->__end_) >= __n)
this->__construct_at_end(__n); this->__construct_at_end(__n);
else else
{ {
allocator_type& __a = this->__alloc(); allocator_type& __a = this->__alloc();
__split_buffer<value_type, allocator_type&> __v(__recommend(size() + __n), size(), __a); __split_buffer<value_type, allocator_type&> __v(__recommend(size() + __n), size(), __a);
__v.__construct_at_end(__n); __v.__construct_at_end(__n);
__swap_out_circular_buffer(__v); __swap_out_circular_buffer(__v);
} }
} }
// Default constructs __n objects starting at __end_ // Default constructs __n objects starting at __end_
// throws if construction throws // throws if construction throws
// Postcondition: size() == size() + __n // Postcondition: size() == size() + __n
// Exception safety: strong. // Exception safety: strong.
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
void void
vector<_Tp, _Allocator>::__append(size_type __n, const_reference __x) vector<_Tp, _Allocator>::__append(size_type __n, const_reference __x)
{ {
if (static_cast<size_type>(this->__end_cap() - this->__end_) >= __n) if (static_cast<size_type>(this->__end_cap() - this->__end_) >= __n)
this->__construct_at_end(__n, __x); this->__construct_at_end(__n, __x);
else else
{ {
allocator_type& __a = this->__alloc(); allocator_type& __a = this->__alloc();
__split_buffer<value_type, allocator_type&> __v(__recommend(size() + __n), size(), __a); __split_buffer<value_type, allocator_type&> __v(__recommend(size() + __n), size(), __a);
__v.__construct_at_end(__n, __x); __v.__construct_at_end(__n, __x);
__swap_out_circular_buffer(__v); __swap_out_circular_buffer(__v);
} }
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
vector<_Tp, _Allocator>::vector(size_type __n) vector<_Tp, _Allocator>::vector(size_type __n)
{ {
_VSTD::__debug_db_insert_c(this); _VSTD::__debug_db_insert_c(this);
if (__n > 0) if (__n > 0)
{ {
__vallocate(__n); __vallocate(__n);
__construct_at_end(__n); __construct_at_end(__n);
} }
} }
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER > 11
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
vector<_Tp, _Allocator>::vector(size_type __n, const allocator_type& __a) vector<_Tp, _Allocator>::vector(size_type __n, const allocator_type& __a)
: __end_cap_(nullptr, __a) : __end_cap_(nullptr, __a)
{ {
_VSTD::__debug_db_insert_c(this); _VSTD::__debug_db_insert_c(this);
if (__n > 0) if (__n > 0)
{ {
__vallocate(__n); __vallocate(__n);
__construct_at_end(__n); __construct_at_end(__n);
} }
} }
#endif #endif
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
vector<_Tp, _Allocator>::vector(size_type __n, const value_type& __x) vector<_Tp, _Allocator>::vector(size_type __n, const value_type& __x)
{ {
_VSTD::__debug_db_insert_c(this); _VSTD::__debug_db_insert_c(this);
if (__n > 0) if (__n > 0)
{ {
__vallocate(__n); __vallocate(__n);
__construct_at_end(__n, __x); __construct_at_end(__n, __x);
} }
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
template <class _InputIterator> template <class _InputIterator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
vector<_Tp, _Allocator>::vector(_InputIterator __first, vector<_Tp, _Allocator>::vector(_InputIterator __first,
typename enable_if<__is_exactly_cpp17_input_iterator<_InputIterator>::value && typename enable_if<__is_exactly_cpp17_input_iterator<_InputIterator>::value &&
is_constructible< is_constructible<
value_type, value_type,
typename iterator_traits<_InputIterator>::reference>::value, typename iterator_traits<_InputIterator>::reference>::value,
_InputIterator>::type __last) _InputIterator>::type __last)
{ {
_VSTD::__debug_db_insert_c(this); _VSTD::__debug_db_insert_c(this);
for (; __first != __last; ++__first) for (; __first != __last; ++__first)
emplace_back(*__first); emplace_back(*__first);
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
template <class _InputIterator> template <class _InputIterator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
vector<_Tp, _Allocator>::vector(_InputIterator __first, _InputIterator __last, const allocator_type& __a, vector<_Tp, _Allocator>::vector(_InputIterator __first, _InputIterator __last, const allocator_type& __a,
typename enable_if<__is_exactly_cpp17_input_iterator<_InputIterator>::value && typename enable_if<__is_exactly_cpp17_input_iterator<_InputIterator>::value &&
is_constructible< is_constructible<
value_type, value_type,
typename iterator_traits<_InputIterator>::reference>::value>::type*) typename iterator_traits<_InputIterator>::reference>::value>::type*)
: __end_cap_(nullptr, __a) : __end_cap_(nullptr, __a)
{ {
_VSTD::__debug_db_insert_c(this); _VSTD::__debug_db_insert_c(this);
for (; __first != __last; ++__first) for (; __first != __last; ++__first)
emplace_back(*__first); emplace_back(*__first);
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
template <class _ForwardIterator> template <class _ForwardIterator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
vector<_Tp, _Allocator>::vector(_ForwardIterator __first, vector<_Tp, _Allocator>::vector(_ForwardIterator __first,
typename enable_if<__is_cpp17_forward_iterator<_ForwardIterator>::value && typename enable_if<__is_cpp17_forward_iterator<_ForwardIterator>::value &&
is_constructible< is_constructible<
value_type, value_type,
typename iterator_traits<_ForwardIterator>::reference>::value, typename iterator_traits<_ForwardIterator>::reference>::value,
_ForwardIterator>::type __last) _ForwardIterator>::type __last)
{ {
_VSTD::__debug_db_insert_c(this); _VSTD::__debug_db_insert_c(this);
size_type __n = static_cast<size_type>(_VSTD::distance(__first, __last)); size_type __n = static_cast<size_type>(_VSTD::distance(__first, __last));
if (__n > 0) if (__n > 0)
{ {
__vallocate(__n); __vallocate(__n);
__construct_at_end(__first, __last, __n); __construct_at_end(__first, __last, __n);
} }
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
template <class _ForwardIterator> template <class _ForwardIterator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
vector<_Tp, _Allocator>::vector(_ForwardIterator __first, _ForwardIterator __last, const allocator_type& __a, vector<_Tp, _Allocator>::vector(_ForwardIterator __first, _ForwardIterator __last, const allocator_type& __a,
typename enable_if<__is_cpp17_forward_iterator<_ForwardIterator>::value && typename enable_if<__is_cpp17_forward_iterator<_ForwardIterator>::value &&
is_constructible< is_constructible<
value_type, value_type,
typename iterator_traits<_ForwardIterator>::reference>::value>::type*) typename iterator_traits<_ForwardIterator>::reference>::value>::type*)
: __end_cap_(nullptr, __a) : __end_cap_(nullptr, __a)
{ {
_VSTD::__debug_db_insert_c(this); _VSTD::__debug_db_insert_c(this);
size_type __n = static_cast<size_type>(_VSTD::distance(__first, __last)); size_type __n = static_cast<size_type>(_VSTD::distance(__first, __last));
if (__n > 0) if (__n > 0)
{ {
__vallocate(__n); __vallocate(__n);
__construct_at_end(__first, __last, __n); __construct_at_end(__first, __last, __n);
} }
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
vector<_Tp, _Allocator>::vector(const vector& __x) vector<_Tp, _Allocator>::vector(const vector& __x)
: __end_cap_(nullptr, __alloc_traits::select_on_container_copy_construction(__x.__alloc())) : __end_cap_(nullptr, __alloc_traits::select_on_container_copy_construction(__x.__alloc()))
{ {
_VSTD::__debug_db_insert_c(this); _VSTD::__debug_db_insert_c(this);
size_type __n = __x.size(); size_type __n = __x.size();
if (__n > 0) if (__n > 0)
{ {
__vallocate(__n); __vallocate(__n);
__construct_at_end(__x.__begin_, __x.__end_, __n); __construct_at_end(__x.__begin_, __x.__end_, __n);
} }
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
vector<_Tp, _Allocator>::vector(const vector& __x, const __type_identity_t<allocator_type>& __a) vector<_Tp, _Allocator>::vector(const vector& __x, const __type_identity_t<allocator_type>& __a)
: __end_cap_(nullptr, __a) : __end_cap_(nullptr, __a)
{ {
_VSTD::__debug_db_insert_c(this); _VSTD::__debug_db_insert_c(this);
size_type __n = __x.size(); size_type __n = __x.size();
if (__n > 0) if (__n > 0)
{ {
__vallocate(__n); __vallocate(__n);
__construct_at_end(__x.__begin_, __x.__end_, __n); __construct_at_end(__x.__begin_, __x.__end_, __n);
} }
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
vector<_Tp, _Allocator>::vector(vector&& __x) vector<_Tp, _Allocator>::vector(vector&& __x)
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER > 14
noexcept noexcept
#else #else
_NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value) _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value)
#endif #endif
: __end_cap_(nullptr, _VSTD::move(__x.__alloc())) : __end_cap_(nullptr, _VSTD::move(__x.__alloc()))
{ {
_VSTD::__debug_db_insert_c(this); _VSTD::__debug_db_insert_c(this);
std::__debug_db_swap(this, std::addressof(__x)); std::__debug_db_swap(this, std::addressof(__x));
this->__begin_ = __x.__begin_; this->__begin_ = __x.__begin_;
this->__end_ = __x.__end_; this->__end_ = __x.__end_;
this->__end_cap() = __x.__end_cap(); this->__end_cap() = __x.__end_cap();
__x.__begin_ = __x.__end_ = __x.__end_cap() = nullptr; __x.__begin_ = __x.__end_ = __x.__end_cap() = nullptr;
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
vector<_Tp, _Allocator>::vector(vector&& __x, const __type_identity_t<allocator_type>& __a) vector<_Tp, _Allocator>::vector(vector&& __x, const __type_identity_t<allocator_type>& __a)
: __end_cap_(nullptr, __a) : __end_cap_(nullptr, __a)
{ {
_VSTD::__debug_db_insert_c(this); _VSTD::__debug_db_insert_c(this);
if (__a == __x.__alloc()) if (__a == __x.__alloc())
{ {
this->__begin_ = __x.__begin_; this->__begin_ = __x.__begin_;
this->__end_ = __x.__end_; this->__end_ = __x.__end_;
this->__end_cap() = __x.__end_cap(); this->__end_cap() = __x.__end_cap();
__x.__begin_ = __x.__end_ = __x.__end_cap() = nullptr; __x.__begin_ = __x.__end_ = __x.__end_cap() = nullptr;
std::__debug_db_swap(this, std::addressof(__x)); std::__debug_db_swap(this, std::addressof(__x));
} }
else else
{ {
typedef move_iterator<iterator> _Ip; typedef move_iterator<iterator> _Ip;
assign(_Ip(__x.begin()), _Ip(__x.end())); assign(_Ip(__x.begin()), _Ip(__x.end()));
} }
} }
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
vector<_Tp, _Allocator>::vector(initializer_list<value_type> __il) vector<_Tp, _Allocator>::vector(initializer_list<value_type> __il)
{ {
_VSTD::__debug_db_insert_c(this); _VSTD::__debug_db_insert_c(this);
if (__il.size() > 0) if (__il.size() > 0)
{ {
__vallocate(__il.size()); __vallocate(__il.size());
__construct_at_end(__il.begin(), __il.end(), __il.size()); __construct_at_end(__il.begin(), __il.end(), __il.size());
} }
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
vector<_Tp, _Allocator>::vector(initializer_list<value_type> __il, const allocator_type& __a) vector<_Tp, _Allocator>::vector(initializer_list<value_type> __il, const allocator_type& __a)
: __end_cap_(nullptr, __a) : __end_cap_(nullptr, __a)
{ {
_VSTD::__debug_db_insert_c(this); _VSTD::__debug_db_insert_c(this);
if (__il.size() > 0) if (__il.size() > 0)
{ {
__vallocate(__il.size()); __vallocate(__il.size());
__construct_at_end(__il.begin(), __il.end(), __il.size()); __construct_at_end(__il.begin(), __il.end(), __il.size());
} }
} }
#endif // _LIBCPP_CXX03_LANG #endif // _LIBCPP_CXX03_LANG
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
vector<_Tp, _Allocator>& vector<_Tp, _Allocator>&
vector<_Tp, _Allocator>::operator=(vector&& __x) vector<_Tp, _Allocator>::operator=(vector&& __x)
_NOEXCEPT_((__noexcept_move_assign_container<_Allocator, __alloc_traits>::value)) _NOEXCEPT_((__noexcept_move_assign_container<_Allocator, __alloc_traits>::value))
{ {
__move_assign(__x, integral_constant<bool, __move_assign(__x, integral_constant<bool,
__alloc_traits::propagate_on_container_move_assignment::value>()); __alloc_traits::propagate_on_container_move_assignment::value>());
return *this; return *this;
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
void void
vector<_Tp, _Allocator>::__move_assign(vector& __c, false_type) vector<_Tp, _Allocator>::__move_assign(vector& __c, false_type)
_NOEXCEPT_(__alloc_traits::is_always_equal::value) _NOEXCEPT_(__alloc_traits::is_always_equal::value)
{ {
if (__alloc() != __c.__alloc()) if (__alloc() != __c.__alloc())
{ {
typedef move_iterator<iterator> _Ip; typedef move_iterator<iterator> _Ip;
assign(_Ip(__c.begin()), _Ip(__c.end())); assign(_Ip(__c.begin()), _Ip(__c.end()));
} }
else else
__move_assign(__c, true_type()); __move_assign(__c, true_type());
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
void void
vector<_Tp, _Allocator>::__move_assign(vector& __c, true_type) vector<_Tp, _Allocator>::__move_assign(vector& __c, true_type)
_NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value) _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value)
{ {
__vdeallocate(); __vdeallocate();
__move_assign_alloc(__c); // this can throw __move_assign_alloc(__c); // this can throw
this->__begin_ = __c.__begin_; this->__begin_ = __c.__begin_;
this->__end_ = __c.__end_; this->__end_ = __c.__end_;
this->__end_cap() = __c.__end_cap(); this->__end_cap() = __c.__end_cap();
__c.__begin_ = __c.__end_ = __c.__end_cap() = nullptr; __c.__begin_ = __c.__end_ = __c.__end_cap() = nullptr;
std::__debug_db_swap(this, std::addressof(__c)); std::__debug_db_swap(this, std::addressof(__c));
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
vector<_Tp, _Allocator>& vector<_Tp, _Allocator>&
vector<_Tp, _Allocator>::operator=(const vector& __x) vector<_Tp, _Allocator>::operator=(const vector& __x)
{ {
if (this != _VSTD::addressof(__x)) if (this != _VSTD::addressof(__x))
{ {
__copy_assign_alloc(__x); __copy_assign_alloc(__x);
assign(__x.__begin_, __x.__end_); assign(__x.__begin_, __x.__end_);
} }
return *this; return *this;
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
template <class _InputIterator> template <class _InputIterator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 typename enable_if <__is_exactly_cpp17_input_iterator<_InputIterator>::value && _LIBCPP_CONSTEXPR_CXX20 typename enable_if <__is_exactly_cpp17_input_iterator<_InputIterator>::value &&
is_constructible< is_constructible<
_Tp, _Tp,
typename iterator_traits<_InputIterator>::reference>::value, typename iterator_traits<_InputIterator>::reference>::value,
void void
>::type >::type
vector<_Tp, _Allocator>::assign(_InputIterator __first, _InputIterator __last) vector<_Tp, _Allocator>::assign(_InputIterator __first, _InputIterator __last)
{ {
clear(); clear();
for (; __first != __last; ++__first) for (; __first != __last; ++__first)
emplace_back(*__first); emplace_back(*__first);
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
template <class _ForwardIterator> template <class _ForwardIterator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
typename enable_if typename enable_if
< <
__is_cpp17_forward_iterator<_ForwardIterator>::value && __is_cpp17_forward_iterator<_ForwardIterator>::value &&
is_constructible< is_constructible<
_Tp, _Tp,
typename iterator_traits<_ForwardIterator>::reference>::value, typename iterator_traits<_ForwardIterator>::reference>::value,
void void
>::type >::type
Show All 21 Lines else
__vdeallocate(); __vdeallocate();
__vallocate(__recommend(__new_size)); __vallocate(__recommend(__new_size));
__construct_at_end(__first, __last, __new_size); __construct_at_end(__first, __last, __new_size);
} }
std::__debug_db_invalidate_all(this); std::__debug_db_invalidate_all(this);
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
void void
vector<_Tp, _Allocator>::assign(size_type __n, const_reference __u) vector<_Tp, _Allocator>::assign(size_type __n, const_reference __u)
{ {
if (__n <= capacity()) if (__n <= capacity())
{ {
size_type __s = size(); size_type __s = size();
_VSTD::fill_n(this->__begin_, _VSTD::min(__n, __s), __u); _VSTD::fill_n(this->__begin_, _VSTD::min(__n, __s), __u);
if (__n > __s) if (__n > __s)
__construct_at_end(__n - __s, __u); __construct_at_end(__n - __s, __u);
else else
this->__destruct_at_end(this->__begin_ + __n); this->__destruct_at_end(this->__begin_ + __n);
} }
else else
{ {
__vdeallocate(); __vdeallocate();
__vallocate(__recommend(static_cast<size_type>(__n))); __vallocate(__recommend(static_cast<size_type>(__n)));
__construct_at_end(__n, __u); __construct_at_end(__n, __u);
} }
std::__debug_db_invalidate_all(this); std::__debug_db_invalidate_all(this);
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
typename vector<_Tp, _Allocator>::iterator typename vector<_Tp, _Allocator>::iterator
vector<_Tp, _Allocator>::begin() _NOEXCEPT vector<_Tp, _Allocator>::begin() _NOEXCEPT
{ {
return iterator(this, this->__begin_); return iterator(this, this->__begin_);
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
typename vector<_Tp, _Allocator>::const_iterator typename vector<_Tp, _Allocator>::const_iterator
vector<_Tp, _Allocator>::begin() const _NOEXCEPT vector<_Tp, _Allocator>::begin() const _NOEXCEPT
{ {
return const_iterator(this, this->__begin_); return const_iterator(this, this->__begin_);
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
typename vector<_Tp, _Allocator>::iterator typename vector<_Tp, _Allocator>::iterator
vector<_Tp, _Allocator>::end() _NOEXCEPT vector<_Tp, _Allocator>::end() _NOEXCEPT
{ {
return iterator(this, this->__end_); return iterator(this, this->__end_);
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
typename vector<_Tp, _Allocator>::const_iterator typename vector<_Tp, _Allocator>::const_iterator
vector<_Tp, _Allocator>::end() const _NOEXCEPT vector<_Tp, _Allocator>::end() const _NOEXCEPT
{ {
return const_iterator(this, this->__end_); return const_iterator(this, this->__end_);
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
typename vector<_Tp, _Allocator>::reference typename vector<_Tp, _Allocator>::reference
vector<_Tp, _Allocator>::operator[](size_type __n) _NOEXCEPT vector<_Tp, _Allocator>::operator[](size_type __n) _NOEXCEPT
{ {
_LIBCPP_ASSERT(__n < size(), "vector[] index out of bounds"); _LIBCPP_ASSERT(__n < size(), "vector[] index out of bounds");
return this->__begin_[__n]; return this->__begin_[__n];
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
typename vector<_Tp, _Allocator>::const_reference typename vector<_Tp, _Allocator>::const_reference
vector<_Tp, _Allocator>::operator[](size_type __n) const _NOEXCEPT vector<_Tp, _Allocator>::operator[](size_type __n) const _NOEXCEPT
{ {
_LIBCPP_ASSERT(__n < size(), "vector[] index out of bounds"); _LIBCPP_ASSERT(__n < size(), "vector[] index out of bounds");
return this->__begin_[__n]; return this->__begin_[__n];
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
typename vector<_Tp, _Allocator>::reference typename vector<_Tp, _Allocator>::reference
vector<_Tp, _Allocator>::at(size_type __n) vector<_Tp, _Allocator>::at(size_type __n)
{ {
if (__n >= size()) if (__n >= size())
this->__throw_out_of_range(); this->__throw_out_of_range();
return this->__begin_[__n]; return this->__begin_[__n];
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
typename vector<_Tp, _Allocator>::const_reference typename vector<_Tp, _Allocator>::const_reference
vector<_Tp, _Allocator>::at(size_type __n) const vector<_Tp, _Allocator>::at(size_type __n) const
{ {
if (__n >= size()) if (__n >= size())
this->__throw_out_of_range(); this->__throw_out_of_range();
return this->__begin_[__n]; return this->__begin_[__n];
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
void void
vector<_Tp, _Allocator>::reserve(size_type __n) vector<_Tp, _Allocator>::reserve(size_type __n)
{ {
if (__n > capacity()) if (__n > capacity())
{ {
if (__n > max_size()) if (__n > max_size())
this->__throw_length_error(); this->__throw_length_error();
allocator_type& __a = this->__alloc(); allocator_type& __a = this->__alloc();
__split_buffer<value_type, allocator_type&> __v(__n, size(), __a); __split_buffer<value_type, allocator_type&> __v(__n, size(), __a);
__swap_out_circular_buffer(__v); __swap_out_circular_buffer(__v);
} }
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
void void
vector<_Tp, _Allocator>::shrink_to_fit() _NOEXCEPT vector<_Tp, _Allocator>::shrink_to_fit() _NOEXCEPT
{ {
if (capacity() > size()) if (capacity() > size())
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_NO_EXCEPTIONS
allocator_type& __a = this->__alloc(); allocator_type& __a = this->__alloc();
__split_buffer<value_type, allocator_type&> __v(size(), size(), __a); __split_buffer<value_type, allocator_type&> __v(size(), size(), __a);
__swap_out_circular_buffer(__v); __swap_out_circular_buffer(__v);
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_NO_EXCEPTIONS
} }
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
template <class _Up> template <class _Up>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
void void
vector<_Tp, _Allocator>::__push_back_slow_path(_Up&& __x) vector<_Tp, _Allocator>::__push_back_slow_path(_Up&& __x)
{ {
allocator_type& __a = this->__alloc(); allocator_type& __a = this->__alloc();
__split_buffer<value_type, allocator_type&> __v(__recommend(size() + 1), size(), __a); __split_buffer<value_type, allocator_type&> __v(__recommend(size() + 1), size(), __a);
// __v.push_back(_VSTD::forward<_Up>(__x)); // __v.push_back(_VSTD::forward<_Up>(__x));
__alloc_traits::construct(__a, _VSTD::__to_address(__v.__end_), _VSTD::forward<_Up>(__x)); __alloc_traits::construct(__a, _VSTD::__to_address(__v.__end_), _VSTD::forward<_Up>(__x));
__v.__end_++; __v.__end_++;
__swap_out_circular_buffer(__v); __swap_out_circular_buffer(__v);
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
void void
vector<_Tp, _Allocator>::push_back(const_reference __x) vector<_Tp, _Allocator>::push_back(const_reference __x)
{ {
if (this->__end_ != this->__end_cap()) if (this->__end_ != this->__end_cap())
{ {
__construct_one_at_end(__x); __construct_one_at_end(__x);
} }
else else
__push_back_slow_path(__x); __push_back_slow_path(__x);
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
void void
vector<_Tp, _Allocator>::push_back(value_type&& __x) vector<_Tp, _Allocator>::push_back(value_type&& __x)
{ {
if (this->__end_ < this->__end_cap()) if (this->__end_ < this->__end_cap())
{ {
__construct_one_at_end(_VSTD::move(__x)); __construct_one_at_end(_VSTD::move(__x));
} }
else else
__push_back_slow_path(_VSTD::move(__x)); __push_back_slow_path(_VSTD::move(__x));
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
template <class... _Args> template <class... _Args>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
void void
vector<_Tp, _Allocator>::__emplace_back_slow_path(_Args&&... __args) vector<_Tp, _Allocator>::__emplace_back_slow_path(_Args&&... __args)
{ {
allocator_type& __a = this->__alloc(); allocator_type& __a = this->__alloc();
__split_buffer<value_type, allocator_type&> __v(__recommend(size() + 1), size(), __a); __split_buffer<value_type, allocator_type&> __v(__recommend(size() + 1), size(), __a);
// __v.emplace_back(_VSTD::forward<_Args>(__args)...); // __v.emplace_back(_VSTD::forward<_Args>(__args)...);
__alloc_traits::construct(__a, _VSTD::__to_address(__v.__end_), _VSTD::forward<_Args>(__args)...); __alloc_traits::construct(__a, _VSTD::__to_address(__v.__end_), _VSTD::forward<_Args>(__args)...);
__v.__end_++; __v.__end_++;
__swap_out_circular_buffer(__v); __swap_out_circular_buffer(__v);
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
template <class... _Args> template <class... _Args>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
inline inline
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER > 14
typename vector<_Tp, _Allocator>::reference typename vector<_Tp, _Allocator>::reference
#else #else
void void
#endif #endif
vector<_Tp, _Allocator>::emplace_back(_Args&&... __args) vector<_Tp, _Allocator>::emplace_back(_Args&&... __args)
{ {
if (this->__end_ < this->__end_cap()) if (this->__end_ < this->__end_cap())
{ {
__construct_one_at_end(_VSTD::forward<_Args>(__args)...); __construct_one_at_end(_VSTD::forward<_Args>(__args)...);
} }
else else
__emplace_back_slow_path(_VSTD::forward<_Args>(__args)...); __emplace_back_slow_path(_VSTD::forward<_Args>(__args)...);
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER > 14
return this->back(); return this->back();
#endif #endif
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
inline inline
void void
vector<_Tp, _Allocator>::pop_back() vector<_Tp, _Allocator>::pop_back()
{ {
_LIBCPP_ASSERT(!empty(), "vector::pop_back called on an empty vector"); _LIBCPP_ASSERT(!empty(), "vector::pop_back called on an empty vector");
this->__destruct_at_end(this->__end_ - 1); this->__destruct_at_end(this->__end_ - 1);
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
typename vector<_Tp, _Allocator>::iterator typename vector<_Tp, _Allocator>::iterator
vector<_Tp, _Allocator>::erase(const_iterator __position) vector<_Tp, _Allocator>::erase(const_iterator __position)
{ {
_LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(_VSTD::addressof(__position)) == this, _LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(_VSTD::addressof(__position)) == this,
"vector::erase(iterator) called with an iterator not referring to this vector"); "vector::erase(iterator) called with an iterator not referring to this vector");
_LIBCPP_ASSERT(__position != end(), _LIBCPP_ASSERT(__position != end(),
"vector::erase(iterator) called with a non-dereferenceable iterator"); "vector::erase(iterator) called with a non-dereferenceable iterator");
difference_type __ps = __position - cbegin(); difference_type __ps = __position - cbegin();
pointer __p = this->__begin_ + __ps; pointer __p = this->__begin_ + __ps;
this->__destruct_at_end(_VSTD::move(__p + 1, this->__end_, __p)); this->__destruct_at_end(_VSTD::move(__p + 1, this->__end_, __p));
if (!__libcpp_is_constant_evaluated()) if (!__libcpp_is_constant_evaluated())
this->__invalidate_iterators_past(__p - 1); this->__invalidate_iterators_past(__p - 1);
iterator __r = iterator(this, __p); iterator __r = iterator(this, __p);
return __r; return __r;
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
typename vector<_Tp, _Allocator>::iterator typename vector<_Tp, _Allocator>::iterator
vector<_Tp, _Allocator>::erase(const_iterator __first, const_iterator __last) vector<_Tp, _Allocator>::erase(const_iterator __first, const_iterator __last)
{ {
_LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(_VSTD::addressof(__first)) == this, _LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(_VSTD::addressof(__first)) == this,
"vector::erase(iterator, iterator) called with an iterator not referring to this vector"); "vector::erase(iterator, iterator) called with an iterator not referring to this vector");
_LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(_VSTD::addressof(__last)) == this, _LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(_VSTD::addressof(__last)) == this,
"vector::erase(iterator, iterator) called with an iterator not referring to this vector"); "vector::erase(iterator, iterator) called with an iterator not referring to this vector");
_LIBCPP_ASSERT(__first <= __last, "vector::erase(first, last) called with invalid range"); _LIBCPP_ASSERT(__first <= __last, "vector::erase(first, last) called with invalid range");
pointer __p = this->__begin_ + (__first - begin()); pointer __p = this->__begin_ + (__first - begin());
if (__first != __last) { if (__first != __last) {
this->__destruct_at_end(_VSTD::move(__p + (__last - __first), this->__end_, __p)); this->__destruct_at_end(_VSTD::move(__p + (__last - __first), this->__end_, __p));
if (!__libcpp_is_constant_evaluated()) if (!__libcpp_is_constant_evaluated())
this->__invalidate_iterators_past(__p - 1); this->__invalidate_iterators_past(__p - 1);
} }
iterator __r = iterator(this, __p); iterator __r = iterator(this, __p);
return __r; return __r;
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
void void
vector<_Tp, _Allocator>::__move_range(pointer __from_s, pointer __from_e, pointer __to) vector<_Tp, _Allocator>::__move_range(pointer __from_s, pointer __from_e, pointer __to)
{ {
pointer __old_last = this->__end_; pointer __old_last = this->__end_;
difference_type __n = __old_last - __to; difference_type __n = __old_last - __to;
{ {
pointer __i = __from_s + __n; pointer __i = __from_s + __n;
_ConstructTransaction __tx(*this, __from_e - __i); _ConstructTransaction __tx(*this, __from_e - __i);
for (pointer __pos = __tx.__pos_; __i < __from_e; for (pointer __pos = __tx.__pos_; __i < __from_e;
++__i, (void) ++__pos, __tx.__pos_ = __pos) { ++__i, (void) ++__pos, __tx.__pos_ = __pos) {
__alloc_traits::construct(this->__alloc(), __alloc_traits::construct(this->__alloc(),
_VSTD::__to_address(__pos), _VSTD::__to_address(__pos),
_VSTD::move(*__i)); _VSTD::move(*__i));
} }
} }
_VSTD::move_backward(__from_s, __from_s + __n, __old_last); _VSTD::move_backward(__from_s, __from_s + __n, __old_last);
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
typename vector<_Tp, _Allocator>::iterator typename vector<_Tp, _Allocator>::iterator
vector<_Tp, _Allocator>::insert(const_iterator __position, const_reference __x) vector<_Tp, _Allocator>::insert(const_iterator __position, const_reference __x)
{ {
_LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(_VSTD::addressof(__position)) == this, _LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(_VSTD::addressof(__position)) == this,
"vector::insert(iterator, x) called with an iterator not referring to this vector"); "vector::insert(iterator, x) called with an iterator not referring to this vector");
pointer __p = this->__begin_ + (__position - begin()); pointer __p = this->__begin_ + (__position - begin());
// We can't compare unrelated pointers inside constant expressions // We can't compare unrelated pointers inside constant expressions
if (!__libcpp_is_constant_evaluated() && this->__end_ < this->__end_cap()) if (!__libcpp_is_constant_evaluated() && this->__end_ < this->__end_cap())
Show All 17 Lines else
__split_buffer<value_type, allocator_type&> __v(__recommend(size() + 1), __p - this->__begin_, __a); __split_buffer<value_type, allocator_type&> __v(__recommend(size() + 1), __p - this->__begin_, __a);
__v.push_back(__x); __v.push_back(__x);
__p = __swap_out_circular_buffer(__v, __p); __p = __swap_out_circular_buffer(__v, __p);
} }
return iterator(this, __p); return iterator(this, __p);
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
typename vector<_Tp, _Allocator>::iterator typename vector<_Tp, _Allocator>::iterator
vector<_Tp, _Allocator>::insert(const_iterator __position, value_type&& __x) vector<_Tp, _Allocator>::insert(const_iterator __position, value_type&& __x)
{ {
_LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(_VSTD::addressof(__position)) == this, _LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(_VSTD::addressof(__position)) == this,
"vector::insert(iterator, x) called with an iterator not referring to this vector"); "vector::insert(iterator, x) called with an iterator not referring to this vector");
pointer __p = this->__begin_ + (__position - begin()); pointer __p = this->__begin_ + (__position - begin());
if (this->__end_ < this->__end_cap()) if (this->__end_ < this->__end_cap())
{ {
Show All 14 Lines else
__v.push_back(_VSTD::move(__x)); __v.push_back(_VSTD::move(__x));
__p = __swap_out_circular_buffer(__v, __p); __p = __swap_out_circular_buffer(__v, __p);
} }
return iterator(this, __p); return iterator(this, __p);
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
template <class... _Args> template <class... _Args>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
typename vector<_Tp, _Allocator>::iterator typename vector<_Tp, _Allocator>::iterator
vector<_Tp, _Allocator>::emplace(const_iterator __position, _Args&&... __args) vector<_Tp, _Allocator>::emplace(const_iterator __position, _Args&&... __args)
{ {
_LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(_VSTD::addressof(__position)) == this, _LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(_VSTD::addressof(__position)) == this,
"vector::emplace(iterator, x) called with an iterator not referring to this vector"); "vector::emplace(iterator, x) called with an iterator not referring to this vector");
pointer __p = this->__begin_ + (__position - begin()); pointer __p = this->__begin_ + (__position - begin());
if (this->__end_ < this->__end_cap()) if (this->__end_ < this->__end_cap())
{ {
Show All 14 Lines else
__split_buffer<value_type, allocator_type&> __v(__recommend(size() + 1), __p - this->__begin_, __a); __split_buffer<value_type, allocator_type&> __v(__recommend(size() + 1), __p - this->__begin_, __a);
__v.emplace_back(_VSTD::forward<_Args>(__args)...); __v.emplace_back(_VSTD::forward<_Args>(__args)...);
__p = __swap_out_circular_buffer(__v, __p); __p = __swap_out_circular_buffer(__v, __p);
} }
return iterator(this, __p); return iterator(this, __p);
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
typename vector<_Tp, _Allocator>::iterator typename vector<_Tp, _Allocator>::iterator
vector<_Tp, _Allocator>::insert(const_iterator __position, size_type __n, const_reference __x) vector<_Tp, _Allocator>::insert(const_iterator __position, size_type __n, const_reference __x)
{ {
_LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(_VSTD::addressof(__position)) == this, _LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(_VSTD::addressof(__position)) == this,
"vector::insert(iterator, n, x) called with an iterator not referring to this vector"); "vector::insert(iterator, n, x) called with an iterator not referring to this vector");
pointer __p = this->__begin_ + (__position - begin()); pointer __p = this->__begin_ + (__position - begin());
if (__n > 0) if (__n > 0)
{ {
Show All 25 Lines if (__n > 0)
__p = __swap_out_circular_buffer(__v, __p); __p = __swap_out_circular_buffer(__v, __p);
} }
} }
return iterator(this, __p); return iterator(this, __p);
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
template <class _InputIterator> template <class _InputIterator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 typename enable_if <__is_exactly_cpp17_input_iterator<_InputIterator>::value && _LIBCPP_CONSTEXPR_CXX20 typename enable_if <__is_exactly_cpp17_input_iterator<_InputIterator>::value &&
is_constructible< is_constructible<
_Tp, _Tp,
typename iterator_traits<_InputIterator>::reference>::value, typename iterator_traits<_InputIterator>::reference>::value,
typename vector<_Tp, _Allocator>::iterator typename vector<_Tp, _Allocator>::iterator
>::type >::type
vector<_Tp, _Allocator>::insert(const_iterator __position, _InputIterator __first, _InputIterator __last) vector<_Tp, _Allocator>::insert(const_iterator __position, _InputIterator __first, _InputIterator __last)
{ {
_LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(_VSTD::addressof(__position)) == this, _LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(_VSTD::addressof(__position)) == this,
Show All 31 Lines#endif // _LIBCPP_NO_EXCEPTIONS
__p = _VSTD::rotate(__p, __old_last, this->__end_); __p = _VSTD::rotate(__p, __old_last, this->__end_);
insert(iterator(this, __p), _VSTD::make_move_iterator(__v.begin()), insert(iterator(this, __p), _VSTD::make_move_iterator(__v.begin()),
_VSTD::make_move_iterator(__v.end())); _VSTD::make_move_iterator(__v.end()));
return begin() + __off; return begin() + __off;
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
template <class _ForwardIterator> template <class _ForwardIterator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
typename enable_if typename enable_if
< <
__is_cpp17_forward_iterator<_ForwardIterator>::value && __is_cpp17_forward_iterator<_ForwardIterator>::value &&
is_constructible< is_constructible<
_Tp, _Tp,
typename iterator_traits<_ForwardIterator>::reference>::value, typename iterator_traits<_ForwardIterator>::reference>::value,
typename vector<_Tp, _Allocator>::iterator typename vector<_Tp, _Allocator>::iterator
>::type >::type
Show All 32 Lines if (__n > 0)
__v.__construct_at_end(__first, __last); __v.__construct_at_end(__first, __last);
__p = __swap_out_circular_buffer(__v, __p); __p = __swap_out_circular_buffer(__v, __p);
} }
} }
return iterator(this, __p); return iterator(this, __p);
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
void void
vector<_Tp, _Allocator>::resize(size_type __sz) vector<_Tp, _Allocator>::resize(size_type __sz)
{ {
size_type __cs = size(); size_type __cs = size();
if (__cs < __sz) if (__cs < __sz)
this->__append(__sz - __cs); this->__append(__sz - __cs);
else if (__cs > __sz) else if (__cs > __sz)
this->__destruct_at_end(this->__begin_ + __sz); this->__destruct_at_end(this->__begin_ + __sz);
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
void void
vector<_Tp, _Allocator>::resize(size_type __sz, const_reference __x) vector<_Tp, _Allocator>::resize(size_type __sz, const_reference __x)
{ {
size_type __cs = size(); size_type __cs = size();
if (__cs < __sz) if (__cs < __sz)
this->__append(__sz - __cs, __x); this->__append(__sz - __cs, __x);
else if (__cs > __sz) else if (__cs > __sz)
this->__destruct_at_end(this->__begin_ + __sz); this->__destruct_at_end(this->__begin_ + __sz);
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
void void
vector<_Tp, _Allocator>::swap(vector& __x) vector<_Tp, _Allocator>::swap(vector& __x)
#if _LIBCPP_STD_VER >= 14 #if _LIBCPP_STD_VER >= 14
_NOEXCEPT _NOEXCEPT
#else #else
_NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value || _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value ||
__is_nothrow_swappable<allocator_type>::value) __is_nothrow_swappable<allocator_type>::value)
#endif #endif
{ {
_LIBCPP_ASSERT(__alloc_traits::propagate_on_container_swap::value || _LIBCPP_ASSERT(__alloc_traits::propagate_on_container_swap::value ||
this->__alloc() == __x.__alloc(), this->__alloc() == __x.__alloc(),
"vector::swap: Either propagate_on_container_swap must be true" "vector::swap: Either propagate_on_container_swap must be true"
" or the allocators must compare equal"); " or the allocators must compare equal");
_VSTD::swap(this->__begin_, __x.__begin_); _VSTD::swap(this->__begin_, __x.__begin_);
_VSTD::swap(this->__end_, __x.__end_); _VSTD::swap(this->__end_, __x.__end_);
_VSTD::swap(this->__end_cap(), __x.__end_cap()); _VSTD::swap(this->__end_cap(), __x.__end_cap());
_VSTD::__swap_allocator(this->__alloc(), __x.__alloc(), _VSTD::__swap_allocator(this->__alloc(), __x.__alloc(),
integral_constant<bool,__alloc_traits::propagate_on_container_swap::value>()); integral_constant<bool,__alloc_traits::propagate_on_container_swap::value>());
std::__debug_db_swap(this, std::addressof(__x)); std::__debug_db_swap(this, std::addressof(__x));
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
bool bool
vector<_Tp, _Allocator>::__invariants() const vector<_Tp, _Allocator>::__invariants() const
{ {
if (this->__begin_ == nullptr) if (this->__begin_ == nullptr)
{ {
if (this->__end_ != nullptr || this->__end_cap() != nullptr) if (this->__end_ != nullptr || this->__end_cap() != nullptr)
return false; return false;
} }
▲ Show 20 Lines • Show All 106 Lines • ▼ Show 20 Lines
public: public:
typedef __bit_reference<vector> reference; typedef __bit_reference<vector> reference;
#ifdef _LIBCPP_ABI_BITSET_VECTOR_BOOL_CONST_SUBSCRIPT_RETURN_BOOL #ifdef _LIBCPP_ABI_BITSET_VECTOR_BOOL_CONST_SUBSCRIPT_RETURN_BOOL
using const_reference = bool; using const_reference = bool;
#else #else
typedef __bit_const_reference<vector> const_reference; typedef __bit_const_reference<vector> const_reference;
#endif #endif
private: private:
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
size_type& __cap() _NOEXCEPT size_type& __cap() _NOEXCEPT
{return __cap_alloc_.first();} {return __cap_alloc_.first();}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
const size_type& __cap() const _NOEXCEPT const size_type& __cap() const _NOEXCEPT
{return __cap_alloc_.first();} {return __cap_alloc_.first();}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
__storage_allocator& __alloc() _NOEXCEPT __storage_allocator& __alloc() _NOEXCEPT
{return __cap_alloc_.second();} {return __cap_alloc_.second();}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
const __storage_allocator& __alloc() const _NOEXCEPT const __storage_allocator& __alloc() const _NOEXCEPT
{return __cap_alloc_.second();} {return __cap_alloc_.second();}
static const unsigned __bits_per_word = static_cast<unsigned>(sizeof(__storage_type) * CHAR_BIT); static const unsigned __bits_per_word = static_cast<unsigned>(sizeof(__storage_type) * CHAR_BIT);
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
static size_type __internal_cap_to_external(size_type __n) _NOEXCEPT static size_type __internal_cap_to_external(size_type __n) _NOEXCEPT
{return __n * __bits_per_word;} {return __n * __bits_per_word;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
static size_type __external_cap_to_internal(size_type __n) _NOEXCEPT static size_type __external_cap_to_internal(size_type __n) _NOEXCEPT
{return (__n - 1) / __bits_per_word + 1;} {return (__n - 1) / __bits_per_word + 1;}
public: public:
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
vector() _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value); vector() _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value);
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 explicit vector(const allocator_type& __a) _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 explicit vector(const allocator_type& __a)
#if _LIBCPP_STD_VER <= 14 #if _LIBCPP_STD_VER <= 14
_NOEXCEPT_(is_nothrow_copy_constructible<allocator_type>::value); _NOEXCEPT_(is_nothrow_copy_constructible<allocator_type>::value);
#else #else
_NOEXCEPT; _NOEXCEPT;
#endif #endif
_LIBCPP_CONSTEXPR_AFTER_CXX17 ~vector(); _LIBCPP_CONSTEXPR_CXX20 ~vector();
_LIBCPP_CONSTEXPR_AFTER_CXX17 explicit vector(size_type __n); _LIBCPP_CONSTEXPR_CXX20 explicit vector(size_type __n);
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER > 11
_LIBCPP_CONSTEXPR_AFTER_CXX17 explicit vector(size_type __n, const allocator_type& __a); _LIBCPP_CONSTEXPR_CXX20 explicit vector(size_type __n, const allocator_type& __a);
#endif #endif
_LIBCPP_CONSTEXPR_AFTER_CXX17 vector(size_type __n, const value_type& __v); _LIBCPP_CONSTEXPR_CXX20 vector(size_type __n, const value_type& __v);
_LIBCPP_CONSTEXPR_AFTER_CXX17 vector(size_type __n, const value_type& __v, const allocator_type& __a); _LIBCPP_CONSTEXPR_CXX20 vector(size_type __n, const value_type& __v, const allocator_type& __a);
template <class _InputIterator> template <class _InputIterator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 vector(_InputIterator __first, _InputIterator __last, _LIBCPP_CONSTEXPR_CXX20 vector(_InputIterator __first, _InputIterator __last,
typename enable_if<__is_exactly_cpp17_input_iterator<_InputIterator>::value>::type* = 0); typename enable_if<__is_exactly_cpp17_input_iterator<_InputIterator>::value>::type* = 0);
template <class _InputIterator> template <class _InputIterator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 vector(_InputIterator __first, _InputIterator __last, const allocator_type& __a, _LIBCPP_CONSTEXPR_CXX20 vector(_InputIterator __first, _InputIterator __last, const allocator_type& __a,
typename enable_if<__is_exactly_cpp17_input_iterator<_InputIterator>::value>::type* = 0); typename enable_if<__is_exactly_cpp17_input_iterator<_InputIterator>::value>::type* = 0);
template <class _ForwardIterator> template <class _ForwardIterator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 vector(_ForwardIterator __first, _ForwardIterator __last, _LIBCPP_CONSTEXPR_CXX20 vector(_ForwardIterator __first, _ForwardIterator __last,
typename enable_if<__is_cpp17_forward_iterator<_ForwardIterator>::value>::type* = 0); typename enable_if<__is_cpp17_forward_iterator<_ForwardIterator>::value>::type* = 0);
template <class _ForwardIterator> template <class _ForwardIterator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 vector(_ForwardIterator __first, _ForwardIterator __last, const allocator_type& __a, _LIBCPP_CONSTEXPR_CXX20 vector(_ForwardIterator __first, _ForwardIterator __last, const allocator_type& __a,
typename enable_if<__is_cpp17_forward_iterator<_ForwardIterator>::value>::type* = 0); typename enable_if<__is_cpp17_forward_iterator<_ForwardIterator>::value>::type* = 0);
_LIBCPP_CONSTEXPR_AFTER_CXX17 vector(const vector& __v); _LIBCPP_CONSTEXPR_CXX20 vector(const vector& __v);
_LIBCPP_CONSTEXPR_AFTER_CXX17 vector(const vector& __v, const allocator_type& __a); _LIBCPP_CONSTEXPR_CXX20 vector(const vector& __v, const allocator_type& __a);
_LIBCPP_CONSTEXPR_AFTER_CXX17 vector& operator=(const vector& __v); _LIBCPP_CONSTEXPR_CXX20 vector& operator=(const vector& __v);
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
_LIBCPP_CONSTEXPR_AFTER_CXX17 vector(initializer_list<value_type> __il); _LIBCPP_CONSTEXPR_CXX20 vector(initializer_list<value_type> __il);
_LIBCPP_CONSTEXPR_AFTER_CXX17 vector(initializer_list<value_type> __il, const allocator_type& __a); _LIBCPP_CONSTEXPR_CXX20 vector(initializer_list<value_type> __il, const allocator_type& __a);
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
vector& operator=(initializer_list<value_type> __il) vector& operator=(initializer_list<value_type> __il)
{assign(__il.begin(), __il.end()); return *this;} {assign(__il.begin(), __il.end()); return *this;}
#endif // !_LIBCPP_CXX03_LANG #endif // !_LIBCPP_CXX03_LANG
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
vector(vector&& __v) vector(vector&& __v)
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER > 14
noexcept; noexcept;
#else #else
_NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value); _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value);
#endif #endif
_LIBCPP_CONSTEXPR_AFTER_CXX17 vector(vector&& __v, const __type_identity_t<allocator_type>& __a); _LIBCPP_CONSTEXPR_CXX20 vector(vector&& __v, const __type_identity_t<allocator_type>& __a);
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
vector& operator=(vector&& __v) vector& operator=(vector&& __v)
_NOEXCEPT_((__noexcept_move_assign_container<_Allocator, __alloc_traits>::value)); _NOEXCEPT_((__noexcept_move_assign_container<_Allocator, __alloc_traits>::value));
template <class _InputIterator> template <class _InputIterator>
typename enable_if <__is_exactly_cpp17_input_iterator<_InputIterator>::value, typename enable_if <__is_exactly_cpp17_input_iterator<_InputIterator>::value,
void void
>::type >::type
_LIBCPP_CONSTEXPR_AFTER_CXX17 assign(_InputIterator __first, _InputIterator __last); _LIBCPP_CONSTEXPR_CXX20 assign(_InputIterator __first, _InputIterator __last);
template <class _ForwardIterator> template <class _ForwardIterator>
typename enable_if typename enable_if
< <
__is_cpp17_forward_iterator<_ForwardIterator>::value, __is_cpp17_forward_iterator<_ForwardIterator>::value,
void void
>::type >::type
_LIBCPP_CONSTEXPR_AFTER_CXX17 assign(_ForwardIterator __first, _ForwardIterator __last); _LIBCPP_CONSTEXPR_CXX20 assign(_ForwardIterator __first, _ForwardIterator __last);
_LIBCPP_CONSTEXPR_AFTER_CXX17 void assign(size_type __n, const value_type& __x); _LIBCPP_CONSTEXPR_CXX20 void assign(size_type __n, const value_type& __x);
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
void assign(initializer_list<value_type> __il) void assign(initializer_list<value_type> __il)
{assign(__il.begin(), __il.end());} {assign(__il.begin(), __il.end());}
#endif #endif
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 allocator_type get_allocator() const _NOEXCEPT _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 allocator_type get_allocator() const _NOEXCEPT
{return allocator_type(this->__alloc());} {return allocator_type(this->__alloc());}
_LIBCPP_CONSTEXPR_AFTER_CXX17 size_type max_size() const _NOEXCEPT; _LIBCPP_CONSTEXPR_CXX20 size_type max_size() const _NOEXCEPT;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
size_type capacity() const _NOEXCEPT size_type capacity() const _NOEXCEPT
{return __internal_cap_to_external(__cap());} {return __internal_cap_to_external(__cap());}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
size_type size() const _NOEXCEPT size_type size() const _NOEXCEPT
{return __size_;} {return __size_;}
_LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
bool empty() const _NOEXCEPT bool empty() const _NOEXCEPT
{return __size_ == 0;} {return __size_ == 0;}
_LIBCPP_CONSTEXPR_AFTER_CXX17 void reserve(size_type __n); _LIBCPP_CONSTEXPR_CXX20 void reserve(size_type __n);
_LIBCPP_CONSTEXPR_AFTER_CXX17 void shrink_to_fit() _NOEXCEPT; _LIBCPP_CONSTEXPR_CXX20 void shrink_to_fit() _NOEXCEPT;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
iterator begin() _NOEXCEPT iterator begin() _NOEXCEPT
{return __make_iter(0);} {return __make_iter(0);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
const_iterator begin() const _NOEXCEPT const_iterator begin() const _NOEXCEPT
{return __make_iter(0);} {return __make_iter(0);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
iterator end() _NOEXCEPT iterator end() _NOEXCEPT
{return __make_iter(__size_);} {return __make_iter(__size_);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
const_iterator end() const _NOEXCEPT const_iterator end() const _NOEXCEPT
{return __make_iter(__size_);} {return __make_iter(__size_);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
reverse_iterator rbegin() _NOEXCEPT reverse_iterator rbegin() _NOEXCEPT
{return reverse_iterator(end());} {return reverse_iterator(end());}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
const_reverse_iterator rbegin() const _NOEXCEPT const_reverse_iterator rbegin() const _NOEXCEPT
{return const_reverse_iterator(end());} {return const_reverse_iterator(end());}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
reverse_iterator rend() _NOEXCEPT reverse_iterator rend() _NOEXCEPT
{return reverse_iterator(begin());} {return reverse_iterator(begin());}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
const_reverse_iterator rend() const _NOEXCEPT const_reverse_iterator rend() const _NOEXCEPT
{return const_reverse_iterator(begin());} {return const_reverse_iterator(begin());}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
const_iterator cbegin() const _NOEXCEPT const_iterator cbegin() const _NOEXCEPT
{return __make_iter(0);} {return __make_iter(0);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
const_iterator cend() const _NOEXCEPT const_iterator cend() const _NOEXCEPT
{return __make_iter(__size_);} {return __make_iter(__size_);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
const_reverse_iterator crbegin() const _NOEXCEPT const_reverse_iterator crbegin() const _NOEXCEPT
{return rbegin();} {return rbegin();}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
const_reverse_iterator crend() const _NOEXCEPT const_reverse_iterator crend() const _NOEXCEPT
{return rend();} {return rend();}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 reference operator[](size_type __n) {return __make_ref(__n);} _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 reference operator[](size_type __n) {return __make_ref(__n);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 const_reference operator[](size_type __n) const {return __make_ref(__n);} _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 const_reference operator[](size_type __n) const {return __make_ref(__n);}
reference at(size_type __n); reference at(size_type __n);
const_reference at(size_type __n) const; const_reference at(size_type __n) const;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 reference front() {return __make_ref(0);} _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 reference front() {return __make_ref(0);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 const_reference front() const {return __make_ref(0);} _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 const_reference front() const {return __make_ref(0);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 reference back() {return __make_ref(__size_ - 1);} _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 reference back() {return __make_ref(__size_ - 1);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 const_reference back() const {return __make_ref(__size_ - 1);} _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 const_reference back() const {return __make_ref(__size_ - 1);}
_LIBCPP_CONSTEXPR_AFTER_CXX17 void push_back(const value_type& __x); _LIBCPP_CONSTEXPR_CXX20 void push_back(const value_type& __x);
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER > 11
template <class... _Args> template <class... _Args>
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER > 14
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 reference emplace_back(_Args&&... __args) _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 reference emplace_back(_Args&&... __args)
#else #else
_LIBCPP_INLINE_VISIBILITY void emplace_back(_Args&&... __args) _LIBCPP_INLINE_VISIBILITY void emplace_back(_Args&&... __args)
#endif #endif
{ {
push_back ( value_type ( _VSTD::forward<_Args>(__args)... )); push_back ( value_type ( _VSTD::forward<_Args>(__args)... ));
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER > 14
return this->back(); return this->back();
#endif #endif
} }
#endif #endif
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 void pop_back() {--__size_;} _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 void pop_back() {--__size_;}
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER > 11
template <class... _Args> template <class... _Args>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 iterator emplace(const_iterator __position, _Args&&... __args) _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 iterator emplace(const_iterator __position, _Args&&... __args)
{ return insert ( __position, value_type ( _VSTD::forward<_Args>(__args)... )); } { return insert ( __position, value_type ( _VSTD::forward<_Args>(__args)... )); }
#endif #endif
_LIBCPP_CONSTEXPR_AFTER_CXX17 iterator insert(const_iterator __position, const value_type& __x); _LIBCPP_CONSTEXPR_CXX20 iterator insert(const_iterator __position, const value_type& __x);
_LIBCPP_CONSTEXPR_AFTER_CXX17 iterator insert(const_iterator __position, size_type __n, const value_type& __x); _LIBCPP_CONSTEXPR_CXX20 iterator insert(const_iterator __position, size_type __n, const value_type& __x);
template <class _InputIterator> template <class _InputIterator>
typename enable_if <__is_exactly_cpp17_input_iterator<_InputIterator>::value, typename enable_if <__is_exactly_cpp17_input_iterator<_InputIterator>::value,
iterator iterator
>::type >::type
_LIBCPP_CONSTEXPR_AFTER_CXX17 insert(const_iterator __position, _InputIterator __first, _InputIterator __last); _LIBCPP_CONSTEXPR_CXX20 insert(const_iterator __position, _InputIterator __first, _InputIterator __last);
template <class _ForwardIterator> template <class _ForwardIterator>
typename enable_if typename enable_if
< <
__is_cpp17_forward_iterator<_ForwardIterator>::value, __is_cpp17_forward_iterator<_ForwardIterator>::value,
iterator iterator
>::type >::type
_LIBCPP_CONSTEXPR_AFTER_CXX17 insert(const_iterator __position, _ForwardIterator __first, _ForwardIterator __last); _LIBCPP_CONSTEXPR_CXX20 insert(const_iterator __position, _ForwardIterator __first, _ForwardIterator __last);
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
iterator insert(const_iterator __position, initializer_list<value_type> __il) iterator insert(const_iterator __position, initializer_list<value_type> __il)
{return insert(__position, __il.begin(), __il.end());} {return insert(__position, __il.begin(), __il.end());}
#endif #endif
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 iterator erase(const_iterator __position); _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 iterator erase(const_iterator __position);
_LIBCPP_CONSTEXPR_AFTER_CXX17 iterator erase(const_iterator __first, const_iterator __last); _LIBCPP_CONSTEXPR_CXX20 iterator erase(const_iterator __first, const_iterator __last);
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
void clear() _NOEXCEPT {__size_ = 0;} void clear() _NOEXCEPT {__size_ = 0;}
_LIBCPP_CONSTEXPR_AFTER_CXX17 void swap(vector&) _LIBCPP_CONSTEXPR_CXX20 void swap(vector&)
#if _LIBCPP_STD_VER >= 14 #if _LIBCPP_STD_VER >= 14
_NOEXCEPT; _NOEXCEPT;
#else #else
_NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value || _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value ||
__is_nothrow_swappable<allocator_type>::value); __is_nothrow_swappable<allocator_type>::value);
#endif #endif
_LIBCPP_CONSTEXPR_AFTER_CXX17 static void swap(reference __x, reference __y) _NOEXCEPT { _VSTD::swap(__x, __y); } _LIBCPP_CONSTEXPR_CXX20 static void swap(reference __x, reference __y) _NOEXCEPT { _VSTD::swap(__x, __y); }
_LIBCPP_CONSTEXPR_AFTER_CXX17 void resize(size_type __sz, value_type __x = false); _LIBCPP_CONSTEXPR_CXX20 void resize(size_type __sz, value_type __x = false);
_LIBCPP_CONSTEXPR_AFTER_CXX17 void flip() _NOEXCEPT; _LIBCPP_CONSTEXPR_CXX20 void flip() _NOEXCEPT;
_LIBCPP_CONSTEXPR_AFTER_CXX17 bool __invariants() const; _LIBCPP_CONSTEXPR_CXX20 bool __invariants() const;
private: private:
_LIBCPP_NORETURN _LIBCPP_HIDE_FROM_ABI _LIBCPP_NORETURN _LIBCPP_HIDE_FROM_ABI
void __throw_length_error() const { void __throw_length_error() const {
_VSTD::__throw_length_error("vector"); _VSTD::__throw_length_error("vector");
} }
_LIBCPP_NORETURN _LIBCPP_HIDE_FROM_ABI _LIBCPP_NORETURN _LIBCPP_HIDE_FROM_ABI
void __throw_out_of_range() const { void __throw_out_of_range() const {
_VSTD::__throw_out_of_range("vector"); _VSTD::__throw_out_of_range("vector");
} }
// Allocate space for __n objects // Allocate space for __n objects
// throws length_error if __n > max_size() // throws length_error if __n > max_size()
// throws (probably bad_alloc) if memory run out // throws (probably bad_alloc) if memory run out
// Precondition: __begin_ == __end_ == __cap() == 0 // Precondition: __begin_ == __end_ == __cap() == 0
// Precondition: __n > 0 // Precondition: __n > 0
// Postcondition: capacity() >= __n // Postcondition: capacity() >= __n
// Postcondition: size() == 0 // Postcondition: size() == 0
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 void __vallocate(size_type __n) { _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX20 void __vallocate(size_type __n) {
if (__n > max_size()) if (__n > max_size())
__throw_length_error(); __throw_length_error();
auto __allocation = std::__allocate_at_least(__alloc(), __external_cap_to_internal(__n)); auto __allocation = std::__allocate_at_least(__alloc(), __external_cap_to_internal(__n));
__begin_ = __allocation.ptr; __begin_ = __allocation.ptr;
__size_ = 0; __size_ = 0;
__cap() = __allocation.count; __cap() = __allocation.count;
if (__libcpp_is_constant_evaluated()) { if (__libcpp_is_constant_evaluated()) {
for (size_type __i = 0; __i != __cap(); ++__i) for (size_type __i = 0; __i != __cap(); ++__i)
std::__construct_at(std::__to_address(__begin_) + __i); std::__construct_at(std::__to_address(__begin_) + __i);
} }
} }
_LIBCPP_CONSTEXPR_AFTER_CXX17 void __vdeallocate() _NOEXCEPT; _LIBCPP_CONSTEXPR_CXX20 void __vdeallocate() _NOEXCEPT;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
static size_type __align_it(size_type __new_size) _NOEXCEPT static size_type __align_it(size_type __new_size) _NOEXCEPT
{return (__new_size + (__bits_per_word-1)) & ~((size_type)__bits_per_word-1);} {return (__new_size + (__bits_per_word-1)) & ~((size_type)__bits_per_word-1);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 size_type __recommend(size_type __new_size) const; _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 size_type __recommend(size_type __new_size) const;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 void __construct_at_end(size_type __n, bool __x); _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 void __construct_at_end(size_type __n, bool __x);
template <class _ForwardIterator> template <class _ForwardIterator>
typename enable_if typename enable_if
< <
__is_cpp17_forward_iterator<_ForwardIterator>::value, __is_cpp17_forward_iterator<_ForwardIterator>::value,
void void
>::type >::type
_LIBCPP_CONSTEXPR_AFTER_CXX17 __construct_at_end(_ForwardIterator __first, _ForwardIterator __last); _LIBCPP_CONSTEXPR_CXX20 __construct_at_end(_ForwardIterator __first, _ForwardIterator __last);
_LIBCPP_CONSTEXPR_AFTER_CXX17 void __append(size_type __n, const_reference __x); _LIBCPP_CONSTEXPR_CXX20 void __append(size_type __n, const_reference __x);
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
reference __make_ref(size_type __pos) _NOEXCEPT reference __make_ref(size_type __pos) _NOEXCEPT
{return reference(__begin_ + __pos / __bits_per_word, __storage_type(1) << __pos % __bits_per_word);} {return reference(__begin_ + __pos / __bits_per_word, __storage_type(1) << __pos % __bits_per_word);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
const_reference __make_ref(size_type __pos) const _NOEXCEPT { const_reference __make_ref(size_type __pos) const _NOEXCEPT {
return __bit_const_reference<vector>(__begin_ + __pos / __bits_per_word, return __bit_const_reference<vector>(__begin_ + __pos / __bits_per_word,
__storage_type(1) << __pos % __bits_per_word); __storage_type(1) << __pos % __bits_per_word);
} }
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
iterator __make_iter(size_type __pos) _NOEXCEPT iterator __make_iter(size_type __pos) _NOEXCEPT
{return iterator(__begin_ + __pos / __bits_per_word, static_cast<unsigned>(__pos % __bits_per_word));} {return iterator(__begin_ + __pos / __bits_per_word, static_cast<unsigned>(__pos % __bits_per_word));}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
const_iterator __make_iter(size_type __pos) const _NOEXCEPT const_iterator __make_iter(size_type __pos) const _NOEXCEPT
{return const_iterator(__begin_ + __pos / __bits_per_word, static_cast<unsigned>(__pos % __bits_per_word));} {return const_iterator(__begin_ + __pos / __bits_per_word, static_cast<unsigned>(__pos % __bits_per_word));}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
iterator __const_iterator_cast(const_iterator __p) _NOEXCEPT iterator __const_iterator_cast(const_iterator __p) _NOEXCEPT
{return begin() + (__p - cbegin());} {return begin() + (__p - cbegin());}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
void __copy_assign_alloc(const vector& __v) void __copy_assign_alloc(const vector& __v)
{__copy_assign_alloc(__v, integral_constant<bool, {__copy_assign_alloc(__v, integral_constant<bool,
__storage_traits::propagate_on_container_copy_assignment::value>());} __storage_traits::propagate_on_container_copy_assignment::value>());}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
void __copy_assign_alloc(const vector& __c, true_type) void __copy_assign_alloc(const vector& __c, true_type)
{ {
if (__alloc() != __c.__alloc()) if (__alloc() != __c.__alloc())
__vdeallocate(); __vdeallocate();
__alloc() = __c.__alloc(); __alloc() = __c.__alloc();
} }
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
void __copy_assign_alloc(const vector&, false_type) void __copy_assign_alloc(const vector&, false_type)
{} {}
_LIBCPP_CONSTEXPR_AFTER_CXX17 void __move_assign(vector& __c, false_type); _LIBCPP_CONSTEXPR_CXX20 void __move_assign(vector& __c, false_type);
_LIBCPP_CONSTEXPR_AFTER_CXX17 void __move_assign(vector& __c, true_type) _LIBCPP_CONSTEXPR_CXX20 void __move_assign(vector& __c, true_type)
_NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value); _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value);
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
void __move_assign_alloc(vector& __c) void __move_assign_alloc(vector& __c)
_NOEXCEPT_( _NOEXCEPT_(
!__storage_traits::propagate_on_container_move_assignment::value || !__storage_traits::propagate_on_container_move_assignment::value ||
is_nothrow_move_assignable<allocator_type>::value) is_nothrow_move_assignable<allocator_type>::value)
{__move_assign_alloc(__c, integral_constant<bool, {__move_assign_alloc(__c, integral_constant<bool,
__storage_traits::propagate_on_container_move_assignment::value>());} __storage_traits::propagate_on_container_move_assignment::value>());}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
void __move_assign_alloc(vector& __c, true_type) void __move_assign_alloc(vector& __c, true_type)
_NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value) _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value)
{ {
__alloc() = _VSTD::move(__c.__alloc()); __alloc() = _VSTD::move(__c.__alloc());
} }
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
void __move_assign_alloc(vector&, false_type) void __move_assign_alloc(vector&, false_type)
_NOEXCEPT _NOEXCEPT
{} {}
_LIBCPP_CONSTEXPR_AFTER_CXX17 size_t __hash_code() const _NOEXCEPT; _LIBCPP_CONSTEXPR_CXX20 size_t __hash_code() const _NOEXCEPT;
friend class __bit_reference<vector>; friend class __bit_reference<vector>;
friend class __bit_const_reference<vector>; friend class __bit_const_reference<vector>;
friend class __bit_iterator<vector, false>; friend class __bit_iterator<vector, false>;
friend class __bit_iterator<vector, true>; friend class __bit_iterator<vector, true>;
friend struct __bit_array<vector>; friend struct __bit_array<vector>;
friend struct _LIBCPP_TEMPLATE_VIS hash<vector>; friend struct _LIBCPP_TEMPLATE_VIS hash<vector>;
}; };
template <class _Allocator> template <class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 void _LIBCPP_CONSTEXPR_CXX20 void
vector<bool, _Allocator>::__vdeallocate() _NOEXCEPT vector<bool, _Allocator>::__vdeallocate() _NOEXCEPT
{ {
if (this->__begin_ != nullptr) if (this->__begin_ != nullptr)
{ {
__storage_traits::deallocate(this->__alloc(), this->__begin_, __cap()); __storage_traits::deallocate(this->__alloc(), this->__begin_, __cap());
std::__debug_db_invalidate_all(this); std::__debug_db_invalidate_all(this);
this->__begin_ = nullptr; this->__begin_ = nullptr;
this->__size_ = this->__cap() = 0; this->__size_ = this->__cap() = 0;
} }
} }
template <class _Allocator> template <class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
typename vector<bool, _Allocator>::size_type typename vector<bool, _Allocator>::size_type
vector<bool, _Allocator>::max_size() const _NOEXCEPT vector<bool, _Allocator>::max_size() const _NOEXCEPT
{ {
size_type __amax = __storage_traits::max_size(__alloc()); size_type __amax = __storage_traits::max_size(__alloc());
size_type __nmax = numeric_limits<size_type>::max() / 2; // end() >= begin(), always size_type __nmax = numeric_limits<size_type>::max() / 2; // end() >= begin(), always
if (__nmax / __bits_per_word <= __amax) if (__nmax / __bits_per_word <= __amax)
return __nmax; return __nmax;
return __internal_cap_to_external(__amax); return __internal_cap_to_external(__amax);
} }
// Precondition: __new_size > capacity() // Precondition: __new_size > capacity()
template <class _Allocator> template <class _Allocator>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
typename vector<bool, _Allocator>::size_type typename vector<bool, _Allocator>::size_type
vector<bool, _Allocator>::__recommend(size_type __new_size) const vector<bool, _Allocator>::__recommend(size_type __new_size) const
{ {
const size_type __ms = max_size(); const size_type __ms = max_size();
if (__new_size > __ms) if (__new_size > __ms)
this->__throw_length_error(); this->__throw_length_error();
const size_type __cap = capacity(); const size_type __cap = capacity();
if (__cap >= __ms / 2) if (__cap >= __ms / 2)
return __ms; return __ms;
return _VSTD::max(2 * __cap, __align_it(__new_size)); return _VSTD::max(2 * __cap, __align_it(__new_size));
} }
// Default constructs __n objects starting at __end_ // Default constructs __n objects starting at __end_
// Precondition: __n > 0 // Precondition: __n > 0
// Precondition: size() + __n <= capacity() // Precondition: size() + __n <= capacity()
// Postcondition: size() == size() + __n // Postcondition: size() == size() + __n
template <class _Allocator> template <class _Allocator>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
void void
vector<bool, _Allocator>::__construct_at_end(size_type __n, bool __x) vector<bool, _Allocator>::__construct_at_end(size_type __n, bool __x)
{ {
size_type __old_size = this->__size_; size_type __old_size = this->__size_;
this->__size_ += __n; this->__size_ += __n;
if (__old_size == 0 || ((__old_size - 1) / __bits_per_word) != ((this->__size_ - 1) / __bits_per_word)) if (__old_size == 0 || ((__old_size - 1) / __bits_per_word) != ((this->__size_ - 1) / __bits_per_word))
{ {
if (this->__size_ <= __bits_per_word) if (this->__size_ <= __bits_per_word)
this->__begin_[0] = __storage_type(0); this->__begin_[0] = __storage_type(0);
else else
this->__begin_[(this->__size_ - 1) / __bits_per_word] = __storage_type(0); this->__begin_[(this->__size_ - 1) / __bits_per_word] = __storage_type(0);
} }
_VSTD::fill_n(__make_iter(__old_size), __n, __x); _VSTD::fill_n(__make_iter(__old_size), __n, __x);
} }
template <class _Allocator> template <class _Allocator>
template <class _ForwardIterator> template <class _ForwardIterator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
typename enable_if typename enable_if
< <
__is_cpp17_forward_iterator<_ForwardIterator>::value, __is_cpp17_forward_iterator<_ForwardIterator>::value,
void void
>::type >::type
vector<bool, _Allocator>::__construct_at_end(_ForwardIterator __first, _ForwardIterator __last) vector<bool, _Allocator>::__construct_at_end(_ForwardIterator __first, _ForwardIterator __last)
{ {
size_type __old_size = this->__size_; size_type __old_size = this->__size_;
this->__size_ += _VSTD::distance(__first, __last); this->__size_ += _VSTD::distance(__first, __last);
if (__old_size == 0 || ((__old_size - 1) / __bits_per_word) != ((this->__size_ - 1) / __bits_per_word)) if (__old_size == 0 || ((__old_size - 1) / __bits_per_word) != ((this->__size_ - 1) / __bits_per_word))
{ {
if (this->__size_ <= __bits_per_word) if (this->__size_ <= __bits_per_word)
this->__begin_[0] = __storage_type(0); this->__begin_[0] = __storage_type(0);
else else
this->__begin_[(this->__size_ - 1) / __bits_per_word] = __storage_type(0); this->__begin_[(this->__size_ - 1) / __bits_per_word] = __storage_type(0);
} }
_VSTD::copy(__first, __last, __make_iter(__old_size)); _VSTD::copy(__first, __last, __make_iter(__old_size));
} }
template <class _Allocator> template <class _Allocator>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
vector<bool, _Allocator>::vector() vector<bool, _Allocator>::vector()
_NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value) _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value)
: __begin_(nullptr), : __begin_(nullptr),
__size_(0), __size_(0),
__cap_alloc_(0, __default_init_tag()) __cap_alloc_(0, __default_init_tag())
{ {
} }
template <class _Allocator> template <class _Allocator>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
vector<bool, _Allocator>::vector(const allocator_type& __a) vector<bool, _Allocator>::vector(const allocator_type& __a)
#if _LIBCPP_STD_VER <= 14 #if _LIBCPP_STD_VER <= 14
_NOEXCEPT_(is_nothrow_copy_constructible<allocator_type>::value) _NOEXCEPT_(is_nothrow_copy_constructible<allocator_type>::value)
#else #else
_NOEXCEPT _NOEXCEPT
#endif #endif
: __begin_(nullptr), : __begin_(nullptr),
__size_(0), __size_(0),
__cap_alloc_(0, static_cast<__storage_allocator>(__a)) __cap_alloc_(0, static_cast<__storage_allocator>(__a))
{ {
} }
template <class _Allocator> template <class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
vector<bool, _Allocator>::vector(size_type __n) vector<bool, _Allocator>::vector(size_type __n)
: __begin_(nullptr), : __begin_(nullptr),
__size_(0), __size_(0),
__cap_alloc_(0, __default_init_tag()) __cap_alloc_(0, __default_init_tag())
{ {
if (__n > 0) if (__n > 0)
{ {
__vallocate(__n); __vallocate(__n);
__construct_at_end(__n, false); __construct_at_end(__n, false);
} }
} }
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER > 11
template <class _Allocator> template <class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
vector<bool, _Allocator>::vector(size_type __n, const allocator_type& __a) vector<bool, _Allocator>::vector(size_type __n, const allocator_type& __a)
: __begin_(nullptr), : __begin_(nullptr),
__size_(0), __size_(0),
__cap_alloc_(0, static_cast<__storage_allocator>(__a)) __cap_alloc_(0, static_cast<__storage_allocator>(__a))
{ {
if (__n > 0) if (__n > 0)
{ {
__vallocate(__n); __vallocate(__n);
__construct_at_end(__n, false); __construct_at_end(__n, false);
} }
} }
#endif #endif
template <class _Allocator> template <class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
vector<bool, _Allocator>::vector(size_type __n, const value_type& __x) vector<bool, _Allocator>::vector(size_type __n, const value_type& __x)
: __begin_(nullptr), : __begin_(nullptr),
__size_(0), __size_(0),
__cap_alloc_(0, __default_init_tag()) __cap_alloc_(0, __default_init_tag())
{ {
if (__n > 0) if (__n > 0)
{ {
__vallocate(__n); __vallocate(__n);
__construct_at_end(__n, __x); __construct_at_end(__n, __x);
} }
} }
template <class _Allocator> template <class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
vector<bool, _Allocator>::vector(size_type __n, const value_type& __x, const allocator_type& __a) vector<bool, _Allocator>::vector(size_type __n, const value_type& __x, const allocator_type& __a)
: __begin_(nullptr), : __begin_(nullptr),
__size_(0), __size_(0),
__cap_alloc_(0, static_cast<__storage_allocator>(__a)) __cap_alloc_(0, static_cast<__storage_allocator>(__a))
{ {
if (__n > 0) if (__n > 0)
{ {
__vallocate(__n); __vallocate(__n);
__construct_at_end(__n, __x); __construct_at_end(__n, __x);
} }
} }
template <class _Allocator> template <class _Allocator>
template <class _InputIterator> template <class _InputIterator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
vector<bool, _Allocator>::vector(_InputIterator __first, _InputIterator __last, vector<bool, _Allocator>::vector(_InputIterator __first, _InputIterator __last,
typename enable_if<__is_exactly_cpp17_input_iterator<_InputIterator>::value>::type*) typename enable_if<__is_exactly_cpp17_input_iterator<_InputIterator>::value>::type*)
: __begin_(nullptr), : __begin_(nullptr),
__size_(0), __size_(0),
__cap_alloc_(0, __default_init_tag()) __cap_alloc_(0, __default_init_tag())
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_NO_EXCEPTIONS
try try
Show All 10 Lines catch (...)
std::__debug_db_invalidate_all(this); std::__debug_db_invalidate_all(this);
throw; throw;
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_NO_EXCEPTIONS
} }
template <class _Allocator> template <class _Allocator>
template <class _InputIterator> template <class _InputIterator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
vector<bool, _Allocator>::vector(_InputIterator __first, _InputIterator __last, const allocator_type& __a, vector<bool, _Allocator>::vector(_InputIterator __first, _InputIterator __last, const allocator_type& __a,
typename enable_if<__is_exactly_cpp17_input_iterator<_InputIterator>::value>::type*) typename enable_if<__is_exactly_cpp17_input_iterator<_InputIterator>::value>::type*)
: __begin_(nullptr), : __begin_(nullptr),
__size_(0), __size_(0),
__cap_alloc_(0, static_cast<__storage_allocator>(__a)) __cap_alloc_(0, static_cast<__storage_allocator>(__a))
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_NO_EXCEPTIONS
try try
Show All 10 Lines catch (...)
std::__debug_db_invalidate_all(this); std::__debug_db_invalidate_all(this);
throw; throw;
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_NO_EXCEPTIONS
} }
template <class _Allocator> template <class _Allocator>
template <class _ForwardIterator> template <class _ForwardIterator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
vector<bool, _Allocator>::vector(_ForwardIterator __first, _ForwardIterator __last, vector<bool, _Allocator>::vector(_ForwardIterator __first, _ForwardIterator __last,
typename enable_if<__is_cpp17_forward_iterator<_ForwardIterator>::value>::type*) typename enable_if<__is_cpp17_forward_iterator<_ForwardIterator>::value>::type*)
: __begin_(nullptr), : __begin_(nullptr),
__size_(0), __size_(0),
__cap_alloc_(0, __default_init_tag()) __cap_alloc_(0, __default_init_tag())
{ {
size_type __n = static_cast<size_type>(_VSTD::distance(__first, __last)); size_type __n = static_cast<size_type>(_VSTD::distance(__first, __last));
if (__n > 0) if (__n > 0)
{ {
__vallocate(__n); __vallocate(__n);
__construct_at_end(__first, __last); __construct_at_end(__first, __last);
} }
} }
template <class _Allocator> template <class _Allocator>
template <class _ForwardIterator> template <class _ForwardIterator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
vector<bool, _Allocator>::vector(_ForwardIterator __first, _ForwardIterator __last, const allocator_type& __a, vector<bool, _Allocator>::vector(_ForwardIterator __first, _ForwardIterator __last, const allocator_type& __a,
typename enable_if<__is_cpp17_forward_iterator<_ForwardIterator>::value>::type*) typename enable_if<__is_cpp17_forward_iterator<_ForwardIterator>::value>::type*)
: __begin_(nullptr), : __begin_(nullptr),
__size_(0), __size_(0),
__cap_alloc_(0, static_cast<__storage_allocator>(__a)) __cap_alloc_(0, static_cast<__storage_allocator>(__a))
{ {
size_type __n = static_cast<size_type>(_VSTD::distance(__first, __last)); size_type __n = static_cast<size_type>(_VSTD::distance(__first, __last));
if (__n > 0) if (__n > 0)
{ {
__vallocate(__n); __vallocate(__n);
__construct_at_end(__first, __last); __construct_at_end(__first, __last);
} }
} }
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
template <class _Allocator> template <class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
vector<bool, _Allocator>::vector(initializer_list<value_type> __il) vector<bool, _Allocator>::vector(initializer_list<value_type> __il)
: __begin_(nullptr), : __begin_(nullptr),
__size_(0), __size_(0),
__cap_alloc_(0, __default_init_tag()) __cap_alloc_(0, __default_init_tag())
{ {
size_type __n = static_cast<size_type>(__il.size()); size_type __n = static_cast<size_type>(__il.size());
if (__n > 0) if (__n > 0)
{ {
__vallocate(__n); __vallocate(__n);
__construct_at_end(__il.begin(), __il.end()); __construct_at_end(__il.begin(), __il.end());
} }
} }
template <class _Allocator> template <class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
vector<bool, _Allocator>::vector(initializer_list<value_type> __il, const allocator_type& __a) vector<bool, _Allocator>::vector(initializer_list<value_type> __il, const allocator_type& __a)
: __begin_(nullptr), : __begin_(nullptr),
__size_(0), __size_(0),
__cap_alloc_(0, static_cast<__storage_allocator>(__a)) __cap_alloc_(0, static_cast<__storage_allocator>(__a))
{ {
size_type __n = static_cast<size_type>(__il.size()); size_type __n = static_cast<size_type>(__il.size());
if (__n > 0) if (__n > 0)
{ {
__vallocate(__n); __vallocate(__n);
__construct_at_end(__il.begin(), __il.end()); __construct_at_end(__il.begin(), __il.end());
} }
} }
#endif // _LIBCPP_CXX03_LANG #endif // _LIBCPP_CXX03_LANG
template <class _Allocator> template <class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
vector<bool, _Allocator>::~vector() vector<bool, _Allocator>::~vector()
{ {
if (__begin_ != nullptr) if (__begin_ != nullptr)
__storage_traits::deallocate(__alloc(), __begin_, __cap()); __storage_traits::deallocate(__alloc(), __begin_, __cap());
std::__debug_db_invalidate_all(this); std::__debug_db_invalidate_all(this);
} }
template <class _Allocator> template <class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
vector<bool, _Allocator>::vector(const vector& __v) vector<bool, _Allocator>::vector(const vector& __v)
: __begin_(nullptr), : __begin_(nullptr),
__size_(0), __size_(0),
__cap_alloc_(0, __storage_traits::select_on_container_copy_construction(__v.__alloc())) __cap_alloc_(0, __storage_traits::select_on_container_copy_construction(__v.__alloc()))
{ {
if (__v.size() > 0) if (__v.size() > 0)
{ {
__vallocate(__v.size()); __vallocate(__v.size());
__construct_at_end(__v.begin(), __v.end()); __construct_at_end(__v.begin(), __v.end());
} }
} }
template <class _Allocator> template <class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
vector<bool, _Allocator>::vector(const vector& __v, const allocator_type& __a) vector<bool, _Allocator>::vector(const vector& __v, const allocator_type& __a)
: __begin_(nullptr), : __begin_(nullptr),
__size_(0), __size_(0),
__cap_alloc_(0, __a) __cap_alloc_(0, __a)
{ {
if (__v.size() > 0) if (__v.size() > 0)
{ {
__vallocate(__v.size()); __vallocate(__v.size());
__construct_at_end(__v.begin(), __v.end()); __construct_at_end(__v.begin(), __v.end());
} }
} }
template <class _Allocator> template <class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
vector<bool, _Allocator>& vector<bool, _Allocator>&
vector<bool, _Allocator>::operator=(const vector& __v) vector<bool, _Allocator>::operator=(const vector& __v)
{ {
if (this != _VSTD::addressof(__v)) if (this != _VSTD::addressof(__v))
{ {
__copy_assign_alloc(__v); __copy_assign_alloc(__v);
if (__v.__size_) if (__v.__size_)
{ {
if (__v.__size_ > capacity()) if (__v.__size_ > capacity())
{ {
__vdeallocate(); __vdeallocate();
__vallocate(__v.__size_); __vallocate(__v.__size_);
} }
_VSTD::copy(__v.__begin_, __v.__begin_ + __external_cap_to_internal(__v.__size_), __begin_); _VSTD::copy(__v.__begin_, __v.__begin_ + __external_cap_to_internal(__v.__size_), __begin_);
} }
__size_ = __v.__size_; __size_ = __v.__size_;
} }
return *this; return *this;
} }
template <class _Allocator> template <class _Allocator>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 vector<bool, _Allocator>::vector(vector&& __v) inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20 vector<bool, _Allocator>::vector(vector&& __v)
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER > 14
_NOEXCEPT _NOEXCEPT
#else #else
_NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value) _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value)
#endif #endif
: __begin_(__v.__begin_), : __begin_(__v.__begin_),
__size_(__v.__size_), __size_(__v.__size_),
__cap_alloc_(_VSTD::move(__v.__cap_alloc_)) { __cap_alloc_(_VSTD::move(__v.__cap_alloc_)) {
__v.__begin_ = nullptr; __v.__begin_ = nullptr;
__v.__size_ = 0; __v.__size_ = 0;
__v.__cap() = 0; __v.__cap() = 0;
} }
template <class _Allocator> template <class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
vector<bool, _Allocator>::vector(vector&& __v, const __type_identity_t<allocator_type>& __a) vector<bool, _Allocator>::vector(vector&& __v, const __type_identity_t<allocator_type>& __a)
: __begin_(nullptr), : __begin_(nullptr),
__size_(0), __size_(0),
__cap_alloc_(0, __a) __cap_alloc_(0, __a)
{ {
if (__a == allocator_type(__v.__alloc())) if (__a == allocator_type(__v.__alloc()))
{ {
this->__begin_ = __v.__begin_; this->__begin_ = __v.__begin_;
this->__size_ = __v.__size_; this->__size_ = __v.__size_;
this->__cap() = __v.__cap(); this->__cap() = __v.__cap();
__v.__begin_ = nullptr; __v.__begin_ = nullptr;
__v.__cap() = __v.__size_ = 0; __v.__cap() = __v.__size_ = 0;
} }
else if (__v.size() > 0) else if (__v.size() > 0)
{ {
__vallocate(__v.size()); __vallocate(__v.size());
__construct_at_end(__v.begin(), __v.end()); __construct_at_end(__v.begin(), __v.end());
} }
} }
template <class _Allocator> template <class _Allocator>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
vector<bool, _Allocator>& vector<bool, _Allocator>&
vector<bool, _Allocator>::operator=(vector&& __v) vector<bool, _Allocator>::operator=(vector&& __v)
_NOEXCEPT_((__noexcept_move_assign_container<_Allocator, __alloc_traits>::value)) _NOEXCEPT_((__noexcept_move_assign_container<_Allocator, __alloc_traits>::value))
{ {
__move_assign(__v, integral_constant<bool, __move_assign(__v, integral_constant<bool,
__storage_traits::propagate_on_container_move_assignment::value>()); __storage_traits::propagate_on_container_move_assignment::value>());
return *this; return *this;
} }
template <class _Allocator> template <class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 void _LIBCPP_CONSTEXPR_CXX20 void
vector<bool, _Allocator>::__move_assign(vector& __c, false_type) vector<bool, _Allocator>::__move_assign(vector& __c, false_type)
{ {
if (__alloc() != __c.__alloc()) if (__alloc() != __c.__alloc())
assign(__c.begin(), __c.end()); assign(__c.begin(), __c.end());
else else
__move_assign(__c, true_type()); __move_assign(__c, true_type());
} }
template <class _Allocator> template <class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 void _LIBCPP_CONSTEXPR_CXX20 void
vector<bool, _Allocator>::__move_assign(vector& __c, true_type) vector<bool, _Allocator>::__move_assign(vector& __c, true_type)
_NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value) _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value)
{ {
__vdeallocate(); __vdeallocate();
__move_assign_alloc(__c); __move_assign_alloc(__c);
this->__begin_ = __c.__begin_; this->__begin_ = __c.__begin_;
this->__size_ = __c.__size_; this->__size_ = __c.__size_;
this->__cap() = __c.__cap(); this->__cap() = __c.__cap();
__c.__begin_ = nullptr; __c.__begin_ = nullptr;
__c.__cap() = __c.__size_ = 0; __c.__cap() = __c.__size_ = 0;
} }
template <class _Allocator> template <class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 void _LIBCPP_CONSTEXPR_CXX20 void
vector<bool, _Allocator>::assign(size_type __n, const value_type& __x) vector<bool, _Allocator>::assign(size_type __n, const value_type& __x)
{ {
__size_ = 0; __size_ = 0;
if (__n > 0) if (__n > 0)
{ {
size_type __c = capacity(); size_type __c = capacity();
if (__n <= __c) if (__n <= __c)
__size_ = __n; __size_ = __n;
else else
{ {
vector __v(get_allocator()); vector __v(get_allocator());
__v.reserve(__recommend(__n)); __v.reserve(__recommend(__n));
__v.__size_ = __n; __v.__size_ = __n;
swap(__v); swap(__v);
} }
_VSTD::fill_n(begin(), __n, __x); _VSTD::fill_n(begin(), __n, __x);
} }
std::__debug_db_invalidate_all(this); std::__debug_db_invalidate_all(this);
} }
template <class _Allocator> template <class _Allocator>
template <class _InputIterator> template <class _InputIterator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 typename enable_if <__is_exactly_cpp17_input_iterator<_InputIterator>::value, _LIBCPP_CONSTEXPR_CXX20 typename enable_if <__is_exactly_cpp17_input_iterator<_InputIterator>::value,
void void
>::type >::type
vector<bool, _Allocator>::assign(_InputIterator __first, _InputIterator __last) vector<bool, _Allocator>::assign(_InputIterator __first, _InputIterator __last)
{ {
clear(); clear();
for (; __first != __last; ++__first) for (; __first != __last; ++__first)
push_back(*__first); push_back(*__first);
} }
template <class _Allocator> template <class _Allocator>
template <class _ForwardIterator> template <class _ForwardIterator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
typename enable_if typename enable_if
< <
__is_cpp17_forward_iterator<_ForwardIterator>::value, __is_cpp17_forward_iterator<_ForwardIterator>::value,
void void
>::type >::type
vector<bool, _Allocator>::assign(_ForwardIterator __first, _ForwardIterator __last) vector<bool, _Allocator>::assign(_ForwardIterator __first, _ForwardIterator __last)
{ {
clear(); clear();
difference_type __ns = _VSTD::distance(__first, __last); difference_type __ns = _VSTD::distance(__first, __last);
_LIBCPP_ASSERT(__ns >= 0, "invalid range specified"); _LIBCPP_ASSERT(__ns >= 0, "invalid range specified");
const size_t __n = static_cast<size_type>(__ns); const size_t __n = static_cast<size_type>(__ns);
if (__n) if (__n)
{ {
if (__n > capacity()) if (__n > capacity())
{ {
__vdeallocate(); __vdeallocate();
__vallocate(__n); __vallocate(__n);
} }
__construct_at_end(__first, __last); __construct_at_end(__first, __last);
} }
} }
template <class _Allocator> template <class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 void _LIBCPP_CONSTEXPR_CXX20 void
vector<bool, _Allocator>::reserve(size_type __n) vector<bool, _Allocator>::reserve(size_type __n)
{ {
if (__n > capacity()) if (__n > capacity())
{ {
if (__n > max_size()) if (__n > max_size())
this->__throw_length_error(); this->__throw_length_error();
vector __v(this->get_allocator()); vector __v(this->get_allocator());
__v.__vallocate(__n); __v.__vallocate(__n);
__v.__construct_at_end(this->begin(), this->end()); __v.__construct_at_end(this->begin(), this->end());
swap(__v); swap(__v);
std::__debug_db_invalidate_all(this); std::__debug_db_invalidate_all(this);
} }
} }
template <class _Allocator> template <class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 void _LIBCPP_CONSTEXPR_CXX20 void
vector<bool, _Allocator>::shrink_to_fit() _NOEXCEPT vector<bool, _Allocator>::shrink_to_fit() _NOEXCEPT
{ {
if (__external_cap_to_internal(size()) > __cap()) if (__external_cap_to_internal(size()) > __cap())
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_NO_EXCEPTIONS
Show All 21 Lines
vector<bool, _Allocator>::at(size_type __n) const vector<bool, _Allocator>::at(size_type __n) const
{ {
if (__n >= size()) if (__n >= size())
this->__throw_out_of_range(); this->__throw_out_of_range();
return (*this)[__n]; return (*this)[__n];
} }
template <class _Allocator> template <class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 void _LIBCPP_CONSTEXPR_CXX20 void
vector<bool, _Allocator>::push_back(const value_type& __x) vector<bool, _Allocator>::push_back(const value_type& __x)
{ {
if (this->__size_ == this->capacity()) if (this->__size_ == this->capacity())
reserve(__recommend(this->__size_ + 1)); reserve(__recommend(this->__size_ + 1));
++this->__size_; ++this->__size_;
back() = __x; back() = __x;
} }
template <class _Allocator> template <class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 typename vector<bool, _Allocator>::iterator _LIBCPP_CONSTEXPR_CXX20 typename vector<bool, _Allocator>::iterator
vector<bool, _Allocator>::insert(const_iterator __position, const value_type& __x) vector<bool, _Allocator>::insert(const_iterator __position, const value_type& __x)
{ {
iterator __r; iterator __r;
if (size() < capacity()) if (size() < capacity())
{ {
const_iterator __old_end = end(); const_iterator __old_end = end();
++__size_; ++__size_;
_VSTD::copy_backward(__position, __old_end, end()); _VSTD::copy_backward(__position, __old_end, end());
__r = __const_iterator_cast(__position); __r = __const_iterator_cast(__position);
} }
else else
{ {
vector __v(get_allocator()); vector __v(get_allocator());
__v.reserve(__recommend(__size_ + 1)); __v.reserve(__recommend(__size_ + 1));
__v.__size_ = __size_ + 1; __v.__size_ = __size_ + 1;
__r = _VSTD::copy(cbegin(), __position, __v.begin()); __r = _VSTD::copy(cbegin(), __position, __v.begin());
_VSTD::copy_backward(__position, cend(), __v.end()); _VSTD::copy_backward(__position, cend(), __v.end());
swap(__v); swap(__v);
} }
*__r = __x; *__r = __x;
return __r; return __r;
} }
template <class _Allocator> template <class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 typename vector<bool, _Allocator>::iterator _LIBCPP_CONSTEXPR_CXX20 typename vector<bool, _Allocator>::iterator
vector<bool, _Allocator>::insert(const_iterator __position, size_type __n, const value_type& __x) vector<bool, _Allocator>::insert(const_iterator __position, size_type __n, const value_type& __x)
{ {
iterator __r; iterator __r;
size_type __c = capacity(); size_type __c = capacity();
if (__n <= __c && size() <= __c - __n) if (__n <= __c && size() <= __c - __n)
{ {
const_iterator __old_end = end(); const_iterator __old_end = end();
__size_ += __n; __size_ += __n;
Show All 10 Lines else
swap(__v); swap(__v);
} }
_VSTD::fill_n(__r, __n, __x); _VSTD::fill_n(__r, __n, __x);
return __r; return __r;
} }
template <class _Allocator> template <class _Allocator>
template <class _InputIterator> template <class _InputIterator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 typename enable_if <__is_exactly_cpp17_input_iterator<_InputIterator>::value, _LIBCPP_CONSTEXPR_CXX20 typename enable_if <__is_exactly_cpp17_input_iterator<_InputIterator>::value,
typename vector<bool, _Allocator>::iterator typename vector<bool, _Allocator>::iterator
>::type >::type
vector<bool, _Allocator>::insert(const_iterator __position, _InputIterator __first, _InputIterator __last) vector<bool, _Allocator>::insert(const_iterator __position, _InputIterator __first, _InputIterator __last)
{ {
difference_type __off = __position - begin(); difference_type __off = __position - begin();
iterator __p = __const_iterator_cast(__position); iterator __p = __const_iterator_cast(__position);
iterator __old_end = end(); iterator __old_end = end();
for (; size() != capacity() && __first != __last; ++__first) for (; size() != capacity() && __first != __last; ++__first)
Show All 25 Lines#endif // _LIBCPP_NO_EXCEPTIONS
} }
__p = _VSTD::rotate(__p, __old_end, end()); __p = _VSTD::rotate(__p, __old_end, end());
insert(__p, __v.begin(), __v.end()); insert(__p, __v.begin(), __v.end());
return begin() + __off; return begin() + __off;
} }
template <class _Allocator> template <class _Allocator>
template <class _ForwardIterator> template <class _ForwardIterator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
typename enable_if typename enable_if
< <
__is_cpp17_forward_iterator<_ForwardIterator>::value, __is_cpp17_forward_iterator<_ForwardIterator>::value,
typename vector<bool, _Allocator>::iterator typename vector<bool, _Allocator>::iterator
>::type >::type
vector<bool, _Allocator>::insert(const_iterator __position, _ForwardIterator __first, _ForwardIterator __last) vector<bool, _Allocator>::insert(const_iterator __position, _ForwardIterator __first, _ForwardIterator __last)
{ {
const difference_type __n_signed = _VSTD::distance(__first, __last); const difference_type __n_signed = _VSTD::distance(__first, __last);
Show All 17 Lines else
_VSTD::copy_backward(__position, cend(), __v.end()); _VSTD::copy_backward(__position, cend(), __v.end());
swap(__v); swap(__v);
} }
_VSTD::copy(__first, __last, __r); _VSTD::copy(__first, __last, __r);
return __r; return __r;
} }
template <class _Allocator> template <class _Allocator>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
typename vector<bool, _Allocator>::iterator typename vector<bool, _Allocator>::iterator
vector<bool, _Allocator>::erase(const_iterator __position) vector<bool, _Allocator>::erase(const_iterator __position)
{ {
iterator __r = __const_iterator_cast(__position); iterator __r = __const_iterator_cast(__position);
_VSTD::copy(__position + 1, this->cend(), __r); _VSTD::copy(__position + 1, this->cend(), __r);
--__size_; --__size_;
return __r; return __r;
} }
template <class _Allocator> template <class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
typename vector<bool, _Allocator>::iterator typename vector<bool, _Allocator>::iterator
vector<bool, _Allocator>::erase(const_iterator __first, const_iterator __last) vector<bool, _Allocator>::erase(const_iterator __first, const_iterator __last)
{ {
iterator __r = __const_iterator_cast(__first); iterator __r = __const_iterator_cast(__first);
difference_type __d = __last - __first; difference_type __d = __last - __first;
_VSTD::copy(__last, this->cend(), __r); _VSTD::copy(__last, this->cend(), __r);
__size_ -= __d; __size_ -= __d;
return __r; return __r;
} }
template <class _Allocator> template <class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 void _LIBCPP_CONSTEXPR_CXX20 void
vector<bool, _Allocator>::swap(vector& __x) vector<bool, _Allocator>::swap(vector& __x)
#if _LIBCPP_STD_VER >= 14 #if _LIBCPP_STD_VER >= 14
_NOEXCEPT _NOEXCEPT
#else #else
_NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value || _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value ||
__is_nothrow_swappable<allocator_type>::value) __is_nothrow_swappable<allocator_type>::value)
#endif #endif
{ {
_VSTD::swap(this->__begin_, __x.__begin_); _VSTD::swap(this->__begin_, __x.__begin_);
_VSTD::swap(this->__size_, __x.__size_); _VSTD::swap(this->__size_, __x.__size_);
_VSTD::swap(this->__cap(), __x.__cap()); _VSTD::swap(this->__cap(), __x.__cap());
_VSTD::__swap_allocator(this->__alloc(), __x.__alloc(), _VSTD::__swap_allocator(this->__alloc(), __x.__alloc(),
integral_constant<bool, __alloc_traits::propagate_on_container_swap::value>()); integral_constant<bool, __alloc_traits::propagate_on_container_swap::value>());
} }
template <class _Allocator> template <class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 void _LIBCPP_CONSTEXPR_CXX20 void
vector<bool, _Allocator>::resize(size_type __sz, value_type __x) vector<bool, _Allocator>::resize(size_type __sz, value_type __x)
{ {
size_type __cs = size(); size_type __cs = size();
if (__cs < __sz) if (__cs < __sz)
{ {
iterator __r; iterator __r;
size_type __c = capacity(); size_type __c = capacity();
size_type __n = __sz - __cs; size_type __n = __sz - __cs;
Show All 12 Lines if (__cs < __sz)
} }
_VSTD::fill_n(__r, __n, __x); _VSTD::fill_n(__r, __n, __x);
} }
else else
__size_ = __sz; __size_ = __sz;
} }
template <class _Allocator> template <class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 void _LIBCPP_CONSTEXPR_CXX20 void
vector<bool, _Allocator>::flip() _NOEXCEPT vector<bool, _Allocator>::flip() _NOEXCEPT
{ {
// do middle whole words // do middle whole words
size_type __n = __size_; size_type __n = __size_;
__storage_pointer __p = __begin_; __storage_pointer __p = __begin_;
for (; __n >= __bits_per_word; ++__p, __n -= __bits_per_word) for (; __n >= __bits_per_word; ++__p, __n -= __bits_per_word)
*__p = ~*__p; *__p = ~*__p;
// do last partial word // do last partial word
if (__n > 0) if (__n > 0)
{ {
__storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n); __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);
__storage_type __b = *__p & __m; __storage_type __b = *__p & __m;
*__p &= ~__m; *__p &= ~__m;
*__p |= ~__b & __m; *__p |= ~__b & __m;
} }
} }
template <class _Allocator> template <class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 bool _LIBCPP_CONSTEXPR_CXX20 bool
vector<bool, _Allocator>::__invariants() const vector<bool, _Allocator>::__invariants() const
{ {
if (this->__begin_ == nullptr) if (this->__begin_ == nullptr)
{ {
if (this->__size_ != 0 || this->__cap() != 0) if (this->__size_ != 0 || this->__cap() != 0)
return false; return false;
} }
else else
{ {
if (this->__cap() == 0) if (this->__cap() == 0)
return false; return false;
if (this->__size_ > this->capacity()) if (this->__size_ > this->capacity())
return false; return false;
} }
return true; return true;
} }
template <class _Allocator> template <class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 size_t _LIBCPP_CONSTEXPR_CXX20 size_t
vector<bool, _Allocator>::__hash_code() const _NOEXCEPT vector<bool, _Allocator>::__hash_code() const _NOEXCEPT
{ {
size_t __h = 0; size_t __h = 0;
// do middle whole words // do middle whole words
size_type __n = __size_; size_type __n = __size_;
__storage_pointer __p = __begin_; __storage_pointer __p = __begin_;
for (; __n >= __bits_per_word; ++__p, __n -= __bits_per_word) for (; __n >= __bits_per_word; ++__p, __n -= __bits_per_word)
__h ^= *__p; __h ^= *__p;
// do last partial word // do last partial word
if (__n > 0) if (__n > 0)
{ {
const __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n); const __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);
__h ^= *__p & __m; __h ^= *__p & __m;
} }
return __h; return __h;
} }
template <class _Allocator> template <class _Allocator>
struct _LIBCPP_TEMPLATE_VIS hash<vector<bool, _Allocator> > struct _LIBCPP_TEMPLATE_VIS hash<vector<bool, _Allocator> >
: public __unary_function<vector<bool, _Allocator>, size_t> : public __unary_function<vector<bool, _Allocator>, size_t>
{ {
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX20
size_t operator()(const vector<bool, _Allocator>& __vec) const _NOEXCEPT size_t operator()(const vector<bool, _Allocator>& __vec) const _NOEXCEPT
{return __vec.__hash_code();} {return __vec.__hash_code();}
}; };
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
bool bool
operator==(const vector<_Tp, _Allocator>& __x, const vector<_Tp, _Allocator>& __y) operator==(const vector<_Tp, _Allocator>& __x, const vector<_Tp, _Allocator>& __y)
{ {
const typename vector<_Tp, _Allocator>::size_type __sz = __x.size(); const typename vector<_Tp, _Allocator>::size_type __sz = __x.size();
return __sz == __y.size() && _VSTD::equal(__x.begin(), __x.end(), __y.begin()); return __sz == __y.size() && _VSTD::equal(__x.begin(), __x.end(), __y.begin());
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
bool bool
operator!=(const vector<_Tp, _Allocator>& __x, const vector<_Tp, _Allocator>& __y) operator!=(const vector<_Tp, _Allocator>& __x, const vector<_Tp, _Allocator>& __y)
{ {
return !(__x == __y); return !(__x == __y);
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
bool bool
operator< (const vector<_Tp, _Allocator>& __x, const vector<_Tp, _Allocator>& __y) operator< (const vector<_Tp, _Allocator>& __x, const vector<_Tp, _Allocator>& __y)
{ {
return _VSTD::lexicographical_compare(__x.begin(), __x.end(), __y.begin(), __y.end()); return _VSTD::lexicographical_compare(__x.begin(), __x.end(), __y.begin(), __y.end());
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
bool bool
operator> (const vector<_Tp, _Allocator>& __x, const vector<_Tp, _Allocator>& __y) operator> (const vector<_Tp, _Allocator>& __x, const vector<_Tp, _Allocator>& __y)
{ {
return __y < __x; return __y < __x;
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
bool bool
operator>=(const vector<_Tp, _Allocator>& __x, const vector<_Tp, _Allocator>& __y) operator>=(const vector<_Tp, _Allocator>& __x, const vector<_Tp, _Allocator>& __y)
{ {
return !(__x < __y); return !(__x < __y);
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
bool bool
operator<=(const vector<_Tp, _Allocator>& __x, const vector<_Tp, _Allocator>& __y) operator<=(const vector<_Tp, _Allocator>& __x, const vector<_Tp, _Allocator>& __y)
{ {
return !(__y < __x); return !(__y < __x);
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
void void
swap(vector<_Tp, _Allocator>& __x, vector<_Tp, _Allocator>& __y) swap(vector<_Tp, _Allocator>& __x, vector<_Tp, _Allocator>& __y)
_NOEXCEPT_(_NOEXCEPT_(__x.swap(__y))) _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
{ {
__x.swap(__y); __x.swap(__y);
} }
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER > 17
template <class _Tp, class _Allocator, class _Up> template <class _Tp, class _Allocator, class _Up>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
inline _LIBCPP_INLINE_VISIBILITY typename vector<_Tp, _Allocator>::size_type inline _LIBCPP_INLINE_VISIBILITY typename vector<_Tp, _Allocator>::size_type
erase(vector<_Tp, _Allocator>& __c, const _Up& __v) { erase(vector<_Tp, _Allocator>& __c, const _Up& __v) {
auto __old_size = __c.size(); auto __old_size = __c.size();
__c.erase(_VSTD::remove(__c.begin(), __c.end(), __v), __c.end()); __c.erase(_VSTD::remove(__c.begin(), __c.end(), __v), __c.end());
return __old_size - __c.size(); return __old_size - __c.size();
} }
template <class _Tp, class _Allocator, class _Predicate> template <class _Tp, class _Allocator, class _Predicate>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_CONSTEXPR_CXX20
inline _LIBCPP_INLINE_VISIBILITY typename vector<_Tp, _Allocator>::size_type inline _LIBCPP_INLINE_VISIBILITY typename vector<_Tp, _Allocator>::size_type
erase_if(vector<_Tp, _Allocator>& __c, _Predicate __pred) { erase_if(vector<_Tp, _Allocator>& __c, _Predicate __pred) {
auto __old_size = __c.size(); auto __old_size = __c.size();
__c.erase(_VSTD::remove_if(__c.begin(), __c.end(), __pred), __c.end()); __c.erase(_VSTD::remove_if(__c.begin(), __c.end(), __pred), __c.end());
return __old_size - __c.size(); return __old_size - __c.size();
} }
template <> template <>
Show All 13 Lines

libcxx/src/experimental/memory_resource.cpp

Show First 20 Lines • Show All 66 Lines • ▼ Show 20 Lines
namespace { namespace {
union ResourceInitHelper { union ResourceInitHelper {
struct { struct {
__new_delete_memory_resource_imp new_delete_res; __new_delete_memory_resource_imp new_delete_res;
__null_memory_resource_imp null_res; __null_memory_resource_imp null_res;
} resources; } resources;
char dummy; char dummy;
_LIBCPP_CONSTEXPR_AFTER_CXX11 ResourceInitHelper() : resources() {} _LIBCPP_CONSTEXPR_CXX14 ResourceInitHelper() : resources() {}
~ResourceInitHelper() {} ~ResourceInitHelper() {}
}; };
// Pretend we're inside a system header so the compiler doesn't flag the use of the init_priority // Pretend we're inside a system header so the compiler doesn't flag the use of the init_priority
// attribute with a value that's reserved for the implementation (we're the implementation). // attribute with a value that's reserved for the implementation (we're the implementation).
#include "memory_resource_init_helper.h" #include "memory_resource_init_helper.h"
} // end namespace } // end namespace
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

libcxx/src/filesystem/filesystem_common.h

Show First 20 Lines • Show All 118 Lines • ▼ Show 20 Lines
error_code make_windows_error(int err) { error_code make_windows_error(int err) {
return make_error_code(__win_err_to_errc(err)); return make_error_code(__win_err_to_errc(err));
} }
#endif #endif
template <class T> template <class T>
T error_value(); T error_value();
template <> template <>
_LIBCPP_CONSTEXPR_AFTER_CXX11 void error_value<void>() {} _LIBCPP_CONSTEXPR_CXX14 void error_value<void>() {}
template <> template <>
bool error_value<bool>() { bool error_value<bool>() {
return false; return false;
} }
#if __SIZEOF_SIZE_T__ != __SIZEOF_LONG_LONG__ #if __SIZEOF_SIZE_T__ != __SIZEOF_LONG_LONG__
template <> template <>
size_t error_value<size_t>() { size_t error_value<size_t>() {
return size_t(-1); return size_t(-1);
} }
#endif #endif
template <> template <>
uintmax_t error_value<uintmax_t>() { uintmax_t error_value<uintmax_t>() {
return uintmax_t(-1); return uintmax_t(-1);
} }
template <> template <>
_LIBCPP_CONSTEXPR_AFTER_CXX11 file_time_type error_value<file_time_type>() { _LIBCPP_CONSTEXPR_CXX14 file_time_type error_value<file_time_type>() {
return file_time_type::min(); return file_time_type::min();
} }
template <> template <>
path error_value<path>() { path error_value<path>() {
return {}; return {};
} }
template <class T> template <class T>
▲ Show 20 Lines • Show All 152 Lines • ▼ Show 20 Linesstruct time_util_base {
static constexpr rep min_nsec_timespec = static constexpr rep min_nsec_timespec =
duration_cast<fs_nanoseconds>( duration_cast<fs_nanoseconds>(
(FileTimeT::duration::min() - fs_seconds(min_seconds)) + (FileTimeT::duration::min() - fs_seconds(min_seconds)) +
fs_seconds(1)) fs_seconds(1))
.count(); .count();
private: private:
static _LIBCPP_CONSTEXPR_AFTER_CXX11 fs_duration get_min_nsecs() { static _LIBCPP_CONSTEXPR_CXX14 fs_duration get_min_nsecs() {
return duration_cast<fs_duration>( return duration_cast<fs_duration>(
fs_nanoseconds(min_nsec_timespec) - fs_nanoseconds(min_nsec_timespec) -
duration_cast<fs_nanoseconds>(fs_seconds(1))); duration_cast<fs_nanoseconds>(fs_seconds(1)));
} }
// Static assert that these values properly round trip. // Static assert that these values properly round trip.
static_assert(fs_seconds(min_seconds) + get_min_nsecs() == static_assert(fs_seconds(min_seconds) + get_min_nsecs() ==
FileTimeT::duration::min(), FileTimeT::duration::min(),
"value doesn't roundtrip"); "value doesn't roundtrip");
static _LIBCPP_CONSTEXPR_AFTER_CXX11 bool check_range() { static _LIBCPP_CONSTEXPR_CXX14 bool check_range() {
// This kinda sucks, but it's what happens when we don't have __int128_t. // This kinda sucks, but it's what happens when we don't have __int128_t.
if (sizeof(TimeT) == sizeof(rep)) { if (sizeof(TimeT) == sizeof(rep)) {
typedef duration<long long, ratio<3600 * 24 * 365> > Years; typedef duration<long long, ratio<3600 * 24 * 365> > Years;
return duration_cast<Years>(fs_seconds(max_seconds)) > Years(250) && return duration_cast<Years>(fs_seconds(max_seconds)) > Years(250) &&
duration_cast<Years>(fs_seconds(min_seconds)) < Years(-250); duration_cast<Years>(fs_seconds(min_seconds)) < Years(-250);
} }
return max_seconds >= numeric_limits<TimeT>::max() && return max_seconds >= numeric_limits<TimeT>::max() &&
min_seconds <= numeric_limits<TimeT>::min(); min_seconds <= numeric_limits<TimeT>::min();
▲ Show 20 Lines • Show All 49 Lines • ▼ Show 20 Linesstruct time_util : time_util_base<FileTimeT, TimeT> {
using typename Base::fs_duration; using typename Base::fs_duration;
using typename Base::fs_microseconds; using typename Base::fs_microseconds;
using typename Base::fs_nanoseconds; using typename Base::fs_nanoseconds;
using typename Base::fs_seconds; using typename Base::fs_seconds;
public: public:
template <class CType, class ChronoType> template <class CType, class ChronoType>
static _LIBCPP_CONSTEXPR_AFTER_CXX11 bool checked_set(CType* out, static _LIBCPP_CONSTEXPR_CXX14 bool checked_set(CType* out,
ChronoType time) { ChronoType time) {
using Lim = numeric_limits<CType>; using Lim = numeric_limits<CType>;
if (time > Lim::max() || time < Lim::min()) if (time > Lim::max() || time < Lim::min())
return false; return false;
*out = static_cast<CType>(time); *out = static_cast<CType>(time);
return true; return true;
} }
static _LIBCPP_CONSTEXPR_AFTER_CXX11 bool is_representable(TimeSpecT tm) { static _LIBCPP_CONSTEXPR_CXX14 bool is_representable(TimeSpecT tm) {
if (tm.tv_sec >= 0) { if (tm.tv_sec >= 0) {
return tm.tv_sec < max_seconds || return tm.tv_sec < max_seconds ||
(tm.tv_sec == max_seconds && tm.tv_nsec <= max_nsec); (tm.tv_sec == max_seconds && tm.tv_nsec <= max_nsec);
} else if (tm.tv_sec == (min_seconds - 1)) { } else if (tm.tv_sec == (min_seconds - 1)) {
return tm.tv_nsec >= min_nsec_timespec; return tm.tv_nsec >= min_nsec_timespec;
} else { } else {
return tm.tv_sec >= min_seconds; return tm.tv_sec >= min_seconds;
} }
} }
static _LIBCPP_CONSTEXPR_AFTER_CXX11 bool is_representable(FileTimeT tm) { static _LIBCPP_CONSTEXPR_CXX14 bool is_representable(FileTimeT tm) {
auto secs = duration_cast<fs_seconds>(tm.time_since_epoch()); auto secs = duration_cast<fs_seconds>(tm.time_since_epoch());
auto nsecs = duration_cast<fs_nanoseconds>(tm.time_since_epoch() - secs); auto nsecs = duration_cast<fs_nanoseconds>(tm.time_since_epoch() - secs);
if (nsecs.count() < 0) { if (nsecs.count() < 0) {
secs = secs + fs_seconds(1); secs = secs + fs_seconds(1);
nsecs = nsecs + fs_seconds(1); nsecs = nsecs + fs_seconds(1);
} }
using TLim = numeric_limits<TimeT>; using TLim = numeric_limits<TimeT>;
if (secs.count() >= 0) if (secs.count() >= 0)
return secs.count() <= TLim::max(); return secs.count() <= TLim::max();
return secs.count() >= TLim::min(); return secs.count() >= TLim::min();
} }
static _LIBCPP_CONSTEXPR_AFTER_CXX11 FileTimeT static _LIBCPP_CONSTEXPR_CXX14 FileTimeT
convert_from_timespec(TimeSpecT tm) { convert_from_timespec(TimeSpecT tm) {
if (tm.tv_sec >= 0 || tm.tv_nsec == 0) { if (tm.tv_sec >= 0 || tm.tv_nsec == 0) {
return FileTimeT(fs_seconds(tm.tv_sec) + return FileTimeT(fs_seconds(tm.tv_sec) +
duration_cast<fs_duration>(fs_nanoseconds(tm.tv_nsec))); duration_cast<fs_duration>(fs_nanoseconds(tm.tv_nsec)));
} else { // tm.tv_sec < 0 } else { // tm.tv_sec < 0
auto adj_subsec = duration_cast<fs_duration>(fs_seconds(1) - auto adj_subsec = duration_cast<fs_duration>(fs_seconds(1) -
fs_nanoseconds(tm.tv_nsec)); fs_nanoseconds(tm.tv_nsec));
auto Dur = fs_seconds(tm.tv_sec + 1) - adj_subsec; auto Dur = fs_seconds(tm.tv_sec + 1) - adj_subsec;
return FileTimeT(Dur); return FileTimeT(Dur);
} }
} }
template <class SubSecT> template <class SubSecT>
static _LIBCPP_CONSTEXPR_AFTER_CXX11 bool static _LIBCPP_CONSTEXPR_CXX14 bool
set_times_checked(TimeT* sec_out, SubSecT* subsec_out, FileTimeT tp) { set_times_checked(TimeT* sec_out, SubSecT* subsec_out, FileTimeT tp) {
auto dur = tp.time_since_epoch(); auto dur = tp.time_since_epoch();
auto sec_dur = duration_cast<fs_seconds>(dur); auto sec_dur = duration_cast<fs_seconds>(dur);
auto subsec_dur = duration_cast<fs_nanoseconds>(dur - sec_dur); auto subsec_dur = duration_cast<fs_nanoseconds>(dur - sec_dur);
// The tv_nsec and tv_usec fields must not be negative so adjust accordingly // The tv_nsec and tv_usec fields must not be negative so adjust accordingly
if (subsec_dur.count() < 0) { if (subsec_dur.count() < 0) {
if (sec_dur.count() > min_seconds) { if (sec_dur.count() > min_seconds) {
sec_dur = sec_dur - fs_seconds(1); sec_dur = sec_dur - fs_seconds(1);
subsec_dur = subsec_dur + fs_seconds(1); subsec_dur = subsec_dur + fs_seconds(1);
} else { } else {
subsec_dur = fs_nanoseconds::zero(); subsec_dur = fs_nanoseconds::zero();
} }
} }
return checked_set(sec_out, sec_dur.count()) && return checked_set(sec_out, sec_dur.count()) &&
checked_set(subsec_out, subsec_dur.count()); checked_set(subsec_out, subsec_dur.count());
} }
static _LIBCPP_CONSTEXPR_AFTER_CXX11 bool convert_to_timespec(TimeSpecT& dest, static _LIBCPP_CONSTEXPR_CXX14 bool convert_to_timespec(TimeSpecT& dest,
FileTimeT tp) { FileTimeT tp) {
if (!is_representable(tp)) if (!is_representable(tp))
return false; return false;
return set_times_checked(&dest.tv_sec, &dest.tv_nsec, tp); return set_times_checked(&dest.tv_sec, &dest.tv_nsec, tp);
} }
}; };
#if defined(_LIBCPP_WIN32API) #if defined(_LIBCPP_WIN32API)
▲ Show 20 Lines • Show All 153 Lines • Show Last 20 Lines

libcxx/test/libcxx/nasty_macros.compile.pass.cpp

Show First 20 Lines • Show All 134 Lines • ▼ Show 20 Lines
#define X NASTY_MACRO #define X NASTY_MACRO
#define Xp NASTY_MACRO #define Xp NASTY_MACRO
#define Xs NASTY_MACRO #define Xs NASTY_MACRO
// The classic Windows min/max macros // The classic Windows min/max macros
#define min NASTY_MACRO #define min NASTY_MACRO
#define max NASTY_MACRO #define max NASTY_MACRO
// Old constexpr macros
#define _LIBCPP_CONSTEXPR_AFTER_CXX11 NASTY_MACRO
#define _LIBCPP_CONSTEXPR_AFTER_CXX14 NASTY_MACRO
#define _LIBCPP_CONSTEXPR_AFTER_CXX17 NASTY_MACRO
MordanteUnsubmitted
Done
ReplyInline Actions

Thanks!

Mordante: Thanks!
ldionneUnsubmitted
Done
ReplyInline Actions

I don't think this is necessary. I understand the goal of catching non-rebased patches, however such patches are going to fail with unknown identifier _LIBCPP_CONSTEXPR_AFTER_CXX14 anyway if someone forgets to use the new macro names. So I don't think this is going to catch anything that we wouldn't otherwise catch.

ldionne: I don't think this is necessary. I understand the goal of catching non-rebased patches, however…
/* /*
BEGIN-SCRIPT BEGIN-SCRIPT
for header in public_headers: for header in public_headers:
print("{}#{}include <{}>{}".format( print("{}#{}include <{}>{}".format(
'#if ' + header_restrictions[header] + '\n' if header in header_restrictions else '', '#if ' + header_restrictions[header] + '\n' if header in header_restrictions else '',
3 * ' ' if header in header_restrictions else '', 3 * ' ' if header in header_restrictions else '',
header, header,
▲ Show 20 Lines • Show All 241 Lines • Show Last 20 Lines