This is an archive of the discontinued LLVM Phabricator instance.

Differential D152666

[libc++] Mark namespace std with default visibility and remove template and enum visibility macros
AbandonedPublic

Authored by philnik on Jun 11 2023, 8:20 PM.

Details

Reviewers
ldionne
Group Reviewers
Restricted Project
Summary

This gives everything inside namespace std default visibility and removes macros which give types default visibility. This isn't a problem, since all the functions should be marked _LIBCPP_HIDE_FROM_ABI anyways, and everything else should have default visibilty.

Diff Detail

Event Timeline

philnik created this revision.Jun 11 2023, 8:20 PM
Herald added a project: Restricted Project. · View Herald TranscriptJun 11 2023, 8:20 PM
Herald added a subscriber: arphaman. · View Herald Transcript
philnik requested review of this revision.Jun 11 2023, 8:20 PM
Herald added a project: Restricted Project. · View Herald TranscriptJun 11 2023, 8:20 PM
Herald added a reviewer: Restricted Project. · View Herald Transcript
Herald added a subscriber: libcxx-commits. · View Herald Transcript
Harbormaster completed remote builds in B238080: Diff 530363.Jun 11 2023, 8:26 PM
philnik updated this revision to Diff 530517.Jun 12 2023, 8:29 AM

Update ignore_format.txt

Herald added a subscriber: arichardson. · View Herald TranscriptJun 12 2023, 8:29 AM
Harbormaster completed remote builds in B238196: Diff 530517.Jun 12 2023, 8:36 AM
philnik updated this revision to Diff 530520.Jun 12 2023, 8:37 AM

Remove more files from ignore_format.txt

Harbormaster completed remote builds in B238199: Diff 530520.Jun 12 2023, 10:03 AM
philnik abandoned this revision.Jun 12 2023, 11:51 AM

Revision Contents

PathSize
libcxx/
2 lines
docs/
DesignDocs/
29 lines
include/
__charconv/
2 lines
__chrono/
11 lines
53 lines
2 lines
5 lines
__compare/
2 lines
2 lines
2 lines
4 lines
24 lines
__coroutine/
6 lines
2 lines
__filesystem/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
__format/
32 lines
8 lines
8 lines
2 lines
2 lines
19 lines
6 lines
6 lines
2 lines
2 lines
2 lines
2 lines
2 lines
8 lines
13 lines
37 lines
6 lines
2 lines
11 lines
16 lines
8 lines
8 lines
14 lines
2 lines
__functional/
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
6 lines
84 lines
24 lines
95 lines
3 lines
3 lines
2 lines
2 lines
2 lines
__fwd/
2 lines
8 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
8 lines
2 lines
6 lines
2 lines
4 lines
2 lines
44 lines
__ios/
2 lines
__iterator/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
19 lines
2 lines
2 lines
2 lines
2 lines
2 lines
6 lines
21 lines
__memory/
10 lines
2 lines
2 lines
4 lines
4 lines
2 lines
32 lines
14 lines
5 lines
__memory_resource/
2 lines
__mutex/
2 lines
2 lines
4 lines
__random/
4 lines
4 lines
4 lines
4 lines
2 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
2 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
2 lines
2 lines
4 lines
4 lines
4 lines
4 lines
__ranges/
2 lines
3 lines
__string/
10 lines
__system_error/
4 lines
8 lines
4 lines
62 lines
__tuple/
2 lines
10 lines
24 lines
__type_traits/
3 lines
3 lines
3 lines
4 lines
4 lines
12 lines
4 lines
2 lines
2 lines
7 lines
23 lines
2 lines
4 lines
2 lines
17 lines
4 lines
4 lines
5 lines
14 lines
2 lines
3 lines
8 lines
4 lines
6 lines
6 lines
4 lines
10 lines
2 lines
2 lines
4 lines
2 lines
3 lines
4 lines
8 lines
4 lines
5 lines
4 lines
6 lines
5 lines
8 lines
7 lines
6 lines
2 lines
5 lines
3 lines
7 lines
2 lines
8 lines
5 lines
27 lines
2 lines
7 lines
8 lines
4 lines
4 lines
6 lines
3 lines
20 lines
2 lines
2 lines
7 lines
3 lines
5 lines
5 lines
13 lines
5 lines
5 lines
2 lines
2 lines
2 lines
2 lines
6 lines
2 lines
2 lines
8 lines
4 lines
5 lines
6 lines
6 lines
12 lines
20 lines
4 lines
2 lines
6 lines
10 lines
6 lines
4 lines
3 lines
__utility/
4 lines
2 lines
11 lines
2 lines
__variant/
4 lines
10 lines
8 lines
8 lines
7 lines
14 lines
10 lines
experimental/
5 lines
8 lines
2 lines
ext/
47 lines
26 lines
4 lines
15 lines
12 lines
32 lines
2 lines
7 lines
10 lines
14 lines
12 lines
14 lines
56 lines
33 lines
12 lines
2 lines
4 lines
7 lines
16 lines
32 lines
79 lines
2 lines
12 lines
4 lines
12 lines
9 lines
2 lines
5 lines
7 lines
7 lines
34 lines
12 lines
36 lines
73 lines
11 lines
src/
2 lines

Diff 530363

libcxx/.clang-format

Show All 20 LinesAttributeMacros: ['_LIBCPP_HIDE_FROM_ABI',
'_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',
'_LIBCPP_FUNC_VIS', '_LIBCPP_FUNC_VIS',
'_LIBCPP_TYPE_VIS', '_LIBCPP_TYPE_VIS',
'_LIBCPP_TEMPLATE_VIS',
'_LIBCPP_TEMPLATE_DATA_VIS', '_LIBCPP_TEMPLATE_DATA_VIS',
'_LIBCPP_EXPORTED_FROM_ABI', '_LIBCPP_EXPORTED_FROM_ABI',
'_LIBCPP_OVERRIDABLE_FUNC_VIS', '_LIBCPP_OVERRIDABLE_FUNC_VIS',
'_LIBCPP_EXCEPTION_ABI', '_LIBCPP_EXCEPTION_ABI',
'_LIBCPP_ENUM_VIS',
'_LIBCPP_EXTERN_TEMPLATE_TYPE_VIS', '_LIBCPP_EXTERN_TEMPLATE_TYPE_VIS',
'_LIBCPP_INTERNAL_LINKAGE', '_LIBCPP_INTERNAL_LINKAGE',
'_LIBCPP_EXCLUDE_FROM_EXPLICIT_INSTANTIATION', '_LIBCPP_EXCLUDE_FROM_EXPLICIT_INSTANTIATION',
'_LIBCPP_HIDE_FROM_ABI_AFTER_V1', '_LIBCPP_HIDE_FROM_ABI_AFTER_V1',
'_LIBCPP_INLINE_VISIBILITY', '_LIBCPP_INLINE_VISIBILITY',
'_LIBCPP_NOALIAS', '_LIBCPP_NOALIAS',
'_LIBCPP_NO_SANITIZE', '_LIBCPP_NO_SANITIZE',
'_LIBCPP_USING_IF_EXISTS', '_LIBCPP_USING_IF_EXISTS',
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

libcxx/docs/DesignDocs/VisibilityMacros.rst

Show First 20 Lines • Show All 63 Lines • ▼ Show 20 Lines**_LIBCPP_HIDE_FROM_ABI_AFTER_V1**
the ABI in a future version. Each time we release a new stable version of the the ABI in a future version. Each time we release a new stable version of the
ABI, we should create a new _LIBCPP_HIDE_FROM_ABI_AFTER_XXX macro, and we can ABI, we should create a new _LIBCPP_HIDE_FROM_ABI_AFTER_XXX macro, and we can
use it to start removing symbols from the ABI after that stable version. use it to start removing symbols from the ABI after that stable version.
**_LIBCPP_TYPE_VIS** **_LIBCPP_TYPE_VIS**
Mark a type's typeinfo, vtable and members as having default visibility. Mark a type's typeinfo, vtable and members as having default visibility.
This attribute cannot be used on class templates. This attribute cannot be used on class templates.
**_LIBCPP_TEMPLATE_VIS**
Mark a type's typeinfo and vtable as having default visibility.
This macro has no effect on the visibility of the type's member functions.
**GCC Behavior**: GCC does not support Clang's `type_visibility(...)`
attribute. With GCC the `visibility(...)` attribute is used and member
functions are affected.
**Windows Behavior**: DLLs do not support dllimport/export on class templates.
The macro has an empty definition on this platform.
**_LIBCPP_ENUM_VIS**
Mark the typeinfo of an enum as having default visibility. This attribute
should be applied to all enum declarations.
**Windows Behavior**: DLLs do not support importing or exporting enumeration
typeinfo. The macro has an empty definition on this platform.
**GCC Behavior**: GCC un-hides the typeinfo for enumerations by default, even
if `-fvisibility=hidden` is specified. Additionally applying a visibility
attribute to an enum class results in a warning. The macro has an empty
definition with GCC.
**_LIBCPP_EXTERN_TEMPLATE_TYPE_VIS** **_LIBCPP_EXTERN_TEMPLATE_TYPE_VIS**
Mark the member functions, typeinfo, and vtable of the type named in Mark the member functions, typeinfo, and vtable of the type named in
an extern template declaration as being exported by the libc++ library. an extern template declaration as being exported by the libc++ library.
This attribute must be specified on all extern class template declarations. This attribute must be specified on all extern class template declarations.
This macro is used to override the `_LIBCPP_TEMPLATE_VIS` attribute This macro is used to export the member functions produced by the explicit
specified on the primary template and to export the member functions produced instantiation in the dylib.
by the explicit instantiation in the dylib.
**Windows Behavior**: `extern template` and `dllexport` are fundamentally **Windows Behavior**: `extern template` and `dllexport` are fundamentally
incompatible *on a class template* on Windows; the former suppresses incompatible *on a class template* on Windows; the former suppresses
instantiation, while the latter forces it. Specifying both on the same instantiation, while the latter forces it. Specifying both on the same
declaration makes the class template be instantiated, which is not desirable declaration makes the class template be instantiated, which is not desirable
inside headers. This macro therefore expands to `dllimport` outside of libc++ inside headers. This macro therefore expands to `dllimport` outside of libc++
but nothing inside of it (rather than expanding to `dllexport`); instead, the but nothing inside of it (rather than expanding to `dllexport`); instead, the
explicit instantiations themselves are marked as exported. Note that this explicit instantiations themselves are marked as exported. Note that this
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

libcxx/include/__charconv/chars_format.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
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
enum class _LIBCPP_ENUM_VIS chars_format { scientific = 0x1, fixed = 0x2, hex = 0x4, general = fixed | scientific }; enum class chars_format { scientific = 0x1, fixed = 0x2, hex = 0x4, general = fixed | scientific };
inline _LIBCPP_HIDE_FROM_ABI constexpr chars_format operator~(chars_format __x) { inline _LIBCPP_HIDE_FROM_ABI constexpr chars_format operator~(chars_format __x) {
return chars_format(~std::__to_underlying(__x)); return chars_format(~std::__to_underlying(__x));
} }
inline _LIBCPP_HIDE_FROM_ABI constexpr chars_format operator&(chars_format __x, chars_format __y) { inline _LIBCPP_HIDE_FROM_ABI constexpr chars_format operator&(chars_format __x, chars_format __y) {
return chars_format(std::__to_underlying(__x) & std::__to_underlying(__y)); return chars_format(std::__to_underlying(__x) & std::__to_underlying(__y));
} }
Show All 32 Lines

libcxx/include/__chrono/duration.h

Show All 26 Lines
_LIBCPP_PUSH_MACROS _LIBCPP_PUSH_MACROS
#include <__undef_macros> #include <__undef_macros>
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace chrono namespace chrono
{ {
template <class _Rep, class _Period = ratio<1> > class _LIBCPP_TEMPLATE_VIS duration; template <class _Rep, class _Period = ratio<1> > class duration;
template <class _Tp> template <class _Tp>
struct __is_duration : false_type {}; struct __is_duration : false_type {};
template <class _Rep, class _Period> template <class _Rep, class _Period>
struct __is_duration<duration<_Rep, _Period> > : true_type {}; struct __is_duration<duration<_Rep, _Period> > : true_type {};
template <class _Rep, class _Period> template <class _Rep, class _Period>
struct __is_duration<const duration<_Rep, _Period> > : true_type {}; struct __is_duration<const duration<_Rep, _Period> > : true_type {};
template <class _Rep, class _Period> template <class _Rep, class _Period>
struct __is_duration<volatile duration<_Rep, _Period> > : true_type {}; struct __is_duration<volatile duration<_Rep, _Period> > : true_type {};
template <class _Rep, class _Period> template <class _Rep, class _Period>
struct __is_duration<const volatile duration<_Rep, _Period> > : true_type {}; struct __is_duration<const volatile duration<_Rep, _Period> > : true_type {};
} // namespace chrono } // namespace chrono
template <class _Rep1, class _Period1, class _Rep2, class _Period2> template <class _Rep1, class _Period1, class _Rep2, class _Period2>
struct _LIBCPP_TEMPLATE_VIS common_type<chrono::duration<_Rep1, _Period1>, struct common_type<chrono::duration<_Rep1, _Period1>, chrono::duration<_Rep2, _Period2> >
chrono::duration<_Rep2, _Period2> >
{ {
typedef chrono::duration<typename common_type<_Rep1, _Rep2>::type, typedef chrono::duration<typename common_type<_Rep1, _Rep2>::type,
typename __ratio_gcd<_Period1, _Period2>::type> type; typename __ratio_gcd<_Period1, _Period2>::type> type;
}; };
namespace chrono { namespace chrono {
// duration_cast // duration_cast
▲ Show 20 Lines • Show All 60 Lines • ▼ Show 20 Lines<
_ToDuration _ToDuration
>::type >::type
duration_cast(const duration<_Rep, _Period>& __fd) duration_cast(const duration<_Rep, _Period>& __fd)
{ {
return __duration_cast<duration<_Rep, _Period>, _ToDuration>()(__fd); return __duration_cast<duration<_Rep, _Period>, _ToDuration>()(__fd);
} }
template <class _Rep> template <class _Rep>
struct _LIBCPP_TEMPLATE_VIS treat_as_floating_point : is_floating_point<_Rep> {}; struct treat_as_floating_point : is_floating_point<_Rep> {};
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <class _Rep> template <class _Rep>
inline constexpr bool treat_as_floating_point_v = treat_as_floating_point<_Rep>::value; inline constexpr bool treat_as_floating_point_v = treat_as_floating_point<_Rep>::value;
#endif #endif
template <class _Rep> template <class _Rep>
struct _LIBCPP_TEMPLATE_VIS duration_values struct duration_values
{ {
public: public:
_LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR _Rep zero() _NOEXCEPT {return _Rep(0);} _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR _Rep zero() _NOEXCEPT {return _Rep(0);}
_LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR _Rep max() _NOEXCEPT {return numeric_limits<_Rep>::max();} _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR _Rep max() _NOEXCEPT {return numeric_limits<_Rep>::max();}
_LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR _Rep min() _NOEXCEPT {return numeric_limits<_Rep>::lowest();} _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR _Rep min() _NOEXCEPT {return numeric_limits<_Rep>::lowest();}
}; };
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
▲ Show 20 Lines • Show All 46 Lines • ▼ Show 20 Lines if (__lower_diff > __upper_diff)
return __upper; return __upper;
return __lower.count() & 1 ? __upper : __lower; return __lower.count() & 1 ? __upper : __lower;
} }
#endif #endif
// duration // duration
template <class _Rep, class _Period> template <class _Rep, class _Period>
class _LIBCPP_TEMPLATE_VIS duration class duration
{ {
static_assert(!__is_duration<_Rep>::value, "A duration representation can not be a duration"); static_assert(!__is_duration<_Rep>::value, "A duration representation can not be a duration");
static_assert(__is_ratio<_Period>::value, "Second template parameter of duration must be a std::ratio"); static_assert(__is_ratio<_Period>::value, "Second template parameter of duration must be a std::ratio");
static_assert(_Period::num > 0, "duration period must be positive"); static_assert(_Period::num > 0, "duration period must be positive");
template <class _R1, class _R2> template <class _R1, class _R2>
struct __no_overflow struct __no_overflow
{ {
▲ Show 20 Lines • Show All 429 Lines • Show Last 20 Lines

libcxx/include/__chrono/formatter.h

Show First 20 Lines • Show All 555 Lines • ▼ Show 20 Lines__format_chrono(const _Tp& __value,
} }
return __formatter::__write_string(__sstr.view(), __ctx.out(), __specs); return __formatter::__write_string(__sstr.view(), __ctx.out(), __specs);
} }
} // namespace __formatter } // namespace __formatter
template <__fmt_char_type _CharT> template <__fmt_char_type _CharT>
struct _LIBCPP_TEMPLATE_VIS __formatter_chrono { struct __formatter_chrono {
public: public:
template <class _ParseContext> template <class _ParseContext>
_LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator _LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator
__parse(_ParseContext& __ctx, __format_spec::__fields __fields, __format_spec::__flags __flags) { __parse(_ParseContext& __ctx, __format_spec::__fields __fields, __format_spec::__flags __flags) {
return __parser_.__parse(__ctx, __fields, __flags); return __parser_.__parse(__ctx, __fields, __flags);
} }
template <class _Tp, class _FormatContext> template <class _Tp, class _FormatContext>
_LIBCPP_HIDE_FROM_ABI typename _FormatContext::iterator format(const _Tp& __value, _FormatContext& __ctx) const { _LIBCPP_HIDE_FROM_ABI typename _FormatContext::iterator format(const _Tp& __value, _FormatContext& __ctx) const {
return __formatter::__format_chrono( return __formatter::__format_chrono(
__value, __ctx, __parser_.__parser_.__get_parsed_chrono_specifications(__ctx), __parser_.__chrono_specs_); __value, __ctx, __parser_.__parser_.__get_parsed_chrono_specifications(__ctx), __parser_.__chrono_specs_);
} }
__format_spec::__parser_chrono<_CharT> __parser_; __format_spec::__parser_chrono<_CharT> __parser_;
}; };
template <class _Duration, __fmt_char_type _CharT> template <class _Duration, __fmt_char_type _CharT>
struct _LIBCPP_TEMPLATE_VIS formatter<chrono::sys_time<_Duration>, _CharT> : public __formatter_chrono<_CharT> { struct formatter<chrono::sys_time<_Duration>, _CharT> : public __formatter_chrono<_CharT> {
public: public:
using _Base = __formatter_chrono<_CharT>; using _Base = __formatter_chrono<_CharT>;
template <class _ParseContext> template <class _ParseContext>
_LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) { _LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) {
return _Base::__parse(__ctx, __format_spec::__fields_chrono, __format_spec::__flags::__clock); return _Base::__parse(__ctx, __format_spec::__fields_chrono, __format_spec::__flags::__clock);
} }
}; };
template <class _Duration, __fmt_char_type _CharT> template <class _Duration, __fmt_char_type _CharT>
struct _LIBCPP_TEMPLATE_VIS formatter<chrono::file_time<_Duration>, _CharT> : public __formatter_chrono<_CharT> { struct formatter<chrono::file_time<_Duration>, _CharT> : public __formatter_chrono<_CharT> {
public: public:
using _Base = __formatter_chrono<_CharT>; using _Base = __formatter_chrono<_CharT>;
template <class _ParseContext> template <class _ParseContext>
_LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) { _LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) {
return _Base::__parse(__ctx, __format_spec::__fields_chrono, __format_spec::__flags::__clock); return _Base::__parse(__ctx, __format_spec::__fields_chrono, __format_spec::__flags::__clock);
} }
}; };
template <class _Duration, __fmt_char_type _CharT> template <class _Duration, __fmt_char_type _CharT>
struct _LIBCPP_TEMPLATE_VIS formatter<chrono::local_time<_Duration>, _CharT> : public __formatter_chrono<_CharT> { struct formatter<chrono::local_time<_Duration>, _CharT> : public __formatter_chrono<_CharT> {
public: public:
using _Base = __formatter_chrono<_CharT>; using _Base = __formatter_chrono<_CharT>;
template <class _ParseContext> template <class _ParseContext>
_LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) { _LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) {
// The flags are not __clock since there is no associated time-zone. // The flags are not __clock since there is no associated time-zone.
return _Base::__parse(__ctx, __format_spec::__fields_chrono, __format_spec::__flags::__date_time); return _Base::__parse(__ctx, __format_spec::__fields_chrono, __format_spec::__flags::__date_time);
} }
Show All 17 Lines _LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) {
if constexpr (std::floating_point<_Rep>) if constexpr (std::floating_point<_Rep>)
return _Base::__parse(__ctx, __format_spec::__fields_chrono_fractional, __format_spec::__flags::__duration); return _Base::__parse(__ctx, __format_spec::__fields_chrono_fractional, __format_spec::__flags::__duration);
else else
return _Base::__parse(__ctx, __format_spec::__fields_chrono, __format_spec::__flags::__duration); return _Base::__parse(__ctx, __format_spec::__fields_chrono, __format_spec::__flags::__duration);
} }
}; };
template <__fmt_char_type _CharT> template <__fmt_char_type _CharT>
struct _LIBCPP_TEMPLATE_VIS formatter<chrono::day, _CharT> struct formatter<chrono::day, _CharT> : public __formatter_chrono<_CharT> {
: public __formatter_chrono<_CharT> {
public: public:
using _Base = __formatter_chrono<_CharT>; using _Base = __formatter_chrono<_CharT>;
template <class _ParseContext> template <class _ParseContext>
_LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) { _LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) {
return _Base::__parse(__ctx, __format_spec::__fields_chrono, __format_spec::__flags::__day); return _Base::__parse(__ctx, __format_spec::__fields_chrono, __format_spec::__flags::__day);
} }
}; };
template <__fmt_char_type _CharT> template <__fmt_char_type _CharT>
struct _LIBCPP_TEMPLATE_VIS formatter<chrono::month, _CharT> struct formatter<chrono::month, _CharT> : public __formatter_chrono<_CharT> {
: public __formatter_chrono<_CharT> {
public: public:
using _Base = __formatter_chrono<_CharT>; using _Base = __formatter_chrono<_CharT>;
template <class _ParseContext> template <class _ParseContext>
_LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) { _LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) {
return _Base::__parse(__ctx, __format_spec::__fields_chrono, __format_spec::__flags::__month); return _Base::__parse(__ctx, __format_spec::__fields_chrono, __format_spec::__flags::__month);
} }
}; };
template <__fmt_char_type _CharT> template <__fmt_char_type _CharT>
struct _LIBCPP_TEMPLATE_VIS formatter<chrono::year, _CharT> struct formatter<chrono::year, _CharT> : public __formatter_chrono<_CharT> {
: public __formatter_chrono<_CharT> {
public: public:
using _Base = __formatter_chrono<_CharT>; using _Base = __formatter_chrono<_CharT>;
template <class _ParseContext> template <class _ParseContext>
_LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) { _LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) {
return _Base::__parse(__ctx, __format_spec::__fields_chrono, __format_spec::__flags::__year); return _Base::__parse(__ctx, __format_spec::__fields_chrono, __format_spec::__flags::__year);
} }
}; };
template <__fmt_char_type _CharT> template <__fmt_char_type _CharT>
struct _LIBCPP_TEMPLATE_VIS formatter<chrono::weekday, _CharT> struct formatter<chrono::weekday, _CharT> : public __formatter_chrono<_CharT> {
: public __formatter_chrono<_CharT> {
public: public:
using _Base = __formatter_chrono<_CharT>; using _Base = __formatter_chrono<_CharT>;
template <class _ParseContext> template <class _ParseContext>
_LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) { _LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) {
return _Base::__parse(__ctx, __format_spec::__fields_chrono, __format_spec::__flags::__weekday); return _Base::__parse(__ctx, __format_spec::__fields_chrono, __format_spec::__flags::__weekday);
} }
}; };
template <__fmt_char_type _CharT> template <__fmt_char_type _CharT>
struct _LIBCPP_TEMPLATE_VIS formatter<chrono::weekday_indexed, _CharT> struct formatter<chrono::weekday_indexed, _CharT> : public __formatter_chrono<_CharT> {
: public __formatter_chrono<_CharT> {
public: public:
using _Base = __formatter_chrono<_CharT>; using _Base = __formatter_chrono<_CharT>;
template <class _ParseContext> template <class _ParseContext>
_LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) { _LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) {
return _Base::__parse(__ctx, __format_spec::__fields_chrono, __format_spec::__flags::__weekday); return _Base::__parse(__ctx, __format_spec::__fields_chrono, __format_spec::__flags::__weekday);
} }
}; };
template <__fmt_char_type _CharT> template <__fmt_char_type _CharT>
struct _LIBCPP_TEMPLATE_VIS formatter<chrono::weekday_last, _CharT> struct formatter<chrono::weekday_last, _CharT> : public __formatter_chrono<_CharT> {
: public __formatter_chrono<_CharT> {
public: public:
using _Base = __formatter_chrono<_CharT>; using _Base = __formatter_chrono<_CharT>;
template <class _ParseContext> template <class _ParseContext>
_LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) { _LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) {
return _Base::__parse(__ctx, __format_spec::__fields_chrono, __format_spec::__flags::__weekday); return _Base::__parse(__ctx, __format_spec::__fields_chrono, __format_spec::__flags::__weekday);
} }
}; };
template <__fmt_char_type _CharT> template <__fmt_char_type _CharT>
struct _LIBCPP_TEMPLATE_VIS formatter<chrono::month_day, _CharT> struct formatter<chrono::month_day, _CharT> : public __formatter_chrono<_CharT> {
: public __formatter_chrono<_CharT> {
public: public:
using _Base = __formatter_chrono<_CharT>; using _Base = __formatter_chrono<_CharT>;
template <class _ParseContext> template <class _ParseContext>
_LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) { _LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) {
return _Base::__parse(__ctx, __format_spec::__fields_chrono, __format_spec::__flags::__month_day); return _Base::__parse(__ctx, __format_spec::__fields_chrono, __format_spec::__flags::__month_day);
} }
}; };
template <__fmt_char_type _CharT> template <__fmt_char_type _CharT>
struct _LIBCPP_TEMPLATE_VIS formatter<chrono::month_day_last, _CharT> struct formatter<chrono::month_day_last, _CharT> : public __formatter_chrono<_CharT> {
: public __formatter_chrono<_CharT> {
public: public:
using _Base = __formatter_chrono<_CharT>; using _Base = __formatter_chrono<_CharT>;
template <class _ParseContext> template <class _ParseContext>
_LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) { _LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) {
return _Base::__parse(__ctx, __format_spec::__fields_chrono, __format_spec::__flags::__month); return _Base::__parse(__ctx, __format_spec::__fields_chrono, __format_spec::__flags::__month);
} }
}; };
template <__fmt_char_type _CharT> template <__fmt_char_type _CharT>
struct _LIBCPP_TEMPLATE_VIS formatter<chrono::month_weekday, _CharT> struct formatter<chrono::month_weekday, _CharT> : public __formatter_chrono<_CharT> {
: public __formatter_chrono<_CharT> {
public: public:
using _Base = __formatter_chrono<_CharT>; using _Base = __formatter_chrono<_CharT>;
template <class _ParseContext> template <class _ParseContext>
_LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) { _LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) {
return _Base::__parse(__ctx, __format_spec::__fields_chrono, __format_spec::__flags::__month_weekday); return _Base::__parse(__ctx, __format_spec::__fields_chrono, __format_spec::__flags::__month_weekday);
} }
}; };
template <__fmt_char_type _CharT> template <__fmt_char_type _CharT>
struct _LIBCPP_TEMPLATE_VIS formatter<chrono::month_weekday_last, _CharT> struct formatter<chrono::month_weekday_last, _CharT> : public __formatter_chrono<_CharT> {
: public __formatter_chrono<_CharT> {
public: public:
using _Base = __formatter_chrono<_CharT>; using _Base = __formatter_chrono<_CharT>;
template <class _ParseContext> template <class _ParseContext>
_LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) { _LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) {
return _Base::__parse(__ctx, __format_spec::__fields_chrono, __format_spec::__flags::__month_weekday); return _Base::__parse(__ctx, __format_spec::__fields_chrono, __format_spec::__flags::__month_weekday);
} }
}; };
template <__fmt_char_type _CharT> template <__fmt_char_type _CharT>
struct _LIBCPP_TEMPLATE_VIS formatter<chrono::year_month, _CharT> struct formatter<chrono::year_month, _CharT> : public __formatter_chrono<_CharT> {
: public __formatter_chrono<_CharT> {
public: public:
using _Base = __formatter_chrono<_CharT>; using _Base = __formatter_chrono<_CharT>;
template <class _ParseContext> template <class _ParseContext>
_LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) { _LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) {
return _Base::__parse(__ctx, __format_spec::__fields_chrono, __format_spec::__flags::__year_month); return _Base::__parse(__ctx, __format_spec::__fields_chrono, __format_spec::__flags::__year_month);
} }
}; };
template <__fmt_char_type _CharT> template <__fmt_char_type _CharT>
struct _LIBCPP_TEMPLATE_VIS formatter<chrono::year_month_day, _CharT> struct formatter<chrono::year_month_day, _CharT> : public __formatter_chrono<_CharT> {
: public __formatter_chrono<_CharT> {
public: public:
using _Base = __formatter_chrono<_CharT>; using _Base = __formatter_chrono<_CharT>;
template <class _ParseContext> template <class _ParseContext>
_LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) { _LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) {
return _Base::__parse(__ctx, __format_spec::__fields_chrono, __format_spec::__flags::__date); return _Base::__parse(__ctx, __format_spec::__fields_chrono, __format_spec::__flags::__date);
} }
}; };
template <__fmt_char_type _CharT> template <__fmt_char_type _CharT>
struct _LIBCPP_TEMPLATE_VIS formatter<chrono::year_month_day_last, _CharT> struct formatter<chrono::year_month_day_last, _CharT> : public __formatter_chrono<_CharT> {
: public __formatter_chrono<_CharT> {
public: public:
using _Base = __formatter_chrono<_CharT>; using _Base = __formatter_chrono<_CharT>;
template <class _ParseContext> template <class _ParseContext>
_LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) { _LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) {
return _Base::__parse(__ctx, __format_spec::__fields_chrono, __format_spec::__flags::__date); return _Base::__parse(__ctx, __format_spec::__fields_chrono, __format_spec::__flags::__date);
} }
}; };
template <__fmt_char_type _CharT> template <__fmt_char_type _CharT>
struct _LIBCPP_TEMPLATE_VIS formatter<chrono::year_month_weekday, _CharT> struct formatter<chrono::year_month_weekday, _CharT> : public __formatter_chrono<_CharT> {
: public __formatter_chrono<_CharT> {
public: public:
using _Base = __formatter_chrono<_CharT>; using _Base = __formatter_chrono<_CharT>;
template <class _ParseContext> template <class _ParseContext>
_LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) { _LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) {
return _Base::__parse(__ctx, __format_spec::__fields_chrono, __format_spec::__flags::__date); return _Base::__parse(__ctx, __format_spec::__fields_chrono, __format_spec::__flags::__date);
} }
}; };
template <__fmt_char_type _CharT> template <__fmt_char_type _CharT>
struct _LIBCPP_TEMPLATE_VIS formatter<chrono::year_month_weekday_last, _CharT> struct formatter<chrono::year_month_weekday_last, _CharT> : public __formatter_chrono<_CharT> {
: public __formatter_chrono<_CharT> {
public: public:
using _Base = __formatter_chrono<_CharT>; using _Base = __formatter_chrono<_CharT>;
template <class _ParseContext> template <class _ParseContext>
_LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) { _LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) {
return _Base::__parse(__ctx, __format_spec::__fields_chrono, __format_spec::__flags::__date); return _Base::__parse(__ctx, __format_spec::__fields_chrono, __format_spec::__flags::__date);
} }
}; };
Show All 16 Lines

libcxx/include/__chrono/parser_std_format_spec.h

Show First 20 Lines • Show All 130 Lines • ▼ Show 20 Lines
} }
_LIBCPP_HIDE_FROM_ABI constexpr void __validate_time_zone(__flags __flags) { _LIBCPP_HIDE_FROM_ABI constexpr void __validate_time_zone(__flags __flags) {
if ((__flags & __flags::__time_zone) != __flags::__time_zone) if ((__flags & __flags::__time_zone) != __flags::__time_zone)
std::__throw_format_error("The supplied date time doesn't contain a time zone"); std::__throw_format_error("The supplied date time doesn't contain a time zone");
} }
template <class _CharT> template <class _CharT>
class _LIBCPP_TEMPLATE_VIS __parser_chrono { class __parser_chrono {
using _ConstIterator = typename basic_format_parse_context<_CharT>::const_iterator; using _ConstIterator = typename basic_format_parse_context<_CharT>::const_iterator;
public: public:
template <class _ParseContext> template <class _ParseContext>
_LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator _LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator
__parse(_ParseContext& __ctx, __fields __fields, __flags __flags) { __parse(_ParseContext& __ctx, __fields __fields, __flags __flags) {
_ConstIterator __begin = __parser_.__parse(__ctx, __fields); _ConstIterator __begin = __parser_.__parse(__ctx, __fields);
_ConstIterator __end = __ctx.end(); _ConstIterator __end = __ctx.end();
▲ Show 20 Lines • Show All 269 Lines • Show Last 20 Lines

libcxx/include/__chrono/time_point.h

Show All 26 Lines
#include <__undef_macros> #include <__undef_macros>
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace chrono namespace chrono
{ {
template <class _Clock, class _Duration = typename _Clock::duration> template <class _Clock, class _Duration = typename _Clock::duration>
class _LIBCPP_TEMPLATE_VIS time_point class time_point
{ {
static_assert(__is_duration<_Duration>::value, static_assert(__is_duration<_Duration>::value,
"Second template parameter of time_point must be a std::chrono::duration"); "Second template parameter of time_point must be a std::chrono::duration");
public: public:
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;
Show All 27 Linespublic:
_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 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_SINCE_CXX14 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
▲ Show 20 Lines • Show All 179 Lines • Show Last 20 Lines

libcxx/include/__compare/common_comparison_category.h

Show First 20 Lines • Show All 75 Lines • ▼ Show 20 Lines else if constexpr (__cat == _StrongOrd)
return strong_ordering::equivalent; return strong_ordering::equivalent;
else else
static_assert(_False, "unhandled case"); static_assert(_False, "unhandled case");
} }
} // namespace __comp_detail } // namespace __comp_detail
// [cmp.common], common comparison category type // [cmp.common], common comparison category type
template<class... _Ts> template<class... _Ts>
struct _LIBCPP_TEMPLATE_VIS common_comparison_category { struct common_comparison_category {
using type = decltype(__comp_detail::__get_comp_type<_Ts...>()); using type = decltype(__comp_detail::__get_comp_type<_Ts...>());
}; };
template<class... _Ts> template<class... _Ts>
using common_comparison_category_t = typename common_comparison_category<_Ts...>::type; using common_comparison_category_t = typename common_comparison_category<_Ts...>::type;
#endif // _LIBCPP_STD_VER >= 20 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___COMPARE_COMMON_COMPARISON_CATEGORY_H #endif // _LIBCPP___COMPARE_COMMON_COMPARISON_CATEGORY_H

libcxx/include/__compare/compare_three_way.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 >= 20 #if _LIBCPP_STD_VER >= 20
struct _LIBCPP_TEMPLATE_VIS compare_three_way struct compare_three_way
{ {
template<class _T1, class _T2> template<class _T1, class _T2>
requires three_way_comparable_with<_T1, _T2> requires three_way_comparable_with<_T1, _T2>
constexpr _LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_HIDE_FROM_ABI
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)))
{ return _VSTD::forward<_T1>(__t) <=> _VSTD::forward<_T2>(__u); } { return _VSTD::forward<_T1>(__t) <=> _VSTD::forward<_T2>(__u); }
using is_transparent = void; using is_transparent = void;
}; };
#endif // _LIBCPP_STD_VER >= 20 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___COMPARE_COMPARE_THREE_WAY_H #endif // _LIBCPP___COMPARE_COMPARE_THREE_WAY_H

libcxx/include/__compare/compare_three_way_result.h

Show All 26 Lines
template<class _Tp, class _Up> template<class _Tp, class _Up>
struct _LIBCPP_HIDE_FROM_ABI __compare_three_way_result<_Tp, _Up, decltype( struct _LIBCPP_HIDE_FROM_ABI __compare_three_way_result<_Tp, _Up, decltype(
std::declval<__make_const_lvalue_ref<_Tp>>() <=> std::declval<__make_const_lvalue_ref<_Up>>(), void() std::declval<__make_const_lvalue_ref<_Tp>>() <=> std::declval<__make_const_lvalue_ref<_Up>>(), void()
)> { )> {
using type = decltype(std::declval<__make_const_lvalue_ref<_Tp>>() <=> std::declval<__make_const_lvalue_ref<_Up>>()); using type = decltype(std::declval<__make_const_lvalue_ref<_Tp>>() <=> std::declval<__make_const_lvalue_ref<_Up>>());
}; };
template<class _Tp, class _Up = _Tp> template<class _Tp, class _Up = _Tp>
struct _LIBCPP_TEMPLATE_VIS compare_three_way_result : __compare_three_way_result<_Tp, _Up, void> { }; struct compare_three_way_result : __compare_three_way_result<_Tp, _Up, void> { };
template<class _Tp, class _Up = _Tp> template<class _Tp, class _Up = _Tp>
using compare_three_way_result_t = typename compare_three_way_result<_Tp, _Up>::type; using compare_three_way_result_t = typename compare_three_way_result<_Tp, _Up>::type;
#endif // _LIBCPP_STD_VER >= 20 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___COMPARE_COMPARE_THREE_WAY_RESULT_H #endif // _LIBCPP___COMPARE_COMPARE_THREE_WAY_RESULT_H

libcxx/include/__compare/ordering.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 >= 20 #if _LIBCPP_STD_VER >= 20
// exposition only // exposition only
enum class _LIBCPP_ENUM_VIS _OrdResult : signed char { enum class _OrdResult : signed char {
__less = -1, __less = -1,
__equiv = 0, __equiv = 0,
__greater = 1 __greater = 1
}; };
enum class _LIBCPP_ENUM_VIS _NCmpResult : signed char { enum class _NCmpResult : signed char {
__unordered = -127 __unordered = -127
}; };
class partial_ordering; class partial_ordering;
class weak_ordering; class weak_ordering;
class strong_ordering; class strong_ordering;
template<class _Tp, class... _Args> template<class _Tp, class... _Args>
▲ Show 20 Lines • Show All 287 Lines • Show Last 20 Lines

libcxx/include/__config

Show First 20 Lines • Show All 538 Lines • ▼ Show 20 Lines
# define _LIBCPP_EXPORTED_FROM_ABI __declspec(dllimport) # define _LIBCPP_EXPORTED_FROM_ABI __declspec(dllimport)
# endif # endif
# define _LIBCPP_TYPE_VIS _LIBCPP_DLL_VIS # define _LIBCPP_TYPE_VIS _LIBCPP_DLL_VIS
# define _LIBCPP_FUNC_VIS _LIBCPP_DLL_VIS # define _LIBCPP_FUNC_VIS _LIBCPP_DLL_VIS
# define _LIBCPP_EXCEPTION_ABI _LIBCPP_DLL_VIS # define _LIBCPP_EXCEPTION_ABI _LIBCPP_DLL_VIS
# define _LIBCPP_HIDDEN # define _LIBCPP_HIDDEN
# define _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS # define _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
# define _LIBCPP_TEMPLATE_VIS # define _LIBCPP_DEFAULT_VISIBILITY
# define _LIBCPP_TEMPLATE_DATA_VIS # define _LIBCPP_TEMPLATE_DATA_VIS
# define _LIBCPP_ENUM_VIS
# else # else
# if !defined(_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS) # if !defined(_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS)
# define _LIBCPP_VISIBILITY(vis) __attribute__((__visibility__(vis))) # define _LIBCPP_VISIBILITY(vis) __attribute__((__visibility__(vis)))
# else # else
# define _LIBCPP_VISIBILITY(vis) # define _LIBCPP_VISIBILITY(vis)
# endif # endif
# define _LIBCPP_HIDDEN _LIBCPP_VISIBILITY("hidden") # define _LIBCPP_HIDDEN _LIBCPP_VISIBILITY("hidden")
# define _LIBCPP_DEFAULT_VISIBILITY _LIBCPP_VISIBILITY("default")
# define _LIBCPP_FUNC_VIS _LIBCPP_VISIBILITY("default") # define _LIBCPP_FUNC_VIS _LIBCPP_VISIBILITY("default")
# define _LIBCPP_TYPE_VIS _LIBCPP_VISIBILITY("default") # define _LIBCPP_TYPE_VIS _LIBCPP_VISIBILITY("default")
# define _LIBCPP_TEMPLATE_DATA_VIS _LIBCPP_VISIBILITY("default") # define _LIBCPP_TEMPLATE_DATA_VIS _LIBCPP_VISIBILITY("default")
# define _LIBCPP_EXPORTED_FROM_ABI _LIBCPP_VISIBILITY("default") # define _LIBCPP_EXPORTED_FROM_ABI _LIBCPP_VISIBILITY("default")
# define _LIBCPP_EXCEPTION_ABI _LIBCPP_VISIBILITY("default") # define _LIBCPP_EXCEPTION_ABI _LIBCPP_VISIBILITY("default")
# define _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS _LIBCPP_VISIBILITY("default") # define _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS _LIBCPP_VISIBILITY("default")
# define _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS # define _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS
// TODO: Make this a proper customization point or remove the option to override it. // TODO: Make this a proper customization point or remove the option to override it.
# ifndef _LIBCPP_OVERRIDABLE_FUNC_VIS # ifndef _LIBCPP_OVERRIDABLE_FUNC_VIS
# define _LIBCPP_OVERRIDABLE_FUNC_VIS _LIBCPP_VISIBILITY("default") # define _LIBCPP_OVERRIDABLE_FUNC_VIS _LIBCPP_VISIBILITY("default")
# endif # endif
# if !defined(_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS) # if !defined(_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS)
// The inline should be removed once PR32114 is resolved // The inline should be removed once PR32114 is resolved
# define _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS inline _LIBCPP_HIDDEN # define _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS inline _LIBCPP_HIDDEN
# else # else
# define _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS # define _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
# endif # endif
# if !defined(_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS)
# if __has_attribute(__type_visibility__)
# define _LIBCPP_TEMPLATE_VIS __attribute__((__type_visibility__("default")))
# else
# define _LIBCPP_TEMPLATE_VIS __attribute__((__visibility__("default")))
# endif
# else
# define _LIBCPP_TEMPLATE_VIS
# endif
# if !defined(_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS) && __has_attribute(__type_visibility__)
# define _LIBCPP_ENUM_VIS __attribute__((__type_visibility__("default")))
# else
# define _LIBCPP_ENUM_VIS
# endif
# endif // defined(_LIBCPP_OBJECT_FORMAT_COFF) # endif // defined(_LIBCPP_OBJECT_FORMAT_COFF)
# if __has_attribute(exclude_from_explicit_instantiation) # if __has_attribute(exclude_from_explicit_instantiation)
# define _LIBCPP_EXCLUDE_FROM_EXPLICIT_INSTANTIATION __attribute__((__exclude_from_explicit_instantiation__)) # define _LIBCPP_EXCLUDE_FROM_EXPLICIT_INSTANTIATION __attribute__((__exclude_from_explicit_instantiation__))
# else # else
// Try to approximate the effect of exclude_from_explicit_instantiation // Try to approximate the effect of exclude_from_explicit_instantiation
// (which is that entities are not assumed to be provided by explicit // (which is that entities are not assumed to be provided by explicit
// template instantiations in the dylib) by always inlining those entities. // template instantiations in the dylib) by always inlining those entities.
▲ Show 20 Lines • Show All 55 Lines • ▼ Show 20 Lines
# define _LIBCPP_HIDE_FROM_ABI_AFTER_V1 _LIBCPP_HIDE_FROM_ABI # define _LIBCPP_HIDE_FROM_ABI_AFTER_V1 _LIBCPP_HIDE_FROM_ABI
# endif # endif
// Just so we can migrate to the new macros gradually. // Just so we can migrate to the new macros gradually.
# define _LIBCPP_INLINE_VISIBILITY _LIBCPP_HIDE_FROM_ABI # define _LIBCPP_INLINE_VISIBILITY _LIBCPP_HIDE_FROM_ABI
// Inline namespaces are available in Clang/GCC/MSVC regardless of C++ dialect. // Inline namespaces are available in Clang/GCC/MSVC regardless of C++ dialect.
// clang-format off // clang-format off
# define _LIBCPP_BEGIN_NAMESPACE_STD namespace std { inline namespace _LIBCPP_ABI_NAMESPACE { # define _LIBCPP_BEGIN_NAMESPACE_STD namespace _LIBCPP_DEFAULT_VISIBILITY std { inline namespace _LIBCPP_ABI_NAMESPACE {
# define _LIBCPP_END_NAMESPACE_STD }} # define _LIBCPP_END_NAMESPACE_STD }}
# define _VSTD std # define _VSTD std
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
# if _LIBCPP_STD_VER >= 17 # if _LIBCPP_STD_VER >= 17
# define _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM \ # define _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM \
_LIBCPP_BEGIN_NAMESPACE_STD inline namespace __fs { namespace filesystem { _LIBCPP_BEGIN_NAMESPACE_STD inline namespace __fs { namespace filesystem {
Show All 36 Lines# define _LIBCPP_DECLARE_STRONG_ENUM_EPILOG(x) \
__lx __v_; \ __lx __v_; \
_LIBCPP_INLINE_VISIBILITY x(__lx __v) : __v_(__v) {} \ _LIBCPP_INLINE_VISIBILITY x(__lx __v) : __v_(__v) {} \
_LIBCPP_INLINE_VISIBILITY explicit x(int __v) : __v_(static_cast<__lx>(__v)) {} \ _LIBCPP_INLINE_VISIBILITY explicit x(int __v) : __v_(static_cast<__lx>(__v)) {} \
_LIBCPP_INLINE_VISIBILITY operator int() const { return __v_; } \ _LIBCPP_INLINE_VISIBILITY operator int() const { return __v_; } \
}; };
// clang-format on // clang-format on
# else // _LIBCPP_CXX03_LANG # else // _LIBCPP_CXX03_LANG
# define _LIBCPP_DECLARE_STRONG_ENUM(x) enum class _LIBCPP_ENUM_VIS x # define _LIBCPP_DECLARE_STRONG_ENUM(x) enum class x
# define _LIBCPP_DECLARE_STRONG_ENUM_EPILOG(x) # define _LIBCPP_DECLARE_STRONG_ENUM_EPILOG(x)
# endif // _LIBCPP_CXX03_LANG # endif // _LIBCPP_CXX03_LANG
# if defined(__APPLE__) || defined(__FreeBSD__) || defined(_LIBCPP_MSVCRT_LIKE) || defined(__NetBSD__) # if defined(__APPLE__) || defined(__FreeBSD__) || defined(_LIBCPP_MSVCRT_LIKE) || defined(__NetBSD__)
# define _LIBCPP_LOCALE__L_EXTENSIONS 1 # define _LIBCPP_LOCALE__L_EXTENSIONS 1
# endif # endif
# ifdef __FreeBSD__ # ifdef __FreeBSD__
▲ Show 20 Lines • Show All 597 Lines • Show Last 20 Lines

libcxx/include/__coroutine/coroutine_handle.h

Show All 21 Lines
#endif #endif
#if _LIBCPP_STD_VER >= 20 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
// [coroutine.handle] // [coroutine.handle]
template <class _Promise = void> template <class _Promise = void>
struct _LIBCPP_TEMPLATE_VIS coroutine_handle; struct coroutine_handle;
template <> template <>
struct _LIBCPP_TEMPLATE_VIS coroutine_handle<void> { struct coroutine_handle<void> {
public: public:
// [coroutine.handle.con], construct/reset // [coroutine.handle.con], construct/reset
constexpr coroutine_handle() noexcept = default; constexpr coroutine_handle() noexcept = default;
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
constexpr coroutine_handle(nullptr_t) noexcept {} constexpr coroutine_handle(nullptr_t) noexcept {}
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
▲ Show 20 Lines • Show All 57 Lines • ▼ Show 20 Linesconstexpr bool operator==(coroutine_handle<> __x, coroutine_handle<> __y) noexcept {
return __x.address() == __y.address(); return __x.address() == __y.address();
} }
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI
constexpr strong_ordering operator<=>(coroutine_handle<> __x, coroutine_handle<> __y) noexcept { constexpr strong_ordering operator<=>(coroutine_handle<> __x, coroutine_handle<> __y) noexcept {
return compare_three_way()(__x.address(), __y.address()); return compare_three_way()(__x.address(), __y.address());
} }
template <class _Promise> template <class _Promise>
struct _LIBCPP_TEMPLATE_VIS coroutine_handle { struct coroutine_handle {
public: public:
// [coroutine.handle.con], construct/reset // [coroutine.handle.con], construct/reset
constexpr coroutine_handle() noexcept = default; constexpr coroutine_handle() noexcept = default;
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
constexpr coroutine_handle(nullptr_t) noexcept {} constexpr coroutine_handle(nullptr_t) noexcept {}
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
▲ Show 20 Lines • Show All 86 Lines • Show Last 20 Lines

libcxx/include/__coroutine/noop_coroutine_handle.h

Show All 22 Lines
#if __has_builtin(__builtin_coro_noop) || defined(_LIBCPP_COMPILER_GCC) #if __has_builtin(__builtin_coro_noop) || defined(_LIBCPP_COMPILER_GCC)
// [coroutine.noop] // [coroutine.noop]
// [coroutine.promise.noop] // [coroutine.promise.noop]
struct noop_coroutine_promise {}; struct noop_coroutine_promise {};
// [coroutine.handle.noop] // [coroutine.handle.noop]
template <> template <>
struct _LIBCPP_TEMPLATE_VIS coroutine_handle<noop_coroutine_promise> { struct coroutine_handle<noop_coroutine_promise> {
public: public:
// [coroutine.handle.noop.conv], conversion // [coroutine.handle.noop.conv], conversion
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
constexpr operator coroutine_handle<>() const noexcept { constexpr operator coroutine_handle<>() const noexcept {
return coroutine_handle<>::from_address(address()); return coroutine_handle<>::from_address(address());
} }
// [coroutine.handle.noop.observers], observers // [coroutine.handle.noop.observers], observers
▲ Show 20 Lines • Show All 73 Lines • Show Last 20 Lines

libcxx/include/__filesystem/copy_options.h

Show All 17 Lines
#endif #endif
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
_LIBCPP_BEGIN_NAMESPACE_FILESYSTEM _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
_LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY_PUSH _LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY_PUSH
enum class _LIBCPP_ENUM_VIS copy_options : unsigned short { enum class copy_options : unsigned short {
none = 0, none = 0,
skip_existing = 1, skip_existing = 1,
overwrite_existing = 2, overwrite_existing = 2,
update_existing = 4, update_existing = 4,
recursive = 8, recursive = 8,
copy_symlinks = 16, copy_symlinks = 16,
skip_symlinks = 32, skip_symlinks = 32,
directories_only = 64, directories_only = 64,
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

libcxx/include/__filesystem/directory_options.h

Show All 17 Lines
#endif #endif
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
_LIBCPP_BEGIN_NAMESPACE_FILESYSTEM _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
_LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY_PUSH _LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY_PUSH
enum class _LIBCPP_ENUM_VIS directory_options : unsigned char { enum class directory_options : unsigned char {
none = 0, none = 0,
follow_directory_symlink = 1, follow_directory_symlink = 1,
skip_permission_denied = 2 skip_permission_denied = 2
}; };
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
inline constexpr directory_options operator&(directory_options __lhs, inline constexpr directory_options operator&(directory_options __lhs,
directory_options __rhs) { directory_options __rhs) {
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

libcxx/include/__filesystem/file_type.h

Show All 17 Lines
#endif #endif
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
_LIBCPP_BEGIN_NAMESPACE_FILESYSTEM _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
// On Windows, the library never identifies files as block, character, fifo // On Windows, the library never identifies files as block, character, fifo
// or socket. // or socket.
enum class _LIBCPP_ENUM_VIS file_type : signed char { enum class file_type : signed char {
none = 0, none = 0,
not_found = -1, not_found = -1,
regular = 1, regular = 1,
directory = 2, directory = 2,
symlink = 3, symlink = 3,
block = 4, block = 4,
character = 5, character = 5,
fifo = 6, fifo = 6,
Show All 9 Lines

libcxx/include/__filesystem/path.h

Show First 20 Lines • Show All 460 Lines • ▼ Show 20 Lines#if defined(_LIBCPP_WIN32API)
static constexpr value_type preferred_separator = L'\\'; static constexpr value_type preferred_separator = L'\\';
#else #else
typedef char value_type; typedef char value_type;
static constexpr value_type preferred_separator = '/'; static constexpr value_type preferred_separator = '/';
#endif #endif
typedef basic_string<value_type> string_type; typedef basic_string<value_type> string_type;
typedef basic_string_view<value_type> __string_view; typedef basic_string_view<value_type> __string_view;
enum _LIBCPP_ENUM_VIS format : unsigned char { enum format : unsigned char {
auto_format, auto_format,
native_format, native_format,
generic_format generic_format
}; };
// constructors and destructor // constructors and destructor
_LIBCPP_HIDE_FROM_ABI path() noexcept {} _LIBCPP_HIDE_FROM_ABI path() noexcept {}
_LIBCPP_HIDE_FROM_ABI path(const path& __p) : __pn_(__p.__pn_) {} _LIBCPP_HIDE_FROM_ABI path(const path& __p) : __pn_(__p.__pn_) {}
▲ Show 20 Lines • Show All 630 Lines • Show Last 20 Lines

libcxx/include/__filesystem/perm_options.h

Show All 17 Lines
#endif #endif
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
_LIBCPP_BEGIN_NAMESPACE_FILESYSTEM _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
_LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY_PUSH _LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY_PUSH
enum class _LIBCPP_ENUM_VIS perm_options : unsigned char { enum class perm_options : unsigned char {
replace = 1, replace = 1,
add = 2, add = 2,
remove = 4, remove = 4,
nofollow = 8 nofollow = 8
}; };
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
inline constexpr perm_options operator&(perm_options __lhs, perm_options __rhs) { inline constexpr perm_options operator&(perm_options __lhs, perm_options __rhs) {
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

libcxx/include/__filesystem/perms.h

Show All 21 Lines
_LIBCPP_BEGIN_NAMESPACE_FILESYSTEM _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
_LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY_PUSH _LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY_PUSH
// On Windows, these permission bits map to one single readonly flag per // On Windows, these permission bits map to one single readonly flag per
// file, and the executable bit is always returned as set. When setting // file, and the executable bit is always returned as set. When setting
// permissions, as long as the write bit is set for either owner, group or // permissions, as long as the write bit is set for either owner, group or
// others, the readonly flag is cleared. // others, the readonly flag is cleared.
enum class _LIBCPP_ENUM_VIS perms : unsigned { enum class perms : unsigned {
none = 0, none = 0,
owner_read = 0400, owner_read = 0400,
owner_write = 0200, owner_write = 0200,
owner_exec = 0100, owner_exec = 0100,
owner_all = 0700, owner_all = 0700,
group_read = 040, group_read = 040,
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

libcxx/include/__format/buffer.h

Show First 20 Lines • Show All 53 Lines • ▼ Show 20 Lines
namespace __format { namespace __format {
/// A "buffer" that handles writing to the proper iterator. /// A "buffer" that handles writing to the proper iterator.
/// ///
/// This helper is used together with the @ref back_insert_iterator to offer /// This helper is used together with the @ref back_insert_iterator to offer
/// type-erasure for the formatting functions. This reduces the number to /// type-erasure for the formatting functions. This reduces the number to
/// template instantiations. /// template instantiations.
template <__fmt_char_type _CharT> template <__fmt_char_type _CharT>
class _LIBCPP_TEMPLATE_VIS __output_buffer { class __output_buffer {
public: public:
using value_type = _CharT; using value_type = _CharT;
template <class _Tp> template <class _Tp>
_LIBCPP_HIDE_FROM_ABI explicit __output_buffer(_CharT* __ptr, size_t __capacity, _Tp* __obj) _LIBCPP_HIDE_FROM_ABI explicit __output_buffer(_CharT* __ptr, size_t __capacity, _Tp* __obj)
: __ptr_(__ptr), : __ptr_(__ptr),
__capacity_(__capacity), __capacity_(__capacity),
__flush_([](_CharT* __p, size_t __n, void* __o) { static_cast<_Tp*>(__o)->__flush(__p, __n); }), __flush_([](_CharT* __p, size_t __n, void* __o) { static_cast<_Tp*>(__o)->__flush(__p, __n); }),
▲ Show 20 Lines • Show All 156 Lines • ▼ Show 20 Linesprivate:
} }
}; };
/// A storage using an internal buffer. /// A storage using an internal buffer.
/// ///
/// This storage is used when writing a single element to the output iterator /// This storage is used when writing a single element to the output iterator
/// is expensive. /// is expensive.
template <__fmt_char_type _CharT> template <__fmt_char_type _CharT>
class _LIBCPP_TEMPLATE_VIS __internal_storage { class __internal_storage {
public: public:
_LIBCPP_HIDE_FROM_ABI _CharT* __begin() { return __buffer_; } _LIBCPP_HIDE_FROM_ABI _CharT* __begin() { return __buffer_; }
static constexpr size_t __buffer_size = 256 / sizeof(_CharT); static constexpr size_t __buffer_size = 256 / sizeof(_CharT);
private: private:
_CharT __buffer_[__buffer_size]; _CharT __buffer_[__buffer_size];
}; };
/// A storage writing directly to the storage. /// A storage writing directly to the storage.
/// ///
/// This requires the storage to be a contiguous buffer of \a _CharT. /// This requires the storage to be a contiguous buffer of \a _CharT.
/// Since the output is directly written to the underlying storage this class /// Since the output is directly written to the underlying storage this class
/// is just an empty class. /// is just an empty class.
template <__fmt_char_type _CharT> template <__fmt_char_type _CharT>
class _LIBCPP_TEMPLATE_VIS __direct_storage {}; class __direct_storage {};
template <class _OutIt, class _CharT> template <class _OutIt, class _CharT>
concept __enable_direct_output = __fmt_char_type<_CharT> && concept __enable_direct_output = __fmt_char_type<_CharT> &&
(same_as<_OutIt, _CharT*> (same_as<_OutIt, _CharT*>
#ifndef _LIBCPP_ENABLE_DEBUG_MODE #ifndef _LIBCPP_ENABLE_DEBUG_MODE
|| same_as<_OutIt, __wrap_iter<_CharT*>> || same_as<_OutIt, __wrap_iter<_CharT*>>
#endif #endif
); );
/// Write policy for directly writing to the underlying output. /// Write policy for directly writing to the underlying output.
template <class _OutIt, __fmt_char_type _CharT> template <class _OutIt, __fmt_char_type _CharT>
class _LIBCPP_TEMPLATE_VIS __writer_direct { class __writer_direct {
public: public:
_LIBCPP_HIDE_FROM_ABI explicit __writer_direct(_OutIt __out_it) _LIBCPP_HIDE_FROM_ABI explicit __writer_direct(_OutIt __out_it)
: __out_it_(__out_it) {} : __out_it_(__out_it) {}
_LIBCPP_HIDE_FROM_ABI _OutIt __out_it() { return __out_it_; } _LIBCPP_HIDE_FROM_ABI _OutIt __out_it() { return __out_it_; }
_LIBCPP_HIDE_FROM_ABI void __flush(_CharT*, size_t __n) { _LIBCPP_HIDE_FROM_ABI void __flush(_CharT*, size_t __n) {
// _OutIt can be a __wrap_iter<CharT*>. Therefore the original iterator // _OutIt can be a __wrap_iter<CharT*>. Therefore the original iterator
// is adjusted. // is adjusted.
__out_it_ += __n; __out_it_ += __n;
} }
private: private:
_OutIt __out_it_; _OutIt __out_it_;
}; };
/// Write policy for copying the buffer to the output. /// Write policy for copying the buffer to the output.
template <class _OutIt, __fmt_char_type _CharT> template <class _OutIt, __fmt_char_type _CharT>
class _LIBCPP_TEMPLATE_VIS __writer_iterator { class __writer_iterator {
public: public:
_LIBCPP_HIDE_FROM_ABI explicit __writer_iterator(_OutIt __out_it) _LIBCPP_HIDE_FROM_ABI explicit __writer_iterator(_OutIt __out_it)
: __out_it_{_VSTD::move(__out_it)} {} : __out_it_{_VSTD::move(__out_it)} {}
_LIBCPP_HIDE_FROM_ABI _OutIt __out_it() && { return std::move(__out_it_); } _LIBCPP_HIDE_FROM_ABI _OutIt __out_it() && { return std::move(__out_it_); }
_LIBCPP_HIDE_FROM_ABI void __flush(_CharT* __ptr, size_t __n) { _LIBCPP_HIDE_FROM_ABI void __flush(_CharT* __ptr, size_t __n) {
__out_it_ = std::ranges::copy_n(__ptr, __n, std::move(__out_it_)).out; __out_it_ = std::ranges::copy_n(__ptr, __n, std::move(__out_it_)).out;
Show All 13 Lines
template <class _Container> template <class _Container>
concept __insertable = concept __insertable =
__enable_insertable<_Container> && __fmt_char_type<typename _Container::value_type> && __enable_insertable<_Container> && __fmt_char_type<typename _Container::value_type> &&
requires(_Container& __t, add_pointer_t<typename _Container::value_type> __first, requires(_Container& __t, add_pointer_t<typename _Container::value_type> __first,
add_pointer_t<typename _Container::value_type> __last) { __t.insert(__t.end(), __first, __last); }; add_pointer_t<typename _Container::value_type> __last) { __t.insert(__t.end(), __first, __last); };
/// Extract the container type of a \ref back_insert_iterator. /// Extract the container type of a \ref back_insert_iterator.
template <class _It> template <class _It>
struct _LIBCPP_TEMPLATE_VIS __back_insert_iterator_container { struct __back_insert_iterator_container {
using type = void; using type = void;
}; };
template <__insertable _Container> template <__insertable _Container>
struct _LIBCPP_TEMPLATE_VIS __back_insert_iterator_container<back_insert_iterator<_Container>> { struct __back_insert_iterator_container<back_insert_iterator<_Container>> {
using type = _Container; using type = _Container;
}; };
/// Write policy for inserting the buffer in a container. /// Write policy for inserting the buffer in a container.
template <class _Container> template <class _Container>
class _LIBCPP_TEMPLATE_VIS __writer_container { class __writer_container {
public: public:
using _CharT = typename _Container::value_type; using _CharT = typename _Container::value_type;
_LIBCPP_HIDE_FROM_ABI explicit __writer_container(back_insert_iterator<_Container> __out_it) _LIBCPP_HIDE_FROM_ABI explicit __writer_container(back_insert_iterator<_Container> __out_it)
: __container_{__out_it.__get_container()} {} : __container_{__out_it.__get_container()} {}
_LIBCPP_HIDE_FROM_ABI auto __out_it() { return std::back_inserter(*__container_); } _LIBCPP_HIDE_FROM_ABI auto __out_it() { return std::back_inserter(*__container_); }
_LIBCPP_HIDE_FROM_ABI void __flush(_CharT* __ptr, size_t __n) { _LIBCPP_HIDE_FROM_ABI void __flush(_CharT* __ptr, size_t __n) {
__container_->insert(__container_->end(), __ptr, __ptr + __n); __container_->insert(__container_->end(), __ptr, __ptr + __n);
} }
private: private:
_Container* __container_; _Container* __container_;
}; };
/// Selects the type of the writer used for the output iterator. /// Selects the type of the writer used for the output iterator.
template <class _OutIt, class _CharT> template <class _OutIt, class _CharT>
class _LIBCPP_TEMPLATE_VIS __writer_selector { class __writer_selector {
using _Container = typename __back_insert_iterator_container<_OutIt>::type; using _Container = typename __back_insert_iterator_container<_OutIt>::type;
public: public:
using type = conditional_t<!same_as<_Container, void>, __writer_container<_Container>, using type = conditional_t<!same_as<_Container, void>, __writer_container<_Container>,
conditional_t<__enable_direct_output<_OutIt, _CharT>, __writer_direct<_OutIt, _CharT>, conditional_t<__enable_direct_output<_OutIt, _CharT>, __writer_direct<_OutIt, _CharT>,
__writer_iterator<_OutIt, _CharT>>>; __writer_iterator<_OutIt, _CharT>>>;
}; };
/// The generic formatting buffer. /// The generic formatting buffer.
template <class _OutIt, __fmt_char_type _CharT> template <class _OutIt, __fmt_char_type _CharT>
requires(output_iterator<_OutIt, const _CharT&>) class _LIBCPP_TEMPLATE_VIS requires(output_iterator<_OutIt, const _CharT&>)
__format_buffer { class __format_buffer {
using _Storage = using _Storage =
conditional_t<__enable_direct_output<_OutIt, _CharT>, conditional_t<__enable_direct_output<_OutIt, _CharT>,
__direct_storage<_CharT>, __internal_storage<_CharT>>; __direct_storage<_CharT>, __internal_storage<_CharT>>;
public: public:
_LIBCPP_HIDE_FROM_ABI explicit __format_buffer(_OutIt __out_it) _LIBCPP_HIDE_FROM_ABI explicit __format_buffer(_OutIt __out_it)
requires(same_as<_Storage, __internal_storage<_CharT>>) requires(same_as<_Storage, __internal_storage<_CharT>>)
: __output_(__storage_.__begin(), __storage_.__buffer_size, this), __writer_(_VSTD::move(__out_it)) {} : __output_(__storage_.__begin(), __storage_.__buffer_size, this), __writer_(_VSTD::move(__out_it)) {}
Show All 18 Linesprivate:
typename __writer_selector<_OutIt, _CharT>::type __writer_; typename __writer_selector<_OutIt, _CharT>::type __writer_;
}; };
/// A buffer that counts the number of insertions. /// A buffer that counts the number of insertions.
/// ///
/// Since \ref formatted_size only needs to know the size, the output itself is /// Since \ref formatted_size only needs to know the size, the output itself is
/// discarded. /// discarded.
template <__fmt_char_type _CharT> template <__fmt_char_type _CharT>
class _LIBCPP_TEMPLATE_VIS __formatted_size_buffer { class __formatted_size_buffer {
public: public:
_LIBCPP_HIDE_FROM_ABI auto __make_output_iterator() { return __output_.__make_output_iterator(); } _LIBCPP_HIDE_FROM_ABI auto __make_output_iterator() { return __output_.__make_output_iterator(); }
_LIBCPP_HIDE_FROM_ABI void __flush(const _CharT*, size_t __n) { __size_ += __n; } _LIBCPP_HIDE_FROM_ABI void __flush(const _CharT*, size_t __n) { __size_ += __n; }
_LIBCPP_HIDE_FROM_ABI size_t __result() && { _LIBCPP_HIDE_FROM_ABI size_t __result() && {
__output_.__flush(); __output_.__flush();
return __size_; return __size_;
} }
private: private:
__internal_storage<_CharT> __storage_; __internal_storage<_CharT> __storage_;
__output_buffer<_CharT> __output_{__storage_.__begin(), __storage_.__buffer_size, this}; __output_buffer<_CharT> __output_{__storage_.__begin(), __storage_.__buffer_size, this};
size_t __size_{0}; size_t __size_{0};
}; };
/// The base of a buffer that counts and limits the number of insertions. /// The base of a buffer that counts and limits the number of insertions.
template <class _OutIt, __fmt_char_type _CharT, bool> template <class _OutIt, __fmt_char_type _CharT, bool>
requires(output_iterator<_OutIt, const _CharT&>) requires(output_iterator<_OutIt, const _CharT&>)
struct _LIBCPP_TEMPLATE_VIS __format_to_n_buffer_base { struct __format_to_n_buffer_base {
using _Size = iter_difference_t<_OutIt>; using _Size = iter_difference_t<_OutIt>;
public: public:
_LIBCPP_HIDE_FROM_ABI explicit __format_to_n_buffer_base(_OutIt __out_it, _Size __max_size) _LIBCPP_HIDE_FROM_ABI explicit __format_to_n_buffer_base(_OutIt __out_it, _Size __max_size)
: __writer_(_VSTD::move(__out_it)), __max_size_(_VSTD::max(_Size(0), __max_size)) {} : __writer_(_VSTD::move(__out_it)), __max_size_(_VSTD::max(_Size(0), __max_size)) {}
_LIBCPP_HIDE_FROM_ABI void __flush(_CharT* __ptr, size_t __n) { _LIBCPP_HIDE_FROM_ABI void __flush(_CharT* __ptr, size_t __n) {
if (_Size(__size_) <= __max_size_) if (_Size(__size_) <= __max_size_)
Show All 13 Lines
/// The base of a buffer that counts and limits the number of insertions. /// The base of a buffer that counts and limits the number of insertions.
/// ///
/// This version is used when \c __enable_direct_output<_OutIt, _CharT> == true. /// This version is used when \c __enable_direct_output<_OutIt, _CharT> == true.
/// ///
/// This class limits the size available to the direct writer so it will not /// This class limits the size available to the direct writer so it will not
/// exceed the maximum number of code units. /// exceed the maximum number of code units.
template <class _OutIt, __fmt_char_type _CharT> template <class _OutIt, __fmt_char_type _CharT>
requires(output_iterator<_OutIt, const _CharT&>) requires(output_iterator<_OutIt, const _CharT&>)
class _LIBCPP_TEMPLATE_VIS __format_to_n_buffer_base<_OutIt, _CharT, true> { class __format_to_n_buffer_base<_OutIt, _CharT, true> {
using _Size = iter_difference_t<_OutIt>; using _Size = iter_difference_t<_OutIt>;
public: public:
_LIBCPP_HIDE_FROM_ABI explicit __format_to_n_buffer_base(_OutIt __out_it, _Size __max_size) _LIBCPP_HIDE_FROM_ABI explicit __format_to_n_buffer_base(_OutIt __out_it, _Size __max_size)
: __output_(_VSTD::__unwrap_iter(__out_it), __max_size, this), : __output_(_VSTD::__unwrap_iter(__out_it), __max_size, this),
__writer_(_VSTD::move(__out_it)), __writer_(_VSTD::move(__out_it)),
__max_size_(__max_size) { __max_size_(__max_size) {
if (__max_size <= 0) [[unlikely]] if (__max_size <= 0) [[unlikely]]
Show All 33 Linesprotected:
_Size __max_size_; _Size __max_size_;
_Size __size_{0}; _Size __size_{0};
}; };
/// The buffer that counts and limits the number of insertions. /// The buffer that counts and limits the number of insertions.
template <class _OutIt, __fmt_char_type _CharT> template <class _OutIt, __fmt_char_type _CharT>
requires(output_iterator<_OutIt, const _CharT&>) requires(output_iterator<_OutIt, const _CharT&>)
struct _LIBCPP_TEMPLATE_VIS __format_to_n_buffer final struct __format_to_n_buffer final
: public __format_to_n_buffer_base< _OutIt, _CharT, __enable_direct_output<_OutIt, _CharT>> { : public __format_to_n_buffer_base< _OutIt, _CharT, __enable_direct_output<_OutIt, _CharT>> {
using _Base = __format_to_n_buffer_base<_OutIt, _CharT, __enable_direct_output<_OutIt, _CharT>>; using _Base = __format_to_n_buffer_base<_OutIt, _CharT, __enable_direct_output<_OutIt, _CharT>>;
using _Size = iter_difference_t<_OutIt>; using _Size = iter_difference_t<_OutIt>;
public: public:
_LIBCPP_HIDE_FROM_ABI explicit __format_to_n_buffer(_OutIt __out_it, _Size __max_size) _LIBCPP_HIDE_FROM_ABI explicit __format_to_n_buffer(_OutIt __out_it, _Size __max_size)
: _Base(_VSTD::move(__out_it), __max_size) {} : _Base(_VSTD::move(__out_it), __max_size) {}
_LIBCPP_HIDE_FROM_ABI auto __make_output_iterator() { return this->__output_.__make_output_iterator(); } _LIBCPP_HIDE_FROM_ABI auto __make_output_iterator() { return this->__output_.__make_output_iterator(); }
Show All 18 Lines
// type. So using this output iterator means there needs to be a new format // type. So using this output iterator means there needs to be a new format
// context and the format arguments need to be retargeted to the new context. // context and the format arguments need to be retargeted to the new context.
// This retargeting is done by a basic_format_context specialized for the // This retargeting is done by a basic_format_context specialized for the
// __iterator of this container. // __iterator of this container.
// //
// This class uses its own buffer management, since using vector // This class uses its own buffer management, since using vector
// would lead to a circular include with formatter for vector<bool>. // would lead to a circular include with formatter for vector<bool>.
template <__fmt_char_type _CharT> template <__fmt_char_type _CharT>
class _LIBCPP_TEMPLATE_VIS __retarget_buffer { class __retarget_buffer {
using _Alloc = allocator<_CharT>; using _Alloc = allocator<_CharT>;
public: public:
using value_type = _CharT; using value_type = _CharT;
struct __iterator { struct __iterator {
using difference_type = ptrdiff_t; using difference_type = ptrdiff_t;
▲ Show 20 Lines • Show All 111 Lines • Show Last 20 Lines

libcxx/include/__format/container_adaptor.h

Show All 31 Lines
// [container.adaptors.format] only specifies the library should provide the // [container.adaptors.format] only specifies the library should provide the
// formatter specializations, not which header should provide them. // formatter specializations, not which header should provide them.
// Since <format> includes a lot of headers, add these headers here instead of // Since <format> includes a lot of headers, add these headers here instead of
// adding more dependencies like, locale, optinal, string, tuple, etc. to the // adding more dependencies like, locale, optinal, string, tuple, etc. to the
// adaptor headers. To use the format functions users already include <format>. // adaptor headers. To use the format functions users already include <format>.
template <class _Adaptor, class _CharT> template <class _Adaptor, class _CharT>
struct _LIBCPP_TEMPLATE_VIS __formatter_container_adaptor { struct __formatter_container_adaptor {
private: private:
using __maybe_const_container = __fmt_maybe_const<typename _Adaptor::container_type, _CharT>; using __maybe_const_container = __fmt_maybe_const<typename _Adaptor::container_type, _CharT>;
using __maybe_const_adaptor = __maybe_const<is_const_v<__maybe_const_container>, _Adaptor>; using __maybe_const_adaptor = __maybe_const<is_const_v<__maybe_const_container>, _Adaptor>;
formatter<ranges::ref_view<__maybe_const_container>, _CharT> __underlying_; formatter<ranges::ref_view<__maybe_const_container>, _CharT> __underlying_;
public: public:
template <class _ParseContext> template <class _ParseContext>
_LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) { _LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) {
return __underlying_.parse(__ctx); return __underlying_.parse(__ctx);
} }
template <class _FormatContext> template <class _FormatContext>
_LIBCPP_HIDE_FROM_ABI typename _FormatContext::iterator _LIBCPP_HIDE_FROM_ABI typename _FormatContext::iterator
format(__maybe_const_adaptor& __adaptor, _FormatContext& __ctx) const { format(__maybe_const_adaptor& __adaptor, _FormatContext& __ctx) const {
return __underlying_.format(__adaptor.__get_container(), __ctx); return __underlying_.format(__adaptor.__get_container(), __ctx);
} }
}; };
template <class _CharT, class _Tp, formattable<_CharT> _Container> template <class _CharT, class _Tp, formattable<_CharT> _Container>
struct _LIBCPP_TEMPLATE_VIS formatter<queue<_Tp, _Container>, _CharT> struct formatter<queue<_Tp, _Container>, _CharT>
: public __formatter_container_adaptor<queue<_Tp, _Container>, _CharT> {}; : public __formatter_container_adaptor<queue<_Tp, _Container>, _CharT> {};
template <class _CharT, class _Tp, class _Container, class _Compare> template <class _CharT, class _Tp, class _Container, class _Compare>
struct _LIBCPP_TEMPLATE_VIS formatter<priority_queue<_Tp, _Container, _Compare>, _CharT> struct formatter<priority_queue<_Tp, _Container, _Compare>, _CharT>
: public __formatter_container_adaptor<priority_queue<_Tp, _Container, _Compare>, _CharT> {}; : public __formatter_container_adaptor<priority_queue<_Tp, _Container, _Compare>, _CharT> {};
template <class _CharT, class _Tp, formattable<_CharT> _Container> template <class _CharT, class _Tp, formattable<_CharT> _Container>
struct _LIBCPP_TEMPLATE_VIS formatter<stack<_Tp, _Container>, _CharT> struct formatter<stack<_Tp, _Container>, _CharT>
: public __formatter_container_adaptor<stack<_Tp, _Container>, _CharT> {}; : public __formatter_container_adaptor<stack<_Tp, _Container>, _CharT> {};
#endif //_LIBCPP_STD_VER >= 23 #endif //_LIBCPP_STD_VER >= 23
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___FORMAT_CONTAINER_ADAPTOR_H #endif // _LIBCPP___FORMAT_CONTAINER_ADAPTOR_H

libcxx/include/__format/format_arg.h

Show First 20 Lines • Show All 48 Lines • ▼ Show 20 Lines
/// ABI break. The packed type is 64-bit so this reduces the maximum number of /// ABI break. The packed type is 64-bit so this reduces the maximum number of
/// packed elements from 16 to 12. /// packed elements from 16 to 12.
/// ///
/// @note Some members of this enum are an extension. These extensions need /// @note Some members of this enum are an extension. These extensions need
/// special behaviour in visit_format_arg. There they need to be wrapped in a /// special behaviour in visit_format_arg. There they need to be wrapped in a
/// handle to satisfy the user observable behaviour. The internal function /// handle to satisfy the user observable behaviour. The internal function
/// __visit_format_arg doesn't do this wrapping. So in the format functions /// __visit_format_arg doesn't do this wrapping. So in the format functions
/// this function is used to avoid unneeded overhead. /// this function is used to avoid unneeded overhead.
enum class _LIBCPP_ENUM_VIS __arg_t : uint8_t { enum class __arg_t : uint8_t {
__none, __none,
__boolean, __boolean,
__char_type, __char_type,
__int, __int,
__long_long, __long_long,
__i128, // extension __i128, // extension
__unsigned, __unsigned,
__unsigned_long_long, __unsigned_long_long,
▲ Show 20 Lines • Show All 156 Lines • ▼ Show 20 Lines _LIBCPP_HIDE_FROM_ABI __basic_format_arg_value(basic_string_view<_CharT> __value) noexcept
: __string_view_(__value) {} : __string_view_(__value) {}
_LIBCPP_HIDE_FROM_ABI __basic_format_arg_value(const void* __value) noexcept : __ptr_(__value) {} _LIBCPP_HIDE_FROM_ABI __basic_format_arg_value(const void* __value) noexcept : __ptr_(__value) {}
_LIBCPP_HIDE_FROM_ABI __basic_format_arg_value(__handle __value) noexcept _LIBCPP_HIDE_FROM_ABI __basic_format_arg_value(__handle __value) noexcept
// TODO FMT Investigate why it doesn't work without the forward. // TODO FMT Investigate why it doesn't work without the forward.
: __handle_(std::forward<__handle>(__value)) {} : __handle_(std::forward<__handle>(__value)) {}
}; };
template <class _Context> template <class _Context>
class _LIBCPP_TEMPLATE_VIS basic_format_arg { class basic_format_arg {
public: public:
class _LIBCPP_TEMPLATE_VIS handle; class handle;
_LIBCPP_HIDE_FROM_ABI basic_format_arg() noexcept _LIBCPP_HIDE_FROM_ABI basic_format_arg() noexcept
: __type_{__format::__arg_t::__none} {} : __type_{__format::__arg_t::__none} {}
_LIBCPP_HIDE_FROM_ABI explicit operator bool() const noexcept { _LIBCPP_HIDE_FROM_ABI explicit operator bool() const noexcept {
return __type_ != __format::__arg_t::__none; return __type_ != __format::__arg_t::__none;
} }
Show All 16 Linespublic:
__format::__arg_t __type_; __format::__arg_t __type_;
_LIBCPP_HIDE_FROM_ABI explicit basic_format_arg(__format::__arg_t __type, _LIBCPP_HIDE_FROM_ABI explicit basic_format_arg(__format::__arg_t __type,
__basic_format_arg_value<_Context> __value) noexcept __basic_format_arg_value<_Context> __value) noexcept
: __value_(__value), __type_(__type) {} : __value_(__value), __type_(__type) {}
}; };
template <class _Context> template <class _Context>
class _LIBCPP_TEMPLATE_VIS basic_format_arg<_Context>::handle { class basic_format_arg<_Context>::handle {
public: public:
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
void format(basic_format_parse_context<char_type>& __parse_ctx, _Context& __ctx) const { void format(basic_format_parse_context<char_type>& __parse_ctx, _Context& __ctx) const {
__handle_.__format_(__parse_ctx, __ctx, __handle_.__ptr_); __handle_.__format_(__parse_ctx, __ctx, __handle_.__ptr_);
} }
_LIBCPP_HIDE_FROM_ABI explicit handle(typename __basic_format_arg_value<_Context>::__handle& __handle) noexcept _LIBCPP_HIDE_FROM_ABI explicit handle(typename __basic_format_arg_value<_Context>::__handle& __handle) noexcept
: __handle_(__handle) {} : __handle_(__handle) {}
Show All 32 Lines

libcxx/include/__format/format_arg_store.h

Show First 20 Lines • Show All 227 Lines • ▼ Show 20 Lines
template <class _Context, size_t N> template <class _Context, size_t N>
struct __unpacked_format_arg_store { struct __unpacked_format_arg_store {
basic_format_arg<_Context> __args_[N]; basic_format_arg<_Context> __args_[N];
}; };
} // namespace __format } // namespace __format
template <class _Context, class... _Args> template <class _Context, class... _Args>
struct _LIBCPP_TEMPLATE_VIS __format_arg_store { struct __format_arg_store {
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
__format_arg_store(_Args&... __args) noexcept { __format_arg_store(_Args&... __args) noexcept {
if constexpr (sizeof...(_Args) != 0) { if constexpr (sizeof...(_Args) != 0) {
if constexpr (__format::__use_packed_format_arg_store(sizeof...(_Args))) if constexpr (__format::__use_packed_format_arg_store(sizeof...(_Args)))
__format::__create_packed_storage(__storage.__types_, __storage.__values_, __args...); __format::__create_packed_storage(__storage.__types_, __storage.__values_, __args...);
else else
__format::__store_basic_format_arg<_Context>(__storage.__args_, __args...); __format::__store_basic_format_arg<_Context>(__storage.__args_, __args...);
} }
Show All 14 Lines

libcxx/include/__format/format_args.h

Show All 21 Lines
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if _LIBCPP_STD_VER >= 20 #if _LIBCPP_STD_VER >= 20
template <class _Context> template <class _Context>
class _LIBCPP_TEMPLATE_VIS basic_format_args { class basic_format_args {
public: public:
basic_format_args() noexcept = default; basic_format_args() noexcept = default;
template <class... _Args> template <class... _Args>
_LIBCPP_HIDE_FROM_ABI basic_format_args(const __format_arg_store<_Context, _Args...>& __store) noexcept _LIBCPP_HIDE_FROM_ABI basic_format_args(const __format_arg_store<_Context, _Args...>& __store) noexcept
: __size_(sizeof...(_Args)) { : __size_(sizeof...(_Args)) {
if constexpr (sizeof...(_Args) != 0) { if constexpr (sizeof...(_Args) != 0) {
if constexpr (__format::__use_packed_format_arg_store(sizeof...(_Args))) { if constexpr (__format::__use_packed_format_arg_store(sizeof...(_Args))) {
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

libcxx/include/__format/format_context.h

Show All 35 Lines
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if _LIBCPP_STD_VER >= 20 #if _LIBCPP_STD_VER >= 20
template <class _OutIt, class _CharT> template <class _OutIt, class _CharT>
requires output_iterator<_OutIt, const _CharT&> requires output_iterator<_OutIt, const _CharT&>
class _LIBCPP_TEMPLATE_VIS basic_format_context; class basic_format_context;
#ifndef _LIBCPP_HAS_NO_LOCALIZATION #ifndef _LIBCPP_HAS_NO_LOCALIZATION
/** /**
* Helper to create a basic_format_context. * Helper to create a basic_format_context.
* *
* This is needed since the constructor is private. * This is needed since the constructor is private.
*/ */
template <class _OutIt, class _CharT> template <class _OutIt, class _CharT>
Show All 18 Linesusing format_context =
basic_format_context<back_insert_iterator<__format::__output_buffer<char>>, basic_format_context<back_insert_iterator<__format::__output_buffer<char>>,
char>; char>;
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
using wformat_context = basic_format_context< using wformat_context = basic_format_context<
back_insert_iterator<__format::__output_buffer<wchar_t>>, wchar_t>; back_insert_iterator<__format::__output_buffer<wchar_t>>, wchar_t>;
#endif #endif
template <class _OutIt, class _CharT> template <class _OutIt, class _CharT>
requires output_iterator<_OutIt, const _CharT&> requires output_iterator<_OutIt, const _CharT&>
class
// clang-format off // clang-format off
_LIBCPP_TEMPLATE_VIS class _LIBCPP_PREFERRED_NAME(format_context)
_LIBCPP_PREFERRED_NAME(format_context)
_LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wformat_context)) _LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wformat_context))
// clang-format on
basic_format_context { basic_format_context {
// clang-format on
public: public:
using iterator = _OutIt; using iterator = _OutIt;
using char_type = _CharT; using char_type = _CharT;
template <class _Tp> template <class _Tp>
using formatter_type = formatter<_Tp, _CharT>; using formatter_type = formatter<_Tp, _CharT>;
_LIBCPP_HIDE_FROM_ABI basic_format_arg<basic_format_context> _LIBCPP_HIDE_FROM_ABI basic_format_arg<basic_format_context>
arg(size_t __id) const noexcept { arg(size_t __id) const noexcept {
▲ Show 20 Lines • Show All 61 Lines • ▼ Show 20 Lines
// //
// The elements of the retargets context are only used when an underlying // The elements of the retargets context are only used when an underlying
// formatter uses a locale specific formatting or an formatting argument is // formatter uses a locale specific formatting or an formatting argument is
// part for the format spec. For example // part for the format spec. For example
// format("{:256:{}}", input, 8); // format("{:256:{}}", input, 8);
// Here the width of an element in input is determined dynamically. // Here the width of an element in input is determined dynamically.
// Note when the top-level element has no width the retargeting is not needed. // Note when the top-level element has no width the retargeting is not needed.
template <class _CharT> template <class _CharT>
class _LIBCPP_TEMPLATE_VIS class basic_format_context<typename __format::__retarget_buffer<_CharT>::__iterator, _CharT> {
basic_format_context<typename __format::__retarget_buffer<_CharT>::__iterator, _CharT> {
public: public:
using iterator = typename __format::__retarget_buffer<_CharT>::__iterator; using iterator = typename __format::__retarget_buffer<_CharT>::__iterator;
using char_type = _CharT; using char_type = _CharT;
template <class _Tp> template <class _Tp>
using formatter_type = formatter<_Tp, _CharT>; using formatter_type = formatter<_Tp, _CharT>;
template <class _Context> template <class _Context>
_LIBCPP_HIDE_FROM_ABI explicit basic_format_context(iterator __out_it, _Context& __ctx) _LIBCPP_HIDE_FROM_ABI explicit basic_format_context(iterator __out_it, _Context& __ctx)
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

libcxx/include/__format/format_functions.h

Show First 20 Lines • Show All 77 Lines • ▼ Show 20 Lines
namespace __format { namespace __format {
/// Helper class parse and handle argument. /// Helper class parse and handle argument.
/// ///
/// When parsing a handle which is not enabled the code is ill-formed. /// When parsing a handle which is not enabled the code is ill-formed.
/// This helper uses the parser of the appropriate formatter for the stored type. /// This helper uses the parser of the appropriate formatter for the stored type.
template <class _CharT> template <class _CharT>
class _LIBCPP_TEMPLATE_VIS __compile_time_handle { class __compile_time_handle {
public: public:
template <class _ParseContext> template <class _ParseContext>
_LIBCPP_HIDE_FROM_ABI constexpr void __parse(_ParseContext& __ctx) const { _LIBCPP_HIDE_FROM_ABI constexpr void __parse(_ParseContext& __ctx) const {
__parse_(__ctx); __parse_(__ctx);
} }
template <class _Tp> template <class _Tp>
_LIBCPP_HIDE_FROM_ABI constexpr void __enable() { _LIBCPP_HIDE_FROM_ABI constexpr void __enable() {
Show All 10 Lines
private: private:
void (*__parse_)(basic_format_parse_context<_CharT>&); void (*__parse_)(basic_format_parse_context<_CharT>&);
}; };
// Dummy format_context only providing the parts used during constant // Dummy format_context only providing the parts used during constant
// validation of the basic_format_string. // validation of the basic_format_string.
template <class _CharT> template <class _CharT>
struct _LIBCPP_TEMPLATE_VIS __compile_time_basic_format_context { struct __compile_time_basic_format_context {
public: public:
using char_type = _CharT; using char_type = _CharT;
_LIBCPP_HIDE_FROM_ABI constexpr explicit __compile_time_basic_format_context( _LIBCPP_HIDE_FROM_ABI constexpr explicit __compile_time_basic_format_context(
const __arg_t* __args, const __compile_time_handle<_CharT>* __handles, size_t __size) const __arg_t* __args, const __compile_time_handle<_CharT>* __handles, size_t __size)
: __args_(__args), __handles_(__handles), __size_(__size) {} : __args_(__args), __handles_(__handles), __size_(__size) {}
// During the compile-time validation nothing needs to be written. // During the compile-time validation nothing needs to be written.
▲ Show 20 Lines • Show All 210 Lines • ▼ Show 20 Lines while (__begin != __end) {
*__out_it++ = *__begin++; *__out_it++ = *__begin++;
} }
return __out_it; return __out_it;
} }
} // namespace __format } // namespace __format
template <class _CharT, class... _Args> template <class _CharT, class... _Args>
struct _LIBCPP_TEMPLATE_VIS basic_format_string { struct basic_format_string {
template <class _Tp> template <class _Tp>
requires convertible_to<const _Tp&, basic_string_view<_CharT>> requires convertible_to<const _Tp&, basic_string_view<_CharT>>
consteval basic_format_string(const _Tp& __str) : __str_{__str} { consteval basic_format_string(const _Tp& __str) : __str_{__str} {
__format::__vformat_to(basic_format_parse_context<_CharT>{__str_, sizeof...(_Args)}, __format::__vformat_to(basic_format_parse_context<_CharT>{__str_, sizeof...(_Args)},
_Context{__types_.data(), __handles_.data(), sizeof...(_Args)}); _Context{__types_.data(), __handles_.data(), sizeof...(_Args)});
} }
_LIBCPP_HIDE_FROM_ABI constexpr basic_string_view<_CharT> get() const noexcept { _LIBCPP_HIDE_FROM_ABI constexpr basic_string_view<_CharT> get() const noexcept {
▲ Show 20 Lines • Show All 329 Lines • Show Last 20 Lines

libcxx/include/__format/format_fwd.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 >= 20 #if _LIBCPP_STD_VER >= 20
template <class _Context> template <class _Context>
class _LIBCPP_TEMPLATE_VIS basic_format_arg; class basic_format_arg;
template <class _OutIt, class _CharT> template <class _OutIt, class _CharT>
requires output_iterator<_OutIt, const _CharT&> requires output_iterator<_OutIt, const _CharT&>
class _LIBCPP_TEMPLATE_VIS basic_format_context; class basic_format_context;
template <class _Tp, class _CharT = char> template <class _Tp, class _CharT = char>
struct _LIBCPP_TEMPLATE_VIS formatter; struct formatter;
#endif //_LIBCPP_STD_VER >= 20 #endif //_LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___FORMAT_FORMAT_FWD_H #endif // _LIBCPP___FORMAT_FORMAT_FWD_H

libcxx/include/__format/format_parse_context.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 >= 20 #if _LIBCPP_STD_VER >= 20
template <class _CharT> template <class _CharT>
class _LIBCPP_TEMPLATE_VIS basic_format_parse_context { class basic_format_parse_context {
public: public:
using char_type = _CharT; using char_type = _CharT;
using const_iterator = typename basic_string_view<_CharT>::const_iterator; using const_iterator = typename basic_string_view<_CharT>::const_iterator;
using iterator = const_iterator; using iterator = const_iterator;
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
constexpr explicit basic_format_parse_context(basic_string_view<_CharT> __fmt, constexpr explicit basic_format_parse_context(basic_string_view<_CharT> __fmt,
size_t __num_args = 0) noexcept size_t __num_args = 0) noexcept
▲ Show 20 Lines • Show All 78 Lines • Show Last 20 Lines

libcxx/include/__format/format_string.h

Show All 23 Lines
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if _LIBCPP_STD_VER >= 20 #if _LIBCPP_STD_VER >= 20
namespace __format { namespace __format {
template <contiguous_iterator _Iterator> template <contiguous_iterator _Iterator>
struct _LIBCPP_TEMPLATE_VIS __parse_number_result { struct __parse_number_result {
_Iterator __last; _Iterator __last;
uint32_t __value; uint32_t __value;
}; };
template <contiguous_iterator _Iterator> template <contiguous_iterator _Iterator>
__parse_number_result(_Iterator, uint32_t) -> __parse_number_result<_Iterator>; __parse_number_result(_Iterator, uint32_t) -> __parse_number_result<_Iterator>;
template <contiguous_iterator _Iterator> template <contiguous_iterator _Iterator>
▲ Show 20 Lines • Show All 127 Lines • Show Last 20 Lines

libcxx/include/__format/format_to_n_result.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 >= 20 #if _LIBCPP_STD_VER >= 20
template <class _OutIt> template <class _OutIt>
struct _LIBCPP_TEMPLATE_VIS format_to_n_result { struct format_to_n_result {
_OutIt out; _OutIt out;
iter_difference_t<_OutIt> size; iter_difference_t<_OutIt> size;
}; };
_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(format_to_n_result); _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(format_to_n_result);
#endif //_LIBCPP_STD_VER >= 20 #endif //_LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___FORMAT_FORMAT_TO_N_RESULT_H #endif // _LIBCPP___FORMAT_FORMAT_TO_N_RESULT_H

libcxx/include/__format/formatter.h

Show All 26 Lines
/// [format.formatter.spec]/5 /// [format.formatter.spec]/5
/// If F is a disabled specialization of formatter, these values are false: /// If F is a disabled specialization of formatter, these values are false:
/// - is_default_constructible_v<F>, /// - is_default_constructible_v<F>,
/// - is_copy_constructible_v<F>, /// - is_copy_constructible_v<F>,
/// - is_move_constructible_v<F>, /// - is_move_constructible_v<F>,
/// - is_copy_assignable<F>, and /// - is_copy_assignable<F>, and
/// - is_move_assignable<F>. /// - is_move_assignable<F>.
template <class _Tp, class _CharT> template <class _Tp, class _CharT>
struct _LIBCPP_TEMPLATE_VIS formatter { struct formatter {
formatter() = delete; formatter() = delete;
formatter(const formatter&) = delete; formatter(const formatter&) = delete;
formatter& operator=(const formatter&) = delete; formatter& operator=(const formatter&) = delete;
}; };
# if _LIBCPP_STD_VER >= 23 # if _LIBCPP_STD_VER >= 23
template <class _Tp> template <class _Tp>
Show All 11 Lines

libcxx/include/__format/formatter_bool.h

Show All 30 Lines
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if _LIBCPP_STD_VER >= 20 #if _LIBCPP_STD_VER >= 20
template <__fmt_char_type _CharT> template <__fmt_char_type _CharT>
struct _LIBCPP_TEMPLATE_VIS formatter<bool, _CharT> { struct formatter<bool, _CharT> {
public: public:
template <class _ParseContext> template <class _ParseContext>
_LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) { _LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) {
typename _ParseContext::iterator __result = __parser_.__parse(__ctx, __format_spec::__fields_integral); typename _ParseContext::iterator __result = __parser_.__parse(__ctx, __format_spec::__fields_integral);
__format_spec::__process_parsed_bool(__parser_); __format_spec::__process_parsed_bool(__parser_);
return __result; return __result;
} }
Show All 32 Lines

libcxx/include/__format/formatter_char.h

Show All 25 Lines
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if _LIBCPP_STD_VER >= 20 #if _LIBCPP_STD_VER >= 20
template <__fmt_char_type _CharT> template <__fmt_char_type _CharT>
struct _LIBCPP_TEMPLATE_VIS __formatter_char { struct __formatter_char {
public: public:
template <class _ParseContext> template <class _ParseContext>
_LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) { _LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) {
typename _ParseContext::iterator __result = __parser_.__parse(__ctx, __format_spec::__fields_integral); typename _ParseContext::iterator __result = __parser_.__parse(__ctx, __format_spec::__fields_integral);
__format_spec::__process_parsed_char(__parser_); __format_spec::__process_parsed_char(__parser_);
return __result; return __result;
} }
Show All 28 Lines
# if _LIBCPP_STD_VER >= 23 # if _LIBCPP_STD_VER >= 23
_LIBCPP_HIDE_FROM_ABI constexpr void set_debug_format() { __parser_.__type_ = __format_spec::__type::__debug; } _LIBCPP_HIDE_FROM_ABI constexpr void set_debug_format() { __parser_.__type_ = __format_spec::__type::__debug; }
# endif # endif
__format_spec::__parser<_CharT> __parser_; __format_spec::__parser<_CharT> __parser_;
}; };
template <> template <>
struct _LIBCPP_TEMPLATE_VIS formatter<char, char> : public __formatter_char<char> {}; struct formatter<char, char> : public __formatter_char<char> {};
# ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS # ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
template <> template <>
struct _LIBCPP_TEMPLATE_VIS formatter<char, wchar_t> : public __formatter_char<wchar_t> {}; struct formatter<char, wchar_t> : public __formatter_char<wchar_t> {};
template <> template <>
struct _LIBCPP_TEMPLATE_VIS formatter<wchar_t, wchar_t> : public __formatter_char<wchar_t> { struct formatter<wchar_t, wchar_t> : public __formatter_char<wchar_t> {
}; };
# endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS # endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
#endif //_LIBCPP_STD_VER >= 20 #endif //_LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___FORMAT_FORMATTER_CHAR_H #endif // _LIBCPP___FORMAT_FORMATTER_CHAR_H

libcxx/include/__format/formatter_floating_point.h

Show First 20 Lines • Show All 132 Lines • ▼ Show 20 Linesstruct __traits<double> {
static constexpr int __hex_precision_digits = 4; static constexpr int __hex_precision_digits = 4;
}; };
/// Helper class to store the conversion buffer. /// Helper class to store the conversion buffer.
/// ///
/// Depending on the maxium size required for a value, the buffer is allocated /// Depending on the maxium size required for a value, the buffer is allocated
/// on the stack or the heap. /// on the stack or the heap.
template <floating_point _Fp> template <floating_point _Fp>
class _LIBCPP_TEMPLATE_VIS __float_buffer { class __float_buffer {
using _Traits = __traits<_Fp>; using _Traits = __traits<_Fp>;
public: public:
// TODO FMT Improve this constructor to do a better estimate. // TODO FMT Improve this constructor to do a better estimate.
// When using a scientific formatting with a precision of 6 a stack buffer // When using a scientific formatting with a precision of 6 a stack buffer
// will always suffice. At the moment that isn't important since floats and // will always suffice. At the moment that isn't important since floats and
// doubles use a stack buffer, unless the precision used in the format string // doubles use a stack buffer, unless the precision used in the format string
// is large. // is large.
▲ Show 20 Lines • Show All 570 Lines • ▼ Show 20 Lines return __formatter::__write_using_trailing_zeros(
__first, __result.__last, _VSTD::move(__out_it), __specs, __size, __result.__exponent, __num_trailing_zeros); __first, __result.__last, _VSTD::move(__out_it), __specs, __size, __result.__exponent, __num_trailing_zeros);
return __formatter::__write(__first, __result.__last, _VSTD::move(__out_it), __specs, __size); return __formatter::__write(__first, __result.__last, _VSTD::move(__out_it), __specs, __size);
} }
} // namespace __formatter } // namespace __formatter
template <__fmt_char_type _CharT> template <__fmt_char_type _CharT>
struct _LIBCPP_TEMPLATE_VIS __formatter_floating_point { struct __formatter_floating_point {
public: public:
template <class _ParseContext> template <class _ParseContext>
_LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) { _LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) {
typename _ParseContext::iterator __result = __parser_.__parse(__ctx, __format_spec::__fields_floating_point); typename _ParseContext::iterator __result = __parser_.__parse(__ctx, __format_spec::__fields_floating_point);
__format_spec::__process_parsed_floating_point(__parser_); __format_spec::__process_parsed_floating_point(__parser_);
return __result; return __result;
} }
template <floating_point _Tp, class _FormatContext> template <floating_point _Tp, class _FormatContext>
_LIBCPP_HIDE_FROM_ABI typename _FormatContext::iterator format(_Tp __value, _FormatContext& __ctx) const { _LIBCPP_HIDE_FROM_ABI typename _FormatContext::iterator format(_Tp __value, _FormatContext& __ctx) const {
return __formatter::__format_floating_point(__value, __ctx, __parser_.__get_parsed_std_specifications(__ctx)); return __formatter::__format_floating_point(__value, __ctx, __parser_.__get_parsed_std_specifications(__ctx));
} }
__format_spec::__parser<_CharT> __parser_; __format_spec::__parser<_CharT> __parser_;
}; };
template <__fmt_char_type _CharT> template <__fmt_char_type _CharT>
struct _LIBCPP_TEMPLATE_VIS formatter<float, _CharT> struct formatter<float, _CharT> : public __formatter_floating_point<_CharT> {};
: public __formatter_floating_point<_CharT> {};
template <__fmt_char_type _CharT> template <__fmt_char_type _CharT>
struct _LIBCPP_TEMPLATE_VIS formatter<double, _CharT> struct formatter<double, _CharT> : public __formatter_floating_point<_CharT> {};
: public __formatter_floating_point<_CharT> {};
template <__fmt_char_type _CharT> template <__fmt_char_type _CharT>
struct _LIBCPP_TEMPLATE_VIS formatter<long double, _CharT> struct formatter<long double, _CharT> : public __formatter_floating_point<_CharT> {};
: public __formatter_floating_point<_CharT> {};
#endif //_LIBCPP_STD_VER >= 20 #endif //_LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
_LIBCPP_POP_MACROS _LIBCPP_POP_MACROS
#endif // _LIBCPP___FORMAT_FORMATTER_FLOATING_POINT_H #endif // _LIBCPP___FORMAT_FORMATTER_FLOATING_POINT_H

libcxx/include/__format/formatter_integer.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
#if _LIBCPP_STD_VER >= 20 #if _LIBCPP_STD_VER >= 20
template <__fmt_char_type _CharT> template <__fmt_char_type _CharT>
struct _LIBCPP_TEMPLATE_VIS __formatter_integer { struct __formatter_integer {
public: public:
template <class _ParseContext> template <class _ParseContext>
_LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) { _LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) {
typename _ParseContext::iterator __result = __parser_.__parse(__ctx, __format_spec::__fields_integral); typename _ParseContext::iterator __result = __parser_.__parse(__ctx, __format_spec::__fields_integral);
__format_spec::__process_parsed_integer(__parser_); __format_spec::__process_parsed_integer(__parser_);
return __result; return __result;
} }
Show All 12 Lines _LIBCPP_HIDE_FROM_ABI typename _FormatContext::iterator format(_Tp __value, _FormatContext& __ctx) const {
return __formatter::__format_integer(static_cast<_Type>(__value), __ctx, __specs); return __formatter::__format_integer(static_cast<_Type>(__value), __ctx, __specs);
} }
__format_spec::__parser<_CharT> __parser_; __format_spec::__parser<_CharT> __parser_;
}; };
// Signed integral types. // Signed integral types.
template <__fmt_char_type _CharT> template <__fmt_char_type _CharT>
struct _LIBCPP_TEMPLATE_VIS formatter<signed char, _CharT> struct formatter<signed char, _CharT> : public __formatter_integer<_CharT> {};
: public __formatter_integer<_CharT> {};
template <__fmt_char_type _CharT> template <__fmt_char_type _CharT>
struct _LIBCPP_TEMPLATE_VIS formatter<short, _CharT> : public __formatter_integer<_CharT> { struct formatter<short, _CharT> : public __formatter_integer<_CharT> {
}; };
template <__fmt_char_type _CharT> template <__fmt_char_type _CharT>
struct _LIBCPP_TEMPLATE_VIS formatter<int, _CharT> : public __formatter_integer<_CharT> {}; struct formatter<int, _CharT> : public __formatter_integer<_CharT> {};
template <__fmt_char_type _CharT> template <__fmt_char_type _CharT>
struct _LIBCPP_TEMPLATE_VIS formatter<long, _CharT> : public __formatter_integer<_CharT> {}; struct formatter<long, _CharT> : public __formatter_integer<_CharT> {};
template <__fmt_char_type _CharT> template <__fmt_char_type _CharT>
struct _LIBCPP_TEMPLATE_VIS formatter<long long, _CharT> struct formatter<long long, _CharT> : public __formatter_integer<_CharT> {};
: public __formatter_integer<_CharT> {};
# ifndef _LIBCPP_HAS_NO_INT128 # ifndef _LIBCPP_HAS_NO_INT128
template <__fmt_char_type _CharT> template <__fmt_char_type _CharT>
struct _LIBCPP_TEMPLATE_VIS formatter<__int128_t, _CharT> struct formatter<__int128_t, _CharT> : public __formatter_integer<_CharT> {};
: public __formatter_integer<_CharT> {};
# endif # endif
// Unsigned integral types. // Unsigned integral types.
template <__fmt_char_type _CharT> template <__fmt_char_type _CharT>
struct _LIBCPP_TEMPLATE_VIS formatter<unsigned char, _CharT> struct formatter<unsigned char, _CharT> : public __formatter_integer<_CharT> {};
: public __formatter_integer<_CharT> {};
template <__fmt_char_type _CharT> template <__fmt_char_type _CharT>
struct _LIBCPP_TEMPLATE_VIS formatter<unsigned short, _CharT> struct formatter<unsigned short, _CharT> : public __formatter_integer<_CharT> {};
: public __formatter_integer<_CharT> {};
template <__fmt_char_type _CharT> template <__fmt_char_type _CharT>
struct _LIBCPP_TEMPLATE_VIS formatter<unsigned, _CharT> struct formatter<unsigned, _CharT> : public __formatter_integer<_CharT> {};
: public __formatter_integer<_CharT> {};
template <__fmt_char_type _CharT> template <__fmt_char_type _CharT>
struct _LIBCPP_TEMPLATE_VIS formatter<unsigned long, _CharT> struct formatter<unsigned long, _CharT> : public __formatter_integer<_CharT> {};
: public __formatter_integer<_CharT> {};
template <__fmt_char_type _CharT> template <__fmt_char_type _CharT>
struct _LIBCPP_TEMPLATE_VIS formatter<unsigned long long, _CharT> struct formatter<unsigned long long, _CharT> : public __formatter_integer<_CharT> {};
: public __formatter_integer<_CharT> {};
# ifndef _LIBCPP_HAS_NO_INT128 # ifndef _LIBCPP_HAS_NO_INT128
template <__fmt_char_type _CharT> template <__fmt_char_type _CharT>
struct _LIBCPP_TEMPLATE_VIS formatter<__uint128_t, _CharT> struct formatter<__uint128_t, _CharT> : public __formatter_integer<_CharT> {};
: public __formatter_integer<_CharT> {};
# endif # endif
#endif //_LIBCPP_STD_VER >= 20 #endif //_LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___FORMAT_FORMATTER_INTEGER_H #endif // _LIBCPP___FORMAT_FORMATTER_INTEGER_H

libcxx/include/__format/formatter_integral.h

Show First 20 Lines • Show All 320 Lines • ▼ Show 20 Lines__format_integer(_Tp __value, _FormatContext& __ctx, __format_spec::__parsed_specifications<_CharT> __specs) {
return __formatter::__format_integer(__r, __ctx, __specs, __negative); return __formatter::__format_integer(__r, __ctx, __specs, __negative);
} }
// //
// Formatter arithmetic (bool) // Formatter arithmetic (bool)
// //
template <class _CharT> template <class _CharT>
struct _LIBCPP_TEMPLATE_VIS __bool_strings; struct __bool_strings;
template <> template <>
struct _LIBCPP_TEMPLATE_VIS __bool_strings<char> { struct __bool_strings<char> {
static constexpr string_view __true{"true"}; static constexpr string_view __true{"true"};
static constexpr string_view __false{"false"}; static constexpr string_view __false{"false"};
}; };
# ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS # ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
template <> template <>
struct _LIBCPP_TEMPLATE_VIS __bool_strings<wchar_t> { struct __bool_strings<wchar_t> {
static constexpr wstring_view __true{L"true"}; static constexpr wstring_view __true{L"true"};
static constexpr wstring_view __false{L"false"}; static constexpr wstring_view __false{L"false"};
}; };
# endif # endif
template <class _CharT, class _FormatContext> template <class _CharT, class _FormatContext>
_LIBCPP_HIDE_FROM_ABI typename _FormatContext::iterator _LIBCPP_HIDE_FROM_ABI typename _FormatContext::iterator
__format_bool(bool __value, _FormatContext& __ctx, __format_spec::__parsed_specifications<_CharT> __specs) { __format_bool(bool __value, _FormatContext& __ctx, __format_spec::__parsed_specifications<_CharT> __specs) {
Show All 21 Lines

libcxx/include/__format/formatter_output.h

Show First 20 Lines • Show All 485 Lines • ▼ Show 20 Lines# endif
return true; return true;
} }
template <class _CharT> template <class _CharT>
[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr char32_t __to_char32(_CharT __value) { [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr char32_t __to_char32(_CharT __value) {
return static_cast<make_unsigned_t<_CharT>>(__value); return static_cast<make_unsigned_t<_CharT>>(__value);
} }
enum class _LIBCPP_ENUM_VIS __escape_quotation_mark { __apostrophe, __double_quote }; enum class __escape_quotation_mark { __apostrophe, __double_quote };
// [format.string.escaped]/2 // [format.string.escaped]/2
template <class _CharT> template <class _CharT>
[[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool [[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool
__is_escaped_sequence_written(basic_string<_CharT>& __str, char32_t __value, __escape_quotation_mark __mark) { __is_escaped_sequence_written(basic_string<_CharT>& __str, char32_t __value, __escape_quotation_mark __mark) {
// 2.2.1.1 - Mapped character in [tab:format.escape.sequences] // 2.2.1.1 - Mapped character in [tab:format.escape.sequences]
switch (__value) { switch (__value) {
case _CharT('\t'): case _CharT('\t'):
▲ Show 20 Lines • Show All 95 Lines • Show Last 20 Lines

libcxx/include/__format/formatter_pointer.h

Show All 24 Lines
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if _LIBCPP_STD_VER >= 20 #if _LIBCPP_STD_VER >= 20
template <__fmt_char_type _CharT> template <__fmt_char_type _CharT>
struct _LIBCPP_TEMPLATE_VIS __formatter_pointer { struct __formatter_pointer {
public: public:
template <class _ParseContext> template <class _ParseContext>
_LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) { _LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) {
typename _ParseContext::iterator __result = __parser_.__parse(__ctx, __format_spec::__fields_pointer); typename _ParseContext::iterator __result = __parser_.__parse(__ctx, __format_spec::__fields_pointer);
__format_spec::__process_display_type_pointer(__parser_.__type_); __format_spec::__process_display_type_pointer(__parser_.__type_);
return __result; return __result;
} }
Show All 9 Lines
}; };
// [format.formatter.spec]/2.4 // [format.formatter.spec]/2.4
// For each charT, the pointer type specializations template<> // For each charT, the pointer type specializations template<>
// - struct formatter<nullptr_t, charT>; // - struct formatter<nullptr_t, charT>;
// - template<> struct formatter<void*, charT>; // - template<> struct formatter<void*, charT>;
// - template<> struct formatter<const void*, charT>; // - template<> struct formatter<const void*, charT>;
template <__fmt_char_type _CharT> template <__fmt_char_type _CharT>
struct _LIBCPP_TEMPLATE_VIS formatter<nullptr_t, _CharT> struct formatter<nullptr_t, _CharT> : public __formatter_pointer<_CharT> {};
: public __formatter_pointer<_CharT> {};
template <__fmt_char_type _CharT> template <__fmt_char_type _CharT>
struct _LIBCPP_TEMPLATE_VIS formatter<void*, _CharT> : public __formatter_pointer<_CharT> { struct formatter<void*, _CharT> : public __formatter_pointer<_CharT> {};
};
template <__fmt_char_type _CharT> template <__fmt_char_type _CharT>
struct _LIBCPP_TEMPLATE_VIS formatter<const void*, _CharT> struct formatter<const void*, _CharT> : public __formatter_pointer<_CharT> {};
: public __formatter_pointer<_CharT> {};
#endif //_LIBCPP_STD_VER >= 20 #endif //_LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___FORMAT_FORMATTER_POINTER_H #endif // _LIBCPP___FORMAT_FORMATTER_POINTER_H

libcxx/include/__format/formatter_string.h

Show All 24 Lines
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if _LIBCPP_STD_VER >= 20 #if _LIBCPP_STD_VER >= 20
template <__fmt_char_type _CharT> template <__fmt_char_type _CharT>
struct _LIBCPP_TEMPLATE_VIS __formatter_string { struct __formatter_string {
public: public:
template <class _ParseContext> template <class _ParseContext>
_LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) { _LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) {
typename _ParseContext::iterator __result = __parser_.__parse(__ctx, __format_spec::__fields_string); typename _ParseContext::iterator __result = __parser_.__parse(__ctx, __format_spec::__fields_string);
__format_spec::__process_display_type_string(__parser_.__type_); __format_spec::__process_display_type_string(__parser_.__type_);
return __result; return __result;
} }
Show All 12 Lines# if _LIBCPP_STD_VER >= 23
_LIBCPP_HIDE_FROM_ABI constexpr void set_debug_format() { __parser_.__type_ = __format_spec::__type::__debug; } _LIBCPP_HIDE_FROM_ABI constexpr void set_debug_format() { __parser_.__type_ = __format_spec::__type::__debug; }
# endif # endif
__format_spec::__parser<_CharT> __parser_{.__alignment_ = __format_spec::__alignment::__left}; __format_spec::__parser<_CharT> __parser_{.__alignment_ = __format_spec::__alignment::__left};
}; };
// Formatter const char*. // Formatter const char*.
template <__fmt_char_type _CharT> template <__fmt_char_type _CharT>
struct _LIBCPP_TEMPLATE_VIS formatter<const _CharT*, _CharT> struct formatter<const _CharT*, _CharT>
: public __formatter_string<_CharT> { : public __formatter_string<_CharT> {
using _Base = __formatter_string<_CharT>; using _Base = __formatter_string<_CharT>;
template <class _FormatContext> template <class _FormatContext>
_LIBCPP_HIDE_FROM_ABI typename _FormatContext::iterator format(const _CharT* __str, _FormatContext& __ctx) const { _LIBCPP_HIDE_FROM_ABI typename _FormatContext::iterator format(const _CharT* __str, _FormatContext& __ctx) const {
_LIBCPP_ASSERT(__str, "The basic_format_arg constructor should have " _LIBCPP_ASSERT(__str, "The basic_format_arg constructor should have "
"prevented an invalid pointer."); "prevented an invalid pointer.");
Show All 22 Lines# endif
while (*__str) while (*__str)
*__out_it++ = *__str++; *__out_it++ = *__str++;
return __out_it; return __out_it;
} }
}; };
// Formatter char*. // Formatter char*.
template <__fmt_char_type _CharT> template <__fmt_char_type _CharT>
struct _LIBCPP_TEMPLATE_VIS formatter<_CharT*, _CharT> struct formatter<_CharT*, _CharT> : public formatter<const _CharT*, _CharT> {
: public formatter<const _CharT*, _CharT> {
using _Base = formatter<const _CharT*, _CharT>; using _Base = formatter<const _CharT*, _CharT>;
template <class _FormatContext> template <class _FormatContext>
_LIBCPP_HIDE_FROM_ABI typename _FormatContext::iterator format(_CharT* __str, _FormatContext& __ctx) const { _LIBCPP_HIDE_FROM_ABI typename _FormatContext::iterator format(_CharT* __str, _FormatContext& __ctx) const {
return _Base::format(__str, __ctx); return _Base::format(__str, __ctx);
} }
}; };
// Formatter char[]. // Formatter char[].
template <__fmt_char_type _CharT, size_t _Size> template <__fmt_char_type _CharT, size_t _Size>
struct _LIBCPP_TEMPLATE_VIS formatter<_CharT[_Size], _CharT> struct formatter<_CharT[_Size], _CharT> : public __formatter_string<_CharT> {
: public __formatter_string<_CharT> {
using _Base = __formatter_string<_CharT>; using _Base = __formatter_string<_CharT>;
template <class _FormatContext> template <class _FormatContext>
_LIBCPP_HIDE_FROM_ABI typename _FormatContext::iterator format(_CharT __str[_Size], _FormatContext& __ctx) const { _LIBCPP_HIDE_FROM_ABI typename _FormatContext::iterator format(_CharT __str[_Size], _FormatContext& __ctx) const {
return _Base::format(basic_string_view<_CharT>(__str, _Size), __ctx); return _Base::format(basic_string_view<_CharT>(__str, _Size), __ctx);
} }
}; };
// Formatter std::string. // Formatter std::string.
template <__fmt_char_type _CharT, class _Traits, class _Allocator> template <__fmt_char_type _CharT, class _Traits, class _Allocator>
struct _LIBCPP_TEMPLATE_VIS formatter<basic_string<_CharT, _Traits, _Allocator>, _CharT> struct formatter<basic_string<_CharT, _Traits, _Allocator>, _CharT> : public __formatter_string<_CharT> {
: public __formatter_string<_CharT> {
using _Base = __formatter_string<_CharT>; using _Base = __formatter_string<_CharT>;
template <class _FormatContext> template <class _FormatContext>
_LIBCPP_HIDE_FROM_ABI typename _FormatContext::iterator _LIBCPP_HIDE_FROM_ABI typename _FormatContext::iterator
format(const basic_string<_CharT, _Traits, _Allocator>& __str, _FormatContext& __ctx) const { format(const basic_string<_CharT, _Traits, _Allocator>& __str, _FormatContext& __ctx) const {
// Drop _Traits and _Allocator to have one std::basic_string formatter. // Drop _Traits and _Allocator to have one std::basic_string formatter.
return _Base::format(basic_string_view<_CharT>(__str.data(), __str.size()), __ctx); return _Base::format(basic_string_view<_CharT>(__str.data(), __str.size()), __ctx);
} }
}; };
// Formatter std::string_view. // Formatter std::string_view.
template <__fmt_char_type _CharT, class _Traits> template <__fmt_char_type _CharT, class _Traits>
struct _LIBCPP_TEMPLATE_VIS formatter<basic_string_view<_CharT, _Traits>, _CharT> struct formatter<basic_string_view<_CharT, _Traits>, _CharT> : public __formatter_string<_CharT> {
: public __formatter_string<_CharT> {
using _Base = __formatter_string<_CharT>; using _Base = __formatter_string<_CharT>;
template <class _FormatContext> template <class _FormatContext>
_LIBCPP_HIDE_FROM_ABI typename _FormatContext::iterator _LIBCPP_HIDE_FROM_ABI typename _FormatContext::iterator
format(basic_string_view<_CharT, _Traits> __str, _FormatContext& __ctx) const { format(basic_string_view<_CharT, _Traits> __str, _FormatContext& __ctx) const {
// Drop _Traits to have one std::basic_string_view formatter. // Drop _Traits to have one std::basic_string_view formatter.
return _Base::format(basic_string_view<_CharT>(__str.data(), __str.size()), __ctx); return _Base::format(basic_string_view<_CharT>(__str.data(), __str.size()), __ctx);
} }
}; };
#endif //_LIBCPP_STD_VER >= 20 #endif //_LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___FORMAT_FORMATTER_STRING_H #endif // _LIBCPP___FORMAT_FORMATTER_STRING_H

libcxx/include/__format/formatter_tuple.h

Show All 33 Lines
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if _LIBCPP_STD_VER >= 23 #if _LIBCPP_STD_VER >= 23
template <__fmt_char_type _CharT, class _Tuple, formattable<_CharT>... _Args> template <__fmt_char_type _CharT, class _Tuple, formattable<_CharT>... _Args>
struct _LIBCPP_TEMPLATE_VIS __formatter_tuple { struct __formatter_tuple {
_LIBCPP_HIDE_FROM_ABI constexpr void set_separator(basic_string_view<_CharT> __separator) noexcept { _LIBCPP_HIDE_FROM_ABI constexpr void set_separator(basic_string_view<_CharT> __separator) noexcept {
__separator_ = __separator; __separator_ = __separator;
} }
_LIBCPP_HIDE_FROM_ABI constexpr void _LIBCPP_HIDE_FROM_ABI constexpr void
set_brackets(basic_string_view<_CharT> __opening_bracket, basic_string_view<_CharT> __closing_bracket) noexcept { set_brackets(basic_string_view<_CharT> __opening_bracket, basic_string_view<_CharT> __closing_bracket) noexcept {
__opening_bracket_ = __opening_bracket; __opening_bracket_ = __opening_bracket;
__closing_bracket_ = __closing_bracket; __closing_bracket_ = __closing_bracket;
} }
▲ Show 20 Lines • Show All 85 Lines • ▼ Show 20 Lines
private: private:
tuple<formatter<remove_cvref_t<_Args>, _CharT>...> __underlying_; tuple<formatter<remove_cvref_t<_Args>, _CharT>...> __underlying_;
basic_string_view<_CharT> __separator_ = _LIBCPP_STATICALLY_WIDEN(_CharT, ", "); basic_string_view<_CharT> __separator_ = _LIBCPP_STATICALLY_WIDEN(_CharT, ", ");
basic_string_view<_CharT> __opening_bracket_ = _LIBCPP_STATICALLY_WIDEN(_CharT, "("); basic_string_view<_CharT> __opening_bracket_ = _LIBCPP_STATICALLY_WIDEN(_CharT, "(");
basic_string_view<_CharT> __closing_bracket_ = _LIBCPP_STATICALLY_WIDEN(_CharT, ")"); basic_string_view<_CharT> __closing_bracket_ = _LIBCPP_STATICALLY_WIDEN(_CharT, ")");
}; };
template <__fmt_char_type _CharT, formattable<_CharT>... _Args> template <__fmt_char_type _CharT, formattable<_CharT>... _Args>
struct _LIBCPP_TEMPLATE_VIS formatter<pair<_Args...>, _CharT> struct formatter<pair<_Args...>, _CharT> : public __formatter_tuple<_CharT, pair<_Args...>, _Args...> {};
: public __formatter_tuple<_CharT, pair<_Args...>, _Args...> {};
template <__fmt_char_type _CharT, formattable<_CharT>... _Args> template <__fmt_char_type _CharT, formattable<_CharT>... _Args>
struct _LIBCPP_TEMPLATE_VIS formatter<tuple<_Args...>, _CharT> struct formatter<tuple<_Args...>, _CharT> : public __formatter_tuple<_CharT, tuple<_Args...>, _Args...> {};
: public __formatter_tuple<_CharT, tuple<_Args...>, _Args...> {};
#endif //_LIBCPP_STD_VER >= 23 #endif //_LIBCPP_STD_VER >= 23
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___FORMAT_FORMATTER_TUPLE_H #endif // _LIBCPP___FORMAT_FORMATTER_TUPLE_H

libcxx/include/__format/parser_std_format_spec.h

Show First 20 Lines • Show All 154 Lines • ▼ Show 20 Lines
inline constexpr __fields __fields_pointer{.__type_ = true}; inline constexpr __fields __fields_pointer{.__type_ = true};
# if _LIBCPP_STD_VER >= 23 # if _LIBCPP_STD_VER >= 23
inline constexpr __fields __fields_tuple{.__use_range_fill_ = true}; inline constexpr __fields __fields_tuple{.__use_range_fill_ = true};
inline constexpr __fields __fields_range{.__use_range_fill_ = true}; inline constexpr __fields __fields_range{.__use_range_fill_ = true};
inline constexpr __fields __fields_fill_align_width{}; inline constexpr __fields __fields_fill_align_width{};
# endif # endif
enum class _LIBCPP_ENUM_VIS __alignment : uint8_t { enum class __alignment : uint8_t {
/// No alignment is set in the format string. /// No alignment is set in the format string.
__default, __default,
__left, __left,
__center, __center,
__right, __right,
__zero_padding __zero_padding
}; };
enum class _LIBCPP_ENUM_VIS __sign : uint8_t { enum class __sign : uint8_t {
/// No sign is set in the format string. /// No sign is set in the format string.
/// ///
/// The sign isn't allowed for certain format-types. By using this value /// The sign isn't allowed for certain format-types. By using this value
/// it's possible to detect whether or not the user explicitly set the sign /// it's possible to detect whether or not the user explicitly set the sign
/// flag. For formatting purposes it behaves the same as \ref __minus. /// flag. For formatting purposes it behaves the same as \ref __minus.
__default, __default,
__minus, __minus,
__plus, __plus,
__space __space
}; };
enum class _LIBCPP_ENUM_VIS __type : uint8_t { enum class __type : uint8_t {
__default, __default,
__string, __string,
__binary_lower_case, __binary_lower_case,
__binary_upper_case, __binary_upper_case,
__octal, __octal,
__decimal, __decimal,
__hexadecimal_lower_case, __hexadecimal_lower_case,
__hexadecimal_upper_case, __hexadecimal_upper_case,
▲ Show 20 Lines • Show All 103 Lines • ▼ Show 20 Lines
/// ///
/// Note this class is a member of std::formatter specializations. It's /// Note this class is a member of std::formatter specializations. It's
/// expected developers will create their own formatter specializations that /// expected developers will create their own formatter specializations that
/// inherit from the std::formatter specializations. This means this class /// inherit from the std::formatter specializations. This means this class
/// must be ABI stable. To aid the stability the unused bits in the class are /// must be ABI stable. To aid the stability the unused bits in the class are
/// set to zero. That way they can be repurposed if a future revision of the /// set to zero. That way they can be repurposed if a future revision of the
/// Standards adds new fields to std-format-spec. /// Standards adds new fields to std-format-spec.
template <class _CharT> template <class _CharT>
class _LIBCPP_TEMPLATE_VIS __parser { class __parser {
public: public:
template <class _ParseContext> template <class _ParseContext>
_LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator __parse(_ParseContext& __ctx, __fields __fields) { _LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator __parse(_ParseContext& __ctx, __fields __fields) {
auto __begin = __ctx.begin(); auto __begin = __ctx.begin();
auto __end = __ctx.end(); auto __end = __ctx.end();
if (__begin == __end) if (__begin == __end)
return __begin; return __begin;
▲ Show 20 Lines • Show All 707 Lines • Show Last 20 Lines

libcxx/include/__format/range_default_formatter.h

Show First 20 Lines • Show All 46 Lines • ▼ Show 20 Lines
_LIBCPP_GCC_DIAGNOSTIC_IGNORED("-Wshadow") _LIBCPP_GCC_DIAGNOSTIC_IGNORED("-Wshadow")
// This shadows map, set, and string. // This shadows map, set, and string.
enum class range_format { disabled, map, set, sequence, string, debug_string }; enum class range_format { disabled, map, set, sequence, string, debug_string };
_LIBCPP_DIAGNOSTIC_POP _LIBCPP_DIAGNOSTIC_POP
// There is no definition of this struct, it's purely intended to be used to // There is no definition of this struct, it's purely intended to be used to
// generate diagnostics. // generate diagnostics.
template <class _Rp> template <class _Rp>
struct _LIBCPP_TEMPLATE_VIS __instantiated_the_primary_template_of_format_kind; struct __instantiated_the_primary_template_of_format_kind;
template <class _Rp> template <class _Rp>
constexpr range_format format_kind = [] { constexpr range_format format_kind = [] {
// [format.range.fmtkind]/1 // [format.range.fmtkind]/1
// A program that instantiates the primary template of format_kind is ill-formed. // A program that instantiates the primary template of format_kind is ill-formed.
static_assert(sizeof(_Rp) != sizeof(_Rp), "create a template specialization of format_kind for your type"); static_assert(sizeof(_Rp) != sizeof(_Rp), "create a template specialization of format_kind for your type");
return range_format::disabled; return range_format::disabled;
}(); }();
Show All 19 Lines else
// 2.2.2 Otherwise format_kind<R> is range_format::set. // 2.2.2 Otherwise format_kind<R> is range_format::set.
return range_format::set; return range_format::set;
} else } else
// 2.3 Otherwise, format_kind<R> is range_format::sequence. // 2.3 Otherwise, format_kind<R> is range_format::sequence.
return range_format::sequence; return range_format::sequence;
}(); }();
template <range_format _Kp, ranges::input_range _Rp, class _CharT> template <range_format _Kp, ranges::input_range _Rp, class _CharT>
struct _LIBCPP_TEMPLATE_VIS __range_default_formatter; struct __range_default_formatter;
// Required specializations // Required specializations
template <ranges::input_range _Rp, class _CharT> template <ranges::input_range _Rp, class _CharT>
struct _LIBCPP_TEMPLATE_VIS __range_default_formatter<range_format::sequence, _Rp, _CharT> { struct __range_default_formatter<range_format::sequence, _Rp, _CharT> {
private: private:
using __maybe_const_r = __fmt_maybe_const<_Rp, _CharT>; using __maybe_const_r = __fmt_maybe_const<_Rp, _CharT>;
range_formatter<remove_cvref_t<ranges::range_reference_t<__maybe_const_r>>, _CharT> __underlying_; range_formatter<remove_cvref_t<ranges::range_reference_t<__maybe_const_r>>, _CharT> __underlying_;
public: public:
_LIBCPP_HIDE_FROM_ABI constexpr void set_separator(basic_string_view<_CharT> __separator) noexcept { _LIBCPP_HIDE_FROM_ABI constexpr void set_separator(basic_string_view<_CharT> __separator) noexcept {
__underlying_.set_separator(__separator); __underlying_.set_separator(__separator);
} }
Show All 9 Linespublic:
template <class FormatContext> template <class FormatContext>
_LIBCPP_HIDE_FROM_ABI typename FormatContext::iterator format(__maybe_const_r& __range, FormatContext& __ctx) const { _LIBCPP_HIDE_FROM_ABI typename FormatContext::iterator format(__maybe_const_r& __range, FormatContext& __ctx) const {
return __underlying_.format(__range, __ctx); return __underlying_.format(__range, __ctx);
} }
}; };
template <ranges::input_range _Rp, class _CharT> template <ranges::input_range _Rp, class _CharT>
struct _LIBCPP_TEMPLATE_VIS __range_default_formatter<range_format::map, _Rp, _CharT> { struct __range_default_formatter<range_format::map, _Rp, _CharT> {
private: private:
using __maybe_const_map = __fmt_maybe_const<_Rp, _CharT>; using __maybe_const_map = __fmt_maybe_const<_Rp, _CharT>;
using __element_type = remove_cvref_t<ranges::range_reference_t<__maybe_const_map>>; using __element_type = remove_cvref_t<ranges::range_reference_t<__maybe_const_map>>;
range_formatter<__element_type, _CharT> __underlying_; range_formatter<__element_type, _CharT> __underlying_;
public: public:
_LIBCPP_HIDE_FROM_ABI constexpr __range_default_formatter() _LIBCPP_HIDE_FROM_ABI constexpr __range_default_formatter()
requires(__fmt_pair_like<__element_type>) requires(__fmt_pair_like<__element_type>)
Show All 11 Linespublic:
template <class _FormatContext> template <class _FormatContext>
_LIBCPP_HIDE_FROM_ABI typename _FormatContext::iterator _LIBCPP_HIDE_FROM_ABI typename _FormatContext::iterator
format(__maybe_const_map& __range, _FormatContext& __ctx) const { format(__maybe_const_map& __range, _FormatContext& __ctx) const {
return __underlying_.format(__range, __ctx); return __underlying_.format(__range, __ctx);
} }
}; };
template <ranges::input_range _Rp, class _CharT> template <ranges::input_range _Rp, class _CharT>
struct _LIBCPP_TEMPLATE_VIS __range_default_formatter<range_format::set, _Rp, _CharT> { struct __range_default_formatter<range_format::set, _Rp, _CharT> {
private: private:
using __maybe_const_set = __fmt_maybe_const<_Rp, _CharT>; using __maybe_const_set = __fmt_maybe_const<_Rp, _CharT>;
using __element_type = remove_cvref_t<ranges::range_reference_t<__maybe_const_set>>; using __element_type = remove_cvref_t<ranges::range_reference_t<__maybe_const_set>>;
range_formatter<__element_type, _CharT> __underlying_; range_formatter<__element_type, _CharT> __underlying_;
public: public:
_LIBCPP_HIDE_FROM_ABI constexpr __range_default_formatter() { _LIBCPP_HIDE_FROM_ABI constexpr __range_default_formatter() {
__underlying_.set_brackets(_LIBCPP_STATICALLY_WIDEN(_CharT, "{"), _LIBCPP_STATICALLY_WIDEN(_CharT, "}")); __underlying_.set_brackets(_LIBCPP_STATICALLY_WIDEN(_CharT, "{"), _LIBCPP_STATICALLY_WIDEN(_CharT, "}"));
} }
template <class _ParseContext> template <class _ParseContext>
_LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) { _LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) {
return __underlying_.parse(__ctx); return __underlying_.parse(__ctx);
} }
template <class _FormatContext> template <class _FormatContext>
_LIBCPP_HIDE_FROM_ABI typename _FormatContext::iterator _LIBCPP_HIDE_FROM_ABI typename _FormatContext::iterator
format(__maybe_const_set& __range, _FormatContext& __ctx) const { format(__maybe_const_set& __range, _FormatContext& __ctx) const {
return __underlying_.format(__range, __ctx); return __underlying_.format(__range, __ctx);
} }
}; };
template <range_format _Kp, ranges::input_range _Rp, class _CharT> template <range_format _Kp, ranges::input_range _Rp, class _CharT>
requires(_Kp == range_format::string || _Kp == range_format::debug_string) requires(_Kp == range_format::string || _Kp == range_format::debug_string)
struct _LIBCPP_TEMPLATE_VIS __range_default_formatter<_Kp, _Rp, _CharT> { struct __range_default_formatter<_Kp, _Rp, _CharT> {
private: private:
// This deviates from the Standard, there the exposition only type is // This deviates from the Standard, there the exposition only type is
// formatter<basic_string<charT>, charT> underlying_; // formatter<basic_string<charT>, charT> underlying_;
// Using a string_view allows the format function to avoid a copy of the // Using a string_view allows the format function to avoid a copy of the
// input range when it is a contigious range. // input range when it is a contigious range.
formatter<basic_string_view<_CharT>, _CharT> __underlying_; formatter<basic_string_view<_CharT>, _CharT> __underlying_;
public: public:
Show All 22 Lines else {
std::ranges::copy(__range, back_insert_iterator{__str}); std::ranges::copy(__range, back_insert_iterator{__str});
return __underlying_.format(static_cast<basic_string_view<_CharT>>(__str), __ctx); return __underlying_.format(static_cast<basic_string_view<_CharT>>(__str), __ctx);
} }
} }
}; };
template <ranges::input_range _Rp, class _CharT> template <ranges::input_range _Rp, class _CharT>
requires(format_kind<_Rp> != range_format::disabled && formattable<ranges::range_reference_t<_Rp>, _CharT>) requires(format_kind<_Rp> != range_format::disabled && formattable<ranges::range_reference_t<_Rp>, _CharT>)
struct _LIBCPP_TEMPLATE_VIS formatter<_Rp, _CharT> : __range_default_formatter<format_kind<_Rp>, _Rp, _CharT> {}; struct formatter<_Rp, _CharT> : __range_default_formatter<format_kind<_Rp>, _Rp, _CharT> {};
#endif //_LIBCPP_STD_VER >= 23 #endif //_LIBCPP_STD_VER >= 23
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___FORMAT_RANGE_DEFAULT_FORMATTER_H #endif // _LIBCPP___FORMAT_RANGE_DEFAULT_FORMATTER_H

libcxx/include/__format/range_formatter.h

Show All 34 Lines
#include <string_view> #include <string_view>
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if _LIBCPP_STD_VER >= 23 #if _LIBCPP_STD_VER >= 23
template <class _Tp, class _CharT = char> template <class _Tp, class _CharT = char>
requires same_as<remove_cvref_t<_Tp>, _Tp> && formattable<_Tp, _CharT> requires same_as<remove_cvref_t<_Tp>, _Tp> && formattable<_Tp, _CharT>
struct _LIBCPP_TEMPLATE_VIS range_formatter { struct range_formatter {
_LIBCPP_HIDE_FROM_ABI constexpr void set_separator(basic_string_view<_CharT> __separator) noexcept { _LIBCPP_HIDE_FROM_ABI constexpr void set_separator(basic_string_view<_CharT> __separator) noexcept {
__separator_ = __separator; __separator_ = __separator;
} }
_LIBCPP_HIDE_FROM_ABI constexpr void _LIBCPP_HIDE_FROM_ABI constexpr void
set_brackets(basic_string_view<_CharT> __opening_bracket, basic_string_view<_CharT> __closing_bracket) noexcept { set_brackets(basic_string_view<_CharT> __opening_bracket, basic_string_view<_CharT> __closing_bracket) noexcept {
__opening_bracket_ = __opening_bracket; __opening_bracket_ = __opening_bracket;
__closing_bracket_ = __closing_bracket; __closing_bracket_ = __closing_bracket;
} }
▲ Show 20 Lines • Show All 230 Lines • Show Last 20 Lines

libcxx/include/__functional/binary_function.h

Show All 15 Lines
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_UNARY_BINARY_FUNCTION) #if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_UNARY_BINARY_FUNCTION)
template <class _Arg1, class _Arg2, class _Result> template <class _Arg1, class _Arg2, class _Result>
struct _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 binary_function struct _LIBCPP_DEPRECATED_IN_CXX11 binary_function
{ {
typedef _Arg1 first_argument_type; typedef _Arg1 first_argument_type;
typedef _Arg2 second_argument_type; typedef _Arg2 second_argument_type;
typedef _Result result_type; typedef _Result result_type;
}; };
#endif // _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_UNARY_BINARY_FUNCTION) #endif // _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_UNARY_BINARY_FUNCTION)
Show All 22 Lines

libcxx/include/__functional/binary_negate.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 <= 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 binary_negate class _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_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY explicit _LIBCPP_CONSTEXPR_SINCE_CXX14
binary_negate(const _Predicate& __pred) : __pred_(__pred) {} binary_negate(const _Predicate& __pred) : __pred_(__pred) {}
Show All 17 Lines

libcxx/include/__functional/binder1st.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 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_BINDERS) #if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_BINDERS)
template <class __Operation> template <class __Operation>
class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 binder1st class _LIBCPP_DEPRECATED_IN_CXX11 binder1st
: public __unary_function<typename __Operation::second_argument_type, typename __Operation::result_type> : public __unary_function<typename __Operation::second_argument_type, typename __Operation::result_type>
{ {
protected: protected:
__Operation op; __Operation op;
typename __Operation::first_argument_type value; typename __Operation::first_argument_type value;
public: public:
_LIBCPP_INLINE_VISIBILITY binder1st(const __Operation& __x, _LIBCPP_INLINE_VISIBILITY binder1st(const __Operation& __x,
const typename __Operation::first_argument_type __y) const typename __Operation::first_argument_type __y)
Show All 20 Lines

libcxx/include/__functional/binder2nd.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 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_BINDERS) #if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_BINDERS)
template <class __Operation> template <class __Operation>
class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 binder2nd class _LIBCPP_DEPRECATED_IN_CXX11 binder2nd
: public __unary_function<typename __Operation::first_argument_type, typename __Operation::result_type> : public __unary_function<typename __Operation::first_argument_type, typename __Operation::result_type>
{ {
protected: protected:
__Operation op; __Operation op;
typename __Operation::second_argument_type value; typename __Operation::second_argument_type value;
public: public:
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
binder2nd(const __Operation& __x, const typename __Operation::second_argument_type __y) binder2nd(const __Operation& __x, const typename __Operation::second_argument_type __y)
Show All 20 Lines

libcxx/include/__functional/boyer_moore_searcher.h

Show First 20 Lines • Show All 94 Lines • ▼ Show 20 Linespublic:
_LIBCPP_HIDE_FROM_ABI value_type operator[](key_type __key) const { _LIBCPP_HIDE_FROM_ABI value_type operator[](key_type __key) const {
return __table_[static_cast<unsigned_key_type>(__key)]; return __table_[static_cast<unsigned_key_type>(__key)];
} }
}; };
template <class _RandomAccessIterator1, template <class _RandomAccessIterator1,
class _Hash = hash<typename iterator_traits<_RandomAccessIterator1>::value_type>, class _Hash = hash<typename iterator_traits<_RandomAccessIterator1>::value_type>,
class _BinaryPredicate = equal_to<>> class _BinaryPredicate = equal_to<>>
class _LIBCPP_TEMPLATE_VIS boyer_moore_searcher { class boyer_moore_searcher {
private: private:
using difference_type = typename std::iterator_traits<_RandomAccessIterator1>::difference_type; using difference_type = typename std::iterator_traits<_RandomAccessIterator1>::difference_type;
using value_type = typename std::iterator_traits<_RandomAccessIterator1>::value_type; using value_type = typename std::iterator_traits<_RandomAccessIterator1>::value_type;
using __skip_table_type = _BMSkipTable<value_type, using __skip_table_type = _BMSkipTable<value_type,
difference_type, difference_type,
_Hash, _Hash,
_BinaryPredicate, _BinaryPredicate,
is_integral_v<value_type> is_integral_v<value_type>
▲ Show 20 Lines • Show All 115 Lines • ▼ Show 20 Lines __build_suffix_table(_RandomAccessIterator1 __first, _RandomAccessIterator1 __last, _BinaryPredicate __pred) {
} }
} }
}; };
_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(boyer_moore_searcher); _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(boyer_moore_searcher);
template <class _RandomAccessIterator1, template <class _RandomAccessIterator1,
class _Hash = hash<typename iterator_traits<_RandomAccessIterator1>::value_type>, class _Hash = hash<typename iterator_traits<_RandomAccessIterator1>::value_type>,
class _BinaryPredicate = equal_to<>> class _BinaryPredicate = equal_to<>>
class _LIBCPP_TEMPLATE_VIS boyer_moore_horspool_searcher { class boyer_moore_horspool_searcher {
private: private:
using difference_type = typename iterator_traits<_RandomAccessIterator1>::difference_type; using difference_type = typename iterator_traits<_RandomAccessIterator1>::difference_type;
using value_type = typename iterator_traits<_RandomAccessIterator1>::value_type; using value_type = typename iterator_traits<_RandomAccessIterator1>::value_type;
using __skip_table_type = _BMSkipTable<value_type, using __skip_table_type = _BMSkipTable<value_type,
difference_type, difference_type,
_Hash, _Hash,
_BinaryPredicate, _BinaryPredicate,
is_integral_v<value_type> is_integral_v<value_type>
▲ Show 20 Lines • Show All 77 Lines • Show Last 20 Lines

libcxx/include/__functional/default_searcher.h

Show All 21 Lines
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
// 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 default_searcher {
public: public:
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_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_SINCE_CXX20 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
Show All 19 Lines

libcxx/include/__functional/function.h

Show First 20 Lines • Show All 76 Lines • ▼ Show 20 Lines
{ {
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
throw bad_function_call(); throw bad_function_call();
#else #else
_LIBCPP_VERBOSE_ABORT("bad_function_call was thrown in -fno-exceptions mode"); _LIBCPP_VERBOSE_ABORT("bad_function_call was thrown in -fno-exceptions mode");
#endif #endif
} }
template<class _Fp> class _LIBCPP_TEMPLATE_VIS function; // undefined template<class _Fp> class function; // undefined
namespace __function namespace __function
{ {
template<class _Rp> template<class _Rp>
struct __maybe_derive_from_unary_function struct __maybe_derive_from_unary_function
{ {
}; };
▲ Show 20 Lines • Show All 161 Lines • ▼ Show 20 Linespublic:
_LIBCPP_HIDE_FROM_ABI static void __destroy_and_delete(__default_alloc_func* __f) { _LIBCPP_HIDE_FROM_ABI static void __destroy_and_delete(__default_alloc_func* __f) {
__f->destroy(); __f->destroy();
__builtin_new_allocator::__deallocate_type<__default_alloc_func>(__f, 1); __builtin_new_allocator::__deallocate_type<__default_alloc_func>(__f, 1);
} }
}; };
// __base provides an abstract interface for copyable functors. // __base provides an abstract interface for copyable functors.
template<class _Fp> class _LIBCPP_TEMPLATE_VIS __base; template<class _Fp> class __base;
template<class _Rp, class ..._ArgTypes> template<class _Rp, class ..._ArgTypes>
class __base<_Rp(_ArgTypes...)> class __base<_Rp(_ArgTypes...)>
{ {
__base(const __base&); __base(const __base&);
__base& operator=(const __base&); __base& operator=(const __base&);
public: public:
_LIBCPP_INLINE_VISIBILITY __base() {} _LIBCPP_INLINE_VISIBILITY __base() {}
▲ Show 20 Lines • Show All 694 Lines • ▼ Show 20 Lines
#endif // _LIBCPP_HAS_NO_RTTI #endif // _LIBCPP_HAS_NO_RTTI
}; };
#endif // _LIBCPP_HAS_EXTENSION_BLOCKS #endif // _LIBCPP_HAS_EXTENSION_BLOCKS
} // namespace __function } // namespace __function
template<class _Rp, class ..._ArgTypes> template<class _Rp, class ..._ArgTypes>
class _LIBCPP_TEMPLATE_VIS function<_Rp(_ArgTypes...)> class function<_Rp(_ArgTypes...)>
: public __function::__maybe_derive_from_unary_function<_Rp(_ArgTypes...)>, : public __function::__maybe_derive_from_unary_function<_Rp(_ArgTypes...)>,
public __function::__maybe_derive_from_binary_function<_Rp(_ArgTypes...)> public __function::__maybe_derive_from_binary_function<_Rp(_ArgTypes...)>
{ {
#ifndef _LIBCPP_ABI_OPTIMIZED_FUNCTION #ifndef _LIBCPP_ABI_OPTIMIZED_FUNCTION
typedef __function::__value_func<_Rp(_ArgTypes...)> __func; typedef __function::__value_func<_Rp(_ArgTypes...)> __func;
#else #else
typedef __function::__policy_func<_Rp(_ArgTypes...)> __func; typedef __function::__policy_func<_Rp(_ArgTypes...)> __func;
#endif #endif
▲ Show 20 Lines • Show All 244 Lines • Show Last 20 Lines

libcxx/include/__functional/hash.h

Show First 20 Lines • Show All 373 Lines • ▼ Show 20 Lines
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
inline size_t __hash_combine(size_t __lhs, size_t __rhs) _NOEXCEPT { inline size_t __hash_combine(size_t __lhs, size_t __rhs) _NOEXCEPT {
typedef __scalar_hash<_PairT> _HashT; typedef __scalar_hash<_PairT> _HashT;
const _PairT __p = {__lhs, __rhs}; const _PairT __p = {__lhs, __rhs};
return _HashT()(__p); return _HashT()(__p);
} }
template<class _Tp> template<class _Tp>
struct _LIBCPP_TEMPLATE_VIS hash<_Tp*> struct hash<_Tp*> : public __unary_function<_Tp*, size_t>
: public __unary_function<_Tp*, size_t>
{ {
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
size_t operator()(_Tp* __v) const _NOEXCEPT size_t operator()(_Tp* __v) const _NOEXCEPT
{ {
union union
{ {
_Tp* __t; _Tp* __t;
size_t __a; size_t __a;
} __u; } __u;
__u.__t = __v; __u.__t = __v;
return __murmur2_or_cityhash<size_t>()(&__u, sizeof(__u)); return __murmur2_or_cityhash<size_t>()(&__u, sizeof(__u));
} }
}; };
template <> template <>
struct _LIBCPP_TEMPLATE_VIS hash<bool> struct hash<bool>: public __unary_function<bool, size_t>
: public __unary_function<bool, size_t>
{ {
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
size_t operator()(bool __v) const _NOEXCEPT {return static_cast<size_t>(__v);} size_t operator()(bool __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
}; };
template <> template <>
struct _LIBCPP_TEMPLATE_VIS hash<char> struct hash<char> : public __unary_function<char, size_t>
: public __unary_function<char, size_t>
{ {
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
size_t operator()(char __v) const _NOEXCEPT {return static_cast<size_t>(__v);} size_t operator()(char __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
}; };
template <> template <>
struct _LIBCPP_TEMPLATE_VIS hash<signed char> struct hash<signed char> : public __unary_function<signed char, size_t>
: public __unary_function<signed char, size_t>
{ {
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
size_t operator()(signed char __v) const _NOEXCEPT {return static_cast<size_t>(__v);} size_t operator()(signed char __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
}; };
template <> template <>
struct _LIBCPP_TEMPLATE_VIS hash<unsigned char> struct hash<unsigned char> : public __unary_function<unsigned char, size_t>
: public __unary_function<unsigned char, size_t>
{ {
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
size_t operator()(unsigned char __v) const _NOEXCEPT {return static_cast<size_t>(__v);} size_t operator()(unsigned char __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
}; };
#ifndef _LIBCPP_HAS_NO_CHAR8_T #ifndef _LIBCPP_HAS_NO_CHAR8_T
template <> template <>
struct _LIBCPP_TEMPLATE_VIS hash<char8_t> struct hash<char8_t> : public __unary_function<char8_t, size_t>
: public __unary_function<char8_t, size_t>
{ {
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
size_t operator()(char8_t __v) const _NOEXCEPT {return static_cast<size_t>(__v);} size_t operator()(char8_t __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
}; };
#endif // !_LIBCPP_HAS_NO_CHAR8_T #endif // !_LIBCPP_HAS_NO_CHAR8_T
template <> template <>
struct _LIBCPP_TEMPLATE_VIS hash<char16_t> struct hash<char16_t> : public __unary_function<char16_t, size_t>
: public __unary_function<char16_t, size_t>
{ {
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
size_t operator()(char16_t __v) const _NOEXCEPT {return static_cast<size_t>(__v);} size_t operator()(char16_t __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
}; };
template <> template <>
struct _LIBCPP_TEMPLATE_VIS hash<char32_t> struct hash<char32_t> : public __unary_function<char32_t, size_t>
: public __unary_function<char32_t, size_t>
{ {
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
size_t operator()(char32_t __v) const _NOEXCEPT {return static_cast<size_t>(__v);} size_t operator()(char32_t __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
}; };
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
template <> template <>
struct _LIBCPP_TEMPLATE_VIS hash<wchar_t> struct hash<wchar_t> : public __unary_function<wchar_t, size_t>
: public __unary_function<wchar_t, size_t>
{ {
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
size_t operator()(wchar_t __v) const _NOEXCEPT {return static_cast<size_t>(__v);} size_t operator()(wchar_t __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
}; };
#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS #endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
template <> template <>
struct _LIBCPP_TEMPLATE_VIS hash<short> struct hash<short>: public __unary_function<short, size_t>
: public __unary_function<short, size_t>
{ {
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
size_t operator()(short __v) const _NOEXCEPT {return static_cast<size_t>(__v);} size_t operator()(short __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
}; };
template <> template <>
struct _LIBCPP_TEMPLATE_VIS hash<unsigned short> struct hash<unsigned short> : public __unary_function<unsigned short, size_t>
: public __unary_function<unsigned short, size_t>
{ {
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
size_t operator()(unsigned short __v) const _NOEXCEPT {return static_cast<size_t>(__v);} size_t operator()(unsigned short __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
}; };
template <> template <>
struct _LIBCPP_TEMPLATE_VIS hash<int> struct hash<int> : public __unary_function<int, size_t>
: public __unary_function<int, size_t>
{ {
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
size_t operator()(int __v) const _NOEXCEPT {return static_cast<size_t>(__v);} size_t operator()(int __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
}; };
template <> template <>
struct _LIBCPP_TEMPLATE_VIS hash<unsigned int> struct hash<unsigned int> : public __unary_function<unsigned int, size_t>
: public __unary_function<unsigned int, size_t>
{ {
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
size_t operator()(unsigned int __v) const _NOEXCEPT {return static_cast<size_t>(__v);} size_t operator()(unsigned int __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
}; };
template <> template <>
struct _LIBCPP_TEMPLATE_VIS hash<long> struct hash<long> : public __unary_function<long, size_t>
: public __unary_function<long, size_t>
{ {
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
size_t operator()(long __v) const _NOEXCEPT {return static_cast<size_t>(__v);} size_t operator()(long __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
}; };
template <> template <>
struct _LIBCPP_TEMPLATE_VIS hash<unsigned long> struct hash<unsigned long> : public __unary_function<unsigned long, size_t>
: public __unary_function<unsigned long, size_t>
{ {
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
size_t operator()(unsigned long __v) const _NOEXCEPT {return static_cast<size_t>(__v);} size_t operator()(unsigned long __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
}; };
template <> template <>
struct _LIBCPP_TEMPLATE_VIS hash<long long> struct hash<long long> : public __scalar_hash<long long> {};
: public __scalar_hash<long long>
{
};
template <> template <>
struct _LIBCPP_TEMPLATE_VIS hash<unsigned long long> struct hash<unsigned long long> : public __scalar_hash<unsigned long long> {};
: public __scalar_hash<unsigned long long>
{
};
#ifndef _LIBCPP_HAS_NO_INT128 #ifndef _LIBCPP_HAS_NO_INT128
template <> template <>
struct _LIBCPP_TEMPLATE_VIS hash<__int128_t> struct hash<__int128_t> : public __scalar_hash<__int128_t> {};
: public __scalar_hash<__int128_t>
{
};
template <> template <>
struct _LIBCPP_TEMPLATE_VIS hash<__uint128_t> struct hash<__uint128_t> : public __scalar_hash<__uint128_t> {};
: public __scalar_hash<__uint128_t>
{
};
#endif #endif
template <> template <>
struct _LIBCPP_TEMPLATE_VIS hash<float> struct hash<float> : public __scalar_hash<float>
: public __scalar_hash<float>
{ {
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
size_t operator()(float __v) const _NOEXCEPT size_t operator()(float __v) const _NOEXCEPT
{ {
// -0.0 and 0.0 should return same hash // -0.0 and 0.0 should return same hash
if (__v == 0.0f) if (__v == 0.0f)
return 0; return 0;
return __scalar_hash<float>::operator()(__v); return __scalar_hash<float>::operator()(__v);
} }
}; };
template <> template <>
struct _LIBCPP_TEMPLATE_VIS hash<double> struct hash<double> : public __scalar_hash<double>
: public __scalar_hash<double>
{ {
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
size_t operator()(double __v) const _NOEXCEPT size_t operator()(double __v) const _NOEXCEPT
{ {
// -0.0 and 0.0 should return same hash // -0.0 and 0.0 should return same hash
if (__v == 0.0) if (__v == 0.0)
return 0; return 0;
return __scalar_hash<double>::operator()(__v); return __scalar_hash<double>::operator()(__v);
} }
}; };
template <> template <>
struct _LIBCPP_TEMPLATE_VIS hash<long double> struct hash<long double> : public __scalar_hash<long double>
: public __scalar_hash<long double>
{ {
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
size_t operator()(long double __v) const _NOEXCEPT size_t operator()(long double __v) const _NOEXCEPT
{ {
// -0.0 and 0.0 should return same hash // -0.0 and 0.0 should return same hash
if (__v == 0.0L) if (__v == 0.0L)
return 0; return 0;
#if defined(__i386__) || (defined(__x86_64__) && defined(__ILP32__)) #if defined(__i386__) || (defined(__x86_64__) && defined(__ILP32__))
Show All 32 Lines#elif defined(__x86_64__)
return __u.__s.__a ^ __u.__s.__b; return __u.__s.__a ^ __u.__s.__b;
#else #else
return __scalar_hash<long double>::operator()(__v); return __scalar_hash<long double>::operator()(__v);
#endif #endif
} }
}; };
template <class _Tp, bool = is_enum<_Tp>::value> template <class _Tp, bool = is_enum<_Tp>::value>
struct _LIBCPP_TEMPLATE_VIS __enum_hash struct __enum_hash : public __unary_function<_Tp, size_t>
: public __unary_function<_Tp, size_t>
{ {
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
size_t operator()(_Tp __v) const _NOEXCEPT size_t operator()(_Tp __v) const _NOEXCEPT
{ {
typedef typename underlying_type<_Tp>::type type; typedef typename underlying_type<_Tp>::type type;
return hash<type>()(static_cast<type>(__v)); return hash<type>()(static_cast<type>(__v));
} }
}; };
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS __enum_hash<_Tp, false> { struct __enum_hash<_Tp, false> {
__enum_hash() = delete; __enum_hash() = delete;
__enum_hash(__enum_hash const&) = delete; __enum_hash(__enum_hash const&) = delete;
__enum_hash& operator=(__enum_hash const&) = delete; __enum_hash& operator=(__enum_hash const&) = delete;
}; };
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS hash : public __enum_hash<_Tp> struct hash : public __enum_hash<_Tp>
{ {
}; };
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <> template <>
struct _LIBCPP_TEMPLATE_VIS hash<nullptr_t> struct hash<nullptr_t> : public __unary_function<nullptr_t, size_t>
: public __unary_function<nullptr_t, size_t>
{ {
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
size_t operator()(nullptr_t) const _NOEXCEPT { size_t operator()(nullptr_t) const _NOEXCEPT {
return 662607004ull; return 662607004ull;
} }
}; };
#endif #endif
Show All 32 Lines

libcxx/include/__functional/mem_fun_ref.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 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_BINDERS) #if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_BINDERS)
template<class _Sp, class _Tp> template<class _Sp, class _Tp>
class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 mem_fun_t class _LIBCPP_DEPRECATED_IN_CXX11 mem_fun_t : public __unary_function<_Tp*, _Sp>
: public __unary_function<_Tp*, _Sp>
{ {
_Sp (_Tp::*__p_)(); _Sp (_Tp::*__p_)();
public: public:
_LIBCPP_INLINE_VISIBILITY explicit mem_fun_t(_Sp (_Tp::*__p)()) _LIBCPP_INLINE_VISIBILITY explicit mem_fun_t(_Sp (_Tp::*__p)())
: __p_(__p) {} : __p_(__p) {}
_LIBCPP_INLINE_VISIBILITY _Sp operator()(_Tp* __p) const _LIBCPP_INLINE_VISIBILITY _Sp operator()(_Tp* __p) const
{return (__p->*__p_)();} {return (__p->*__p_)();}
}; };
template<class _Sp, class _Tp, class _Ap> template<class _Sp, class _Tp, class _Ap>
class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 mem_fun1_t class _LIBCPP_DEPRECATED_IN_CXX11 mem_fun1_t : public __binary_function<_Tp*, _Ap, _Sp>
: public __binary_function<_Tp*, _Ap, _Sp>
{ {
_Sp (_Tp::*__p_)(_Ap); _Sp (_Tp::*__p_)(_Ap);
public: public:
_LIBCPP_INLINE_VISIBILITY explicit mem_fun1_t(_Sp (_Tp::*__p)(_Ap)) _LIBCPP_INLINE_VISIBILITY explicit mem_fun1_t(_Sp (_Tp::*__p)(_Ap))
: __p_(__p) {} : __p_(__p) {}
_LIBCPP_INLINE_VISIBILITY _Sp operator()(_Tp* __p, _Ap __x) const _LIBCPP_INLINE_VISIBILITY _Sp operator()(_Tp* __p, _Ap __x) const
{return (__p->*__p_)(__x);} {return (__p->*__p_)(__x);}
}; };
template<class _Sp, class _Tp> template<class _Sp, class _Tp>
_LIBCPP_DEPRECATED_IN_CXX11 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_DEPRECATED_IN_CXX11 inline _LIBCPP_INLINE_VISIBILITY
mem_fun_t<_Sp,_Tp> mem_fun_t<_Sp,_Tp>
mem_fun(_Sp (_Tp::*__f)()) mem_fun(_Sp (_Tp::*__f)())
{return mem_fun_t<_Sp,_Tp>(__f);} {return mem_fun_t<_Sp,_Tp>(__f);}
template<class _Sp, class _Tp, class _Ap> template<class _Sp, class _Tp, class _Ap>
_LIBCPP_DEPRECATED_IN_CXX11 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_DEPRECATED_IN_CXX11 inline _LIBCPP_INLINE_VISIBILITY
mem_fun1_t<_Sp,_Tp,_Ap> mem_fun1_t<_Sp,_Tp,_Ap>
mem_fun(_Sp (_Tp::*__f)(_Ap)) mem_fun(_Sp (_Tp::*__f)(_Ap))
{return mem_fun1_t<_Sp,_Tp,_Ap>(__f);} {return mem_fun1_t<_Sp,_Tp,_Ap>(__f);}
template<class _Sp, class _Tp> template<class _Sp, class _Tp>
class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 mem_fun_ref_t class _LIBCPP_DEPRECATED_IN_CXX11 mem_fun_ref_t : public __unary_function<_Tp, _Sp>
: public __unary_function<_Tp, _Sp>
{ {
_Sp (_Tp::*__p_)(); _Sp (_Tp::*__p_)();
public: public:
_LIBCPP_INLINE_VISIBILITY explicit mem_fun_ref_t(_Sp (_Tp::*__p)()) _LIBCPP_INLINE_VISIBILITY explicit mem_fun_ref_t(_Sp (_Tp::*__p)())
: __p_(__p) {} : __p_(__p) {}
_LIBCPP_INLINE_VISIBILITY _Sp operator()(_Tp& __p) const _LIBCPP_INLINE_VISIBILITY _Sp operator()(_Tp& __p) const
{return (__p.*__p_)();} {return (__p.*__p_)();}
}; };
template<class _Sp, class _Tp, class _Ap> template<class _Sp, class _Tp, class _Ap>
class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 mem_fun1_ref_t class _LIBCPP_DEPRECATED_IN_CXX11 mem_fun1_ref_t : public __binary_function<_Tp, _Ap, _Sp>
: public __binary_function<_Tp, _Ap, _Sp>
{ {
_Sp (_Tp::*__p_)(_Ap); _Sp (_Tp::*__p_)(_Ap);
public: public:
_LIBCPP_INLINE_VISIBILITY explicit mem_fun1_ref_t(_Sp (_Tp::*__p)(_Ap)) _LIBCPP_INLINE_VISIBILITY explicit mem_fun1_ref_t(_Sp (_Tp::*__p)(_Ap))
: __p_(__p) {} : __p_(__p) {}
_LIBCPP_INLINE_VISIBILITY _Sp operator()(_Tp& __p, _Ap __x) const _LIBCPP_INLINE_VISIBILITY _Sp operator()(_Tp& __p, _Ap __x) const
{return (__p.*__p_)(__x);} {return (__p.*__p_)(__x);}
}; };
template<class _Sp, class _Tp> template<class _Sp, class _Tp>
_LIBCPP_DEPRECATED_IN_CXX11 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_DEPRECATED_IN_CXX11 inline _LIBCPP_INLINE_VISIBILITY
mem_fun_ref_t<_Sp,_Tp> mem_fun_ref_t<_Sp,_Tp>
mem_fun_ref(_Sp (_Tp::*__f)()) mem_fun_ref(_Sp (_Tp::*__f)())
{return mem_fun_ref_t<_Sp,_Tp>(__f);} {return mem_fun_ref_t<_Sp,_Tp>(__f);}
template<class _Sp, class _Tp, class _Ap> template<class _Sp, class _Tp, class _Ap>
_LIBCPP_DEPRECATED_IN_CXX11 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_DEPRECATED_IN_CXX11 inline _LIBCPP_INLINE_VISIBILITY
mem_fun1_ref_t<_Sp,_Tp,_Ap> mem_fun1_ref_t<_Sp,_Tp,_Ap>
mem_fun_ref(_Sp (_Tp::*__f)(_Ap)) mem_fun_ref(_Sp (_Tp::*__f)(_Ap))
{return mem_fun1_ref_t<_Sp,_Tp,_Ap>(__f);} {return mem_fun1_ref_t<_Sp,_Tp,_Ap>(__f);}
template <class _Sp, class _Tp> template <class _Sp, class _Tp>
class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 const_mem_fun_t class _LIBCPP_DEPRECATED_IN_CXX11 const_mem_fun_t : public __unary_function<const _Tp*, _Sp>
: public __unary_function<const _Tp*, _Sp>
{ {
_Sp (_Tp::*__p_)() const; _Sp (_Tp::*__p_)() const;
public: public:
_LIBCPP_INLINE_VISIBILITY explicit const_mem_fun_t(_Sp (_Tp::*__p)() const) _LIBCPP_INLINE_VISIBILITY explicit const_mem_fun_t(_Sp (_Tp::*__p)() const)
: __p_(__p) {} : __p_(__p) {}
_LIBCPP_INLINE_VISIBILITY _Sp operator()(const _Tp* __p) const _LIBCPP_INLINE_VISIBILITY _Sp operator()(const _Tp* __p) const
{return (__p->*__p_)();} {return (__p->*__p_)();}
}; };
template <class _Sp, class _Tp, class _Ap> template <class _Sp, class _Tp, class _Ap>
class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 const_mem_fun1_t class _LIBCPP_DEPRECATED_IN_CXX11 const_mem_fun1_t : public __binary_function<const _Tp*, _Ap, _Sp>
: public __binary_function<const _Tp*, _Ap, _Sp>
{ {
_Sp (_Tp::*__p_)(_Ap) const; _Sp (_Tp::*__p_)(_Ap) const;
public: public:
_LIBCPP_INLINE_VISIBILITY explicit const_mem_fun1_t(_Sp (_Tp::*__p)(_Ap) const) _LIBCPP_INLINE_VISIBILITY explicit const_mem_fun1_t(_Sp (_Tp::*__p)(_Ap) const)
: __p_(__p) {} : __p_(__p) {}
_LIBCPP_INLINE_VISIBILITY _Sp operator()(const _Tp* __p, _Ap __x) const _LIBCPP_INLINE_VISIBILITY _Sp operator()(const _Tp* __p, _Ap __x) const
{return (__p->*__p_)(__x);} {return (__p->*__p_)(__x);}
}; };
template <class _Sp, class _Tp> template <class _Sp, class _Tp>
_LIBCPP_DEPRECATED_IN_CXX11 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_DEPRECATED_IN_CXX11 inline _LIBCPP_INLINE_VISIBILITY
const_mem_fun_t<_Sp,_Tp> const_mem_fun_t<_Sp,_Tp>
mem_fun(_Sp (_Tp::*__f)() const) mem_fun(_Sp (_Tp::*__f)() const)
{return const_mem_fun_t<_Sp,_Tp>(__f);} {return const_mem_fun_t<_Sp,_Tp>(__f);}
template <class _Sp, class _Tp, class _Ap> template <class _Sp, class _Tp, class _Ap>
_LIBCPP_DEPRECATED_IN_CXX11 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_DEPRECATED_IN_CXX11 inline _LIBCPP_INLINE_VISIBILITY
const_mem_fun1_t<_Sp,_Tp,_Ap> const_mem_fun1_t<_Sp,_Tp,_Ap>
mem_fun(_Sp (_Tp::*__f)(_Ap) const) mem_fun(_Sp (_Tp::*__f)(_Ap) const)
{return const_mem_fun1_t<_Sp,_Tp,_Ap>(__f);} {return const_mem_fun1_t<_Sp,_Tp,_Ap>(__f);}
template <class _Sp, class _Tp> template <class _Sp, class _Tp>
class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 const_mem_fun_ref_t class _LIBCPP_DEPRECATED_IN_CXX11 const_mem_fun_ref_t : public __unary_function<_Tp, _Sp>
: public __unary_function<_Tp, _Sp>
{ {
_Sp (_Tp::*__p_)() const; _Sp (_Tp::*__p_)() const;
public: public:
_LIBCPP_INLINE_VISIBILITY explicit const_mem_fun_ref_t(_Sp (_Tp::*__p)() const) _LIBCPP_INLINE_VISIBILITY explicit const_mem_fun_ref_t(_Sp (_Tp::*__p)() const)
: __p_(__p) {} : __p_(__p) {}
_LIBCPP_INLINE_VISIBILITY _Sp operator()(const _Tp& __p) const _LIBCPP_INLINE_VISIBILITY _Sp operator()(const _Tp& __p) const
{return (__p.*__p_)();} {return (__p.*__p_)();}
}; };
template <class _Sp, class _Tp, class _Ap> template <class _Sp, class _Tp, class _Ap>
class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 const_mem_fun1_ref_t class _LIBCPP_DEPRECATED_IN_CXX11 const_mem_fun1_ref_t : public __binary_function<_Tp, _Ap, _Sp>
: public __binary_function<_Tp, _Ap, _Sp>
{ {
_Sp (_Tp::*__p_)(_Ap) const; _Sp (_Tp::*__p_)(_Ap) const;
public: public:
_LIBCPP_INLINE_VISIBILITY explicit const_mem_fun1_ref_t(_Sp (_Tp::*__p)(_Ap) const) _LIBCPP_INLINE_VISIBILITY explicit const_mem_fun1_ref_t(_Sp (_Tp::*__p)(_Ap) const)
: __p_(__p) {} : __p_(__p) {}
_LIBCPP_INLINE_VISIBILITY _Sp operator()(const _Tp& __p, _Ap __x) const _LIBCPP_INLINE_VISIBILITY _Sp operator()(const _Tp& __p, _Ap __x) const
{return (__p.*__p_)(__x);} {return (__p.*__p_)(__x);}
}; };
Show All 18 Lines

libcxx/include/__functional/operations.h

Show All 25 Lines
// Arithmetic operations // Arithmetic operations
#if _LIBCPP_STD_VER >= 14 #if _LIBCPP_STD_VER >= 14
template <class _Tp = void> template <class _Tp = void>
#else #else
template <class _Tp> template <class _Tp>
#endif #endif
struct _LIBCPP_TEMPLATE_VIS plus struct 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_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_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;}
}; };
_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(plus); _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(plus);
template <class _Tp> template <class _Tp>
struct __is_trivial_plus_operation<plus<_Tp>, _Tp, _Tp> : true_type {}; struct __is_trivial_plus_operation<plus<_Tp>, _Tp, _Tp> : true_type {};
#if _LIBCPP_STD_VER >= 14 #if _LIBCPP_STD_VER >= 14
template <class _Tp, class _Up> template <class _Tp, class _Up>
struct __is_trivial_plus_operation<plus<>, _Tp, _Up> : true_type {}; struct __is_trivial_plus_operation<plus<>, _Tp, _Up> : true_type {};
#endif #endif
#if _LIBCPP_STD_VER >= 14 #if _LIBCPP_STD_VER >= 14
template <> template <>
struct _LIBCPP_TEMPLATE_VIS plus<void> struct plus<void>
{ {
template <class _T1, class _T2> template <class _T1, class _T2>
_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_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 >= 14 #if _LIBCPP_STD_VER >= 14
template <class _Tp = void> template <class _Tp = void>
#else #else
template <class _Tp> template <class _Tp>
#endif #endif
struct _LIBCPP_TEMPLATE_VIS minus struct 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_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_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;}
}; };
_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(minus); _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(minus);
#if _LIBCPP_STD_VER >= 14 #if _LIBCPP_STD_VER >= 14
template <> template <>
struct _LIBCPP_TEMPLATE_VIS minus<void> struct minus<void>
{ {
template <class _T1, class _T2> template <class _T1, class _T2>
_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_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 >= 14 #if _LIBCPP_STD_VER >= 14
template <class _Tp = void> template <class _Tp = void>
#else #else
template <class _Tp> template <class _Tp>
#endif #endif
struct _LIBCPP_TEMPLATE_VIS multiplies struct 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_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_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;}
}; };
_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(multiplies); _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(multiplies);
#if _LIBCPP_STD_VER >= 14 #if _LIBCPP_STD_VER >= 14
template <> template <>
struct _LIBCPP_TEMPLATE_VIS multiplies<void> struct multiplies<void>
{ {
template <class _T1, class _T2> template <class _T1, class _T2>
_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_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 >= 14 #if _LIBCPP_STD_VER >= 14
template <class _Tp = void> template <class _Tp = void>
#else #else
template <class _Tp> template <class _Tp>
#endif #endif
struct _LIBCPP_TEMPLATE_VIS divides struct 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_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_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;}
}; };
_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(divides); _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(divides);
#if _LIBCPP_STD_VER >= 14 #if _LIBCPP_STD_VER >= 14
template <> template <>
struct _LIBCPP_TEMPLATE_VIS divides<void> struct divides<void>
{ {
template <class _T1, class _T2> template <class _T1, class _T2>
_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_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 >= 14 #if _LIBCPP_STD_VER >= 14
template <class _Tp = void> template <class _Tp = void>
#else #else
template <class _Tp> template <class _Tp>
#endif #endif
struct _LIBCPP_TEMPLATE_VIS modulus struct 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_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_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;}
}; };
_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(modulus); _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(modulus);
#if _LIBCPP_STD_VER >= 14 #if _LIBCPP_STD_VER >= 14
template <> template <>
struct _LIBCPP_TEMPLATE_VIS modulus<void> struct modulus<void>
{ {
template <class _T1, class _T2> template <class _T1, class _T2>
_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_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 >= 14 #if _LIBCPP_STD_VER >= 14
template <class _Tp = void> template <class _Tp = void>
#else #else
template <class _Tp> template <class _Tp>
#endif #endif
struct _LIBCPP_TEMPLATE_VIS negate struct 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_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
_Tp operator()(const _Tp& __x) const _Tp operator()(const _Tp& __x) const
{return -__x;} {return -__x;}
}; };
_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(negate); _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(negate);
#if _LIBCPP_STD_VER >= 14 #if _LIBCPP_STD_VER >= 14
template <> template <>
struct _LIBCPP_TEMPLATE_VIS negate<void> struct negate<void>
{ {
template <class _Tp> template <class _Tp>
_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_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 >= 14 #if _LIBCPP_STD_VER >= 14
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 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_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_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;}
}; };
_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(bit_and); _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(bit_and);
#if _LIBCPP_STD_VER >= 14 #if _LIBCPP_STD_VER >= 14
template <> template <>
struct _LIBCPP_TEMPLATE_VIS bit_and<void> struct bit_and<void>
{ {
template <class _T1, class _T2> template <class _T1, class _T2>
_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_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 >= 14 #if _LIBCPP_STD_VER >= 14
template <class _Tp = void> template <class _Tp = void>
struct _LIBCPP_TEMPLATE_VIS bit_not struct bit_not : __unary_function<_Tp, _Tp>
: __unary_function<_Tp, _Tp>
{ {
_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
_Tp operator()(const _Tp& __x) const _Tp operator()(const _Tp& __x) const
{return ~__x;} {return ~__x;}
}; };
_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(bit_not); _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(bit_not);
template <> template <>
struct _LIBCPP_TEMPLATE_VIS bit_not<void> struct bit_not<void>
{ {
template <class _Tp> template <class _Tp>
_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_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 >= 14 #if _LIBCPP_STD_VER >= 14
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 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_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_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;}
}; };
_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(bit_or); _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(bit_or);
#if _LIBCPP_STD_VER >= 14 #if _LIBCPP_STD_VER >= 14
template <> template <>
struct _LIBCPP_TEMPLATE_VIS bit_or<void> struct bit_or<void>
{ {
template <class _T1, class _T2> template <class _T1, class _T2>
_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_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 >= 14 #if _LIBCPP_STD_VER >= 14
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 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_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_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;}
}; };
_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(bit_xor); _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(bit_xor);
#if _LIBCPP_STD_VER >= 14 #if _LIBCPP_STD_VER >= 14
template <> template <>
struct _LIBCPP_TEMPLATE_VIS bit_xor<void> struct bit_xor<void>
{ {
template <class _T1, class _T2> template <class _T1, class _T2>
_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_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 >= 14 #if _LIBCPP_STD_VER >= 14
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 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_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_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;}
}; };
_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(equal_to); _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(equal_to);
#if _LIBCPP_STD_VER >= 14 #if _LIBCPP_STD_VER >= 14
template <> template <>
struct _LIBCPP_TEMPLATE_VIS equal_to<void> struct equal_to<void>
{ {
template <class _T1, class _T2> template <class _T1, class _T2>
_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_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
template <class _Tp> template <class _Tp>
struct __is_trivial_equality_predicate<equal_to<_Tp>, _Tp, _Tp> : true_type {}; struct __is_trivial_equality_predicate<equal_to<_Tp>, _Tp, _Tp> : true_type {};
#if _LIBCPP_STD_VER >= 14 #if _LIBCPP_STD_VER >= 14
template <class _Tp> template <class _Tp>
struct __is_trivial_equality_predicate<equal_to<>, _Tp, _Tp> : true_type {}; struct __is_trivial_equality_predicate<equal_to<>, _Tp, _Tp> : true_type {};
#endif #endif
#if _LIBCPP_STD_VER >= 14 #if _LIBCPP_STD_VER >= 14
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 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_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_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;}
}; };
_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(not_equal_to); _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(not_equal_to);
#if _LIBCPP_STD_VER >= 14 #if _LIBCPP_STD_VER >= 14
template <> template <>
struct _LIBCPP_TEMPLATE_VIS not_equal_to<void> struct not_equal_to<void>
{ {
template <class _T1, class _T2> template <class _T1, class _T2>
_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_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 >= 14 #if _LIBCPP_STD_VER >= 14
template <class _Tp = void> template <class _Tp = void>
#else #else
template <class _Tp> template <class _Tp>
#endif #endif
struct _LIBCPP_TEMPLATE_VIS less struct 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_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_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;}
}; };
_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(less); _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(less);
#if _LIBCPP_STD_VER >= 14 #if _LIBCPP_STD_VER >= 14
template <> template <>
struct _LIBCPP_TEMPLATE_VIS less<void> struct less<void>
{ {
template <class _T1, class _T2> template <class _T1, class _T2>
_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_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 >= 14 #if _LIBCPP_STD_VER >= 14
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 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_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_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;}
}; };
_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(less_equal); _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(less_equal);
#if _LIBCPP_STD_VER >= 14 #if _LIBCPP_STD_VER >= 14
template <> template <>
struct _LIBCPP_TEMPLATE_VIS less_equal<void> struct less_equal<void>
{ {
template <class _T1, class _T2> template <class _T1, class _T2>
_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_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 >= 14 #if _LIBCPP_STD_VER >= 14
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 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_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_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;}
}; };
_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(greater_equal); _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(greater_equal);
#if _LIBCPP_STD_VER >= 14 #if _LIBCPP_STD_VER >= 14
template <> template <>
struct _LIBCPP_TEMPLATE_VIS greater_equal<void> struct greater_equal<void>
{ {
template <class _T1, class _T2> template <class _T1, class _T2>
_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_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 >= 14 #if _LIBCPP_STD_VER >= 14
template <class _Tp = void> template <class _Tp = void>
#else #else
template <class _Tp> template <class _Tp>
#endif #endif
struct _LIBCPP_TEMPLATE_VIS greater struct 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_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_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;}
}; };
_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(greater); _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(greater);
#if _LIBCPP_STD_VER >= 14 #if _LIBCPP_STD_VER >= 14
template <> template <>
struct _LIBCPP_TEMPLATE_VIS greater<void> struct greater<void>
{ {
template <class _T1, class _T2> template <class _T1, class _T2>
_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_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 >= 14 #if _LIBCPP_STD_VER >= 14
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 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_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_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;}
}; };
_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(logical_and); _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(logical_and);
#if _LIBCPP_STD_VER >= 14 #if _LIBCPP_STD_VER >= 14
template <> template <>
struct _LIBCPP_TEMPLATE_VIS logical_and<void> struct logical_and<void>
{ {
template <class _T1, class _T2> template <class _T1, class _T2>
_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_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 >= 14 #if _LIBCPP_STD_VER >= 14
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 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_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
bool operator()(const _Tp& __x) const bool operator()(const _Tp& __x) const
{return !__x;} {return !__x;}
}; };
_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(logical_not); _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(logical_not);
#if _LIBCPP_STD_VER >= 14 #if _LIBCPP_STD_VER >= 14
template <> template <>
struct _LIBCPP_TEMPLATE_VIS logical_not<void> struct logical_not<void>
{ {
template <class _Tp> template <class _Tp>
_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_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 >= 14 #if _LIBCPP_STD_VER >= 14
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 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_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_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;}
}; };
_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(logical_or); _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(logical_or);
#if _LIBCPP_STD_VER >= 14 #if _LIBCPP_STD_VER >= 14
template <> template <>
struct _LIBCPP_TEMPLATE_VIS logical_or<void> struct logical_or<void>
{ {
template <class _T1, class _T2> template <class _T1, class _T2>
_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_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/pointer_to_binary_function.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 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_BINDERS) #if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_BINDERS)
template <class _Arg1, class _Arg2, class _Result> template <class _Arg1, class _Arg2, class _Result>
class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 pointer_to_binary_function class _LIBCPP_DEPRECATED_IN_CXX11 pointer_to_binary_function : public __binary_function<_Arg1, _Arg2, _Result>
: public __binary_function<_Arg1, _Arg2, _Result>
{ {
_Result (*__f_)(_Arg1, _Arg2); _Result (*__f_)(_Arg1, _Arg2);
public: public:
_LIBCPP_INLINE_VISIBILITY explicit pointer_to_binary_function(_Result (*__f)(_Arg1, _Arg2)) _LIBCPP_INLINE_VISIBILITY explicit pointer_to_binary_function(_Result (*__f)(_Arg1, _Arg2))
: __f_(__f) {} : __f_(__f) {}
_LIBCPP_INLINE_VISIBILITY _Result operator()(_Arg1 __x, _Arg2 __y) const _LIBCPP_INLINE_VISIBILITY _Result operator()(_Arg1 __x, _Arg2 __y) const
{return __f_(__x, __y);} {return __f_(__x, __y);}
}; };
Show All 12 Lines

libcxx/include/__functional/pointer_to_unary_function.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 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_BINDERS) #if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_BINDERS)
template <class _Arg, class _Result> template <class _Arg, class _Result>
class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 pointer_to_unary_function class _LIBCPP_DEPRECATED_IN_CXX11 pointer_to_unary_function : public __unary_function<_Arg, _Result>
: public __unary_function<_Arg, _Result>
{ {
_Result (*__f_)(_Arg); _Result (*__f_)(_Arg);
public: public:
_LIBCPP_INLINE_VISIBILITY explicit pointer_to_unary_function(_Result (*__f)(_Arg)) _LIBCPP_INLINE_VISIBILITY explicit pointer_to_unary_function(_Result (*__f)(_Arg))
: __f_(__f) {} : __f_(__f) {}
_LIBCPP_INLINE_VISIBILITY _Result operator()(_Arg __x) const _LIBCPP_INLINE_VISIBILITY _Result operator()(_Arg __x) const
{return __f_(__x);} {return __f_(__x);}
}; };
Show All 12 Lines

libcxx/include/__functional/reference_wrapper.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 _Tp> template <class _Tp>
class _LIBCPP_TEMPLATE_VIS reference_wrapper : public __weak_result_type<_Tp> class reference_wrapper : public __weak_result_type<_Tp>
{ {
public: public:
// types // types
typedef _Tp type; typedef _Tp type;
private: private:
type* __f_; type* __f_;
static void __fun(_Tp&) _NOEXCEPT; static void __fun(_Tp&) _NOEXCEPT;
▲ Show 20 Lines • Show All 74 Lines • Show Last 20 Lines

libcxx/include/__functional/unary_function.h

Show All 14 Lines
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_UNARY_BINARY_FUNCTION) #if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_UNARY_BINARY_FUNCTION)
template <class _Arg, class _Result> template <class _Arg, class _Result>
struct _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 unary_function struct _LIBCPP_DEPRECATED_IN_CXX11 unary_function
{ {
typedef _Arg argument_type; typedef _Arg argument_type;
typedef _Result result_type; typedef _Result result_type;
}; };
#endif // _LIBCPP_STD_VER <= 14 #endif // _LIBCPP_STD_VER <= 14
template <class _Arg, class _Result> struct __unary_function_keep_layout_base { template <class _Arg, class _Result> struct __unary_function_keep_layout_base {
Show All 20 Lines

libcxx/include/__functional/unary_negate.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 <= 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_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_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
explicit unary_negate(const _Predicate& __pred) explicit unary_negate(const _Predicate& __pred)
: __pred_(__pred) {} : __pred_(__pred) {}
_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
Show All 14 Lines

libcxx/include/__fwd/array.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, size_t _Size> template <class _Tp, size_t _Size>
struct _LIBCPP_TEMPLATE_VIS array; struct array;
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___FWD_ARRAY_H #endif // _LIBCPP___FWD_ARRAY_H

libcxx/include/__fwd/fstream.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 _CharT, class _Traits = char_traits<_CharT> > template <class _CharT, class _Traits = char_traits<_CharT> >
class _LIBCPP_TEMPLATE_VIS basic_filebuf; class basic_filebuf;
template <class _CharT, class _Traits = char_traits<_CharT> > template <class _CharT, class _Traits = char_traits<_CharT> >
class _LIBCPP_TEMPLATE_VIS basic_ifstream; class basic_ifstream;
template <class _CharT, class _Traits = char_traits<_CharT> > template <class _CharT, class _Traits = char_traits<_CharT> >
class _LIBCPP_TEMPLATE_VIS basic_ofstream; class basic_ofstream;
template <class _CharT, class _Traits = char_traits<_CharT> > template <class _CharT, class _Traits = char_traits<_CharT> >
class _LIBCPP_TEMPLATE_VIS basic_fstream; class basic_fstream;
using filebuf = basic_filebuf<char>; using filebuf = basic_filebuf<char>;
using ifstream = basic_ifstream<char>; using ifstream = basic_ifstream<char>;
using ofstream = basic_ofstream<char>; using ofstream = basic_ofstream<char>;
using fstream = basic_fstream<char>; using fstream = basic_fstream<char>;
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
using wfilebuf = basic_filebuf<wchar_t>; using wfilebuf = basic_filebuf<wchar_t>;
Show All 17 Lines

libcxx/include/__fwd/hash.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> template <class>
struct _LIBCPP_TEMPLATE_VIS hash; struct hash;
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___FWD_HASH_H #endif // _LIBCPP___FWD_HASH_H

libcxx/include/__fwd/ios.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 _CharT, class _Traits = char_traits<_CharT> > template <class _CharT, class _Traits = char_traits<_CharT> >
class _LIBCPP_TEMPLATE_VIS basic_ios; class basic_ios;
using ios = basic_ios<char>; using ios = basic_ios<char>;
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
using wios = basic_ios<wchar_t>; using wios = basic_ios<wchar_t>;
#endif #endif
template <class _CharT, class _Traits> template <class _CharT, class _Traits>
class _LIBCPP_PREFERRED_NAME(ios) _LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wios)) basic_ios; class _LIBCPP_PREFERRED_NAME(ios) _LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wios)) basic_ios;
Show All 11 Lines

libcxx/include/__fwd/istream.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 _CharT, class _Traits = char_traits<_CharT> > template <class _CharT, class _Traits = char_traits<_CharT> >
class _LIBCPP_TEMPLATE_VIS basic_istream; class basic_istream;
template <class _CharT, class _Traits = char_traits<_CharT> > template <class _CharT, class _Traits = char_traits<_CharT> >
class _LIBCPP_TEMPLATE_VIS basic_iostream; class basic_iostream;
using istream = basic_istream<char>; using istream = basic_istream<char>;
using iostream = basic_iostream<char>; using iostream = basic_iostream<char>;
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
using wistream = basic_istream<wchar_t>; using wistream = basic_istream<wchar_t>;
using wiostream = basic_iostream<wchar_t>; using wiostream = basic_iostream<wchar_t>;
#endif #endif
Show All 10 Lines

libcxx/include/__fwd/memory_resource.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
namespace pmr { namespace pmr {
template <class _ValueType> template <class _ValueType>
class _LIBCPP_TEMPLATE_VIS polymorphic_allocator; class polymorphic_allocator;
} // namespace pmr } // namespace pmr
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___FWD_MEMORY_RESOURCE_H #endif // _LIBCPP___FWD_MEMORY_RESOURCE_H

libcxx/include/__fwd/ostream.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 _CharT, class _Traits = char_traits<_CharT> > template <class _CharT, class _Traits = char_traits<_CharT> >
class _LIBCPP_TEMPLATE_VIS basic_ostream; class basic_ostream;
using ostream = basic_ostream<char>; using ostream = basic_ostream<char>;
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
using wostream = basic_ostream<wchar_t>; using wostream = basic_ostream<wchar_t>;
#endif #endif
template <class _CharT, class _Traits> template <class _CharT, class _Traits>
class _LIBCPP_PREFERRED_NAME(ostream) _LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wostream)) basic_ostream; class _LIBCPP_PREFERRED_NAME(ostream) _LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wostream)) basic_ostream;
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___FWD_OSTREAM_H #endif // _LIBCPP___FWD_OSTREAM_H

libcxx/include/__fwd/pair.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, class> template <class, class>
struct _LIBCPP_TEMPLATE_VIS pair; struct pair;
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___FWD_PAIR_H #endif // _LIBCPP___FWD_PAIR_H

libcxx/include/__fwd/sstream.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 _CharT, class _Traits = char_traits<_CharT>, class _Allocator = allocator<_CharT> > template <class _CharT, class _Traits = char_traits<_CharT>, class _Allocator = allocator<_CharT> >
class _LIBCPP_TEMPLATE_VIS basic_stringbuf; class basic_stringbuf;
template <class _CharT, class _Traits = char_traits<_CharT>, class _Allocator = allocator<_CharT> > template <class _CharT, class _Traits = char_traits<_CharT>, class _Allocator = allocator<_CharT> >
class _LIBCPP_TEMPLATE_VIS basic_istringstream; class basic_istringstream;
template <class _CharT, class _Traits = char_traits<_CharT>, class _Allocator = allocator<_CharT> > template <class _CharT, class _Traits = char_traits<_CharT>, class _Allocator = allocator<_CharT> >
class _LIBCPP_TEMPLATE_VIS basic_ostringstream; class basic_ostringstream;
template <class _CharT, class _Traits = char_traits<_CharT>, class _Allocator = allocator<_CharT> > template <class _CharT, class _Traits = char_traits<_CharT>, class _Allocator = allocator<_CharT> >
class _LIBCPP_TEMPLATE_VIS basic_stringstream; class basic_stringstream;
using stringbuf = basic_stringbuf<char>; using stringbuf = basic_stringbuf<char>;
using istringstream = basic_istringstream<char>; using istringstream = basic_istringstream<char>;
using ostringstream = basic_ostringstream<char>; using ostringstream = basic_ostringstream<char>;
using stringstream = basic_stringstream<char>; using stringstream = basic_stringstream<char>;
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
using wstringbuf = basic_stringbuf<wchar_t>; using wstringbuf = basic_stringbuf<wchar_t>;
Show All 20 Lines

libcxx/include/__fwd/streambuf.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 _CharT, class _Traits = char_traits<_CharT> > template <class _CharT, class _Traits = char_traits<_CharT> >
class _LIBCPP_TEMPLATE_VIS basic_streambuf; class basic_streambuf;
using streambuf = basic_streambuf<char>; using streambuf = basic_streambuf<char>;
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
using wstreambuf = basic_streambuf<wchar_t>; using wstreambuf = basic_streambuf<wchar_t>;
#endif #endif
template <class _CharT, class _Traits> template <class _CharT, class _Traits>
class _LIBCPP_PREFERRED_NAME(streambuf) _LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wstreambuf)) basic_streambuf; class _LIBCPP_PREFERRED_NAME(streambuf) _LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wstreambuf)) basic_streambuf;
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___FWD_STREAMBUF_H #endif // _LIBCPP___FWD_STREAMBUF_H

libcxx/include/__fwd/string.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 _CharT> template <class _CharT>
struct _LIBCPP_TEMPLATE_VIS char_traits; struct char_traits;
template <> template <>
struct char_traits<char>; struct char_traits<char>;
#ifndef _LIBCPP_HAS_NO_CHAR8_T #ifndef _LIBCPP_HAS_NO_CHAR8_T
template <> template <>
struct char_traits<char8_t>; struct char_traits<char8_t>;
#endif #endif
template <> template <>
struct char_traits<char16_t>; struct char_traits<char16_t>;
template <> template <>
struct char_traits<char32_t>; struct char_traits<char32_t>;
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
template <> template <>
struct char_traits<wchar_t>; struct char_traits<wchar_t>;
#endif #endif
template <class _Tp> template <class _Tp>
class _LIBCPP_TEMPLATE_VIS allocator; class allocator;
template <class _CharT, class _Traits = char_traits<_CharT>, class _Allocator = allocator<_CharT> > template <class _CharT, class _Traits = char_traits<_CharT>, class _Allocator = allocator<_CharT> >
class _LIBCPP_TEMPLATE_VIS basic_string; class basic_string;
using string = basic_string<char>; using string = basic_string<char>;
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
using wstring = basic_string<wchar_t>; using wstring = basic_string<wchar_t>;
#endif #endif
#ifndef _LIBCPP_HAS_NO_CHAR8_T #ifndef _LIBCPP_HAS_NO_CHAR8_T
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

libcxx/include/__fwd/string_view.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 _CharT, class _Traits = char_traits<_CharT> > template<class _CharT, class _Traits = char_traits<_CharT> >
class _LIBCPP_TEMPLATE_VIS basic_string_view; class basic_string_view;
typedef basic_string_view<char> string_view; typedef basic_string_view<char> string_view;
#ifndef _LIBCPP_HAS_NO_CHAR8_T #ifndef _LIBCPP_HAS_NO_CHAR8_T
typedef basic_string_view<char8_t> u8string_view; typedef basic_string_view<char8_t> u8string_view;
#endif #endif
typedef basic_string_view<char16_t> u16string_view; typedef basic_string_view<char16_t> u16string_view;
typedef basic_string_view<char32_t> u32string_view; typedef basic_string_view<char32_t> u32string_view;
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
Show All 19 Lines

libcxx/include/__fwd/subrange.h

Show All 17 Lines
#if _LIBCPP_STD_VER >= 20 #if _LIBCPP_STD_VER >= 20
#include <__iterator/concepts.h> #include <__iterator/concepts.h>
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
enum class _LIBCPP_ENUM_VIS subrange_kind : bool { unsized, sized }; enum class subrange_kind : bool { unsized, sized };
template <input_or_output_iterator _Iter, sentinel_for<_Iter> _Sent, subrange_kind _Kind> template <input_or_output_iterator _Iter, sentinel_for<_Iter> _Sent, subrange_kind _Kind>
requires(_Kind == subrange_kind::sized || !sized_sentinel_for<_Sent, _Iter>) requires(_Kind == subrange_kind::sized || !sized_sentinel_for<_Sent, _Iter>)
class _LIBCPP_TEMPLATE_VIS subrange; class subrange;
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER >= 20 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___FWD_SUBRANGE_H #endif // _LIBCPP___FWD_SUBRANGE_H

libcxx/include/__fwd/tuple.h

Show All 14 Lines
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
template <class...> template <class...>
class _LIBCPP_TEMPLATE_VIS tuple; class tuple;
#endif // _LIBCPP_CXX03_LANG #endif // _LIBCPP_CXX03_LANG
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___FWD_TUPLE_H #endif // _LIBCPP___FWD_TUPLE_H

libcxx/include/__hash_table

Show First 20 Lines • Show All 143 Lines • ▼ Show 20 Lines
__next_hash_pow2(size_t __n) __next_hash_pow2(size_t __n)
{ {
return __n < 2 ? __n : (size_t(1) << (numeric_limits<size_t>::digits - __libcpp_clz(__n-1))); return __n < 2 ? __n : (size_t(1) << (numeric_limits<size_t>::digits - __libcpp_clz(__n-1)));
} }
template <class _Tp, class _Hash, class _Equal, class _Alloc> class __hash_table; template <class _Tp, class _Hash, class _Equal, class _Alloc> class __hash_table;
template <class _NodePtr> class _LIBCPP_TEMPLATE_VIS __hash_iterator; template <class _NodePtr> class __hash_iterator;
template <class _ConstNodePtr> class _LIBCPP_TEMPLATE_VIS __hash_const_iterator; template <class _ConstNodePtr> class __hash_const_iterator;
template <class _NodePtr> class _LIBCPP_TEMPLATE_VIS __hash_local_iterator; template <class _NodePtr> class __hash_local_iterator;
template <class _ConstNodePtr> class _LIBCPP_TEMPLATE_VIS __hash_const_local_iterator; template <class _ConstNodePtr> class __hash_const_local_iterator;
template <class _HashIterator> class _LIBCPP_TEMPLATE_VIS __hash_map_iterator; template <class _HashIterator> class __hash_map_iterator;
template <class _HashIterator> class _LIBCPP_TEMPLATE_VIS __hash_map_const_iterator; template <class _HashIterator> class __hash_map_const_iterator;
template <class _Tp> template <class _Tp>
struct __hash_key_value_types { struct __hash_key_value_types {
static_assert(!is_reference<_Tp>::value && !is_const<_Tp>::value, ""); static_assert(!is_reference<_Tp>::value && !is_const<_Tp>::value, "");
typedef _Tp key_type; typedef _Tp key_type;
typedef _Tp __node_value_type; typedef _Tp __node_value_type;
typedef _Tp __container_value_type; typedef _Tp __container_value_type;
static const bool __is_map = false; static const bool __is_map = false;
▲ Show 20 Lines • Show All 122 Lines • ▼ Show 20 Lines
template <class _NodeValueTp, class _VoidPtr> template <class _NodeValueTp, class _VoidPtr>
struct __make_hash_node_types { struct __make_hash_node_types {
typedef __hash_node<_NodeValueTp, _VoidPtr> _NodeTp; typedef __hash_node<_NodeValueTp, _VoidPtr> _NodeTp;
typedef __rebind_pointer_t<_VoidPtr, _NodeTp> _NodePtr; typedef __rebind_pointer_t<_VoidPtr, _NodeTp> _NodePtr;
typedef __hash_node_types<_NodePtr> type; typedef __hash_node_types<_NodePtr> type;
}; };
template <class _NodePtr> template <class _NodePtr>
class _LIBCPP_TEMPLATE_VIS __hash_iterator class __hash_iterator
{ {
typedef __hash_node_types<_NodePtr> _NodeTypes; typedef __hash_node_types<_NodePtr> _NodeTypes;
typedef _NodePtr __node_pointer; typedef _NodePtr __node_pointer;
typedef typename _NodeTypes::__next_pointer __next_pointer; typedef typename _NodeTypes::__next_pointer __next_pointer;
__next_pointer __node_; __next_pointer __node_;
public: public:
▲ Show 20 Lines • Show All 78 Lines • ▼ Show 20 Lines explicit __hash_iterator(__next_pointer __node, const void* __c) _NOEXCEPT
: __node_(__node) : __node_(__node)
{ {
(void)__c; (void)__c;
#ifdef _LIBCPP_ENABLE_DEBUG_MODE #ifdef _LIBCPP_ENABLE_DEBUG_MODE
__get_db()->__insert_ic(this, __c); __get_db()->__insert_ic(this, __c);
#endif #endif
} }
template <class, class, class, class> friend class __hash_table; template <class, class, class, class> friend class __hash_table;
template <class> friend class _LIBCPP_TEMPLATE_VIS __hash_const_iterator; template <class> friend class __hash_const_iterator;
template <class> friend class _LIBCPP_TEMPLATE_VIS __hash_map_iterator; template <class> friend class __hash_map_iterator;
template <class, class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS unordered_map; template <class, class, class, class, class> friend class unordered_map;
template <class, class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS unordered_multimap; template <class, class, class, class, class> friend class unordered_multimap;
}; };
template <class _NodePtr> template <class _NodePtr>
class _LIBCPP_TEMPLATE_VIS __hash_const_iterator class __hash_const_iterator
{ {
static_assert(!is_const<typename pointer_traits<_NodePtr>::element_type>::value, ""); static_assert(!is_const<typename pointer_traits<_NodePtr>::element_type>::value, "");
typedef __hash_node_types<_NodePtr> _NodeTypes; typedef __hash_node_types<_NodePtr> _NodeTypes;
typedef _NodePtr __node_pointer; typedef _NodePtr __node_pointer;
typedef typename _NodeTypes::__next_pointer __next_pointer; typedef typename _NodeTypes::__next_pointer __next_pointer;
__next_pointer __node_; __next_pointer __node_;
▲ Show 20 Lines • Show All 90 Lines • ▼ Show 20 Lines explicit __hash_const_iterator(__next_pointer __node, const void* __c) _NOEXCEPT
: __node_(__node) : __node_(__node)
{ {
(void)__c; (void)__c;
#ifdef _LIBCPP_ENABLE_DEBUG_MODE #ifdef _LIBCPP_ENABLE_DEBUG_MODE
__get_db()->__insert_ic(this, __c); __get_db()->__insert_ic(this, __c);
#endif #endif
} }
template <class, class, class, class> friend class __hash_table; template <class, class, class, class> friend class __hash_table;
template <class> friend class _LIBCPP_TEMPLATE_VIS __hash_map_const_iterator; template <class> friend class __hash_map_const_iterator;
template <class, class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS unordered_map; template <class, class, class, class, class> friend class unordered_map;
template <class, class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS unordered_multimap; template <class, class, class, class, class> friend class unordered_multimap;
}; };
template <class _NodePtr> template <class _NodePtr>
class _LIBCPP_TEMPLATE_VIS __hash_local_iterator class __hash_local_iterator
{ {
typedef __hash_node_types<_NodePtr> _NodeTypes; typedef __hash_node_types<_NodePtr> _NodeTypes;
typedef _NodePtr __node_pointer; typedef _NodePtr __node_pointer;
typedef typename _NodeTypes::__next_pointer __next_pointer; typedef typename _NodeTypes::__next_pointer __next_pointer;
__next_pointer __node_; __next_pointer __node_;
size_t __bucket_; size_t __bucket_;
size_t __bucket_count_; size_t __bucket_count_;
▲ Show 20 Lines • Show All 91 Lines • ▼ Show 20 Lines explicit __hash_local_iterator(__next_pointer __node, size_t __bucket,
(void)__c; (void)__c;
#ifdef _LIBCPP_ENABLE_DEBUG_MODE #ifdef _LIBCPP_ENABLE_DEBUG_MODE
__get_db()->__insert_ic(this, __c); __get_db()->__insert_ic(this, __c);
#endif #endif
if (__node_ != nullptr) if (__node_ != nullptr)
__node_ = __node_->__next_; __node_ = __node_->__next_;
} }
template <class, class, class, class> friend class __hash_table; template <class, class, class, class> friend class __hash_table;
template <class> friend class _LIBCPP_TEMPLATE_VIS __hash_const_local_iterator; template <class> friend class __hash_const_local_iterator;
template <class> friend class _LIBCPP_TEMPLATE_VIS __hash_map_iterator; template <class> friend class __hash_map_iterator;
}; };
template <class _ConstNodePtr> template <class _ConstNodePtr>
class _LIBCPP_TEMPLATE_VIS __hash_const_local_iterator class __hash_const_local_iterator
{ {
typedef __hash_node_types<_ConstNodePtr> _NodeTypes; typedef __hash_node_types<_ConstNodePtr> _NodeTypes;
typedef _ConstNodePtr __node_pointer; typedef _ConstNodePtr __node_pointer;
typedef typename _NodeTypes::__next_pointer __next_pointer; typedef typename _NodeTypes::__next_pointer __next_pointer;
__next_pointer __node_; __next_pointer __node_;
size_t __bucket_; size_t __bucket_;
size_t __bucket_count_; size_t __bucket_count_;
▲ Show 20 Lines • Show All 111 Lines • ▼ Show 20 Lines explicit __hash_const_local_iterator(__next_pointer __node_ptr, size_t __bucket,
(void)__c; (void)__c;
#ifdef _LIBCPP_ENABLE_DEBUG_MODE #ifdef _LIBCPP_ENABLE_DEBUG_MODE
__get_db()->__insert_ic(this, __c); __get_db()->__insert_ic(this, __c);
#endif #endif
if (__node_ != nullptr) if (__node_ != nullptr)
__node_ = __node_->__next_; __node_ = __node_->__next_;
} }
template <class, class, class, class> friend class __hash_table; template <class, class, class, class> friend class __hash_table;
template <class> friend class _LIBCPP_TEMPLATE_VIS __hash_map_const_iterator; template <class> friend class __hash_map_const_iterator;
}; };
template <class _Alloc> template <class _Alloc>
class __bucket_list_deallocator class __bucket_list_deallocator
{ {
typedef _Alloc allocator_type; typedef _Alloc allocator_type;
typedef allocator_traits<allocator_type> __alloc_traits; typedef allocator_traits<allocator_type> __alloc_traits;
typedef typename __alloc_traits::size_type size_type; typedef typename __alloc_traits::size_type size_type;
▲ Show 20 Lines • Show All 595 Lines • ▼ Show 20 Lines void __move_assign_alloc(__hash_table& __u, true_type)
__node_alloc() = _VSTD::move(__u.__node_alloc()); __node_alloc() = _VSTD::move(__u.__node_alloc());
} }
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
void __move_assign_alloc(__hash_table&, false_type) _NOEXCEPT {} void __move_assign_alloc(__hash_table&, false_type) _NOEXCEPT {}
_LIBCPP_HIDE_FROM_ABI void __deallocate_node(__next_pointer __np) _NOEXCEPT; _LIBCPP_HIDE_FROM_ABI void __deallocate_node(__next_pointer __np) _NOEXCEPT;
_LIBCPP_HIDE_FROM_ABI __next_pointer __detach() _NOEXCEPT; _LIBCPP_HIDE_FROM_ABI __next_pointer __detach() _NOEXCEPT;
template <class, class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS unordered_map; template <class, class, class, class, class> friend class unordered_map;
template <class, class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS unordered_multimap; template <class, class, class, class, class> friend class unordered_multimap;
}; };
template <class _Tp, class _Hash, class _Equal, class _Alloc> template <class _Tp, class _Hash, class _Equal, class _Alloc>
inline inline
__hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table() __hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table()
_NOEXCEPT_( _NOEXCEPT_(
is_nothrow_default_constructible<__bucket_list>::value && is_nothrow_default_constructible<__bucket_list>::value &&
is_nothrow_default_constructible<__first_node>::value && is_nothrow_default_constructible<__first_node>::value &&
▲ Show 20 Lines • Show All 1,357 Lines • Show Last 20 Lines

libcxx/include/__ios/fpos.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 _StateT> template <class _StateT>
class _LIBCPP_TEMPLATE_VIS fpos { class fpos {
private: private:
_StateT __st_; _StateT __st_;
streamoff __off_; streamoff __off_;
public: public:
_LIBCPP_HIDE_FROM_ABI fpos(streamoff __off = streamoff()) : __st_(), __off_(__off) {} _LIBCPP_HIDE_FROM_ABI fpos(streamoff __off = streamoff()) : __st_(), __off_(__off) {}
_LIBCPP_HIDE_FROM_ABI operator streamoff() const { return __off_; } _LIBCPP_HIDE_FROM_ABI operator streamoff() const { return __off_; }
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

libcxx/include/__iterator/back_insert_iterator.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
_LIBCPP_SUPPRESS_DEPRECATED_PUSH _LIBCPP_SUPPRESS_DEPRECATED_PUSH
template <class _Container> template <class _Container>
class _LIBCPP_TEMPLATE_VIS back_insert_iterator class back_insert_iterator
#if _LIBCPP_STD_VER <= 14 || !defined(_LIBCPP_ABI_NO_ITERATOR_BASES) #if _LIBCPP_STD_VER <= 14 || !defined(_LIBCPP_ABI_NO_ITERATOR_BASES)
: public iterator<output_iterator_tag, void, void, void, void> : public iterator<output_iterator_tag, void, void, void, void>
#endif #endif
{ {
_LIBCPP_SUPPRESS_DEPRECATED_POP _LIBCPP_SUPPRESS_DEPRECATED_POP
protected: protected:
_Container* container; _Container* container;
public: public:
Show All 37 Lines

libcxx/include/__iterator/front_insert_iterator.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
_LIBCPP_SUPPRESS_DEPRECATED_PUSH _LIBCPP_SUPPRESS_DEPRECATED_PUSH
template <class _Container> template <class _Container>
class _LIBCPP_TEMPLATE_VIS front_insert_iterator class front_insert_iterator
#if _LIBCPP_STD_VER <= 14 || !defined(_LIBCPP_ABI_NO_ITERATOR_BASES) #if _LIBCPP_STD_VER <= 14 || !defined(_LIBCPP_ABI_NO_ITERATOR_BASES)
: public iterator<output_iterator_tag, void, void, void, void> : public iterator<output_iterator_tag, void, void, void, void>
#endif #endif
{ {
_LIBCPP_SUPPRESS_DEPRECATED_POP _LIBCPP_SUPPRESS_DEPRECATED_POP
protected: protected:
_Container* container; _Container* container;
public: public:
Show All 35 Lines

libcxx/include/__iterator/insert_iterator.h

Show All 28 Lines
using __insert_iterator_iter_t = ranges::iterator_t<_Container>; using __insert_iterator_iter_t = ranges::iterator_t<_Container>;
#else #else
template <class _Container> template <class _Container>
using __insert_iterator_iter_t = typename _Container::iterator; using __insert_iterator_iter_t = typename _Container::iterator;
#endif #endif
_LIBCPP_SUPPRESS_DEPRECATED_PUSH _LIBCPP_SUPPRESS_DEPRECATED_PUSH
template <class _Container> template <class _Container>
class _LIBCPP_TEMPLATE_VIS insert_iterator class insert_iterator
#if _LIBCPP_STD_VER <= 14 || !defined(_LIBCPP_ABI_NO_ITERATOR_BASES) #if _LIBCPP_STD_VER <= 14 || !defined(_LIBCPP_ABI_NO_ITERATOR_BASES)
: public iterator<output_iterator_tag, void, void, void, void> : public iterator<output_iterator_tag, void, void, void, void>
#endif #endif
{ {
_LIBCPP_SUPPRESS_DEPRECATED_POP _LIBCPP_SUPPRESS_DEPRECATED_POP
protected: protected:
_Container* container; _Container* container;
__insert_iterator_iter_t<_Container> iter; __insert_iterator_iter_t<_Container> iter;
Show All 36 Lines

libcxx/include/__iterator/istream_iterator.h

Show All 21 Lines
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
_LIBCPP_SUPPRESS_DEPRECATED_PUSH _LIBCPP_SUPPRESS_DEPRECATED_PUSH
template <class _Tp, class _CharT = char, template <class _Tp, class _CharT = char,
class _Traits = char_traits<_CharT>, class _Distance = ptrdiff_t> class _Traits = char_traits<_CharT>, class _Distance = ptrdiff_t>
class _LIBCPP_TEMPLATE_VIS istream_iterator class istream_iterator
#if _LIBCPP_STD_VER <= 14 || !defined(_LIBCPP_ABI_NO_ITERATOR_BASES) #if _LIBCPP_STD_VER <= 14 || !defined(_LIBCPP_ABI_NO_ITERATOR_BASES)
: public iterator<input_iterator_tag, _Tp, _Distance, const _Tp*, const _Tp&> : public iterator<input_iterator_tag, _Tp, _Distance, const _Tp*, const _Tp&>
#endif #endif
{ {
_LIBCPP_SUPPRESS_DEPRECATED_POP _LIBCPP_SUPPRESS_DEPRECATED_POP
public: public:
typedef input_iterator_tag iterator_category; typedef input_iterator_tag iterator_category;
typedef _Tp value_type; typedef _Tp value_type;
▲ Show 20 Lines • Show All 67 Lines • Show Last 20 Lines

libcxx/include/__iterator/istreambuf_iterator.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
_LIBCPP_SUPPRESS_DEPRECATED_PUSH _LIBCPP_SUPPRESS_DEPRECATED_PUSH
template<class _CharT, class _Traits> template<class _CharT, class _Traits>
class _LIBCPP_TEMPLATE_VIS istreambuf_iterator class istreambuf_iterator
#if _LIBCPP_STD_VER <= 14 || !defined(_LIBCPP_ABI_NO_ITERATOR_BASES) #if _LIBCPP_STD_VER <= 14 || !defined(_LIBCPP_ABI_NO_ITERATOR_BASES)
: public iterator<input_iterator_tag, _CharT, : public iterator<input_iterator_tag, _CharT,
typename _Traits::off_type, _CharT*, typename _Traits::off_type, _CharT*,
_CharT> _CharT>
#endif #endif
{ {
_LIBCPP_SUPPRESS_DEPRECATED_POP _LIBCPP_SUPPRESS_DEPRECATED_POP
public: public:
▲ Show 20 Lines • Show All 84 Lines • Show Last 20 Lines

libcxx/include/__iterator/iterator.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 _Category, class _Tp, class _Distance = ptrdiff_t, template<class _Category, class _Tp, class _Distance = ptrdiff_t,
class _Pointer = _Tp*, class _Reference = _Tp&> class _Pointer = _Tp*, class _Reference = _Tp&>
struct _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX17 iterator struct _LIBCPP_DEPRECATED_IN_CXX17 iterator
{ {
typedef _Tp value_type; typedef _Tp value_type;
typedef _Distance difference_type; typedef _Distance difference_type;
typedef _Pointer pointer; typedef _Pointer pointer;
typedef _Reference reference; typedef _Reference reference;
typedef _Category iterator_category; typedef _Category iterator_category;
}; };
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ITERATOR_ITERATOR_H #endif // _LIBCPP___ITERATOR_ITERATOR_H

libcxx/include/__iterator/iterator_traits.h

Show First 20 Lines • Show All 59 Lines • ▼ Show 20 Lines
// [iterator.traits] // [iterator.traits]
template<__dereferenceable _Tp> template<__dereferenceable _Tp>
using iter_reference_t = decltype(*std::declval<_Tp&>()); using iter_reference_t = decltype(*std::declval<_Tp&>());
#endif // _LIBCPP_STD_VER >= 20 #endif // _LIBCPP_STD_VER >= 20
template <class _Iter> template <class _Iter>
struct _LIBCPP_TEMPLATE_VIS iterator_traits; struct iterator_traits;
struct _LIBCPP_TEMPLATE_VIS input_iterator_tag {}; struct input_iterator_tag {};
struct _LIBCPP_TEMPLATE_VIS output_iterator_tag {}; struct output_iterator_tag {};
struct _LIBCPP_TEMPLATE_VIS forward_iterator_tag : public input_iterator_tag {}; struct forward_iterator_tag : public input_iterator_tag {};
struct _LIBCPP_TEMPLATE_VIS bidirectional_iterator_tag : public forward_iterator_tag {}; struct bidirectional_iterator_tag : public forward_iterator_tag {};
struct _LIBCPP_TEMPLATE_VIS random_access_iterator_tag : public bidirectional_iterator_tag {}; struct random_access_iterator_tag : public bidirectional_iterator_tag {};
#if _LIBCPP_STD_VER >= 20 #if _LIBCPP_STD_VER >= 20
struct _LIBCPP_TEMPLATE_VIS contiguous_iterator_tag : public random_access_iterator_tag {}; struct contiguous_iterator_tag : public random_access_iterator_tag {};
#endif #endif
template <class _Iter> template <class _Iter>
struct __iter_traits_cache { struct __iter_traits_cache {
using type = _If< using type = _If<
__is_primary_template<iterator_traits<_Iter> >::value, __is_primary_template<iterator_traits<_Iter> >::value,
_Iter, _Iter,
iterator_traits<_Iter> iterator_traits<_Iter>
▲ Show 20 Lines • Show All 323 Lines • ▼ Show 20 Lines
{}; {};
// iterator_traits<Iterator> will only have the nested types if Iterator::iterator_category // iterator_traits<Iterator> will only have the nested types if Iterator::iterator_category
// exists. Else iterator_traits<Iterator> will be an empty class. This is a // exists. Else iterator_traits<Iterator> will be an empty class. This is a
// conforming extension which allows some programs to compile and behave as // conforming extension which allows some programs to compile and behave as
// the client expects instead of failing at compile time. // the client expects instead of failing at compile time.
template <class _Iter> template <class _Iter>
struct _LIBCPP_TEMPLATE_VIS iterator_traits struct iterator_traits : __iterator_traits<_Iter, __has_iterator_typedefs<_Iter>::value> {
: __iterator_traits<_Iter, __has_iterator_typedefs<_Iter>::value> {
using __primary_template = iterator_traits; using __primary_template = iterator_traits;
}; };
#endif // _LIBCPP_STD_VER >= 20 #endif // _LIBCPP_STD_VER >= 20
template<class _Tp> template<class _Tp>
#if _LIBCPP_STD_VER >= 20 #if _LIBCPP_STD_VER >= 20
requires is_object_v<_Tp> requires is_object_v<_Tp>
#endif #endif
struct _LIBCPP_TEMPLATE_VIS iterator_traits<_Tp*> struct iterator_traits<_Tp*>
{ {
typedef ptrdiff_t difference_type; typedef ptrdiff_t difference_type;
typedef __remove_cv_t<_Tp> value_type; typedef __remove_cv_t<_Tp> value_type;
typedef _Tp* pointer; typedef _Tp* pointer;
typedef _Tp& reference; typedef _Tp& reference;
typedef random_access_iterator_tag iterator_category; typedef random_access_iterator_tag iterator_category;
#if _LIBCPP_STD_VER >= 20 #if _LIBCPP_STD_VER >= 20
typedef contiguous_iterator_tag iterator_concept; typedef contiguous_iterator_tag iterator_concept;
▲ Show 20 Lines • Show All 104 Lines • Show Last 20 Lines

libcxx/include/__iterator/move_iterator.h

Show First 20 Lines • Show All 56 Lines • ▼ Show 20 Lines
template<class _Iter, class _Sent> template<class _Iter, class _Sent>
concept __move_iter_comparable = requires { concept __move_iter_comparable = requires {
{ std::declval<const _Iter&>() == std::declval<_Sent>() } -> convertible_to<bool>; { std::declval<const _Iter&>() == std::declval<_Sent>() } -> convertible_to<bool>;
}; };
#endif // _LIBCPP_STD_VER >= 20 #endif // _LIBCPP_STD_VER >= 20
template <class _Iter> template <class _Iter>
class _LIBCPP_TEMPLATE_VIS move_iterator class move_iterator
#if _LIBCPP_STD_VER >= 20 #if _LIBCPP_STD_VER >= 20
: public __move_iter_category_base<_Iter> : public __move_iter_category_base<_Iter>
#endif #endif
{ {
#if _LIBCPP_STD_VER >= 20 #if _LIBCPP_STD_VER >= 20
private: private:
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
static constexpr auto __get_iter_concept() { static constexpr auto __get_iter_concept() {
▲ Show 20 Lines • Show All 277 Lines • Show Last 20 Lines

libcxx/include/__iterator/move_sentinel.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 >= 20 #if _LIBCPP_STD_VER >= 20
template <semiregular _Sent> template <semiregular _Sent>
class _LIBCPP_TEMPLATE_VIS move_sentinel class move_sentinel
{ {
public: public:
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
move_sentinel() = default; move_sentinel() = default;
_LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_HIDE_FROM_ABI constexpr
explicit move_sentinel(_Sent __s) : __last_(std::move(__s)) {} explicit move_sentinel(_Sent __s) : __last_(std::move(__s)) {}
Show All 24 Lines

libcxx/include/__iterator/ostream_iterator.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
_LIBCPP_SUPPRESS_DEPRECATED_PUSH _LIBCPP_SUPPRESS_DEPRECATED_PUSH
template <class _Tp, class _CharT = char, class _Traits = char_traits<_CharT> > template <class _Tp, class _CharT = char, class _Traits = char_traits<_CharT> >
class _LIBCPP_TEMPLATE_VIS ostream_iterator class ostream_iterator
#if _LIBCPP_STD_VER <= 14 || !defined(_LIBCPP_ABI_NO_ITERATOR_BASES) #if _LIBCPP_STD_VER <= 14 || !defined(_LIBCPP_ABI_NO_ITERATOR_BASES)
: public iterator<output_iterator_tag, void, void, void, void> : public iterator<output_iterator_tag, void, void, void, void>
#endif #endif
{ {
_LIBCPP_SUPPRESS_DEPRECATED_POP _LIBCPP_SUPPRESS_DEPRECATED_POP
public: public:
typedef output_iterator_tag iterator_category; typedef output_iterator_tag iterator_category;
typedef void value_type; typedef void value_type;
Show All 35 Lines

libcxx/include/__iterator/ostreambuf_iterator.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
_LIBCPP_SUPPRESS_DEPRECATED_PUSH _LIBCPP_SUPPRESS_DEPRECATED_PUSH
template <class _CharT, class _Traits> template <class _CharT, class _Traits>
class _LIBCPP_TEMPLATE_VIS ostreambuf_iterator class ostreambuf_iterator
#if _LIBCPP_STD_VER <= 14 || !defined(_LIBCPP_ABI_NO_ITERATOR_BASES) #if _LIBCPP_STD_VER <= 14 || !defined(_LIBCPP_ABI_NO_ITERATOR_BASES)
: public iterator<output_iterator_tag, void, void, void, void> : public iterator<output_iterator_tag, void, void, void, void>
#endif #endif
{ {
_LIBCPP_SUPPRESS_DEPRECATED_POP _LIBCPP_SUPPRESS_DEPRECATED_POP
public: public:
typedef output_iterator_tag iterator_category; typedef output_iterator_tag iterator_category;
typedef void value_type; typedef void value_type;
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

libcxx/include/__iterator/reverse_iterator.h

Show First 20 Lines • Show All 42 Lines • ▼ Show 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
_LIBCPP_SUPPRESS_DEPRECATED_PUSH _LIBCPP_SUPPRESS_DEPRECATED_PUSH
template <class _Iter> template <class _Iter>
class _LIBCPP_TEMPLATE_VIS reverse_iterator class reverse_iterator
#if _LIBCPP_STD_VER <= 14 || !defined(_LIBCPP_ABI_NO_ITERATOR_BASES) #if _LIBCPP_STD_VER <= 14 || !defined(_LIBCPP_ABI_NO_ITERATOR_BASES)
: public iterator<typename iterator_traits<_Iter>::iterator_category, : public iterator<typename iterator_traits<_Iter>::iterator_category,
typename iterator_traits<_Iter>::value_type, typename iterator_traits<_Iter>::value_type,
typename iterator_traits<_Iter>::difference_type, typename iterator_traits<_Iter>::difference_type,
typename iterator_traits<_Iter>::pointer, typename iterator_traits<_Iter>::pointer,
typename iterator_traits<_Iter>::reference> typename iterator_traits<_Iter>::reference>
#endif #endif
{ {
▲ Show 20 Lines • Show All 474 Lines • Show Last 20 Lines

libcxx/include/__iterator/wrap_iter.h

Show First 20 Lines • Show All 142 Lines • ▼ Show 20 Lines
#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
} }
template <class _Up> friend class __wrap_iter; template <class _Up> friend class __wrap_iter;
template <class _CharT, class _Traits, class _Alloc> friend class basic_string; template <class _CharT, class _Traits, class _Alloc> friend class basic_string;
template <class _Tp, class _Alloc> friend class _LIBCPP_TEMPLATE_VIS vector; template <class _Tp, class _Alloc> friend class vector;
template <class _Tp, size_t> friend class _LIBCPP_TEMPLATE_VIS span; template <class _Tp, size_t> friend class span;
}; };
template <class _Iter1> template <class _Iter1>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR
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
{ {
return __x.base() == __y.base(); return __x.base() == __y.base();
} }
▲ Show 20 Lines • Show All 103 Lines • ▼ Show 20 Lines
} }
#if _LIBCPP_STD_VER <= 17 #if _LIBCPP_STD_VER <= 17
template <class _It> template <class _It>
struct __libcpp_is_contiguous_iterator<__wrap_iter<_It> > : true_type {}; struct __libcpp_is_contiguous_iterator<__wrap_iter<_It> > : true_type {};
#endif #endif
template <class _It> template <class _It>
struct _LIBCPP_TEMPLATE_VIS pointer_traits<__wrap_iter<_It> > struct pointer_traits<__wrap_iter<_It> >
{ {
typedef __wrap_iter<_It> pointer; typedef __wrap_iter<_It> pointer;
typedef typename pointer_traits<_It>::element_type element_type; typedef typename pointer_traits<_It>::element_type element_type;
typedef typename pointer_traits<_It>::difference_type difference_type; typedef typename pointer_traits<_It>::difference_type difference_type;
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR
static element_type *to_address(pointer __w) _NOEXCEPT { static element_type *to_address(pointer __w) _NOEXCEPT {
return _VSTD::__to_address(__w.base()); return _VSTD::__to_address(__w.base());
} }
}; };
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ITERATOR_WRAP_ITER_H #endif // _LIBCPP___ITERATOR_WRAP_ITER_H

libcxx/include/__locale

Show First 20 Lines • Show All 199 Lines • ▼ Show 20 Lines
use_facet(const locale& __l) use_facet(const locale& __l)
{ {
return static_cast<const _Facet&>(*__l.use_facet(_Facet::id)); return static_cast<const _Facet&>(*__l.use_facet(_Facet::id));
} }
// template <class _CharT> class collate; // template <class _CharT> class collate;
template <class _CharT> template <class _CharT>
class _LIBCPP_TEMPLATE_VIS collate class collate : public locale::facet
: public locale::facet
{ {
public: public:
typedef _CharT char_type; typedef _CharT char_type;
typedef basic_string<char_type> string_type; typedef basic_string<char_type> string_type;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
explicit collate(size_t __refs = 0) explicit collate(size_t __refs = 0)
: locale::facet(__refs) {} : locale::facet(__refs) {}
▲ Show 20 Lines • Show All 71 Lines • ▼ Show 20 Lines
extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS collate<char>; extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS collate<char>;
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS collate<wchar_t>; extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS collate<wchar_t>;
#endif #endif
// template <class CharT> class collate_byname; // template <class CharT> class collate_byname;
template <class _CharT> class _LIBCPP_TEMPLATE_VIS collate_byname; template <class _CharT> class collate_byname;
template <> template <>
class _LIBCPP_TYPE_VIS collate_byname<char> class _LIBCPP_TYPE_VIS collate_byname<char>
: public collate<char> : public collate<char>
{ {
locale_t __l_; locale_t __l_;
public: public:
typedef char char_type; typedef char char_type;
▲ Show 20 Lines • Show All 190 Lines • ▼ Show 20 Lines#endif
_LIBCPP_INLINE_VISIBILITY ctype_base() {} _LIBCPP_INLINE_VISIBILITY ctype_base() {}
static_assert((__regex_word & ~(std::make_unsigned<mask>::type)(space | print | cntrl | upper | lower | alpha | static_assert((__regex_word & ~(std::make_unsigned<mask>::type)(space | print | cntrl | upper | lower | alpha |
digit | punct | xdigit | blank)) == __regex_word, digit | punct | xdigit | blank)) == __regex_word,
"__regex_word can't overlap other bits"); "__regex_word can't overlap other bits");
}; };
template <class _CharT> class _LIBCPP_TEMPLATE_VIS ctype; template <class _CharT>
class ctype;
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
template <> template <>
class _LIBCPP_TYPE_VIS ctype<wchar_t> class _LIBCPP_TYPE_VIS ctype<wchar_t>
: public locale::facet, : public locale::facet,
public ctype_base public ctype_base
{ {
public: public:
▲ Show 20 Lines • Show All 216 Lines • ▼ Show 20 Linesprotected:
virtual char_type do_widen(char __c) const; virtual char_type do_widen(char __c) const;
virtual const char* do_widen(const char* __low, const char* __high, char_type* __to) const; virtual const char* do_widen(const char* __low, const char* __high, char_type* __to) const;
virtual char do_narrow(char_type __c, char __dfault) const; virtual char do_narrow(char_type __c, char __dfault) const;
virtual const char* do_narrow(const char_type* __low, const char_type* __high, char __dfault, char* __to) const; virtual const char* do_narrow(const char_type* __low, const char_type* __high, char __dfault, char* __to) const;
}; };
// template <class CharT> class ctype_byname; // template <class CharT> class ctype_byname;
template <class _CharT> class _LIBCPP_TEMPLATE_VIS ctype_byname; template <class _CharT>
class ctype_byname;
template <> template <>
class _LIBCPP_TYPE_VIS ctype_byname<char> class _LIBCPP_TYPE_VIS ctype_byname<char>
: public ctype<char> : public ctype<char>
{ {
locale_t __l_; locale_t __l_;
public: public:
▲ Show 20 Lines • Show All 151 Lines • ▼ Show 20 Lines
{ {
public: public:
_LIBCPP_INLINE_VISIBILITY codecvt_base() {} _LIBCPP_INLINE_VISIBILITY codecvt_base() {}
enum result {ok, partial, error, noconv}; enum result {ok, partial, error, noconv};
}; };
// template <class internT, class externT, class stateT> class codecvt; // template <class internT, class externT, class stateT> class codecvt;
template <class _InternT, class _ExternT, class _StateT> class _LIBCPP_TEMPLATE_VIS codecvt; template <class _InternT, class _ExternT, class _StateT>
class codecvt;
// template <> class codecvt<char, char, mbstate_t> // template <> class codecvt<char, char, mbstate_t>
template <> template <>
class _LIBCPP_TYPE_VIS codecvt<char, char, mbstate_t> class _LIBCPP_TYPE_VIS codecvt<char, char, mbstate_t>
: public locale::facet, : public locale::facet,
public codecvt_base public codecvt_base
{ {
▲ Show 20 Lines • Show All 511 Lines • ▼ Show 20 Linesprotected:
virtual int do_max_length() const _NOEXCEPT; virtual int do_max_length() const _NOEXCEPT;
}; };
#endif #endif
// template <class _InternT, class _ExternT, class _StateT> class codecvt_byname // template <class _InternT, class _ExternT, class _StateT> class codecvt_byname
template <class _InternT, class _ExternT, class _StateT> template <class _InternT, class _ExternT, class _StateT>
class _LIBCPP_TEMPLATE_VIS codecvt_byname class codecvt_byname : public codecvt<_InternT, _ExternT, _StateT>
: public codecvt<_InternT, _ExternT, _StateT>
{ {
public: public:
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
explicit codecvt_byname(const char* __nm, size_t __refs = 0) explicit codecvt_byname(const char* __nm, size_t __refs = 0)
: codecvt<_InternT, _ExternT, _StateT>(__nm, __refs) {} : codecvt<_InternT, _ExternT, _StateT>(__nm, __refs) {}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
explicit codecvt_byname(const string& __nm, size_t __refs = 0) explicit codecvt_byname(const string& __nm, size_t __refs = 0)
: codecvt<_InternT, _ExternT, _StateT>(__nm.c_str(), __refs) {} : codecvt<_InternT, _ExternT, _StateT>(__nm.c_str(), __refs) {}
▲ Show 20 Lines • Show All 204 Lines • ▼ Show 20 Lines operator()(_OutputIterator __s, const char* __nb, const char* __ne) const
__nb = __nn; __nb = __nn;
} }
return __s; return __s;
} }
}; };
// template <class charT> class numpunct // template <class charT> class numpunct
template <class _CharT> class _LIBCPP_TEMPLATE_VIS numpunct; template <class _CharT> class numpunct;
template <> template <>
class _LIBCPP_TYPE_VIS numpunct<char> class _LIBCPP_TYPE_VIS numpunct<char>
: public locale::facet : public locale::facet
{ {
public: public:
typedef char char_type; typedef char char_type;
typedef basic_string<char_type> string_type; typedef basic_string<char_type> string_type;
▲ Show 20 Lines • Show All 51 Lines • ▼ Show 20 Linesprotected:
char_type __decimal_point_; char_type __decimal_point_;
char_type __thousands_sep_; char_type __thousands_sep_;
string __grouping_; string __grouping_;
}; };
#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS #endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
// template <class charT> class numpunct_byname // template <class charT> class numpunct_byname
template <class _CharT> class _LIBCPP_TEMPLATE_VIS numpunct_byname; template <class _CharT> class numpunct_byname;
template <> template <>
class _LIBCPP_TYPE_VIS numpunct_byname<char> class _LIBCPP_TYPE_VIS numpunct_byname<char>
: public numpunct<char> : public numpunct<char>
{ {
public: public:
typedef char char_type; typedef char char_type;
typedef basic_string<char_type> string_type; typedef basic_string<char_type> string_type;
Show All 34 Lines

libcxx/include/__memory/allocator.h

Show All 28 Lines
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp> class allocator; template <class _Tp> class allocator;
#if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_VOID_SPECIALIZATION) #if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_VOID_SPECIALIZATION)
// These specializations shouldn't be marked _LIBCPP_DEPRECATED_IN_CXX17. // These specializations shouldn't be marked _LIBCPP_DEPRECATED_IN_CXX17.
// Specializing allocator<void> is deprecated, but not using it. // Specializing allocator<void> is deprecated, but not using it.
template <> template <>
class _LIBCPP_TEMPLATE_VIS allocator<void> class allocator<void>
{ {
#if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS) #if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS)
public: public:
_LIBCPP_DEPRECATED_IN_CXX17 typedef void* pointer; _LIBCPP_DEPRECATED_IN_CXX17 typedef void* pointer;
_LIBCPP_DEPRECATED_IN_CXX17 typedef const void* const_pointer; _LIBCPP_DEPRECATED_IN_CXX17 typedef const void* const_pointer;
_LIBCPP_DEPRECATED_IN_CXX17 typedef void value_type; _LIBCPP_DEPRECATED_IN_CXX17 typedef void value_type;
template <class _Up> struct _LIBCPP_DEPRECATED_IN_CXX17 rebind {typedef allocator<_Up> other;}; template <class _Up> struct _LIBCPP_DEPRECATED_IN_CXX17 rebind {typedef allocator<_Up> other;};
#endif #endif
}; };
template <> template <>
class _LIBCPP_TEMPLATE_VIS allocator<const void> class allocator<const void>
{ {
#if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS) #if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS)
public: public:
_LIBCPP_DEPRECATED_IN_CXX17 typedef const void* pointer; _LIBCPP_DEPRECATED_IN_CXX17 typedef const void* pointer;
_LIBCPP_DEPRECATED_IN_CXX17 typedef const void* const_pointer; _LIBCPP_DEPRECATED_IN_CXX17 typedef const void* const_pointer;
_LIBCPP_DEPRECATED_IN_CXX17 typedef const void value_type; _LIBCPP_DEPRECATED_IN_CXX17 typedef const void value_type;
template <class _Up> struct _LIBCPP_DEPRECATED_IN_CXX17 rebind {typedef allocator<_Up> other;}; template <class _Up> struct _LIBCPP_DEPRECATED_IN_CXX17 rebind {typedef allocator<_Up> other;};
Show All 23 Lines
}; };
// allocator // allocator
// //
// Note: For ABI compatibility between C++20 and previous standards, we make // Note: For ABI compatibility between C++20 and previous standards, we make
// allocator<void> trivial in C++20. // allocator<void> trivial in C++20.
template <class _Tp> template <class _Tp>
class _LIBCPP_TEMPLATE_VIS allocator class allocator : private __non_trivial_if<!is_void<_Tp>::value, allocator<_Tp> >
: private __non_trivial_if<!is_void<_Tp>::value, allocator<_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 _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;
▲ Show 20 Lines • Show All 70 Lines • ▼ Show 20 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> template <class _Tp>
class _LIBCPP_TEMPLATE_VIS allocator<const _Tp> class allocator<const _Tp> : private __non_trivial_if<!is_void<_Tp>::value, allocator<const _Tp> >
: private __non_trivial_if<!is_void<_Tp>::value, 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;
▲ Show 20 Lines • Show All 84 Lines • Show Last 20 Lines

libcxx/include/__memory/allocator_arg_t.h

Show All 17 Lines
#include <__utility/forward.h> #include <__utility/forward.h>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
struct _LIBCPP_TEMPLATE_VIS allocator_arg_t { explicit allocator_arg_t() = default; }; struct allocator_arg_t { explicit allocator_arg_t() = default; };
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
inline constexpr allocator_arg_t allocator_arg = allocator_arg_t(); inline constexpr allocator_arg_t allocator_arg = allocator_arg_t();
#elif !defined(_LIBCPP_CXX03_LANG) #elif !defined(_LIBCPP_CXX03_LANG)
constexpr allocator_arg_t allocator_arg = allocator_arg_t(); constexpr allocator_arg_t allocator_arg = allocator_arg_t();
#endif #endif
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

libcxx/include/__memory/allocator_traits.h

Show First 20 Lines • Show All 226 Lines • ▼ Show 20 Lines
template <class _Alloc> template <class _Alloc>
struct __has_select_on_container_copy_construction<_Alloc, decltype( struct __has_select_on_container_copy_construction<_Alloc, decltype(
(void)std::declval<_Alloc>().select_on_container_copy_construction() (void)std::declval<_Alloc>().select_on_container_copy_construction()
)> : true_type { }; )> : true_type { };
_LIBCPP_SUPPRESS_DEPRECATED_POP _LIBCPP_SUPPRESS_DEPRECATED_POP
template <class _Alloc> template <class _Alloc>
struct _LIBCPP_TEMPLATE_VIS allocator_traits struct allocator_traits
{ {
using allocator_type = _Alloc; using allocator_type = _Alloc;
using value_type = typename allocator_type::value_type; using value_type = typename allocator_type::value_type;
using pointer = typename __pointer<value_type, allocator_type>::type; using pointer = typename __pointer<value_type, allocator_type>::type;
using const_pointer = typename __const_pointer<value_type, pointer, allocator_type>::type; using const_pointer = typename __const_pointer<value_type, pointer, allocator_type>::type;
using void_pointer = typename __void_pointer<pointer, allocator_type>::type; using void_pointer = typename __void_pointer<pointer, allocator_type>::type;
using const_void_pointer = typename __const_void_pointer<pointer, allocator_type>::type; using const_void_pointer = typename __const_void_pointer<pointer, allocator_type>::type;
using difference_type = typename __alloc_traits_difference_type<allocator_type, pointer>::type; using difference_type = typename __alloc_traits_difference_type<allocator_type, pointer>::type;
▲ Show 20 Lines • Show All 186 Lines • Show Last 20 Lines

libcxx/include/__memory/auto_ptr.h

Show All 21 Lines
template <class _Tp> template <class _Tp>
struct _LIBCPP_DEPRECATED_IN_CXX11 auto_ptr_ref struct _LIBCPP_DEPRECATED_IN_CXX11 auto_ptr_ref
{ {
_Tp* __ptr_; _Tp* __ptr_;
}; };
template<class _Tp> template<class _Tp>
class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 auto_ptr class _LIBCPP_DEPRECATED_IN_CXX11 auto_ptr
{ {
private: private:
_Tp* __ptr_; _Tp* __ptr_;
public: public:
typedef _Tp element_type; typedef _Tp element_type;
_LIBCPP_INLINE_VISIBILITY explicit auto_ptr(_Tp* __p = 0) _NOEXCEPT : __ptr_(__p) {} _LIBCPP_INLINE_VISIBILITY explicit auto_ptr(_Tp* __p = 0) _NOEXCEPT : __ptr_(__p) {}
_LIBCPP_INLINE_VISIBILITY auto_ptr(auto_ptr& __p) _NOEXCEPT : __ptr_(__p.release()) {} _LIBCPP_INLINE_VISIBILITY auto_ptr(auto_ptr& __p) _NOEXCEPT : __ptr_(__p.release()) {}
Show All 27 Linespublic:
_LIBCPP_INLINE_VISIBILITY auto_ptr(auto_ptr_ref<_Tp> __p) _NOEXCEPT : __ptr_(__p.__ptr_) {} _LIBCPP_INLINE_VISIBILITY auto_ptr(auto_ptr_ref<_Tp> __p) _NOEXCEPT : __ptr_(__p.__ptr_) {}
template<class _Up> _LIBCPP_INLINE_VISIBILITY operator auto_ptr_ref<_Up>() _NOEXCEPT template<class _Up> _LIBCPP_INLINE_VISIBILITY operator auto_ptr_ref<_Up>() _NOEXCEPT
{auto_ptr_ref<_Up> __t; __t.__ptr_ = release(); return __t;} {auto_ptr_ref<_Up> __t; __t.__ptr_ = release(); return __t;}
template<class _Up> _LIBCPP_INLINE_VISIBILITY operator auto_ptr<_Up>() _NOEXCEPT template<class _Up> _LIBCPP_INLINE_VISIBILITY operator auto_ptr<_Up>() _NOEXCEPT
{return auto_ptr<_Up>(release());} {return auto_ptr<_Up>(release());}
}; };
template <> template <>
class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 auto_ptr<void> class _LIBCPP_DEPRECATED_IN_CXX11 auto_ptr<void>
{ {
public: public:
typedef void element_type; typedef void element_type;
}; };
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR) #endif // _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR)
#endif // _LIBCPP___MEMORY_AUTO_PTR_H #endif // _LIBCPP___MEMORY_AUTO_PTR_H

libcxx/include/__memory/pointer_traits.h

Show First 20 Lines • Show All 106 Lines • ▼ Show 20 Lines
template <template <class, class...> class _Sp, class _Tp, class ..._Args, class _Up> template <template <class, class...> class _Sp, class _Tp, class ..._Args, class _Up>
struct __pointer_traits_rebind<_Sp<_Tp, _Args...>, _Up, false> struct __pointer_traits_rebind<_Sp<_Tp, _Args...>, _Up, false>
{ {
typedef _Sp<_Up, _Args...> type; typedef _Sp<_Up, _Args...> type;
}; };
template <class _Ptr> template <class _Ptr>
struct _LIBCPP_TEMPLATE_VIS pointer_traits struct pointer_traits
{ {
typedef _Ptr pointer; typedef _Ptr pointer;
typedef typename __pointer_traits_element_type<pointer>::type element_type; typedef typename __pointer_traits_element_type<pointer>::type element_type;
typedef typename __pointer_traits_difference_type<pointer>::type difference_type; typedef typename __pointer_traits_difference_type<pointer>::type difference_type;
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
template <class _Up> using rebind = typename __pointer_traits_rebind<pointer, _Up>::type; template <class _Up> using rebind = typename __pointer_traits_rebind<pointer, _Up>::type;
#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_SINCE_CXX20 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
static pointer pointer_to(__conditional_t<is_void<element_type>::value, __nat, element_type>& __r) static pointer pointer_to(__conditional_t<is_void<element_type>::value, __nat, element_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 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
▲ Show 20 Lines • Show All 97 Lines • Show Last 20 Lines

libcxx/include/__memory/raw_storage_iterator.h

Show All 22 Lines
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_RAW_STORAGE_ITERATOR) #if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_RAW_STORAGE_ITERATOR)
_LIBCPP_SUPPRESS_DEPRECATED_PUSH _LIBCPP_SUPPRESS_DEPRECATED_PUSH
template <class _OutputIterator, class _Tp> template <class _OutputIterator, class _Tp>
class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX17 raw_storage_iterator class _LIBCPP_DEPRECATED_IN_CXX17 raw_storage_iterator
#if _LIBCPP_STD_VER <= 14 || !defined(_LIBCPP_ABI_NO_ITERATOR_BASES) #if _LIBCPP_STD_VER <= 14 || !defined(_LIBCPP_ABI_NO_ITERATOR_BASES)
: public iterator<output_iterator_tag, void, void, void, void> : public iterator<output_iterator_tag, void, void, void, void>
#endif #endif
{ {
_LIBCPP_SUPPRESS_DEPRECATED_POP _LIBCPP_SUPPRESS_DEPRECATED_POP
private: private:
_OutputIterator __x_; _OutputIterator __x_;
public: public:
Show All 31 Lines

libcxx/include/__memory/shared_ptr.h

Show First 20 Lines • Show All 134 Lines • ▼ Show 20 Lines
{ {
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
throw bad_weak_ptr(); throw bad_weak_ptr();
#else #else
_LIBCPP_VERBOSE_ABORT("bad_weak_ptr was thrown in -fno-exceptions mode"); _LIBCPP_VERBOSE_ABORT("bad_weak_ptr was thrown in -fno-exceptions mode");
#endif #endif
} }
template<class _Tp> class _LIBCPP_TEMPLATE_VIS weak_ptr; template<class _Tp> class weak_ptr;
class _LIBCPP_TYPE_VIS __shared_count class _LIBCPP_TYPE_VIS __shared_count
{ {
__shared_count(const __shared_count&); __shared_count(const __shared_count&);
__shared_count& operator=(const __shared_count&); __shared_count& operator=(const __shared_count&);
protected: protected:
long __shared_owners_; long __shared_owners_;
▲ Show 20 Lines • Show All 215 Lines • ▼ Show 20 Lines#endif
static_assert(_LIBCPP_ALIGNOF(_Storage) == _LIBCPP_ALIGNOF(_CompressedPair), ""); static_assert(_LIBCPP_ALIGNOF(_Storage) == _LIBCPP_ALIGNOF(_CompressedPair), "");
static_assert(sizeof(_Storage) == sizeof(_CompressedPair), ""); static_assert(sizeof(_Storage) == sizeof(_CompressedPair), "");
_Storage __storage_; _Storage __storage_;
}; };
struct __shared_ptr_dummy_rebind_allocator_type; struct __shared_ptr_dummy_rebind_allocator_type;
template <> template <>
class _LIBCPP_TEMPLATE_VIS allocator<__shared_ptr_dummy_rebind_allocator_type> class allocator<__shared_ptr_dummy_rebind_allocator_type>
{ {
public: public:
template <class _Other> template <class _Other>
struct rebind struct rebind
{ {
typedef allocator<_Other> other; typedef allocator<_Other> other;
}; };
}; };
template<class _Tp> class _LIBCPP_TEMPLATE_VIS enable_shared_from_this; template<class _Tp> class enable_shared_from_this;
// http://eel.is/c++draft/util.sharedptr#util.smartptr.shared.general-6 // http://eel.is/c++draft/util.sharedptr#util.smartptr.shared.general-6
// A pointer type Y* is said to be compatible with a pointer type T* // A pointer type Y* is said to be compatible with a pointer type T*
// when either Y* is convertible to T* or Y is U[N] and T is cv U[]. // when either Y* is convertible to T* or Y is U[N] and T is cv U[].
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <class _Yp, class _Tp> template <class _Yp, class _Tp>
struct __bounded_convertible_to_unbounded : false_type {}; struct __bounded_convertible_to_unbounded : false_type {};
▲ Show 20 Lines • Show All 72 Lines • ▼ Show 20 Lines
#if defined(_LIBCPP_ABI_ENABLE_SHARED_PTR_TRIVIAL_ABI) #if defined(_LIBCPP_ABI_ENABLE_SHARED_PTR_TRIVIAL_ABI)
# define _LIBCPP_SHARED_PTR_TRIVIAL_ABI __attribute__((__trivial_abi__)) # define _LIBCPP_SHARED_PTR_TRIVIAL_ABI __attribute__((__trivial_abi__))
#else #else
# define _LIBCPP_SHARED_PTR_TRIVIAL_ABI # define _LIBCPP_SHARED_PTR_TRIVIAL_ABI
#endif #endif
template<class _Tp> template<class _Tp>
class _LIBCPP_SHARED_PTR_TRIVIAL_ABI _LIBCPP_TEMPLATE_VIS shared_ptr class _LIBCPP_SHARED_PTR_TRIVIAL_ABI shared_ptr
{ {
public: public:
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
typedef weak_ptr<_Tp> weak_type; typedef weak_ptr<_Tp> weak_type;
typedef remove_extent_t<_Tp> element_type; typedef remove_extent_t<_Tp> element_type;
#else #else
typedef _Tp element_type; typedef _Tp element_type;
#endif #endif
▲ Show 20 Lines • Show All 498 Lines • ▼ Show 20 Lines struct __shared_ptr_default_delete<_Yp[_Sz], _Un>
: default_delete<_Yp[]> : default_delete<_Yp[]>
{ }; { };
template <class _Yp, class _Un> template <class _Yp, class _Un>
struct __shared_ptr_default_delete<_Yp[], _Un> struct __shared_ptr_default_delete<_Yp[], _Un>
: default_delete<_Yp[]> : default_delete<_Yp[]>
{ }; { };
template <class _Up> friend class _LIBCPP_TEMPLATE_VIS shared_ptr; template <class _Up> friend class shared_ptr;
template <class _Up> friend class _LIBCPP_TEMPLATE_VIS weak_ptr; template <class _Up> friend class weak_ptr;
}; };
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template<class _Tp> template<class _Tp>
shared_ptr(weak_ptr<_Tp>) -> shared_ptr<_Tp>; shared_ptr(weak_ptr<_Tp>) -> shared_ptr<_Tp>;
template<class _Tp, class _Dp> template<class _Tp, class _Dp>
shared_ptr(unique_ptr<_Tp, _Dp>) -> shared_ptr<_Tp>; shared_ptr(unique_ptr<_Tp, _Dp>) -> shared_ptr<_Tp>;
#endif #endif
▲ Show 20 Lines • Show All 555 Lines • ▼ Show 20 Lines
get_deleter(const shared_ptr<_Tp>& __p) _NOEXCEPT get_deleter(const shared_ptr<_Tp>& __p) _NOEXCEPT
{ {
return __p.template __get_deleter<_Dp>(); return __p.template __get_deleter<_Dp>();
} }
#endif // _LIBCPP_HAS_NO_RTTI #endif // _LIBCPP_HAS_NO_RTTI
template<class _Tp> template<class _Tp>
class _LIBCPP_SHARED_PTR_TRIVIAL_ABI _LIBCPP_TEMPLATE_VIS weak_ptr class _LIBCPP_SHARED_PTR_TRIVIAL_ABI weak_ptr
{ {
public: public:
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
typedef remove_extent_t<_Tp> element_type; typedef remove_extent_t<_Tp> element_type;
#else #else
typedef _Tp element_type; typedef _Tp element_type;
#endif #endif
▲ Show 20 Lines • Show All 67 Lines • ▼ Show 20 Lines template<class _Up>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
bool owner_before(const shared_ptr<_Up>& __r) const _NOEXCEPT bool owner_before(const shared_ptr<_Up>& __r) const _NOEXCEPT
{return __cntrl_ < __r.__cntrl_;} {return __cntrl_ < __r.__cntrl_;}
template<class _Up> template<class _Up>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
bool owner_before(const weak_ptr<_Up>& __r) const _NOEXCEPT bool owner_before(const weak_ptr<_Up>& __r) const _NOEXCEPT
{return __cntrl_ < __r.__cntrl_;} {return __cntrl_ < __r.__cntrl_;}
template <class _Up> friend class _LIBCPP_TEMPLATE_VIS weak_ptr; template <class _Up> friend class weak_ptr;
template <class _Up> friend class _LIBCPP_TEMPLATE_VIS shared_ptr; template <class _Up> friend class shared_ptr;
}; };
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template<class _Tp> template<class _Tp>
weak_ptr(shared_ptr<_Tp>) -> weak_ptr<_Tp>; weak_ptr(shared_ptr<_Tp>) -> weak_ptr<_Tp>;
#endif #endif
template<class _Tp> template<class _Tp>
▲ Show 20 Lines • Show All 170 Lines • ▼ Show 20 Lines
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <class _Tp = void> struct owner_less; template <class _Tp = void> struct owner_less;
#else #else
template <class _Tp> struct owner_less; template <class _Tp> struct owner_less;
#endif #endif
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS owner_less<shared_ptr<_Tp> > struct owner_less<shared_ptr<_Tp> > : __binary_function<shared_ptr<_Tp>, shared_ptr<_Tp>, bool>
: __binary_function<shared_ptr<_Tp>, shared_ptr<_Tp>, bool>
{ {
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
bool operator()(shared_ptr<_Tp> const& __x, shared_ptr<_Tp> const& __y) const _NOEXCEPT bool operator()(shared_ptr<_Tp> const& __x, shared_ptr<_Tp> const& __y) const _NOEXCEPT
{return __x.owner_before(__y);} {return __x.owner_before(__y);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
bool operator()(shared_ptr<_Tp> const& __x, weak_ptr<_Tp> const& __y) const _NOEXCEPT bool operator()(shared_ptr<_Tp> const& __x, weak_ptr<_Tp> const& __y) const _NOEXCEPT
{return __x.owner_before(__y);} {return __x.owner_before(__y);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
bool operator()( weak_ptr<_Tp> const& __x, shared_ptr<_Tp> const& __y) const _NOEXCEPT bool operator()( weak_ptr<_Tp> const& __x, shared_ptr<_Tp> const& __y) const _NOEXCEPT
{return __x.owner_before(__y);} {return __x.owner_before(__y);}
}; };
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS owner_less<weak_ptr<_Tp> > struct owner_less<weak_ptr<_Tp> > : __binary_function<weak_ptr<_Tp>, weak_ptr<_Tp>, bool>
: __binary_function<weak_ptr<_Tp>, weak_ptr<_Tp>, bool>
{ {
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
bool operator()( weak_ptr<_Tp> const& __x, weak_ptr<_Tp> const& __y) const _NOEXCEPT bool operator()( weak_ptr<_Tp> const& __x, weak_ptr<_Tp> const& __y) const _NOEXCEPT
{return __x.owner_before(__y);} {return __x.owner_before(__y);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
bool operator()(shared_ptr<_Tp> const& __x, weak_ptr<_Tp> const& __y) const _NOEXCEPT bool operator()(shared_ptr<_Tp> const& __x, weak_ptr<_Tp> const& __y) const _NOEXCEPT
{return __x.owner_before(__y);} {return __x.owner_before(__y);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
bool operator()( weak_ptr<_Tp> const& __x, shared_ptr<_Tp> const& __y) const _NOEXCEPT bool operator()( weak_ptr<_Tp> const& __x, shared_ptr<_Tp> const& __y) const _NOEXCEPT
{return __x.owner_before(__y);} {return __x.owner_before(__y);}
}; };
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <> template <>
struct _LIBCPP_TEMPLATE_VIS owner_less<void> struct owner_less<void>
{ {
template <class _Tp, class _Up> template <class _Tp, class _Up>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
bool operator()( shared_ptr<_Tp> const& __x, shared_ptr<_Up> const& __y) const _NOEXCEPT bool operator()( shared_ptr<_Tp> const& __x, shared_ptr<_Up> const& __y) const _NOEXCEPT
{return __x.owner_before(__y);} {return __x.owner_before(__y);}
template <class _Tp, class _Up> template <class _Tp, class _Up>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
bool operator()( shared_ptr<_Tp> const& __x, weak_ptr<_Up> const& __y) const _NOEXCEPT bool operator()( shared_ptr<_Tp> const& __x, weak_ptr<_Up> const& __y) const _NOEXCEPT
{return __x.owner_before(__y);} {return __x.owner_before(__y);}
template <class _Tp, class _Up> template <class _Tp, class _Up>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
bool operator()( weak_ptr<_Tp> const& __x, shared_ptr<_Up> const& __y) const _NOEXCEPT bool operator()( weak_ptr<_Tp> const& __x, shared_ptr<_Up> const& __y) const _NOEXCEPT
{return __x.owner_before(__y);} {return __x.owner_before(__y);}
template <class _Tp, class _Up> template <class _Tp, class _Up>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
bool operator()( weak_ptr<_Tp> const& __x, weak_ptr<_Up> const& __y) const _NOEXCEPT bool operator()( weak_ptr<_Tp> const& __x, weak_ptr<_Up> const& __y) const _NOEXCEPT
{return __x.owner_before(__y);} {return __x.owner_before(__y);}
typedef void is_transparent; typedef void is_transparent;
}; };
#endif #endif
template<class _Tp> template<class _Tp>
class _LIBCPP_TEMPLATE_VIS enable_shared_from_this class enable_shared_from_this
{ {
mutable weak_ptr<_Tp> __weak_this_; mutable weak_ptr<_Tp> __weak_this_;
protected: protected:
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
enable_shared_from_this() _NOEXCEPT {} enable_shared_from_this() _NOEXCEPT {}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
enable_shared_from_this(enable_shared_from_this const&) _NOEXCEPT {} enable_shared_from_this(enable_shared_from_this const&) _NOEXCEPT {}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
Show All 17 Lines#if _LIBCPP_STD_VER >= 17
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
weak_ptr<const _Tp> weak_from_this() const _NOEXCEPT weak_ptr<const _Tp> weak_from_this() const _NOEXCEPT
{ return __weak_this_; } { return __weak_this_; }
#endif // _LIBCPP_STD_VER >= 17 #endif // _LIBCPP_STD_VER >= 17
template <class _Up> friend class shared_ptr; template <class _Up> friend class shared_ptr;
}; };
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS hash; template <class _Tp> struct hash;
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS hash<shared_ptr<_Tp> > struct hash<shared_ptr<_Tp> >
{ {
#if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS) #if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS)
_LIBCPP_DEPRECATED_IN_CXX17 typedef shared_ptr<_Tp> argument_type; _LIBCPP_DEPRECATED_IN_CXX17 typedef shared_ptr<_Tp> argument_type;
_LIBCPP_DEPRECATED_IN_CXX17 typedef size_t result_type; _LIBCPP_DEPRECATED_IN_CXX17 typedef size_t result_type;
#endif #endif
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
size_t operator()(const shared_ptr<_Tp>& __ptr) const _NOEXCEPT size_t operator()(const shared_ptr<_Tp>& __ptr) const _NOEXCEPT
▲ Show 20 Lines • Show All 156 Lines • Show Last 20 Lines

libcxx/include/__memory/unique_ptr.h

Show First 20 Lines • Show All 41 Lines • ▼ Show 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 _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS default_delete { struct default_delete {
static_assert(!is_function<_Tp>::value, static_assert(!is_function<_Tp>::value,
"default_delete cannot be instantiated for function types"); "default_delete cannot be instantiated for function types");
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
_LIBCPP_INLINE_VISIBILITY constexpr default_delete() _NOEXCEPT = default; _LIBCPP_INLINE_VISIBILITY constexpr default_delete() _NOEXCEPT = default;
#else #else
_LIBCPP_INLINE_VISIBILITY default_delete() {} _LIBCPP_INLINE_VISIBILITY default_delete() {}
#endif #endif
template <class _Up> template <class _Up>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 default_delete( _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 default_delete(
const default_delete<_Up>&, typename enable_if<is_convertible<_Up*, _Tp*>::value>::type* = 0) _NOEXCEPT {} const default_delete<_Up>&, typename enable_if<is_convertible<_Up*, _Tp*>::value>::type* = 0) _NOEXCEPT {}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 void operator()(_Tp* __ptr) const _NOEXCEPT { _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 void operator()(_Tp* __ptr) const _NOEXCEPT {
static_assert(sizeof(_Tp) >= 0, "cannot delete an incomplete type"); static_assert(sizeof(_Tp) >= 0, "cannot delete an incomplete type");
static_assert(!is_void<_Tp>::value, "cannot delete an incomplete type"); static_assert(!is_void<_Tp>::value, "cannot delete an incomplete type");
delete __ptr; delete __ptr;
} }
}; };
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS default_delete<_Tp[]> { struct default_delete<_Tp[]> {
private: private:
template <class _Up> template <class _Up>
struct _EnableIfConvertible struct _EnableIfConvertible
: enable_if<is_convertible<_Up(*)[], _Tp(*)[]>::value> {}; : enable_if<is_convertible<_Up(*)[], _Tp(*)[]>::value> {};
public: public:
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
_LIBCPP_INLINE_VISIBILITY constexpr default_delete() _NOEXCEPT = default; _LIBCPP_INLINE_VISIBILITY constexpr default_delete() _NOEXCEPT = default;
Show All 37 Lines
#if defined(_LIBCPP_ABI_ENABLE_UNIQUE_PTR_TRIVIAL_ABI) #if defined(_LIBCPP_ABI_ENABLE_UNIQUE_PTR_TRIVIAL_ABI)
# define _LIBCPP_UNIQUE_PTR_TRIVIAL_ABI __attribute__((__trivial_abi__)) # define _LIBCPP_UNIQUE_PTR_TRIVIAL_ABI __attribute__((__trivial_abi__))
#else #else
# define _LIBCPP_UNIQUE_PTR_TRIVIAL_ABI # define _LIBCPP_UNIQUE_PTR_TRIVIAL_ABI
#endif #endif
template <class _Tp, class _Dp = default_delete<_Tp> > template <class _Tp, class _Dp = default_delete<_Tp> >
class _LIBCPP_UNIQUE_PTR_TRIVIAL_ABI _LIBCPP_TEMPLATE_VIS unique_ptr { class _LIBCPP_UNIQUE_PTR_TRIVIAL_ABI unique_ptr {
public: public:
typedef _Tp element_type; typedef _Tp element_type;
typedef _Dp deleter_type; typedef _Dp deleter_type;
typedef _LIBCPP_NODEBUG typename __pointer<_Tp, deleter_type>::type pointer; typedef _LIBCPP_NODEBUG typename __pointer<_Tp, deleter_type>::type pointer;
static_assert(!is_rvalue_reference<deleter_type>::value, static_assert(!is_rvalue_reference<deleter_type>::value,
"the specified deleter type cannot be an rvalue reference"); "the specified deleter type cannot be an rvalue reference");
▲ Show 20 Lines • Show All 166 Lines • ▼ Show 20 Lines#endif
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 void swap(unique_ptr& __u) _NOEXCEPT { _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 void swap(unique_ptr& __u) _NOEXCEPT {
__ptr_.swap(__u.__ptr_); __ptr_.swap(__u.__ptr_);
} }
}; };
template <class _Tp, class _Dp> template <class _Tp, class _Dp>
class _LIBCPP_UNIQUE_PTR_TRIVIAL_ABI _LIBCPP_TEMPLATE_VIS unique_ptr<_Tp[], _Dp> { class _LIBCPP_UNIQUE_PTR_TRIVIAL_ABI unique_ptr<_Tp[], _Dp> {
public: public:
typedef _Tp element_type; typedef _Tp element_type;
typedef _Dp deleter_type; typedef _Dp deleter_type;
typedef typename __pointer<_Tp, deleter_type>::type pointer; typedef typename __pointer<_Tp, deleter_type>::type pointer;
private: private:
__compressed_pair<pointer, deleter_type> __ptr_; __compressed_pair<pointer, deleter_type> __ptr_;
▲ Show 20 Lines • Show All 397 Lines • ▼ Show 20 Linesmake_unique_for_overwrite(size_t __n) {
return unique_ptr<_Tp>(new __remove_extent_t<_Tp>[__n]); return unique_ptr<_Tp>(new __remove_extent_t<_Tp>[__n]);
} }
template<class _Tp, class... _Args> template<class _Tp, class... _Args>
typename __unique_if<_Tp>::__unique_array_known_bound make_unique_for_overwrite(_Args&&...) = delete; typename __unique_if<_Tp>::__unique_array_known_bound make_unique_for_overwrite(_Args&&...) = delete;
#endif // _LIBCPP_STD_VER >= 20 #endif // _LIBCPP_STD_VER >= 20
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS hash; template <class _Tp> struct hash;
template <class _Tp, class _Dp> template <class _Tp, class _Dp>
#ifdef _LIBCPP_CXX03_LANG #ifdef _LIBCPP_CXX03_LANG
struct _LIBCPP_TEMPLATE_VIS hash<unique_ptr<_Tp, _Dp> > struct hash<unique_ptr<_Tp, _Dp> >
#else #else
struct _LIBCPP_TEMPLATE_VIS hash<__enable_hash_helper< struct hash<__enable_hash_helper<
unique_ptr<_Tp, _Dp>, typename unique_ptr<_Tp, _Dp>::pointer> > unique_ptr<_Tp, _Dp>, typename unique_ptr<_Tp, _Dp>::pointer> >
#endif #endif
{ {
#if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS) #if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS)
_LIBCPP_DEPRECATED_IN_CXX17 typedef unique_ptr<_Tp, _Dp> argument_type; _LIBCPP_DEPRECATED_IN_CXX17 typedef unique_ptr<_Tp, _Dp> argument_type;
_LIBCPP_DEPRECATED_IN_CXX17 typedef size_t result_type; _LIBCPP_DEPRECATED_IN_CXX17 typedef size_t result_type;
#endif #endif
Show All 11 Lines

libcxx/include/__memory/uses_allocator.h

Show All 38 Lines
template <class _Tp, class _Alloc> template <class _Tp, class _Alloc>
struct __uses_allocator<_Tp, _Alloc, false> struct __uses_allocator<_Tp, _Alloc, false>
: public false_type : public false_type
{ {
}; };
template <class _Tp, class _Alloc> template <class _Tp, class _Alloc>
struct _LIBCPP_TEMPLATE_VIS uses_allocator struct uses_allocator : public __uses_allocator<_Tp, _Alloc> {};
: public __uses_allocator<_Tp, _Alloc>
{
};
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <class _Tp, class _Alloc> template <class _Tp, class _Alloc>
inline constexpr bool uses_allocator_v = uses_allocator<_Tp, _Alloc>::value; inline constexpr bool uses_allocator_v = uses_allocator<_Tp, _Alloc>::value;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___MEMORY_USES_ALLOCATOR_H #endif // _LIBCPP___MEMORY_USES_ALLOCATOR_H

libcxx/include/__memory_resource/polymorphic_allocator.h

Show All 33 Lines
// [mem.poly.allocator.class] // [mem.poly.allocator.class]
template <class _ValueType template <class _ValueType
# if _LIBCPP_STD_VER >= 20 # if _LIBCPP_STD_VER >= 20
= byte = byte
# endif # endif
> >
class _LIBCPP_TEMPLATE_VIS polymorphic_allocator { class polymorphic_allocator {
public: public:
using value_type = _ValueType; using value_type = _ValueType;
// [mem.poly.allocator.ctor] // [mem.poly.allocator.ctor]
_LIBCPP_HIDE_FROM_ABI polymorphic_allocator() noexcept : __res_(std::pmr::get_default_resource()) {} _LIBCPP_HIDE_FROM_ABI polymorphic_allocator() noexcept : __res_(std::pmr::get_default_resource()) {}
▲ Show 20 Lines • Show All 174 Lines • Show Last 20 Lines

libcxx/include/__mutex/lock_guard.h

Show All 15 Lines
# pragma GCC system_header # pragma GCC system_header
#endif #endif
#ifndef _LIBCPP_HAS_NO_THREADS #ifndef _LIBCPP_HAS_NO_THREADS
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Mutex> template <class _Mutex>
class _LIBCPP_TEMPLATE_VIS _LIBCPP_THREAD_SAFETY_ANNOTATION(scoped_lockable) lock_guard { class _LIBCPP_THREAD_SAFETY_ANNOTATION(scoped_lockable) lock_guard {
public: public:
typedef _Mutex mutex_type; typedef _Mutex mutex_type;
private: private:
mutex_type& __m_; mutex_type& __m_;
public: public:
_LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI explicit lock_guard(mutex_type& __m) _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI explicit lock_guard(mutex_type& __m)
Show All 21 Lines

libcxx/include/__mutex/unique_lock.h

Show All 21 Lines
# pragma GCC system_header # pragma GCC system_header
#endif #endif
#ifndef _LIBCPP_HAS_NO_THREADS #ifndef _LIBCPP_HAS_NO_THREADS
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Mutex> template <class _Mutex>
class _LIBCPP_TEMPLATE_VIS unique_lock { class unique_lock {
public: public:
typedef _Mutex mutex_type; typedef _Mutex mutex_type;
private: private:
mutex_type* __m_; mutex_type* __m_;
bool __owns_; bool __owns_;
public: public:
▲ Show 20 Lines • Show All 135 Lines • Show Last 20 Lines

libcxx/include/__node_handle

Show First 20 Lines • Show All 72 Lines • ▼ Show 20 Lines
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
// Specialized in __tree & __hash_table for their _NodeType. // Specialized in __tree & __hash_table for their _NodeType.
template <class _NodeType, class _Alloc> template <class _NodeType, class _Alloc>
struct __generic_container_node_destructor; struct __generic_container_node_destructor;
template <class _NodeType, class _Alloc, template <class _NodeType, class _Alloc,
template <class, class> class _MapOrSetSpecifics> template <class, class> class _MapOrSetSpecifics>
class _LIBCPP_TEMPLATE_VIS __basic_node_handle class __basic_node_handle
: public _MapOrSetSpecifics< : public _MapOrSetSpecifics<
_NodeType, _NodeType,
__basic_node_handle<_NodeType, _Alloc, _MapOrSetSpecifics>> __basic_node_handle<_NodeType, _Alloc, _MapOrSetSpecifics>>
{ {
template <class _Tp, class _Compare, class _Allocator> template <class _Tp, class _Compare, class _Allocator>
friend class __tree; friend class __tree;
template <class _Tp, class _Hash, class _Equal, class _Allocator> template <class _Tp, class _Hash, class _Equal, class _Allocator>
friend class __hash_table; friend class __hash_table;
▲ Show 20 Lines • Show All 145 Lines • ▼ Show 20 Lines
using __set_node_handle = using __set_node_handle =
__basic_node_handle< _NodeType, _Alloc, __set_node_handle_specifics>; __basic_node_handle< _NodeType, _Alloc, __set_node_handle_specifics>;
template <class _NodeType, class _Alloc> template <class _NodeType, class _Alloc>
using __map_node_handle = using __map_node_handle =
__basic_node_handle< _NodeType, _Alloc, __map_node_handle_specifics>; __basic_node_handle< _NodeType, _Alloc, __map_node_handle_specifics>;
template <class _Iterator, class _NodeType> template <class _Iterator, class _NodeType>
struct _LIBCPP_TEMPLATE_VIS __insert_return_type struct __insert_return_type
{ {
_Iterator position; _Iterator position;
bool inserted; bool inserted;
_NodeType node; _NodeType node;
}; };
#endif // _LIBCPP_STD_VER >= 17 #endif // _LIBCPP_STD_VER >= 17
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___NODE_HANDLE #endif // _LIBCPP___NODE_HANDLE

libcxx/include/__random/bernoulli_distribution.h

Show All 17 Lines
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_PUSH_MACROS _LIBCPP_PUSH_MACROS
#include <__undef_macros> #include <__undef_macros>
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
class _LIBCPP_TEMPLATE_VIS bernoulli_distribution class bernoulli_distribution
{ {
public: public:
// types // types
typedef bool result_type; typedef bool result_type;
class _LIBCPP_TEMPLATE_VIS param_type class param_type
{ {
double __p_; double __p_;
public: public:
typedef bernoulli_distribution distribution_type; typedef bernoulli_distribution distribution_type;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
explicit param_type(double __p = 0.5) : __p_(__p) {} explicit param_type(double __p = 0.5) : __p_(__p) {}
▲ Show 20 Lines • Show All 105 Lines • Show Last 20 Lines

libcxx/include/__random/binomial_distribution.h

Show All 19 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 _IntType = int> template<class _IntType = int>
class _LIBCPP_TEMPLATE_VIS binomial_distribution class binomial_distribution
{ {
static_assert(__libcpp_random_is_valid_inttype<_IntType>::value, "IntType must be a supported integer type"); static_assert(__libcpp_random_is_valid_inttype<_IntType>::value, "IntType must be a supported integer type");
public: public:
// types // types
typedef _IntType result_type; typedef _IntType result_type;
class _LIBCPP_TEMPLATE_VIS param_type class param_type
{ {
result_type __t_; result_type __t_;
double __p_; double __p_;
double __pr_; double __pr_;
double __odds_ratio_; double __odds_ratio_;
result_type __r0_; result_type __r0_;
public: public:
typedef binomial_distribution distribution_type; typedef binomial_distribution distribution_type;
▲ Show 20 Lines • Show All 186 Lines • Show Last 20 Lines

libcxx/include/__random/cauchy_distribution.h

Show All 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 _RealType = double> template<class _RealType = double>
class _LIBCPP_TEMPLATE_VIS cauchy_distribution class cauchy_distribution
{ {
public: public:
// types // types
typedef _RealType result_type; typedef _RealType result_type;
class _LIBCPP_TEMPLATE_VIS param_type class param_type
{ {
result_type __a_; result_type __a_;
result_type __b_; result_type __b_;
public: public:
typedef cauchy_distribution distribution_type; typedef cauchy_distribution distribution_type;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
explicit param_type(result_type __a = 0, result_type __b = 1) explicit param_type(result_type __a = 0, result_type __b = 1)
▲ Show 20 Lines • Show All 121 Lines • Show Last 20 Lines

libcxx/include/__random/chi_squared_distribution.h

Show All 18 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 _RealType = double> template<class _RealType = double>
class _LIBCPP_TEMPLATE_VIS chi_squared_distribution class chi_squared_distribution
{ {
public: public:
// types // types
typedef _RealType result_type; typedef _RealType result_type;
class _LIBCPP_TEMPLATE_VIS param_type class param_type
{ {
result_type __n_; result_type __n_;
public: public:
typedef chi_squared_distribution distribution_type; typedef chi_squared_distribution distribution_type;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
explicit param_type(result_type __n = 1) : __n_(__n) {} explicit param_type(result_type __n = 1) : __n_(__n) {}
▲ Show 20 Lines • Show All 103 Lines • Show Last 20 Lines

libcxx/include/__random/discard_block_engine.h

Show All 22 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 _Engine, size_t __p, size_t __r> template<class _Engine, size_t __p, size_t __r>
class _LIBCPP_TEMPLATE_VIS discard_block_engine class discard_block_engine
{ {
_Engine __e_; _Engine __e_;
int __n_; int __n_;
static_assert( 0 < __r, "discard_block_engine invalid parameters"); static_assert( 0 < __r, "discard_block_engine invalid parameters");
static_assert(__r <= __p, "discard_block_engine invalid parameters"); static_assert(__r <= __p, "discard_block_engine invalid parameters");
#ifndef _LIBCPP_CXX03_LANG // numeric_limits::max() is not constexpr in C++03 #ifndef _LIBCPP_CXX03_LANG // numeric_limits::max() is not constexpr in C++03
static_assert(__r <= numeric_limits<int>::max(), "discard_block_engine invalid parameters"); static_assert(__r <= numeric_limits<int>::max(), "discard_block_engine invalid parameters");
▲ Show 20 Lines • Show All 168 Lines • Show Last 20 Lines

libcxx/include/__random/discrete_distribution.h

Show All 22 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 _IntType = int> template<class _IntType = int>
class _LIBCPP_TEMPLATE_VIS discrete_distribution class discrete_distribution
{ {
static_assert(__libcpp_random_is_valid_inttype<_IntType>::value, "IntType must be a supported integer type"); static_assert(__libcpp_random_is_valid_inttype<_IntType>::value, "IntType must be a supported integer type");
public: public:
// types // types
typedef _IntType result_type; typedef _IntType result_type;
class _LIBCPP_TEMPLATE_VIS param_type class param_type
{ {
vector<double> __p_; vector<double> __p_;
public: public:
typedef discrete_distribution distribution_type; typedef discrete_distribution distribution_type;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
param_type() {} param_type() {}
template<class _InputIterator> template<class _InputIterator>
▲ Show 20 Lines • Show All 218 Lines • Show Last 20 Lines

libcxx/include/__random/exponential_distribution.h

Show All 21 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 _RealType = double> template<class _RealType = double>
class _LIBCPP_TEMPLATE_VIS exponential_distribution class exponential_distribution
{ {
public: public:
// types // types
typedef _RealType result_type; typedef _RealType result_type;
class _LIBCPP_TEMPLATE_VIS param_type class param_type
{ {
result_type __lambda_; result_type __lambda_;
public: public:
typedef exponential_distribution distribution_type; typedef exponential_distribution distribution_type;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
explicit param_type(result_type __lambda = 1) : __lambda_(__lambda) {} explicit param_type(result_type __lambda = 1) : __lambda_(__lambda) {}
▲ Show 20 Lines • Show All 114 Lines • Show Last 20 Lines

libcxx/include/__random/extreme_value_distribution.h

Show All 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 _RealType = double> template<class _RealType = double>
class _LIBCPP_TEMPLATE_VIS extreme_value_distribution class extreme_value_distribution
{ {
public: public:
// types // types
typedef _RealType result_type; typedef _RealType result_type;
class _LIBCPP_TEMPLATE_VIS param_type class param_type
{ {
result_type __a_; result_type __a_;
result_type __b_; result_type __b_;
public: public:
typedef extreme_value_distribution distribution_type; typedef extreme_value_distribution distribution_type;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
explicit param_type(result_type __a = 0, result_type __b = 1) explicit param_type(result_type __a = 0, result_type __b = 1)
▲ Show 20 Lines • Show All 121 Lines • Show Last 20 Lines

libcxx/include/__random/fisher_f_distribution.h

Show All 19 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 _RealType = double> template<class _RealType = double>
class _LIBCPP_TEMPLATE_VIS fisher_f_distribution class fisher_f_distribution
{ {
public: public:
// types // types
typedef _RealType result_type; typedef _RealType result_type;
class _LIBCPP_TEMPLATE_VIS param_type class param_type
{ {
result_type __m_; result_type __m_;
result_type __n_; result_type __n_;
public: public:
typedef fisher_f_distribution distribution_type; typedef fisher_f_distribution distribution_type;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
explicit param_type(result_type __m = 1, result_type __n = 1) explicit param_type(result_type __m = 1, result_type __n = 1)
▲ Show 20 Lines • Show All 121 Lines • Show Last 20 Lines

libcxx/include/__random/gamma_distribution.h

Show All 21 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 _RealType = double> template<class _RealType = double>
class _LIBCPP_TEMPLATE_VIS gamma_distribution class gamma_distribution
{ {
public: public:
// types // types
typedef _RealType result_type; typedef _RealType result_type;
class _LIBCPP_TEMPLATE_VIS param_type class param_type
{ {
result_type __alpha_; result_type __alpha_;
result_type __beta_; result_type __beta_;
public: public:
typedef gamma_distribution distribution_type; typedef gamma_distribution distribution_type;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
explicit param_type(result_type __alpha = 1, result_type __beta = 1) explicit param_type(result_type __alpha = 1, result_type __beta = 1)
▲ Show 20 Lines • Show All 172 Lines • Show Last 20 Lines

libcxx/include/__random/geometric_distribution.h

Show All 19 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 _IntType = int> template<class _IntType = int>
class _LIBCPP_TEMPLATE_VIS geometric_distribution class geometric_distribution
{ {
static_assert(__libcpp_random_is_valid_inttype<_IntType>::value, "IntType must be a supported integer type"); static_assert(__libcpp_random_is_valid_inttype<_IntType>::value, "IntType must be a supported integer type");
public: public:
// types // types
typedef _IntType result_type; typedef _IntType result_type;
class _LIBCPP_TEMPLATE_VIS param_type class param_type
{ {
double __p_; double __p_;
public: public:
typedef geometric_distribution distribution_type; typedef geometric_distribution distribution_type;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
explicit param_type(double __p = 0.5) : __p_(__p) {} explicit param_type(double __p = 0.5) : __p_(__p) {}
▲ Show 20 Lines • Show All 100 Lines • Show Last 20 Lines

libcxx/include/__random/independent_bits_engine.h

Show All 24 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 _Engine, size_t __w, class _UIntType> template<class _Engine, size_t __w, class _UIntType>
class _LIBCPP_TEMPLATE_VIS independent_bits_engine class independent_bits_engine
{ {
template <class _UInt, _UInt _R0, size_t _Wp, size_t _Mp> template <class _UInt, _UInt _R0, size_t _Wp, size_t _Mp>
class __get_n class __get_n
{ {
static _LIBCPP_CONSTEXPR const size_t _Dt = numeric_limits<_UInt>::digits; static _LIBCPP_CONSTEXPR const size_t _Dt = numeric_limits<_UInt>::digits;
static _LIBCPP_CONSTEXPR const size_t _Np = _Wp / _Mp + (_Wp % _Mp != 0); static _LIBCPP_CONSTEXPR const size_t _Np = _Wp / _Mp + (_Wp % _Mp != 0);
static _LIBCPP_CONSTEXPR const size_t _W0 = _Wp / _Np; static _LIBCPP_CONSTEXPR const size_t _W0 = _Wp / _Np;
static _LIBCPP_CONSTEXPR const _UInt _Y0 = _W0 >= _Dt ? 0 : (_R0 >> _W0) << _W0; static _LIBCPP_CONSTEXPR const _UInt _Y0 = _W0 >= _Dt ? 0 : (_R0 >> _W0) << _W0;
▲ Show 20 Lines • Show All 229 Lines • Show Last 20 Lines

libcxx/include/__random/linear_congruential_engine.h

Show First 20 Lines • Show All 183 Lines • ▼ Show 20 Linesstruct __lce_ta<__a, __c, __m, (unsigned short)(~0), __b>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
static result_type next(result_type __x) static result_type next(result_type __x)
{ {
return static_cast<result_type>(__lce_ta<__a, __c, __m, unsigned(~0)>::next(__x)); return static_cast<result_type>(__lce_ta<__a, __c, __m, unsigned(~0)>::next(__x));
} }
}; };
template <class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m> template <class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
class _LIBCPP_TEMPLATE_VIS linear_congruential_engine; class linear_congruential_engine;
template <class _CharT, class _Traits, template <class _CharT, class _Traits,
class _Up, _Up _Ap, _Up _Cp, _Up _Np> class _Up, _Up _Ap, _Up _Cp, _Up _Np>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __os, operator<<(basic_ostream<_CharT, _Traits>& __os,
const linear_congruential_engine<_Up, _Ap, _Cp, _Np>&); const linear_congruential_engine<_Up, _Ap, _Cp, _Np>&);
template <class _CharT, class _Traits, template <class _CharT, class _Traits,
class _Up, _Up _Ap, _Up _Cp, _Up _Np> class _Up, _Up _Ap, _Up _Cp, _Up _Np>
_LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>& _LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __is, operator>>(basic_istream<_CharT, _Traits>& __is,
linear_congruential_engine<_Up, _Ap, _Cp, _Np>& __x); linear_congruential_engine<_Up, _Ap, _Cp, _Np>& __x);
template <class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m> template <class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
class _LIBCPP_TEMPLATE_VIS linear_congruential_engine class linear_congruential_engine
{ {
public: public:
// types // types
typedef _UIntType result_type; typedef _UIntType result_type;
private: private:
result_type __x_; result_type __x_;
▲ Show 20 Lines • Show All 184 Lines • Show Last 20 Lines

libcxx/include/__random/lognormal_distribution.h

Show All 19 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 _RealType = double> template<class _RealType = double>
class _LIBCPP_TEMPLATE_VIS lognormal_distribution class lognormal_distribution
{ {
public: public:
// types // types
typedef _RealType result_type; typedef _RealType result_type;
class _LIBCPP_TEMPLATE_VIS param_type class param_type
{ {
result_type __m_; result_type __m_;
result_type __s_; result_type __s_;
public: public:
typedef lognormal_distribution distribution_type; typedef lognormal_distribution distribution_type;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
explicit param_type(result_type __m = 0, result_type __s = 1) explicit param_type(result_type __m = 0, result_type __s = 1)
▲ Show 20 Lines • Show All 119 Lines • Show Last 20 Lines

libcxx/include/__random/mersenne_twister_engine.h

Show All 24 Lines
_LIBCPP_PUSH_MACROS _LIBCPP_PUSH_MACROS
#include <__undef_macros> #include <__undef_macros>
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r, template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
_UIntType __a, size_t __u, _UIntType __d, size_t __s, _UIntType __a, size_t __u, _UIntType __d, size_t __s,
_UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f> _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
class _LIBCPP_TEMPLATE_VIS mersenne_twister_engine; class mersenne_twister_engine;
template <class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp, template <class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
_UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp, _UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
_UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp> _UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
_LIBCPP_HIDE_FROM_ABI bool _LIBCPP_HIDE_FROM_ABI bool
operator==(const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, operator==(const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
_Bp, _Tp, _Cp, _Lp, _Fp>& __x, _Bp, _Tp, _Cp, _Lp, _Fp>& __x,
const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
Show All 25 Lines
_LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>& _LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __is, operator>>(basic_istream<_CharT, _Traits>& __is,
mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
_Bp, _Tp, _Cp, _Lp, _Fp>& __x); _Bp, _Tp, _Cp, _Lp, _Fp>& __x);
template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r, template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
_UIntType __a, size_t __u, _UIntType __d, size_t __s, _UIntType __a, size_t __u, _UIntType __d, size_t __s,
_UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f> _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
class _LIBCPP_TEMPLATE_VIS mersenne_twister_engine class mersenne_twister_engine
{ {
public: public:
// types // types
typedef _UIntType result_type; typedef _UIntType result_type;
private: private:
result_type __x_[__n]; result_type __x_[__n];
size_t __i_; size_t __i_;
▲ Show 20 Lines • Show All 450 Lines • Show Last 20 Lines

libcxx/include/__random/negative_binomial_distribution.h

Show All 21 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 _IntType = int> template<class _IntType = int>
class _LIBCPP_TEMPLATE_VIS negative_binomial_distribution class negative_binomial_distribution
{ {
static_assert(__libcpp_random_is_valid_inttype<_IntType>::value, "IntType must be a supported integer type"); static_assert(__libcpp_random_is_valid_inttype<_IntType>::value, "IntType must be a supported integer type");
public: public:
// types // types
typedef _IntType result_type; typedef _IntType result_type;
class _LIBCPP_TEMPLATE_VIS param_type class param_type
{ {
result_type __k_; result_type __k_;
double __p_; double __p_;
public: public:
typedef negative_binomial_distribution distribution_type; typedef negative_binomial_distribution distribution_type;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
explicit param_type(result_type __k = 1, double __p = 0.5) explicit param_type(result_type __k = 1, double __p = 0.5)
▲ Show 20 Lines • Show All 139 Lines • Show Last 20 Lines

libcxx/include/__random/normal_distribution.h

Show All 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 _RealType = double> template<class _RealType = double>
class _LIBCPP_TEMPLATE_VIS normal_distribution class normal_distribution
{ {
public: public:
// types // types
typedef _RealType result_type; typedef _RealType result_type;
class _LIBCPP_TEMPLATE_VIS param_type class param_type
{ {
result_type __mean_; result_type __mean_;
result_type __stddev_; result_type __stddev_;
public: public:
typedef normal_distribution distribution_type; typedef normal_distribution distribution_type;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
explicit param_type(result_type __mean = 0, result_type __stddev = 1) explicit param_type(result_type __mean = 0, result_type __stddev = 1)
▲ Show 20 Lines • Show All 168 Lines • Show Last 20 Lines

libcxx/include/__random/piecewise_constant_distribution.h

Show All 21 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 _RealType = double> template<class _RealType = double>
class _LIBCPP_TEMPLATE_VIS piecewise_constant_distribution class piecewise_constant_distribution
{ {
public: public:
// types // types
typedef _RealType result_type; typedef _RealType result_type;
class _LIBCPP_TEMPLATE_VIS param_type class param_type
{ {
vector<result_type> __b_; vector<result_type> __b_;
vector<result_type> __densities_; vector<result_type> __densities_;
vector<result_type> __areas_; vector<result_type> __areas_;
public: public:
typedef piecewise_constant_distribution distribution_type; typedef piecewise_constant_distribution distribution_type;
_LIBCPP_HIDE_FROM_ABI param_type(); _LIBCPP_HIDE_FROM_ABI param_type();
▲ Show 20 Lines • Show All 315 Lines • Show Last 20 Lines

libcxx/include/__random/piecewise_linear_distribution.h

Show All 21 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 _RealType = double> template<class _RealType = double>
class _LIBCPP_TEMPLATE_VIS piecewise_linear_distribution class piecewise_linear_distribution
{ {
public: public:
// types // types
typedef _RealType result_type; typedef _RealType result_type;
class _LIBCPP_TEMPLATE_VIS param_type class param_type
{ {
vector<result_type> __b_; vector<result_type> __b_;
vector<result_type> __densities_; vector<result_type> __densities_;
vector<result_type> __areas_; vector<result_type> __areas_;
public: public:
typedef piecewise_linear_distribution distribution_type; typedef piecewise_linear_distribution distribution_type;
_LIBCPP_HIDE_FROM_ABI param_type(); _LIBCPP_HIDE_FROM_ABI param_type();
▲ Show 20 Lines • Show All 331 Lines • Show Last 20 Lines

libcxx/include/__random/poisson_distribution.h

Show All 23 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 _IntType = int> template<class _IntType = int>
class _LIBCPP_TEMPLATE_VIS poisson_distribution class poisson_distribution
{ {
static_assert(__libcpp_random_is_valid_inttype<_IntType>::value, "IntType must be a supported integer type"); static_assert(__libcpp_random_is_valid_inttype<_IntType>::value, "IntType must be a supported integer type");
public: public:
// types // types
typedef _IntType result_type; typedef _IntType result_type;
class _LIBCPP_TEMPLATE_VIS param_type class param_type
{ {
double __mean_; double __mean_;
double __s_; double __s_;
double __d_; double __d_;
double __l_; double __l_;
double __omega_; double __omega_;
double __c0_; double __c0_;
double __c1_; double __c1_;
▲ Show 20 Lines • Show All 234 Lines • Show Last 20 Lines

libcxx/include/__random/seed_seq.h

Show All 21 Lines
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_PUSH_MACROS _LIBCPP_PUSH_MACROS
#include <__undef_macros> #include <__undef_macros>
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
class _LIBCPP_TEMPLATE_VIS seed_seq class seed_seq
{ {
public: public:
// types // types
typedef uint32_t result_type; typedef uint32_t result_type;
// constructors // constructors
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
seed_seq() _NOEXCEPT {} seed_seq() _NOEXCEPT {}
▲ Show 20 Lines • Show All 141 Lines • Show Last 20 Lines

libcxx/include/__random/shuffle_order_engine.h

Show First 20 Lines • Show All 48 Lines • ▼ Show 20 Lines
public: public:
static _LIBCPP_CONSTEXPR const uint64_t num = _Np / __gcd; static _LIBCPP_CONSTEXPR const uint64_t num = _Np / __gcd;
static _LIBCPP_CONSTEXPR const uint64_t den = _Dp / __gcd; static _LIBCPP_CONSTEXPR const uint64_t den = _Dp / __gcd;
typedef __uratio<num, den> type; typedef __uratio<num, den> type;
}; };
template<class _Engine, size_t __k> template<class _Engine, size_t __k>
class _LIBCPP_TEMPLATE_VIS shuffle_order_engine class shuffle_order_engine
{ {
static_assert(0 < __k, "shuffle_order_engine invalid parameters"); static_assert(0 < __k, "shuffle_order_engine invalid parameters");
public: public:
// types // types
typedef typename _Engine::result_type result_type; typedef typename _Engine::result_type result_type;
private: private:
_Engine __e_; _Engine __e_;
▲ Show 20 Lines • Show All 221 Lines • Show Last 20 Lines

libcxx/include/__random/student_t_distribution.h

Show All 21 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 _RealType = double> template<class _RealType = double>
class _LIBCPP_TEMPLATE_VIS student_t_distribution class student_t_distribution
{ {
public: public:
// types // types
typedef _RealType result_type; typedef _RealType result_type;
class _LIBCPP_TEMPLATE_VIS param_type class param_type
{ {
result_type __n_; result_type __n_;
public: public:
typedef student_t_distribution distribution_type; typedef student_t_distribution distribution_type;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
explicit param_type(result_type __n = 1) : __n_(__n) {} explicit param_type(result_type __n = 1) : __n_(__n) {}
▲ Show 20 Lines • Show All 112 Lines • Show Last 20 Lines

libcxx/include/__random/subtract_with_carry_engine.h

Show All 23 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 _UIntType, size_t __w, size_t __s, size_t __r> template<class _UIntType, size_t __w, size_t __s, size_t __r>
class _LIBCPP_TEMPLATE_VIS subtract_with_carry_engine; class subtract_with_carry_engine;
template<class _UInt, size_t _Wp, size_t _Sp, size_t _Rp> template<class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
_LIBCPP_HIDE_FROM_ABI bool _LIBCPP_HIDE_FROM_ABI bool
operator==( operator==(
const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x, const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x,
const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __y); const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __y);
template<class _UInt, size_t _Wp, size_t _Sp, size_t _Rp> template<class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
Show All 11 Lines
template <class _CharT, class _Traits, template <class _CharT, class _Traits,
class _UInt, size_t _Wp, size_t _Sp, size_t _Rp> class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
_LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>& _LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __is, operator>>(basic_istream<_CharT, _Traits>& __is,
subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x); subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x);
template<class _UIntType, size_t __w, size_t __s, size_t __r> template<class _UIntType, size_t __w, size_t __s, size_t __r>
class _LIBCPP_TEMPLATE_VIS subtract_with_carry_engine class subtract_with_carry_engine
{ {
public: public:
// types // types
typedef _UIntType result_type; typedef _UIntType result_type;
private: private:
result_type __x_[__r]; result_type __x_[__r];
result_type __c_; result_type __c_;
▲ Show 20 Lines • Show All 283 Lines • Show Last 20 Lines

libcxx/include/__random/uniform_real_distribution.h

Show All 19 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 _RealType = double> template<class _RealType = double>
class _LIBCPP_TEMPLATE_VIS uniform_real_distribution class uniform_real_distribution
{ {
public: public:
// types // types
typedef _RealType result_type; typedef _RealType result_type;
class _LIBCPP_TEMPLATE_VIS param_type class param_type
{ {
result_type __a_; result_type __a_;
result_type __b_; result_type __b_;
public: public:
typedef uniform_real_distribution distribution_type; typedef uniform_real_distribution distribution_type;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
explicit param_type(result_type __a = 0, explicit param_type(result_type __a = 0,
▲ Show 20 Lines • Show All 119 Lines • Show Last 20 Lines

libcxx/include/__random/weibull_distribution.h

Show All 19 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 _RealType = double> template<class _RealType = double>
class _LIBCPP_TEMPLATE_VIS weibull_distribution class weibull_distribution
{ {
public: public:
// types // types
typedef _RealType result_type; typedef _RealType result_type;
class _LIBCPP_TEMPLATE_VIS param_type class param_type
{ {
result_type __a_; result_type __a_;
result_type __b_; result_type __b_;
public: public:
typedef weibull_distribution distribution_type; typedef weibull_distribution distribution_type;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
explicit param_type(result_type __a = 1, result_type __b = 1) explicit param_type(result_type __a = 1, result_type __b = 1)
▲ Show 20 Lines • Show All 113 Lines • Show Last 20 Lines

libcxx/include/__ranges/non_propagating_cache.h

Show All 30 Linesnamespace ranges {
// and which resets the source's value when it is moved-from. // and which resets the source's value when it is moved-from.
// //
// This type is used as an implementation detail of some views that need to cache the // This type is used as an implementation detail of some views that need to cache the
// result of `begin()` in order to provide an amortized O(1) begin() method. Typically, // result of `begin()` in order to provide an amortized O(1) begin() method. Typically,
// we don't want to propagate the value of the cache upon copy because the cached iterator // we don't want to propagate the value of the cache upon copy because the cached iterator
// may refer to internal details of the source view. // may refer to internal details of the source view.
template<class _Tp> template<class _Tp>
requires is_object_v<_Tp> requires is_object_v<_Tp>
class _LIBCPP_TEMPLATE_VIS __non_propagating_cache { class __non_propagating_cache {
struct __from_tag { }; struct __from_tag { };
struct __forward_tag { }; struct __forward_tag { };
// This helper class is needed to perform copy and move elision when // This helper class is needed to perform copy and move elision when
// constructing the contained type from an iterator. // constructing the contained type from an iterator.
struct __wrapper { struct __wrapper {
template <class... _Args> template <class... _Args>
_LIBCPP_HIDE_FROM_ABI constexpr explicit __wrapper(__forward_tag, _Args&&... __args) _LIBCPP_HIDE_FROM_ABI constexpr explicit __wrapper(__forward_tag, _Args&&... __args)
▲ Show 20 Lines • Show All 67 Lines • Show Last 20 Lines

libcxx/include/__ranges/subrange.h

Show First 20 Lines • Show All 67 Lines • ▼ Show 20 Lines concept __pair_like_convertible_from =
__convertible_to_non_slicing<_Iter, tuple_element_t<0, _Pair>> && __convertible_to_non_slicing<_Iter, tuple_element_t<0, _Pair>> &&
convertible_to<_Sent, tuple_element_t<1, _Pair>>; convertible_to<_Sent, tuple_element_t<1, _Pair>>;
template<input_or_output_iterator _Iter, sentinel_for<_Iter> _Sent = _Iter, template<input_or_output_iterator _Iter, sentinel_for<_Iter> _Sent = _Iter,
subrange_kind _Kind = sized_sentinel_for<_Sent, _Iter> subrange_kind _Kind = sized_sentinel_for<_Sent, _Iter>
? subrange_kind::sized ? subrange_kind::sized
: subrange_kind::unsized> : subrange_kind::unsized>
requires (_Kind == subrange_kind::sized || !sized_sentinel_for<_Sent, _Iter>) requires (_Kind == subrange_kind::sized || !sized_sentinel_for<_Sent, _Iter>)
class _LIBCPP_TEMPLATE_VIS subrange class subrange : public view_interface<subrange<_Iter, _Sent, _Kind>>
: public view_interface<subrange<_Iter, _Sent, _Kind>>
{ {
public: public:
// Note: this is an internal implementation detail that is public only for internal usage. // Note: this is an internal implementation detail that is public only for internal usage.
static constexpr bool _StoreSize = (_Kind == subrange_kind::sized && !sized_sentinel_for<_Sent, _Iter>); static constexpr bool _StoreSize = (_Kind == subrange_kind::sized && !sized_sentinel_for<_Sent, _Iter>);
private: private:
static constexpr bool _MustProvideSizeAtConstruction = !_StoreSize; // just to improve compiler diagnostics static constexpr bool _MustProvideSizeAtConstruction = !_StoreSize; // just to improve compiler diagnostics
struct _Empty { _LIBCPP_HIDE_FROM_ABI constexpr _Empty(auto) noexcept { } }; struct _Empty { _LIBCPP_HIDE_FROM_ABI constexpr _Empty(auto) noexcept { } };
▲ Show 20 Lines • Show All 206 Lines • Show Last 20 Lines

libcxx/include/__string/char_traits.h

Show First 20 Lines • Show All 186 Lines • ▼ Show 20 Lines
#endif #endif
::__builtin_memmove(__dest, __source, __n * sizeof(_CharT)); ::__builtin_memmove(__dest, __source, __n * sizeof(_CharT));
return __dest; return __dest;
} }
// char_traits<char> // char_traits<char>
template <> template <>
struct _LIBCPP_TEMPLATE_VIS char_traits<char> struct char_traits<char>
{ {
using char_type = char; using char_type = char;
using int_type = int; using int_type = int;
using off_type = streamoff; using off_type = streamoff;
using pos_type = streampos; using pos_type = streampos;
using state_type = mbstate_t; using state_type = mbstate_t;
#if _LIBCPP_STD_VER >= 20 #if _LIBCPP_STD_VER >= 20
using comparison_category = strong_ordering; using comparison_category = strong_ordering;
▲ Show 20 Lines • Show All 73 Lines • ▼ Show 20 Lines#endif // _LIBCPP_COMPILER_CLANG_BASED
static inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR int_type eof() _NOEXCEPT static inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR int_type eof() _NOEXCEPT
{return int_type(EOF);} {return int_type(EOF);}
}; };
// char_traits<wchar_t> // char_traits<wchar_t>
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
template <> template <>
struct _LIBCPP_TEMPLATE_VIS char_traits<wchar_t> struct char_traits<wchar_t>
{ {
using char_type = wchar_t; using char_type = wchar_t;
using int_type = wint_t; using int_type = wint_t;
using off_type = streamoff; using off_type = streamoff;
using pos_type = streampos; using pos_type = streampos;
using state_type = mbstate_t; using state_type = mbstate_t;
#if _LIBCPP_STD_VER >= 20 #if _LIBCPP_STD_VER >= 20
using comparison_category = strong_ordering; using comparison_category = strong_ordering;
▲ Show 20 Lines • Show All 54 Lines • ▼ Show 20 Lines const char_type* find(const char_type* __s, size_t __n, const char_type& __a) _NOEXCEPT {
static inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR int_type eof() _NOEXCEPT static inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR int_type eof() _NOEXCEPT
{return int_type(WEOF);} {return int_type(WEOF);}
}; };
#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS #endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
#ifndef _LIBCPP_HAS_NO_CHAR8_T #ifndef _LIBCPP_HAS_NO_CHAR8_T
template <> template <>
struct _LIBCPP_TEMPLATE_VIS char_traits<char8_t> struct char_traits<char8_t>
{ {
using char_type = char8_t; using char_type = char8_t;
using int_type = unsigned int; using int_type = unsigned int;
using off_type = streamoff; using off_type = streamoff;
using pos_type = u8streampos; using pos_type = u8streampos;
using state_type = mbstate_t; using state_type = mbstate_t;
#if _LIBCPP_STD_VER >= 20 #if _LIBCPP_STD_VER >= 20
using comparison_category = strong_ordering; using comparison_category = strong_ordering;
▲ Show 20 Lines • Show All 71 Lines • ▼ Show 20 Lines for (; __n; --__n)
++__s; ++__s;
} }
return nullptr; return nullptr;
} }
#endif // _LIBCPP_HAS_NO_CHAR8_T #endif // _LIBCPP_HAS_NO_CHAR8_T
template <> template <>
struct _LIBCPP_TEMPLATE_VIS char_traits<char16_t> struct char_traits<char16_t>
{ {
using char_type = char16_t; using char_type = char16_t;
using int_type = uint_least16_t; using int_type = uint_least16_t;
using off_type = streamoff; using off_type = streamoff;
using pos_type = u16streampos; using pos_type = u16streampos;
using state_type = mbstate_t; using state_type = mbstate_t;
#if _LIBCPP_STD_VER >= 20 #if _LIBCPP_STD_VER >= 20
using comparison_category = strong_ordering; using comparison_category = strong_ordering;
▲ Show 20 Lines • Show All 77 Lines • ▼ Show 20 Lines 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 char_traits<char32_t>
{ {
using char_type = char32_t; using char_type = char32_t;
using int_type = uint_least32_t; using int_type = uint_least32_t;
using off_type = streamoff; using off_type = streamoff;
using pos_type = u32streampos; using pos_type = u32streampos;
using state_type = mbstate_t; using state_type = mbstate_t;
#if _LIBCPP_STD_VER >= 20 #if _LIBCPP_STD_VER >= 20
using comparison_category = strong_ordering; using comparison_category = strong_ordering;
▲ Show 20 Lines • Show All 311 Lines • Show Last 20 Lines

libcxx/include/__system_error/error_code.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 _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_error_code_enum : public false_type {}; struct is_error_code_enum : public false_type {};
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_error_code_enum_v = is_error_code_enum<_Tp>::value; inline constexpr bool is_error_code_enum_v = is_error_code_enum<_Tp>::value;
#endif #endif
namespace __adl_only { namespace __adl_only {
// Those cause ADL to trigger but they are not viable candidates, // Those cause ADL to trigger but they are not viable candidates,
▲ Show 20 Lines • Show All 90 Lines • ▼ Show 20 Linesinline _LIBCPP_HIDE_FROM_ABI strong_ordering operator<=>(const error_code& __x, const error_code& __y) noexcept {
if (auto __c = __x.category() <=> __y.category(); __c != 0) if (auto __c = __x.category() <=> __y.category(); __c != 0)
return __c; return __c;
return __x.value() <=> __y.value(); return __x.value() <=> __y.value();
} }
#endif // _LIBCPP_STD_VER <= 17 #endif // _LIBCPP_STD_VER <= 17
template <> template <>
struct _LIBCPP_TEMPLATE_VIS hash<error_code> : public __unary_function<error_code, size_t> { struct hash<error_code> : public __unary_function<error_code, size_t> {
_LIBCPP_HIDE_FROM_ABI size_t operator()(const error_code& __ec) const _NOEXCEPT { _LIBCPP_HIDE_FROM_ABI size_t operator()(const error_code& __ec) const _NOEXCEPT {
return static_cast<size_t>(__ec.value()); return static_cast<size_t>(__ec.value());
} }
}; };
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___SYSTEM_ERROR_ERROR_CODE_H #endif // _LIBCPP___SYSTEM_ERROR_ERROR_CODE_H

libcxx/include/__system_error/error_condition.h

Show All 19 Lines
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_error_condition_enum : public false_type {}; struct is_error_condition_enum : public false_type {};
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_error_condition_enum_v = is_error_condition_enum<_Tp>::value; inline constexpr bool is_error_condition_enum_v = is_error_condition_enum<_Tp>::value;
#endif #endif
template <> template <>
struct _LIBCPP_TEMPLATE_VIS is_error_condition_enum<errc> : true_type {}; struct is_error_condition_enum<errc> : true_type {};
#ifdef _LIBCPP_CXX03_LANG #ifdef _LIBCPP_CXX03_LANG
template <> template <>
struct _LIBCPP_TEMPLATE_VIS is_error_condition_enum<errc::__lx> : true_type {}; struct is_error_condition_enum<errc::__lx> : true_type {};
#endif #endif
namespace __adl_only { namespace __adl_only {
// Those cause ADL to trigger but they are not viable candidates, // Those cause ADL to trigger but they are not viable candidates,
// so they are never actually selected. // so they are never actually selected.
void make_error_condition() = delete; void make_error_condition() = delete;
} // namespace __adl_only } // namespace __adl_only
▲ Show 20 Lines • Show All 66 Lines • ▼ Show 20 Linesoperator<=>(const error_condition& __x, const error_condition& __y) noexcept {
if (auto __c = __x.category() <=> __y.category(); __c != 0) if (auto __c = __x.category() <=> __y.category(); __c != 0)
return __c; return __c;
return __x.value() <=> __y.value(); return __x.value() <=> __y.value();
} }
#endif // _LIBCPP_STD_VER <= 17 #endif // _LIBCPP_STD_VER <= 17
template <> template <>
struct _LIBCPP_TEMPLATE_VIS hash<error_condition> : public __unary_function<error_condition, size_t> { struct hash<error_condition> : public __unary_function<error_condition, size_t> {
_LIBCPP_HIDE_FROM_ABI size_t operator()(const error_condition& __ec) const _NOEXCEPT { _LIBCPP_HIDE_FROM_ABI size_t operator()(const error_condition& __ec) const _NOEXCEPT {
return static_cast<size_t>(__ec.value()); return static_cast<size_t>(__ec.value());
} }
}; };
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___SYSTEM_ERROR_ERROR_CONDITION_H #endif // _LIBCPP___SYSTEM_ERROR_ERROR_CONDITION_H

libcxx/include/__threading_support

Show First 20 Lines • Show All 598 Lines • ▼ Show 20 Lines
{ {
_LIBCPP_INLINE_VISIBILITY __thread_id get_id() _NOEXCEPT; _LIBCPP_INLINE_VISIBILITY __thread_id get_id() _NOEXCEPT;
} // namespace this_thread } // namespace this_thread
template<> struct hash<__thread_id>; template<> struct hash<__thread_id>;
class _LIBCPP_TEMPLATE_VIS __thread_id class __thread_id
{ {
// FIXME: pthread_t is a pointer on Darwin but a long on Linux. // FIXME: pthread_t is a pointer on Darwin but a long on Linux.
// NULL is the no-thread value on Darwin. Someone needs to check // NULL is the no-thread value on Darwin. Someone needs to check
// on other platforms. We assume 0 works everywhere for now. // on other platforms. We assume 0 works everywhere for now.
__libcpp_thread_id __id_; __libcpp_thread_id __id_;
static _LIBCPP_HIDE_FROM_ABI static _LIBCPP_HIDE_FROM_ABI
bool __lt_impl(__thread_id __x, __thread_id __y) _NOEXCEPT bool __lt_impl(__thread_id __x, __thread_id __y) _NOEXCEPT
Show All 26 Lines
private: private:
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
__thread_id(__libcpp_thread_id __id) : __id_(__id) {} __thread_id(__libcpp_thread_id __id) : __id_(__id) {}
_LIBCPP_HIDE_FROM_ABI friend __libcpp_thread_id __get_underlying_id(const __thread_id __id) { return __id.__id_; } _LIBCPP_HIDE_FROM_ABI friend __libcpp_thread_id __get_underlying_id(const __thread_id __id) { return __id.__id_; }
friend __thread_id this_thread::get_id() _NOEXCEPT; friend __thread_id this_thread::get_id() _NOEXCEPT;
friend class _LIBCPP_TYPE_VIS thread; friend class _LIBCPP_TYPE_VIS thread;
friend struct _LIBCPP_TEMPLATE_VIS hash<__thread_id>; friend struct hash<__thread_id>;
}; };
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI
bool operator==(__thread_id __x, __thread_id __y) _NOEXCEPT { bool operator==(__thread_id __x, __thread_id __y) _NOEXCEPT {
// Don't pass id==0 to underlying routines // Don't pass id==0 to underlying routines
if (__x.__id_ == 0) if (__x.__id_ == 0)
return __y.__id_ == 0; return __y.__id_ == 0;
if (__y.__id_ == 0) if (__y.__id_ == 0)
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

libcxx/include/__tree

Show First 20 Lines • Show All 48 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, class, class, class> class _LIBCPP_TEMPLATE_VIS map; template <class, class, class, class>
template <class, class, class, class> class _LIBCPP_TEMPLATE_VIS multimap; class map;
template <class, class, class> class _LIBCPP_TEMPLATE_VIS set;
template <class, class, class> class _LIBCPP_TEMPLATE_VIS multiset; template <class, class, class, class>
class multimap;
template <class, class, class>
class set;
template <class, class, class>
class multiset;
template <class _Tp, class _Compare, class _Allocator>
class __tree;
template <class _Tp, class _Compare, class _Allocator> class __tree;
template <class _Tp, class _NodePtr, class _DiffType> template <class _Tp, class _NodePtr, class _DiffType>
class _LIBCPP_TEMPLATE_VIS __tree_iterator; class __tree_iterator;
template <class _Tp, class _ConstNodePtr, class _DiffType> template <class _Tp, class _ConstNodePtr, class _DiffType>
class _LIBCPP_TEMPLATE_VIS __tree_const_iterator; class __tree_const_iterator;
template <class _Pointer> class __tree_end_node; template <class _Pointer> class __tree_end_node;
template <class _VoidPtr> class __tree_node_base; template <class _VoidPtr> class __tree_node_base;
template <class _Tp, class _VoidPtr> class __tree_node; template <class _Tp, class _VoidPtr> class __tree_node;
template <class _Key, class _Value> template <class _Key, class _Value>
struct __value_type; struct __value_type;
template <class _Allocator> class __map_node_destructor; template <class _Allocator> class __map_node_destructor;
template <class _TreeIterator> class _LIBCPP_TEMPLATE_VIS __map_iterator;
template <class _TreeIterator> class _LIBCPP_TEMPLATE_VIS __map_const_iterator; template <class _TreeIterator>
class __map_iterator;
template <class _TreeIterator>
class __map_const_iterator;
/* /*
_NodePtr algorithms _NodePtr algorithms
The algorithms taking _NodePtr are red black tree algorithms. Those The algorithms taking _NodePtr are red black tree algorithms. Those
algorithms taking a parameter named __root should assume that __root algorithms taking a parameter named __root should assume that __root
points to a proper red black tree (unless otherwise specified). points to a proper red black tree (unless otherwise specified).
▲ Show 20 Lines • Show All 741 Lines • ▼ Show 20 Lines
struct __generic_container_node_destructor<__tree_node<_Tp, _VoidPtr>, _Alloc> struct __generic_container_node_destructor<__tree_node<_Tp, _VoidPtr>, _Alloc>
: __tree_node_destructor<_Alloc> : __tree_node_destructor<_Alloc>
{ {
using __tree_node_destructor<_Alloc>::__tree_node_destructor; using __tree_node_destructor<_Alloc>::__tree_node_destructor;
}; };
#endif #endif
template <class _Tp, class _NodePtr, class _DiffType> template <class _Tp, class _NodePtr, class _DiffType>
class _LIBCPP_TEMPLATE_VIS __tree_iterator class __tree_iterator
{ {
typedef __tree_node_types<_NodePtr> _NodeTypes; typedef __tree_node_types<_NodePtr> _NodeTypes;
typedef _NodePtr __node_pointer; typedef _NodePtr __node_pointer;
typedef typename _NodeTypes::__node_base_pointer __node_base_pointer; typedef typename _NodeTypes::__node_base_pointer __node_base_pointer;
typedef typename _NodeTypes::__end_node_pointer __end_node_pointer; typedef typename _NodeTypes::__end_node_pointer __end_node_pointer;
typedef typename _NodeTypes::__iter_pointer __iter_pointer; typedef typename _NodeTypes::__iter_pointer __iter_pointer;
typedef pointer_traits<__node_pointer> __pointer_traits; typedef pointer_traits<__node_pointer> __pointer_traits;
▲ Show 20 Lines • Show All 47 Lines • ▼ Show 20 Lines
private: private:
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
explicit __tree_iterator(__node_pointer __p) _NOEXCEPT : __ptr_(__p) {} explicit __tree_iterator(__node_pointer __p) _NOEXCEPT : __ptr_(__p) {}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
explicit __tree_iterator(__end_node_pointer __p) _NOEXCEPT : __ptr_(__p) {} explicit __tree_iterator(__end_node_pointer __p) _NOEXCEPT : __ptr_(__p) {}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
__node_pointer __get_np() const { return static_cast<__node_pointer>(__ptr_); } __node_pointer __get_np() const { return static_cast<__node_pointer>(__ptr_); }
template <class, class, class> friend class __tree; template <class, class, class> friend class __tree;
template <class, class, class> friend class _LIBCPP_TEMPLATE_VIS __tree_const_iterator; template <class, class, class> friend class __tree_const_iterator;
template <class> friend class _LIBCPP_TEMPLATE_VIS __map_iterator; template <class> friend class __map_iterator;
template <class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS map; template <class, class, class, class> friend class map;
template <class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS multimap; template <class, class, class, class> friend class multimap;
template <class, class, class> friend class _LIBCPP_TEMPLATE_VIS set; template <class, class, class> friend class set;
template <class, class, class> friend class _LIBCPP_TEMPLATE_VIS multiset; template <class, class, class> friend class multiset;
}; };
template <class _Tp, class _NodePtr, class _DiffType> template <class _Tp, class _NodePtr, class _DiffType>
class _LIBCPP_TEMPLATE_VIS __tree_const_iterator class __tree_const_iterator
{ {
typedef __tree_node_types<_NodePtr> _NodeTypes; typedef __tree_node_types<_NodePtr> _NodeTypes;
typedef typename _NodeTypes::__node_pointer __node_pointer; typedef typename _NodeTypes::__node_pointer __node_pointer;
typedef typename _NodeTypes::__node_base_pointer __node_base_pointer; typedef typename _NodeTypes::__node_base_pointer __node_base_pointer;
typedef typename _NodeTypes::__end_node_pointer __end_node_pointer; typedef typename _NodeTypes::__end_node_pointer __end_node_pointer;
typedef typename _NodeTypes::__iter_pointer __iter_pointer; typedef typename _NodeTypes::__iter_pointer __iter_pointer;
typedef pointer_traits<__node_pointer> __pointer_traits; typedef pointer_traits<__node_pointer> __pointer_traits;
▲ Show 20 Lines • Show All 60 Lines • ▼ Show 20 Lines explicit __tree_const_iterator(__node_pointer __p) _NOEXCEPT
: __ptr_(__p) {} : __ptr_(__p) {}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
explicit __tree_const_iterator(__end_node_pointer __p) _NOEXCEPT explicit __tree_const_iterator(__end_node_pointer __p) _NOEXCEPT
: __ptr_(__p) {} : __ptr_(__p) {}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
__node_pointer __get_np() const { return static_cast<__node_pointer>(__ptr_); } __node_pointer __get_np() const { return static_cast<__node_pointer>(__ptr_); }
template <class, class, class> friend class __tree; template <class, class, class> friend class __tree;
template <class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS map; template <class, class, class, class> friend class map;
template <class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS multimap; template <class, class, class, class> friend class multimap;
template <class, class, class> friend class _LIBCPP_TEMPLATE_VIS set; template <class, class, class> friend class set;
template <class, class, class> friend class _LIBCPP_TEMPLATE_VIS multiset; template <class, class, class> friend class multiset;
template <class> friend class _LIBCPP_TEMPLATE_VIS __map_const_iterator; template <class> friend class __map_const_iterator;
}; };
template<class _Tp, class _Compare> template<class _Tp, class _Compare>
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
_LIBCPP_DIAGNOSE_WARNING(!__invokable<_Compare const&, _Tp const&, _Tp const&>::value, _LIBCPP_DIAGNOSE_WARNING(!__invokable<_Compare const&, _Tp const&, _Tp const&>::value,
"the specified comparator type does not provide a viable const call operator") "the specified comparator type does not provide a viable const call operator")
#endif #endif
▲ Show 20 Lines • Show All 537 Lines • ▼ Show 20 Lines private:
static __node_pointer __detach_next(__node_pointer) _NOEXCEPT; static __node_pointer __detach_next(__node_pointer) _NOEXCEPT;
__tree *__t_; __tree *__t_;
__node_pointer __cache_root_; __node_pointer __cache_root_;
__node_pointer __cache_elem_; __node_pointer __cache_elem_;
}; };
template <class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS map; template <class, class, class, class> friend class map;
template <class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS multimap; template <class, class, class, class> friend class multimap;
}; };
template <class _Tp, class _Compare, class _Allocator> template <class _Tp, class _Compare, class _Allocator>
__tree<_Tp, _Compare, _Allocator>::__tree(const value_compare& __comp) __tree<_Tp, _Compare, _Allocator>::__tree(const value_compare& __comp)
_NOEXCEPT_( _NOEXCEPT_(
is_nothrow_default_constructible<__node_allocator>::value && is_nothrow_default_constructible<__node_allocator>::value &&
is_nothrow_copy_constructible<value_compare>::value) is_nothrow_copy_constructible<value_compare>::value)
: __pair3_(0, __comp) : __pair3_(0, __comp)
▲ Show 20 Lines • Show All 1,205 Lines • Show Last 20 Lines

libcxx/include/__tuple/sfinae_helpers.h

Show First 20 Lines • Show All 97 Lines • ▼ Show 20 Linesstruct __tuple_assignable<_Tp, _Up, true, true>
: public __tuple_sfinae_base::__assignable< : public __tuple_sfinae_base::__assignable<
typename __make_tuple_types<_Tp>::type typename __make_tuple_types<_Tp>::type
, typename __make_tuple_types<_Up&>::type , typename __make_tuple_types<_Up&>::type
> >
{}; {};
template <size_t _Ip, class ..._Tp> template <size_t _Ip, class ..._Tp>
struct _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, tuple<_Tp...> > struct tuple_element<_Ip, tuple<_Tp...> >
{ {
typedef _LIBCPP_NODEBUG typename tuple_element<_Ip, __tuple_types<_Tp...> >::type type; typedef _LIBCPP_NODEBUG typename tuple_element<_Ip, __tuple_types<_Tp...> >::type type;
}; };
struct _LIBCPP_TYPE_VIS __check_tuple_constructor_fail { struct _LIBCPP_TYPE_VIS __check_tuple_constructor_fail {
static _LIBCPP_HIDE_FROM_ABI constexpr bool __enable_explicit_default() { return false; } static _LIBCPP_HIDE_FROM_ABI constexpr bool __enable_explicit_default() { return false; }
static _LIBCPP_HIDE_FROM_ABI constexpr bool __enable_implicit_default() { return false; } static _LIBCPP_HIDE_FROM_ABI constexpr bool __enable_implicit_default() { return false; }
▲ Show 20 Lines • Show All 69 Lines • Show Last 20 Lines

libcxx/include/__tuple/tuple_element.h

Show All 17 Lines
#include <cstddef> #include <cstddef>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <size_t _Ip, class _Tp> struct _LIBCPP_TEMPLATE_VIS tuple_element; template <size_t _Ip, class _Tp> struct tuple_element;
template <size_t _Ip, class _Tp> template <size_t _Ip, class _Tp>
struct _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, const _Tp> struct tuple_element<_Ip, const _Tp>
{ {
typedef _LIBCPP_NODEBUG typename add_const<typename tuple_element<_Ip, _Tp>::type>::type type; typedef _LIBCPP_NODEBUG typename add_const<typename tuple_element<_Ip, _Tp>::type>::type type;
}; };
template <size_t _Ip, class _Tp> template <size_t _Ip, class _Tp>
struct _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, volatile _Tp> struct tuple_element<_Ip, volatile _Tp>
{ {
typedef _LIBCPP_NODEBUG typename add_volatile<typename tuple_element<_Ip, _Tp>::type>::type type; typedef _LIBCPP_NODEBUG typename add_volatile<typename tuple_element<_Ip, _Tp>::type>::type type;
}; };
template <size_t _Ip, class _Tp> template <size_t _Ip, class _Tp>
struct _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, const volatile _Tp> struct tuple_element<_Ip, const volatile _Tp>
{ {
typedef _LIBCPP_NODEBUG typename add_cv<typename tuple_element<_Ip, _Tp>::type>::type type; typedef _LIBCPP_NODEBUG typename add_cv<typename tuple_element<_Ip, _Tp>::type>::type type;
}; };
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
#if !__has_builtin(__type_pack_element) #if !__has_builtin(__type_pack_element)
Show All 20 Lines __indexer_detail::__at_index<_Idx>(
__indexer_detail::__indexer< __indexer_detail::__indexer<
__tuple_types<_Types...>, __tuple_types<_Types...>,
typename __make_tuple_indices<sizeof...(_Types)>::type typename __make_tuple_indices<sizeof...(_Types)>::type
>{}) >{})
)::type; )::type;
#endif #endif
template <size_t _Ip, class ..._Types> template <size_t _Ip, class ..._Types>
struct _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, __tuple_types<_Types...> > struct tuple_element<_Ip, __tuple_types<_Types...> >
{ {
static_assert(_Ip < sizeof...(_Types), "tuple_element index out of range"); static_assert(_Ip < sizeof...(_Types), "tuple_element index out of range");
typedef _LIBCPP_NODEBUG __type_pack_element<_Ip, _Types...> type; typedef _LIBCPP_NODEBUG __type_pack_element<_Ip, _Types...> type;
}; };
#if _LIBCPP_STD_VER >= 14 #if _LIBCPP_STD_VER >= 14
template <size_t _Ip, class ..._Tp> template <size_t _Ip, class ..._Tp>
using tuple_element_t _LIBCPP_NODEBUG = typename tuple_element <_Ip, _Tp...>::type; using tuple_element_t _LIBCPP_NODEBUG = typename tuple_element <_Ip, _Tp...>::type;
#endif #endif
#endif // _LIBCPP_CXX03_LANG #endif // _LIBCPP_CXX03_LANG
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TUPLE_TUPLE_ELEMENT_H #endif // _LIBCPP___TUPLE_TUPLE_ELEMENT_H

libcxx/include/__tuple/tuple_size.h

Show All 16 Lines
#include <cstddef> #include <cstddef>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS tuple_size; template <class _Tp> struct tuple_size;
#if !defined(_LIBCPP_CXX03_LANG) #if !defined(_LIBCPP_CXX03_LANG)
template <class _Tp, class...> template <class _Tp, class...>
using __enable_if_tuple_size_imp = _Tp; using __enable_if_tuple_size_imp = _Tp;
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS tuple_size<__enable_if_tuple_size_imp< struct tuple_size<__enable_if_tuple_size_imp<
const _Tp, const _Tp,
__enable_if_t<!is_volatile<_Tp>::value>, __enable_if_t<!is_volatile<_Tp>::value>,
integral_constant<size_t, sizeof(tuple_size<_Tp>)>>> integral_constant<size_t, sizeof(tuple_size<_Tp>)>>>
: public integral_constant<size_t, tuple_size<_Tp>::value> {}; : public integral_constant<size_t, tuple_size<_Tp>::value> {};
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS tuple_size<__enable_if_tuple_size_imp< struct tuple_size<__enable_if_tuple_size_imp<
volatile _Tp, volatile _Tp,
__enable_if_t<!is_const<_Tp>::value>, __enable_if_t<!is_const<_Tp>::value>,
integral_constant<size_t, sizeof(tuple_size<_Tp>)>>> integral_constant<size_t, sizeof(tuple_size<_Tp>)>>>
: public integral_constant<size_t, tuple_size<_Tp>::value> {}; : public integral_constant<size_t, tuple_size<_Tp>::value> {};
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS tuple_size<__enable_if_tuple_size_imp< struct tuple_size<__enable_if_tuple_size_imp<
const volatile _Tp, const volatile _Tp,
integral_constant<size_t, sizeof(tuple_size<_Tp>)>>> integral_constant<size_t, sizeof(tuple_size<_Tp>)>>>
: public integral_constant<size_t, tuple_size<_Tp>::value> {}; : public integral_constant<size_t, tuple_size<_Tp>::value> {};
#else #else
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS tuple_size<const _Tp> : public tuple_size<_Tp> {}; template <class _Tp> struct tuple_size<const _Tp> : public tuple_size<_Tp> {};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS tuple_size<volatile _Tp> : public tuple_size<_Tp> {}; template <class _Tp> struct tuple_size<volatile _Tp> : public tuple_size<_Tp> {};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS tuple_size<const volatile _Tp> : public tuple_size<_Tp> {}; template <class _Tp> struct tuple_size<const volatile _Tp> : public tuple_size<_Tp> {};
#endif #endif
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
template <class ..._Tp> template <class ..._Tp>
struct _LIBCPP_TEMPLATE_VIS tuple_size<tuple<_Tp...> > struct tuple_size<tuple<_Tp...> > : public integral_constant<size_t, sizeof...(_Tp)> {};
: public integral_constant<size_t, sizeof...(_Tp)>
{
};
template <class ..._Tp> template <class ..._Tp>
struct _LIBCPP_TEMPLATE_VIS tuple_size<__tuple_types<_Tp...> > struct tuple_size<__tuple_types<_Tp...> > : public integral_constant<size_t, sizeof...(_Tp)> {};
: public integral_constant<size_t, sizeof...(_Tp)>
{
};
#endif // _LIBCPP_CXX03_LANG #endif // _LIBCPP_CXX03_LANG
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TUPLE_TUPLE_SIZE_H #endif // _LIBCPP___TUPLE_TUPLE_SIZE_H

libcxx/include/__type_traits/add_const.h

Show All 11 Lines
#include <__config> #include <__config>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS add_const { template <class _Tp>
struct add_const {
typedef _LIBCPP_NODEBUG const _Tp type; typedef _LIBCPP_NODEBUG const _Tp type;
}; };
#if _LIBCPP_STD_VER >= 14 #if _LIBCPP_STD_VER >= 14
template <class _Tp> using add_const_t = typename add_const<_Tp>::type; template <class _Tp> using add_const_t = typename add_const<_Tp>::type;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_ADD_CONST_H #endif // _LIBCPP___TYPE_TRAITS_ADD_CONST_H

libcxx/include/__type_traits/add_cv.h

Show All 11 Lines
#include <__config> #include <__config>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS add_cv { template <class _Tp>
struct add_cv {
typedef _LIBCPP_NODEBUG const volatile _Tp type; typedef _LIBCPP_NODEBUG const volatile _Tp type;
}; };
#if _LIBCPP_STD_VER >= 14 #if _LIBCPP_STD_VER >= 14
template <class _Tp> using add_cv_t = typename add_cv<_Tp>::type; template <class _Tp> using add_cv_t = typename add_cv<_Tp>::type;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_ADD_CV_H #endif // _LIBCPP___TYPE_TRAITS_ADD_CV_H

libcxx/include/__type_traits/add_volatile.h

Show All 11 Lines
#include <__config> #include <__config>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS add_volatile { template <class _Tp>
struct add_volatile {
typedef _LIBCPP_NODEBUG volatile _Tp type; typedef _LIBCPP_NODEBUG volatile _Tp type;
}; };
#if _LIBCPP_STD_VER >= 14 #if _LIBCPP_STD_VER >= 14
template <class _Tp> using add_volatile_t = typename add_volatile<_Tp>::type; template <class _Tp> using add_volatile_t = typename add_volatile<_Tp>::type;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_ADD_VOLATILE_H #endif // _LIBCPP___TYPE_TRAITS_ADD_VOLATILE_H

libcxx/include/__type_traits/aligned_storage.h

Show First 20 Lines • Show All 77 Lines • ▼ Show 20 Linespublic:
static const size_t value = _Len < __max ? __min : __max; static const size_t value = _Len < __max ? __min : __max;
}; };
template <class _Hp, class _Tp, size_t _Len> template <class _Hp, class _Tp, size_t _Len>
struct __find_max_align<__type_list<_Hp, _Tp>, _Len> struct __find_max_align<__type_list<_Hp, _Tp>, _Len>
: public integral_constant<size_t, __select_align<_Len, _Hp::value, __find_max_align<_Tp, _Len>::value>::value> {}; : public integral_constant<size_t, __select_align<_Len, _Hp::value, __find_max_align<_Tp, _Len>::value>::value> {};
template <size_t _Len, size_t _Align = __find_max_align<__all_types, _Len>::value> template <size_t _Len, size_t _Align = __find_max_align<__all_types, _Len>::value>
struct _LIBCPP_DEPRECATED_IN_CXX23 _LIBCPP_TEMPLATE_VIS aligned_storage struct _LIBCPP_DEPRECATED_IN_CXX23 aligned_storage
{ {
typedef typename __find_pod<__all_types, _Align>::type _Aligner; typedef typename __find_pod<__all_types, _Align>::type _Aligner;
union type union type
{ {
_Aligner __align; _Aligner __align;
unsigned char __data[(_Len + _Align - 1)/_Align * _Align]; unsigned char __data[(_Len + _Align - 1)/_Align * _Align];
}; };
}; };
#if _LIBCPP_STD_VER >= 14 #if _LIBCPP_STD_VER >= 14
_LIBCPP_SUPPRESS_DEPRECATED_PUSH _LIBCPP_SUPPRESS_DEPRECATED_PUSH
template <size_t _Len, size_t _Align = __find_max_align<__all_types, _Len>::value> template <size_t _Len, size_t _Align = __find_max_align<__all_types, _Len>::value>
using aligned_storage_t _LIBCPP_DEPRECATED_IN_CXX23 = typename aligned_storage<_Len, _Align>::type; using aligned_storage_t _LIBCPP_DEPRECATED_IN_CXX23 = typename aligned_storage<_Len, _Align>::type;
_LIBCPP_SUPPRESS_DEPRECATED_POP _LIBCPP_SUPPRESS_DEPRECATED_POP
#endif #endif
#define _CREATE_ALIGNED_STORAGE_SPECIALIZATION(n) \ #define _CREATE_ALIGNED_STORAGE_SPECIALIZATION(n) \
template <size_t _Len> \ template <size_t _Len> \
struct _LIBCPP_DEPRECATED_IN_CXX23 _LIBCPP_TEMPLATE_VIS aligned_storage<_Len, n> { \ struct _LIBCPP_DEPRECATED_IN_CXX23 aligned_storage<_Len, n> { \
struct _ALIGNAS(n) type { \ struct _ALIGNAS(n) type { \
unsigned char __lx[(_Len + n - 1) / n * n]; \ unsigned char __lx[(_Len + n - 1) / n * n]; \
}; \ }; \
} }
_CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x1); _CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x1);
_CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x2); _CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x2);
_CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x4); _CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x4);
Show All 21 Lines

libcxx/include/__type_traits/alignment_of.h

Show All 13 Lines
#include <cstddef> #include <cstddef>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS alignment_of template <class _Tp>
: public integral_constant<size_t, _LIBCPP_ALIGNOF(_Tp)> {}; struct alignment_of : public integral_constant<size_t, _LIBCPP_ALIGNOF(_Tp)> {};
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr size_t alignment_of_v = _LIBCPP_ALIGNOF(_Tp); inline constexpr size_t alignment_of_v = _LIBCPP_ALIGNOF(_Tp);
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_ALIGNMENT_OF_H #endif // _LIBCPP___TYPE_TRAITS_ALIGNMENT_OF_H

libcxx/include/__type_traits/common_type.h

Show First 20 Lines • Show All 54 Lines • ▼ Show 20 Lines
}; };
template <class, class = void> template <class, class = void>
struct __common_type_impl {}; struct __common_type_impl {};
template <class... _Tp> template <class... _Tp>
struct __common_types; struct __common_types;
template <class... _Tp> template <class... _Tp>
struct _LIBCPP_TEMPLATE_VIS common_type; struct common_type;
template <class _Tp, class _Up> template <class _Tp, class _Up>
struct __common_type_impl< struct __common_type_impl<
__common_types<_Tp, _Up>, __void_t<typename common_type<_Tp, _Up>::type> > __common_types<_Tp, _Up>, __void_t<typename common_type<_Tp, _Up>::type> >
{ {
typedef typename common_type<_Tp, _Up>::type type; typedef typename common_type<_Tp, _Up>::type type;
}; };
template <class _Tp, class _Up, class _Vp, class... _Rest> template <class _Tp, class _Up, class _Vp, class... _Rest>
struct __common_type_impl< struct __common_type_impl<
__common_types<_Tp, _Up, _Vp, _Rest...>, __common_types<_Tp, _Up, _Vp, _Rest...>,
__void_t<typename common_type<_Tp, _Up>::type> > __void_t<typename common_type<_Tp, _Up>::type> >
: __common_type_impl<__common_types<typename common_type<_Tp, _Up>::type, : __common_type_impl<__common_types<typename common_type<_Tp, _Up>::type,
_Vp, _Rest...> > { _Vp, _Rest...> > {
}; };
// bullet 1 - sizeof...(Tp) == 0 // bullet 1 - sizeof...(Tp) == 0
template <> template <>
struct _LIBCPP_TEMPLATE_VIS common_type<> {}; struct common_type<> {};
// bullet 2 - sizeof...(Tp) == 1 // bullet 2 - sizeof...(Tp) == 1
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS common_type<_Tp> struct common_type<_Tp> : public common_type<_Tp, _Tp> {};
: public common_type<_Tp, _Tp> {};
// bullet 3 - sizeof...(Tp) == 2 // bullet 3 - sizeof...(Tp) == 2
// sub-bullet 1 - "If is_same_v<T1, D1> is false or ..." // sub-bullet 1 - "If is_same_v<T1, D1> is false or ..."
template <class _Tp, class _Up> template <class _Tp, class _Up>
struct _LIBCPP_TEMPLATE_VIS common_type<_Tp, _Up> struct common_type<_Tp, _Up>
: conditional< : conditional<
_IsSame<_Tp, __decay_t<_Tp> >::value && _IsSame<_Up, __decay_t<_Up> >::value, _IsSame<_Tp, __decay_t<_Tp> >::value && _IsSame<_Up, __decay_t<_Up> >::value,
__common_type2_imp<_Tp, _Up>, __common_type2_imp<_Tp, _Up>,
common_type<__decay_t<_Tp>, __decay_t<_Up> > common_type<__decay_t<_Tp>, __decay_t<_Up> >
>::type >::type
{}; {};
// bullet 4 - sizeof...(Tp) > 2 // bullet 4 - sizeof...(Tp) > 2
template <class _Tp, class _Up, class _Vp, class... _Rest> template <class _Tp, class _Up, class _Vp, class... _Rest>
struct _LIBCPP_TEMPLATE_VIS struct common_type<_Tp, _Up, _Vp, _Rest...>
common_type<_Tp, _Up, _Vp, _Rest...>
: __common_type_impl< : __common_type_impl<
__common_types<_Tp, _Up, _Vp, _Rest...> > {}; __common_types<_Tp, _Up, _Vp, _Rest...> > {};
#if _LIBCPP_STD_VER >= 14 #if _LIBCPP_STD_VER >= 14
template <class ..._Tp> using common_type_t = typename common_type<_Tp...>::type; template <class ..._Tp> using common_type_t = typename common_type<_Tp...>::type;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_COMMON_TYPE_H #endif // _LIBCPP___TYPE_TRAITS_COMMON_TYPE_H

libcxx/include/__type_traits/conditional.h

Show All 30 Linesstruct _IfImpl<false> {
template <class _IfRes, class _ElseRes> template <class _IfRes, class _ElseRes>
using _Select _LIBCPP_NODEBUG = _ElseRes; using _Select _LIBCPP_NODEBUG = _ElseRes;
}; };
template <bool _Cond, class _IfRes, class _ElseRes> template <bool _Cond, class _IfRes, class _ElseRes>
using _If _LIBCPP_NODEBUG = typename _IfImpl<_Cond>::template _Select<_IfRes, _ElseRes>; using _If _LIBCPP_NODEBUG = typename _IfImpl<_Cond>::template _Select<_IfRes, _ElseRes>;
template <bool _Bp, class _If, class _Then> template <bool _Bp, class _If, class _Then>
struct _LIBCPP_TEMPLATE_VIS conditional { struct conditional {
using type _LIBCPP_NODEBUG = _If; using type _LIBCPP_NODEBUG = _If;
}; };
template <class _If, class _Then> template <class _If, class _Then>
struct _LIBCPP_TEMPLATE_VIS conditional<false, _If, _Then> { struct conditional<false, _If, _Then> {
using type _LIBCPP_NODEBUG = _Then; using type _LIBCPP_NODEBUG = _Then;
}; };
#if _LIBCPP_STD_VER >= 14 #if _LIBCPP_STD_VER >= 14
template <bool _Bp, class _IfRes, class _ElseRes> template <bool _Bp, class _IfRes, class _ElseRes>
using conditional_t _LIBCPP_NODEBUG = typename conditional<_Bp, _IfRes, _ElseRes>::type; using conditional_t _LIBCPP_NODEBUG = typename conditional<_Bp, _IfRes, _ElseRes>::type;
#endif #endif
// Helper so we can use "conditional_t" in all language versions. // Helper so we can use "conditional_t" in all language versions.
template <bool _Bp, class _If, class _Then> template <bool _Bp, class _If, class _Then>
using __conditional_t _LIBCPP_NODEBUG = typename conditional<_Bp, _If, _Then>::type; using __conditional_t _LIBCPP_NODEBUG = typename conditional<_Bp, _If, _Then>::type;
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_CONDITIONAL_H #endif // _LIBCPP___TYPE_TRAITS_CONDITIONAL_H

libcxx/include/__type_traits/decay.h

Show First 20 Lines • Show All 51 Lines • ▼ Show 20 Lines typedef _LIBCPP_NODEBUG typename conditional
is_function<_Up>::value, is_function<_Up>::value,
typename add_pointer<_Up>::type, typename add_pointer<_Up>::type,
__remove_cv_t<_Up> __remove_cv_t<_Up>
>::type >::type
>::type type; >::type type;
}; };
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS decay struct decay
{ {
private: private:
typedef _LIBCPP_NODEBUG __libcpp_remove_reference_t<_Tp> _Up; typedef _LIBCPP_NODEBUG __libcpp_remove_reference_t<_Tp> _Up;
public: public:
typedef _LIBCPP_NODEBUG typename __decay<_Up, __libcpp_is_referenceable<_Up>::value>::type type; typedef _LIBCPP_NODEBUG typename __decay<_Up, __libcpp_is_referenceable<_Up>::value>::type type;
}; };
template <class _Tp> template <class _Tp>
Show All 10 Lines

libcxx/include/__type_traits/dependent_type.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 _Tp, bool> template <class _Tp, bool>
struct _LIBCPP_TEMPLATE_VIS __dependent_type : public _Tp {}; struct __dependent_type : public _Tp {};
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_DEPENDENT_TYPE_H #endif // _LIBCPP___TYPE_TRAITS_DEPENDENT_TYPE_H

libcxx/include/__type_traits/enable_if.h

Show All 11 Lines
#include <__config> #include <__config>
#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 <bool, class _Tp = void> struct _LIBCPP_TEMPLATE_VIS enable_if {}; template <bool, class _Tp = void>
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS enable_if<true, _Tp> {typedef _Tp type;}; struct enable_if {};
template <class _Tp>
struct enable_if<true, _Tp> {typedef _Tp type;};
template <bool _Bp, class _Tp = void> using __enable_if_t _LIBCPP_NODEBUG = typename enable_if<_Bp, _Tp>::type; template <bool _Bp, class _Tp = void> using __enable_if_t _LIBCPP_NODEBUG = typename enable_if<_Bp, _Tp>::type;
#if _LIBCPP_STD_VER >= 14 #if _LIBCPP_STD_VER >= 14
template <bool _Bp, class _Tp = void> using enable_if_t = typename enable_if<_Bp, _Tp>::type; template <bool _Bp, class _Tp = void> using enable_if_t = typename enable_if<_Bp, _Tp>::type;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_ENABLE_IF_H #endif // _LIBCPP___TYPE_TRAITS_ENABLE_IF_H

libcxx/include/__type_traits/extent.h

Show All 16 Lines
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if __has_builtin(__array_extent) #if __has_builtin(__array_extent)
template<class _Tp, size_t _Dim = 0> template<class _Tp, size_t _Dim = 0>
struct _LIBCPP_TEMPLATE_VIS extent struct extent : integral_constant<size_t, __array_extent(_Tp, _Dim)> { };
: integral_constant<size_t, __array_extent(_Tp, _Dim)> { };
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <class _Tp, unsigned _Ip = 0> template <class _Tp, unsigned _Ip = 0>
inline constexpr size_t extent_v = __array_extent(_Tp, _Ip); inline constexpr size_t extent_v = __array_extent(_Tp, _Ip);
#endif #endif
#else // __has_builtin(__array_extent) #else // __has_builtin(__array_extent)
template <class _Tp, unsigned _Ip = 0> struct _LIBCPP_TEMPLATE_VIS extent template <class _Tp, unsigned _Ip = 0>
: public integral_constant<size_t, 0> {}; struct extent : public integral_constant<size_t, 0> {};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS extent<_Tp[], 0> template <class _Tp>
: public integral_constant<size_t, 0> {}; struct extent<_Tp[], 0> : public integral_constant<size_t, 0> {};
template <class _Tp, unsigned _Ip> struct _LIBCPP_TEMPLATE_VIS extent<_Tp[], _Ip> template <class _Tp, unsigned _Ip>
: public integral_constant<size_t, extent<_Tp, _Ip-1>::value> {}; struct extent<_Tp[], _Ip> : public integral_constant<size_t, extent<_Tp, _Ip-1>::value> {};
template <class _Tp, size_t _Np> struct _LIBCPP_TEMPLATE_VIS extent<_Tp[_Np], 0> template <class _Tp, size_t _Np>
: public integral_constant<size_t, _Np> {}; struct extent<_Tp[_Np], 0> : public integral_constant<size_t, _Np> {};
template <class _Tp, size_t _Np, unsigned _Ip> struct _LIBCPP_TEMPLATE_VIS extent<_Tp[_Np], _Ip> template <class _Tp, size_t _Np, unsigned _Ip>
: public integral_constant<size_t, extent<_Tp, _Ip-1>::value> {}; struct extent<_Tp[_Np], _Ip> : public integral_constant<size_t, extent<_Tp, _Ip-1>::value> {};
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <class _Tp, unsigned _Ip = 0> template <class _Tp, unsigned _Ip = 0>
inline constexpr size_t extent_v = extent<_Tp, _Ip>::value; inline constexpr size_t extent_v = extent<_Tp, _Ip>::value;
#endif #endif
#endif // __has_builtin(__array_extent) #endif // __has_builtin(__array_extent)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_EXTENT_H #endif // _LIBCPP___TYPE_TRAITS_EXTENT_H

libcxx/include/__type_traits/has_unique_object_representation.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 >= 17 #if _LIBCPP_STD_VER >= 17
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS has_unique_object_representations template <class _Tp> struct has_unique_object_representations
: public integral_constant<bool, : public integral_constant<bool,
__has_unique_object_representations(remove_cv_t<remove_all_extents_t<_Tp>>)> {}; __has_unique_object_representations(remove_cv_t<remove_all_extents_t<_Tp>>)> {};
template <class _Tp> template <class _Tp>
inline constexpr bool has_unique_object_representations_v = has_unique_object_representations<_Tp>::value; inline constexpr bool has_unique_object_representations_v = has_unique_object_representations<_Tp>::value;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_HAS_UNIQUE_OBJECT_REPRESENTATION_H #endif // _LIBCPP___TYPE_TRAITS_HAS_UNIQUE_OBJECT_REPRESENTATION_H

libcxx/include/__type_traits/has_virtual_destructor.h

Show All 12 Lines
#include <__type_traits/integral_constant.h> #include <__type_traits/integral_constant.h>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS has_virtual_destructor template <class _Tp>
: public integral_constant<bool, __has_virtual_destructor(_Tp)> {}; struct has_virtual_destructor : public integral_constant<bool, __has_virtual_destructor(_Tp)> {};
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool has_virtual_destructor_v = __has_virtual_destructor(_Tp); inline constexpr bool has_virtual_destructor_v = __has_virtual_destructor(_Tp);
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_HAS_VIRTUAL_DESTRUCTOR_H #endif // _LIBCPP___TYPE_TRAITS_HAS_VIRTUAL_DESTRUCTOR_H

libcxx/include/__type_traits/integral_constant.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 _Tp, _Tp __v> template <class _Tp, _Tp __v>
struct _LIBCPP_TEMPLATE_VIS integral_constant struct integral_constant
{ {
static _LIBCPP_CONSTEXPR const _Tp value = __v; static _LIBCPP_CONSTEXPR const _Tp value = __v;
typedef _Tp value_type; typedef _Tp value_type;
typedef integral_constant type; typedef integral_constant type;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR operator value_type() const _NOEXCEPT {return value;} _LIBCPP_CONSTEXPR operator value_type() const _NOEXCEPT {return value;}
#if _LIBCPP_STD_VER >= 14 #if _LIBCPP_STD_VER >= 14
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
Show All 21 Lines

libcxx/include/__type_traits/invoke.h

Show First 20 Lines • Show All 485 Lines • ▼ Show 20 Linesstruct __invoke_void_return_wrapper<_Ret, true>
} }
}; };
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
// is_invocable // is_invocable
template <class _Fn, class ..._Args> template <class _Fn, class ..._Args>
struct _LIBCPP_TEMPLATE_VIS is_invocable struct is_invocable : integral_constant<bool, __invokable<_Fn, _Args...>::value> {};
: integral_constant<bool, __invokable<_Fn, _Args...>::value> {};
template <class _Ret, class _Fn, class ..._Args> template <class _Ret, class _Fn, class ..._Args>
struct _LIBCPP_TEMPLATE_VIS is_invocable_r struct is_invocable_r : integral_constant<bool, __invokable_r<_Ret, _Fn, _Args...>::value> {};
: integral_constant<bool, __invokable_r<_Ret, _Fn, _Args...>::value> {};
template <class _Fn, class ..._Args> template <class _Fn, class ..._Args>
inline constexpr bool is_invocable_v = is_invocable<_Fn, _Args...>::value; inline constexpr bool is_invocable_v = is_invocable<_Fn, _Args...>::value;
template <class _Ret, class _Fn, class ..._Args> template <class _Ret, class _Fn, class ..._Args>
inline constexpr bool is_invocable_r_v = is_invocable_r<_Ret, _Fn, _Args...>::value; inline constexpr bool is_invocable_r_v = is_invocable_r<_Ret, _Fn, _Args...>::value;
// is_nothrow_invocable // is_nothrow_invocable
template <class _Fn, class ..._Args> template <class _Fn, class ..._Args>
struct _LIBCPP_TEMPLATE_VIS is_nothrow_invocable struct is_nothrow_invocable : integral_constant<bool, __nothrow_invokable<_Fn, _Args...>::value> {};
: integral_constant<bool, __nothrow_invokable<_Fn, _Args...>::value> {};
template <class _Ret, class _Fn, class ..._Args> template <class _Ret, class _Fn, class ..._Args>
struct _LIBCPP_TEMPLATE_VIS is_nothrow_invocable_r struct is_nothrow_invocable_r : integral_constant<bool, __nothrow_invokable_r<_Ret, _Fn, _Args...>::value> {};
: integral_constant<bool, __nothrow_invokable_r<_Ret, _Fn, _Args...>::value> {};
template <class _Fn, class ..._Args> template <class _Fn, class ..._Args>
inline constexpr bool is_nothrow_invocable_v = is_nothrow_invocable<_Fn, _Args...>::value; inline constexpr bool is_nothrow_invocable_v = is_nothrow_invocable<_Fn, _Args...>::value;
template <class _Ret, class _Fn, class ..._Args> template <class _Ret, class _Fn, class ..._Args>
inline constexpr bool is_nothrow_invocable_r_v = is_nothrow_invocable_r<_Ret, _Fn, _Args...>::value; inline constexpr bool is_nothrow_invocable_r_v = is_nothrow_invocable_r<_Ret, _Fn, _Args...>::value;
template <class _Fn, class... _Args> template <class _Fn, class... _Args>
struct _LIBCPP_TEMPLATE_VIS invoke_result struct 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;
#endif // _LIBCPP_STD_VER >= 17 #endif // _LIBCPP_STD_VER >= 17
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_INVOKE_H #endif // _LIBCPP___TYPE_TRAITS_INVOKE_H

libcxx/include/__type_traits/is_abstract.h

Show All 12 Lines
#include <__type_traits/integral_constant.h> #include <__type_traits/integral_constant.h>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_abstract template <class _Tp>
: public integral_constant<bool, __is_abstract(_Tp)> {}; struct is_abstract : public integral_constant<bool, __is_abstract(_Tp)> {};
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_abstract_v = __is_abstract(_Tp); inline constexpr bool is_abstract_v = __is_abstract(_Tp);
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_ABSTRACT_H #endif // _LIBCPP___TYPE_TRAITS_IS_ABSTRACT_H

libcxx/include/__type_traits/is_aggregate.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
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS template <class _Tp>
is_aggregate : public integral_constant<bool, __is_aggregate(_Tp)> {}; struct is_aggregate : public integral_constant<bool, __is_aggregate(_Tp)> {};
template <class _Tp> template <class _Tp>
inline constexpr bool is_aggregate_v = __is_aggregate(_Tp); inline constexpr bool is_aggregate_v = __is_aggregate(_Tp);
#endif // _LIBCPP_STD_VER >= 17 #endif // _LIBCPP_STD_VER >= 17
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_AGGREGATE_H #endif // _LIBCPP___TYPE_TRAITS_IS_AGGREGATE_H

libcxx/include/__type_traits/is_arithmetic.h

Show All 14 Lines
#include <__type_traits/is_integral.h> #include <__type_traits/is_integral.h>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_arithmetic template <class _Tp>
: public integral_constant<bool, is_integral<_Tp>::value || struct is_arithmetic : public integral_constant<bool, is_integral<_Tp>::value || is_floating_point<_Tp>::value> {};
is_floating_point<_Tp>::value> {};
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_arithmetic_v = is_arithmetic<_Tp>::value; inline constexpr bool is_arithmetic_v = is_arithmetic<_Tp>::value;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_ARITHMETIC_H #endif // _LIBCPP___TYPE_TRAITS_IS_ARITHMETIC_H

libcxx/include/__type_traits/is_array.h

Show All 18 Lines
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
// TODO: Clang incorrectly reports that __is_array is true for T[0]. // TODO: Clang incorrectly reports that __is_array is true for T[0].
// Re-enable the branch once https://llvm.org/PR54705 is fixed. // Re-enable the branch once https://llvm.org/PR54705 is fixed.
#if __has_builtin(__is_array) && 0 #if __has_builtin(__is_array) && 0
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_array : _BoolConstant<__is_array(_Tp)> { }; struct is_array : _BoolConstant<__is_array(_Tp)> { };
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_array_v = __is_array(_Tp); inline constexpr bool is_array_v = __is_array(_Tp);
#endif #endif
#else #else
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_array template <class _Tp>
: public false_type {}; struct is_array : public false_type {};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_array<_Tp[]> template <class _Tp>
: public true_type {}; struct is_array<_Tp[]> : public true_type {};
template <class _Tp, size_t _Np> struct _LIBCPP_TEMPLATE_VIS is_array<_Tp[_Np]> template <class _Tp, size_t _Np>
: public true_type {}; struct is_array<_Tp[_Np]> : public true_type {};
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_array_v = is_array<_Tp>::value; inline constexpr bool is_array_v = is_array<_Tp>::value;
#endif #endif
#endif // __has_builtin(__is_array) #endif // __has_builtin(__is_array)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_ARRAY_H #endif // _LIBCPP___TYPE_TRAITS_IS_ARRAY_H

libcxx/include/__type_traits/is_assignable.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, class _Up> template<class _Tp, class _Up>
struct _LIBCPP_TEMPLATE_VIS is_assignable : _BoolConstant<__is_assignable(_Tp, _Up)> { }; struct is_assignable : _BoolConstant<__is_assignable(_Tp, _Up)> { };
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <class _Tp, class _Arg> template <class _Tp, class _Arg>
inline constexpr bool is_assignable_v = __is_assignable(_Tp, _Arg); inline constexpr bool is_assignable_v = __is_assignable(_Tp, _Arg);
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_ASSIGNABLE_H #endif // _LIBCPP___TYPE_TRAITS_IS_ASSIGNABLE_H

libcxx/include/__type_traits/is_base_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 _Bp, class _Dp> template <class _Bp, class _Dp>
struct _LIBCPP_TEMPLATE_VIS is_base_of struct is_base_of : public integral_constant<bool, __is_base_of(_Bp, _Dp)> {};
: public integral_constant<bool, __is_base_of(_Bp, _Dp)> {};
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <class _Bp, class _Dp> template <class _Bp, class _Dp>
inline constexpr bool is_base_of_v = __is_base_of(_Bp, _Dp); inline constexpr bool is_base_of_v = __is_base_of(_Bp, _Dp);
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_BASE_OF_H #endif // _LIBCPP___TYPE_TRAITS_IS_BASE_OF_H

libcxx/include/__type_traits/is_bounded_array.h

Show All 13 Lines
#include <cstddef> #include <cstddef>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class> struct _LIBCPP_TEMPLATE_VIS __libcpp_is_bounded_array : false_type {}; template <class> struct __libcpp_is_bounded_array : false_type {};
template <class _Tp, size_t _Np> struct _LIBCPP_TEMPLATE_VIS __libcpp_is_bounded_array<_Tp[_Np]> : true_type {}; template <class _Tp, size_t _Np> struct __libcpp_is_bounded_array<_Tp[_Np]> : true_type {};
#if _LIBCPP_STD_VER >= 20 #if _LIBCPP_STD_VER >= 20
template <class> struct _LIBCPP_TEMPLATE_VIS is_bounded_array : false_type {}; template <class> struct is_bounded_array : false_type {};
template <class _Tp, size_t _Np> struct _LIBCPP_TEMPLATE_VIS is_bounded_array<_Tp[_Np]> : true_type {}; template <class _Tp, size_t _Np> struct is_bounded_array<_Tp[_Np]> : true_type {};
template <class _Tp> template <class _Tp>
inline constexpr inline constexpr
bool is_bounded_array_v = is_bounded_array<_Tp>::value; bool is_bounded_array_v = is_bounded_array<_Tp>::value;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_BOUNDED_ARRAY_H #endif // _LIBCPP___TYPE_TRAITS_IS_BOUNDED_ARRAY_H

libcxx/include/__type_traits/is_class.h

Show All 12 Lines
#include <__type_traits/integral_constant.h> #include <__type_traits/integral_constant.h>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_class template <class _Tp>
: public integral_constant<bool, __is_class(_Tp)> {}; struct is_class : public integral_constant<bool, __is_class(_Tp)> {};
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_class_v = __is_class(_Tp); inline constexpr bool is_class_v = __is_class(_Tp);
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_CLASS_H #endif // _LIBCPP___TYPE_TRAITS_IS_CLASS_H

libcxx/include/__type_traits/is_compound.h

Show All 16 Lines
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if __has_builtin(__is_compound) #if __has_builtin(__is_compound)
template<class _Tp> template<class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_compound : _BoolConstant<__is_compound(_Tp)> { }; struct is_compound : _BoolConstant<__is_compound(_Tp)> { };
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_compound_v = __is_compound(_Tp); inline constexpr bool is_compound_v = __is_compound(_Tp);
#endif #endif
#else // __has_builtin(__is_compound) #else // __has_builtin(__is_compound)
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_compound template <class _Tp>
: public integral_constant<bool, !is_fundamental<_Tp>::value> {}; struct is_compound : public integral_constant<bool, !is_fundamental<_Tp>::value> {};
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_compound_v = is_compound<_Tp>::value; inline constexpr bool is_compound_v = is_compound<_Tp>::value;
#endif #endif
#endif // __has_builtin(__is_compound) #endif // __has_builtin(__is_compound)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_COMPOUND_H #endif // _LIBCPP___TYPE_TRAITS_IS_COMPOUND_H

libcxx/include/__type_traits/is_const.h

Show All 15 Lines
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if __has_builtin(__is_const) #if __has_builtin(__is_const)
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_const : _BoolConstant<__is_const(_Tp)> { }; struct is_const : _BoolConstant<__is_const(_Tp)> { };
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_const_v = __is_const(_Tp); inline constexpr bool is_const_v = __is_const(_Tp);
#endif #endif
#else #else
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_const : public false_type {}; template <class _Tp> struct is_const : public false_type {};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_const<_Tp const> : public true_type {}; template <class _Tp> struct is_const<_Tp const> : public true_type {};
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_const_v = is_const<_Tp>::value; inline constexpr bool is_const_v = is_const<_Tp>::value;
#endif #endif
#endif // __has_builtin(__is_const) #endif // __has_builtin(__is_const)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_CONST_H #endif // _LIBCPP___TYPE_TRAITS_IS_CONST_H

libcxx/include/__type_traits/is_constructible.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, class ..._Args> template <class _Tp, class ..._Args>
struct _LIBCPP_TEMPLATE_VIS is_constructible struct is_constructible : public integral_constant<bool, __is_constructible(_Tp, _Args...)> {};
: public integral_constant<bool, __is_constructible(_Tp, _Args...)>
{ };
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <class _Tp, class ..._Args> template <class _Tp, class ..._Args>
inline constexpr bool is_constructible_v = __is_constructible(_Tp, _Args...); inline constexpr bool is_constructible_v = __is_constructible(_Tp, _Args...);
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_IS_CONSTRUCTIBLE_H #endif // _LIBCPP___TYPE_IS_CONSTRUCTIBLE_H

libcxx/include/__type_traits/is_convertible.h

Show All 21 Lines
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if __has_builtin(__is_convertible) && !defined(_LIBCPP_USE_IS_CONVERTIBLE_FALLBACK) #if __has_builtin(__is_convertible) && !defined(_LIBCPP_USE_IS_CONVERTIBLE_FALLBACK)
template <class _T1, class _T2> template <class _T1, class _T2>
struct _LIBCPP_TEMPLATE_VIS is_convertible : public integral_constant<bool, __is_convertible(_T1, _T2)> {}; struct is_convertible : public integral_constant<bool, __is_convertible(_T1, _T2)> {};
#elif __has_builtin(__is_convertible_to) && !defined(_LIBCPP_USE_IS_CONVERTIBLE_FALLBACK) #elif __has_builtin(__is_convertible_to) && !defined(_LIBCPP_USE_IS_CONVERTIBLE_FALLBACK)
template <class _T1, class _T2> struct _LIBCPP_TEMPLATE_VIS is_convertible template <class _T1, class _T2>
: public integral_constant<bool, __is_convertible_to(_T1, _T2)> {}; struct is_convertible : public integral_constant<bool, __is_convertible_to(_T1, _T2)> {};
// TODO: Remove this fallback when GCC < 13 support is no longer required. // TODO: Remove this fallback when GCC < 13 support is no longer required.
// GCC 13 has the __is_convertible built-in. // GCC 13 has the __is_convertible built-in.
#else // __has_builtin(__is_convertible_to) && !defined(_LIBCPP_USE_IS_CONVERTIBLE_FALLBACK) #else // __has_builtin(__is_convertible_to) && !defined(_LIBCPP_USE_IS_CONVERTIBLE_FALLBACK)
namespace __is_convertible_imp namespace __is_convertible_imp
{ {
template <class _Tp> void __test_convert(_Tp); template <class _Tp> void __test_convert(_Tp);
▲ Show 20 Lines • Show All 47 Lines • ▼ Show 20 Lines
template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 2, 2> : public false_type {}; template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 2, 2> : public false_type {};
template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 3, 2> : public false_type {}; template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 3, 2> : public false_type {};
template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 0, 3> : public false_type {}; template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 0, 3> : public false_type {};
template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 1, 3> : public false_type {}; template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 1, 3> : public false_type {};
template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 2, 3> : public false_type {}; template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 2, 3> : public false_type {};
template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 3, 3> : public true_type {}; template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 3, 3> : public true_type {};
template <class _T1, class _T2> struct _LIBCPP_TEMPLATE_VIS is_convertible template <class _T1, class _T2>
: public __is_convertible<_T1, _T2> struct is_convertible : public __is_convertible<_T1, _T2>
{ {
static const size_t __complete_check1 = __is_convertible_check<_T1>::__v; static const size_t __complete_check1 = __is_convertible_check<_T1>::__v;
static const size_t __complete_check2 = __is_convertible_check<_T2>::__v; static const size_t __complete_check2 = __is_convertible_check<_T2>::__v;
}; };
#endif // __has_builtin(__is_convertible_to) && !defined(_LIBCPP_USE_IS_CONVERTIBLE_FALLBACK) #endif // __has_builtin(__is_convertible_to) && !defined(_LIBCPP_USE_IS_CONVERTIBLE_FALLBACK)
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <class _From, class _To> template <class _From, class _To>
inline constexpr bool is_convertible_v = is_convertible<_From, _To>::value; inline constexpr bool is_convertible_v = is_convertible<_From, _To>::value;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_CONVERTIBLE_H #endif // _LIBCPP___TYPE_TRAITS_IS_CONVERTIBLE_H

libcxx/include/__type_traits/is_copy_assignable.h

Show All 15 Lines
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_copy_assignable struct is_copy_assignable
: public integral_constant< : public integral_constant<
bool, bool,
__is_assignable(__add_lvalue_reference_t<_Tp>, __is_assignable(__add_lvalue_reference_t<_Tp>,
__add_lvalue_reference_t<typename add_const<_Tp>::type>)> {}; __add_lvalue_reference_t<typename add_const<_Tp>::type>)> {};
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_copy_assignable_v = is_copy_assignable<_Tp>::value; inline constexpr bool is_copy_assignable_v = is_copy_assignable<_Tp>::value;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_COPY_ASSIGNABLE_H #endif // _LIBCPP___TYPE_TRAITS_IS_COPY_ASSIGNABLE_H

libcxx/include/__type_traits/is_copy_constructible.h

Show All 15 Lines
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_copy_constructible struct is_copy_constructible
: public integral_constant< : public integral_constant<
bool, bool,
__is_constructible(_Tp, __add_lvalue_reference_t<typename add_const<_Tp>::type>)> {}; __is_constructible(_Tp, __add_lvalue_reference_t<typename add_const<_Tp>::type>)> {};
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_copy_constructible_v = is_copy_constructible<_Tp>::value; inline constexpr bool is_copy_constructible_v = is_copy_constructible<_Tp>::value;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_COPY_CONSTRUCTIBLE_H #endif // _LIBCPP___TYPE_TRAITS_IS_COPY_CONSTRUCTIBLE_H

libcxx/include/__type_traits/is_default_constructible.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>
struct _LIBCPP_TEMPLATE_VIS is_default_constructible struct is_default_constructible : public integral_constant<bool, __is_constructible(_Tp)> {};
: public integral_constant<bool, __is_constructible(_Tp)>
{};
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_default_constructible_v = __is_constructible(_Tp); inline constexpr bool is_default_constructible_v = __is_constructible(_Tp);
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_DEFAULT_CONSTRUCTIBLE_H #endif // _LIBCPP___TYPE_TRAITS_IS_DEFAULT_CONSTRUCTIBLE_H

libcxx/include/__type_traits/is_destructible.h

Show All 19 Lines
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if __has_builtin(__is_destructible) #if __has_builtin(__is_destructible)
template<class _Tp> template<class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_destructible : _BoolConstant<__is_destructible(_Tp)> { }; struct is_destructible : _BoolConstant<__is_destructible(_Tp)> { };
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_destructible_v = __is_destructible(_Tp); inline constexpr bool is_destructible_v = __is_destructible(_Tp);
#endif #endif
#else // __has_builtin(__is_destructible) #else // __has_builtin(__is_destructible)
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

libcxx/include/__type_traits/is_empty.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>
struct _LIBCPP_TEMPLATE_VIS is_empty struct is_empty : public integral_constant<bool, __is_empty(_Tp)> {};
: public integral_constant<bool, __is_empty(_Tp)> {};
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_empty_v = __is_empty(_Tp); inline constexpr bool is_empty_v = __is_empty(_Tp);
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_EMPTY_H #endif // _LIBCPP___TYPE_TRAITS_IS_EMPTY_H

libcxx/include/__type_traits/is_enum.h

Show All 12 Lines
#include <__type_traits/integral_constant.h> #include <__type_traits/integral_constant.h>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_enum template <class _Tp>
: public integral_constant<bool, __is_enum(_Tp)> {}; struct is_enum : public integral_constant<bool, __is_enum(_Tp)> {};
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_enum_v = __is_enum(_Tp); inline constexpr bool is_enum_v = __is_enum(_Tp);
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_ENUM_H #endif // _LIBCPP___TYPE_TRAITS_IS_ENUM_H

libcxx/include/__type_traits/is_final.h

Show All 12 Lines
#include <__type_traits/integral_constant.h> #include <__type_traits/integral_constant.h>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS template <class _Tp>
__libcpp_is_final : public integral_constant<bool, __is_final(_Tp)> {}; struct __libcpp_is_final : public integral_constant<bool, __is_final(_Tp)> {};
#if _LIBCPP_STD_VER >= 14 #if _LIBCPP_STD_VER >= 14
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS template <class _Tp>
is_final : public integral_constant<bool, __is_final(_Tp)> {}; struct is_final : public integral_constant<bool, __is_final(_Tp)> {};
#endif #endif
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_final_v = __is_final(_Tp); inline constexpr bool is_final_v = __is_final(_Tp);
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_FINAL_H #endif // _LIBCPP___TYPE_TRAITS_IS_FINAL_H

libcxx/include/__type_traits/is_floating_point.h

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

libcxx/include/__type_traits/is_function.h

Show All 17 Lines
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if __has_builtin(__is_function) #if __has_builtin(__is_function)
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_function : integral_constant<bool, __is_function(_Tp)> {}; struct is_function : integral_constant<bool, __is_function(_Tp)> {};
#else #else
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_function struct is_function : public integral_constant<bool, !(is_reference<_Tp>::value || is_const<const _Tp>::value)> {};
: public integral_constant<bool, !(is_reference<_Tp>::value || is_const<const _Tp>::value)> {};
#endif // __has_builtin(__is_function) #endif // __has_builtin(__is_function)
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_function_v = is_function<_Tp>::value; inline constexpr bool is_function_v = is_function<_Tp>::value;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_FUNCTIONAL_H #endif // _LIBCPP___TYPE_TRAITS_IS_FUNCTIONAL_H

libcxx/include/__type_traits/is_fundamental.h

Show All 17 Lines
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if __has_builtin(__is_fundamental) #if __has_builtin(__is_fundamental)
template<class _Tp> template<class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_fundamental : _BoolConstant<__is_fundamental(_Tp)> { }; struct is_fundamental : _BoolConstant<__is_fundamental(_Tp)> { };
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_fundamental_v = __is_fundamental(_Tp); inline constexpr bool is_fundamental_v = __is_fundamental(_Tp);
#endif #endif
#else // __has_builtin(__is_fundamental) #else // __has_builtin(__is_fundamental)
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_fundamental template <class _Tp> struct is_fundamental
: public integral_constant<bool, is_void<_Tp>::value || : public integral_constant<bool, is_void<_Tp>::value ||
__is_nullptr_t<_Tp>::value || __is_nullptr_t<_Tp>::value ||
is_arithmetic<_Tp>::value> {}; is_arithmetic<_Tp>::value> {};
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_fundamental_v = is_fundamental<_Tp>::value; inline constexpr bool is_fundamental_v = is_fundamental<_Tp>::value;
#endif #endif
#endif // __has_builtin(__is_fundamental) #endif // __has_builtin(__is_fundamental)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_FUNDAMENTAL_H #endif // _LIBCPP___TYPE_TRAITS_IS_FUNDAMENTAL_H

libcxx/include/__type_traits/is_integral.h

Show First 20 Lines • Show All 42 Lines • ▼ Show 20 Lines
#ifndef _LIBCPP_HAS_NO_INT128 #ifndef _LIBCPP_HAS_NO_INT128
template <> struct __libcpp_is_integral<__int128_t> { enum { value = 1 }; }; template <> struct __libcpp_is_integral<__int128_t> { enum { value = 1 }; };
template <> struct __libcpp_is_integral<__uint128_t> { enum { value = 1 }; }; template <> struct __libcpp_is_integral<__uint128_t> { enum { value = 1 }; };
#endif #endif
#if __has_builtin(__is_integral) #if __has_builtin(__is_integral)
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_integral : _BoolConstant<__is_integral(_Tp)> { }; struct is_integral : _BoolConstant<__is_integral(_Tp)> { };
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_integral_v = __is_integral(_Tp); inline constexpr bool is_integral_v = __is_integral(_Tp);
#endif #endif
#else #else
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_integral template <class _Tp>
: public _BoolConstant<__libcpp_is_integral<__remove_cv_t<_Tp> >::value> {}; struct is_integral : public _BoolConstant<__libcpp_is_integral<__remove_cv_t<_Tp> >::value> {};
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_integral_v = is_integral<_Tp>::value; inline constexpr bool is_integral_v = is_integral<_Tp>::value;
#endif #endif
#endif // __has_builtin(__is_integral) #endif // __has_builtin(__is_integral)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_INTEGRAL_H #endif // _LIBCPP___TYPE_TRAITS_IS_INTEGRAL_H

libcxx/include/__type_traits/is_literal_type.h

Show All 13 Lines
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_TYPE_TRAITS) #if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_TYPE_TRAITS)
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX17 is_literal_type template <class _Tp>
: public integral_constant<bool, __is_literal_type(_Tp)> struct _LIBCPP_DEPRECATED_IN_CXX17 is_literal_type : public integral_constant<bool, __is_literal_type(_Tp)> {};
{};
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
_LIBCPP_DEPRECATED_IN_CXX17 inline constexpr bool is_literal_type_v = __is_literal_type(_Tp); _LIBCPP_DEPRECATED_IN_CXX17 inline constexpr bool is_literal_type_v = __is_literal_type(_Tp);
#endif // _LIBCPP_STD_VER >= 17 #endif // _LIBCPP_STD_VER >= 17
#endif // _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_TYPE_TRAITS) #endif // _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_TYPE_TRAITS)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_LITERAL_TYPE #endif // _LIBCPP___TYPE_TRAITS_IS_LITERAL_TYPE

libcxx/include/__type_traits/is_member_function_pointer.h

Show All 33 Lines enum {
__is_func = is_function<_Tp>::value, __is_func = is_function<_Tp>::value,
__is_obj = !__is_func, __is_obj = !__is_func,
}; };
}; };
#if __has_builtin(__is_member_function_pointer) #if __has_builtin(__is_member_function_pointer)
template<class _Tp> template<class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_member_function_pointer struct is_member_function_pointer : _BoolConstant<__is_member_function_pointer(_Tp)> { };
: _BoolConstant<__is_member_function_pointer(_Tp)> { };
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_member_function_pointer_v = __is_member_function_pointer(_Tp); inline constexpr bool is_member_function_pointer_v = __is_member_function_pointer(_Tp);
#endif #endif
#else // __has_builtin(__is_member_function_pointer) #else // __has_builtin(__is_member_function_pointer)
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_member_function_pointer template <class _Tp>
: public _BoolConstant< __libcpp_is_member_pointer<__remove_cv_t<_Tp> >::__is_func > {}; struct is_member_function_pointer : public _BoolConstant< __libcpp_is_member_pointer<__remove_cv_t<_Tp> >::__is_func > {
};
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_member_function_pointer_v = is_member_function_pointer<_Tp>::value; inline constexpr bool is_member_function_pointer_v = is_member_function_pointer<_Tp>::value;
#endif #endif
#endif // __has_builtin(__is_member_function_pointer) #endif // __has_builtin(__is_member_function_pointer)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_MEMBER_FUNCTION_POINTER_H #endif // _LIBCPP___TYPE_TRAITS_IS_MEMBER_FUNCTION_POINTER_H

libcxx/include/__type_traits/is_member_object_pointer.h

Show All 15 Lines
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if __has_builtin(__is_member_object_pointer) #if __has_builtin(__is_member_object_pointer)
template<class _Tp> template<class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_member_object_pointer struct is_member_object_pointer : _BoolConstant<__is_member_object_pointer(_Tp)> { };
: _BoolConstant<__is_member_object_pointer(_Tp)> { };
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_member_object_pointer_v = __is_member_object_pointer(_Tp); inline constexpr bool is_member_object_pointer_v = __is_member_object_pointer(_Tp);
#endif #endif
#else // __has_builtin(__is_member_object_pointer) #else // __has_builtin(__is_member_object_pointer)
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_member_object_pointer template <class _Tp>
: public _BoolConstant< __libcpp_is_member_pointer<__remove_cv_t<_Tp> >::__is_obj > {}; struct is_member_object_pointer : public _BoolConstant< __libcpp_is_member_pointer<__remove_cv_t<_Tp> >::__is_obj > {};
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_member_object_pointer_v = is_member_object_pointer<_Tp>::value; inline constexpr bool is_member_object_pointer_v = is_member_object_pointer<_Tp>::value;
#endif #endif
#endif // __has_builtin(__is_member_object_pointer) #endif // __has_builtin(__is_member_object_pointer)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_MEMBER_FUNCTION_POINTER_H #endif // _LIBCPP___TYPE_TRAITS_IS_MEMBER_FUNCTION_POINTER_H

libcxx/include/__type_traits/is_member_pointer.h

Show All 16 Lines
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if __has_builtin(__is_member_pointer) #if __has_builtin(__is_member_pointer)
template<class _Tp> template<class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_member_pointer : _BoolConstant<__is_member_pointer(_Tp)> { }; struct is_member_pointer : _BoolConstant<__is_member_pointer(_Tp)> { };
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_member_pointer_v = __is_member_pointer(_Tp); inline constexpr bool is_member_pointer_v = __is_member_pointer(_Tp);
#endif #endif
#else // __has_builtin(__is_member_pointer) #else // __has_builtin(__is_member_pointer)
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_member_pointer template <class _Tp>
: public _BoolConstant< __libcpp_is_member_pointer<__remove_cv_t<_Tp> >::__is_member > {}; struct is_member_pointer : public _BoolConstant< __libcpp_is_member_pointer<__remove_cv_t<_Tp> >::__is_member > {};
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_member_pointer_v = is_member_pointer<_Tp>::value; inline constexpr bool is_member_pointer_v = is_member_pointer<_Tp>::value;
#endif #endif
#endif // __has_builtin(__is_member_pointer) #endif // __has_builtin(__is_member_pointer)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_MEMBER_POINTER_H #endif // _LIBCPP___TYPE_TRAITS_IS_MEMBER_POINTER_H

libcxx/include/__type_traits/is_move_assignable.h

Show All 15 Lines
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_move_assignable struct is_move_assignable
: public integral_constant< : public integral_constant<
bool, bool,
__is_assignable(__add_lvalue_reference_t<_Tp>, __add_rvalue_reference_t<_Tp>)> {}; __is_assignable(__add_lvalue_reference_t<_Tp>, __add_rvalue_reference_t<_Tp>)> {};
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_move_assignable_v = is_move_assignable<_Tp>::value; inline constexpr bool is_move_assignable_v = is_move_assignable<_Tp>::value;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_MOVE_ASSIGNABLE_H #endif // _LIBCPP___TYPE_TRAITS_IS_MOVE_ASSIGNABLE_H

libcxx/include/__type_traits/is_move_constructible.h

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

libcxx/include/__type_traits/is_nothrow_assignable.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, class _Arg> template <class _Tp, class _Arg>
struct _LIBCPP_TEMPLATE_VIS is_nothrow_assignable struct is_nothrow_assignable : public integral_constant<bool, __is_nothrow_assignable(_Tp, _Arg)> {};
: public integral_constant<bool, __is_nothrow_assignable(_Tp, _Arg)> {};
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <class _Tp, class _Arg> template <class _Tp, class _Arg>
inline constexpr bool is_nothrow_assignable_v = __is_nothrow_assignable(_Tp, _Arg); inline constexpr bool is_nothrow_assignable_v = __is_nothrow_assignable(_Tp, _Arg);
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_NOTHROW_ASSIGNABLE_H #endif // _LIBCPP___TYPE_TRAITS_IS_NOTHROW_ASSIGNABLE_H

libcxx/include/__type_traits/is_nothrow_constructible.h

Show All 20 Lines
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if __has_builtin(__is_nothrow_constructible) #if __has_builtin(__is_nothrow_constructible)
template < template <
class _Tp, class... _Args> class _Tp, class... _Args>
struct _LIBCPP_TEMPLATE_VIS is_nothrow_constructible struct is_nothrow_constructible : public integral_constant<bool, __is_nothrow_constructible(_Tp, _Args...)> {};
: public integral_constant<bool, __is_nothrow_constructible(_Tp, _Args...)> {};
#else #else
template <bool, bool, class _Tp, class... _Args> struct __libcpp_is_nothrow_constructible; template <bool, bool, class _Tp, class... _Args> struct __libcpp_is_nothrow_constructible;
template <class _Tp, class... _Args> template <class _Tp, class... _Args>
struct __libcpp_is_nothrow_constructible</*is constructible*/true, /*is reference*/false, _Tp, _Args...> struct __libcpp_is_nothrow_constructible</*is constructible*/true, /*is reference*/false, _Tp, _Args...>
: public integral_constant<bool, noexcept(_Tp(std::declval<_Args>()...))> : public integral_constant<bool, noexcept(_Tp(std::declval<_Args>()...))>
{ {
Show All 10 Lines
template <class _Tp, bool _IsReference, class... _Args> template <class _Tp, bool _IsReference, class... _Args>
struct __libcpp_is_nothrow_constructible</*is constructible*/false, _IsReference, _Tp, _Args...> struct __libcpp_is_nothrow_constructible</*is constructible*/false, _IsReference, _Tp, _Args...>
: public false_type : public false_type
{ {
}; };
template <class _Tp, class... _Args> template <class _Tp, class... _Args>
struct _LIBCPP_TEMPLATE_VIS is_nothrow_constructible struct is_nothrow_constructible
: __libcpp_is_nothrow_constructible<is_constructible<_Tp, _Args...>::value, is_reference<_Tp>::value, _Tp, _Args...> : __libcpp_is_nothrow_constructible<is_constructible<_Tp, _Args...>::value, is_reference<_Tp>::value, _Tp, _Args...>
{ {
}; };
template <class _Tp, size_t _Ns> template <class _Tp, size_t _Ns>
struct _LIBCPP_TEMPLATE_VIS is_nothrow_constructible<_Tp[_Ns]> struct is_nothrow_constructible<_Tp[_Ns]>
: __libcpp_is_nothrow_constructible<is_constructible<_Tp>::value, is_reference<_Tp>::value, _Tp> : __libcpp_is_nothrow_constructible<is_constructible<_Tp>::value, is_reference<_Tp>::value, _Tp>
{ {
}; };
#endif // __has_builtin(__is_nothrow_constructible) #endif // __has_builtin(__is_nothrow_constructible)
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <class _Tp, class ..._Args> template <class _Tp, class ..._Args>
inline constexpr bool is_nothrow_constructible_v = is_nothrow_constructible<_Tp, _Args...>::value; inline constexpr bool is_nothrow_constructible_v = is_nothrow_constructible<_Tp, _Args...>::value;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_NOTHROW_CONSTRUCTIBLE_H #endif // _LIBCPP___TYPE_TRAITS_IS_NOTHROW_CONSTRUCTIBLE_H

libcxx/include/__type_traits/is_nothrow_copy_assignable.h

Show All 15 Lines
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_nothrow_copy_assignable struct is_nothrow_copy_assignable
: public integral_constant< : public integral_constant<
bool, bool,
__is_nothrow_assignable( __is_nothrow_assignable(
__add_lvalue_reference_t<_Tp>, __add_lvalue_reference_t<_Tp>,
__add_lvalue_reference_t<typename add_const<_Tp>::type>)> {}; __add_lvalue_reference_t<typename add_const<_Tp>::type>)> {};
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_nothrow_copy_assignable_v = is_nothrow_copy_assignable<_Tp>::value; inline constexpr bool is_nothrow_copy_assignable_v = is_nothrow_copy_assignable<_Tp>::value;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_NOTHROW_COPY_ASSIGNABLE_H #endif // _LIBCPP___TYPE_TRAITS_IS_NOTHROW_COPY_ASSIGNABLE_H

libcxx/include/__type_traits/is_nothrow_copy_constructible.h

Show All 18 Lines
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
// TODO: remove this implementation once https://gcc.gnu.org/bugzilla/show_bug.cgi?id=106611 is fixed // TODO: remove this implementation once https://gcc.gnu.org/bugzilla/show_bug.cgi?id=106611 is fixed
#ifdef _LIBCPP_COMPILER_GCC #ifdef _LIBCPP_COMPILER_GCC
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_nothrow_copy_constructible template <class _Tp>
: public is_nothrow_constructible<_Tp, struct is_nothrow_copy_constructible
__add_lvalue_reference_t<typename add_const<_Tp>::type> > {}; : public is_nothrow_constructible<_Tp, __add_lvalue_reference_t<typename add_const<_Tp>::type> > {};
#else // _LIBCPP_COMPILER_GCC #else // _LIBCPP_COMPILER_GCC
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_nothrow_copy_constructible struct is_nothrow_copy_constructible
: public integral_constant< : public integral_constant<
bool, bool,
__is_nothrow_constructible(_Tp, typename add_lvalue_reference<typename add_const<_Tp>::type>::type)> {}; __is_nothrow_constructible(_Tp, typename add_lvalue_reference<typename add_const<_Tp>::type>::type)> {};
#endif // _LIBCPP_COMPILER_GCC #endif // _LIBCPP_COMPILER_GCC
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_nothrow_copy_constructible_v = is_nothrow_copy_constructible<_Tp>::value; inline constexpr bool is_nothrow_copy_constructible_v = is_nothrow_copy_constructible<_Tp>::value;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_NOTHROW_COPY_CONSTRUCTIBLE_H #endif // _LIBCPP___TYPE_TRAITS_IS_NOTHROW_COPY_CONSTRUCTIBLE_H

libcxx/include/__type_traits/is_nothrow_default_constructible.h

Show All 12 Lines
#include <__type_traits/integral_constant.h> #include <__type_traits/integral_constant.h>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_nothrow_default_constructible template <class _Tp>
: public integral_constant<bool, __is_nothrow_constructible(_Tp)> struct is_nothrow_default_constructible : public integral_constant<bool, __is_nothrow_constructible(_Tp)> {};
{};
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_nothrow_default_constructible_v = __is_nothrow_constructible(_Tp); inline constexpr bool is_nothrow_default_constructible_v = __is_nothrow_constructible(_Tp);
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_NOTHROW_DEFAULT_CONSTRUCTIBLE_H #endif // _LIBCPP___TYPE_TRAITS_IS_NOTHROW_DEFAULT_CONSTRUCTIBLE_H

libcxx/include/__type_traits/is_nothrow_destructible.h

Show All 35 Lines
template <class _Tp> template <class _Tp>
struct __libcpp_is_nothrow_destructible<true, _Tp> struct __libcpp_is_nothrow_destructible<true, _Tp>
: public integral_constant<bool, noexcept(std::declval<_Tp>().~_Tp()) > : public integral_constant<bool, noexcept(std::declval<_Tp>().~_Tp()) >
{ {
}; };
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_nothrow_destructible struct is_nothrow_destructible : public __libcpp_is_nothrow_destructible<is_destructible<_Tp>::value, _Tp> {};
: public __libcpp_is_nothrow_destructible<is_destructible<_Tp>::value, _Tp>
{
};
template <class _Tp, size_t _Ns> template <class _Tp, size_t _Ns>
struct _LIBCPP_TEMPLATE_VIS is_nothrow_destructible<_Tp[_Ns]> struct is_nothrow_destructible<_Tp[_Ns]> : public is_nothrow_destructible<_Tp> {};
: public is_nothrow_destructible<_Tp>
{
};
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_nothrow_destructible<_Tp&> struct is_nothrow_destructible<_Tp&> : public true_type {};
: public true_type
{
};
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_nothrow_destructible<_Tp&&> struct is_nothrow_destructible<_Tp&&> : public true_type {};
: public true_type
{
};
#else #else
template <class _Tp> struct __libcpp_nothrow_destructor template <class _Tp> struct __libcpp_nothrow_destructor
: public integral_constant<bool, is_scalar<_Tp>::value || : public integral_constant<bool, is_scalar<_Tp>::value ||
is_reference<_Tp>::value> {}; is_reference<_Tp>::value> {};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_nothrow_destructible template <class _Tp>
: public __libcpp_nothrow_destructor<__remove_all_extents_t<_Tp> > {}; struct is_nothrow_destructible : public __libcpp_nothrow_destructor<__remove_all_extents_t<_Tp> > {};
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_nothrow_destructible<_Tp[]> struct is_nothrow_destructible<_Tp[]> : public false_type {};
: public false_type {};
#endif #endif
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_nothrow_destructible_v = is_nothrow_destructible<_Tp>::value; inline constexpr bool is_nothrow_destructible_v = is_nothrow_destructible<_Tp>::value;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_NOTHROW_DESTRUCTIBLE_H #endif // _LIBCPP___TYPE_TRAITS_IS_NOTHROW_DESTRUCTIBLE_H

libcxx/include/__type_traits/is_nothrow_move_assignable.h

Show All 15 Lines
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_nothrow_move_assignable struct is_nothrow_move_assignable
: public integral_constant< : public integral_constant<
bool, bool,
__is_nothrow_assignable(__add_lvalue_reference_t<_Tp>, __add_rvalue_reference_t<_Tp>)> { __is_nothrow_assignable(__add_lvalue_reference_t<_Tp>, __add_rvalue_reference_t<_Tp>)> {
}; };
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_nothrow_move_assignable_v = is_nothrow_move_assignable<_Tp>::value; inline constexpr bool is_nothrow_move_assignable_v = is_nothrow_move_assignable<_Tp>::value;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_NOTHROW_MOVE_ASSIGNABLE_H #endif // _LIBCPP___TYPE_TRAITS_IS_NOTHROW_MOVE_ASSIGNABLE_H

libcxx/include/__type_traits/is_nothrow_move_constructible.h

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

libcxx/include/__type_traits/is_null_pointer.h

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

libcxx/include/__type_traits/is_object.h

Show All 19 Lines
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if __has_builtin(__is_object) #if __has_builtin(__is_object)
template<class _Tp> template<class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_object : _BoolConstant<__is_object(_Tp)> { }; struct is_object : _BoolConstant<__is_object(_Tp)> { };
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_object_v = __is_object(_Tp); inline constexpr bool is_object_v = __is_object(_Tp);
#endif #endif
#else // __has_builtin(__is_object) #else // __has_builtin(__is_object)
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_object template <class _Tp> struct is_object
: public integral_constant<bool, is_scalar<_Tp>::value || : public integral_constant<bool, is_scalar<_Tp>::value ||
is_array<_Tp>::value || is_array<_Tp>::value ||
is_union<_Tp>::value || is_union<_Tp>::value ||
is_class<_Tp>::value > {}; is_class<_Tp>::value > {};
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_object_v = is_object<_Tp>::value; inline constexpr bool is_object_v = is_object<_Tp>::value;
#endif #endif
#endif // __has_builtin(__is_object) #endif // __has_builtin(__is_object)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_OBJECT_H #endif // _LIBCPP___TYPE_TRAITS_IS_OBJECT_H

libcxx/include/__type_traits/is_pod.h

Show All 12 Lines
#include <__type_traits/integral_constant.h> #include <__type_traits/integral_constant.h>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_pod template <class _Tp>
: public integral_constant<bool, __is_pod(_Tp)> {}; struct is_pod : public integral_constant<bool, __is_pod(_Tp)> {};
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_pod_v = __is_pod(_Tp); inline constexpr bool is_pod_v = __is_pod(_Tp);
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_POD_H #endif // _LIBCPP___TYPE_TRAITS_IS_POD_H

libcxx/include/__type_traits/is_pointer.h

Show All 16 Lines
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if __has_builtin(__is_pointer) #if __has_builtin(__is_pointer)
template<class _Tp> template<class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_pointer : _BoolConstant<__is_pointer(_Tp)> { }; struct is_pointer : _BoolConstant<__is_pointer(_Tp)> { };
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_pointer_v = __is_pointer(_Tp); inline constexpr bool is_pointer_v = __is_pointer(_Tp);
#endif #endif
#else // __has_builtin(__is_pointer) #else // __has_builtin(__is_pointer)
template <class _Tp> struct __libcpp_is_pointer : public false_type {}; template <class _Tp> struct __libcpp_is_pointer : public false_type {};
template <class _Tp> struct __libcpp_is_pointer<_Tp*> : public true_type {}; template <class _Tp> struct __libcpp_is_pointer<_Tp*> : public true_type {};
template <class _Tp> struct __libcpp_remove_objc_qualifiers { typedef _Tp type; }; template <class _Tp> struct __libcpp_remove_objc_qualifiers { typedef _Tp type; };
#if defined(_LIBCPP_HAS_OBJC_ARC) #if defined(_LIBCPP_HAS_OBJC_ARC)
template <class _Tp> struct __libcpp_remove_objc_qualifiers<_Tp __strong> { typedef _Tp type; }; template <class _Tp> struct __libcpp_remove_objc_qualifiers<_Tp __strong> { typedef _Tp type; };
template <class _Tp> struct __libcpp_remove_objc_qualifiers<_Tp __weak> { typedef _Tp type; }; template <class _Tp> struct __libcpp_remove_objc_qualifiers<_Tp __weak> { typedef _Tp type; };
template <class _Tp> struct __libcpp_remove_objc_qualifiers<_Tp __autoreleasing> { typedef _Tp type; }; template <class _Tp> struct __libcpp_remove_objc_qualifiers<_Tp __autoreleasing> { typedef _Tp type; };
template <class _Tp> struct __libcpp_remove_objc_qualifiers<_Tp __unsafe_unretained> { typedef _Tp type; }; template <class _Tp> struct __libcpp_remove_objc_qualifiers<_Tp __unsafe_unretained> { typedef _Tp type; };
#endif #endif
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_pointer template <class _Tp>
: public __libcpp_is_pointer<typename __libcpp_remove_objc_qualifiers<__remove_cv_t<_Tp> >::type> {}; struct is_pointer : public __libcpp_is_pointer<typename __libcpp_remove_objc_qualifiers<__remove_cv_t<_Tp> >::type> {};
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_pointer_v = is_pointer<_Tp>::value; inline constexpr bool is_pointer_v = is_pointer<_Tp>::value;
#endif #endif
#endif // __has_builtin(__is_pointer) #endif // __has_builtin(__is_pointer)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_POINTER_H #endif // _LIBCPP___TYPE_TRAITS_IS_POINTER_H

libcxx/include/__type_traits/is_polymorphic.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>
struct _LIBCPP_TEMPLATE_VIS is_polymorphic struct is_polymorphic : public integral_constant<bool, __is_polymorphic(_Tp)> {};
: public integral_constant<bool, __is_polymorphic(_Tp)> {};
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_polymorphic_v = __is_polymorphic(_Tp); inline constexpr bool is_polymorphic_v = __is_polymorphic(_Tp);
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_POLYMORPHIC_H #endif // _LIBCPP___TYPE_TRAITS_IS_POLYMORPHIC_H

libcxx/include/__type_traits/is_reference.h

Show All 17 Lines
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if __has_builtin(__is_lvalue_reference) && \ #if __has_builtin(__is_lvalue_reference) && \
__has_builtin(__is_rvalue_reference) && \ __has_builtin(__is_rvalue_reference) && \
__has_builtin(__is_reference) __has_builtin(__is_reference)
template<class _Tp> template<class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_lvalue_reference : _BoolConstant<__is_lvalue_reference(_Tp)> { }; struct is_lvalue_reference : _BoolConstant<__is_lvalue_reference(_Tp)> { };
template<class _Tp> template<class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_rvalue_reference : _BoolConstant<__is_rvalue_reference(_Tp)> { }; struct is_rvalue_reference : _BoolConstant<__is_rvalue_reference(_Tp)> { };
template<class _Tp> template<class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_reference : _BoolConstant<__is_reference(_Tp)> { }; struct is_reference : _BoolConstant<__is_reference(_Tp)> { };
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_reference_v = __is_reference(_Tp); inline constexpr bool is_reference_v = __is_reference(_Tp);
template <class _Tp> template <class _Tp>
inline constexpr bool is_lvalue_reference_v = __is_lvalue_reference(_Tp); inline constexpr bool is_lvalue_reference_v = __is_lvalue_reference(_Tp);
template <class _Tp> template <class _Tp>
inline constexpr bool is_rvalue_reference_v = __is_rvalue_reference(_Tp); inline constexpr bool is_rvalue_reference_v = __is_rvalue_reference(_Tp);
#endif #endif
#else // __has_builtin(__is_lvalue_reference) && etc... #else // __has_builtin(__is_lvalue_reference) && etc...
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_lvalue_reference : public false_type {}; template <class _Tp> struct is_lvalue_reference : public false_type {};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_lvalue_reference<_Tp&> : public true_type {}; template <class _Tp> struct is_lvalue_reference<_Tp&> : public true_type {};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_rvalue_reference : public false_type {}; template <class _Tp> struct is_rvalue_reference : public false_type {};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_rvalue_reference<_Tp&&> : public true_type {}; template <class _Tp> struct is_rvalue_reference<_Tp&&> : public true_type {};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_reference : public false_type {}; template <class _Tp> struct is_reference : public false_type {};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_reference<_Tp&> : public true_type {}; template <class _Tp> struct is_reference<_Tp&> : public true_type {};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_reference<_Tp&&> : public true_type {}; template <class _Tp> struct is_reference<_Tp&&> : public true_type {};
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_reference_v = is_reference<_Tp>::value; inline constexpr bool is_reference_v = is_reference<_Tp>::value;
template <class _Tp> template <class _Tp>
inline constexpr bool is_lvalue_reference_v = is_lvalue_reference<_Tp>::value; inline constexpr bool is_lvalue_reference_v = is_lvalue_reference<_Tp>::value;
Show All 9 Lines

libcxx/include/__type_traits/is_reference_wrapper.h

Show All 13 Lines
#include <__type_traits/remove_cv.h> #include <__type_traits/remove_cv.h>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp> class _LIBCPP_TEMPLATE_VIS reference_wrapper; template <class _Tp> class reference_wrapper;
template <class _Tp> struct __is_reference_wrapper_impl : public false_type {}; template <class _Tp> struct __is_reference_wrapper_impl : public false_type {};
template <class _Tp> struct __is_reference_wrapper_impl<reference_wrapper<_Tp> > : public true_type {}; template <class _Tp> struct __is_reference_wrapper_impl<reference_wrapper<_Tp> > : public true_type {};
template <class _Tp> struct __is_reference_wrapper template <class _Tp> struct __is_reference_wrapper
: public __is_reference_wrapper_impl<__remove_cv_t<_Tp> > {}; : public __is_reference_wrapper_impl<__remove_cv_t<_Tp> > {};
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_ENABLE_IF_H #endif // _LIBCPP___TYPE_TRAITS_ENABLE_IF_H

libcxx/include/__type_traits/is_same.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, class _Up> template <class _Tp, class _Up>
struct _LIBCPP_TEMPLATE_VIS is_same : _BoolConstant<__is_same(_Tp, _Up)> { }; struct is_same : _BoolConstant<__is_same(_Tp, _Up)> { };
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <class _Tp, class _Up> template <class _Tp, class _Up>
inline constexpr bool is_same_v = __is_same(_Tp, _Up); inline constexpr bool is_same_v = __is_same(_Tp, _Up);
#endif #endif
// _IsSame<T,U> has the same effect as is_same<T,U> but instantiates fewer types: // _IsSame<T,U> has the same effect as is_same<T,U> but instantiates fewer types:
// is_same<A,B> and is_same<C,D> are guaranteed to be different types, but // is_same<A,B> and is_same<C,D> are guaranteed to be different types, but
Show All 14 Lines

libcxx/include/__type_traits/is_scalar.h

Show All 20 Lines
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if __has_builtin(__is_scalar) #if __has_builtin(__is_scalar)
template<class _Tp> template<class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_scalar : _BoolConstant<__is_scalar(_Tp)> { }; struct is_scalar : _BoolConstant<__is_scalar(_Tp)> { };
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_scalar_v = __is_scalar(_Tp); inline constexpr bool is_scalar_v = __is_scalar(_Tp);
#endif #endif
#else // __has_builtin(__is_scalar) #else // __has_builtin(__is_scalar)
template <class _Tp> struct __is_block : false_type {}; template <class _Tp> struct __is_block : false_type {};
#if defined(_LIBCPP_HAS_EXTENSION_BLOCKS) #if defined(_LIBCPP_HAS_EXTENSION_BLOCKS)
template <class _Rp, class ..._Args> struct __is_block<_Rp (^)(_Args...)> : true_type {}; template <class _Rp, class ..._Args> struct __is_block<_Rp (^)(_Args...)> : true_type {};
#endif #endif
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_scalar template <class _Tp> struct is_scalar
: public integral_constant<bool, is_arithmetic<_Tp>::value || : public integral_constant<bool, is_arithmetic<_Tp>::value ||
is_member_pointer<_Tp>::value || is_member_pointer<_Tp>::value ||
is_pointer<_Tp>::value || is_pointer<_Tp>::value ||
__is_nullptr_t<_Tp>::value || __is_nullptr_t<_Tp>::value ||
__is_block<_Tp>::value || __is_block<_Tp>::value ||
is_enum<_Tp>::value > {}; is_enum<_Tp>::value > {};
template <> struct _LIBCPP_TEMPLATE_VIS is_scalar<nullptr_t> : public true_type {}; template <>
struct is_scalar<nullptr_t> : public true_type {};
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_scalar_v = is_scalar<_Tp>::value; inline constexpr bool is_scalar_v = is_scalar<_Tp>::value;
#endif #endif
#endif // __has_builtin(__is_scalar) #endif // __has_builtin(__is_scalar)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_SCALAR_H #endif // _LIBCPP___TYPE_TRAITS_IS_SCALAR_H

libcxx/include/__type_traits/is_scoped_enum.h

Show All 24 Lines
template <class _Tp, bool = is_enum_v<_Tp> > template <class _Tp, bool = is_enum_v<_Tp> >
struct __is_scoped_enum_helper : false_type {}; struct __is_scoped_enum_helper : false_type {};
template <class _Tp> template <class _Tp>
struct __is_scoped_enum_helper<_Tp, true> struct __is_scoped_enum_helper<_Tp, true>
: public bool_constant<!is_convertible_v<_Tp, underlying_type_t<_Tp> > > {}; : public bool_constant<!is_convertible_v<_Tp, underlying_type_t<_Tp> > > {};
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_scoped_enum struct is_scoped_enum : public __is_scoped_enum_helper<_Tp> {};
: public __is_scoped_enum_helper<_Tp> {};
template <class _Tp> template <class _Tp>
inline constexpr bool is_scoped_enum_v = is_scoped_enum<_Tp>::value; inline constexpr bool is_scoped_enum_v = is_scoped_enum<_Tp>::value;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_SCOPED_ENUM_H #endif // _LIBCPP___TYPE_TRAITS_IS_SCOPED_ENUM_H

libcxx/include/__type_traits/is_signed.h

Show All 17 Lines
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if __has_builtin(__is_signed) #if __has_builtin(__is_signed)
template<class _Tp> template<class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_signed : _BoolConstant<__is_signed(_Tp)> { }; struct is_signed : _BoolConstant<__is_signed(_Tp)> { };
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_signed_v = __is_signed(_Tp); inline constexpr bool is_signed_v = __is_signed(_Tp);
#endif #endif
#else // __has_builtin(__is_signed) #else // __has_builtin(__is_signed)
template <class _Tp, bool = is_integral<_Tp>::value> template <class _Tp, bool = is_integral<_Tp>::value>
struct __libcpp_is_signed_impl : public _BoolConstant<(_Tp(-1) < _Tp(0))> {}; struct __libcpp_is_signed_impl : public _BoolConstant<(_Tp(-1) < _Tp(0))> {};
template <class _Tp> template <class _Tp>
struct __libcpp_is_signed_impl<_Tp, false> : public true_type {}; // floating point struct __libcpp_is_signed_impl<_Tp, false> : public true_type {}; // floating point
template <class _Tp, bool = is_arithmetic<_Tp>::value> template <class _Tp, bool = is_arithmetic<_Tp>::value>
struct __libcpp_is_signed : public __libcpp_is_signed_impl<_Tp> {}; struct __libcpp_is_signed : public __libcpp_is_signed_impl<_Tp> {};
template <class _Tp> struct __libcpp_is_signed<_Tp, false> : public false_type {}; template <class _Tp> struct __libcpp_is_signed<_Tp, false> : public false_type {};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_signed : public __libcpp_is_signed<_Tp> {}; template <class _Tp>
struct is_signed : public __libcpp_is_signed<_Tp> {};
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_signed_v = is_signed<_Tp>::value; inline constexpr bool is_signed_v = is_signed<_Tp>::value;
#endif #endif
#endif // __has_builtin(__is_signed) #endif // __has_builtin(__is_signed)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_SIGNED_H #endif // _LIBCPP___TYPE_TRAITS_IS_SIGNED_H

libcxx/include/__type_traits/is_standard_layout.h

Show All 12 Lines
#include <__type_traits/integral_constant.h> #include <__type_traits/integral_constant.h>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_standard_layout template <class _Tp>
: public integral_constant<bool, __is_standard_layout(_Tp)> struct is_standard_layout : public integral_constant<bool, __is_standard_layout(_Tp)> {};
{};
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_standard_layout_v = __is_standard_layout(_Tp); inline constexpr bool is_standard_layout_v = __is_standard_layout(_Tp);
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_STANDARD_LAYOUT_H #endif // _LIBCPP___TYPE_TRAITS_IS_STANDARD_LAYOUT_H

libcxx/include/__type_traits/is_swappable.h

Show First 20 Lines • Show All 105 Lines • ▼ Show 20 Lines
struct __is_nothrow_swappable struct __is_nothrow_swappable
: public integral_constant<bool, __detail::__nothrow_swappable_with<_Tp&>::value> : public integral_constant<bool, __detail::__nothrow_swappable_with<_Tp&>::value>
{ {
}; };
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <class _Tp, class _Up> template <class _Tp, class _Up>
struct _LIBCPP_TEMPLATE_VIS is_swappable_with struct is_swappable_with : public integral_constant<bool, __detail::__swappable_with<_Tp, _Up>::value> {};
: public integral_constant<bool, __detail::__swappable_with<_Tp, _Up>::value>
{
};
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_swappable struct is_swappable
: public __conditional_t< : public __conditional_t<
__libcpp_is_referenceable<_Tp>::value, __libcpp_is_referenceable<_Tp>::value,
is_swappable_with< is_swappable_with<
__add_lvalue_reference_t<_Tp>, __add_lvalue_reference_t<_Tp>,
__add_lvalue_reference_t<_Tp> >, __add_lvalue_reference_t<_Tp> >,
false_type false_type
> >
{ {
}; };
template <class _Tp, class _Up> template <class _Tp, class _Up>
struct _LIBCPP_TEMPLATE_VIS is_nothrow_swappable_with struct is_nothrow_swappable_with : public integral_constant<bool, __detail::__nothrow_swappable_with<_Tp, _Up>::value> {
: public integral_constant<bool, __detail::__nothrow_swappable_with<_Tp, _Up>::value>
{
}; };
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_nothrow_swappable struct is_nothrow_swappable
: public __conditional_t< : public __conditional_t<
__libcpp_is_referenceable<_Tp>::value, __libcpp_is_referenceable<_Tp>::value,
is_nothrow_swappable_with< is_nothrow_swappable_with<
__add_lvalue_reference_t<_Tp>, __add_lvalue_reference_t<_Tp>,
__add_lvalue_reference_t<_Tp> >, __add_lvalue_reference_t<_Tp> >,
false_type false_type
> >
{ {
Show All 19 Lines

libcxx/include/__type_traits/is_trivial.h

Show All 12 Lines
#include <__type_traits/integral_constant.h> #include <__type_traits/integral_constant.h>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_trivial template <class _Tp>
: public integral_constant<bool, __is_trivial(_Tp)> struct is_trivial : public integral_constant<bool, __is_trivial(_Tp)> {};
{};
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_trivial_v = __is_trivial(_Tp); inline constexpr bool is_trivial_v = __is_trivial(_Tp);
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_TRIVIAL_H #endif // _LIBCPP___TYPE_TRAITS_IS_TRIVIAL_H

libcxx/include/__type_traits/is_trivially_constructible.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, class... _Args> template <class _Tp, class... _Args>
struct _LIBCPP_TEMPLATE_VIS is_trivially_constructible struct is_trivially_constructible : integral_constant<bool, __is_trivially_constructible(_Tp, _Args...)> {};
: integral_constant<bool, __is_trivially_constructible(_Tp, _Args...)>
{
};
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <class _Tp, class... _Args> template <class _Tp, class... _Args>
inline constexpr bool is_trivially_constructible_v = __is_trivially_constructible(_Tp, _Args...); inline constexpr bool is_trivially_constructible_v = __is_trivially_constructible(_Tp, _Args...);
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_TRIVIALLY_CONSTRUCTIBLE_H #endif // _LIBCPP___TYPE_TRAITS_IS_TRIVIALLY_CONSTRUCTIBLE_H

libcxx/include/__type_traits/is_trivially_copy_assignable.h

Show All 15 Lines
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_trivially_copy_assignable struct is_trivially_copy_assignable
: public integral_constant< : public integral_constant<
bool, bool,
__is_trivially_assignable( __is_trivially_assignable(
__add_lvalue_reference_t<_Tp>, __add_lvalue_reference_t<_Tp>,
__add_lvalue_reference_t<typename add_const<_Tp>::type>)> {}; __add_lvalue_reference_t<typename add_const<_Tp>::type>)> {};
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_trivially_copy_assignable_v = is_trivially_copy_assignable<_Tp>::value; inline constexpr bool is_trivially_copy_assignable_v = is_trivially_copy_assignable<_Tp>::value;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_TRIVIALLY_COPY_ASSIGNABLE_H #endif // _LIBCPP___TYPE_TRAITS_IS_TRIVIALLY_COPY_ASSIGNABLE_H

libcxx/include/__type_traits/is_trivially_copy_constructible.h

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

libcxx/include/__type_traits/is_trivially_copyable.h

Show All 13 Lines
#include <cstdint> #include <cstdint>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_trivially_copyable template <class _Tp> struct is_trivially_copyable
: public integral_constant<bool, __is_trivially_copyable(_Tp)> : public integral_constant<bool, __is_trivially_copyable(_Tp)>
{}; {};
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_trivially_copyable_v = __is_trivially_copyable(_Tp); inline constexpr bool is_trivially_copyable_v = __is_trivially_copyable(_Tp);
#endif #endif
#if _LIBCPP_STD_VER >= 20 #if _LIBCPP_STD_VER >= 20
template <class _Tp> template <class _Tp>
inline constexpr bool __is_cheap_to_copy = is_trivially_copyable_v<_Tp> && sizeof(_Tp) <= sizeof(std::intmax_t); inline constexpr bool __is_cheap_to_copy = is_trivially_copyable_v<_Tp> && sizeof(_Tp) <= sizeof(std::intmax_t);
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_TRIVIALLY_COPYABLE_H #endif // _LIBCPP___TYPE_TRAITS_IS_TRIVIALLY_COPYABLE_H

libcxx/include/__type_traits/is_trivially_default_constructible.h

Show All 12 Lines
#include <__type_traits/integral_constant.h> #include <__type_traits/integral_constant.h>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_trivially_default_constructible template <class _Tp> struct is_trivially_default_constructible
: public integral_constant<bool, __is_trivially_constructible(_Tp)> : public integral_constant<bool, __is_trivially_constructible(_Tp)>
{}; {};
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_trivially_default_constructible_v = __is_trivially_constructible(_Tp); inline constexpr bool is_trivially_default_constructible_v = __is_trivially_constructible(_Tp);
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_TRIVIALLY_DEFAULT_CONSTRUCTIBLE_H #endif // _LIBCPP___TYPE_TRAITS_IS_TRIVIALLY_DEFAULT_CONSTRUCTIBLE_H

libcxx/include/__type_traits/is_trivially_destructible.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
#if __has_builtin(__is_trivially_destructible) #if __has_builtin(__is_trivially_destructible)
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_trivially_destructible template <class _Tp>
: public integral_constant<bool, __is_trivially_destructible(_Tp)> {}; struct is_trivially_destructible : public integral_constant<bool, __is_trivially_destructible(_Tp)> {};
#elif __has_builtin(__has_trivial_destructor) #elif __has_builtin(__has_trivial_destructor)
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_trivially_destructible template <class _Tp> struct is_trivially_destructible
: public integral_constant<bool, is_destructible<_Tp>::value && __has_trivial_destructor(_Tp)> {}; : public integral_constant<bool, is_destructible<_Tp>::value && __has_trivial_destructor(_Tp)> {};
#else #else
#error is_trivially_destructible is not implemented #error is_trivially_destructible is not implemented
#endif // __has_builtin(__is_trivially_destructible) #endif // __has_builtin(__is_trivially_destructible)
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_trivially_destructible_v = is_trivially_destructible<_Tp>::value; inline constexpr bool is_trivially_destructible_v = is_trivially_destructible<_Tp>::value;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_TRIVIALLY_DESTRUCTIBLE_H #endif // _LIBCPP___TYPE_TRAITS_IS_TRIVIALLY_DESTRUCTIBLE_H

libcxx/include/__type_traits/is_trivially_move_assignable.h

Show All 15 Lines
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_trivially_move_assignable struct is_trivially_move_assignable
: public integral_constant< : public integral_constant<
bool, bool,
__is_trivially_assignable(__add_lvalue_reference_t<_Tp>, __add_rvalue_reference_t<_Tp>)> {}; __is_trivially_assignable(__add_lvalue_reference_t<_Tp>, __add_rvalue_reference_t<_Tp>)> {};
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_trivially_move_assignable_v = is_trivially_move_assignable<_Tp>::value; inline constexpr bool is_trivially_move_assignable_v = is_trivially_move_assignable<_Tp>::value;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_TRIVIALLY_MOVE_ASSIGNABLE_H #endif // _LIBCPP___TYPE_TRAITS_IS_TRIVIALLY_MOVE_ASSIGNABLE_H

libcxx/include/__type_traits/is_trivially_move_constructible.h

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

libcxx/include/__type_traits/is_unbounded_array.h

Show All 12 Lines
#include <__type_traits/integral_constant.h> #include <__type_traits/integral_constant.h>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class> struct _LIBCPP_TEMPLATE_VIS __libcpp_is_unbounded_array : false_type {}; template <class> struct __libcpp_is_unbounded_array : false_type {};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS __libcpp_is_unbounded_array<_Tp[]> : true_type {}; template <class _Tp> struct __libcpp_is_unbounded_array<_Tp[]> : true_type {};
#if _LIBCPP_STD_VER >= 20 #if _LIBCPP_STD_VER >= 20
template <class> struct _LIBCPP_TEMPLATE_VIS is_unbounded_array : false_type {}; template <class> struct is_unbounded_array : false_type {};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_unbounded_array<_Tp[]> : true_type {}; template <class _Tp> struct is_unbounded_array<_Tp[]> : true_type {};
template <class _Tp> template <class _Tp>
inline constexpr inline constexpr
bool is_unbounded_array_v = is_unbounded_array<_Tp>::value; bool is_unbounded_array_v = is_unbounded_array<_Tp>::value;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_UNBOUNDED_ARRAY_H #endif // _LIBCPP___TYPE_TRAITS_IS_UNBOUNDED_ARRAY_H

libcxx/include/__type_traits/is_union.h

Show All 12 Lines
#include <__type_traits/integral_constant.h> #include <__type_traits/integral_constant.h>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_union template <class _Tp>
: public integral_constant<bool, __is_union(_Tp)> {}; struct is_union : public integral_constant<bool, __is_union(_Tp)> {};
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_union_v = __is_union(_Tp); inline constexpr bool is_union_v = __is_union(_Tp);
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_UNION_H #endif // _LIBCPP___TYPE_TRAITS_IS_UNION_H

libcxx/include/__type_traits/is_unsigned.h

Show All 17 Lines
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if __has_builtin(__is_unsigned) #if __has_builtin(__is_unsigned)
template<class _Tp> template<class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_unsigned : _BoolConstant<__is_unsigned(_Tp)> { }; struct is_unsigned : _BoolConstant<__is_unsigned(_Tp)> { };
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_unsigned_v = __is_unsigned(_Tp); inline constexpr bool is_unsigned_v = __is_unsigned(_Tp);
#endif #endif
#else // __has_builtin(__is_unsigned) #else // __has_builtin(__is_unsigned)
template <class _Tp, bool = is_integral<_Tp>::value> template <class _Tp, bool = is_integral<_Tp>::value>
struct __libcpp_is_unsigned_impl : public _BoolConstant<(_Tp(0) < _Tp(-1))> {}; struct __libcpp_is_unsigned_impl : public _BoolConstant<(_Tp(0) < _Tp(-1))> {};
template <class _Tp> template <class _Tp>
struct __libcpp_is_unsigned_impl<_Tp, false> : public false_type {}; // floating point struct __libcpp_is_unsigned_impl<_Tp, false> : public false_type {}; // floating point
template <class _Tp, bool = is_arithmetic<_Tp>::value> template <class _Tp, bool = is_arithmetic<_Tp>::value>
struct __libcpp_is_unsigned : public __libcpp_is_unsigned_impl<_Tp> {}; struct __libcpp_is_unsigned : public __libcpp_is_unsigned_impl<_Tp> {};
template <class _Tp> struct __libcpp_is_unsigned<_Tp, false> : public false_type {}; template <class _Tp> struct __libcpp_is_unsigned<_Tp, false> : public false_type {};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_unsigned : public __libcpp_is_unsigned<_Tp> {}; template <class _Tp>
struct is_unsigned : public __libcpp_is_unsigned<_Tp> {};
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_unsigned_v = is_unsigned<_Tp>::value; inline constexpr bool is_unsigned_v = is_unsigned<_Tp>::value;
#endif #endif
#endif // __has_builtin(__is_unsigned) #endif // __has_builtin(__is_unsigned)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_UNSIGNED_H #endif // _LIBCPP___TYPE_TRAITS_IS_UNSIGNED_H

libcxx/include/__type_traits/is_void.h

Show All 17 Lines
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if __has_builtin(__is_void) #if __has_builtin(__is_void)
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_void : _BoolConstant<__is_void(_Tp)> { }; struct is_void : _BoolConstant<__is_void(_Tp)> { };
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_void_v = __is_void(_Tp); inline constexpr bool is_void_v = __is_void(_Tp);
#endif #endif
#else #else
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_void template <class _Tp>
: public is_same<__remove_cv_t<_Tp>, void> {}; struct is_void : public is_same<__remove_cv_t<_Tp>, void> {};
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_void_v = is_void<_Tp>::value; inline constexpr bool is_void_v = is_void<_Tp>::value;
#endif #endif
#endif // __has_builtin(__is_void) #endif // __has_builtin(__is_void)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_VOID_H #endif // _LIBCPP___TYPE_TRAITS_IS_VOID_H

libcxx/include/__type_traits/is_volatile.h

Show All 15 Lines
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if __has_builtin(__is_volatile) #if __has_builtin(__is_volatile)
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_volatile : _BoolConstant<__is_volatile(_Tp)> { }; struct is_volatile : _BoolConstant<__is_volatile(_Tp)> { };
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_volatile_v = __is_volatile(_Tp); inline constexpr bool is_volatile_v = __is_volatile(_Tp);
#endif #endif
#else #else
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_volatile : public false_type {}; template <class _Tp> struct is_volatile : public false_type {};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_volatile<_Tp volatile> : public true_type {}; template <class _Tp> struct is_volatile<_Tp volatile> : public true_type {};
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_volatile_v = is_volatile<_Tp>::value; inline constexpr bool is_volatile_v = is_volatile<_Tp>::value;
#endif #endif
#endif // __has_builtin(__is_volatile) #endif // __has_builtin(__is_volatile)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_VOLATILE_H #endif // _LIBCPP___TYPE_TRAITS_IS_VOLATILE_H

libcxx/include/__type_traits/rank.h

Show All 21 Lines
// TODO: Enable using the builtin __array_rank when https://llvm.org/PR57133 is resolved // TODO: Enable using the builtin __array_rank when https://llvm.org/PR57133 is resolved
#if __has_builtin(__array_rank) && 0 #if __has_builtin(__array_rank) && 0
template <class _Tp> template <class _Tp>
struct rank : integral_constant<size_t, __array_rank(_Tp)> {}; struct rank : integral_constant<size_t, __array_rank(_Tp)> {};
#else #else
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS rank template <class _Tp>
: public integral_constant<size_t, 0> {}; struct rank : public integral_constant<size_t, 0> {};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS rank<_Tp[]> template <class _Tp>
: public integral_constant<size_t, rank<_Tp>::value + 1> {}; struct rank<_Tp[]> : public integral_constant<size_t, rank<_Tp>::value + 1> {};
template <class _Tp, size_t _Np> struct _LIBCPP_TEMPLATE_VIS rank<_Tp[_Np]> template <class _Tp, size_t _Np>
: public integral_constant<size_t, rank<_Tp>::value + 1> {}; struct rank<_Tp[_Np]> : public integral_constant<size_t, rank<_Tp>::value + 1> {};
#endif // __has_builtin(__array_rank) #endif // __has_builtin(__array_rank)
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr size_t rank_v = rank<_Tp>::value; inline constexpr size_t rank_v = rank<_Tp>::value;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_RANK_H #endif // _LIBCPP___TYPE_TRAITS_RANK_H

libcxx/include/__type_traits/remove_all_extents.h

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

libcxx/include/__type_traits/remove_const.h

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

libcxx/include/__type_traits/remove_cv.h

Show All 22 Lines
template <class _Tp> template <class _Tp>
struct remove_cv { struct remove_cv {
using type _LIBCPP_NODEBUG = __remove_cv(_Tp); using type _LIBCPP_NODEBUG = __remove_cv(_Tp);
}; };
template <class _Tp> template <class _Tp>
using __remove_cv_t = __remove_cv(_Tp); using __remove_cv_t = __remove_cv(_Tp);
#else #else
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_cv template <class _Tp> struct remove_cv
{typedef __remove_volatile_t<__remove_const_t<_Tp> > type;}; {typedef __remove_volatile_t<__remove_const_t<_Tp> > type;};
template <class _Tp> template <class _Tp>
using __remove_cv_t = __remove_volatile_t<__remove_const_t<_Tp> >; using __remove_cv_t = __remove_volatile_t<__remove_const_t<_Tp> >;
#endif // __has_builtin(__remove_cv) #endif // __has_builtin(__remove_cv)
#if _LIBCPP_STD_VER >= 14 #if _LIBCPP_STD_VER >= 14
template <class _Tp> using remove_cv_t = __remove_cv_t<_Tp>; template <class _Tp> using remove_cv_t = __remove_cv_t<_Tp>;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_REMOVE_CV_H #endif // _LIBCPP___TYPE_TRAITS_REMOVE_CV_H

libcxx/include/__type_traits/remove_extent.h

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

libcxx/include/__type_traits/remove_pointer.h

Show All 20 Lines
template <class _Tp> template <class _Tp>
struct remove_pointer { struct remove_pointer {
using type _LIBCPP_NODEBUG = __remove_pointer(_Tp); using type _LIBCPP_NODEBUG = __remove_pointer(_Tp);
}; };
template <class _Tp> template <class _Tp>
using __remove_pointer_t = __remove_pointer(_Tp); using __remove_pointer_t = __remove_pointer(_Tp);
#else #else
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_pointer {typedef _LIBCPP_NODEBUG _Tp type;}; template <class _Tp> struct remove_pointer {typedef _LIBCPP_NODEBUG _Tp type;};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_pointer<_Tp*> {typedef _LIBCPP_NODEBUG _Tp type;}; template <class _Tp> struct remove_pointer<_Tp*> {typedef _LIBCPP_NODEBUG _Tp type;};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_pointer<_Tp* const> {typedef _LIBCPP_NODEBUG _Tp type;}; template <class _Tp> struct remove_pointer<_Tp* const> {typedef _LIBCPP_NODEBUG _Tp type;};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_pointer<_Tp* volatile> {typedef _LIBCPP_NODEBUG _Tp type;}; template <class _Tp> struct remove_pointer<_Tp* volatile> {typedef _LIBCPP_NODEBUG _Tp type;};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_pointer<_Tp* const volatile> {typedef _LIBCPP_NODEBUG _Tp type;}; template <class _Tp> struct remove_pointer<_Tp* const volatile> {typedef _LIBCPP_NODEBUG _Tp type;};
template <class _Tp> template <class _Tp>
using __remove_pointer_t = typename remove_pointer<_Tp>::type; using __remove_pointer_t = typename remove_pointer<_Tp>::type;
#endif // !defined(_LIBCPP_WORKAROUND_OBJCXX_COMPILER_INTRINSICS) && __has_builtin(__remove_pointer) #endif // !defined(_LIBCPP_WORKAROUND_OBJCXX_COMPILER_INTRINSICS) && __has_builtin(__remove_pointer)
#if _LIBCPP_STD_VER >= 14 #if _LIBCPP_STD_VER >= 14
template <class _Tp> using remove_pointer_t = __remove_pointer_t<_Tp>; template <class _Tp> using remove_pointer_t = __remove_pointer_t<_Tp>;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_REMOVE_POINTER_H #endif // _LIBCPP___TYPE_TRAITS_REMOVE_POINTER_H

libcxx/include/__type_traits/remove_reference.h

Show All 21 Lines
template <class _Tp> template <class _Tp>
struct remove_reference { struct remove_reference {
using type _LIBCPP_NODEBUG = __remove_reference_t(_Tp); using type _LIBCPP_NODEBUG = __remove_reference_t(_Tp);
}; };
template <class _Tp> template <class _Tp>
using __libcpp_remove_reference_t = __remove_reference_t(_Tp); using __libcpp_remove_reference_t = __remove_reference_t(_Tp);
#else #else
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_reference {typedef _LIBCPP_NODEBUG _Tp type;}; template <class _Tp> struct remove_reference {typedef _LIBCPP_NODEBUG _Tp type;};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_reference<_Tp&> {typedef _LIBCPP_NODEBUG _Tp type;}; template <class _Tp> struct remove_reference<_Tp&> {typedef _LIBCPP_NODEBUG _Tp type;};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_reference<_Tp&&> {typedef _LIBCPP_NODEBUG _Tp type;}; template <class _Tp> struct remove_reference<_Tp&&> {typedef _LIBCPP_NODEBUG _Tp type;};
template <class _Tp> template <class _Tp>
using __libcpp_remove_reference_t = typename remove_reference<_Tp>::type; using __libcpp_remove_reference_t = typename remove_reference<_Tp>::type;
#endif // __has_builtin(__remove_reference_t) #endif // __has_builtin(__remove_reference_t)
#if _LIBCPP_STD_VER >= 14 #if _LIBCPP_STD_VER >= 14
template <class _Tp> using remove_reference_t = __libcpp_remove_reference_t<_Tp>; template <class _Tp> using remove_reference_t = __libcpp_remove_reference_t<_Tp>;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_REMOVE_REFERENCE_H #endif // _LIBCPP___TYPE_TRAITS_REMOVE_REFERENCE_H

libcxx/include/__type_traits/remove_volatile.h

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

libcxx/include/__type_traits/result_of.h

Show All 18 Lines
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
// result_of // result_of
#if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_TYPE_TRAITS) #if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_TYPE_TRAITS)
template <class _Callable> class _LIBCPP_DEPRECATED_IN_CXX17 result_of; template <class _Callable> class _LIBCPP_DEPRECATED_IN_CXX17 result_of;
template <class _Fp, class ..._Args> template <class _Fp, class ..._Args>
class _LIBCPP_TEMPLATE_VIS result_of<_Fp(_Args...)> class result_of<_Fp(_Args...)> : public __invoke_of<_Fp, _Args...>
: public __invoke_of<_Fp, _Args...>
{ {
}; };
#if _LIBCPP_STD_VER >= 14 #if _LIBCPP_STD_VER >= 14
template <class _Tp> using result_of_t _LIBCPP_DEPRECATED_IN_CXX17 = typename result_of<_Tp>::type; template <class _Tp> using result_of_t _LIBCPP_DEPRECATED_IN_CXX17 = typename result_of<_Tp>::type;
#endif // _LIBCPP_STD_VER >= 14 #endif // _LIBCPP_STD_VER >= 14
#endif // _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_TYPE_TRAITS) #endif // _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_TYPE_TRAITS)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_RESULT_OF_H #endif // _LIBCPP___TYPE_TRAITS_RESULT_OF_H

libcxx/include/__utility/in_place.h

Show All 21 Lines
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
struct _LIBCPP_TYPE_VIS in_place_t { struct _LIBCPP_TYPE_VIS in_place_t {
explicit in_place_t() = default; explicit in_place_t() = default;
}; };
inline constexpr in_place_t in_place{}; inline constexpr in_place_t in_place{};
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS in_place_type_t { struct in_place_type_t {
_LIBCPP_HIDE_FROM_ABI explicit in_place_type_t() = default; _LIBCPP_HIDE_FROM_ABI explicit in_place_type_t() = default;
}; };
template <class _Tp> template <class _Tp>
inline constexpr in_place_type_t<_Tp> in_place_type{}; inline constexpr in_place_type_t<_Tp> in_place_type{};
template <size_t _Idx> template <size_t _Idx>
struct _LIBCPP_TEMPLATE_VIS in_place_index_t { struct in_place_index_t {
_LIBCPP_HIDE_FROM_ABI explicit in_place_index_t() = default; _LIBCPP_HIDE_FROM_ABI explicit in_place_index_t() = default;
}; };
template <size_t _Idx> template <size_t _Idx>
inline constexpr in_place_index_t<_Idx> in_place_index{}; inline constexpr in_place_index_t<_Idx> in_place_index{};
template <class _Tp> struct __is_inplace_type_imp : false_type {}; template <class _Tp> struct __is_inplace_type_imp : false_type {};
template <class _Tp> struct __is_inplace_type_imp<in_place_type_t<_Tp>> : true_type {}; template <class _Tp> struct __is_inplace_type_imp<in_place_type_t<_Tp>> : true_type {};
Show All 14 Lines

libcxx/include/__utility/integer_sequence.h

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
using __make_indices_imp = using __make_indices_imp =
typename __detail::__make<_Ep - _Sp>::type::template __to_tuple_indices<_Sp>; typename __detail::__make<_Ep - _Sp>::type::template __to_tuple_indices<_Sp>;
#endif #endif
#if _LIBCPP_STD_VER >= 14 #if _LIBCPP_STD_VER >= 14
template<class _Tp, _Tp... _Ip> template<class _Tp, _Tp... _Ip>
struct _LIBCPP_TEMPLATE_VIS integer_sequence struct integer_sequence
{ {
typedef _Tp value_type; typedef _Tp value_type;
static_assert( is_integral<_Tp>::value, static_assert( is_integral<_Tp>::value,
"std::integer_sequence can only be instantiated with an integral type" ); "std::integer_sequence can only be instantiated with an integral type" );
static static
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
constexpr constexpr
size_t size_t
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

libcxx/include/__utility/pair.h

Show First 20 Lines • Show All 68 Lines • ▼ Show 20 Lines
template <class _Tp> template <class _Tp>
struct __is_specialization_of_subrange : false_type {}; struct __is_specialization_of_subrange : false_type {};
template <class _Iter, class _Sent, ranges::subrange_kind _Kind> template <class _Iter, class _Sent, ranges::subrange_kind _Kind>
struct __is_specialization_of_subrange<ranges::subrange<_Iter, _Sent, _Kind>> : true_type {}; struct __is_specialization_of_subrange<ranges::subrange<_Iter, _Sent, _Kind>> : true_type {};
#endif #endif
template <class _T1, class _T2> template <class _T1, class _T2>
struct _LIBCPP_TEMPLATE_VIS pair struct 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>
#endif #endif
{ {
using first_type = _T1; using first_type = _T1;
using second_type = _T2; using second_type = _T2;
_T1 first; _T1 first;
▲ Show 20 Lines • Show All 630 Lines • ▼ Show 20 Lines
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>
(std::forward<_T1>(__t1), std::forward<_T2>(__t2)); (std::forward<_T1>(__t1), std::forward<_T2>(__t2));
} }
template <class _T1, class _T2> template <class _T1, class _T2>
struct _LIBCPP_TEMPLATE_VIS tuple_size<pair<_T1, _T2> > struct tuple_size<pair<_T1, _T2> > : public integral_constant<size_t, 2> {};
: public integral_constant<size_t, 2> {};
template <size_t _Ip, class _T1, class _T2> template <size_t _Ip, class _T1, class _T2>
struct _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, pair<_T1, _T2> > struct tuple_element<_Ip, pair<_T1, _T2> >
{ {
static_assert(_Ip < 2, "Index out of bounds in std::tuple_element<std::pair<T1, T2>>"); static_assert(_Ip < 2, "Index out of bounds in std::tuple_element<std::pair<T1, T2>>");
}; };
template <class _T1, class _T2> template <class _T1, class _T2>
struct _LIBCPP_TEMPLATE_VIS tuple_element<0, pair<_T1, _T2> > struct tuple_element<0, pair<_T1, _T2> >
{ {
using type _LIBCPP_NODEBUG = _T1; using type _LIBCPP_NODEBUG = _T1;
}; };
template <class _T1, class _T2> template <class _T1, class _T2>
struct _LIBCPP_TEMPLATE_VIS tuple_element<1, pair<_T1, _T2> > struct tuple_element<1, pair<_T1, _T2> >
{ {
using type _LIBCPP_NODEBUG = _T2; using type _LIBCPP_NODEBUG = _T2;
}; };
template <size_t _Ip> struct __get_pair; template <size_t _Ip> struct __get_pair;
template <> template <>
struct __get_pair<0> struct __get_pair<0>
▲ Show 20 Lines • Show All 148 Lines • Show Last 20 Lines

libcxx/include/__utility/piecewise_construct.h

Show All 11 Lines
#include <__config> #include <__config>
#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
struct _LIBCPP_TEMPLATE_VIS piecewise_construct_t { explicit piecewise_construct_t() = default; }; struct piecewise_construct_t { explicit piecewise_construct_t() = default; };
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
inline constexpr piecewise_construct_t piecewise_construct = piecewise_construct_t(); inline constexpr piecewise_construct_t piecewise_construct = piecewise_construct_t();
#elif !defined(_LIBCPP_CXX03_LANG) #elif !defined(_LIBCPP_CXX03_LANG)
constexpr piecewise_construct_t piecewise_construct = piecewise_construct_t(); constexpr piecewise_construct_t piecewise_construct = piecewise_construct_t();
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___UTILITY_PIECEWISE_CONSTRUCT_H #endif // _LIBCPP___UTILITY_PIECEWISE_CONSTRUCT_H

libcxx/include/__variant/monostate.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
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
struct _LIBCPP_TEMPLATE_VIS monostate {}; struct monostate {};
_LIBCPP_HIDE_FROM_ABI constexpr bool operator==(monostate, monostate) noexcept { return true; } _LIBCPP_HIDE_FROM_ABI constexpr bool operator==(monostate, monostate) noexcept { return true; }
# if _LIBCPP_STD_VER >= 20 # if _LIBCPP_STD_VER >= 20
_LIBCPP_HIDE_FROM_ABI constexpr strong_ordering operator<=>(monostate, monostate) noexcept { _LIBCPP_HIDE_FROM_ABI constexpr strong_ordering operator<=>(monostate, monostate) noexcept {
return strong_ordering::equal; return strong_ordering::equal;
} }
# else // _LIBCPP_STD_VER >= 20 # else // _LIBCPP_STD_VER >= 20
_LIBCPP_HIDE_FROM_ABI constexpr bool operator!=(monostate, monostate) noexcept { return false; } _LIBCPP_HIDE_FROM_ABI constexpr bool operator!=(monostate, monostate) noexcept { return false; }
_LIBCPP_HIDE_FROM_ABI constexpr bool operator<(monostate, monostate) noexcept { return false; } _LIBCPP_HIDE_FROM_ABI constexpr bool operator<(monostate, monostate) noexcept { return false; }
_LIBCPP_HIDE_FROM_ABI constexpr bool operator>(monostate, monostate) noexcept { return false; } _LIBCPP_HIDE_FROM_ABI constexpr bool operator>(monostate, monostate) noexcept { return false; }
_LIBCPP_HIDE_FROM_ABI constexpr bool operator<=(monostate, monostate) noexcept { return true; } _LIBCPP_HIDE_FROM_ABI constexpr bool operator<=(monostate, monostate) noexcept { return true; }
_LIBCPP_HIDE_FROM_ABI constexpr bool operator>=(monostate, monostate) noexcept { return true; } _LIBCPP_HIDE_FROM_ABI constexpr bool operator>=(monostate, monostate) noexcept { return true; }
# endif // _LIBCPP_STD_VER >= 20 # endif // _LIBCPP_STD_VER >= 20
template <> template <>
struct _LIBCPP_TEMPLATE_VIS hash<monostate> { struct hash<monostate> {
using argument_type = monostate; using argument_type = monostate;
using result_type = size_t; using result_type = size_t;
inline _LIBCPP_HIDE_FROM_ABI result_type operator()(const argument_type&) const _NOEXCEPT { inline _LIBCPP_HIDE_FROM_ABI result_type operator()(const argument_type&) const _NOEXCEPT {
return 66740831; // return a fundamentally attractive random value. return 66740831; // return a fundamentally attractive random value.
} }
}; };
#endif // _LIBCPP_STD_VER >= 17 #endif // _LIBCPP_STD_VER >= 17
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___VARIANT_MONOSTATE_H #endif // _LIBCPP___VARIANT_MONOSTATE_H

libcxx/include/any

Show First 20 Lines • Show All 133 Lines • ▼ Show 20 Lines
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
throw bad_any_cast(); throw bad_any_cast();
#else #else
_LIBCPP_VERBOSE_ABORT("bad_any_cast was thrown in -fno-exceptions mode"); _LIBCPP_VERBOSE_ABORT("bad_any_cast was thrown in -fno-exceptions mode");
#endif #endif
} }
// Forward declarations // Forward declarations
class _LIBCPP_TEMPLATE_VIS any; class any;
template <class _ValueType> template <class _ValueType>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
add_pointer_t<add_const_t<_ValueType>> add_pointer_t<add_const_t<_ValueType>>
any_cast(any const *) _NOEXCEPT; any_cast(any const *) _NOEXCEPT;
template <class _ValueType> template <class _ValueType>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
Show All 20 Lines enum class _Action {
_Get, _Get,
_TypeInfo _TypeInfo
}; };
template <class _Tp> struct _SmallHandler; template <class _Tp> struct _SmallHandler;
template <class _Tp> struct _LargeHandler; template <class _Tp> struct _LargeHandler;
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS __unique_typeinfo { static constexpr int __id = 0; }; struct __unique_typeinfo { static constexpr int __id = 0; };
template <class _Tp> constexpr int __unique_typeinfo<_Tp>::__id; template <class _Tp> constexpr int __unique_typeinfo<_Tp>::__id;
template <class _Tp> template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
constexpr const void* __get_fallback_typeid() { constexpr const void* __get_fallback_typeid() {
return &__unique_typeinfo<remove_cv_t<remove_reference_t<_Tp>>>::__id; return &__unique_typeinfo<remove_cv_t<remove_reference_t<_Tp>>>::__id;
} }
Show All 11 Lines#endif
} }
template <class _Tp> template <class _Tp>
using _Handler = conditional_t< using _Handler = conditional_t<
_IsSmallObject<_Tp>::value, _SmallHandler<_Tp>, _LargeHandler<_Tp>>; _IsSmallObject<_Tp>::value, _SmallHandler<_Tp>, _LargeHandler<_Tp>>;
} // namespace __any_imp } // namespace __any_imp
class _LIBCPP_TEMPLATE_VIS any class any
{ {
public: public:
// construct/destruct // construct/destruct
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
constexpr any() _NOEXCEPT : __h_(nullptr) {} constexpr any() _NOEXCEPT : __h_(nullptr) {}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
any(any const & __other) : __h_(nullptr) any(any const & __other) : __h_(nullptr)
▲ Show 20 Lines • Show All 145 Lines • ▼ Show 20 Linesprivate:
_HandleFuncPtr __h_ = nullptr; _HandleFuncPtr __h_ = nullptr;
_Storage __s_; _Storage __s_;
}; };
namespace __any_imp namespace __any_imp
{ {
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS _SmallHandler struct _SmallHandler
{ {
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
static void* __handle(_Action __act, any const * __this, any * __other, static void* __handle(_Action __act, any const * __this, any * __other,
type_info const * __info, const void* __fallback_info) type_info const * __info, const void* __fallback_info)
{ {
switch (__act) switch (__act)
{ {
case _Action::_Destroy: case _Action::_Destroy:
▲ Show 20 Lines • Show All 66 Lines • ▼ Show 20 Lines#if !defined(_LIBCPP_HAS_NO_RTTI)
return const_cast<void*>(static_cast<void const *>(&typeid(_Tp))); return const_cast<void*>(static_cast<void const *>(&typeid(_Tp)));
#else #else
return nullptr; return nullptr;
#endif #endif
} }
}; };
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS _LargeHandler struct _LargeHandler
{ {
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
static void* __handle(_Action __act, any const * __this, static void* __handle(_Action __act, any const * __this,
any * __other, type_info const * __info, any * __other, type_info const * __info,
void const* __fallback_info) void const* __fallback_info)
{ {
switch (__act) switch (__act)
{ {
▲ Show 20 Lines • Show All 269 Lines • Show Last 20 Lines

libcxx/include/array

Show First 20 Lines • Show All 154 Lines • ▼ Show 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 _Tp, size_t _Size> template <class _Tp, size_t _Size>
struct _LIBCPP_TEMPLATE_VIS array struct array
{ {
// types: // types:
typedef array __self; typedef array __self;
typedef _Tp value_type; typedef _Tp value_type;
typedef value_type& reference; typedef value_type& reference;
typedef const value_type& const_reference; typedef const value_type& const_reference;
typedef value_type* iterator; typedef value_type* iterator;
typedef const value_type* const_iterator; typedef const value_type* const_iterator;
▲ Show 20 Lines • Show All 86 Lines • ▼ Show 20 Linesstruct array
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
value_type* data() _NOEXCEPT {return __elems_;} value_type* data() _NOEXCEPT {return __elems_;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_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 array<_Tp, 0>
{ {
// types: // types:
typedef array __self; typedef array __self;
typedef _Tp value_type; typedef _Tp value_type;
typedef value_type& reference; typedef value_type& reference;
typedef const value_type& const_reference; typedef const value_type& const_reference;
typedef value_type* iterator; typedef value_type* iterator;
typedef const value_type* const_iterator; typedef const value_type* const_iterator;
▲ Show 20 Lines • Show All 173 Lines • ▼ Show 20 Lines
__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 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 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_SINCE_CXX14 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
_Tp& _Tp&
▲ Show 20 Lines • Show All 86 Lines • Show Last 20 Lines

libcxx/include/bitset

Show First 20 Lines • Show All 666 Lines • ▼ Show 20 Lines
} }
inline inline
_LIBCPP_CONSTEXPR _LIBCPP_CONSTEXPR
__bitset<0, 0>::__bitset(unsigned long long) _NOEXCEPT __bitset<0, 0>::__bitset(unsigned long long) _NOEXCEPT
{ {
} }
template <size_t _Size> class _LIBCPP_TEMPLATE_VIS bitset; template <size_t _Size> class bitset;
template <size_t _Size> struct hash<bitset<_Size> >; template <size_t _Size> struct hash<bitset<_Size> >;
template <size_t _Size> template <size_t _Size>
class _LIBCPP_TEMPLATE_VIS bitset class bitset : private __bitset<_Size == 0 ? 0 : (_Size - 1) / (sizeof(size_t) * CHAR_BIT) + 1, _Size>
: private __bitset<_Size == 0 ? 0 : (_Size - 1) / (sizeof(size_t) * CHAR_BIT) + 1, _Size>
{ {
public: public:
static const unsigned __n_words = _Size == 0 ? 0 : (_Size - 1) / (sizeof(size_t) * CHAR_BIT) + 1; static const unsigned __n_words = _Size == 0 ? 0 : (_Size - 1) / (sizeof(size_t) * CHAR_BIT) + 1;
typedef __bitset<__n_words, _Size> base; typedef __bitset<__n_words, _Size> base;
public: public:
typedef typename base::reference reference; typedef typename base::reference reference;
typedef typename base::const_reference const_reference; typedef typename base::const_reference const_reference;
▲ Show 20 Lines • Show All 438 Lines • ▼ Show 20 Lines
operator^(const bitset<_Size>& __x, const bitset<_Size>& __y) _NOEXCEPT operator^(const bitset<_Size>& __x, const bitset<_Size>& __y) _NOEXCEPT
{ {
bitset<_Size> __r = __x; bitset<_Size> __r = __x;
__r ^= __y; __r ^= __y;
return __r; return __r;
} }
template <size_t _Size> template <size_t _Size>
struct _LIBCPP_TEMPLATE_VIS hash<bitset<_Size> > struct hash<bitset<_Size> > : public __unary_function<bitset<_Size>, size_t>
: public __unary_function<bitset<_Size>, size_t>
{ {
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
size_t operator()(const bitset<_Size>& __bs) const _NOEXCEPT size_t operator()(const bitset<_Size>& __bs) const _NOEXCEPT
{return __bs.__hash_code();} {return __bs.__hash_code();}
}; };
template <class _CharT, class _Traits, size_t _Size> template <class _CharT, class _Traits, size_t _Size>
_LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>& _LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
Show All 17 Lines

libcxx/include/codecvt

Show First 20 Lines • Show All 178 Lines • ▼ Show 20 Linesprotected:
bool do_always_noconv() const _NOEXCEPT override; bool do_always_noconv() const _NOEXCEPT override;
int do_length(state_type&, const extern_type* __frm, const extern_type* __end, size_t __mx) const override; int do_length(state_type&, const extern_type* __frm, const extern_type* __end, size_t __mx) const override;
int do_max_length() const _NOEXCEPT override; int do_max_length() const _NOEXCEPT override;
}; };
_LIBCPP_SUPPRESS_DEPRECATED_PUSH _LIBCPP_SUPPRESS_DEPRECATED_PUSH
template <class _Elem, unsigned long _Maxcode = 0x10ffff, template <class _Elem, unsigned long _Maxcode = 0x10ffff,
codecvt_mode _Mode = (codecvt_mode)0> codecvt_mode _Mode = (codecvt_mode)0>
class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX17 codecvt_utf8 class _LIBCPP_DEPRECATED_IN_CXX17 codecvt_utf8
: public __codecvt_utf8<_Elem> : public __codecvt_utf8<_Elem>
{ {
public: public:
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
explicit codecvt_utf8(size_t __refs = 0) explicit codecvt_utf8(size_t __refs = 0)
: __codecvt_utf8<_Elem>(__refs, _Maxcode, _Mode) {} : __codecvt_utf8<_Elem>(__refs, _Maxcode, _Mode) {}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
▲ Show 20 Lines • Show All 212 Lines • ▼ Show 20 Linesprotected:
bool do_always_noconv() const _NOEXCEPT override; bool do_always_noconv() const _NOEXCEPT override;
int do_length(state_type&, const extern_type* __frm, const extern_type* __end, size_t __mx) const override; int do_length(state_type&, const extern_type* __frm, const extern_type* __end, size_t __mx) const override;
int do_max_length() const _NOEXCEPT override; int do_max_length() const _NOEXCEPT override;
}; };
_LIBCPP_SUPPRESS_DEPRECATED_PUSH _LIBCPP_SUPPRESS_DEPRECATED_PUSH
template <class _Elem, unsigned long _Maxcode = 0x10ffff, template <class _Elem, unsigned long _Maxcode = 0x10ffff,
codecvt_mode _Mode = (codecvt_mode)0> codecvt_mode _Mode = (codecvt_mode)0>
class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX17 codecvt_utf16 class _LIBCPP_DEPRECATED_IN_CXX17 codecvt_utf16
: public __codecvt_utf16<_Elem, _Mode & little_endian> : public __codecvt_utf16<_Elem, _Mode & little_endian>
{ {
public: public:
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
explicit codecvt_utf16(size_t __refs = 0) explicit codecvt_utf16(size_t __refs = 0)
: __codecvt_utf16<_Elem, _Mode & little_endian>(__refs, _Maxcode, _Mode) {} : __codecvt_utf16<_Elem, _Mode & little_endian>(__refs, _Maxcode, _Mode) {}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
▲ Show 20 Lines • Show All 108 Lines • ▼ Show 20 Linesprotected:
bool do_always_noconv() const _NOEXCEPT override; bool do_always_noconv() const _NOEXCEPT override;
int do_length(state_type&, const extern_type* __frm, const extern_type* __end, size_t __mx) const override; int do_length(state_type&, const extern_type* __frm, const extern_type* __end, size_t __mx) const override;
int do_max_length() const _NOEXCEPT override; int do_max_length() const _NOEXCEPT override;
}; };
_LIBCPP_SUPPRESS_DEPRECATED_PUSH _LIBCPP_SUPPRESS_DEPRECATED_PUSH
template <class _Elem, unsigned long _Maxcode = 0x10ffff, template <class _Elem, unsigned long _Maxcode = 0x10ffff,
codecvt_mode _Mode = (codecvt_mode)0> codecvt_mode _Mode = (codecvt_mode)0>
class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX17 codecvt_utf8_utf16 class _LIBCPP_DEPRECATED_IN_CXX17 codecvt_utf8_utf16 : public __codecvt_utf8_utf16<_Elem>
: public __codecvt_utf8_utf16<_Elem>
{ {
public: public:
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
explicit codecvt_utf8_utf16(size_t __refs = 0) explicit codecvt_utf8_utf16(size_t __refs = 0)
: __codecvt_utf8_utf16<_Elem>(__refs, _Maxcode, _Mode) {} : __codecvt_utf8_utf16<_Elem>(__refs, _Maxcode, _Mode) {}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
~codecvt_utf8_utf16() {} ~codecvt_utf8_utf16() {}
Show All 21 Lines

libcxx/include/complex

Show First 20 Lines • Show All 242 Lines • ▼ Show 20 Lines
#endif #endif
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template<class _Tp> class _LIBCPP_TEMPLATE_VIS complex; template<class _Tp> class complex;
template<class _Tp> _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp> operator*(const complex<_Tp>& __z, const complex<_Tp>& __w); template<class _Tp> _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp> operator*(const complex<_Tp>& __z, const complex<_Tp>& __w);
template<class _Tp> _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp> operator/(const complex<_Tp>& __x, const complex<_Tp>& __y); template<class _Tp> _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp> operator/(const complex<_Tp>& __x, const complex<_Tp>& __y);
template<class _Tp> template<class _Tp>
class _LIBCPP_TEMPLATE_VIS complex class 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_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Lines template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator*=(const complex<_Xp>& __c)
} }
template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator/=(const complex<_Xp>& __c) template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator/=(const complex<_Xp>& __c)
{ {
*this = *this / complex(__c.real(), __c.imag()); *this = *this / complex(__c.real(), __c.imag());
return *this; return *this;
} }
}; };
template<> class _LIBCPP_TEMPLATE_VIS complex<double>; template<> class complex<double>;
template<> class _LIBCPP_TEMPLATE_VIS complex<long double>; template<> class complex<long double>;
template<> template<>
class _LIBCPP_TEMPLATE_VIS complex<float> class complex<float>
{ {
float __re_; float __re_;
float __im_; float __im_;
public: public:
typedef float value_type; typedef float value_type;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR complex(float __re = 0.0f, float __im = 0.0f) _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR complex(float __re = 0.0f, float __im = 0.0f)
: __re_(__re), __im_(__im) {} : __re_(__re), __im_(__im) {}
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Linespublic:
template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator/=(const complex<_Xp>& __c) template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator/=(const complex<_Xp>& __c)
{ {
*this = *this / complex(__c.real(), __c.imag()); *this = *this / complex(__c.real(), __c.imag());
return *this; return *this;
} }
}; };
template<> template<>
class _LIBCPP_TEMPLATE_VIS complex<double> class complex<double>
{ {
double __re_; double __re_;
double __im_; double __im_;
public: public:
typedef double value_type; typedef double value_type;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR complex(double __re = 0.0, double __im = 0.0) _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR complex(double __re = 0.0, double __im = 0.0)
: __re_(__re), __im_(__im) {} : __re_(__re), __im_(__im) {}
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Linespublic:
template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator/=(const complex<_Xp>& __c) template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator/=(const complex<_Xp>& __c)
{ {
*this = *this / complex(__c.real(), __c.imag()); *this = *this / complex(__c.real(), __c.imag());
return *this; return *this;
} }
}; };
template<> template<>
class _LIBCPP_TEMPLATE_VIS complex<long double> class complex<long double>
{ {
long double __re_; long double __re_;
long double __im_; long double __im_;
public: public:
typedef long double value_type; typedef long double value_type;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR complex(long double __re = 0.0L, long double __im = 0.0L) _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR complex(long double __re = 0.0L, long double __im = 0.0L)
: __re_(__re), __im_(__im) {} : __re_(__re), __im_(__im) {}
▲ Show 20 Lines • Show All 1,128 Lines • Show Last 20 Lines

libcxx/include/deque

Show First 20 Lines • Show All 238 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, class _Allocator = allocator<_Tp> > class _LIBCPP_TEMPLATE_VIS deque; template <class _Tp, class _Allocator = allocator<_Tp> > class deque;
template <class _ValueType, class _DiffType> template <class _ValueType, class _DiffType>
struct __deque_block_size { struct __deque_block_size {
static const _DiffType value = sizeof(_ValueType) < 256 ? 4096 / sizeof(_ValueType) : 16; static const _DiffType value = sizeof(_ValueType) < 256 ? 4096 / sizeof(_ValueType) : 16;
}; };
template <class _ValueType, class _Pointer, class _Reference, class _MapPointer, template <class _ValueType, class _Pointer, class _Reference, class _MapPointer,
class _DiffType, _DiffType _BS = class _DiffType, _DiffType _BS =
#ifdef _LIBCPP_ABI_INCOMPLETE_TYPES_IN_DEQUE #ifdef _LIBCPP_ABI_INCOMPLETE_TYPES_IN_DEQUE
// Keep template parameter to avoid changing all template declarations thoughout // Keep template parameter to avoid changing all template declarations thoughout
// this file. // this file.
0 0
#else #else
__deque_block_size<_ValueType, _DiffType>::value __deque_block_size<_ValueType, _DiffType>::value
#endif #endif
> >
class _LIBCPP_TEMPLATE_VIS __deque_iterator class __deque_iterator
{ {
typedef _MapPointer __map_iterator; typedef _MapPointer __map_iterator;
public: public:
typedef _Pointer pointer; typedef _Pointer pointer;
typedef _DiffType difference_type; typedef _DiffType difference_type;
private: private:
__map_iterator __m_iter_; __map_iterator __m_iter_;
pointer __ptr_; pointer __ptr_;
▲ Show 20 Lines • Show All 134 Lines • ▼ Show 20 Lines#endif
_LIBCPP_HIDE_FROM_ABI friend _LIBCPP_HIDE_FROM_ABI friend
bool operator>=(const __deque_iterator& __x, const __deque_iterator& __y) bool operator>=(const __deque_iterator& __x, const __deque_iterator& __y)
{return !(__x < __y);} {return !(__x < __y);}
private: private:
_LIBCPP_HIDE_FROM_ABI explicit __deque_iterator(__map_iterator __m, pointer __p) _NOEXCEPT _LIBCPP_HIDE_FROM_ABI explicit __deque_iterator(__map_iterator __m, pointer __p) _NOEXCEPT
: __m_iter_(__m), __ptr_(__p) {} : __m_iter_(__m), __ptr_(__p) {}
template <class _Tp, class _Ap> friend class _LIBCPP_TEMPLATE_VIS deque; template <class _Tp, class _Ap> friend class deque;
template <class _Vp, class _Pp, class _Rp, class _MP, class _Dp, _Dp> template <class _Vp, class _Pp, class _Rp, class _MP, class _Dp, _Dp>
friend class _LIBCPP_TEMPLATE_VIS __deque_iterator; friend class __deque_iterator;
template <class> template <class>
friend struct __segmented_iterator_traits; friend struct __segmented_iterator_traits;
}; };
template <class _ValueType, class _Pointer, class _Reference, class _MapPointer, class _DiffType, _DiffType _BlockSize> template <class _ValueType, class _Pointer, class _Reference, class _MapPointer, class _DiffType, _DiffType _BlockSize>
struct __segmented_iterator_traits< struct __segmented_iterator_traits<
__deque_iterator<_ValueType, _Pointer, _Reference, _MapPointer, _DiffType, _BlockSize> > { __deque_iterator<_ValueType, _Pointer, _Reference, _MapPointer, _DiffType, _BlockSize> > {
Show All 24 Lines
template <class _ValueType, class _Pointer, class _Reference, class _MapPointer, template <class _ValueType, class _Pointer, class _Reference, class _MapPointer,
class _DiffType, _DiffType _BlockSize> class _DiffType, _DiffType _BlockSize>
const _DiffType __deque_iterator<_ValueType, _Pointer, _Reference, _MapPointer, const _DiffType __deque_iterator<_ValueType, _Pointer, _Reference, _MapPointer,
_DiffType, _BlockSize>::__block_size = _DiffType, _BlockSize>::__block_size =
__deque_block_size<_ValueType, _DiffType>::value; __deque_block_size<_ValueType, _DiffType>::value;
template <class _Tp, class _Allocator /*= allocator<_Tp>*/> template <class _Tp, class _Allocator /*= allocator<_Tp>*/>
class _LIBCPP_TEMPLATE_VIS deque class deque
{ {
public: public:
// types: // types:
using value_type = _Tp; using value_type = _Tp;
static_assert((is_same<typename _Allocator::value_type, value_type>::value), static_assert((is_same<typename _Allocator::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");
▲ Show 20 Lines • Show All 2,208 Lines • Show Last 20 Lines

libcxx/include/experimental/memory_resource

Show First 20 Lines • Show All 152 Lines • ▼ Show 20 Lines
_LIBCPP_DEPCREATED_MEMORY_RESOURCE("set_default_resource()") _LIBCPP_FUNC_VIS _LIBCPP_DEPCREATED_MEMORY_RESOURCE("set_default_resource()") _LIBCPP_FUNC_VIS
memory_resource * set_default_resource(memory_resource * __new_res) _NOEXCEPT; memory_resource * set_default_resource(memory_resource * __new_res) _NOEXCEPT;
// 8.6, memory.polymorphic.allocator.class // 8.6, memory.polymorphic.allocator.class
// 8.6.1, memory.polymorphic.allocator.overview // 8.6.1, memory.polymorphic.allocator.overview
template <class _ValueType> template <class _ValueType>
class _LIBCPP_DEPCREATED_MEMORY_RESOURCE("polymorphic_allocator") _LIBCPP_TEMPLATE_VIS polymorphic_allocator class _LIBCPP_DEPCREATED_MEMORY_RESOURCE("polymorphic_allocator") polymorphic_allocator
{ {
public: public:
typedef _ValueType value_type; typedef _ValueType value_type;
// 8.6.2, memory.polymorphic.allocator.ctor // 8.6.2, memory.polymorphic.allocator.ctor
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
polymorphic_allocator() _NOEXCEPT polymorphic_allocator() _NOEXCEPT
: __res_(_VSTD_LFTS_PMR::get_default_resource()) : __res_(_VSTD_LFTS_PMR::get_default_resource())
▲ Show 20 Lines • Show All 166 Lines • ▼ Show 20 Linesbool operator!=(polymorphic_allocator<_Tp> const & __lhs,
return !(__lhs == __rhs); return !(__lhs == __rhs);
} }
// 8.7, memory.resource.adaptor // 8.7, memory.resource.adaptor
_LIBCPP_SUPPRESS_DEPRECATED_PUSH _LIBCPP_SUPPRESS_DEPRECATED_PUSH
// 8.7.1, memory.resource.adaptor.overview // 8.7.1, memory.resource.adaptor.overview
template <class _CharAlloc> template <class _CharAlloc>
class _LIBCPP_TEMPLATE_VIS __resource_adaptor_imp class __resource_adaptor_imp : public memory_resource
: public memory_resource
{ {
using _CTraits = allocator_traits<_CharAlloc>; using _CTraits = allocator_traits<_CharAlloc>;
static_assert(is_same<typename _CTraits::value_type, char>::value static_assert(is_same<typename _CTraits::value_type, char>::value
&& is_same<typename _CTraits::pointer, char*>::value && is_same<typename _CTraits::pointer, char*>::value
&& is_same<typename _CTraits::void_pointer, void*>::value, ""); && is_same<typename _CTraits::void_pointer, void*>::value, "");
static const size_t _MaxAlign = _LIBCPP_ALIGNOF(max_align_t); static const size_t _MaxAlign = _LIBCPP_ALIGNOF(max_align_t);
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

libcxx/include/experimental/type_traits

Show First 20 Lines • Show All 79 Lines • ▼ Show 20 Lines
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_LFTS _LIBCPP_BEGIN_NAMESPACE_LFTS
// 3.3.2, Other type transformations // 3.3.2, Other type transformations
/* /*
template <class> template <class>
class _LIBCPP_TEMPLATE_VIS raw_invocation_type; class raw_invocation_type;
template <class _Fn, class ..._Args> template <class _Fn, class ..._Args>
class _LIBCPP_TEMPLATE_VIS raw_invocation_type<_Fn(_Args...)>; class raw_invocation_type<_Fn(_Args...)>;
template <class> template <class>
class _LIBCPP_TEMPLATE_VIS invokation_type; class invokation_type;
template <class _Fn, class ..._Args> template <class _Fn, class ..._Args>
class _LIBCPP_TEMPLATE_VIS invokation_type<_Fn(_Args...)>; class invokation_type<_Fn(_Args...)>;
template <class _Tp> template <class _Tp>
using invokation_type_t = typename invokation_type<_Tp>::type; using invokation_type_t = typename invokation_type<_Tp>::type;
template <class _Tp> template <class _Tp>
using raw_invocation_type_t = typename raw_invocation_type<_Tp>::type; using raw_invocation_type_t = typename raw_invocation_type<_Tp>::type;
*/ */
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

libcxx/include/experimental/utility

Show All 34 Lines
#include <utility> #include <utility>
#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_LFTS _LIBCPP_BEGIN_NAMESPACE_LFTS
struct _LIBCPP_TEMPLATE_VIS erased_type { }; struct erased_type {};
_LIBCPP_END_NAMESPACE_LFTS _LIBCPP_END_NAMESPACE_LFTS
#endif /* _LIBCPP_EXPERIMENTAL_UTILITY */ #endif /* _LIBCPP_EXPERIMENTAL_UTILITY */

libcxx/include/ext/__hash

Show All 13 Lines
#include <__config> #include <__config>
#include <cstring> #include <cstring>
#include <stddef.h> #include <stddef.h>
#include <string> #include <string>
namespace __gnu_cxx { namespace __gnu_cxx {
template <typename _Tp> struct _LIBCPP_TEMPLATE_VIS hash { }; template <typename _Tp>
struct hash {};
template <> struct _LIBCPP_TEMPLATE_VIS hash<const char*> template <>
: public std::__unary_function<const char*, size_t> struct hash<const char*> : public std::__unary_function<const char*, size_t>
{ {
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
size_t operator()(const char *__c) const _NOEXCEPT size_t operator()(const char *__c) const _NOEXCEPT
{ {
return std::__do_string_hash(__c, __c + strlen(__c)); return std::__do_string_hash(__c, __c + strlen(__c));
} }
}; };
template <> struct _LIBCPP_TEMPLATE_VIS hash<char *> template <>
: public std::__unary_function<char*, size_t> struct hash<char *> : public std::__unary_function<char*, size_t>
{ {
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
size_t operator()(char *__c) const _NOEXCEPT size_t operator()(char *__c) const _NOEXCEPT
{ {
return std::__do_string_hash<const char *>(__c, __c + strlen(__c)); return std::__do_string_hash<const char *>(__c, __c + strlen(__c));
} }
}; };
template <> struct _LIBCPP_TEMPLATE_VIS hash<char> template <>
: public std::__unary_function<char, size_t> struct hash<char> : public std::__unary_function<char, size_t>
{ {
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
size_t operator()(char __c) const _NOEXCEPT size_t operator()(char __c) const _NOEXCEPT
{ {
return __c; return __c;
} }
}; };
template <> struct _LIBCPP_TEMPLATE_VIS hash<signed char> template <>
: public std::__unary_function<signed char, size_t> struct hash<signed char> : public std::__unary_function<signed char, size_t>
{ {
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
size_t operator()(signed char __c) const _NOEXCEPT size_t operator()(signed char __c) const _NOEXCEPT
{ {
return __c; return __c;
} }
}; };
template <> struct _LIBCPP_TEMPLATE_VIS hash<unsigned char> template <>
: public std::__unary_function<unsigned char, size_t> struct hash<unsigned char> : public std::__unary_function<unsigned char, size_t>
{ {
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
size_t operator()(unsigned char __c) const _NOEXCEPT size_t operator()(unsigned char __c) const _NOEXCEPT
{ {
return __c; return __c;
} }
}; };
template <> struct _LIBCPP_TEMPLATE_VIS hash<short> template <>
: public std::__unary_function<short, size_t> struct hash<short> : public std::__unary_function<short, size_t>
{ {
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
size_t operator()(short __c) const _NOEXCEPT size_t operator()(short __c) const _NOEXCEPT
{ {
return __c; return __c;
} }
}; };
template <> struct _LIBCPP_TEMPLATE_VIS hash<unsigned short> template <>
: public std::__unary_function<unsigned short, size_t> struct hash<unsigned short> : public std::__unary_function<unsigned short, size_t>
{ {
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
size_t operator()(unsigned short __c) const _NOEXCEPT size_t operator()(unsigned short __c) const _NOEXCEPT
{ {
return __c; return __c;
} }
}; };
template <> struct _LIBCPP_TEMPLATE_VIS hash<int> template <>
: public std::__unary_function<int, size_t> struct hash<int> : public std::__unary_function<int, size_t>
{ {
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
size_t operator()(int __c) const _NOEXCEPT size_t operator()(int __c) const _NOEXCEPT
{ {
return __c; return __c;
} }
}; };
template <> struct _LIBCPP_TEMPLATE_VIS hash<unsigned int> template <>
: public std::__unary_function<unsigned int, size_t> struct hash<unsigned int> : public std::__unary_function<unsigned int, size_t>
{ {
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
size_t operator()(unsigned int __c) const _NOEXCEPT size_t operator()(unsigned int __c) const _NOEXCEPT
{ {
return __c; return __c;
} }
}; };
template <> struct _LIBCPP_TEMPLATE_VIS hash<long> template <>
: public std::__unary_function<long, size_t> struct hash<long> : public std::__unary_function<long, size_t>
{ {
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
size_t operator()(long __c) const _NOEXCEPT size_t operator()(long __c) const _NOEXCEPT
{ {
return __c; return __c;
} }
}; };
template <> struct _LIBCPP_TEMPLATE_VIS hash<unsigned long> template <>
: public std::__unary_function<unsigned long, size_t> struct hash<unsigned long> : public std::__unary_function<unsigned long, size_t>
{ {
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
size_t operator()(unsigned long __c) const _NOEXCEPT size_t operator()(unsigned long __c) const _NOEXCEPT
{ {
return __c; return __c;
} }
}; };
} // namespace __gnu_cxx } // namespace __gnu_cxx
#endif // _LIBCPP_EXT_HASH #endif // _LIBCPP_EXT_HASH

libcxx/include/ext/hash_map

Show First 20 Lines • Show All 360 Lines • ▼ Show 20 Lines void operator()(pointer __p)
if (__first_constructed) if (__first_constructed)
__alloc_traits::destroy(__na_, _VSTD::addressof(__p->__value_.first)); __alloc_traits::destroy(__na_, _VSTD::addressof(__p->__value_.first));
if (__p) if (__p)
__alloc_traits::deallocate(__na_, __p, 1); __alloc_traits::deallocate(__na_, __p, 1);
} }
}; };
template <class _HashIterator> template <class _HashIterator>
class _LIBCPP_TEMPLATE_VIS __hash_map_iterator class __hash_map_iterator
{ {
_HashIterator __i_; _HashIterator __i_;
typedef const typename _HashIterator::value_type::first_type key_type; typedef const typename _HashIterator::value_type::first_type key_type;
typedef typename _HashIterator::value_type::second_type mapped_type; typedef typename _HashIterator::value_type::second_type mapped_type;
public: public:
typedef std::forward_iterator_tag iterator_category; typedef std::forward_iterator_tag iterator_category;
typedef std::pair<key_type, mapped_type> value_type; typedef std::pair<key_type, mapped_type> value_type;
Show All 20 Linespublic:
friend _LIBCPP_INLINE_VISIBILITY friend _LIBCPP_INLINE_VISIBILITY
bool operator==(const __hash_map_iterator& __x, const __hash_map_iterator& __y) bool operator==(const __hash_map_iterator& __x, const __hash_map_iterator& __y)
{return __x.__i_ == __y.__i_;} {return __x.__i_ == __y.__i_;}
friend _LIBCPP_INLINE_VISIBILITY friend _LIBCPP_INLINE_VISIBILITY
bool operator!=(const __hash_map_iterator& __x, const __hash_map_iterator& __y) bool operator!=(const __hash_map_iterator& __x, const __hash_map_iterator& __y)
{return __x.__i_ != __y.__i_;} {return __x.__i_ != __y.__i_;}
template <class, class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS hash_map; template <class, class, class, class, class> friend class hash_map;
template <class, class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS hash_multimap; template <class, class, class, class, class> friend class hash_multimap;
template <class> friend class _LIBCPP_TEMPLATE_VIS __hash_const_iterator; template <class> friend class __hash_const_iterator;
template <class> friend class _LIBCPP_TEMPLATE_VIS __hash_const_local_iterator; template <class> friend class __hash_const_local_iterator;
template <class> friend class _LIBCPP_TEMPLATE_VIS __hash_map_const_iterator; template <class> friend class __hash_map_const_iterator;
}; };
template <class _HashIterator> template <class _HashIterator>
class _LIBCPP_TEMPLATE_VIS __hash_map_const_iterator class __hash_map_const_iterator
{ {
_HashIterator __i_; _HashIterator __i_;
typedef const typename _HashIterator::value_type::first_type key_type; typedef const typename _HashIterator::value_type::first_type key_type;
typedef typename _HashIterator::value_type::second_type mapped_type; typedef typename _HashIterator::value_type::second_type mapped_type;
public: public:
typedef std::forward_iterator_tag iterator_category; typedef std::forward_iterator_tag iterator_category;
typedef std::pair<key_type, mapped_type> value_type; typedef std::pair<key_type, mapped_type> value_type;
Show All 28 Linespublic:
friend _LIBCPP_INLINE_VISIBILITY friend _LIBCPP_INLINE_VISIBILITY
bool operator==(const __hash_map_const_iterator& __x, const __hash_map_const_iterator& __y) bool operator==(const __hash_map_const_iterator& __x, const __hash_map_const_iterator& __y)
{return __x.__i_ == __y.__i_;} {return __x.__i_ == __y.__i_;}
friend _LIBCPP_INLINE_VISIBILITY friend _LIBCPP_INLINE_VISIBILITY
bool operator!=(const __hash_map_const_iterator& __x, const __hash_map_const_iterator& __y) bool operator!=(const __hash_map_const_iterator& __x, const __hash_map_const_iterator& __y)
{return __x.__i_ != __y.__i_;} {return __x.__i_ != __y.__i_;}
template <class, class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS hash_map; template <class, class, class, class, class> friend class hash_map;
template <class, class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS hash_multimap; template <class, class, class, class, class> friend class hash_multimap;
template <class> friend class _LIBCPP_TEMPLATE_VIS __hash_const_iterator; template <class> friend class __hash_const_iterator;
template <class> friend class _LIBCPP_TEMPLATE_VIS __hash_const_local_iterator; template <class> friend class __hash_const_local_iterator;
}; };
template <class _Key, class _Tp, class _Hash = hash<_Key>, class _Pred = std::equal_to<_Key>, template <class _Key, class _Tp, class _Hash = hash<_Key>, class _Pred = std::equal_to<_Key>,
class _Alloc = std::allocator<std::pair<const _Key, _Tp> > > class _Alloc = std::allocator<std::pair<const _Key, _Tp> > >
class _LIBCPP_TEMPLATE_VIS hash_map class hash_map
{ {
public: public:
// types // types
typedef _Key key_type; typedef _Key key_type;
typedef _Tp mapped_type; typedef _Tp mapped_type;
typedef _Tp data_type; typedef _Tp data_type;
typedef _Hash hasher; typedef _Hash hasher;
typedef _Pred key_equal; typedef _Pred key_equal;
▲ Show 20 Lines • Show All 256 Lines • ▼ Show 20 Lines
operator!=(const hash_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x, operator!=(const hash_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
const hash_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y) const hash_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
{ {
return !(__x == __y); return !(__x == __y);
} }
template <class _Key, class _Tp, class _Hash = hash<_Key>, class _Pred = std::equal_to<_Key>, template <class _Key, class _Tp, class _Hash = hash<_Key>, class _Pred = std::equal_to<_Key>,
class _Alloc = std::allocator<std::pair<const _Key, _Tp> > > class _Alloc = std::allocator<std::pair<const _Key, _Tp> > >
class _LIBCPP_TEMPLATE_VIS hash_multimap class hash_multimap
{ {
public: public:
// types // types
typedef _Key key_type; typedef _Key key_type;
typedef _Tp mapped_type; typedef _Tp mapped_type;
typedef _Tp data_type; typedef _Tp data_type;
typedef _Hash hasher; typedef _Hash hasher;
typedef _Pred key_equal; typedef _Pred key_equal;
▲ Show 20 Lines • Show All 242 Lines • Show Last 20 Lines

libcxx/include/ext/hash_set

Show First 20 Lines • Show All 210 Lines • ▼ Show 20 Lines
# pragma GCC system_header # pragma GCC system_header
#endif #endif
namespace __gnu_cxx { namespace __gnu_cxx {
template <class _Value, class _Hash = hash<_Value>, class _Pred = std::equal_to<_Value>, template <class _Value, class _Hash = hash<_Value>, class _Pred = std::equal_to<_Value>,
class _Alloc = std::allocator<_Value> > class _Alloc = std::allocator<_Value> >
class _LIBCPP_TEMPLATE_VIS hash_set class hash_set
{ {
public: public:
// types // types
typedef _Value key_type; typedef _Value key_type;
typedef key_type value_type; typedef key_type value_type;
typedef _Hash hasher; typedef _Hash hasher;
typedef _Pred key_equal; typedef _Pred key_equal;
typedef _Alloc allocator_type; typedef _Alloc allocator_type;
▲ Show 20 Lines • Show All 204 Lines • ▼ Show 20 Lines
operator!=(const hash_set<_Value, _Hash, _Pred, _Alloc>& __x, operator!=(const hash_set<_Value, _Hash, _Pred, _Alloc>& __x,
const hash_set<_Value, _Hash, _Pred, _Alloc>& __y) const hash_set<_Value, _Hash, _Pred, _Alloc>& __y)
{ {
return !(__x == __y); return !(__x == __y);
} }
template <class _Value, class _Hash = hash<_Value>, class _Pred = std::equal_to<_Value>, template <class _Value, class _Hash = hash<_Value>, class _Pred = std::equal_to<_Value>,
class _Alloc = std::allocator<_Value> > class _Alloc = std::allocator<_Value> >
class _LIBCPP_TEMPLATE_VIS hash_multiset class hash_multiset
{ {
public: public:
// types // types
typedef _Value key_type; typedef _Value key_type;
typedef key_type value_type; typedef key_type value_type;
typedef _Hash hasher; typedef _Hash hasher;
typedef _Pred key_equal; typedef _Pred key_equal;
typedef _Alloc allocator_type; typedef _Alloc allocator_type;
▲ Show 20 Lines • Show All 223 Lines • Show Last 20 Lines

libcxx/include/forward_list

Show First 20 Lines • Show All 305 Lines • ▼ Show 20 Linesstruct _LIBCPP_STANDALONE_DEBUG __forward_list_node
: public __begin_node_of<_Tp, _VoidPtr> : public __begin_node_of<_Tp, _VoidPtr>
{ {
typedef _Tp value_type; typedef _Tp value_type;
value_type __value_; value_type __value_;
}; };
template <class _Tp, class _Alloc = allocator<_Tp> > class _LIBCPP_TEMPLATE_VIS forward_list; template <class _Tp, class _Alloc = allocator<_Tp> > class forward_list;
template<class _NodeConstPtr> class _LIBCPP_TEMPLATE_VIS __forward_list_const_iterator; template<class _NodeConstPtr> class __forward_list_const_iterator;
template <class _NodePtr> template <class _NodePtr>
class _LIBCPP_TEMPLATE_VIS __forward_list_iterator class __forward_list_iterator
{ {
typedef __forward_node_traits<_NodePtr> __traits; typedef __forward_node_traits<_NodePtr> __traits;
typedef typename __traits::__node_pointer __node_pointer; typedef typename __traits::__node_pointer __node_pointer;
typedef typename __traits::__begin_node_pointer __begin_node_pointer; typedef typename __traits::__begin_node_pointer __begin_node_pointer;
typedef typename __traits::__iter_node_pointer __iter_node_pointer; typedef typename __traits::__iter_node_pointer __iter_node_pointer;
typedef typename __traits::__void_pointer __void_pointer; typedef typename __traits::__void_pointer __void_pointer;
__iter_node_pointer __ptr_; __iter_node_pointer __ptr_;
Show All 15 Linesclass __forward_list_iterator
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
explicit __forward_list_iterator(__begin_node_pointer __p) _NOEXCEPT explicit __forward_list_iterator(__begin_node_pointer __p) _NOEXCEPT
: __ptr_(__traits::__as_iter_node(__p)) {} : __ptr_(__traits::__as_iter_node(__p)) {}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
explicit __forward_list_iterator(__node_pointer __p) _NOEXCEPT explicit __forward_list_iterator(__node_pointer __p) _NOEXCEPT
: __ptr_(__traits::__as_iter_node(__p)) {} : __ptr_(__traits::__as_iter_node(__p)) {}
template<class, class> friend class _LIBCPP_TEMPLATE_VIS forward_list; template<class, class> friend class forward_list;
template<class> friend class _LIBCPP_TEMPLATE_VIS __forward_list_const_iterator; template<class> friend class __forward_list_const_iterator;
public: public:
typedef forward_iterator_tag iterator_category; typedef forward_iterator_tag iterator_category;
typedef typename __traits::__node_value_type value_type; typedef typename __traits::__node_value_type value_type;
typedef value_type& reference; typedef value_type& reference;
typedef typename pointer_traits<__node_pointer>::difference_type typedef typename pointer_traits<__node_pointer>::difference_type
difference_type; difference_type;
typedef __rebind_pointer_t<__node_pointer, value_type> pointer; typedef __rebind_pointer_t<__node_pointer, value_type> pointer;
Show All 28 Lines bool operator==(const __forward_list_iterator& __x,
{return __x.__ptr_ == __y.__ptr_;} {return __x.__ptr_ == __y.__ptr_;}
friend _LIBCPP_INLINE_VISIBILITY friend _LIBCPP_INLINE_VISIBILITY
bool operator!=(const __forward_list_iterator& __x, bool operator!=(const __forward_list_iterator& __x,
const __forward_list_iterator& __y) const __forward_list_iterator& __y)
{return !(__x == __y);} {return !(__x == __y);}
}; };
template <class _NodeConstPtr> template <class _NodeConstPtr>
class _LIBCPP_TEMPLATE_VIS __forward_list_const_iterator class __forward_list_const_iterator
{ {
static_assert((!is_const<typename pointer_traits<_NodeConstPtr>::element_type>::value), ""); static_assert((!is_const<typename pointer_traits<_NodeConstPtr>::element_type>::value), "");
typedef _NodeConstPtr _NodePtr; typedef _NodeConstPtr _NodePtr;
typedef __forward_node_traits<_NodePtr> __traits; typedef __forward_node_traits<_NodePtr> __traits;
typedef typename __traits::__node __node; typedef typename __traits::__node __node;
typedef typename __traits::__node_pointer __node_pointer; typedef typename __traits::__node_pointer __node_pointer;
typedef typename __traits::__begin_node_pointer __begin_node_pointer; typedef typename __traits::__begin_node_pointer __begin_node_pointer;
▲ Show 20 Lines • Show All 239 Lines • ▼ Show 20 Lines for (__node_pointer __p = __before_begin()->__next_; __p != nullptr;)
__node_traits::destroy(__a, _VSTD::addressof(__p->__value_)); __node_traits::destroy(__a, _VSTD::addressof(__p->__value_));
__node_traits::deallocate(__a, __p, 1); __node_traits::deallocate(__a, __p, 1);
__p = __next; __p = __next;
} }
__before_begin()->__next_ = nullptr; __before_begin()->__next_ = nullptr;
} }
template <class _Tp, class _Alloc /*= allocator<_Tp>*/> template <class _Tp, class _Alloc /*= allocator<_Tp>*/>
class _LIBCPP_TEMPLATE_VIS forward_list class forward_list : private __forward_list_base<_Tp, _Alloc>
: private __forward_list_base<_Tp, _Alloc>
{ {
typedef __forward_list_base<_Tp, _Alloc> base; typedef __forward_list_base<_Tp, _Alloc> base;
typedef typename base::__node_allocator __node_allocator; typedef typename base::__node_allocator __node_allocator;
typedef typename base::__node __node; typedef typename base::__node __node;
typedef typename base::__node_traits __node_traits; typedef typename base::__node_traits __node_traits;
typedef typename base::__node_pointer __node_pointer; typedef typename base::__node_pointer __node_pointer;
typedef typename base::__begin_node_pointer __begin_node_pointer; typedef typename base::__begin_node_pointer __begin_node_pointer;
▲ Show 20 Lines • Show All 1,175 Lines • Show Last 20 Lines

libcxx/include/fstream

Show First 20 Lines • Show All 208 Lines • ▼ Show 20 Lines
# define _LIBCPP_HAS_NO_OFF_T_FUNCTIONS # define _LIBCPP_HAS_NO_OFF_T_FUNCTIONS
#endif #endif
#if !defined(_LIBCPP_HAS_NO_FILESYSTEM) #if !defined(_LIBCPP_HAS_NO_FILESYSTEM)
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _CharT, class _Traits> template <class _CharT, class _Traits>
class _LIBCPP_TEMPLATE_VIS basic_filebuf class basic_filebuf : public basic_streambuf<_CharT, _Traits>
: public basic_streambuf<_CharT, _Traits>
{ {
public: public:
typedef _CharT char_type; typedef _CharT char_type;
typedef _Traits traits_type; typedef _Traits traits_type;
typedef typename traits_type::int_type int_type; typedef typename traits_type::int_type int_type;
typedef typename traits_type::pos_type pos_type; typedef typename traits_type::pos_type pos_type;
typedef typename traits_type::off_type off_type; typedef typename traits_type::off_type off_type;
typedef typename traits_type::state_type state_type; typedef typename traits_type::state_type state_type;
▲ Show 20 Lines • Show All 916 Lines • ▼ Show 20 Lines if (!(__cm_ & ios_base::out))
this->setp(nullptr, nullptr); this->setp(nullptr, nullptr);
__cm_ = ios_base::out; __cm_ = ios_base::out;
} }
} }
// basic_ifstream // basic_ifstream
template <class _CharT, class _Traits> template <class _CharT, class _Traits>
class _LIBCPP_TEMPLATE_VIS basic_ifstream class basic_ifstream : public basic_istream<_CharT, _Traits>
: public basic_istream<_CharT, _Traits>
{ {
public: public:
typedef _CharT char_type; typedef _CharT char_type;
typedef _Traits traits_type; typedef _Traits traits_type;
typedef typename traits_type::int_type int_type; typedef typename traits_type::int_type int_type;
typedef typename traits_type::pos_type pos_type; typedef typename traits_type::pos_type pos_type;
typedef typename traits_type::off_type off_type; typedef typename traits_type::off_type off_type;
▲ Show 20 Lines • Show All 182 Lines • ▼ Show 20 Lines
{ {
if (__sb_.close() == 0) if (__sb_.close() == 0)
this->setstate(ios_base::failbit); this->setstate(ios_base::failbit);
} }
// basic_ofstream // basic_ofstream
template <class _CharT, class _Traits> template <class _CharT, class _Traits>
class _LIBCPP_TEMPLATE_VIS basic_ofstream class basic_ofstream : public basic_ostream<_CharT, _Traits>
: public basic_ostream<_CharT, _Traits>
{ {
public: public:
typedef _CharT char_type; typedef _CharT char_type;
typedef _Traits traits_type; typedef _Traits traits_type;
typedef typename traits_type::int_type int_type; typedef typename traits_type::int_type int_type;
typedef typename traits_type::pos_type pos_type; typedef typename traits_type::pos_type pos_type;
typedef typename traits_type::off_type off_type; typedef typename traits_type::off_type off_type;
▲ Show 20 Lines • Show All 183 Lines • ▼ Show 20 Lines
{ {
if (__sb_.close() == nullptr) if (__sb_.close() == nullptr)
this->setstate(ios_base::failbit); this->setstate(ios_base::failbit);
} }
// basic_fstream // basic_fstream
template <class _CharT, class _Traits> template <class _CharT, class _Traits>
class _LIBCPP_TEMPLATE_VIS basic_fstream class basic_fstream : public basic_iostream<_CharT, _Traits>
: public basic_iostream<_CharT, _Traits>
{ {
public: public:
typedef _CharT char_type; typedef _CharT char_type;
typedef _Traits traits_type; typedef _Traits traits_type;
typedef typename traits_type::int_type int_type; typedef typename traits_type::int_type int_type;
typedef typename traits_type::pos_type pos_type; typedef typename traits_type::pos_type pos_type;
typedef typename traits_type::off_type off_type; typedef typename traits_type::off_type off_type;
▲ Show 20 Lines • Show All 202 Lines • Show Last 20 Lines

libcxx/include/future

Show First 20 Lines • Show All 406 Lines • ▼ Show 20 Lines_LIBCPP_DECLARE_STRONG_ENUM(future_errc)
future_already_retrieved = 1, future_already_retrieved = 1,
promise_already_satisfied, promise_already_satisfied,
no_state, no_state,
broken_promise broken_promise
}; };
_LIBCPP_DECLARE_STRONG_ENUM_EPILOG(future_errc) _LIBCPP_DECLARE_STRONG_ENUM_EPILOG(future_errc)
template <> template <>
struct _LIBCPP_TEMPLATE_VIS is_error_code_enum<future_errc> : public true_type {}; struct is_error_code_enum<future_errc> : public true_type {};
#ifdef _LIBCPP_CXX03_LANG #ifdef _LIBCPP_CXX03_LANG
template <> template <>
struct _LIBCPP_TEMPLATE_VIS is_error_code_enum<future_errc::__lx> : public true_type { }; struct is_error_code_enum<future_errc::__lx> : public true_type { };
#endif #endif
//enum class launch //enum class launch
_LIBCPP_DECLARE_STRONG_ENUM(launch) _LIBCPP_DECLARE_STRONG_ENUM(launch)
{ {
async = 1, async = 1,
deferred = 2, deferred = 2,
any = async | deferred any = async | deferred
▲ Show 20 Lines • Show All 602 Lines • ▼ Show 20 Lines
template <class _Fp> template <class _Fp>
void void
__async_assoc_state<void, _Fp>::__on_zero_shared() _NOEXCEPT __async_assoc_state<void, _Fp>::__on_zero_shared() _NOEXCEPT
{ {
this->wait(); this->wait();
base::__on_zero_shared(); base::__on_zero_shared();
} }
template <class _Rp> class _LIBCPP_TEMPLATE_VIS promise; template <class _Rp> class promise;
template <class _Rp> class _LIBCPP_TEMPLATE_VIS shared_future; template <class _Rp> class shared_future;
// future // future
template <class _Rp> class _LIBCPP_TEMPLATE_VIS future; template <class _Rp> class future;
template <class _Rp, class _Fp> template <class _Rp, class _Fp>
_LIBCPP_INLINE_VISIBILITY future<_Rp> _LIBCPP_INLINE_VISIBILITY future<_Rp>
__make_deferred_assoc_state(_Fp&& __f); __make_deferred_assoc_state(_Fp&& __f);
template <class _Rp, class _Fp> template <class _Rp, class _Fp>
_LIBCPP_INLINE_VISIBILITY future<_Rp> _LIBCPP_INLINE_VISIBILITY future<_Rp>
__make_async_assoc_state(_Fp&& __f); __make_async_assoc_state(_Fp&& __f);
template <class _Rp> template <class _Rp>
class _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FUTURE future class _LIBCPP_AVAILABILITY_FUTURE future
{ {
__assoc_state<_Rp>* __state_; __assoc_state<_Rp>* __state_;
explicit _LIBCPP_HIDE_FROM_ABI future(__assoc_state<_Rp>* __state); explicit _LIBCPP_HIDE_FROM_ABI future(__assoc_state<_Rp>* __state);
template <class> friend class promise; template <class> friend class promise;
template <class> friend class shared_future; template <class> friend class shared_future;
▲ Show 20 Lines • Show All 70 Lines • ▼ Show 20 Lines
{ {
unique_ptr<__shared_count, __release_shared_count> __guard(__state_); unique_ptr<__shared_count, __release_shared_count> __guard(__state_);
__assoc_state<_Rp>* __s = __state_; __assoc_state<_Rp>* __s = __state_;
__state_ = nullptr; __state_ = nullptr;
return __s->move(); return __s->move();
} }
template <class _Rp> template <class _Rp>
class _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FUTURE future<_Rp&> class _LIBCPP_AVAILABILITY_FUTURE future<_Rp&>
{ {
__assoc_state<_Rp&>* __state_; __assoc_state<_Rp&>* __state_;
explicit _LIBCPP_HIDE_FROM_ABI future(__assoc_state<_Rp&>* __state); explicit _LIBCPP_HIDE_FROM_ABI future(__assoc_state<_Rp&>* __state);
template <class> friend class promise; template <class> friend class promise;
template <class> friend class shared_future; template <class> friend class shared_future;
▲ Show 20 Lines • Show All 135 Lines • ▼ Show 20 Linesswap(future<_Rp>& __x, future<_Rp>& __y) _NOEXCEPT
__x.swap(__y); __x.swap(__y);
} }
// promise<R> // promise<R>
template <class _Callable> class packaged_task; template <class _Callable> class packaged_task;
template <class _Rp> template <class _Rp>
class _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FUTURE promise class _LIBCPP_AVAILABILITY_FUTURE promise
{ {
__assoc_state<_Rp>* __state_; __assoc_state<_Rp>* __state_;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
explicit promise(nullptr_t) _NOEXCEPT : __state_(nullptr) {} explicit promise(nullptr_t) _NOEXCEPT : __state_(nullptr) {}
template <class> friend class packaged_task; template <class> friend class packaged_task;
public: public:
▲ Show 20 Lines • Show All 127 Lines • ▼ Show 20 Linespromise<_Rp>::set_exception_at_thread_exit(exception_ptr __p)
if (__state_ == nullptr) if (__state_ == nullptr)
__throw_future_error(future_errc::no_state); __throw_future_error(future_errc::no_state);
__state_->set_exception_at_thread_exit(__p); __state_->set_exception_at_thread_exit(__p);
} }
// promise<R&> // promise<R&>
template <class _Rp> template <class _Rp>
class _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FUTURE promise<_Rp&> class _LIBCPP_AVAILABILITY_FUTURE promise<_Rp&>
{ {
__assoc_state<_Rp&>* __state_; __assoc_state<_Rp&>* __state_;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
explicit promise(nullptr_t) _NOEXCEPT : __state_(nullptr) {} explicit promise(nullptr_t) _NOEXCEPT : __state_(nullptr) {}
template <class> friend class packaged_task; template <class> friend class packaged_task;
▲ Show 20 Lines • Show All 173 Lines • ▼ Show 20 Lines
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
void void
swap(promise<_Rp>& __x, promise<_Rp>& __y) _NOEXCEPT swap(promise<_Rp>& __x, promise<_Rp>& __y) _NOEXCEPT
{ {
__x.swap(__y); __x.swap(__y);
} }
template <class _Rp, class _Alloc> template <class _Rp, class _Alloc>
struct _LIBCPP_TEMPLATE_VIS uses_allocator<promise<_Rp>, _Alloc> struct uses_allocator<promise<_Rp>, _Alloc> : public true_type {};
: public true_type {};
// packaged_task // packaged_task
template<class _Fp> class __packaged_task_base; template<class _Fp> class __packaged_task_base;
template<class _Rp, class ..._ArgTypes> template<class _Rp, class ..._ArgTypes>
class _LIBCPP_AVAILABILITY_FUTURE __packaged_task_base<_Rp(_ArgTypes...)> class _LIBCPP_AVAILABILITY_FUTURE __packaged_task_base<_Rp(_ArgTypes...)>
{ {
▲ Show 20 Lines • Show All 250 Lines • ▼ Show 20 Lines
inline inline
_Rp _Rp
__packaged_task_function<_Rp(_ArgTypes...)>::operator()(_ArgTypes... __arg) const __packaged_task_function<_Rp(_ArgTypes...)>::operator()(_ArgTypes... __arg) const
{ {
return (*__f_)(_VSTD::forward<_ArgTypes>(__arg)...); return (*__f_)(_VSTD::forward<_ArgTypes>(__arg)...);
} }
template<class _Rp, class ..._ArgTypes> template<class _Rp, class ..._ArgTypes>
class _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FUTURE packaged_task<_Rp(_ArgTypes...)> class _LIBCPP_AVAILABILITY_FUTURE packaged_task<_Rp(_ArgTypes...)>
{ {
public: public:
typedef _Rp result_type; // extension typedef _Rp result_type; // extension
private: private:
__packaged_task_function<result_type(_ArgTypes...)> __f_; __packaged_task_function<result_type(_ArgTypes...)> __f_;
promise<result_type> __p_; promise<result_type> __p_;
▲ Show 20 Lines • Show All 98 Lines • ▼ Show 20 Lines
packaged_task<_Rp(_ArgTypes...)>::reset() packaged_task<_Rp(_ArgTypes...)>::reset()
{ {
if (!valid()) if (!valid())
__throw_future_error(future_errc::no_state); __throw_future_error(future_errc::no_state);
__p_ = promise<result_type>(); __p_ = promise<result_type>();
} }
template<class ..._ArgTypes> template<class ..._ArgTypes>
class _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FUTURE packaged_task<void(_ArgTypes...)> class _LIBCPP_AVAILABILITY_FUTURE packaged_task<void(_ArgTypes...)>
{ {
public: public:
typedef void result_type; // extension typedef void result_type; // extension
private: private:
__packaged_task_function<result_type(_ArgTypes...)> __f_; __packaged_task_function<result_type(_ArgTypes...)> __f_;
promise<result_type> __p_; promise<result_type> __p_;
▲ Show 20 Lines • Show All 118 Lines • ▼ Show 20 Lines
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
void void
swap(packaged_task<_Rp(_ArgTypes...)>& __x, packaged_task<_Rp(_ArgTypes...)>& __y) _NOEXCEPT swap(packaged_task<_Rp(_ArgTypes...)>& __x, packaged_task<_Rp(_ArgTypes...)>& __y) _NOEXCEPT
{ {
__x.swap(__y); __x.swap(__y);
} }
template <class _Callable, class _Alloc> template <class _Callable, class _Alloc>
struct _LIBCPP_TEMPLATE_VIS uses_allocator<packaged_task<_Callable>, _Alloc> struct uses_allocator<packaged_task<_Callable>, _Alloc> : public true_type {};
: public true_type {};
template <class _Rp, class _Fp> template <class _Rp, class _Fp>
_LIBCPP_INLINE_VISIBILITY future<_Rp> _LIBCPP_INLINE_VISIBILITY future<_Rp>
__make_deferred_assoc_state(_Fp&& __f) __make_deferred_assoc_state(_Fp&& __f)
{ {
unique_ptr<__deferred_assoc_state<_Rp, _Fp>, __release_shared_count> unique_ptr<__deferred_assoc_state<_Rp, _Fp>, __release_shared_count>
__h(new __deferred_assoc_state<_Rp, _Fp>(_VSTD::forward<_Fp>(__f))); __h(new __deferred_assoc_state<_Rp, _Fp>(_VSTD::forward<_Fp>(__f)));
return future<_Rp>(__h.get()); return future<_Rp>(__h.get());
▲ Show 20 Lines • Show All 78 Lines • ▼ Show 20 Lines return _VSTD::async(launch::any, _VSTD::forward<_Fp>(__f),
_VSTD::forward<_Args>(__args)...); _VSTD::forward<_Args>(__args)...);
} }
#endif // C++03 #endif // C++03
// shared_future // shared_future
template <class _Rp> template <class _Rp>
class _LIBCPP_TEMPLATE_VIS shared_future class shared_future
{ {
__assoc_state<_Rp>* __state_; __assoc_state<_Rp>* __state_;
public: public:
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
shared_future() _NOEXCEPT : __state_(nullptr) {} shared_future() _NOEXCEPT : __state_(nullptr) {}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
shared_future(const shared_future& __rhs) _NOEXCEPT : __state_(__rhs.__state_) shared_future(const shared_future& __rhs) _NOEXCEPT : __state_(__rhs.__state_)
▲ Show 20 Lines • Show All 53 Lines • ▼ Show 20 Lines if (__rhs.__state_)
__rhs.__state_->__add_shared(); __rhs.__state_->__add_shared();
if (__state_) if (__state_)
__state_->__release_shared(); __state_->__release_shared();
__state_ = __rhs.__state_; __state_ = __rhs.__state_;
return *this; return *this;
} }
template <class _Rp> template <class _Rp>
class _LIBCPP_TEMPLATE_VIS shared_future<_Rp&> class shared_future<_Rp&>
{ {
__assoc_state<_Rp&>* __state_; __assoc_state<_Rp&>* __state_;
public: public:
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
shared_future() _NOEXCEPT : __state_(nullptr) {} shared_future() _NOEXCEPT : __state_(nullptr) {}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
shared_future(const shared_future& __rhs) : __state_(__rhs.__state_) shared_future(const shared_future& __rhs) : __state_(__rhs.__state_)
▲ Show 20 Lines • Show All 156 Lines • Show Last 20 Lines

libcxx/include/initializer_list

Show First 20 Lines • Show All 50 Lines • ▼ Show 20 Lines
#endif #endif
namespace std // purposefully not versioned namespace std // purposefully not versioned
{ {
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
template<class _Ep> template<class _Ep>
class _LIBCPP_TEMPLATE_VIS initializer_list class initializer_list
{ {
const _Ep* __begin_; const _Ep* __begin_;
size_t __size_; size_t __size_;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_CONSTEXPR_SINCE_CXX14
initializer_list(const _Ep* __b, size_t __s) _NOEXCEPT initializer_list(const _Ep* __b, size_t __s) _NOEXCEPT
: __begin_(__b), : __begin_(__b),
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

libcxx/include/ios

Show First 20 Lines • Show All 411 Lines • ▼ Show 20 Lines
//enum class io_errc //enum class io_errc
_LIBCPP_DECLARE_STRONG_ENUM(io_errc) _LIBCPP_DECLARE_STRONG_ENUM(io_errc)
{ {
stream = 1 stream = 1
}; };
_LIBCPP_DECLARE_STRONG_ENUM_EPILOG(io_errc) _LIBCPP_DECLARE_STRONG_ENUM_EPILOG(io_errc)
template <> template <>
struct _LIBCPP_TEMPLATE_VIS is_error_code_enum<io_errc> : public true_type { }; struct is_error_code_enum<io_errc> : public true_type { };
#ifdef _LIBCPP_CXX03_LANG #ifdef _LIBCPP_CXX03_LANG
template <> template <>
struct _LIBCPP_TEMPLATE_VIS is_error_code_enum<io_errc::__lx> : public true_type { }; struct is_error_code_enum<io_errc::__lx> : public true_type { };
#endif #endif
_LIBCPP_FUNC_VIS _LIBCPP_FUNC_VIS
const error_category& iostream_category() _NOEXCEPT; const error_category& iostream_category() _NOEXCEPT;
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
error_code error_code
make_error_code(io_errc __e) _NOEXCEPT make_error_code(io_errc __e) _NOEXCEPT
▲ Show 20 Lines • Show All 169 Lines • ▼ Show 20 Lines
void void
ios_base::exceptions(iostate __iostate) ios_base::exceptions(iostate __iostate)
{ {
__exceptions_ = __iostate; __exceptions_ = __iostate;
clear(__rdstate_); clear(__rdstate_);
} }
template <class _CharT, class _Traits> template <class _CharT, class _Traits>
class _LIBCPP_TEMPLATE_VIS basic_ios class basic_ios : public ios_base
: public ios_base
{ {
public: public:
// types: // types:
typedef _CharT char_type; typedef _CharT char_type;
typedef _Traits traits_type; typedef _Traits traits_type;
typedef typename traits_type::int_type int_type; typedef typename traits_type::int_type int_type;
typedef typename traits_type::pos_type pos_type; typedef typename traits_type::pos_type pos_type;
▲ Show 20 Lines • Show All 447 Lines • Show Last 20 Lines

libcxx/include/iosfwd

Show First 20 Lines • Show All 109 Lines • ▼ Show 20 Lines
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
class _LIBCPP_TYPE_VIS ios_base; class _LIBCPP_TYPE_VIS ios_base;
template <class _CharT, class _Traits = char_traits<_CharT> > template <class _CharT, class _Traits = char_traits<_CharT> >
class _LIBCPP_TEMPLATE_VIS istreambuf_iterator; class istreambuf_iterator;
template <class _CharT, class _Traits = char_traits<_CharT> > template <class _CharT, class _Traits = char_traits<_CharT> >
class _LIBCPP_TEMPLATE_VIS ostreambuf_iterator; class ostreambuf_iterator;
template <class _State>
class fpos;
template <class _State> class _LIBCPP_TEMPLATE_VIS fpos;
typedef fpos<mbstate_t> streampos; typedef fpos<mbstate_t> streampos;
typedef fpos<mbstate_t> wstreampos; typedef fpos<mbstate_t> wstreampos;
#ifndef _LIBCPP_HAS_NO_CHAR8_T #ifndef _LIBCPP_HAS_NO_CHAR8_T
typedef fpos<mbstate_t> u8streampos; typedef fpos<mbstate_t> u8streampos;
#endif #endif
typedef fpos<mbstate_t> u16streampos; typedef fpos<mbstate_t> u16streampos;
typedef fpos<mbstate_t> u32streampos; typedef fpos<mbstate_t> u32streampos;
// Include other forward declarations here // Include other forward declarations here
template <class _Tp, class _Alloc = allocator<_Tp> > template <class _Tp, class _Alloc = allocator<_Tp> >
class _LIBCPP_TEMPLATE_VIS vector; class vector;
template <class _CharT, class _Traits> template <class _CharT, class _Traits>
class __save_flags class __save_flags
{ {
typedef basic_ios<_CharT, _Traits> __stream_type; typedef basic_ios<_CharT, _Traits> __stream_type;
typedef typename __stream_type::fmtflags fmtflags; typedef typename __stream_type::fmtflags fmtflags;
__stream_type& __stream_; __stream_type& __stream_;
Show All 23 Lines

libcxx/include/istream

Show First 20 Lines • Show All 175 Lines • ▼ Show 20 Lines
_LIBCPP_PUSH_MACROS _LIBCPP_PUSH_MACROS
#include <__undef_macros> #include <__undef_macros>
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _CharT, class _Traits> template <class _CharT, class _Traits>
class _LIBCPP_TEMPLATE_VIS basic_istream class basic_istream : virtual public basic_ios<_CharT, _Traits>
: virtual public basic_ios<_CharT, _Traits>
{ {
streamsize __gc_; streamsize __gc_;
public: public:
// types (inherited from basic_ios (27.5.4)): // types (inherited from basic_ios (27.5.4)):
typedef _CharT char_type; typedef _CharT char_type;
typedef _Traits traits_type; typedef _Traits traits_type;
typedef typename traits_type::int_type int_type; typedef typename traits_type::int_type int_type;
typedef typename traits_type::pos_type pos_type; typedef typename traits_type::pos_type pos_type;
Show All 18 Lines void swap(basic_istream& __rhs) {
basic_ios<char_type, traits_type>::swap(__rhs); basic_ios<char_type, traits_type>::swap(__rhs);
} }
basic_istream (const basic_istream& __rhs) = delete; basic_istream (const basic_istream& __rhs) = delete;
basic_istream& operator=(const basic_istream& __rhs) = delete; basic_istream& operator=(const basic_istream& __rhs) = delete;
public: public:
// 27.7.1.1.3 Prefix/suffix: // 27.7.1.1.3 Prefix/suffix:
class _LIBCPP_TEMPLATE_VIS sentry; class sentry;
// 27.7.1.2 Formatted input: // 27.7.1.2 Formatted input:
inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
basic_istream& operator>>(basic_istream& (*__pf)(basic_istream&)) basic_istream& operator>>(basic_istream& (*__pf)(basic_istream&))
{ return __pf(*this); } { return __pf(*this); }
inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
basic_istream& operator>>(basic_ios<char_type, traits_type>& basic_istream& operator>>(basic_ios<char_type, traits_type>&
▲ Show 20 Lines • Show All 60 Lines • ▼ Show 20 Linespublic:
int sync(); int sync();
pos_type tellg(); pos_type tellg();
basic_istream& seekg(pos_type __pos); basic_istream& seekg(pos_type __pos);
basic_istream& seekg(off_type __off, ios_base::seekdir __dir); basic_istream& seekg(off_type __off, ios_base::seekdir __dir);
}; };
template <class _CharT, class _Traits> template <class _CharT, class _Traits>
class _LIBCPP_TEMPLATE_VIS basic_istream<_CharT, _Traits>::sentry class basic_istream<_CharT, _Traits>::sentry
{ {
bool __ok_; bool __ok_;
public: public:
explicit sentry(basic_istream<_CharT, _Traits>& __is, bool __noskipws = false); explicit sentry(basic_istream<_CharT, _Traits>& __is, bool __noskipws = false);
// ~sentry() = default; // ~sentry() = default;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
▲ Show 20 Lines • Show All 1,084 Lines • ▼ Show 20 Lines
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
_Stream&& operator>>(_Stream&& __is, _Tp&& __x) _Stream&& operator>>(_Stream&& __is, _Tp&& __x)
{ {
__is >> _VSTD::forward<_Tp>(__x); __is >> _VSTD::forward<_Tp>(__x);
return _VSTD::move(__is); return _VSTD::move(__is);
} }
template <class _CharT, class _Traits> template <class _CharT, class _Traits>
class _LIBCPP_TEMPLATE_VIS basic_iostream class basic_iostream : public basic_istream<_CharT, _Traits>, public basic_ostream<_CharT, _Traits> {
: public basic_istream<_CharT, _Traits>,
public basic_ostream<_CharT, _Traits>
{
public: public:
// types: // types:
typedef _CharT char_type; typedef _CharT char_type;
typedef _Traits traits_type; typedef _Traits traits_type;
typedef typename traits_type::int_type int_type; typedef typename traits_type::int_type int_type;
typedef typename traits_type::pos_type pos_type; typedef typename traits_type::pos_type pos_type;
typedef typename traits_type::off_type off_type; typedef typename traits_type::off_type off_type;
// constructor/destructor // constructor/destructor
▲ Show 20 Lines • Show All 242 Lines • Show Last 20 Lines

libcxx/include/limits

Show First 20 Lines • Show All 442 Lines • ▼ Show 20 Lines#if (defined(__arm__) || defined(__aarch64__))
static _LIBCPP_CONSTEXPR const bool tinyness_before = true; static _LIBCPP_CONSTEXPR const bool tinyness_before = true;
#else #else
static _LIBCPP_CONSTEXPR const bool tinyness_before = false; static _LIBCPP_CONSTEXPR const bool tinyness_before = false;
#endif #endif
static _LIBCPP_CONSTEXPR const float_round_style round_style = round_to_nearest; static _LIBCPP_CONSTEXPR const float_round_style round_style = round_to_nearest;
}; };
template <class _Tp> template <class _Tp>
class _LIBCPP_TEMPLATE_VIS numeric_limits class numeric_limits : private __libcpp_numeric_limits<__remove_cv_t<_Tp> >
: private __libcpp_numeric_limits<__remove_cv_t<_Tp> >
{ {
typedef __libcpp_numeric_limits<__remove_cv_t<_Tp> > __base; typedef __libcpp_numeric_limits<__remove_cv_t<_Tp> > __base;
typedef typename __base::type type; typedef typename __base::type type;
public: public:
static _LIBCPP_CONSTEXPR const bool is_specialized = __base::is_specialized; static _LIBCPP_CONSTEXPR const bool is_specialized = __base::is_specialized;
_LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type min() _NOEXCEPT {return __base::min();} _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type min() _NOEXCEPT {return __base::min();}
_LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type max() _NOEXCEPT {return __base::max();} _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type max() _NOEXCEPT {return __base::max();}
_LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type lowest() _NOEXCEPT {return __base::lowest();} _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type lowest() _NOEXCEPT {return __base::lowest();}
▲ Show 20 Lines • Show All 75 Lines • ▼ Show 20 Lines
template <class _Tp> template <class _Tp>
_LIBCPP_CONSTEXPR const bool numeric_limits<_Tp>::traps; _LIBCPP_CONSTEXPR const bool numeric_limits<_Tp>::traps;
template <class _Tp> template <class _Tp>
_LIBCPP_CONSTEXPR const bool numeric_limits<_Tp>::tinyness_before; _LIBCPP_CONSTEXPR const bool numeric_limits<_Tp>::tinyness_before;
template <class _Tp> template <class _Tp>
_LIBCPP_CONSTEXPR const float_round_style numeric_limits<_Tp>::round_style; _LIBCPP_CONSTEXPR const float_round_style numeric_limits<_Tp>::round_style;
template <class _Tp> template <class _Tp>
class _LIBCPP_TEMPLATE_VIS numeric_limits<const _Tp> class numeric_limits<const _Tp> : private numeric_limits<_Tp>
: private numeric_limits<_Tp>
{ {
typedef numeric_limits<_Tp> __base; typedef numeric_limits<_Tp> __base;
typedef _Tp type; typedef _Tp type;
public: public:
static _LIBCPP_CONSTEXPR const bool is_specialized = __base::is_specialized; static _LIBCPP_CONSTEXPR const bool is_specialized = __base::is_specialized;
_LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type min() _NOEXCEPT {return __base::min();} _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type min() _NOEXCEPT {return __base::min();}
_LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type max() _NOEXCEPT {return __base::max();} _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type max() _NOEXCEPT {return __base::max();}
_LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type lowest() _NOEXCEPT {return __base::lowest();} _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type lowest() _NOEXCEPT {return __base::lowest();}
▲ Show 20 Lines • Show All 75 Lines • ▼ Show 20 Lines
template <class _Tp> template <class _Tp>
_LIBCPP_CONSTEXPR const bool numeric_limits<const _Tp>::traps; _LIBCPP_CONSTEXPR const bool numeric_limits<const _Tp>::traps;
template <class _Tp> template <class _Tp>
_LIBCPP_CONSTEXPR const bool numeric_limits<const _Tp>::tinyness_before; _LIBCPP_CONSTEXPR const bool numeric_limits<const _Tp>::tinyness_before;
template <class _Tp> template <class _Tp>
_LIBCPP_CONSTEXPR const float_round_style numeric_limits<const _Tp>::round_style; _LIBCPP_CONSTEXPR const float_round_style numeric_limits<const _Tp>::round_style;
template <class _Tp> template <class _Tp>
class _LIBCPP_TEMPLATE_VIS numeric_limits<volatile _Tp> class numeric_limits<volatile _Tp> : private numeric_limits<_Tp>
: private numeric_limits<_Tp>
{ {
typedef numeric_limits<_Tp> __base; typedef numeric_limits<_Tp> __base;
typedef _Tp type; typedef _Tp type;
public: public:
static _LIBCPP_CONSTEXPR const bool is_specialized = __base::is_specialized; static _LIBCPP_CONSTEXPR const bool is_specialized = __base::is_specialized;
_LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type min() _NOEXCEPT {return __base::min();} _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type min() _NOEXCEPT {return __base::min();}
_LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type max() _NOEXCEPT {return __base::max();} _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type max() _NOEXCEPT {return __base::max();}
_LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type lowest() _NOEXCEPT {return __base::lowest();} _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type lowest() _NOEXCEPT {return __base::lowest();}
▲ Show 20 Lines • Show All 75 Lines • ▼ Show 20 Lines
template <class _Tp> template <class _Tp>
_LIBCPP_CONSTEXPR const bool numeric_limits<volatile _Tp>::traps; _LIBCPP_CONSTEXPR const bool numeric_limits<volatile _Tp>::traps;
template <class _Tp> template <class _Tp>
_LIBCPP_CONSTEXPR const bool numeric_limits<volatile _Tp>::tinyness_before; _LIBCPP_CONSTEXPR const bool numeric_limits<volatile _Tp>::tinyness_before;
template <class _Tp> template <class _Tp>
_LIBCPP_CONSTEXPR const float_round_style numeric_limits<volatile _Tp>::round_style; _LIBCPP_CONSTEXPR const float_round_style numeric_limits<volatile _Tp>::round_style;
template <class _Tp> template <class _Tp>
class _LIBCPP_TEMPLATE_VIS numeric_limits<const volatile _Tp> class numeric_limits<const volatile _Tp> : private numeric_limits<_Tp>
: private numeric_limits<_Tp>
{ {
typedef numeric_limits<_Tp> __base; typedef numeric_limits<_Tp> __base;
typedef _Tp type; typedef _Tp type;
public: public:
static _LIBCPP_CONSTEXPR const bool is_specialized = __base::is_specialized; static _LIBCPP_CONSTEXPR const bool is_specialized = __base::is_specialized;
_LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type min() _NOEXCEPT {return __base::min();} _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type min() _NOEXCEPT {return __base::min();}
_LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type max() _NOEXCEPT {return __base::max();} _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type max() _NOEXCEPT {return __base::max();}
_LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type lowest() _NOEXCEPT {return __base::lowest();} _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type lowest() _NOEXCEPT {return __base::lowest();}
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

libcxx/include/list

Show First 20 Lines • Show All 311 Lines • ▼ Show 20 Linesstruct _LIBCPP_STANDALONE_DEBUG __list_node
typedef typename __base::__link_pointer __link_pointer; typedef typename __base::__link_pointer __link_pointer;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
__link_pointer __as_link() { __link_pointer __as_link() {
return static_cast<__link_pointer>(__base::__self()); return static_cast<__link_pointer>(__base::__self());
} }
}; };
template <class _Tp, class _Alloc = allocator<_Tp> > class _LIBCPP_TEMPLATE_VIS list; template <class _Tp, class _Alloc = allocator<_Tp> >
class list;
template <class _Tp, class _Alloc> class __list_imp; template <class _Tp, class _Alloc> class __list_imp;
template <class _Tp, class _VoidPtr> class _LIBCPP_TEMPLATE_VIS __list_const_iterator; template <class _Tp, class _VoidPtr>
class __list_const_iterator;
template <class _Tp, class _VoidPtr> template <class _Tp, class _VoidPtr>
class _LIBCPP_TEMPLATE_VIS __list_iterator class __list_iterator
{ {
typedef __list_node_pointer_traits<_Tp, _VoidPtr> _NodeTraits; typedef __list_node_pointer_traits<_Tp, _VoidPtr> _NodeTraits;
typedef typename _NodeTraits::__link_pointer __link_pointer; typedef typename _NodeTraits::__link_pointer __link_pointer;
__link_pointer __ptr_; __link_pointer __ptr_;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
explicit __list_iterator(__link_pointer __p, const void* __c) _NOEXCEPT explicit __list_iterator(__link_pointer __p, const void* __c) _NOEXCEPT
▲ Show 20 Lines • Show All 92 Lines • ▼ Show 20 Lines bool operator==(const __list_iterator& __x, const __list_iterator& __y)
return __x.__ptr_ == __y.__ptr_; return __x.__ptr_ == __y.__ptr_;
} }
friend _LIBCPP_INLINE_VISIBILITY friend _LIBCPP_INLINE_VISIBILITY
bool operator!=(const __list_iterator& __x, const __list_iterator& __y) bool operator!=(const __list_iterator& __x, const __list_iterator& __y)
{return !(__x == __y);} {return !(__x == __y);}
}; };
template <class _Tp, class _VoidPtr> template <class _Tp, class _VoidPtr>
class _LIBCPP_TEMPLATE_VIS __list_const_iterator class __list_const_iterator
{ {
typedef __list_node_pointer_traits<_Tp, _VoidPtr> _NodeTraits; typedef __list_node_pointer_traits<_Tp, _VoidPtr> _NodeTraits;
typedef typename _NodeTraits::__link_pointer __link_pointer; typedef typename _NodeTraits::__link_pointer __link_pointer;
__link_pointer __ptr_; __link_pointer __ptr_;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
explicit __list_const_iterator(__link_pointer __p, const void* __c) _NOEXCEPT explicit __list_const_iterator(__link_pointer __p, const void* __c) _NOEXCEPT
▲ Show 20 Lines • Show All 370 Lines • ▼ Show 20 Lines for (__i_node** __p = __cn2->end_; __p != __cn2->beg_;)
else else
(*__p)->__c_ = __cn2; (*__p)->__c_ = __cn2;
} }
__db->unlock(); __db->unlock();
#endif #endif
} }
template <class _Tp, class _Alloc /*= allocator<_Tp>*/> template <class _Tp, class _Alloc /*= allocator<_Tp>*/>
class _LIBCPP_TEMPLATE_VIS list class list : private __list_imp<_Tp, _Alloc>
: private __list_imp<_Tp, _Alloc>
{ {
typedef __list_imp<_Tp, _Alloc> base; typedef __list_imp<_Tp, _Alloc> base;
typedef typename base::__node __node; typedef typename base::__node __node;
typedef typename base::__node_allocator __node_allocator; typedef typename base::__node_allocator __node_allocator;
typedef typename base::__node_pointer __node_pointer; typedef typename base::__node_pointer __node_pointer;
typedef typename base::__node_alloc_traits __node_alloc_traits; typedef typename base::__node_alloc_traits __node_alloc_traits;
typedef typename base::__node_base __node_base; typedef typename base::__node_base __node_base;
typedef typename base::__node_base_pointer __node_base_pointer; typedef typename base::__node_base_pointer __node_base_pointer;
▲ Show 20 Lines • Show All 1,583 Lines • Show Last 20 Lines

libcxx/include/locale

Show First 20 Lines • Show All 584 Lines • ▼ Show 20 Lines
} }
extern template struct _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS __num_get<char>; extern template struct _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS __num_get<char>;
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
extern template struct _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS __num_get<wchar_t>; extern template struct _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS __num_get<wchar_t>;
#endif #endif
template <class _CharT, class _InputIterator = istreambuf_iterator<_CharT> > template <class _CharT, class _InputIterator = istreambuf_iterator<_CharT> >
class _LIBCPP_TEMPLATE_VIS num_get class num_get : public locale::facet, private __num_get<_CharT>
: public locale::facet,
private __num_get<_CharT>
{ {
public: public:
typedef _CharT char_type; typedef _CharT char_type;
typedef _InputIterator iter_type; typedef _InputIterator iter_type;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
explicit num_get(size_t __refs = 0) explicit num_get(size_t __refs = 0)
: locale::facet(__refs) {} : locale::facet(__refs) {}
▲ Show 20 Lines • Show All 672 Lines • ▼ Show 20 Lines
} }
extern template struct _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS __num_put<char>; extern template struct _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS __num_put<char>;
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
extern template struct _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS __num_put<wchar_t>; extern template struct _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS __num_put<wchar_t>;
#endif #endif
template <class _CharT, class _OutputIterator = ostreambuf_iterator<_CharT> > template <class _CharT, class _OutputIterator = ostreambuf_iterator<_CharT> >
class _LIBCPP_TEMPLATE_VIS num_put class num_put : public locale::facet, private __num_put<_CharT>
: public locale::facet,
private __num_put<_CharT>
{ {
public: public:
typedef _CharT char_type; typedef _CharT char_type;
typedef _OutputIterator iter_type; typedef _OutputIterator iter_type;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
explicit num_put(size_t __refs = 0) explicit num_put(size_t __refs = 0)
: locale::facet(__refs) {} : locale::facet(__refs) {}
▲ Show 20 Lines • Show All 390 Lines • ▼ Show 20 Lines
class _LIBCPP_TYPE_VIS time_base class _LIBCPP_TYPE_VIS time_base
{ {
public: public:
enum dateorder {no_order, dmy, mdy, ymd, ydm}; enum dateorder {no_order, dmy, mdy, ymd, ydm};
}; };
template <class _CharT> template <class _CharT>
class _LIBCPP_TEMPLATE_VIS __time_get_c_storage class __time_get_c_storage
{ {
protected: protected:
typedef basic_string<_CharT> string_type; typedef basic_string<_CharT> string_type;
virtual const string_type* __weeks() const; virtual const string_type* __weeks() const;
virtual const string_type* __months() const; virtual const string_type* __months() const;
virtual const string_type* __am_pm() const; virtual const string_type* __am_pm() const;
virtual const string_type& __c() const; virtual const string_type& __c() const;
Show All 19 Lines
template <> _LIBCPP_FUNC_VIS const wstring* __time_get_c_storage<wchar_t>::__am_pm() const; template <> _LIBCPP_FUNC_VIS const wstring* __time_get_c_storage<wchar_t>::__am_pm() const;
template <> _LIBCPP_FUNC_VIS const wstring& __time_get_c_storage<wchar_t>::__c() const; template <> _LIBCPP_FUNC_VIS const wstring& __time_get_c_storage<wchar_t>::__c() const;
template <> _LIBCPP_FUNC_VIS const wstring& __time_get_c_storage<wchar_t>::__r() const; template <> _LIBCPP_FUNC_VIS const wstring& __time_get_c_storage<wchar_t>::__r() const;
template <> _LIBCPP_FUNC_VIS const wstring& __time_get_c_storage<wchar_t>::__x() const; template <> _LIBCPP_FUNC_VIS const wstring& __time_get_c_storage<wchar_t>::__x() const;
template <> _LIBCPP_FUNC_VIS const wstring& __time_get_c_storage<wchar_t>::__X() const; template <> _LIBCPP_FUNC_VIS const wstring& __time_get_c_storage<wchar_t>::__X() const;
#endif #endif
template <class _CharT, class _InputIterator = istreambuf_iterator<_CharT> > template <class _CharT, class _InputIterator = istreambuf_iterator<_CharT> >
class _LIBCPP_TEMPLATE_VIS time_get class time_get : public locale::facet, public time_base, private __time_get_c_storage<_CharT>
: public locale::facet,
public time_base,
private __time_get_c_storage<_CharT>
{ {
public: public:
typedef _CharT char_type; typedef _CharT char_type;
typedef _InputIterator iter_type; typedef _InputIterator iter_type;
typedef time_base::dateorder dateorder; typedef time_base::dateorder dateorder;
typedef basic_string<char_type> string_type; typedef basic_string<char_type> string_type;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
▲ Show 20 Lines • Show All 604 Lines • ▼ Show 20 Linesprotected:
locale_t __loc_; locale_t __loc_;
__time_get(const char* __nm); __time_get(const char* __nm);
__time_get(const string& __nm); __time_get(const string& __nm);
~__time_get(); ~__time_get();
}; };
template <class _CharT> template <class _CharT>
class _LIBCPP_TEMPLATE_VIS __time_get_storage class __time_get_storage : public __time_get
: public __time_get
{ {
protected: protected:
typedef basic_string<_CharT> string_type; typedef basic_string<_CharT> string_type;
string_type __weeks_[14]; string_type __weeks_[14];
string_type __months_[24]; string_type __months_[24];
string_type __am_pm_[2]; string_type __am_pm_[2];
string_type __c_; string_type __c_;
Show All 28 Lines
_LIBCPP_TIME_GET_STORAGE_EXPLICIT_INSTANTIATION(char) _LIBCPP_TIME_GET_STORAGE_EXPLICIT_INSTANTIATION(char)
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
_LIBCPP_TIME_GET_STORAGE_EXPLICIT_INSTANTIATION(wchar_t) _LIBCPP_TIME_GET_STORAGE_EXPLICIT_INSTANTIATION(wchar_t)
#endif #endif
#undef _LIBCPP_TIME_GET_STORAGE_EXPLICIT_INSTANTIATION #undef _LIBCPP_TIME_GET_STORAGE_EXPLICIT_INSTANTIATION
template <class _CharT, class _InputIterator = istreambuf_iterator<_CharT> > template <class _CharT, class _InputIterator = istreambuf_iterator<_CharT> >
class _LIBCPP_TEMPLATE_VIS time_get_byname class time_get_byname : public time_get<_CharT, _InputIterator>, private __time_get_storage<_CharT>
: public time_get<_CharT, _InputIterator>,
private __time_get_storage<_CharT>
{ {
public: public:
typedef time_base::dateorder dateorder; typedef time_base::dateorder dateorder;
typedef _InputIterator iter_type; typedef _InputIterator iter_type;
typedef _CharT char_type; typedef _CharT char_type;
typedef basic_string<char_type> string_type; typedef basic_string<char_type> string_type;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
Show All 36 Lines void __do_put(char* __nb, char*& __ne, const tm* __tm,
char __fmt, char __mod) const; char __fmt, char __mod) const;
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
void __do_put(wchar_t* __wb, wchar_t*& __we, const tm* __tm, void __do_put(wchar_t* __wb, wchar_t*& __we, const tm* __tm,
char __fmt, char __mod) const; char __fmt, char __mod) const;
#endif #endif
}; };
template <class _CharT, class _OutputIterator = ostreambuf_iterator<_CharT> > template <class _CharT, class _OutputIterator = ostreambuf_iterator<_CharT> >
class _LIBCPP_TEMPLATE_VIS time_put class time_put : public locale::facet, private __time_put
: public locale::facet,
private __time_put
{ {
public: public:
typedef _CharT char_type; typedef _CharT char_type;
typedef _OutputIterator iter_type; typedef _OutputIterator iter_type;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
explicit time_put(size_t __refs = 0) explicit time_put(size_t __refs = 0)
: locale::facet(__refs) {} : locale::facet(__refs) {}
▲ Show 20 Lines • Show All 81 Lines • ▼ Show 20 Lines
} }
extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS time_put<char>; extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS time_put<char>;
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS time_put<wchar_t>; extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS time_put<wchar_t>;
#endif #endif
template <class _CharT, class _OutputIterator = ostreambuf_iterator<_CharT> > template <class _CharT, class _OutputIterator = ostreambuf_iterator<_CharT> >
class _LIBCPP_TEMPLATE_VIS time_put_byname class time_put_byname : public time_put<_CharT, _OutputIterator>
: public time_put<_CharT, _OutputIterator>
{ {
public: public:
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
explicit time_put_byname(const char* __nm, size_t __refs = 0) explicit time_put_byname(const char* __nm, size_t __refs = 0)
: time_put<_CharT, _OutputIterator>(__nm, __refs) {} : time_put<_CharT, _OutputIterator>(__nm, __refs) {}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
explicit time_put_byname(const string& __nm, size_t __refs = 0) explicit time_put_byname(const string& __nm, size_t __refs = 0)
Show All 17 Linespublic:
struct pattern {char field[4];}; struct pattern {char field[4];};
_LIBCPP_INLINE_VISIBILITY money_base() {} _LIBCPP_INLINE_VISIBILITY money_base() {}
}; };
// moneypunct // moneypunct
template <class _CharT, bool _International = false> template <class _CharT, bool _International = false>
class _LIBCPP_TEMPLATE_VIS moneypunct class moneypunct : public locale::facet, public money_base
: public locale::facet,
public money_base
{ {
public: public:
typedef _CharT char_type; typedef _CharT char_type;
typedef basic_string<char_type> string_type; typedef basic_string<char_type> string_type;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
explicit moneypunct(size_t __refs = 0) explicit moneypunct(size_t __refs = 0)
: locale::facet(__refs) {} : locale::facet(__refs) {}
Show All 40 Lines
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS moneypunct<wchar_t, false>; extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS moneypunct<wchar_t, false>;
extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS moneypunct<wchar_t, true>; extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS moneypunct<wchar_t, true>;
#endif #endif
// moneypunct_byname // moneypunct_byname
template <class _CharT, bool _International = false> template <class _CharT, bool _International = false>
class _LIBCPP_TEMPLATE_VIS moneypunct_byname class moneypunct_byname : public moneypunct<_CharT, _International>
: public moneypunct<_CharT, _International>
{ {
public: public:
typedef money_base::pattern pattern; typedef money_base::pattern pattern;
typedef _CharT char_type; typedef _CharT char_type;
typedef basic_string<char_type> string_type; typedef basic_string<char_type> string_type;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
explicit moneypunct_byname(const char* __nm, size_t __refs = 0) explicit moneypunct_byname(const char* __nm, size_t __refs = 0)
▲ Show 20 Lines • Show All 97 Lines • ▼ Show 20 Lines
} }
extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS __money_get<char>; extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS __money_get<char>;
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS __money_get<wchar_t>; extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS __money_get<wchar_t>;
#endif #endif
template <class _CharT, class _InputIterator = istreambuf_iterator<_CharT> > template <class _CharT, class _InputIterator = istreambuf_iterator<_CharT> >
class _LIBCPP_TEMPLATE_VIS money_get class money_get : public locale::facet, private __money_get<_CharT>
: public locale::facet,
private __money_get<_CharT>
{ {
public: public:
typedef _CharT char_type; typedef _CharT char_type;
typedef _InputIterator iter_type; typedef _InputIterator iter_type;
typedef basic_string<char_type> string_type; typedef basic_string<char_type> string_type;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
explicit money_get(size_t __refs = 0) explicit money_get(size_t __refs = 0)
▲ Show 20 Lines • Show All 525 Lines • ▼ Show 20 Lines
} }
extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS __money_put<char>; extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS __money_put<char>;
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS __money_put<wchar_t>; extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS __money_put<wchar_t>;
#endif #endif
template <class _CharT, class _OutputIterator = ostreambuf_iterator<_CharT> > template <class _CharT, class _OutputIterator = ostreambuf_iterator<_CharT> >
class _LIBCPP_TEMPLATE_VIS money_put class money_put : public locale::facet, private __money_put<_CharT>
: public locale::facet,
private __money_put<_CharT>
{ {
public: public:
typedef _CharT char_type; typedef _CharT char_type;
typedef _OutputIterator iter_type; typedef _OutputIterator iter_type;
typedef basic_string<char_type> string_type; typedef basic_string<char_type> string_type;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
explicit money_put(size_t __refs = 0) explicit money_put(size_t __refs = 0)
▲ Show 20 Lines • Show All 145 Lines • ▼ Show 20 Lines
{ {
public: public:
typedef ptrdiff_t catalog; typedef ptrdiff_t catalog;
_LIBCPP_INLINE_VISIBILITY messages_base() {} _LIBCPP_INLINE_VISIBILITY messages_base() {}
}; };
template <class _CharT> template <class _CharT>
class _LIBCPP_TEMPLATE_VIS messages class messages : public locale::facet, public messages_base
: public locale::facet,
public messages_base
{ {
public: public:
typedef _CharT char_type; typedef _CharT char_type;
typedef basic_string<_CharT> string_type; typedef basic_string<_CharT> string_type;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
explicit messages(size_t __refs = 0) explicit messages(size_t __refs = 0)
: locale::facet(__refs) {} : locale::facet(__refs) {}
▲ Show 20 Lines • Show All 88 Lines • ▼ Show 20 Lines
} }
extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS messages<char>; extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS messages<char>;
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS messages<wchar_t>; extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS messages<wchar_t>;
#endif #endif
template <class _CharT> template <class _CharT>
class _LIBCPP_TEMPLATE_VIS messages_byname class messages_byname : public messages<_CharT>
: public messages<_CharT>
{ {
public: public:
typedef messages_base::catalog catalog; typedef messages_base::catalog catalog;
typedef basic_string<_CharT> string_type; typedef basic_string<_CharT> string_type;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
explicit messages_byname(const char*, size_t __refs = 0) explicit messages_byname(const char*, size_t __refs = 0)
: messages<_CharT>(__refs) {} : messages<_CharT>(__refs) {}
Show All 9 Lines
extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS messages_byname<char>; extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS messages_byname<char>;
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS messages_byname<wchar_t>; extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS messages_byname<wchar_t>;
#endif #endif
template<class _Codecvt, class _Elem = wchar_t, template<class _Codecvt, class _Elem = wchar_t,
class _Wide_alloc = allocator<_Elem>, class _Wide_alloc = allocator<_Elem>,
class _Byte_alloc = allocator<char> > class _Byte_alloc = allocator<char> >
class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX17 wstring_convert class _LIBCPP_DEPRECATED_IN_CXX17 wstring_convert
{ {
public: public:
typedef basic_string<char, char_traits<char>, _Byte_alloc> byte_string; typedef basic_string<char, char_traits<char>, _Byte_alloc> byte_string;
typedef basic_string<_Elem, char_traits<_Elem>, _Wide_alloc> wide_string; typedef basic_string<_Elem, char_traits<_Elem>, _Wide_alloc> wide_string;
typedef typename _Codecvt::state_type state_type; typedef typename _Codecvt::state_type state_type;
typedef typename wide_string::traits_type::int_type int_type; typedef typename wide_string::traits_type::int_type int_type;
private: private:
▲ Show 20 Lines • Show All 252 Lines • ▼ Show 20 Lineswstring_convert<_Codecvt, _Elem, _Wide_alloc, _Byte_alloc>::
if (__byte_err_string_.empty()) if (__byte_err_string_.empty())
__throw_range_error("wstring_convert: to_bytes error"); __throw_range_error("wstring_convert: to_bytes error");
return __byte_err_string_; return __byte_err_string_;
} }
template <class _Codecvt, class _Elem = wchar_t, class _Tr = char_traits<_Elem> > template <class _Codecvt, class _Elem = wchar_t, class _Tr = char_traits<_Elem> >
class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX17 wbuffer_convert class _LIBCPP_DEPRECATED_IN_CXX17 wbuffer_convert : public basic_streambuf<_Elem, _Tr>
: public basic_streambuf<_Elem, _Tr>
{ {
public: public:
// types: // types:
typedef _Elem char_type; typedef _Elem char_type;
typedef _Tr traits_type; typedef _Tr traits_type;
typedef typename traits_type::int_type int_type; typedef typename traits_type::int_type int_type;
typedef typename traits_type::pos_type pos_type; typedef typename traits_type::pos_type pos_type;
typedef typename traits_type::off_type off_type; typedef typename traits_type::off_type off_type;
▲ Show 20 Lines • Show All 487 Lines • Show Last 20 Lines

libcxx/include/map

Show First 20 Lines • Show All 849 Lines • ▼ Show 20 Lines
template <class _Key, class _Tp> template <class _Key, class _Tp>
struct __extract_key_value_types<__value_type<_Key, _Tp> > struct __extract_key_value_types<__value_type<_Key, _Tp> >
{ {
typedef _Key const __key_type; typedef _Key const __key_type;
typedef _Tp __mapped_type; typedef _Tp __mapped_type;
}; };
template <class _TreeIterator> template <class _TreeIterator>
class _LIBCPP_TEMPLATE_VIS __map_iterator class __map_iterator
{ {
typedef typename _TreeIterator::_NodeTypes _NodeTypes; typedef typename _TreeIterator::_NodeTypes _NodeTypes;
typedef typename _TreeIterator::__pointer_traits __pointer_traits; typedef typename _TreeIterator::__pointer_traits __pointer_traits;
_TreeIterator __i_; _TreeIterator __i_;
public: public:
typedef bidirectional_iterator_tag iterator_category; typedef bidirectional_iterator_tag iterator_category;
Show All 36 Linespublic:
friend _LIBCPP_INLINE_VISIBILITY friend _LIBCPP_INLINE_VISIBILITY
bool operator==(const __map_iterator& __x, const __map_iterator& __y) bool operator==(const __map_iterator& __x, const __map_iterator& __y)
{return __x.__i_ == __y.__i_;} {return __x.__i_ == __y.__i_;}
friend friend
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
bool operator!=(const __map_iterator& __x, const __map_iterator& __y) bool operator!=(const __map_iterator& __x, const __map_iterator& __y)
{return __x.__i_ != __y.__i_;} {return __x.__i_ != __y.__i_;}
template <class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS map; template <class, class, class, class> friend class map;
template <class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS multimap; template <class, class, class, class> friend class multimap;
template <class> friend class _LIBCPP_TEMPLATE_VIS __map_const_iterator; template <class> friend class __map_const_iterator;
}; };
template <class _TreeIterator> template <class _TreeIterator>
class _LIBCPP_TEMPLATE_VIS __map_const_iterator class __map_const_iterator
{ {
typedef typename _TreeIterator::_NodeTypes _NodeTypes; typedef typename _TreeIterator::_NodeTypes _NodeTypes;
typedef typename _TreeIterator::__pointer_traits __pointer_traits; typedef typename _TreeIterator::__pointer_traits __pointer_traits;
_TreeIterator __i_; _TreeIterator __i_;
public: public:
typedef bidirectional_iterator_tag iterator_category; typedef bidirectional_iterator_tag iterator_category;
Show All 39 Linespublic:
friend _LIBCPP_INLINE_VISIBILITY friend _LIBCPP_INLINE_VISIBILITY
bool operator==(const __map_const_iterator& __x, const __map_const_iterator& __y) bool operator==(const __map_const_iterator& __x, const __map_const_iterator& __y)
{return __x.__i_ == __y.__i_;} {return __x.__i_ == __y.__i_;}
friend _LIBCPP_INLINE_VISIBILITY friend _LIBCPP_INLINE_VISIBILITY
bool operator!=(const __map_const_iterator& __x, const __map_const_iterator& __y) bool operator!=(const __map_const_iterator& __x, const __map_const_iterator& __y)
{return __x.__i_ != __y.__i_;} {return __x.__i_ != __y.__i_;}
template <class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS map; template <class, class, class, class> friend class map;
template <class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS multimap; template <class, class, class, class> friend class multimap;
template <class, class, class> friend class _LIBCPP_TEMPLATE_VIS __tree_const_iterator; template <class, class, class> friend class __tree_const_iterator;
}; };
template <class _Key, class _Tp, class _Compare = less<_Key>, template <class _Key, class _Tp, class _Compare = less<_Key>,
class _Allocator = allocator<pair<const _Key, _Tp> > > class _Allocator = allocator<pair<const _Key, _Tp> > >
class _LIBCPP_TEMPLATE_VIS map class map
{ {
public: public:
// types: // types:
typedef _Key key_type; typedef _Key key_type;
typedef _Tp mapped_type; typedef _Tp mapped_type;
typedef pair<const key_type, mapped_type> value_type; typedef pair<const key_type, mapped_type> value_type;
typedef __type_identity_t<_Compare> key_compare; typedef __type_identity_t<_Compare> key_compare;
typedef __type_identity_t<_Allocator> allocator_type; typedef __type_identity_t<_Allocator> allocator_type;
typedef value_type& reference; typedef value_type& reference;
typedef const value_type& const_reference; typedef const value_type& const_reference;
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");
class _LIBCPP_TEMPLATE_VIS value_compare class value_compare : public __binary_function<value_type, value_type, bool>
: public __binary_function<value_type, value_type, bool>
{ {
friend class map; friend class map;
protected: protected:
key_compare comp; key_compare comp;
_LIBCPP_INLINE_VISIBILITY value_compare(key_compare __c) : comp(__c) {} _LIBCPP_INLINE_VISIBILITY value_compare(key_compare __c) : comp(__c) {}
public: public:
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
Show All 27 Linespublic:
typedef _VSTD::reverse_iterator<const_iterator> const_reverse_iterator; typedef _VSTD::reverse_iterator<const_iterator> const_reverse_iterator;
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
typedef __map_node_handle<typename __base::__node, allocator_type> node_type; typedef __map_node_handle<typename __base::__node, allocator_type> node_type;
typedef __insert_return_type<iterator, node_type> insert_return_type; typedef __insert_return_type<iterator, node_type> insert_return_type;
#endif #endif
template <class _Key2, class _Value2, class _Comp2, class _Alloc2> template <class _Key2, class _Value2, class _Comp2, class _Alloc2>
friend class _LIBCPP_TEMPLATE_VIS map; friend class map;
template <class _Key2, class _Value2, class _Comp2, class _Alloc2> template <class _Key2, class _Value2, class _Comp2, class _Alloc2>
friend class _LIBCPP_TEMPLATE_VIS multimap; friend class multimap;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
map() map()
_NOEXCEPT_( _NOEXCEPT_(
is_nothrow_default_constructible<allocator_type>::value && is_nothrow_default_constructible<allocator_type>::value &&
is_nothrow_default_constructible<key_compare>::value && is_nothrow_default_constructible<key_compare>::value &&
is_nothrow_copy_constructible<key_compare>::value) is_nothrow_copy_constructible<key_compare>::value)
: __tree_(__vc(key_compare())) {} : __tree_(__vc(key_compare())) {}
▲ Show 20 Lines • Show All 717 Lines • ▼ Show 20 Linesinline _LIBCPP_INLINE_VISIBILITY
erase_if(map<_Key, _Tp, _Compare, _Allocator>& __c, _Predicate __pred) { erase_if(map<_Key, _Tp, _Compare, _Allocator>& __c, _Predicate __pred) {
return _VSTD::__libcpp_erase_if_container(__c, __pred); return _VSTD::__libcpp_erase_if_container(__c, __pred);
} }
#endif #endif
template <class _Key, class _Tp, class _Compare = less<_Key>, template <class _Key, class _Tp, class _Compare = less<_Key>,
class _Allocator = allocator<pair<const _Key, _Tp> > > class _Allocator = allocator<pair<const _Key, _Tp> > >
class _LIBCPP_TEMPLATE_VIS multimap class multimap
{ {
public: public:
// types: // types:
typedef _Key key_type; typedef _Key key_type;
typedef _Tp mapped_type; typedef _Tp mapped_type;
typedef pair<const key_type, mapped_type> value_type; typedef pair<const key_type, mapped_type> value_type;
typedef __type_identity_t<_Compare> key_compare; typedef __type_identity_t<_Compare> key_compare;
typedef __type_identity_t<_Allocator> allocator_type; typedef __type_identity_t<_Allocator> allocator_type;
typedef value_type& reference; typedef value_type& reference;
typedef const value_type& const_reference; typedef const value_type& const_reference;
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");
class _LIBCPP_TEMPLATE_VIS value_compare class value_compare
: public __binary_function<value_type, value_type, bool> : public __binary_function<value_type, value_type, bool>
{ {
friend class multimap; friend class multimap;
protected: protected:
key_compare comp; key_compare comp;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
value_compare(key_compare __c) : comp(__c) {} value_compare(key_compare __c) : comp(__c) {}
Show All 28 Linespublic:
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;
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
typedef __map_node_handle<typename __base::__node, allocator_type> node_type; typedef __map_node_handle<typename __base::__node, allocator_type> node_type;
#endif #endif
template <class _Key2, class _Value2, class _Comp2, class _Alloc2> template <class _Key2, class _Value2, class _Comp2, class _Alloc2>
friend class _LIBCPP_TEMPLATE_VIS map; friend class map;
template <class _Key2, class _Value2, class _Comp2, class _Alloc2> template <class _Key2, class _Value2, class _Comp2, class _Alloc2>
friend class _LIBCPP_TEMPLATE_VIS multimap; friend class multimap;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
multimap() multimap()
_NOEXCEPT_( _NOEXCEPT_(
is_nothrow_default_constructible<allocator_type>::value && is_nothrow_default_constructible<allocator_type>::value &&
is_nothrow_default_constructible<key_compare>::value && is_nothrow_default_constructible<key_compare>::value &&
is_nothrow_copy_constructible<key_compare>::value) is_nothrow_copy_constructible<key_compare>::value)
: __tree_(__vc(key_compare())) {} : __tree_(__vc(key_compare())) {}
▲ Show 20 Lines • Show All 563 Lines • Show Last 20 Lines

libcxx/include/mutex

Show First 20 Lines • Show All 469 Lines • ▼ Show 20 Linesvoid __unlock(_L0& __l0, _L1& __l1, _L2& __l2, _L3&... __l3) {
__l1.unlock(); __l1.unlock();
_VSTD::__unlock(__l2, __l3...); _VSTD::__unlock(__l2, __l3...);
} }
#endif // _LIBCPP_CXX03_LANG #endif // _LIBCPP_CXX03_LANG
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <class ..._Mutexes> template <class ..._Mutexes>
class _LIBCPP_TEMPLATE_VIS scoped_lock; class scoped_lock;
template <> template <>
class _LIBCPP_TEMPLATE_VIS scoped_lock<> { class scoped_lock<> {
public: public:
explicit scoped_lock() {} explicit scoped_lock() {}
~scoped_lock() = default; ~scoped_lock() = default;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
explicit scoped_lock(adopt_lock_t) {} explicit scoped_lock(adopt_lock_t) {}
scoped_lock(scoped_lock const&) = delete; scoped_lock(scoped_lock const&) = delete;
scoped_lock& operator=(scoped_lock const&) = delete; scoped_lock& operator=(scoped_lock const&) = delete;
}; };
template <class _Mutex> template <class _Mutex>
class _LIBCPP_TEMPLATE_VIS _LIBCPP_THREAD_SAFETY_ANNOTATION(scoped_lockable) scoped_lock<_Mutex> { class _LIBCPP_THREAD_SAFETY_ANNOTATION(scoped_lockable) scoped_lock<_Mutex> {
public: public:
typedef _Mutex mutex_type; typedef _Mutex mutex_type;
private: private:
mutex_type& __m_; mutex_type& __m_;
public: public:
explicit scoped_lock(mutex_type & __m) _LIBCPP_THREAD_SAFETY_ANNOTATION(acquire_capability(__m)) explicit scoped_lock(mutex_type & __m) _LIBCPP_THREAD_SAFETY_ANNOTATION(acquire_capability(__m))
: __m_(__m) {__m_.lock();} : __m_(__m) {__m_.lock();}
~scoped_lock() _LIBCPP_THREAD_SAFETY_ANNOTATION(release_capability()) {__m_.unlock();} ~scoped_lock() _LIBCPP_THREAD_SAFETY_ANNOTATION(release_capability()) {__m_.unlock();}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
explicit scoped_lock(adopt_lock_t, mutex_type& __m) _LIBCPP_THREAD_SAFETY_ANNOTATION(requires_capability(__m)) explicit scoped_lock(adopt_lock_t, mutex_type& __m) _LIBCPP_THREAD_SAFETY_ANNOTATION(requires_capability(__m))
: __m_(__m) {} : __m_(__m) {}
scoped_lock(scoped_lock const&) = delete; scoped_lock(scoped_lock const&) = delete;
scoped_lock& operator=(scoped_lock const&) = delete; scoped_lock& operator=(scoped_lock const&) = delete;
}; };
template <class ..._MArgs> template <class ..._MArgs>
class _LIBCPP_TEMPLATE_VIS scoped_lock class scoped_lock
{ {
static_assert(sizeof...(_MArgs) > 1, "At least 2 lock types required"); static_assert(sizeof...(_MArgs) > 1, "At least 2 lock types required");
typedef tuple<_MArgs&...> _MutexTuple; typedef tuple<_MArgs&...> _MutexTuple;
public: public:
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
explicit scoped_lock(_MArgs&... __margs) explicit scoped_lock(_MArgs&... __margs)
: __t_(__margs...) : __t_(__margs...)
Show All 25 Linesprivate:
_MutexTuple __t_; _MutexTuple __t_;
}; };
_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(scoped_lock); _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(scoped_lock);
#endif // _LIBCPP_STD_VER >= 17 #endif // _LIBCPP_STD_VER >= 17
#endif // !_LIBCPP_HAS_NO_THREADS #endif // !_LIBCPP_HAS_NO_THREADS
struct _LIBCPP_TEMPLATE_VIS once_flag; struct once_flag;
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
template<class _Callable, class... _Args> template<class _Callable, class... _Args>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
void call_once(once_flag&, _Callable&&, _Args&&...); void call_once(once_flag&, _Callable&&, _Args&&...);
#else // _LIBCPP_CXX03_LANG #else // _LIBCPP_CXX03_LANG
template<class _Callable> template<class _Callable>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
void call_once(once_flag&, _Callable&); void call_once(once_flag&, _Callable&);
template<class _Callable> template<class _Callable>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
void call_once(once_flag&, const _Callable&); void call_once(once_flag&, const _Callable&);
#endif // _LIBCPP_CXX03_LANG #endif // _LIBCPP_CXX03_LANG
struct _LIBCPP_TEMPLATE_VIS once_flag struct once_flag
{ {
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR _LIBCPP_CONSTEXPR
once_flag() _NOEXCEPT : __state_(0) {} once_flag() _NOEXCEPT : __state_(0) {}
once_flag(const once_flag&) = delete; once_flag(const once_flag&) = delete;
once_flag& operator=(const once_flag&) = delete; once_flag& operator=(const once_flag&) = delete;
#if defined(_LIBCPP_ABI_MICROSOFT) #if defined(_LIBCPP_ABI_MICROSOFT)
▲ Show 20 Lines • Show All 142 Lines • Show Last 20 Lines

libcxx/include/new

Show First 20 Lines • Show All 179 Lines • ▼ Show 20 Lines
#else #else
_LIBCPP_VERBOSE_ABORT("bad_array_new_length was thrown in -fno-exceptions mode"); _LIBCPP_VERBOSE_ABORT("bad_array_new_length was thrown in -fno-exceptions mode");
#endif #endif
} }
#if !defined(_LIBCPP_HAS_NO_LIBRARY_ALIGNED_ALLOCATION) && \ #if !defined(_LIBCPP_HAS_NO_LIBRARY_ALIGNED_ALLOCATION) && \
!defined(_LIBCPP_ABI_VCRUNTIME) !defined(_LIBCPP_ABI_VCRUNTIME)
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
enum class _LIBCPP_ENUM_VIS align_val_t : size_t { }; enum class align_val_t : size_t { };
#else #else
enum align_val_t { __zero = 0, __max = (size_t)-1 }; enum align_val_t { __zero = 0, __max = (size_t)-1 };
#endif #endif
#endif #endif
#if _LIBCPP_STD_VER >= 20 #if _LIBCPP_STD_VER >= 20
// Enable the declaration even if the compiler doesn't support the language // Enable the declaration even if the compiler doesn't support the language
// feature. // feature.
▲ Show 20 Lines • Show All 177 Lines • Show Last 20 Lines

libcxx/include/optional

Show First 20 Lines • Show All 1,643 Lines • ▼ Show 20 Lines
template <class _Tp, class _Up, class... _Args> template <class _Tp, class _Up, class... _Args>
_LIBCPP_INLINE_VISIBILITY constexpr _LIBCPP_INLINE_VISIBILITY constexpr
optional<_Tp> make_optional(initializer_list<_Up> __il, _Args&&... __args) optional<_Tp> make_optional(initializer_list<_Up> __il, _Args&&... __args)
{ {
return optional<_Tp>(in_place, __il, _VSTD::forward<_Args>(__args)...); return optional<_Tp>(in_place, __il, _VSTD::forward<_Args>(__args)...);
} }
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS hash< struct hash<__enable_hash_helper<optional<_Tp>, remove_const_t<_Tp>>>
__enable_hash_helper<optional<_Tp>, remove_const_t<_Tp>>
>
{ {
#if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS) #if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS)
_LIBCPP_DEPRECATED_IN_CXX17 typedef optional<_Tp> argument_type; _LIBCPP_DEPRECATED_IN_CXX17 typedef optional<_Tp> argument_type;
_LIBCPP_DEPRECATED_IN_CXX17 typedef size_t result_type; _LIBCPP_DEPRECATED_IN_CXX17 typedef size_t result_type;
#endif #endif
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
size_t operator()(const optional<_Tp>& __opt) const size_t operator()(const optional<_Tp>& __opt) const
Show All 25 Lines

libcxx/include/ostream

Show First 20 Lines • Show All 183 Lines • ▼ Show 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 _CharT, class _Traits> template <class _CharT, class _Traits>
class _LIBCPP_TEMPLATE_VIS basic_ostream class basic_ostream : virtual public basic_ios<_CharT, _Traits>
: virtual public basic_ios<_CharT, _Traits>
{ {
public: public:
// types (inherited from basic_ios (27.5.4)): // types (inherited from basic_ios (27.5.4)):
typedef _CharT char_type; typedef _CharT char_type;
typedef _Traits traits_type; typedef _Traits traits_type;
typedef typename traits_type::int_type int_type; typedef typename traits_type::int_type int_type;
typedef typename traits_type::pos_type pos_type; typedef typename traits_type::pos_type pos_type;
typedef typename traits_type::off_type off_type; typedef typename traits_type::off_type off_type;
Show All 15 Linesprotected:
void swap(basic_ostream& __rhs) void swap(basic_ostream& __rhs)
{ basic_ios<char_type, traits_type>::swap(__rhs); } { basic_ios<char_type, traits_type>::swap(__rhs); }
basic_ostream (const basic_ostream& __rhs) = delete; basic_ostream (const basic_ostream& __rhs) = delete;
basic_ostream& operator=(const basic_ostream& __rhs) = delete; basic_ostream& operator=(const basic_ostream& __rhs) = delete;
public: public:
// 27.7.2.4 Prefix/suffix: // 27.7.2.4 Prefix/suffix:
class _LIBCPP_TEMPLATE_VIS sentry; class sentry;
// 27.7.2.6 Formatted output: // 27.7.2.6 Formatted output:
inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
basic_ostream& operator<<(basic_ostream& (*__pf)(basic_ostream&)) basic_ostream& operator<<(basic_ostream& (*__pf)(basic_ostream&))
{ return __pf(*this); } { return __pf(*this); }
inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
basic_ostream& operator<<(basic_ios<char_type, traits_type>& basic_ostream& operator<<(basic_ios<char_type, traits_type>&
▲ Show 20 Lines • Show All 49 Lines • ▼ Show 20 Lines#endif
basic_ostream& seekp(off_type __off, ios_base::seekdir __dir); basic_ostream& seekp(off_type __off, ios_base::seekdir __dir);
protected: protected:
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
basic_ostream() {} // extension, intentially does not initialize basic_ostream() {} // extension, intentially does not initialize
}; };
template <class _CharT, class _Traits> template <class _CharT, class _Traits>
class _LIBCPP_TEMPLATE_VIS basic_ostream<_CharT, _Traits>::sentry class basic_ostream<_CharT, _Traits>::sentry
{ {
bool __ok_; bool __ok_;
basic_ostream<_CharT, _Traits>& __os_; basic_ostream<_CharT, _Traits>& __os_;
public: public:
explicit sentry(basic_ostream<_CharT, _Traits>& __os); explicit sentry(basic_ostream<_CharT, _Traits>& __os);
~sentry(); ~sentry();
sentry(const sentry&) = delete; sentry(const sentry&) = delete;
▲ Show 20 Lines • Show All 908 Lines • Show Last 20 Lines

libcxx/include/queue

Show First 20 Lines • Show All 279 Lines • ▼ Show 20 Lines
#include <initializer_list> #include <initializer_list>
#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 _Container = deque<_Tp> > class _LIBCPP_TEMPLATE_VIS queue; template <class _Tp, class _Container = deque<_Tp> > class queue;
template <class _Tp, class _Container> template <class _Tp, class _Container>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
bool bool
operator==(const queue<_Tp, _Container>& __x,const queue<_Tp, _Container>& __y); operator==(const queue<_Tp, _Container>& __x,const queue<_Tp, _Container>& __y);
template <class _Tp, class _Container> template <class _Tp, class _Container>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
bool bool
operator< (const queue<_Tp, _Container>& __x,const queue<_Tp, _Container>& __y); operator< (const queue<_Tp, _Container>& __x,const queue<_Tp, _Container>& __y);
template <class _Tp, class _Container /*= deque<_Tp>*/> template <class _Tp, class _Container /*= deque<_Tp>*/>
class _LIBCPP_TEMPLATE_VIS queue class queue
{ {
public: public:
typedef _Container container_type; typedef _Container container_type;
typedef typename container_type::value_type value_type; typedef typename container_type::value_type value_type;
typedef typename container_type::reference reference; typedef typename container_type::reference reference;
typedef typename container_type::const_reference const_reference; typedef typename container_type::const_reference const_reference;
typedef typename container_type::size_type size_type; typedef typename container_type::size_type size_type;
static_assert((is_same<_Tp, value_type>::value), "" ); static_assert((is_same<_Tp, value_type>::value), "" );
▲ Show 20 Lines • Show All 260 Lines • ▼ Show 20 Lines
__enable_if_t<__is_swappable<_Container>::value, void> __enable_if_t<__is_swappable<_Container>::value, void>
swap(queue<_Tp, _Container>& __x, queue<_Tp, _Container>& __y) swap(queue<_Tp, _Container>& __x, queue<_Tp, _Container>& __y)
_NOEXCEPT_(_NOEXCEPT_(__x.swap(__y))) _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
{ {
__x.swap(__y); __x.swap(__y);
} }
template <class _Tp, class _Container, class _Alloc> template <class _Tp, class _Container, class _Alloc>
struct _LIBCPP_TEMPLATE_VIS uses_allocator<queue<_Tp, _Container>, _Alloc> struct uses_allocator<queue<_Tp, _Container>, _Alloc> : public uses_allocator<_Container, _Alloc> {};
: public uses_allocator<_Container, _Alloc>
{
};
template <class _Tp, class _Container = vector<_Tp>, template <class _Tp, class _Container = vector<_Tp>,
class _Compare = less<typename _Container::value_type> > class _Compare = less<typename _Container::value_type> >
class _LIBCPP_TEMPLATE_VIS priority_queue class priority_queue
{ {
public: public:
typedef _Container container_type; typedef _Container container_type;
typedef _Compare value_compare; typedef _Compare value_compare;
typedef typename container_type::value_type value_type; typedef typename container_type::value_type value_type;
typedef typename container_type::reference reference; typedef typename container_type::reference reference;
typedef typename container_type::const_reference const_reference; typedef typename container_type::const_reference const_reference;
typedef typename container_type::size_type size_type; typedef typename container_type::size_type size_type;
▲ Show 20 Lines • Show All 523 Lines • ▼ Show 20 Lines
swap(priority_queue<_Tp, _Container, _Compare>& __x, swap(priority_queue<_Tp, _Container, _Compare>& __x,
priority_queue<_Tp, _Container, _Compare>& __y) priority_queue<_Tp, _Container, _Compare>& __y)
_NOEXCEPT_(_NOEXCEPT_(__x.swap(__y))) _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
{ {
__x.swap(__y); __x.swap(__y);
} }
template <class _Tp, class _Container, class _Compare, class _Alloc> template <class _Tp, class _Container, class _Compare, class _Alloc>
struct _LIBCPP_TEMPLATE_VIS uses_allocator<priority_queue<_Tp, _Container, _Compare>, _Alloc> struct uses_allocator<priority_queue<_Tp, _Container, _Compare>, _Alloc> : public uses_allocator<_Container, _Alloc> {};
: public uses_allocator<_Container, _Alloc>
{
};
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
# include <concepts> # include <concepts>
# include <cstdlib> # include <cstdlib>
# include <functional> # include <functional>
# include <type_traits> # include <type_traits>
#endif #endif
#endif // _LIBCPP_QUEUE #endif // _LIBCPP_QUEUE

libcxx/include/ratio

Show First 20 Lines • Show All 241 Lines • ▼ Show 20 Linesclass __ll_div
static const intmax_t max = -min; static const intmax_t max = -min;
static_assert(_Xp != nan && _Yp != nan && _Yp != 0, "overflow in __ll_div"); static_assert(_Xp != nan && _Yp != nan && _Yp != 0, "overflow in __ll_div");
public: public:
static const intmax_t value = _Xp / _Yp; static const intmax_t value = _Xp / _Yp;
}; };
template <intmax_t _Num, intmax_t _Den = 1> template <intmax_t _Num, intmax_t _Den = 1>
class _LIBCPP_TEMPLATE_VIS ratio class ratio
{ {
static_assert(__static_abs<_Num>::value >= 0, "ratio numerator is out of range"); static_assert(__static_abs<_Num>::value >= 0, "ratio numerator is out of range");
static_assert(_Den != 0, "ratio divide by 0"); static_assert(_Den != 0, "ratio divide by 0");
static_assert(__static_abs<_Den>::value > 0, "ratio denominator is out of range"); static_assert(__static_abs<_Den>::value > 0, "ratio denominator is out of range");
static _LIBCPP_CONSTEXPR const intmax_t __na = __static_abs<_Num>::value; static _LIBCPP_CONSTEXPR const intmax_t __na = __static_abs<_Num>::value;
static _LIBCPP_CONSTEXPR const intmax_t __da = __static_abs<_Den>::value; static _LIBCPP_CONSTEXPR const intmax_t __da = __static_abs<_Den>::value;
static _LIBCPP_CONSTEXPR const intmax_t __s = __static_sign<_Num>::value * __static_sign<_Den>::value; static _LIBCPP_CONSTEXPR const intmax_t __s = __static_sign<_Num>::value * __static_sign<_Den>::value;
static _LIBCPP_CONSTEXPR const intmax_t __gcd = __static_gcd<__na, __da>::value; static _LIBCPP_CONSTEXPR const intmax_t __gcd = __static_gcd<__na, __da>::value;
▲ Show 20 Lines • Show All 47 Lines • ▼ Show 20 Lines
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
template <class _R1, class _R2> using ratio_multiply template <class _R1, class _R2> using ratio_multiply
= typename __ratio_multiply<_R1, _R2>::type; = typename __ratio_multiply<_R1, _R2>::type;
#else // _LIBCPP_CXX03_LANG #else // _LIBCPP_CXX03_LANG
template <class _R1, class _R2> template <class _R1, class _R2>
struct _LIBCPP_TEMPLATE_VIS ratio_multiply struct ratio_multiply : public __ratio_multiply<_R1, _R2>::type {};
: public __ratio_multiply<_R1, _R2>::type {};
#endif // _LIBCPP_CXX03_LANG #endif // _LIBCPP_CXX03_LANG
template <class _R1, class _R2> template <class _R1, class _R2>
struct __ratio_divide struct __ratio_divide
{ {
private: private:
static const intmax_t __gcd_n1_n2 = __static_gcd<_R1::num, _R2::num>::value; static const intmax_t __gcd_n1_n2 = __static_gcd<_R1::num, _R2::num>::value;
Show All 9 Lines
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
template <class _R1, class _R2> using ratio_divide template <class _R1, class _R2> using ratio_divide
= typename __ratio_divide<_R1, _R2>::type; = typename __ratio_divide<_R1, _R2>::type;
#else // _LIBCPP_CXX03_LANG #else // _LIBCPP_CXX03_LANG
template <class _R1, class _R2> template <class _R1, class _R2>
struct _LIBCPP_TEMPLATE_VIS ratio_divide struct ratio_divide : public __ratio_divide<_R1, _R2>::type {};
: public __ratio_divide<_R1, _R2>::type {};
#endif // _LIBCPP_CXX03_LANG #endif // _LIBCPP_CXX03_LANG
template <class _R1, class _R2> template <class _R1, class _R2>
struct __ratio_add struct __ratio_add
{ {
private: private:
static const intmax_t __gcd_n1_n2 = __static_gcd<_R1::num, _R2::num>::value; static const intmax_t __gcd_n1_n2 = __static_gcd<_R1::num, _R2::num>::value;
Show All 17 Lines
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
template <class _R1, class _R2> using ratio_add template <class _R1, class _R2> using ratio_add
= typename __ratio_add<_R1, _R2>::type; = typename __ratio_add<_R1, _R2>::type;
#else // _LIBCPP_CXX03_LANG #else // _LIBCPP_CXX03_LANG
template <class _R1, class _R2> template <class _R1, class _R2>
struct _LIBCPP_TEMPLATE_VIS ratio_add struct ratio_add : public __ratio_add<_R1, _R2>::type {};
: public __ratio_add<_R1, _R2>::type {};
#endif // _LIBCPP_CXX03_LANG #endif // _LIBCPP_CXX03_LANG
template <class _R1, class _R2> template <class _R1, class _R2>
struct __ratio_subtract struct __ratio_subtract
{ {
private: private:
static const intmax_t __gcd_n1_n2 = __static_gcd<_R1::num, _R2::num>::value; static const intmax_t __gcd_n1_n2 = __static_gcd<_R1::num, _R2::num>::value;
Show All 17 Lines
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
template <class _R1, class _R2> using ratio_subtract template <class _R1, class _R2> using ratio_subtract
= typename __ratio_subtract<_R1, _R2>::type; = typename __ratio_subtract<_R1, _R2>::type;
#else // _LIBCPP_CXX03_LANG #else // _LIBCPP_CXX03_LANG
template <class _R1, class _R2> template <class _R1, class _R2>
struct _LIBCPP_TEMPLATE_VIS ratio_subtract struct ratio_subtract : public __ratio_subtract<_R1, _R2>::type {};
: public __ratio_subtract<_R1, _R2>::type {};
#endif // _LIBCPP_CXX03_LANG #endif // _LIBCPP_CXX03_LANG
// ratio_equal // ratio_equal
template <class _R1, class _R2> template <class _R1, class _R2>
struct _LIBCPP_TEMPLATE_VIS ratio_equal struct ratio_equal : _BoolConstant<(_R1::num == _R2::num && _R1::den == _R2::den)> {};
: _BoolConstant<(_R1::num == _R2::num && _R1::den == _R2::den)> {};
template <class _R1, class _R2> template <class _R1, class _R2>
struct _LIBCPP_TEMPLATE_VIS ratio_not_equal struct ratio_not_equal : _BoolConstant<!ratio_equal<_R1, _R2>::value> {};
: _BoolConstant<!ratio_equal<_R1, _R2>::value> {};
// ratio_less // ratio_less
template <class _R1, class _R2, bool _Odd = false, template <class _R1, class _R2, bool _Odd = false,
intmax_t _Q1 = _R1::num / _R1::den, intmax_t _M1 = _R1::num % _R1::den, intmax_t _Q1 = _R1::num / _R1::den, intmax_t _M1 = _R1::num % _R1::den,
intmax_t _Q2 = _R2::num / _R2::den, intmax_t _M2 = _R2::num % _R2::den> intmax_t _Q2 = _R2::num / _R2::den, intmax_t _M2 = _R2::num % _R2::den>
struct __ratio_less1 struct __ratio_less1
{ {
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Lines
template <class _R1, class _R2> template <class _R1, class _R2>
struct __ratio_less<_R1, _R2, -1LL, -1LL> struct __ratio_less<_R1, _R2, -1LL, -1LL>
{ {
static const bool value = __ratio_less1<ratio<-_R2::num, _R2::den>, ratio<-_R1::num, _R1::den> >::value; static const bool value = __ratio_less1<ratio<-_R2::num, _R2::den>, ratio<-_R1::num, _R1::den> >::value;
}; };
template <class _R1, class _R2> template <class _R1, class _R2>
struct _LIBCPP_TEMPLATE_VIS ratio_less struct ratio_less : _BoolConstant<__ratio_less<_R1, _R2>::value> {};
: _BoolConstant<__ratio_less<_R1, _R2>::value> {};
template <class _R1, class _R2> template <class _R1, class _R2>
struct _LIBCPP_TEMPLATE_VIS ratio_less_equal struct ratio_less_equal : _BoolConstant<!ratio_less<_R2, _R1>::value> {};
: _BoolConstant<!ratio_less<_R2, _R1>::value> {};
template <class _R1, class _R2> template <class _R1, class _R2>
struct _LIBCPP_TEMPLATE_VIS ratio_greater struct ratio_greater : _BoolConstant<ratio_less<_R2, _R1>::value> {};
: _BoolConstant<ratio_less<_R2, _R1>::value> {};
template <class _R1, class _R2> template <class _R1, class _R2>
struct _LIBCPP_TEMPLATE_VIS ratio_greater_equal struct ratio_greater_equal : _BoolConstant<!ratio_less<_R1, _R2>::value> {};
: _BoolConstant<!ratio_less<_R1, _R2>::value> {};
template <class _R1, class _R2> template <class _R1, class _R2>
struct __ratio_gcd struct __ratio_gcd
{ {
typedef ratio<__static_gcd<_R1::num, _R2::num>::value, typedef ratio<__static_gcd<_R1::num, _R2::num>::value,
__static_lcm<_R1::den, _R2::den>::value> type; __static_lcm<_R1::den, _R2::den>::value> type;
}; };
Show All 29 Lines

libcxx/include/regex

Show First 20 Lines • Show All 1,038 Lines • ▼ Show 20 Lines
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
throw regex_error(_Ev); throw regex_error(_Ev);
#else #else
_LIBCPP_VERBOSE_ABORT("regex_error was thrown in -fno-exceptions mode"); _LIBCPP_VERBOSE_ABORT("regex_error was thrown in -fno-exceptions mode");
#endif #endif
} }
template <class _CharT> template <class _CharT>
struct _LIBCPP_TEMPLATE_VIS regex_traits struct regex_traits
{ {
public: public:
typedef _CharT char_type; typedef _CharT char_type;
typedef basic_string<char_type> string_type; typedef basic_string<char_type> string_type;
typedef locale locale_type; typedef locale locale_type;
#if defined(__BIONIC__) || defined(_NEWLIB_VERSION) #if defined(__BIONIC__) || defined(_NEWLIB_VERSION)
// Originally bionic's ctype_base used its own ctype masks because the // Originally bionic's ctype_base used its own ctype masks because the
// builtin ctype implementation wasn't in libc++ yet. Bionic's ctype mask // builtin ctype implementation wasn't in libc++ yet. Bionic's ctype mask
▲ Show 20 Lines • Show All 358 Lines • ▼ Show 20 Lines
regex_traits<_CharT>::__regex_traits_value(wchar_t __ch, int __radix) const regex_traits<_CharT>::__regex_traits_value(wchar_t __ch, int __radix) const
{ {
return __regex_traits_value(static_cast<unsigned char>(__ct_->narrow(__ch, char_type())), __radix); return __regex_traits_value(static_cast<unsigned char>(__ct_->narrow(__ch, char_type())), __radix);
} }
#endif #endif
template <class _CharT> class __node; template <class _CharT> class __node;
template <class _BidirectionalIterator> class _LIBCPP_TEMPLATE_VIS sub_match; template <class _BidirectionalIterator> class sub_match;
template <class _BidirectionalIterator, template <class _BidirectionalIterator,
class _Allocator = allocator<sub_match<_BidirectionalIterator> > > class _Allocator = allocator<sub_match<_BidirectionalIterator> > >
class _LIBCPP_TEMPLATE_VIS match_results; class match_results;
template <class _CharT> template <class _CharT>
struct __state struct __state
{ {
enum enum
{ {
__end_state = -1000, __end_state = -1000,
__consume_input, // -999 __consume_input, // -999
▲ Show 20 Lines • Show All 1,192 Lines • ▼ Show 20 Lines else
__s.__do_ = __state::__reject; __s.__do_ = __state::__reject;
__s.__node_ = nullptr; __s.__node_ = nullptr;
} }
} }
template <class _CharT, class _Traits> class __lookahead; template <class _CharT, class _Traits> class __lookahead;
template <class _CharT, class _Traits = regex_traits<_CharT> > template <class _CharT, class _Traits = regex_traits<_CharT> >
class _LIBCPP_TEMPLATE_VIS basic_regex; class basic_regex;
typedef basic_regex<char> regex; typedef basic_regex<char> regex;
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
typedef basic_regex<wchar_t> wregex; typedef basic_regex<wchar_t> wregex;
#endif #endif
template <class _CharT, class _Traits> template <class _CharT, class _Traits>
class class _LIBCPP_PREFERRED_NAME(regex) _LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wregex)) basic_regex
_LIBCPP_TEMPLATE_VIS
_LIBCPP_PREFERRED_NAME(regex)
_LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wregex))
basic_regex
{ {
public: public:
// types: // types:
typedef _CharT value_type; typedef _CharT value_type;
typedef _Traits traits_type; typedef _Traits traits_type;
typedef typename _Traits::string_type string_type; typedef typename _Traits::string_type string_type;
typedef regex_constants::syntax_option_type flag_type; typedef regex_constants::syntax_option_type flag_type;
typedef typename _Traits::locale_type locale_type; typedef typename _Traits::locale_type locale_type;
▲ Show 20 Lines • Show All 2,332 Lines • ▼ Show 20 Lines
typedef sub_match<const char*> csub_match; typedef sub_match<const char*> csub_match;
typedef sub_match<string::const_iterator> ssub_match; typedef sub_match<string::const_iterator> ssub_match;
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
typedef sub_match<const wchar_t*> wcsub_match; typedef sub_match<const wchar_t*> wcsub_match;
typedef sub_match<wstring::const_iterator> wssub_match; typedef sub_match<wstring::const_iterator> wssub_match;
#endif #endif
// clang-format off
template <class _BidirectionalIterator> template <class _BidirectionalIterator>
class class _LIBCPP_PREFERRED_NAME(csub_match)
_LIBCPP_TEMPLATE_VIS
_LIBCPP_PREFERRED_NAME(csub_match)
_LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wcsub_match)) _LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wcsub_match))
_LIBCPP_PREFERRED_NAME(ssub_match) _LIBCPP_PREFERRED_NAME(ssub_match)
_LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wssub_match)) _LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wssub_match))
sub_match sub_match : public pair<_BidirectionalIterator, _BidirectionalIterator> {
: public pair<_BidirectionalIterator, _BidirectionalIterator> // clang-format on
{
public: public:
typedef _BidirectionalIterator iterator; typedef _BidirectionalIterator iterator;
typedef typename iterator_traits<iterator>::value_type value_type; typedef typename iterator_traits<iterator>::value_type value_type;
typedef typename iterator_traits<iterator>::difference_type difference_type; typedef typename iterator_traits<iterator>::difference_type difference_type;
typedef basic_string<value_type> string_type; typedef basic_string<value_type> string_type;
bool matched; bool matched;
▲ Show 20 Lines • Show All 451 Lines • ▼ Show 20 Lines
typedef match_results<const char*> cmatch; typedef match_results<const char*> cmatch;
typedef match_results<string::const_iterator> smatch; typedef match_results<string::const_iterator> smatch;
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
typedef match_results<const wchar_t*> wcmatch; typedef match_results<const wchar_t*> wcmatch;
typedef match_results<wstring::const_iterator> wsmatch; typedef match_results<wstring::const_iterator> wsmatch;
#endif #endif
// clang-format off
template <class _BidirectionalIterator, class _Allocator> template <class _BidirectionalIterator, class _Allocator>
class class _LIBCPP_PREFERRED_NAME(cmatch)
_LIBCPP_TEMPLATE_VIS
_LIBCPP_PREFERRED_NAME(cmatch)
_LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wcmatch)) _LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wcmatch))
_LIBCPP_PREFERRED_NAME(smatch) _LIBCPP_PREFERRED_NAME(smatch)
_LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wsmatch)) _LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wsmatch))
match_results match_results {
{ // clang-format on
public: public:
typedef _Allocator allocator_type; typedef _Allocator allocator_type;
typedef sub_match<_BidirectionalIterator> value_type; typedef sub_match<_BidirectionalIterator> value_type;
private: private:
typedef vector<value_type, allocator_type> __container_type; typedef vector<value_type, allocator_type> __container_type;
__container_type __matches_; __container_type __matches_;
value_type __unmatched_; value_type __unmatched_;
▲ Show 20 Lines • Show All 886 Lines • ▼ Show 20 Linesregex_match(const basic_string<_CharT, _ST, _SA>& __s,
return _VSTD::regex_match(__s.begin(), __s.end(), __e, __flags); return _VSTD::regex_match(__s.begin(), __s.end(), __e, __flags);
} }
// regex_iterator // regex_iterator
template <class _BidirectionalIterator, template <class _BidirectionalIterator,
class _CharT = typename iterator_traits<_BidirectionalIterator>::value_type, class _CharT = typename iterator_traits<_BidirectionalIterator>::value_type,
class _Traits = regex_traits<_CharT> > class _Traits = regex_traits<_CharT> >
class _LIBCPP_TEMPLATE_VIS regex_iterator; class regex_iterator;
typedef regex_iterator<const char*> cregex_iterator; typedef regex_iterator<const char*> cregex_iterator;
typedef regex_iterator<string::const_iterator> sregex_iterator; typedef regex_iterator<string::const_iterator> sregex_iterator;
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
typedef regex_iterator<const wchar_t*> wcregex_iterator; typedef regex_iterator<const wchar_t*> wcregex_iterator;
typedef regex_iterator<wstring::const_iterator> wsregex_iterator; typedef regex_iterator<wstring::const_iterator> wsregex_iterator;
#endif #endif
// clang-format off
template <class _BidirectionalIterator, class _CharT, class _Traits> template <class _BidirectionalIterator, class _CharT, class _Traits>
class class _LIBCPP_PREFERRED_NAME(cregex_iterator)
_LIBCPP_TEMPLATE_VIS
_LIBCPP_PREFERRED_NAME(cregex_iterator)
_LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wcregex_iterator)) _LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wcregex_iterator))
_LIBCPP_PREFERRED_NAME(sregex_iterator) _LIBCPP_PREFERRED_NAME(sregex_iterator)
_LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wsregex_iterator)) _LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wsregex_iterator))
regex_iterator regex_iterator {
{ // clang-format on
public: public:
typedef basic_regex<_CharT, _Traits> regex_type; typedef basic_regex<_CharT, _Traits> regex_type;
typedef match_results<_BidirectionalIterator> value_type; typedef match_results<_BidirectionalIterator> value_type;
typedef ptrdiff_t difference_type; typedef ptrdiff_t difference_type;
typedef const value_type* pointer; typedef const value_type* pointer;
typedef const value_type& reference; typedef const value_type& reference;
typedef forward_iterator_tag iterator_category; typedef forward_iterator_tag iterator_category;
▲ Show 20 Lines • Show All 96 Lines • ▼ Show 20 Linesregex_iterator<_BidirectionalIterator, _CharT, _Traits>::operator++()
return *this; return *this;
} }
// regex_token_iterator // regex_token_iterator
template <class _BidirectionalIterator, template <class _BidirectionalIterator,
class _CharT = typename iterator_traits<_BidirectionalIterator>::value_type, class _CharT = typename iterator_traits<_BidirectionalIterator>::value_type,
class _Traits = regex_traits<_CharT> > class _Traits = regex_traits<_CharT> >
class _LIBCPP_TEMPLATE_VIS regex_token_iterator; class regex_token_iterator;
typedef regex_token_iterator<const char*> cregex_token_iterator; typedef regex_token_iterator<const char*> cregex_token_iterator;
typedef regex_token_iterator<string::const_iterator> sregex_token_iterator; typedef regex_token_iterator<string::const_iterator> sregex_token_iterator;
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
typedef regex_token_iterator<const wchar_t*> wcregex_token_iterator; typedef regex_token_iterator<const wchar_t*> wcregex_token_iterator;
typedef regex_token_iterator<wstring::const_iterator> wsregex_token_iterator; typedef regex_token_iterator<wstring::const_iterator> wsregex_token_iterator;
#endif #endif
// clang-format off
template <class _BidirectionalIterator, class _CharT, class _Traits> template <class _BidirectionalIterator, class _CharT, class _Traits>
class class _LIBCPP_PREFERRED_NAME(cregex_token_iterator)
_LIBCPP_TEMPLATE_VIS
_LIBCPP_PREFERRED_NAME(cregex_token_iterator)
_LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wcregex_token_iterator)) _LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wcregex_token_iterator))
_LIBCPP_PREFERRED_NAME(sregex_token_iterator) _LIBCPP_PREFERRED_NAME(sregex_token_iterator)
_LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wsregex_token_iterator)) _LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wsregex_token_iterator))
regex_token_iterator regex_token_iterator {
{ // clang-format on
public: public:
typedef basic_regex<_CharT, _Traits> regex_type; typedef basic_regex<_CharT, _Traits> regex_type;
typedef sub_match<_BidirectionalIterator> value_type; typedef sub_match<_BidirectionalIterator> value_type;
typedef ptrdiff_t difference_type; typedef ptrdiff_t difference_type;
typedef const value_type* pointer; typedef const value_type* pointer;
typedef const value_type& reference; typedef const value_type& reference;
typedef forward_iterator_tag iterator_category; typedef forward_iterator_tag iterator_category;
▲ Show 20 Lines • Show All 409 Lines • Show Last 20 Lines

libcxx/include/scoped_allocator

Show First 20 Lines • Show All 395 Lines • ▼ Show 20 Lines typedef __libcpp_remove_reference_t
> _OuterAlloc; > _OuterAlloc;
typedef typename __outermost<_OuterAlloc>::type type; typedef typename __outermost<_OuterAlloc>::type type;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
type& operator()(_Alloc& __a) const _NOEXCEPT type& operator()(_Alloc& __a) const _NOEXCEPT
{return __outermost<_OuterAlloc>()(__a.outer_allocator());} {return __outermost<_OuterAlloc>()(__a.outer_allocator());}
}; };
template <class _OuterAlloc, class... _InnerAllocs> template <class _OuterAlloc, class... _InnerAllocs>
class _LIBCPP_TEMPLATE_VIS scoped_allocator_adaptor<_OuterAlloc, _InnerAllocs...> class scoped_allocator_adaptor<_OuterAlloc, _InnerAllocs...>
: public __scoped_allocator_storage<_OuterAlloc, _InnerAllocs...> : public __scoped_allocator_storage<_OuterAlloc, _InnerAllocs...>
{ {
typedef __scoped_allocator_storage<_OuterAlloc, _InnerAllocs...> base; typedef __scoped_allocator_storage<_OuterAlloc, _InnerAllocs...> base;
typedef allocator_traits<_OuterAlloc> _OuterTraits; typedef allocator_traits<_OuterAlloc> _OuterTraits;
public: public:
typedef _OuterAlloc outer_allocator_type; typedef _OuterAlloc outer_allocator_type;
typedef typename base::inner_allocator_type inner_allocator_type; typedef typename base::inner_allocator_type inner_allocator_type;
typedef typename _OuterTraits::size_type size_type; typedef typename _OuterTraits::size_type size_type;
▲ Show 20 Lines • Show All 321 Lines • Show Last 20 Lines

libcxx/include/set

Show First 20 Lines • Show All 515 Lines • ▼ Show 20 Lines
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Key, class _Compare, class _Allocator> template <class _Key, class _Compare, class _Allocator>
class multiset; class multiset;
template <class _Key, class _Compare = less<_Key>, template <class _Key, class _Compare = less<_Key>,
class _Allocator = allocator<_Key> > class _Allocator = allocator<_Key> >
class _LIBCPP_TEMPLATE_VIS set class set
{ {
public: public:
// types: // types:
typedef _Key key_type; typedef _Key key_type;
typedef key_type value_type; typedef key_type value_type;
typedef __type_identity_t<_Compare> key_compare; typedef __type_identity_t<_Compare> key_compare;
typedef key_compare value_compare; typedef key_compare value_compare;
typedef __type_identity_t<_Allocator> allocator_type; typedef __type_identity_t<_Allocator> allocator_type;
Show All 24 Linespublic:
typedef _VSTD::reverse_iterator<const_iterator> const_reverse_iterator; typedef _VSTD::reverse_iterator<const_iterator> const_reverse_iterator;
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
typedef __set_node_handle<typename __base::__node, allocator_type> node_type; typedef __set_node_handle<typename __base::__node, allocator_type> node_type;
typedef __insert_return_type<iterator, node_type> insert_return_type; typedef __insert_return_type<iterator, node_type> insert_return_type;
#endif #endif
template <class _Key2, class _Compare2, class _Alloc2> template <class _Key2, class _Compare2, class _Alloc2>
friend class _LIBCPP_TEMPLATE_VIS set; friend class set;
template <class _Key2, class _Compare2, class _Alloc2> template <class _Key2, class _Compare2, class _Alloc2>
friend class _LIBCPP_TEMPLATE_VIS multiset; friend class multiset;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
set() set()
_NOEXCEPT_( _NOEXCEPT_(
is_nothrow_default_constructible<allocator_type>::value && is_nothrow_default_constructible<allocator_type>::value &&
is_nothrow_default_constructible<key_compare>::value && is_nothrow_default_constructible<key_compare>::value &&
is_nothrow_copy_constructible<key_compare>::value) is_nothrow_copy_constructible<key_compare>::value)
: __tree_(value_compare()) {} : __tree_(value_compare()) {}
▲ Show 20 Lines • Show All 490 Lines • ▼ Show 20 Linesinline _LIBCPP_INLINE_VISIBILITY
typename set<_Key, _Compare, _Allocator>::size_type typename set<_Key, _Compare, _Allocator>::size_type
erase_if(set<_Key, _Compare, _Allocator>& __c, _Predicate __pred) { erase_if(set<_Key, _Compare, _Allocator>& __c, _Predicate __pred) {
return _VSTD::__libcpp_erase_if_container(__c, __pred); return _VSTD::__libcpp_erase_if_container(__c, __pred);
} }
#endif #endif
template <class _Key, class _Compare = less<_Key>, template <class _Key, class _Compare = less<_Key>,
class _Allocator = allocator<_Key> > class _Allocator = allocator<_Key> >
class _LIBCPP_TEMPLATE_VIS multiset class multiset
{ {
public: public:
// types: // types:
typedef _Key key_type; typedef _Key key_type;
typedef key_type value_type; typedef key_type value_type;
typedef __type_identity_t<_Compare> key_compare; typedef __type_identity_t<_Compare> key_compare;
typedef key_compare value_compare; typedef key_compare value_compare;
typedef __type_identity_t<_Allocator> allocator_type; typedef __type_identity_t<_Allocator> allocator_type;
Show All 23 Linespublic:
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;
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
typedef __set_node_handle<typename __base::__node, allocator_type> node_type; typedef __set_node_handle<typename __base::__node, allocator_type> node_type;
#endif #endif
template <class _Key2, class _Compare2, class _Alloc2> template <class _Key2, class _Compare2, class _Alloc2>
friend class _LIBCPP_TEMPLATE_VIS set; friend class set;
template <class _Key2, class _Compare2, class _Alloc2> template <class _Key2, class _Compare2, class _Alloc2>
friend class _LIBCPP_TEMPLATE_VIS multiset; friend class multiset;
// construct/copy/destroy: // construct/copy/destroy:
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
multiset() multiset()
_NOEXCEPT_( _NOEXCEPT_(
is_nothrow_default_constructible<allocator_type>::value && is_nothrow_default_constructible<allocator_type>::value &&
is_nothrow_default_constructible<key_compare>::value && is_nothrow_default_constructible<key_compare>::value &&
is_nothrow_copy_constructible<key_compare>::value) is_nothrow_copy_constructible<key_compare>::value)
▲ Show 20 Lines • Show All 518 Lines • Show Last 20 Lines

libcxx/include/span

Show First 20 Lines • Show All 197 Lines • ▼ Show 20 Lines
template <class _It, class _Tp> template <class _It, class _Tp>
concept __span_compatible_iterator = contiguous_iterator<_It> && __span_array_convertible<remove_reference_t<iter_reference_t<_It>>, _Tp>; concept __span_compatible_iterator = contiguous_iterator<_It> && __span_array_convertible<remove_reference_t<iter_reference_t<_It>>, _Tp>;
template <class _Sentinel, class _It> template <class _Sentinel, class _It>
concept __span_compatible_sentinel_for = sized_sentinel_for<_Sentinel, _It> && !is_convertible_v<_Sentinel, size_t>; concept __span_compatible_sentinel_for = sized_sentinel_for<_Sentinel, _It> && !is_convertible_v<_Sentinel, size_t>;
template <typename _Tp, size_t _Extent> template <typename _Tp, size_t _Extent>
class _LIBCPP_TEMPLATE_VIS span { class span {
public: public:
// constants and types // constants and types
using element_type = _Tp; using element_type = _Tp;
using value_type = remove_cv_t<_Tp>; using value_type = remove_cv_t<_Tp>;
using size_type = size_t; using size_type = size_t;
using difference_type = ptrdiff_t; using difference_type = ptrdiff_t;
using pointer = _Tp *; using pointer = _Tp *;
using const_pointer = const _Tp *; using const_pointer = const _Tp *;
▲ Show 20 Lines • Show All 167 Lines • ▼ Show 20 Lines#endif
{ return span<byte, _Extent * sizeof(element_type)>{reinterpret_cast<byte *>(data()), size_bytes()}; } { return span<byte, _Extent * sizeof(element_type)>{reinterpret_cast<byte *>(data()), size_bytes()}; }
private: private:
pointer __data_; pointer __data_;
}; };
template <typename _Tp> template <typename _Tp>
class _LIBCPP_TEMPLATE_VIS span<_Tp, dynamic_extent> { class span<_Tp, dynamic_extent> {
public: public:
// constants and types // constants and types
using element_type = _Tp; using element_type = _Tp;
using value_type = remove_cv_t<_Tp>; using value_type = remove_cv_t<_Tp>;
using size_type = size_t; using size_type = size_t;
using difference_type = ptrdiff_t; using difference_type = ptrdiff_t;
using pointer = _Tp *; using pointer = _Tp *;
using const_pointer = const _Tp *; using const_pointer = const _Tp *;
▲ Show 20 Lines • Show All 204 Lines • Show Last 20 Lines

libcxx/include/sstream

Show First 20 Lines • Show All 205 Lines • ▼ Show 20 Lines
#include <__undef_macros> #include <__undef_macros>
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
// Class template basic_stringbuf [stringbuf] // Class template basic_stringbuf [stringbuf]
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
class _LIBCPP_TEMPLATE_VIS basic_stringbuf class basic_stringbuf : public basic_streambuf<_CharT, _Traits>
: public basic_streambuf<_CharT, _Traits>
{ {
public: public:
typedef _CharT char_type; typedef _CharT char_type;
typedef _Traits traits_type; typedef _Traits traits_type;
typedef typename traits_type::int_type int_type; typedef typename traits_type::int_type int_type;
typedef typename traits_type::pos_type pos_type; typedef typename traits_type::pos_type pos_type;
typedef typename traits_type::off_type off_type; typedef typename traits_type::off_type off_type;
typedef _Allocator allocator_type; typedef _Allocator allocator_type;
▲ Show 20 Lines • Show All 425 Lines • ▼ Show 20 Lines if (__wch & ios_base::out)
this->__pbump(__noff); this->__pbump(__noff);
} }
return pos_type(__noff); return pos_type(__noff);
} }
// Class template basic_istringstream [istringstream] // Class template basic_istringstream [istringstream]
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
class _LIBCPP_TEMPLATE_VIS basic_istringstream class basic_istringstream : public basic_istream<_CharT, _Traits>
: public basic_istream<_CharT, _Traits>
{ {
public: public:
typedef _CharT char_type; typedef _CharT char_type;
typedef _Traits traits_type; typedef _Traits traits_type;
typedef typename traits_type::int_type int_type; typedef typename traits_type::int_type int_type;
typedef typename traits_type::pos_type pos_type; typedef typename traits_type::pos_type pos_type;
typedef typename traits_type::off_type off_type; typedef typename traits_type::off_type off_type;
typedef _Allocator allocator_type; typedef _Allocator allocator_type;
▲ Show 20 Lines • Show All 68 Lines • ▼ Show 20 Linesswap(basic_istringstream<_CharT, _Traits, _Allocator>& __x,
basic_istringstream<_CharT, _Traits, _Allocator>& __y) basic_istringstream<_CharT, _Traits, _Allocator>& __y)
{ {
__x.swap(__y); __x.swap(__y);
} }
// Class template basic_ostringstream [ostringstream] // Class template basic_ostringstream [ostringstream]
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
class _LIBCPP_TEMPLATE_VIS basic_ostringstream class basic_ostringstream : public basic_ostream<_CharT, _Traits>
: public basic_ostream<_CharT, _Traits>
{ {
public: public:
typedef _CharT char_type; typedef _CharT char_type;
typedef _Traits traits_type; typedef _Traits traits_type;
typedef typename traits_type::int_type int_type; typedef typename traits_type::int_type int_type;
typedef typename traits_type::pos_type pos_type; typedef typename traits_type::pos_type pos_type;
typedef typename traits_type::off_type off_type; typedef typename traits_type::off_type off_type;
typedef _Allocator allocator_type; typedef _Allocator allocator_type;
▲ Show 20 Lines • Show All 69 Lines • ▼ Show 20 Linesswap(basic_ostringstream<_CharT, _Traits, _Allocator>& __x,
basic_ostringstream<_CharT, _Traits, _Allocator>& __y) basic_ostringstream<_CharT, _Traits, _Allocator>& __y)
{ {
__x.swap(__y); __x.swap(__y);
} }
// Class template basic_stringstream [stringstream] // Class template basic_stringstream [stringstream]
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
class _LIBCPP_TEMPLATE_VIS basic_stringstream class basic_stringstream : public basic_iostream<_CharT, _Traits>
: public basic_iostream<_CharT, _Traits>
{ {
public: public:
typedef _CharT char_type; typedef _CharT char_type;
typedef _Traits traits_type; typedef _Traits traits_type;
typedef typename traits_type::int_type int_type; typedef typename traits_type::int_type int_type;
typedef typename traits_type::pos_type pos_type; typedef typename traits_type::pos_type pos_type;
typedef typename traits_type::off_type off_type; typedef typename traits_type::off_type off_type;
typedef _Allocator allocator_type; typedef _Allocator allocator_type;
▲ Show 20 Lines • Show All 89 Lines • Show Last 20 Lines

libcxx/include/stack

Show First 20 Lines • Show All 134 Lines • ▼ Show 20 Lines
#include <initializer_list> #include <initializer_list>
#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 _Container = deque<_Tp> > class _LIBCPP_TEMPLATE_VIS stack; template <class _Tp, class _Container = deque<_Tp> > class stack;
template <class _Tp, class _Container> template <class _Tp, class _Container>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
bool bool
operator==(const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y); operator==(const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y);
template <class _Tp, class _Container> template <class _Tp, class _Container>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
bool bool
operator< (const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y); operator< (const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y);
template <class _Tp, class _Container /*= deque<_Tp>*/> template <class _Tp, class _Container /*= deque<_Tp>*/>
class _LIBCPP_TEMPLATE_VIS stack class stack
{ {
public: public:
typedef _Container container_type; typedef _Container container_type;
typedef typename container_type::value_type value_type; typedef typename container_type::value_type value_type;
typedef typename container_type::reference reference; typedef typename container_type::reference reference;
typedef typename container_type::const_reference const_reference; typedef typename container_type::const_reference const_reference;
typedef typename container_type::size_type size_type; typedef typename container_type::size_type size_type;
static_assert((is_same<_Tp, value_type>::value), "" ); static_assert((is_same<_Tp, value_type>::value), "" );
▲ Show 20 Lines • Show All 254 Lines • ▼ Show 20 Lines
__enable_if_t<__is_swappable<_Container>::value, void> __enable_if_t<__is_swappable<_Container>::value, void>
swap(stack<_Tp, _Container>& __x, stack<_Tp, _Container>& __y) swap(stack<_Tp, _Container>& __x, stack<_Tp, _Container>& __y)
_NOEXCEPT_(_NOEXCEPT_(__x.swap(__y))) _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
{ {
__x.swap(__y); __x.swap(__y);
} }
template <class _Tp, class _Container, class _Alloc> template <class _Tp, class _Container, class _Alloc>
struct _LIBCPP_TEMPLATE_VIS uses_allocator<stack<_Tp, _Container>, _Alloc> struct uses_allocator<stack<_Tp, _Container>, _Alloc> : public uses_allocator<_Container, _Alloc> {};
: public uses_allocator<_Container, _Alloc>
{
};
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
# include <concepts> # include <concepts>
# include <functional> # include <functional>
# include <type_traits> # include <type_traits>
#endif #endif
#endif // _LIBCPP_STACK #endif // _LIBCPP_STACK

libcxx/include/streambuf

Show First 20 Lines • Show All 119 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 _CharT, class _Traits> template <class _CharT, class _Traits>
class _LIBCPP_TEMPLATE_VIS basic_streambuf class basic_streambuf
{ {
public: public:
// types: // types:
typedef _CharT char_type; typedef _CharT char_type;
typedef _Traits traits_type; typedef _Traits traits_type;
typedef typename traits_type::int_type int_type; typedef typename traits_type::int_type int_type;
typedef typename traits_type::pos_type pos_type; typedef typename traits_type::pos_type pos_type;
typedef typename traits_type::off_type off_type; typedef typename traits_type::off_type off_type;
▲ Show 20 Lines • Show All 366 Lines • Show Last 20 Lines

libcxx/include/thread

Show First 20 Lines • Show All 214 Lines • ▼ Show 20 Lines
__thread_specific_ptr<_Tp>::set_pointer(pointer __p) __thread_specific_ptr<_Tp>::set_pointer(pointer __p)
{ {
_LIBCPP_ASSERT(get() == nullptr, _LIBCPP_ASSERT(get() == nullptr,
"Attempting to overwrite thread local data"); "Attempting to overwrite thread local data");
std::__libcpp_tls_set(__key_, __p); std::__libcpp_tls_set(__key_, __p);
} }
template<> template<>
struct _LIBCPP_TEMPLATE_VIS hash<__thread_id> struct hash<__thread_id> : public __unary_function<__thread_id, size_t>
: public __unary_function<__thread_id, size_t>
{ {
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
size_t operator()(__thread_id __v) const _NOEXCEPT size_t operator()(__thread_id __v) const _NOEXCEPT
{ {
return hash<__libcpp_thread_id>()(__v.__id_); return hash<__libcpp_thread_id>()(__v.__id_);
} }
}; };
template<class _CharT, class _Traits> template<class _CharT, class _Traits>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __os, __thread_id __id) operator<<(basic_ostream<_CharT, _Traits>& __os, __thread_id __id)
{return __os << __id.__id_;} {return __os << __id.__id_;}
#if _LIBCPP_STD_VER >= 23 #if _LIBCPP_STD_VER >= 23
template <__fmt_char_type _CharT> template <__fmt_char_type _CharT>
struct _LIBCPP_TEMPLATE_VIS formatter<__thread_id, _CharT> { struct formatter<__thread_id, _CharT> {
public: public:
template <class _ParseContext> template <class _ParseContext>
_LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) { _LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) {
return __parser_.__parse(__ctx, __format_spec::__fields_fill_align_width); return __parser_.__parse(__ctx, __format_spec::__fields_fill_align_width);
} }
template <class _FormatContext> template <class _FormatContext>
_LIBCPP_HIDE_FROM_ABI typename _FormatContext::iterator format(__thread_id __id, _FormatContext& __ctx) const { _LIBCPP_HIDE_FROM_ABI typename _FormatContext::iterator format(__thread_id __id, _FormatContext& __ctx) const {
▲ Show 20 Lines • Show All 232 Lines • Show Last 20 Lines

libcxx/include/tuple

Show First 20 Lines • Show All 565 Lines • ▼ Show 20 Lines
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_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 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_SINCE_CXX14 template <size_t _Jp, class ..._Up> friend _LIBCPP_CONSTEXPR_SINCE_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_SINCE_CXX14 template <size_t _Jp, class ..._Up> friend _LIBCPP_CONSTEXPR_SINCE_CXX14
▲ Show 20 Lines • Show All 725 Lines • ▼ Show 20 Lines#if _LIBCPP_STD_VER >= 23
_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 >= 23 #endif // _LIBCPP_STD_VER >= 23
}; };
template <> template <>
class _LIBCPP_TEMPLATE_VIS tuple<> class tuple<>
{ {
public: public:
constexpr tuple() _NOEXCEPT = default; constexpr tuple() _NOEXCEPT = default;
template <class _Alloc> template <class _Alloc>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_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_SINCE_CXX20 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
▲ Show 20 Lines • Show All 464 Lines • ▼ Show 20 Linestuple_cat(_Tuple0&& __t0, _Tuples&&... __tpls)
typedef _LIBCPP_NODEBUG __libcpp_remove_reference_t<_Tuple0> _T0; typedef _LIBCPP_NODEBUG __libcpp_remove_reference_t<_Tuple0> _T0;
return __tuple_cat<tuple<>, __tuple_indices<>, return __tuple_cat<tuple<>, __tuple_indices<>,
typename __make_tuple_indices<tuple_size<_T0>::value>::type>() typename __make_tuple_indices<tuple_size<_T0>::value>::type>()
(tuple<>(), _VSTD::forward<_Tuple0>(__t0), (tuple<>(), _VSTD::forward<_Tuple0>(__t0),
_VSTD::forward<_Tuples>(__tpls)...); _VSTD::forward<_Tuples>(__tpls)...);
} }
template <class ..._Tp, class _Alloc> template <class ..._Tp, class _Alloc>
struct _LIBCPP_TEMPLATE_VIS uses_allocator<tuple<_Tp...>, _Alloc> struct 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_SINCE_CXX20 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_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))...),
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

libcxx/include/typeindex

Show First 20 Lines • Show All 54 Lines • ▼ Show 20 Lines
#include <compare> #include <compare>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
class _LIBCPP_TEMPLATE_VIS type_index class type_index
{ {
const type_info* __t_; const type_info* __t_;
public: public:
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
type_index(const type_info& __y) _NOEXCEPT : __t_(&__y) {} type_index(const type_info& __y) _NOEXCEPT : __t_(&__y) {}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
bool operator==(const type_index& __y) const _NOEXCEPT bool operator==(const type_index& __y) const _NOEXCEPT
Show All 27 Lines
#endif #endif
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
size_t hash_code() const _NOEXCEPT {return __t_->hash_code();} size_t hash_code() const _NOEXCEPT {return __t_->hash_code();}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
const char* name() const _NOEXCEPT {return __t_->name();} const char* name() const _NOEXCEPT {return __t_->name();}
}; };
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS hash; template <class _Tp> struct hash;
template <> template <>
struct _LIBCPP_TEMPLATE_VIS hash<type_index> struct hash<type_index> : public __unary_function<type_index, size_t>
: public __unary_function<type_index, size_t>
{ {
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
size_t operator()(type_index __index) const _NOEXCEPT size_t operator()(type_index __index) const _NOEXCEPT
{return __index.hash_code();} {return __index.hash_code();}
}; };
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
# include <iosfwd> # include <iosfwd>
# include <new> # include <new>
# include <utility> # include <utility>
#endif #endif
#endif // _LIBCPP_TYPEINDEX #endif // _LIBCPP_TYPEINDEX

libcxx/include/unordered_map

Show First 20 Lines • Show All 911 Lines • ▼ Show 20 Lines
private: private:
~__hash_value_type(); ~__hash_value_type();
}; };
#endif #endif
template <class _HashIterator> template <class _HashIterator>
class _LIBCPP_TEMPLATE_VIS __hash_map_iterator class __hash_map_iterator
{ {
_HashIterator __i_; _HashIterator __i_;
typedef __hash_node_types_from_iterator<_HashIterator> _NodeTypes; typedef __hash_node_types_from_iterator<_HashIterator> _NodeTypes;
public: public:
typedef forward_iterator_tag iterator_category; typedef forward_iterator_tag iterator_category;
typedef typename _NodeTypes::__map_value_type value_type; typedef typename _NodeTypes::__map_value_type value_type;
Show All 24 Linespublic:
friend _LIBCPP_INLINE_VISIBILITY friend _LIBCPP_INLINE_VISIBILITY
bool operator==(const __hash_map_iterator& __x, const __hash_map_iterator& __y) bool operator==(const __hash_map_iterator& __x, const __hash_map_iterator& __y)
{return __x.__i_ == __y.__i_;} {return __x.__i_ == __y.__i_;}
friend _LIBCPP_INLINE_VISIBILITY friend _LIBCPP_INLINE_VISIBILITY
bool operator!=(const __hash_map_iterator& __x, const __hash_map_iterator& __y) bool operator!=(const __hash_map_iterator& __x, const __hash_map_iterator& __y)
{return __x.__i_ != __y.__i_;} {return __x.__i_ != __y.__i_;}
template <class, class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS unordered_map; template <class, class, class, class, class> friend class unordered_map;
template <class, class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS unordered_multimap; template <class, class, class, class, class> friend class unordered_multimap;
template <class> friend class _LIBCPP_TEMPLATE_VIS __hash_const_iterator; template <class> friend class __hash_const_iterator;
template <class> friend class _LIBCPP_TEMPLATE_VIS __hash_const_local_iterator; template <class> friend class __hash_const_local_iterator;
template <class> friend class _LIBCPP_TEMPLATE_VIS __hash_map_const_iterator; template <class> friend class __hash_map_const_iterator;
}; };
template <class _HashIterator> template <class _HashIterator>
class _LIBCPP_TEMPLATE_VIS __hash_map_const_iterator class __hash_map_const_iterator
{ {
_HashIterator __i_; _HashIterator __i_;
typedef __hash_node_types_from_iterator<_HashIterator> _NodeTypes; typedef __hash_node_types_from_iterator<_HashIterator> _NodeTypes;
public: public:
typedef forward_iterator_tag iterator_category; typedef forward_iterator_tag iterator_category;
typedef typename _NodeTypes::__map_value_type value_type; typedef typename _NodeTypes::__map_value_type value_type;
Show All 29 Linespublic:
friend _LIBCPP_INLINE_VISIBILITY friend _LIBCPP_INLINE_VISIBILITY
bool operator==(const __hash_map_const_iterator& __x, const __hash_map_const_iterator& __y) bool operator==(const __hash_map_const_iterator& __x, const __hash_map_const_iterator& __y)
{return __x.__i_ == __y.__i_;} {return __x.__i_ == __y.__i_;}
friend _LIBCPP_INLINE_VISIBILITY friend _LIBCPP_INLINE_VISIBILITY
bool operator!=(const __hash_map_const_iterator& __x, const __hash_map_const_iterator& __y) bool operator!=(const __hash_map_const_iterator& __x, const __hash_map_const_iterator& __y)
{return __x.__i_ != __y.__i_;} {return __x.__i_ != __y.__i_;}
template <class, class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS unordered_map; template <class, class, class, class, class> friend class unordered_map;
template <class, class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS unordered_multimap; template <class, class, class, class, class> friend class unordered_multimap;
template <class> friend class _LIBCPP_TEMPLATE_VIS __hash_const_iterator; template <class> friend class __hash_const_iterator;
template <class> friend class _LIBCPP_TEMPLATE_VIS __hash_const_local_iterator; template <class> friend class __hash_const_local_iterator;
}; };
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc> template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
class unordered_multimap; class unordered_multimap;
template <class _Key, class _Tp, class _Hash = hash<_Key>, class _Pred = equal_to<_Key>, template <class _Key, class _Tp, class _Hash = hash<_Key>, class _Pred = equal_to<_Key>,
class _Alloc = allocator<pair<const _Key, _Tp> > > class _Alloc = allocator<pair<const _Key, _Tp> > >
class _LIBCPP_TEMPLATE_VIS unordered_map class unordered_map
{ {
public: public:
// types // types
typedef _Key key_type; typedef _Key key_type;
typedef _Tp mapped_type; typedef _Tp mapped_type;
typedef __type_identity_t<_Hash> hasher; typedef __type_identity_t<_Hash> hasher;
typedef __type_identity_t<_Pred> key_equal; typedef __type_identity_t<_Pred> key_equal;
typedef __type_identity_t<_Alloc> allocator_type; typedef __type_identity_t<_Alloc> allocator_type;
▲ Show 20 Lines • Show All 42 Lines • ▼ Show 20 Linespublic:
typedef __hash_map_const_iterator<typename __table::const_local_iterator> const_local_iterator; typedef __hash_map_const_iterator<typename __table::const_local_iterator> const_local_iterator;
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
typedef __map_node_handle<__node, allocator_type> node_type; typedef __map_node_handle<__node, allocator_type> node_type;
typedef __insert_return_type<iterator, node_type> insert_return_type; typedef __insert_return_type<iterator, node_type> insert_return_type;
#endif #endif
template <class _Key2, class _Tp2, class _Hash2, class _Pred2, class _Alloc2> template <class _Key2, class _Tp2, class _Hash2, class _Pred2, class _Alloc2>
friend class _LIBCPP_TEMPLATE_VIS unordered_map; friend class unordered_map;
template <class _Key2, class _Tp2, class _Hash2, class _Pred2, class _Alloc2> template <class _Key2, class _Tp2, class _Hash2, class _Pred2, class _Alloc2>
friend class _LIBCPP_TEMPLATE_VIS unordered_multimap; friend class unordered_multimap;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
unordered_map() unordered_map()
_NOEXCEPT_(is_nothrow_default_constructible<__table>::value) _NOEXCEPT_(is_nothrow_default_constructible<__table>::value)
{ {
_VSTD::__debug_db_insert_c(this); _VSTD::__debug_db_insert_c(this);
} }
explicit _LIBCPP_HIDE_FROM_ABI unordered_map(size_type __n, const hasher& __hf = hasher(), explicit _LIBCPP_HIDE_FROM_ABI unordered_map(size_type __n, const hasher& __hf = hasher(),
▲ Show 20 Lines • Show All 815 Lines • ▼ Show 20 Lines
operator!=(const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x, operator!=(const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y) const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
{ {
return !(__x == __y); return !(__x == __y);
} }
template <class _Key, class _Tp, class _Hash = hash<_Key>, class _Pred = equal_to<_Key>, template <class _Key, class _Tp, class _Hash = hash<_Key>, class _Pred = equal_to<_Key>,
class _Alloc = allocator<pair<const _Key, _Tp> > > class _Alloc = allocator<pair<const _Key, _Tp> > >
class _LIBCPP_TEMPLATE_VIS unordered_multimap class unordered_multimap
{ {
public: public:
// types // types
typedef _Key key_type; typedef _Key key_type;
typedef _Tp mapped_type; typedef _Tp mapped_type;
typedef __type_identity_t<_Hash> hasher; typedef __type_identity_t<_Hash> hasher;
typedef __type_identity_t<_Pred> key_equal; typedef __type_identity_t<_Pred> key_equal;
typedef __type_identity_t<_Alloc> allocator_type; typedef __type_identity_t<_Alloc> allocator_type;
Show All 40 Lines public:
typedef __hash_map_iterator<typename __table::local_iterator> local_iterator; typedef __hash_map_iterator<typename __table::local_iterator> local_iterator;
typedef __hash_map_const_iterator<typename __table::const_local_iterator> const_local_iterator; typedef __hash_map_const_iterator<typename __table::const_local_iterator> const_local_iterator;
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
typedef __map_node_handle<__node, allocator_type> node_type; typedef __map_node_handle<__node, allocator_type> node_type;
#endif #endif
template <class _Key2, class _Tp2, class _Hash2, class _Pred2, class _Alloc2> template <class _Key2, class _Tp2, class _Hash2, class _Pred2, class _Alloc2>
friend class _LIBCPP_TEMPLATE_VIS unordered_map; friend class unordered_map;
template <class _Key2, class _Tp2, class _Hash2, class _Pred2, class _Alloc2> template <class _Key2, class _Tp2, class _Hash2, class _Pred2, class _Alloc2>
friend class _LIBCPP_TEMPLATE_VIS unordered_multimap; friend class unordered_multimap;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
unordered_multimap() unordered_multimap()
_NOEXCEPT_(is_nothrow_default_constructible<__table>::value) _NOEXCEPT_(is_nothrow_default_constructible<__table>::value)
{ {
_VSTD::__debug_db_insert_c(this); _VSTD::__debug_db_insert_c(this);
} }
explicit _LIBCPP_HIDE_FROM_ABI unordered_multimap(size_type __n, const hasher& __hf = hasher(), explicit _LIBCPP_HIDE_FROM_ABI unordered_multimap(size_type __n, const hasher& __hf = hasher(),
▲ Show 20 Lines • Show All 670 Lines • Show Last 20 Lines

libcxx/include/unordered_set

Show First 20 Lines • Show All 495 Lines • ▼ Show 20 Lines
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Value, class _Hash, class _Pred, class _Alloc> template <class _Value, class _Hash, class _Pred, class _Alloc>
class unordered_multiset; class unordered_multiset;
template <class _Value, class _Hash = hash<_Value>, class _Pred = equal_to<_Value>, template <class _Value, class _Hash = hash<_Value>, class _Pred = equal_to<_Value>,
class _Alloc = allocator<_Value> > class _Alloc = allocator<_Value> >
class _LIBCPP_TEMPLATE_VIS unordered_set class unordered_set
{ {
public: public:
// types // types
typedef _Value key_type; typedef _Value key_type;
typedef key_type value_type; typedef key_type value_type;
typedef __type_identity_t<_Hash> hasher; typedef __type_identity_t<_Hash> hasher;
typedef __type_identity_t<_Pred> key_equal; typedef __type_identity_t<_Pred> key_equal;
typedef __type_identity_t<_Alloc> allocator_type; typedef __type_identity_t<_Alloc> allocator_type;
Show All 23 Linespublic:
typedef typename __table::const_local_iterator const_local_iterator; typedef typename __table::const_local_iterator const_local_iterator;
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
typedef __set_node_handle<typename __table::__node, allocator_type> node_type; typedef __set_node_handle<typename __table::__node, allocator_type> node_type;
typedef __insert_return_type<iterator, node_type> insert_return_type; typedef __insert_return_type<iterator, node_type> insert_return_type;
#endif #endif
template <class _Value2, class _Hash2, class _Pred2, class _Alloc2> template <class _Value2, class _Hash2, class _Pred2, class _Alloc2>
friend class _LIBCPP_TEMPLATE_VIS unordered_set; friend class unordered_set;
template <class _Value2, class _Hash2, class _Pred2, class _Alloc2> template <class _Value2, class _Hash2, class _Pred2, class _Alloc2>
friend class _LIBCPP_TEMPLATE_VIS unordered_multiset; friend class unordered_multiset;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
unordered_set() unordered_set()
_NOEXCEPT_(is_nothrow_default_constructible<__table>::value) _NOEXCEPT_(is_nothrow_default_constructible<__table>::value)
{ {
_VSTD::__debug_db_insert_c(this); _VSTD::__debug_db_insert_c(this);
} }
explicit _LIBCPP_HIDE_FROM_ABI unordered_set(size_type __n, const hasher& __hf = hasher(), explicit _LIBCPP_HIDE_FROM_ABI unordered_set(size_type __n, const hasher& __hf = hasher(),
▲ Show 20 Lines • Show All 601 Lines • ▼ Show 20 Lines
operator!=(const unordered_set<_Value, _Hash, _Pred, _Alloc>& __x, operator!=(const unordered_set<_Value, _Hash, _Pred, _Alloc>& __x,
const unordered_set<_Value, _Hash, _Pred, _Alloc>& __y) const unordered_set<_Value, _Hash, _Pred, _Alloc>& __y)
{ {
return !(__x == __y); return !(__x == __y);
} }
template <class _Value, class _Hash = hash<_Value>, class _Pred = equal_to<_Value>, template <class _Value, class _Hash = hash<_Value>, class _Pred = equal_to<_Value>,
class _Alloc = allocator<_Value> > class _Alloc = allocator<_Value> >
class _LIBCPP_TEMPLATE_VIS unordered_multiset class unordered_multiset
{ {
public: public:
// types // types
typedef _Value key_type; typedef _Value key_type;
typedef key_type value_type; typedef key_type value_type;
typedef __type_identity_t<_Hash> hasher; typedef __type_identity_t<_Hash> hasher;
typedef __type_identity_t<_Pred> key_equal; typedef __type_identity_t<_Pred> key_equal;
typedef __type_identity_t<_Alloc> allocator_type; typedef __type_identity_t<_Alloc> allocator_type;
Show All 18 Linespublic:
typedef typename __table::const_local_iterator local_iterator; typedef typename __table::const_local_iterator local_iterator;
typedef typename __table::const_local_iterator const_local_iterator; typedef typename __table::const_local_iterator const_local_iterator;
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
typedef __set_node_handle<typename __table::__node, allocator_type> node_type; typedef __set_node_handle<typename __table::__node, allocator_type> node_type;
#endif #endif
template <class _Value2, class _Hash2, class _Pred2, class _Alloc2> template <class _Value2, class _Hash2, class _Pred2, class _Alloc2>
friend class _LIBCPP_TEMPLATE_VIS unordered_set; friend class unordered_set;
template <class _Value2, class _Hash2, class _Pred2, class _Alloc2> template <class _Value2, class _Hash2, class _Pred2, class _Alloc2>
friend class _LIBCPP_TEMPLATE_VIS unordered_multiset; friend class unordered_multiset;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
unordered_multiset() unordered_multiset()
_NOEXCEPT_(is_nothrow_default_constructible<__table>::value) _NOEXCEPT_(is_nothrow_default_constructible<__table>::value)
{ {
_VSTD::__debug_db_insert_c(this); _VSTD::__debug_db_insert_c(this);
} }
explicit _LIBCPP_HIDE_FROM_ABI unordered_multiset(size_type __n, const hasher& __hf = hasher(), explicit _LIBCPP_HIDE_FROM_ABI unordered_multiset(size_type __n, const hasher& __hf = hasher(),
▲ Show 20 Lines • Show All 617 Lines • Show Last 20 Lines

libcxx/include/valarray

Show First 20 Lines • Show All 371 Lines • ▼ Show 20 Lines
# pragma GCC system_header # pragma GCC system_header
#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> class _LIBCPP_TEMPLATE_VIS valarray; template<class _Tp> class valarray;
class _LIBCPP_TEMPLATE_VIS slice class slice
{ {
size_t __start_; size_t __start_;
size_t __size_; size_t __size_;
size_t __stride_; size_t __stride_;
public: public:
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
slice() slice()
: __start_(0), : __start_(0),
__size_(0), __size_(0),
__stride_(0) __stride_(0)
{} {}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
slice(size_t __start, size_t __size, size_t __stride) slice(size_t __start, size_t __size, size_t __stride)
: __start_(__start), : __start_(__start),
__size_(__size), __size_(__size),
__stride_(__stride) __stride_(__stride)
{} {}
_LIBCPP_INLINE_VISIBILITY size_t start() const {return __start_;} _LIBCPP_INLINE_VISIBILITY size_t start() const {return __start_;}
_LIBCPP_INLINE_VISIBILITY size_t size() const {return __size_;} _LIBCPP_INLINE_VISIBILITY size_t size() const {return __size_;}
_LIBCPP_INLINE_VISIBILITY size_t stride() const {return __stride_;} _LIBCPP_INLINE_VISIBILITY size_t stride() const {return __stride_;}
}; };
template <class _Tp> class _LIBCPP_TEMPLATE_VIS slice_array; template <class _Tp> class slice_array;
class _LIBCPP_TYPE_VIS gslice; class _LIBCPP_TYPE_VIS gslice;
template <class _Tp> class _LIBCPP_TEMPLATE_VIS gslice_array; template <class _Tp> class gslice_array;
template <class _Tp> class _LIBCPP_TEMPLATE_VIS mask_array; template <class _Tp> class mask_array;
template <class _Tp> class _LIBCPP_TEMPLATE_VIS indirect_array; template <class _Tp> class indirect_array;
template <class _Tp> template <class _Tp>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
_Tp* _Tp*
begin(valarray<_Tp>& __v); begin(valarray<_Tp>& __v);
template <class _Tp> template <class _Tp>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
▲ Show 20 Lines • Show All 292 Lines • ▼ Show 20 Linespublic:
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
__result_type operator[](size_t __i) const __result_type operator[](size_t __i) const
{return __expr_[__start_ + __i * __stride_];} {return __expr_[__start_ + __i * __stride_];}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
size_t size() const {return __size_;} size_t size() const {return __size_;}
template <class> friend class __val_expr; template <class> friend class __val_expr;
template <class> friend class _LIBCPP_TEMPLATE_VIS valarray; template <class> friend class valarray;
}; };
template <class _ValExpr> template <class _ValExpr>
class __mask_expr; class __mask_expr;
template <class _ValExpr> template <class _ValExpr>
class __indirect_expr; class __indirect_expr;
▲ Show 20 Lines • Show All 98 Lines • ▼ Show 20 Lines
template<class _ValExpr> template<class _ValExpr>
struct __is_val_expr<__val_expr<_ValExpr> > : true_type {}; struct __is_val_expr<__val_expr<_ValExpr> > : true_type {};
template<class _Tp> template<class _Tp>
struct __is_val_expr<valarray<_Tp> > : true_type {}; struct __is_val_expr<valarray<_Tp> > : true_type {};
template<class _Tp> template<class _Tp>
class _LIBCPP_TEMPLATE_VIS valarray class valarray
{ {
public: public:
typedef _Tp value_type; typedef _Tp value_type;
typedef _Tp __result_type; typedef _Tp __result_type;
private: private:
value_type* __begin_; value_type* __begin_;
value_type* __end_; value_type* __end_;
▲ Show 20 Lines • Show All 223 Lines • ▼ Show 20 Lines#endif // _LIBCPP_CXX03_LANG
valarray shift (int __i) const; valarray shift (int __i) const;
valarray cshift(int __i) const; valarray cshift(int __i) const;
valarray apply(value_type __f(value_type)) const; valarray apply(value_type __f(value_type)) const;
valarray apply(value_type __f(const value_type&)) const; valarray apply(value_type __f(const value_type&)) const;
void resize(size_t __n, value_type __x = value_type()); void resize(size_t __n, value_type __x = value_type());
private: private:
template <class> friend class _LIBCPP_TEMPLATE_VIS valarray; template <class> friend class valarray;
template <class> friend class _LIBCPP_TEMPLATE_VIS slice_array; template <class> friend class slice_array;
template <class> friend class _LIBCPP_TEMPLATE_VIS gslice_array; template <class> friend class gslice_array;
template <class> friend class _LIBCPP_TEMPLATE_VIS mask_array; template <class> friend class mask_array;
template <class> friend class __mask_expr; template <class> friend class __mask_expr;
template <class> friend class _LIBCPP_TEMPLATE_VIS indirect_array; template <class> friend class indirect_array;
template <class> friend class __indirect_expr; template <class> friend class __indirect_expr;
template <class> friend class __val_expr; template <class> friend class __val_expr;
template <class _Up> template <class _Up>
friend friend
_Up* _Up*
begin(valarray<_Up>& __v); begin(valarray<_Up>& __v);
▲ Show 20 Lines • Show All 104 Lines • ▼ Show 20 Linesstruct _BinaryOp<_Op, valarray<_Tp>, valarray<_Tp> >
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
size_t size() const {return __a0_.size();} size_t size() const {return __a0_.size();}
}; };
// slice_array // slice_array
template <class _Tp> template <class _Tp>
class _LIBCPP_TEMPLATE_VIS slice_array class slice_array
{ {
public: public:
typedef _Tp value_type; typedef _Tp value_type;
private: private:
value_type* __vp_; value_type* __vp_;
size_t __size_; size_t __size_;
size_t __stride_; size_t __stride_;
▲ Show 20 Lines • Show All 375 Lines • ▼ Show 20 Linesprivate:
template <class> friend class gslice_array; template <class> friend class gslice_array;
template <class> friend class valarray; template <class> friend class valarray;
template <class> friend class __val_expr; template <class> friend class __val_expr;
}; };
// gslice_array // gslice_array
template <class _Tp> template <class _Tp>
class _LIBCPP_TEMPLATE_VIS gslice_array class gslice_array
{ {
public: public:
typedef _Tp value_type; typedef _Tp value_type;
private: private:
value_type* __vp_; value_type* __vp_;
valarray<size_t> __1d_; valarray<size_t> __1d_;
▲ Show 20 Lines • Show All 318 Lines • ▼ Show 20 Linesgslice_array<_Tp>::operator=(const value_type& __x) const
typedef const size_t* _Ip; typedef const size_t* _Ip;
for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i) for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i)
__vp_[*__i] = __x; __vp_[*__i] = __x;
} }
// mask_array // mask_array
template <class _Tp> template <class _Tp>
class _LIBCPP_TEMPLATE_VIS mask_array class mask_array
{ {
public: public:
typedef _Tp value_type; typedef _Tp value_type;
private: private:
value_type* __vp_; value_type* __vp_;
valarray<size_t> __1d_; valarray<size_t> __1d_;
▲ Show 20 Lines • Show All 339 Lines • ▼ Show 20 Linespublic:
template <class> friend class __val_expr; template <class> friend class __val_expr;
template <class> friend class valarray; template <class> friend class valarray;
}; };
// indirect_array // indirect_array
template <class _Tp> template <class _Tp>
class _LIBCPP_TEMPLATE_VIS indirect_array class indirect_array
{ {
public: public:
typedef _Tp value_type; typedef _Tp value_type;
private: private:
value_type* __vp_; value_type* __vp_;
valarray<size_t> __1d_; valarray<size_t> __1d_;
▲ Show 20 Lines • Show All 345 Lines • ▼ Show 20 Linespublic:
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
__result_type operator[](size_t __i) const __result_type operator[](size_t __i) const
{return __expr_[__1d_[__i]];} {return __expr_[__1d_[__i]];}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
size_t size() const {return __1d_.size();} size_t size() const {return __1d_.size();}
template <class> friend class __val_expr; template <class> friend class __val_expr;
template <class> friend class _LIBCPP_TEMPLATE_VIS valarray; template <class> friend class valarray;
}; };
template<class _ValExpr> template<class _ValExpr>
class __val_expr class __val_expr
{ {
typedef __libcpp_remove_reference_t<_ValExpr> _RmExpr; typedef __libcpp_remove_reference_t<_ValExpr> _RmExpr;
_ValExpr __expr_; _ValExpr __expr_;
▲ Show 20 Lines • Show All 2,290 Lines • Show Last 20 Lines

libcxx/include/variant

Show First 20 Lines • Show All 290 Lines • ▼ Show 20 Lines
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
throw bad_variant_access(); throw bad_variant_access();
#else #else
_LIBCPP_VERBOSE_ABORT("bad_variant_access was thrown in -fno-exceptions mode"); _LIBCPP_VERBOSE_ABORT("bad_variant_access was thrown in -fno-exceptions mode");
#endif #endif
} }
template <class... _Types> template <class... _Types>
class _LIBCPP_TEMPLATE_VIS variant; class variant;
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS variant_size; struct variant_size;
template <class _Tp> template <class _Tp>
inline constexpr size_t variant_size_v = variant_size<_Tp>::value; inline constexpr size_t variant_size_v = variant_size<_Tp>::value;
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS variant_size<const _Tp> : variant_size<_Tp> {}; struct variant_size<const _Tp> : variant_size<_Tp> {};
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS variant_size<volatile _Tp> : variant_size<_Tp> {}; struct variant_size<volatile _Tp> : variant_size<_Tp> {};
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS variant_size<const volatile _Tp> struct variant_size<const volatile _Tp>
: variant_size<_Tp> {}; : variant_size<_Tp> {};
template <class... _Types> template <class... _Types>
struct _LIBCPP_TEMPLATE_VIS variant_size<variant<_Types...>> struct variant_size<variant<_Types...>>
: integral_constant<size_t, sizeof...(_Types)> {}; : integral_constant<size_t, sizeof...(_Types)> {};
template <size_t _Ip, class _Tp> template <size_t _Ip, class _Tp>
struct _LIBCPP_TEMPLATE_VIS variant_alternative; struct variant_alternative;
template <size_t _Ip, class _Tp> template <size_t _Ip, class _Tp>
using variant_alternative_t = typename variant_alternative<_Ip, _Tp>::type; using variant_alternative_t = typename variant_alternative<_Ip, _Tp>::type;
template <size_t _Ip, class _Tp> template <size_t _Ip, class _Tp>
struct _LIBCPP_TEMPLATE_VIS variant_alternative<_Ip, const _Tp> struct variant_alternative<_Ip, const _Tp>
: add_const<variant_alternative_t<_Ip, _Tp>> {}; : add_const<variant_alternative_t<_Ip, _Tp>> {};
template <size_t _Ip, class _Tp> template <size_t _Ip, class _Tp>
struct _LIBCPP_TEMPLATE_VIS variant_alternative<_Ip, volatile _Tp> struct variant_alternative<_Ip, volatile _Tp>
: add_volatile<variant_alternative_t<_Ip, _Tp>> {}; : add_volatile<variant_alternative_t<_Ip, _Tp>> {};
template <size_t _Ip, class _Tp> template <size_t _Ip, class _Tp>
struct _LIBCPP_TEMPLATE_VIS variant_alternative<_Ip, const volatile _Tp> struct variant_alternative<_Ip, const volatile _Tp>
: add_cv<variant_alternative_t<_Ip, _Tp>> {}; : add_cv<variant_alternative_t<_Ip, _Tp>> {};
template <size_t _Ip, class... _Types> template <size_t _Ip, class... _Types>
struct _LIBCPP_TEMPLATE_VIS variant_alternative<_Ip, variant<_Types...>> { struct variant_alternative<_Ip, variant<_Types...>> {
static_assert(_Ip < sizeof...(_Types), "Index out of bounds in std::variant_alternative<>"); static_assert(_Ip < sizeof...(_Types), "Index out of bounds in std::variant_alternative<>");
using type = __type_pack_element<_Ip, _Types...>; using type = __type_pack_element<_Ip, _Types...>;
}; };
inline constexpr size_t variant_npos = static_cast<size_t>(-1); inline constexpr size_t variant_npos = static_cast<size_t>(-1);
_LIBCPP_HIDE_FROM_ABI constexpr int __choose_index_type(unsigned int __num_elem) { _LIBCPP_HIDE_FROM_ABI constexpr int __choose_index_type(unsigned int __num_elem) {
if (__num_elem < numeric_limits<unsigned char>::max()) if (__num_elem < numeric_limits<unsigned char>::max())
Show All 13 Lines std::tuple_element_t<
std::tuple<unsigned char, unsigned short, unsigned int> std::tuple<unsigned char, unsigned short, unsigned int>
>; >;
#endif #endif
template <class _IndexType> template <class _IndexType>
constexpr _IndexType __variant_npos = static_cast<_IndexType>(-1); constexpr _IndexType __variant_npos = static_cast<_IndexType>(-1);
template <class... _Types> template <class... _Types>
class _LIBCPP_TEMPLATE_VIS variant; class variant;
template <class... _Types> template <class... _Types>
_LIBCPP_INLINE_VISIBILITY constexpr variant<_Types...>& _LIBCPP_INLINE_VISIBILITY constexpr variant<_Types...>&
__as_variant(variant<_Types...>& __vs) noexcept { __as_variant(variant<_Types...>& __vs) noexcept {
return __vs; return __vs;
} }
template <class... _Types> template <class... _Types>
▲ Show 20 Lines • Show All 352 Lines • ▼ Show 20 Lines static constexpr auto __make_value_visitor(_Visitor&& __visitor) {
return __value_visitor_return_type<_Rp, _Visitor>{_VSTD::forward<_Visitor>(__visitor)}; return __value_visitor_return_type<_Rp, _Visitor>{_VSTD::forward<_Visitor>(__visitor)};
} }
#endif #endif
}; };
} // namespace __visitation } // namespace __visitation
template <size_t _Index, class _Tp> template <size_t _Index, class _Tp>
struct _LIBCPP_TEMPLATE_VIS __alt { struct __alt {
using __value_type = _Tp; using __value_type = _Tp;
template <class... _Args> template <class... _Args>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
explicit constexpr __alt(in_place_t, _Args&&... __args) explicit constexpr __alt(in_place_t, _Args&&... __args)
: __value(_VSTD::forward<_Args>(__args)...) {} : __value(_VSTD::forward<_Args>(__args)...) {}
__value_type __value; __value_type __value;
}; };
template <_Trait _DestructibleTrait, size_t _Index, class... _Types> template <_Trait _DestructibleTrait, size_t _Index, class... _Types>
union _LIBCPP_TEMPLATE_VIS __union; union __union;
template <_Trait _DestructibleTrait, size_t _Index> template <_Trait _DestructibleTrait, size_t _Index>
union _LIBCPP_TEMPLATE_VIS __union<_DestructibleTrait, _Index> {}; union __union<_DestructibleTrait, _Index> {};
#define _LIBCPP_VARIANT_UNION(destructible_trait, destructor) \ #define _LIBCPP_VARIANT_UNION(destructible_trait, destructor) \
template <size_t _Index, class _Tp, class... _Types> \ template <size_t _Index, class _Tp, class... _Types> \
union _LIBCPP_TEMPLATE_VIS __union<destructible_trait, \ union __union<destructible_trait, \
_Index, \ _Index, \
_Tp, \ _Tp, \
_Types...> { \ _Types...> { \
public: \ public: \
_LIBCPP_HIDE_FROM_ABI \ _LIBCPP_HIDE_FROM_ABI \
explicit constexpr __union(__valueless_t) noexcept : __dummy{} {} \ explicit constexpr __union(__valueless_t) noexcept : __dummy{} {} \
\ \
template <class... _Args> \ template <class... _Args> \
Show All 24 Lines
_LIBCPP_VARIANT_UNION(_Trait::_TriviallyAvailable, ~__union() = default;); _LIBCPP_VARIANT_UNION(_Trait::_TriviallyAvailable, ~__union() = default;);
_LIBCPP_VARIANT_UNION(_Trait::_Available, ~__union() {}); _LIBCPP_VARIANT_UNION(_Trait::_Available, ~__union() {});
_LIBCPP_VARIANT_UNION(_Trait::_Unavailable, ~__union() = delete;); _LIBCPP_VARIANT_UNION(_Trait::_Unavailable, ~__union() = delete;);
#undef _LIBCPP_VARIANT_UNION #undef _LIBCPP_VARIANT_UNION
template <_Trait _DestructibleTrait, class... _Types> template <_Trait _DestructibleTrait, class... _Types>
class _LIBCPP_TEMPLATE_VIS __base { class __base {
public: public:
using __index_t = __variant_index_t<sizeof...(_Types)>; using __index_t = __variant_index_t<sizeof...(_Types)>;
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
explicit constexpr __base(__valueless_t __tag) noexcept explicit constexpr __base(__valueless_t __tag) noexcept
: __data(__tag), __index(__variant_npos<__index_t>) {} : __data(__tag), __index(__variant_npos<__index_t>) {}
template <size_t _Ip, class... _Args> template <size_t _Ip, class... _Args>
Show All 32 Linesprotected:
__union<_DestructibleTrait, 0, _Types...> __data; __union<_DestructibleTrait, 0, _Types...> __data;
__index_t __index; __index_t __index;
friend struct __access::__base; friend struct __access::__base;
friend struct __visitation::__base; friend struct __visitation::__base;
}; };
template <class _Traits, _Trait = _Traits::__destructible_trait> template <class _Traits, _Trait = _Traits::__destructible_trait>
class _LIBCPP_TEMPLATE_VIS __dtor; class __dtor;
#define _LIBCPP_VARIANT_DESTRUCTOR(destructible_trait, destructor, destroy) \ #define _LIBCPP_VARIANT_DESTRUCTOR(destructible_trait, destructor, destroy) \
template <class... _Types> \ template <class... _Types> \
class _LIBCPP_TEMPLATE_VIS __dtor<__traits<_Types...>, \ class __dtor<__traits<_Types...>, destructible_trait> : public __base<destructible_trait, _Types...> { \
destructible_trait> \
: public __base<destructible_trait, _Types...> { \
using __base_type = __base<destructible_trait, _Types...>; \ using __base_type = __base<destructible_trait, _Types...>; \
using __index_t = typename __base_type::__index_t; \ using __index_t = typename __base_type::__index_t; \
\ \
public: \ public: \
using __base_type::__base_type; \ using __base_type::__base_type; \
using __base_type::operator=; \ using __base_type::operator=; \
\ \
__dtor(const __dtor&) = default; \ __dtor(const __dtor&) = default; \
Show All 30 Lines
_LIBCPP_VARIANT_DESTRUCTOR( _LIBCPP_VARIANT_DESTRUCTOR(
_Trait::_Unavailable, _Trait::_Unavailable,
~__dtor() = delete;, ~__dtor() = delete;,
void __destroy() noexcept = delete;); void __destroy() noexcept = delete;);
#undef _LIBCPP_VARIANT_DESTRUCTOR #undef _LIBCPP_VARIANT_DESTRUCTOR
template <class _Traits> template <class _Traits>
class _LIBCPP_TEMPLATE_VIS __ctor : public __dtor<_Traits> { class __ctor : public __dtor<_Traits> {
using __base_type = __dtor<_Traits>; using __base_type = __dtor<_Traits>;
public: public:
using __base_type::__base_type; using __base_type::__base_type;
using __base_type::operator=; using __base_type::operator=;
protected: protected:
template <size_t _Ip, class _Tp, class... _Args> template <size_t _Ip, class _Tp, class... _Args>
Show All 18 Lines if (!__rhs.valueless_by_exception()) {
}, },
__lhs, _VSTD::forward<_Rhs>(__rhs)); __lhs, _VSTD::forward<_Rhs>(__rhs));
__lhs.__index = __rhs.index(); __lhs.__index = __rhs.index();
} }
} }
}; };
template <class _Traits, _Trait = _Traits::__move_constructible_trait> template <class _Traits, _Trait = _Traits::__move_constructible_trait>
class _LIBCPP_TEMPLATE_VIS __move_constructor; class __move_constructor;
#define _LIBCPP_VARIANT_MOVE_CONSTRUCTOR(move_constructible_trait, \ #define _LIBCPP_VARIANT_MOVE_CONSTRUCTOR(move_constructible_trait, \
move_constructor) \ move_constructor) \
template <class... _Types> \ template <class... _Types> \
class _LIBCPP_TEMPLATE_VIS __move_constructor<__traits<_Types...>, \ class __move_constructor<__traits<_Types...>, move_constructible_trait> : public __ctor<__traits<_Types...>> { \
move_constructible_trait> \
: public __ctor<__traits<_Types...>> { \
using __base_type = __ctor<__traits<_Types...>>; \ using __base_type = __ctor<__traits<_Types...>>; \
\ \
public: \ public: \
using __base_type::__base_type; \ using __base_type::__base_type; \
using __base_type::operator=; \ using __base_type::operator=; \
\ \
__move_constructor(const __move_constructor&) = default; \ __move_constructor(const __move_constructor&) = default; \
move_constructor \ move_constructor \
Show All 16 Lines
_LIBCPP_VARIANT_MOVE_CONSTRUCTOR( _LIBCPP_VARIANT_MOVE_CONSTRUCTOR(
_Trait::_Unavailable, _Trait::_Unavailable,
__move_constructor(__move_constructor&&) = delete;); __move_constructor(__move_constructor&&) = delete;);
#undef _LIBCPP_VARIANT_MOVE_CONSTRUCTOR #undef _LIBCPP_VARIANT_MOVE_CONSTRUCTOR
template <class _Traits, _Trait = _Traits::__copy_constructible_trait> template <class _Traits, _Trait = _Traits::__copy_constructible_trait>
class _LIBCPP_TEMPLATE_VIS __copy_constructor; class __copy_constructor;
#define _LIBCPP_VARIANT_COPY_CONSTRUCTOR(copy_constructible_trait, \ #define _LIBCPP_VARIANT_COPY_CONSTRUCTOR(copy_constructible_trait, \
copy_constructor) \ copy_constructor) \
template <class... _Types> \ template <class... _Types> \
class _LIBCPP_TEMPLATE_VIS __copy_constructor<__traits<_Types...>, \ class __copy_constructor<__traits<_Types...>, copy_constructible_trait> \
copy_constructible_trait> \
: public __move_constructor<__traits<_Types...>> { \ : public __move_constructor<__traits<_Types...>> { \
using __base_type = __move_constructor<__traits<_Types...>>; \ using __base_type = __move_constructor<__traits<_Types...>>; \
\ \
public: \ public: \
using __base_type::__base_type; \ using __base_type::__base_type; \
using __base_type::operator=; \ using __base_type::operator=; \
\ \
copy_constructor \ copy_constructor \
Show All 16 Lines
_LIBCPP_VARIANT_COPY_CONSTRUCTOR( _LIBCPP_VARIANT_COPY_CONSTRUCTOR(
_Trait::_Unavailable, _Trait::_Unavailable,
__copy_constructor(const __copy_constructor&) = delete;); __copy_constructor(const __copy_constructor&) = delete;);
#undef _LIBCPP_VARIANT_COPY_CONSTRUCTOR #undef _LIBCPP_VARIANT_COPY_CONSTRUCTOR
template <class _Traits> template <class _Traits>
class _LIBCPP_TEMPLATE_VIS __assignment : public __copy_constructor<_Traits> { class __assignment : public __copy_constructor<_Traits> {
using __base_type = __copy_constructor<_Traits>; using __base_type = __copy_constructor<_Traits>;
public: public:
using __base_type::__base_type; using __base_type::__base_type;
using __base_type::operator=; using __base_type::operator=;
template <size_t _Ip, class... _Args> template <size_t _Ip, class... _Args>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
▲ Show 20 Lines • Show All 43 Lines • ▼ Show 20 Lines if (this->valueless_by_exception() && __that.valueless_by_exception()) {
_VSTD::forward<decltype(__that_alt)>(__that_alt).__value); _VSTD::forward<decltype(__that_alt)>(__that_alt).__value);
}, },
*this, _VSTD::forward<_That>(__that)); *this, _VSTD::forward<_That>(__that));
} }
} }
}; };
template <class _Traits, _Trait = _Traits::__move_assignable_trait> template <class _Traits, _Trait = _Traits::__move_assignable_trait>
class _LIBCPP_TEMPLATE_VIS __move_assignment; class __move_assignment;
#define _LIBCPP_VARIANT_MOVE_ASSIGNMENT(move_assignable_trait, \ #define _LIBCPP_VARIANT_MOVE_ASSIGNMENT(move_assignable_trait, \
move_assignment) \ move_assignment) \
template <class... _Types> \ template <class... _Types> \
class _LIBCPP_TEMPLATE_VIS __move_assignment<__traits<_Types...>, \ class __move_assignment<__traits<_Types...>, move_assignable_trait> \
move_assignable_trait> \
: public __assignment<__traits<_Types...>> { \ : public __assignment<__traits<_Types...>> { \
using __base_type = __assignment<__traits<_Types...>>; \ using __base_type = __assignment<__traits<_Types...>>; \
\ \
public: \ public: \
using __base_type::__base_type; \ using __base_type::__base_type; \
using __base_type::operator=; \ using __base_type::operator=; \
\ \
__move_assignment(const __move_assignment&) = default; \ __move_assignment(const __move_assignment&) = default; \
Show All 18 Lines
_LIBCPP_VARIANT_MOVE_ASSIGNMENT( _LIBCPP_VARIANT_MOVE_ASSIGNMENT(
_Trait::_Unavailable, _Trait::_Unavailable,
__move_assignment& operator=(__move_assignment&&) = delete;); __move_assignment& operator=(__move_assignment&&) = delete;);
#undef _LIBCPP_VARIANT_MOVE_ASSIGNMENT #undef _LIBCPP_VARIANT_MOVE_ASSIGNMENT
template <class _Traits, _Trait = _Traits::__copy_assignable_trait> template <class _Traits, _Trait = _Traits::__copy_assignable_trait>
class _LIBCPP_TEMPLATE_VIS __copy_assignment; class __copy_assignment;
#define _LIBCPP_VARIANT_COPY_ASSIGNMENT(copy_assignable_trait, \ #define _LIBCPP_VARIANT_COPY_ASSIGNMENT(copy_assignable_trait, \
copy_assignment) \ copy_assignment) \
template <class... _Types> \ template <class... _Types> \
class _LIBCPP_TEMPLATE_VIS __copy_assignment<__traits<_Types...>, \ class __copy_assignment<__traits<_Types...>, copy_assignable_trait> \
copy_assignable_trait> \
: public __move_assignment<__traits<_Types...>> { \ : public __move_assignment<__traits<_Types...>> { \
using __base_type = __move_assignment<__traits<_Types...>>; \ using __base_type = __move_assignment<__traits<_Types...>>; \
\ \
public: \ public: \
using __base_type::__base_type; \ using __base_type::__base_type; \
using __base_type::operator=; \ using __base_type::operator=; \
\ \
__copy_assignment(const __copy_assignment&) = default; \ __copy_assignment(const __copy_assignment&) = default; \
Show All 16 Lines
_LIBCPP_VARIANT_COPY_ASSIGNMENT( _LIBCPP_VARIANT_COPY_ASSIGNMENT(
_Trait::_Unavailable, _Trait::_Unavailable,
__copy_assignment& operator=(const __copy_assignment&) = delete;); __copy_assignment& operator=(const __copy_assignment&) = delete;);
#undef _LIBCPP_VARIANT_COPY_ASSIGNMENT #undef _LIBCPP_VARIANT_COPY_ASSIGNMENT
template <class... _Types> template <class... _Types>
class _LIBCPP_TEMPLATE_VIS __impl class __impl : public __copy_assignment<__traits<_Types...>> {
: public __copy_assignment<__traits<_Types...>> {
using __base_type = __copy_assignment<__traits<_Types...>>; using __base_type = __copy_assignment<__traits<_Types...>>;
public: public:
using __base_type::__base_type; // get in_place_index_t constructor & friends using __base_type::__base_type; // get in_place_index_t constructor & friends
_LIBCPP_HIDE_FROM_ABI __impl(__impl const&) = default; _LIBCPP_HIDE_FROM_ABI __impl(__impl const&) = default;
_LIBCPP_HIDE_FROM_ABI __impl(__impl&&) = default; _LIBCPP_HIDE_FROM_ABI __impl(__impl&&) = default;
_LIBCPP_HIDE_FROM_ABI __impl& operator=(__impl const&) = default; _LIBCPP_HIDE_FROM_ABI __impl& operator=(__impl const&) = default;
_LIBCPP_HIDE_FROM_ABI __impl& operator=(__impl&&) = default; _LIBCPP_HIDE_FROM_ABI __impl& operator=(__impl&&) = default;
▲ Show 20 Lines • Show All 124 Lines • ▼ Show 20 Lines
template <class _Tp, class... _Types> template <class _Tp, class... _Types>
using __best_match_t = using __best_match_t =
typename invoke_result_t<_MakeOverloads<_Types...>, _Tp, _Tp>::type; typename invoke_result_t<_MakeOverloads<_Types...>, _Tp, _Tp>::type;
} // namespace __variant_detail } // namespace __variant_detail
template <class... _Types> template <class... _Types>
class _LIBCPP_TEMPLATE_VIS _LIBCPP_DECLSPEC_EMPTY_BASES variant class _LIBCPP_DECLSPEC_EMPTY_BASES variant
: private __sfinae_ctor_base< : private __sfinae_ctor_base<
__all<is_copy_constructible_v<_Types>...>::value, __all<is_copy_constructible_v<_Types>...>::value,
__all<is_move_constructible_v<_Types>...>::value>, __all<is_move_constructible_v<_Types>...>::value>,
private __sfinae_assign_base< private __sfinae_assign_base<
__all<(is_copy_constructible_v<_Types> && __all<(is_copy_constructible_v<_Types> &&
is_copy_assignable_v<_Types>)...>::value, is_copy_assignable_v<_Types>)...>::value,
__all<(is_move_constructible_v<_Types> && __all<(is_move_constructible_v<_Types> &&
is_move_assignable_v<_Types>)...>::value> { is_move_assignable_v<_Types>)...>::value> {
▲ Show 20 Lines • Show All 471 Lines • ▼ Show 20 Lines
template <class... _Types> template <class... _Types>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
auto swap(variant<_Types...>& __lhs, variant<_Types...>& __rhs) auto swap(variant<_Types...>& __lhs, variant<_Types...>& __rhs)
noexcept(noexcept(__lhs.swap(__rhs))) noexcept(noexcept(__lhs.swap(__rhs)))
-> decltype( __lhs.swap(__rhs)) -> decltype( __lhs.swap(__rhs))
{ return __lhs.swap(__rhs); } { return __lhs.swap(__rhs); }
template <class... _Types> template <class... _Types>
struct _LIBCPP_TEMPLATE_VIS hash< struct hash<__enable_hash_helper<variant<_Types...>, remove_const_t<_Types>...>> {
__enable_hash_helper<variant<_Types...>, remove_const_t<_Types>...>> {
using argument_type = variant<_Types...>; using argument_type = variant<_Types...>;
using result_type = size_t; using result_type = size_t;
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
result_type operator()(const argument_type& __v) const { result_type operator()(const argument_type& __v) const {
using __variant_detail::__visitation::__variant; using __variant_detail::__visitation::__variant;
size_t __res = size_t __res =
__v.valueless_by_exception() __v.valueless_by_exception()
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

libcxx/include/vector

Show First 20 Lines • Show All 374 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, class _Allocator /* = allocator<_Tp> */> template <class _Tp, class _Allocator /* = allocator<_Tp> */>
class _LIBCPP_TEMPLATE_VIS vector class vector
{ {
private: private:
typedef allocator<_Tp> __default_allocator_type; typedef allocator<_Tp> __default_allocator_type;
public: public:
typedef vector __self; typedef vector __self;
typedef _Tp value_type; typedef _Tp value_type;
typedef _Allocator allocator_type; typedef _Allocator allocator_type;
typedef allocator_traits<allocator_type> __alloc_traits; typedef allocator_traits<allocator_type> __alloc_traits;
▲ Show 20 Lines • Show All 1,768 Lines • ▼ Show 20 Lines
template <class _Allocator> template <class _Allocator>
struct __has_storage_type<vector<bool, _Allocator> > struct __has_storage_type<vector<bool, _Allocator> >
{ {
static const bool value = true; static const bool value = true;
}; };
template <class _Allocator> template <class _Allocator>
class _LIBCPP_TEMPLATE_VIS vector<bool, _Allocator> class vector<bool, _Allocator>
{ {
public: public:
typedef vector __self; typedef vector __self;
typedef bool value_type; typedef bool value_type;
typedef _Allocator allocator_type; typedef _Allocator allocator_type;
typedef allocator_traits<allocator_type> __alloc_traits; typedef allocator_traits<allocator_type> __alloc_traits;
typedef typename __alloc_traits::size_type size_type; typedef typename __alloc_traits::size_type size_type;
typedef typename __alloc_traits::difference_type difference_type; typedef typename __alloc_traits::difference_type difference_type;
▲ Show 20 Lines • Show All 468 Lines • ▼ Show 20 Lines iterator __insert_with_size(const_iterator __position, _Iterator __first, _Sentinel __last, difference_type __n);
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_t __hash_code() const _NOEXCEPT; _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_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 hash<vector>;
}; };
template <class _Allocator> template <class _Allocator>
_LIBCPP_CONSTEXPR_SINCE_CXX20 void _LIBCPP_CONSTEXPR_SINCE_CXX20 void
vector<bool, _Allocator>::__vdeallocate() _NOEXCEPT vector<bool, _Allocator>::__vdeallocate() _NOEXCEPT
{ {
if (this->__begin_ != nullptr) if (this->__begin_ != nullptr)
{ {
▲ Show 20 Lines • Show All 760 Lines • ▼ Show 20 Linesvector<bool, _Allocator>::__hash_code() const _NOEXCEPT
{ {
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 hash<vector<bool, _Allocator> > : public __unary_function<vector<bool, _Allocator>, size_t>
: public __unary_function<vector<bool, _Allocator>, size_t>
{ {
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_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_SINCE_CXX20 _LIBCPP_CONSTEXPR_SINCE_CXX20
▲ Show 20 Lines • Show All 95 Lines • ▼ Show 20 Lines
#endif #endif
#endif // _LIBCPP_STD_VER >= 20 #endif // _LIBCPP_STD_VER >= 20
#if _LIBCPP_STD_VER >= 23 #if _LIBCPP_STD_VER >= 23
template <class _Tp, class CharT> template <class _Tp, class CharT>
// Since is-vector-bool-reference is only used once it's inlined here. // Since is-vector-bool-reference is only used once it's inlined here.
requires same_as<typename _Tp::__container, vector<bool, typename _Tp::__container::allocator_type>> requires same_as<typename _Tp::__container, vector<bool, typename _Tp::__container::allocator_type>>
struct _LIBCPP_TEMPLATE_VIS formatter<_Tp, CharT> { struct formatter<_Tp, CharT> {
private: private:
formatter<bool, CharT> __underlying_; formatter<bool, CharT> __underlying_;
public: public:
template <class _ParseContext> template <class _ParseContext>
_LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) { _LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) {
return __underlying_.parse(__ctx); return __underlying_.parse(__ctx);
} }
Show All 32 Lines

libcxx/src/legacy_debug_handler.cpp

Show All 11 Lines
#include <string> #include <string>
// This file defines the legacy default debug handler and related mechanisms // This file defines the legacy default debug handler and related mechanisms
// to set it. This is for backwards ABI compatibility with code that has been // to set it. This is for backwards ABI compatibility with code that has been
// using this debug handler previously. // using this debug handler previously.
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
struct _LIBCPP_TEMPLATE_VIS __libcpp_debug_info { struct __libcpp_debug_info {
_LIBCPP_EXPORTED_FROM_ABI string what() const; _LIBCPP_EXPORTED_FROM_ABI string what() const;
const char* __file_; const char* __file_;
int __line_; int __line_;
const char* __pred_; const char* __pred_;
const char* __msg_; const char* __msg_;
}; };
Show All 26 Lines