Coverage Report

Created: 2020-02-25 14:32

/Users/buildslave/jenkins/workspace/coverage/llvm-project/libcxx/include/__tuple
Line
Count
Source (jump to first uncovered line)
1
// -*- C++ -*-
2
//===----------------------------------------------------------------------===//
3
//
4
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
5
// See https://llvm.org/LICENSE.txt for license information.
6
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7
//
8
//===----------------------------------------------------------------------===//
9
10
#ifndef _LIBCPP___TUPLE
11
#define _LIBCPP___TUPLE
12
13
#include <__config>
14
#include <cstddef>
15
#include <type_traits>
16
17
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
18
#pragma GCC system_header
19
#endif
20
21
22
_LIBCPP_BEGIN_NAMESPACE_STD
23
24
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS tuple_size;
25
26
#if !defined(_LIBCPP_CXX03_LANG)
27
template <class _Tp, class...>
28
using __enable_if_tuple_size_imp = _Tp;
29
30
template <class _Tp>
31
struct _LIBCPP_TEMPLATE_VIS tuple_size<__enable_if_tuple_size_imp<
32
    const _Tp,
33
    typename enable_if<!is_volatile<_Tp>::value>::type,
34
    integral_constant<size_t, sizeof(tuple_size<_Tp>)>>>
35
    : public integral_constant<size_t, tuple_size<_Tp>::value> {};
36
37
template <class _Tp>
38
struct _LIBCPP_TEMPLATE_VIS tuple_size<__enable_if_tuple_size_imp<
39
    volatile _Tp,
40
    typename enable_if<!is_const<_Tp>::value>::type,
41
    integral_constant<size_t, sizeof(tuple_size<_Tp>)>>>
42
    : public integral_constant<size_t, tuple_size<_Tp>::value> {};
43
44
template <class _Tp>
45
struct _LIBCPP_TEMPLATE_VIS tuple_size<__enable_if_tuple_size_imp<
46
    const volatile _Tp,
47
    integral_constant<size_t, sizeof(tuple_size<_Tp>)>>>
48
    : public integral_constant<size_t, tuple_size<_Tp>::value> {};
49
50
#else
51
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS tuple_size<const _Tp> : public tuple_size<_Tp> {};
52
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS tuple_size<volatile _Tp> : public tuple_size<_Tp> {};
53
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS tuple_size<const volatile _Tp> : public tuple_size<_Tp> {};
54
#endif
55
56
template <size_t _Ip, class _Tp> struct _LIBCPP_TEMPLATE_VIS tuple_element;
57
58
template <size_t _Ip, class _Tp>
59
struct _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, const _Tp>
60
{
61
    typedef _LIBCPP_NODEBUG_TYPE typename add_const<typename tuple_element<_Ip, _Tp>::type>::type type;
62
};
63
64
template <size_t _Ip, class _Tp>
65
struct _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, volatile _Tp>
66
{
67
    typedef _LIBCPP_NODEBUG_TYPE typename add_volatile<typename tuple_element<_Ip, _Tp>::type>::type type;
68
};
69
70
template <size_t _Ip, class _Tp>
71
struct _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, const volatile _Tp>
72
{
73
    typedef _LIBCPP_NODEBUG_TYPE typename add_cv<typename tuple_element<_Ip, _Tp>::type>::type type;
74
};
75
76
template <class _Tp> struct __tuple_like : false_type {};
77
78
template <class _Tp> struct __tuple_like<const _Tp> : public __tuple_like<_Tp> {};
79
template <class _Tp> struct __tuple_like<volatile _Tp> : public __tuple_like<_Tp> {};
80
template <class _Tp> struct __tuple_like<const volatile _Tp> : public __tuple_like<_Tp> {};
81
82
// tuple specializations
83
84
#ifndef _LIBCPP_CXX03_LANG
85
86
template <size_t...> struct __tuple_indices {};
87
88
template <class _IdxType, _IdxType... _Values>
89
struct __integer_sequence {
90
  template <template <class _OIdxType, _OIdxType...> class _ToIndexSeq, class _ToIndexType>
91
  using __convert = _ToIndexSeq<_ToIndexType, _Values...>;
92
93
  template <size_t _Sp>
94
  using __to_tuple_indices = __tuple_indices<(_Values + _Sp)...>;
95
};
96
97
#if !__has_builtin(__make_integer_seq) || defined(_LIBCPP_TESTING_FALLBACK_MAKE_INTEGER_SEQUENCE)
98
namespace __detail {
99
100
template<typename _Tp, size_t ..._Extra> struct __repeat;
101
template<typename _Tp, _Tp ..._Np, size_t ..._Extra> struct __repeat<__integer_sequence<_Tp, _Np...>, _Extra...> {
102
  typedef _LIBCPP_NODEBUG_TYPE __integer_sequence<_Tp,
103
                           _Np...,
104
                           sizeof...(_Np) + _Np...,
105
                           2 * sizeof...(_Np) + _Np...,
106
                           3 * sizeof...(_Np) + _Np...,
107
                           4 * sizeof...(_Np) + _Np...,
108
                           5 * sizeof...(_Np) + _Np...,
109
                           6 * sizeof...(_Np) + _Np...,
110
                           7 * sizeof...(_Np) + _Np...,
111
                           _Extra...> type;
112
};
113
114
template<size_t _Np> struct __parity;
115
template<size_t _Np> struct __make : __parity<_Np % 8>::template __pmake<_Np> {};
116
117
template<> struct __make<0> { typedef __integer_sequence<size_t> type; };
118
template<> struct __make<1> { typedef __integer_sequence<size_t, 0> type; };
119
template<> struct __make<2> { typedef __integer_sequence<size_t, 0, 1> type; };
120
template<> struct __make<3> { typedef __integer_sequence<size_t, 0, 1, 2> type; };
121
template<> struct __make<4> { typedef __integer_sequence<size_t, 0, 1, 2, 3> type; };
122
template<> struct __make<5> { typedef __integer_sequence<size_t, 0, 1, 2, 3, 4> type; };
123
template<> struct __make<6> { typedef __integer_sequence<size_t, 0, 1, 2, 3, 4, 5> type; };
124
template<> struct __make<7> { typedef __integer_sequence<size_t, 0, 1, 2, 3, 4, 5, 6> type; };
125
126
template<> struct __parity<0> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type> {}; };
127
template<> struct __parity<1> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type, _Np - 1> {}; };
128
template<> struct __parity<2> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type, _Np - 2, _Np - 1> {}; };
129
template<> struct __parity<3> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type, _Np - 3, _Np - 2, _Np - 1> {}; };
130
template<> struct __parity<4> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type, _Np - 4, _Np - 3, _Np - 2, _Np - 1> {}; };
131
template<> struct __parity<5> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type, _Np - 5, _Np - 4, _Np - 3, _Np - 2, _Np - 1> {}; };
132
template<> struct __parity<6> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type, _Np - 6, _Np - 5, _Np - 4, _Np - 3, _Np - 2, _Np - 1> {}; };
133
template<> struct __parity<7> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type, _Np - 7, _Np - 6, _Np - 5, _Np - 4, _Np - 3, _Np - 2, _Np - 1> {}; };
134
135
} // namespace detail
136
137
#endif  // !__has_builtin(__make_integer_seq) || defined(_LIBCPP_TESTING_FALLBACK_MAKE_INTEGER_SEQUENCE)
138
139
#if __has_builtin(__make_integer_seq)
140
template <size_t _Ep, size_t _Sp>
141
using __make_indices_imp =
142
    typename __make_integer_seq<__integer_sequence, size_t, _Ep - _Sp>::template
143
    __to_tuple_indices<_Sp>;
144
#else
145
template <size_t _Ep, size_t _Sp>
146
using __make_indices_imp =
147
    typename __detail::__make<_Ep - _Sp>::type::template __to_tuple_indices<_Sp>;
148
149
#endif
150
151
template <size_t _Ep, size_t _Sp = 0>
152
struct __make_tuple_indices
153
{
154
    static_assert(_Sp <= _Ep, "__make_tuple_indices input error");
155
    typedef __make_indices_imp<_Ep, _Sp> type;
156
};
157
158
159
template <class ..._Tp> class _LIBCPP_TEMPLATE_VIS tuple;
160
161
template <class... _Tp> struct __tuple_like<tuple<_Tp...> > : true_type {};
162
163
template <class ..._Tp>
164
struct _LIBCPP_TEMPLATE_VIS tuple_size<tuple<_Tp...> >
165
    : public integral_constant<size_t, sizeof...(_Tp)>
166
{
167
};
168
169
template <size_t _Ip, class ..._Tp>
170
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
171
typename tuple_element<_Ip, tuple<_Tp...> >::type&
172
get(tuple<_Tp...>&) _NOEXCEPT;
173
174
template <size_t _Ip, class ..._Tp>
175
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
176
const typename tuple_element<_Ip, tuple<_Tp...> >::type&
177
get(const tuple<_Tp...>&) _NOEXCEPT;
178
179
template <size_t _Ip, class ..._Tp>
180
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
181
typename tuple_element<_Ip, tuple<_Tp...> >::type&&
182
get(tuple<_Tp...>&&) _NOEXCEPT;
183
184
template <size_t _Ip, class ..._Tp>
185
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
186
const typename tuple_element<_Ip, tuple<_Tp...> >::type&&
187
get(const tuple<_Tp...>&&) _NOEXCEPT;
188
189
#endif // !defined(_LIBCPP_CXX03_LANG)
190
191
// pair specializations
192
193
template <class _T1, class _T2> struct __tuple_like<pair<_T1, _T2> > : true_type {};
194
195
template <size_t _Ip, class _T1, class _T2>
196
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
197
typename tuple_element<_Ip, pair<_T1, _T2> >::type&
198
get(pair<_T1, _T2>&) _NOEXCEPT;
199
200
template <size_t _Ip, class _T1, class _T2>
201
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
202
const typename tuple_element<_Ip, pair<_T1, _T2> >::type&
203
get(const pair<_T1, _T2>&) _NOEXCEPT;
204
205
#ifndef _LIBCPP_CXX03_LANG
206
template <size_t _Ip, class _T1, class _T2>
207
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
208
typename tuple_element<_Ip, pair<_T1, _T2> >::type&&
209
get(pair<_T1, _T2>&&) _NOEXCEPT;
210
211
template <size_t _Ip, class _T1, class _T2>
212
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
213
const typename tuple_element<_Ip, pair<_T1, _T2> >::type&&
214
get(const pair<_T1, _T2>&&) _NOEXCEPT;
215
#endif
216
217
// array specializations
218
219
template <class _Tp, size_t _Size> struct _LIBCPP_TEMPLATE_VIS array;
220
221
template <class _Tp, size_t _Size> struct __tuple_like<array<_Tp, _Size> > : true_type {};
222
223
template <size_t _Ip, class _Tp, size_t _Size>
224
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
225
_Tp&
226
get(array<_Tp, _Size>&) _NOEXCEPT;
227
228
template <size_t _Ip, class _Tp, size_t _Size>
229
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
230
const _Tp&
231
get(const array<_Tp, _Size>&) _NOEXCEPT;
232
233
#ifndef _LIBCPP_CXX03_LANG
234
template <size_t _Ip, class _Tp, size_t _Size>
235
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
236
_Tp&&
237
get(array<_Tp, _Size>&&) _NOEXCEPT;
238
239
template <size_t _Ip, class _Tp, size_t _Size>
240
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
241
const _Tp&&
242
get(const array<_Tp, _Size>&&) _NOEXCEPT;
243
#endif
244
245
#ifndef _LIBCPP_CXX03_LANG
246
247
// __tuple_types
248
249
template <class ..._Tp> struct __tuple_types {};
250
251
#if !__has_builtin(__type_pack_element)
252
253
namespace __indexer_detail {
254
255
template <size_t _Idx, class _Tp>
256
struct __indexed { using type _LIBCPP_NODEBUG_TYPE = _Tp; };
257
258
template <class _Types, class _Indexes> struct __indexer;
259
260
template <class ..._Types, size_t ..._Idx>
261
struct __indexer<__tuple_types<_Types...>, __tuple_indices<_Idx...>>
262
    : __indexed<_Idx, _Types>...
263
{};
264
265
template <size_t _Idx, class _Tp>
266
__indexed<_Idx, _Tp> __at_index(__indexed<_Idx, _Tp> const&);
267
268
} // namespace __indexer_detail
269
270
template <size_t _Idx, class ..._Types>
271
using __type_pack_element _LIBCPP_NODEBUG_TYPE = typename decltype(
272
    __indexer_detail::__at_index<_Idx>(
273
        __indexer_detail::__indexer<
274
            __tuple_types<_Types...>,
275
            typename __make_tuple_indices<sizeof...(_Types)>::type
276
        >{})
277
  )::type;
278
#endif
279
280
template <size_t _Ip, class ..._Types>
281
struct _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, __tuple_types<_Types...>>
282
{
283
    static_assert(_Ip < sizeof...(_Types), "tuple_element index out of range");
284
    typedef _LIBCPP_NODEBUG_TYPE __type_pack_element<_Ip, _Types...> type;
285
};
286
287
288
template <class ..._Tp>
289
struct _LIBCPP_TEMPLATE_VIS tuple_size<__tuple_types<_Tp...> >
290
    : public integral_constant<size_t, sizeof...(_Tp)>
291
{
292
};
293
294
template <class... _Tp> struct __tuple_like<__tuple_types<_Tp...> > : true_type {};
295
296
template <bool _ApplyLV, bool _ApplyConst, bool _ApplyVolatile>
297
struct __apply_cv_mf;
298
template <>
299
struct __apply_cv_mf<false, false, false> {
300
  template <class _Tp> using __apply = _Tp;
301
};
302
template <>
303
struct __apply_cv_mf<false, true, false> {
304
  template <class _Tp> using __apply _LIBCPP_NODEBUG_TYPE  = const _Tp;
305
};
306
template <>
307
struct __apply_cv_mf<false, false, true> {
308
  template <class _Tp> using __apply _LIBCPP_NODEBUG_TYPE  = volatile _Tp;
309
};
310
template <>
311
struct __apply_cv_mf<false, true, true> {
312
  template <class _Tp> using __apply _LIBCPP_NODEBUG_TYPE  = const volatile _Tp;
313
};
314
template <>
315
struct __apply_cv_mf<true, false, false> {
316
  template <class _Tp> using __apply _LIBCPP_NODEBUG_TYPE  = _Tp&;
317
};
318
template <>
319
struct __apply_cv_mf<true, true, false> {
320
  template <class _Tp> using __apply _LIBCPP_NODEBUG_TYPE  = const _Tp&;
321
};
322
template <>
323
struct __apply_cv_mf<true, false, true> {
324
  template <class _Tp> using __apply _LIBCPP_NODEBUG_TYPE  = volatile _Tp&;
325
};
326
template <>
327
struct __apply_cv_mf<true, true, true> {
328
  template <class _Tp> using __apply _LIBCPP_NODEBUG_TYPE = const volatile _Tp&;
329
};
330
template <class _Tp, class _RawTp = typename remove_reference<_Tp>::type>
331
using __apply_cv_t _LIBCPP_NODEBUG_TYPE  = __apply_cv_mf<
332
    is_lvalue_reference<_Tp>::value,
333
    is_const<_RawTp>::value,
334
    is_volatile<_RawTp>::value>;
335
336
// __make_tuple_types
337
338
// __make_tuple_types<_Tuple<_Types...>, _Ep, _Sp>::type is a
339
// __tuple_types<_Types...> using only those _Types in the range [_Sp, _Ep).
340
// _Sp defaults to 0 and _Ep defaults to tuple_size<_Tuple>.  If _Tuple is a
341
// lvalue_reference type, then __tuple_types<_Types&...> is the result.
342
343
template <class _TupleTypes, class _TupleIndices>
344
struct __make_tuple_types_flat;
345
346
template <template <class...> class _Tuple, class ..._Types, size_t ..._Idx>
347
struct __make_tuple_types_flat<_Tuple<_Types...>, __tuple_indices<_Idx...>> {
348
  // Specialization for pair, tuple, and __tuple_types
349
  template <class _Tp, class _ApplyFn = __apply_cv_t<_Tp>>
350
  using __apply_quals _LIBCPP_NODEBUG_TYPE = __tuple_types<
351
      typename _ApplyFn::template __apply<__type_pack_element<_Idx, _Types...>>...
352
    >;
353
};
354
355
template <class _Vt, size_t _Np, size_t ..._Idx>
356
struct __make_tuple_types_flat<array<_Vt, _Np>, __tuple_indices<_Idx...>> {
357
  template <size_t>
358
  using __value_type = _Vt;
359
  template <class _Tp, class _ApplyFn = __apply_cv_t<_Tp>>
360
  using __apply_quals = __tuple_types<
361
      typename _ApplyFn::template __apply<__value_type<_Idx>>...
362
    >;
363
};
364
365
template <class _Tp, size_t _Ep = tuple_size<typename remove_reference<_Tp>::type>::value,
366
          size_t _Sp = 0,
367
          bool _SameSize = (_Ep == tuple_size<typename remove_reference<_Tp>::type>::value)>
368
struct __make_tuple_types
369
{
370
    static_assert(_Sp <= _Ep, "__make_tuple_types input error");
371
    using _RawTp = typename remove_cv<typename remove_reference<_Tp>::type>::type;
372
    using _Maker = __make_tuple_types_flat<_RawTp, typename __make_tuple_indices<_Ep, _Sp>::type>;
373
    using type = typename _Maker::template __apply_quals<_Tp>;
374
};
375
376
template <class ..._Types, size_t _Ep>
377
struct __make_tuple_types<tuple<_Types...>, _Ep, 0, true> {
378
  typedef _LIBCPP_NODEBUG_TYPE __tuple_types<_Types...> type;
379
};
380
381
template <class ..._Types, size_t _Ep>
382
struct __make_tuple_types<__tuple_types<_Types...>, _Ep, 0, true> {
383
  typedef _LIBCPP_NODEBUG_TYPE __tuple_types<_Types...> type;
384
};
385
386
template <bool ..._Preds>
387
struct __all_dummy;
388
389
template <bool ..._Pred>
390
using __all = _IsSame<__all_dummy<_Pred...>, __all_dummy<((void)_Pred, true)...>>;
391
392
struct __tuple_sfinae_base {
393
  template <template <class, class...> class _Trait,
394
            class ..._LArgs, class ..._RArgs>
395
  static auto __do_test(__tuple_types<_LArgs...>, __tuple_types<_RArgs...>)
396
    -> __all<typename enable_if<_Trait<_LArgs, _RArgs>::value, bool>::type{true}...>;
397
  template <template <class...> class>
398
  static auto __do_test(...) -> false_type;
399
400
  template <class _FromArgs, class _ToArgs>
401
  using __constructible = decltype(__do_test<is_constructible>(_ToArgs{}, _FromArgs{}));
402
  template <class _FromArgs, class _ToArgs>
403
  using __convertible = decltype(__do_test<is_convertible>(_FromArgs{}, _ToArgs{}));
404
  template <class _FromArgs, class _ToArgs>
405
  using __assignable = decltype(__do_test<is_assignable>(_ToArgs{}, _FromArgs{}));
406
};
407
408
// __tuple_convertible
409
410
template <class _Tp, class _Up, bool = __tuple_like<typename remove_reference<_Tp>::type>::value,
411
                                bool = __tuple_like<_Up>::value>
412
struct __tuple_convertible
413
    : public false_type {};
414
415
template <class _Tp, class _Up>
416
struct __tuple_convertible<_Tp, _Up, true, true>
417
    : public __tuple_sfinae_base::__convertible<
418
      typename __make_tuple_types<_Tp>::type
419
    , typename __make_tuple_types<_Up>::type
420
    >
421
{};
422
423
// __tuple_constructible
424
425
template <class _Tp, class _Up, bool = __tuple_like<typename remove_reference<_Tp>::type>::value,
426
                                bool = __tuple_like<_Up>::value>
427
struct __tuple_constructible
428
    : public false_type {};
429
430
template <class _Tp, class _Up>
431
struct __tuple_constructible<_Tp, _Up, true, true>
432
    : public __tuple_sfinae_base::__constructible<
433
      typename __make_tuple_types<_Tp>::type
434
    , typename __make_tuple_types<_Up>::type
435
    >
436
{};
437
438
// __tuple_assignable
439
440
template <class _Tp, class _Up, bool = __tuple_like<typename remove_reference<_Tp>::type>::value,
441
                                bool = __tuple_like<_Up>::value>
442
struct __tuple_assignable
443
    : public false_type {};
444
445
template <class _Tp, class _Up>
446
struct __tuple_assignable<_Tp, _Up, true, true>
447
    : public __tuple_sfinae_base::__assignable<
448
      typename __make_tuple_types<_Tp>::type
449
    , typename __make_tuple_types<_Up&>::type
450
    >
451
{};
452
453
454
template <size_t _Ip, class ..._Tp>
455
struct _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, tuple<_Tp...> >
456
{
457
    typedef _LIBCPP_NODEBUG_TYPE typename tuple_element<_Ip, __tuple_types<_Tp...> >::type type;
458
};
459
460
#if _LIBCPP_STD_VER > 11
461
template <size_t _Ip, class ..._Tp>
462
using tuple_element_t _LIBCPP_NODEBUG_TYPE  = typename tuple_element <_Ip, _Tp...>::type;
463
#endif
464
465
template <bool _IsTuple, class _SizeTrait, size_t _Expected>
466
struct __tuple_like_with_size_imp : false_type {};
467
468
template <class _SizeTrait, size_t _Expected>
469
struct __tuple_like_with_size_imp<true, _SizeTrait, _Expected>
470
    : integral_constant<bool, _SizeTrait::value == _Expected> {};
471
472
template <class _Tuple, size_t _ExpectedSize,
473
          class _RawTuple = typename __uncvref<_Tuple>::type>
474
using __tuple_like_with_size _LIBCPP_NODEBUG_TYPE = __tuple_like_with_size_imp<
475
                                   __tuple_like<_RawTuple>::value,
476
                                   tuple_size<_RawTuple>, _ExpectedSize
477
                              >;
478
479
struct _LIBCPP_TYPE_VIS __check_tuple_constructor_fail {
480
481
0
    static constexpr bool __enable_explicit_default() { return false; }
482
0
    static constexpr bool __enable_implicit_default() { return false; }
483
    template <class ...>
484
0
    static constexpr bool __enable_explicit() { return false; }
Unexecuted instantiation: locale.cpp:bool std::__1::__check_tuple_constructor_fail::__enable_explicit<std::__1::(anonymous namespace)::__fake_bind>()
Unexecuted instantiation: locale.cpp:bool std::__1::__check_tuple_constructor_fail::__enable_explicit<std::__1::(anonymous namespace)::__fake_bind const&>()
Unexecuted instantiation: bool std::__1::__check_tuple_constructor_fail::__enable_explicit<std::__1::pair<std::__1::condition_variable*, std::__1::mutex*> >()
Unexecuted instantiation: bool std::__1::__check_tuple_constructor_fail::__enable_explicit<std::__1::allocator<std::__1::__fs::filesystem::filesystem_error::_Storage>&>()
Unexecuted instantiation: bool std::__1::__check_tuple_constructor_fail::__enable_explicit<std::__1::allocator<std::__1::__fs::filesystem::filesystem_error::_Storage> const&>()
Unexecuted instantiation: bool std::__1::__check_tuple_constructor_fail::__enable_explicit<>()
Unexecuted instantiation: bool std::__1::__check_tuple_constructor_fail::__enable_explicit<std::__1::pair<std::__1::basic_string_view<char, std::__1::char_traits<char> >, std::__1::__fs::filesystem::PathPartKind> >()
Unexecuted instantiation: bool std::__1::__check_tuple_constructor_fail::__enable_explicit<std::__1::allocator<std::__1::__fs::filesystem::__dir_stream>&>()
Unexecuted instantiation: bool std::__1::__check_tuple_constructor_fail::__enable_explicit<std::__1::allocator<std::__1::__fs::filesystem::__dir_stream> const&>()
Unexecuted instantiation: bool std::__1::__check_tuple_constructor_fail::__enable_explicit<std::__1::error_code&>()
485
    template <class ...>
486
0
    static constexpr bool __enable_implicit() { return false; }
Unexecuted instantiation: bool std::__1::__check_tuple_constructor_fail::__enable_implicit<std::__1::pair<unsigned long, unsigned long> >()
Unexecuted instantiation: locale.cpp:bool std::__1::__check_tuple_constructor_fail::__enable_implicit<std::__1::(anonymous namespace)::__fake_bind>()
Unexecuted instantiation: locale.cpp:bool std::__1::__check_tuple_constructor_fail::__enable_implicit<std::__1::(anonymous namespace)::__fake_bind const&>()
Unexecuted instantiation: bool std::__1::__check_tuple_constructor_fail::__enable_implicit<std::__1::pair<std::__1::condition_variable*, std::__1::mutex*> >()
Unexecuted instantiation: bool std::__1::__check_tuple_constructor_fail::__enable_implicit<std::__1::pair<std::__1::basic_string_view<char, std::__1::char_traits<char> >, std::__1::basic_string_view<char, std::__1::char_traits<char> > > >()
Unexecuted instantiation: bool std::__1::__check_tuple_constructor_fail::__enable_implicit<std::__1::allocator<std::__1::__fs::filesystem::filesystem_error::_Storage>&>()
Unexecuted instantiation: bool std::__1::__check_tuple_constructor_fail::__enable_implicit<std::__1::allocator<std::__1::__fs::filesystem::filesystem_error::_Storage> const&>()
Unexecuted instantiation: bool std::__1::__check_tuple_constructor_fail::__enable_implicit<std::__1::tuple<std::__1::allocator<std::__1::__fs::filesystem::filesystem_error::_Storage>&> >()
Unexecuted instantiation: bool std::__1::__check_tuple_constructor_fail::__enable_implicit<std::__1::tuple<std::__1::allocator<std::__1::__fs::filesystem::filesystem_error::_Storage>&> const&>()
Unexecuted instantiation: bool std::__1::__check_tuple_constructor_fail::__enable_implicit<std::__1::__fs::filesystem::path, std::__1::__fs::filesystem::path>()
Unexecuted instantiation: bool std::__1::__check_tuple_constructor_fail::__enable_implicit<>()
Unexecuted instantiation: bool std::__1::__check_tuple_constructor_fail::__enable_implicit<std::__1::tuple<std::__1::__fs::filesystem::path&&, std::__1::__fs::filesystem::path&&> >()
Unexecuted instantiation: bool std::__1::__check_tuple_constructor_fail::__enable_implicit<std::__1::tuple<std::__1::__fs::filesystem::path&&, std::__1::__fs::filesystem::path&&> const&>()
Unexecuted instantiation: bool std::__1::__check_tuple_constructor_fail::__enable_implicit<std::__1::__fs::filesystem::path const&, std::__1::__fs::filesystem::path>()
Unexecuted instantiation: bool std::__1::__check_tuple_constructor_fail::__enable_implicit<std::__1::tuple<std::__1::__fs::filesystem::path const&, std::__1::__fs::filesystem::path&&> >()
Unexecuted instantiation: bool std::__1::__check_tuple_constructor_fail::__enable_implicit<std::__1::tuple<std::__1::__fs::filesystem::path const&, std::__1::__fs::filesystem::path&&> const&>()
Unexecuted instantiation: bool std::__1::__check_tuple_constructor_fail::__enable_implicit<std::__1::__fs::filesystem::path const&, std::__1::__fs::filesystem::path const&>()
Unexecuted instantiation: bool std::__1::__check_tuple_constructor_fail::__enable_implicit<std::__1::tuple<std::__1::__fs::filesystem::path const&, std::__1::__fs::filesystem::path const&> >()
Unexecuted instantiation: bool std::__1::__check_tuple_constructor_fail::__enable_implicit<std::__1::tuple<std::__1::__fs::filesystem::path const&, std::__1::__fs::filesystem::path const&> const&>()
Unexecuted instantiation: bool std::__1::__check_tuple_constructor_fail::__enable_implicit<std::__1::pair<std::__1::basic_string_view<char, std::__1::char_traits<char> >, std::__1::__fs::filesystem::PathPartKind> >()
Unexecuted instantiation: bool std::__1::__check_tuple_constructor_fail::__enable_implicit<std::__1::pair<std::__1::basic_string_view<char, std::__1::char_traits<char> >, std::__1::__fs::filesystem::file_type> >()
Unexecuted instantiation: bool std::__1::__check_tuple_constructor_fail::__enable_implicit<std::__1::allocator<std::__1::__fs::filesystem::__dir_stream>&>()
Unexecuted instantiation: bool std::__1::__check_tuple_constructor_fail::__enable_implicit<std::__1::allocator<std::__1::__fs::filesystem::__dir_stream> const&>()
Unexecuted instantiation: bool std::__1::__check_tuple_constructor_fail::__enable_implicit<std::__1::tuple<std::__1::allocator<std::__1::__fs::filesystem::__dir_stream>&> >()
Unexecuted instantiation: bool std::__1::__check_tuple_constructor_fail::__enable_implicit<std::__1::tuple<std::__1::allocator<std::__1::__fs::filesystem::__dir_stream>&> const&>()
Unexecuted instantiation: bool std::__1::__check_tuple_constructor_fail::__enable_implicit<std::__1::__fs::filesystem::path const&, std::__1::__fs::filesystem::directory_options&, std::__1::error_code&>()
Unexecuted instantiation: bool std::__1::__check_tuple_constructor_fail::__enable_implicit<std::__1::error_code&>()
Unexecuted instantiation: bool std::__1::__check_tuple_constructor_fail::__enable_implicit<std::__1::tuple<std::__1::__fs::filesystem::path const&, std::__1::__fs::filesystem::directory_options&, std::__1::error_code&> >()
Unexecuted instantiation: bool std::__1::__check_tuple_constructor_fail::__enable_implicit<std::__1::tuple<std::__1::__fs::filesystem::path const&, std::__1::__fs::filesystem::directory_options&, std::__1::error_code&> const&>()
487
    template <class ...>
488
0
    static constexpr bool __enable_assign() { return false; }
489
};
490
#endif // !defined(_LIBCPP_CXX03_LANG)
491
492
#if _LIBCPP_STD_VER > 14
493
494
template <bool _CanCopy, bool _CanMove>
495
struct __sfinae_ctor_base {};
496
template <>
497
struct __sfinae_ctor_base<false, false> {
498
  __sfinae_ctor_base() = default;
499
  __sfinae_ctor_base(__sfinae_ctor_base const&) = delete;
500
  __sfinae_ctor_base(__sfinae_ctor_base &&) = delete;
501
  __sfinae_ctor_base& operator=(__sfinae_ctor_base const&) = default;
502
  __sfinae_ctor_base& operator=(__sfinae_ctor_base&&) = default;
503
};
504
template <>
505
struct __sfinae_ctor_base<true, false> {
506
  __sfinae_ctor_base() = default;
507
  __sfinae_ctor_base(__sfinae_ctor_base const&) = default;
508
  __sfinae_ctor_base(__sfinae_ctor_base &&) = delete;
509
  __sfinae_ctor_base& operator=(__sfinae_ctor_base const&) = default;
510
  __sfinae_ctor_base& operator=(__sfinae_ctor_base&&) = default;
511
};
512
template <>
513
struct __sfinae_ctor_base<false, true> {
514
  __sfinae_ctor_base() = default;
515
  __sfinae_ctor_base(__sfinae_ctor_base const&) = delete;
516
  __sfinae_ctor_base(__sfinae_ctor_base &&) = default;
517
  __sfinae_ctor_base& operator=(__sfinae_ctor_base const&) = default;
518
  __sfinae_ctor_base& operator=(__sfinae_ctor_base&&) = default;
519
};
520
521
template <bool _CanCopy, bool _CanMove>
522
struct __sfinae_assign_base {};
523
template <>
524
struct __sfinae_assign_base<false, false> {
525
  __sfinae_assign_base() = default;
526
  __sfinae_assign_base(__sfinae_assign_base const&) = default;
527
  __sfinae_assign_base(__sfinae_assign_base &&) = default;
528
  __sfinae_assign_base& operator=(__sfinae_assign_base const&) = delete;
529
  __sfinae_assign_base& operator=(__sfinae_assign_base&&) = delete;
530
};
531
template <>
532
struct __sfinae_assign_base<true, false> {
533
  __sfinae_assign_base() = default;
534
  __sfinae_assign_base(__sfinae_assign_base const&) = default;
535
  __sfinae_assign_base(__sfinae_assign_base &&) = default;
536
  __sfinae_assign_base& operator=(__sfinae_assign_base const&) = default;
537
  __sfinae_assign_base& operator=(__sfinae_assign_base&&) = delete;
538
};
539
template <>
540
struct __sfinae_assign_base<false, true> {
541
  __sfinae_assign_base() = default;
542
  __sfinae_assign_base(__sfinae_assign_base const&) = default;
543
  __sfinae_assign_base(__sfinae_assign_base &&) = default;
544
  __sfinae_assign_base& operator=(__sfinae_assign_base const&) = delete;
545
  __sfinae_assign_base& operator=(__sfinae_assign_base&&) = default;
546
};
547
#endif // _LIBCPP_STD_VER > 14
548
549
_LIBCPP_END_NAMESPACE_STD
550
551
#endif  // _LIBCPP___TUPLE