1// -*- C++ -*-
2//===------------------------ functional ----------------------------------===//
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_FUNCTIONAL
11#define _LIBCPP_FUNCTIONAL
12
13/*
14 functional synopsis
15
16namespace std
17{
18
19template <class Arg, class Result>
20struct unary_function
21{
22 typedef Arg argument_type;
23 typedef Result result_type;
24};
25
26template <class Arg1, class Arg2, class Result>
27struct binary_function
28{
29 typedef Arg1 first_argument_type;
30 typedef Arg2 second_argument_type;
31 typedef Result result_type;
32};
33
34template <class T>
35class reference_wrapper
36 : public unary_function<T1, R> // if wrapping a unary functor
37 : public binary_function<T1, T2, R> // if wraping a binary functor
38{
39public:
40 // types
41 typedef T type;
42 typedef see below result_type; // Not always defined
43
44 // construct/copy/destroy
45 reference_wrapper(T&) noexcept;
46 reference_wrapper(T&&) = delete; // do not bind to temps
47 reference_wrapper(const reference_wrapper<T>& x) noexcept;
48
49 // assignment
50 reference_wrapper& operator=(const reference_wrapper<T>& x) noexcept;
51
52 // access
53 operator T& () const noexcept;
54 T& get() const noexcept;
55
56 // invoke
57 template <class... ArgTypes>
58 typename result_of<T&(ArgTypes&&...)>::type
59 operator() (ArgTypes&&...) const;
60};
61
62template <class T> reference_wrapper<T> ref(T& t) noexcept;
63template <class T> void ref(const T&& t) = delete;
64template <class T> reference_wrapper<T> ref(reference_wrapper<T>t) noexcept;
65
66template <class T> reference_wrapper<const T> cref(const T& t) noexcept;
67template <class T> void cref(const T&& t) = delete;
68template <class T> reference_wrapper<const T> cref(reference_wrapper<T> t) noexcept;
69
70template <class T> struct unwrap_reference; // since C++20
71template <class T> struct unwrap_ref_decay : unwrap_reference<decay_t<T>> { }; // since C++20
72template <class T> using unwrap_reference_t = typename unwrap_reference<T>::type; // since C++20
73template <class T> using unwrap_ref_decay_t = typename unwrap_ref_decay<T>::type; // since C++20
74
75template <class T> // <class T=void> in C++14
76struct plus : binary_function<T, T, T>
77{
78 T operator()(const T& x, const T& y) const;
79};
80
81template <class T> // <class T=void> in C++14
82struct minus : binary_function<T, T, T>
83{
84 T operator()(const T& x, const T& y) const;
85};
86
87template <class T> // <class T=void> in C++14
88struct multiplies : binary_function<T, T, T>
89{
90 T operator()(const T& x, const T& y) const;
91};
92
93template <class T> // <class T=void> in C++14
94struct divides : binary_function<T, T, T>
95{
96 T operator()(const T& x, const T& y) const;
97};
98
99template <class T> // <class T=void> in C++14
100struct modulus : binary_function<T, T, T>
101{
102 T operator()(const T& x, const T& y) const;
103};
104
105template <class T> // <class T=void> in C++14
106struct negate : unary_function<T, T>
107{
108 T operator()(const T& x) const;
109};
110
111template <class T> // <class T=void> in C++14
112struct equal_to : binary_function<T, T, bool>
113{
114 bool operator()(const T& x, const T& y) const;
115};
116
117template <class T> // <class T=void> in C++14
118struct not_equal_to : binary_function<T, T, bool>
119{
120 bool operator()(const T& x, const T& y) const;
121};
122
123template <class T> // <class T=void> in C++14
124struct greater : binary_function<T, T, bool>
125{
126 bool operator()(const T& x, const T& y) const;
127};
128
129template <class T> // <class T=void> in C++14
130struct less : binary_function<T, T, bool>
131{
132 bool operator()(const T& x, const T& y) const;
133};
134
135template <class T> // <class T=void> in C++14
136struct greater_equal : binary_function<T, T, bool>
137{
138 bool operator()(const T& x, const T& y) const;
139};
140
141template <class T> // <class T=void> in C++14
142struct less_equal : binary_function<T, T, bool>
143{
144 bool operator()(const T& x, const T& y) const;
145};
146
147template <class T> // <class T=void> in C++14
148struct logical_and : binary_function<T, T, bool>
149{
150 bool operator()(const T& x, const T& y) const;
151};
152
153template <class T> // <class T=void> in C++14
154struct logical_or : binary_function<T, T, bool>
155{
156 bool operator()(const T& x, const T& y) const;
157};
158
159template <class T> // <class T=void> in C++14
160struct logical_not : unary_function<T, bool>
161{
162 bool operator()(const T& x) const;
163};
164
165template <class T> // <class T=void> in C++14
166struct bit_and : unary_function<T, bool>
167{
168 bool operator()(const T& x, const T& y) const;
169};
170
171template <class T> // <class T=void> in C++14
172struct bit_or : unary_function<T, bool>
173{
174 bool operator()(const T& x, const T& y) const;
175};
176
177template <class T> // <class T=void> in C++14
178struct bit_xor : unary_function<T, bool>
179{
180 bool operator()(const T& x, const T& y) const;
181};
182
183template <class T=void> // C++14
184struct bit_xor : unary_function<T, bool>
185{
186 bool operator()(const T& x) const;
187};
188
189template <class Predicate>
190class unary_negate // deprecated in C++17
191 : public unary_function<typename Predicate::argument_type, bool>
192{
193public:
194 explicit unary_negate(const Predicate& pred);
195 bool operator()(const typename Predicate::argument_type& x) const;
196};
197
198template <class Predicate> // deprecated in C++17
199unary_negate<Predicate> not1(const Predicate& pred);
200
201template <class Predicate>
202class binary_negate // deprecated in C++17
203 : public binary_function<typename Predicate::first_argument_type,
204 typename Predicate::second_argument_type,
205 bool>
206{
207public:
208 explicit binary_negate(const Predicate& pred);
209 bool operator()(const typename Predicate::first_argument_type& x,
210 const typename Predicate::second_argument_type& y) const;
211};
212
213template <class Predicate> // deprecated in C++17
214binary_negate<Predicate> not2(const Predicate& pred);
215
216template <class F> unspecified not_fn(F&& f); // C++17
217
218template<class T> struct is_bind_expression;
219template<class T> struct is_placeholder;
220
221 // See C++14 20.9.9, Function object binders
222template <class T> inline constexpr bool is_bind_expression_v
223 = is_bind_expression<T>::value; // C++17
224template <class T> inline constexpr int is_placeholder_v
225 = is_placeholder<T>::value; // C++17
226
227
228template<class Fn, class... BoundArgs>
229 unspecified bind(Fn&&, BoundArgs&&...);
230template<class R, class Fn, class... BoundArgs>
231 unspecified bind(Fn&&, BoundArgs&&...);
232
233template<class F, class... Args>
234 invoke_result_t<F, Args...> invoke(F&& f, Args&&... args) // C++17
235 noexcept(is_nothrow_invocable_v<F, Args...>);
236
237namespace placeholders {
238 // M is the implementation-defined number of placeholders
239 extern unspecified _1;
240 extern unspecified _2;
241 .
242 .
243 .
244 extern unspecified _Mp;
245}
246
247template <class Operation>
248class binder1st // deprecated in C++11, removed in C++17
249 : public unary_function<typename Operation::second_argument_type,
250 typename Operation::result_type>
251{
252protected:
253 Operation op;
254 typename Operation::first_argument_type value;
255public:
256 binder1st(const Operation& x, const typename Operation::first_argument_type y);
257 typename Operation::result_type operator()( typename Operation::second_argument_type& x) const;
258 typename Operation::result_type operator()(const typename Operation::second_argument_type& x) const;
259};
260
261template <class Operation, class T>
262binder1st<Operation> bind1st(const Operation& op, const T& x); // deprecated in C++11, removed in C++17
263
264template <class Operation>
265class binder2nd // deprecated in C++11, removed in C++17
266 : public unary_function<typename Operation::first_argument_type,
267 typename Operation::result_type>
268{
269protected:
270 Operation op;
271 typename Operation::second_argument_type value;
272public:
273 binder2nd(const Operation& x, const typename Operation::second_argument_type y);
274 typename Operation::result_type operator()( typename Operation::first_argument_type& x) const;
275 typename Operation::result_type operator()(const typename Operation::first_argument_type& x) const;
276};
277
278template <class Operation, class T>
279binder2nd<Operation> bind2nd(const Operation& op, const T& x); // deprecated in C++11, removed in C++17
280
281template <class Arg, class Result> // deprecated in C++11, removed in C++17
282class pointer_to_unary_function : public unary_function<Arg, Result>
283{
284public:
285 explicit pointer_to_unary_function(Result (*f)(Arg));
286 Result operator()(Arg x) const;
287};
288
289template <class Arg, class Result>
290pointer_to_unary_function<Arg,Result> ptr_fun(Result (*f)(Arg)); // deprecated in C++11, removed in C++17
291
292template <class Arg1, class Arg2, class Result> // deprecated in C++11, removed in C++17
293class pointer_to_binary_function : public binary_function<Arg1, Arg2, Result>
294{
295public:
296 explicit pointer_to_binary_function(Result (*f)(Arg1, Arg2));
297 Result operator()(Arg1 x, Arg2 y) const;
298};
299
300template <class Arg1, class Arg2, class Result>
301pointer_to_binary_function<Arg1,Arg2,Result> ptr_fun(Result (*f)(Arg1,Arg2)); // deprecated in C++11, removed in C++17
302
303template<class S, class T> // deprecated in C++11, removed in C++17
304class mem_fun_t : public unary_function<T*, S>
305{
306public:
307 explicit mem_fun_t(S (T::*p)());
308 S operator()(T* p) const;
309};
310
311template<class S, class T, class A>
312class mem_fun1_t : public binary_function<T*, A, S> // deprecated in C++11, removed in C++17
313{
314public:
315 explicit mem_fun1_t(S (T::*p)(A));
316 S operator()(T* p, A x) const;
317};
318
319template<class S, class T> mem_fun_t<S,T> mem_fun(S (T::*f)()); // deprecated in C++11, removed in C++17
320template<class S, class T, class A> mem_fun1_t<S,T,A> mem_fun(S (T::*f)(A)); // deprecated in C++11, removed in C++17
321
322template<class S, class T>
323class mem_fun_ref_t : public unary_function<T, S> // deprecated in C++11, removed in C++17
324{
325public:
326 explicit mem_fun_ref_t(S (T::*p)());
327 S operator()(T& p) const;
328};
329
330template<class S, class T, class A>
331class mem_fun1_ref_t : public binary_function<T, A, S> // deprecated in C++11, removed in C++17
332{
333public:
334 explicit mem_fun1_ref_t(S (T::*p)(A));
335 S operator()(T& p, A x) const;
336};
337
338template<class S, class T> mem_fun_ref_t<S,T> mem_fun_ref(S (T::*f)()); // deprecated in C++11, removed in C++17
339template<class S, class T, class A> mem_fun1_ref_t<S,T,A> mem_fun_ref(S (T::*f)(A)); // deprecated in C++11, removed in C++17
340
341template <class S, class T>
342class const_mem_fun_t : public unary_function<const T*, S> // deprecated in C++11, removed in C++17
343{
344public:
345 explicit const_mem_fun_t(S (T::*p)() const);
346 S operator()(const T* p) const;
347};
348
349template <class S, class T, class A>
350class const_mem_fun1_t : public binary_function<const T*, A, S> // deprecated in C++11, removed in C++17
351{
352public:
353 explicit const_mem_fun1_t(S (T::*p)(A) const);
354 S operator()(const T* p, A x) const;
355};
356
357template <class S, class T> const_mem_fun_t<S,T> mem_fun(S (T::*f)() const); // deprecated in C++11, removed in C++17
358template <class S, class T, class A> const_mem_fun1_t<S,T,A> mem_fun(S (T::*f)(A) const); // deprecated in C++11, removed in C++17
359
360template <class S, class T>
361class const_mem_fun_ref_t : public unary_function<T, S> // deprecated in C++11, removed in C++17
362{
363public:
364 explicit const_mem_fun_ref_t(S (T::*p)() const);
365 S operator()(const T& p) const;
366};
367
368template <class S, class T, class A>
369class const_mem_fun1_ref_t : public binary_function<T, A, S> // deprecated in C++11, removed in C++17
370{
371public:
372 explicit const_mem_fun1_ref_t(S (T::*p)(A) const);
373 S operator()(const T& p, A x) const;
374};
375
376template <class S, class T> const_mem_fun_ref_t<S,T> mem_fun_ref(S (T::*f)() const); // deprecated in C++11, removed in C++17
377template <class S, class T, class A> const_mem_fun1_ref_t<S,T,A> mem_fun_ref(S (T::*f)(A) const); // deprecated in C++11, removed in C++17
378
379template<class R, class T> unspecified mem_fn(R T::*);
380
381class bad_function_call
382 : public exception
383{
384};
385
386template<class> class function; // undefined
387
388template<class R, class... ArgTypes>
389class function<R(ArgTypes...)>
390 : public unary_function<T1, R> // iff sizeof...(ArgTypes) == 1 and
391 // ArgTypes contains T1
392 : public binary_function<T1, T2, R> // iff sizeof...(ArgTypes) == 2 and
393 // ArgTypes contains T1 and T2
394{
395public:
396 typedef R result_type;
397
398 // construct/copy/destroy:
399 function() noexcept;
400 function(nullptr_t) noexcept;
401 function(const function&);
402 function(function&&) noexcept;
403 template<class F>
404 function(F);
405 template<Allocator Alloc>
406 function(allocator_arg_t, const Alloc&) noexcept; // removed in C++17
407 template<Allocator Alloc>
408 function(allocator_arg_t, const Alloc&, nullptr_t) noexcept; // removed in C++17
409 template<Allocator Alloc>
410 function(allocator_arg_t, const Alloc&, const function&); // removed in C++17
411 template<Allocator Alloc>
412 function(allocator_arg_t, const Alloc&, function&&); // removed in C++17
413 template<class F, Allocator Alloc>
414 function(allocator_arg_t, const Alloc&, F); // removed in C++17
415
416 function& operator=(const function&);
417 function& operator=(function&&) noexcept;
418 function& operator=(nullptr_t) noexcept;
419 template<class F>
420 function& operator=(F&&);
421 template<class F>
422 function& operator=(reference_wrapper<F>) noexcept;
423
424 ~function();
425
426 // function modifiers:
427 void swap(function&) noexcept;
428 template<class F, class Alloc>
429 void assign(F&&, const Alloc&); // Removed in C++17
430
431 // function capacity:
432 explicit operator bool() const noexcept;
433
434 // function invocation:
435 R operator()(ArgTypes...) const;
436
437 // function target access:
438 const std::type_info& target_type() const noexcept;
439 template <typename T> T* target() noexcept;
440 template <typename T> const T* target() const noexcept;
441};
442
443// Null pointer comparisons:
444template <class R, class ... ArgTypes>
445 bool operator==(const function<R(ArgTypes...)>&, nullptr_t) noexcept;
446
447template <class R, class ... ArgTypes>
448 bool operator==(nullptr_t, const function<R(ArgTypes...)>&) noexcept;
449
450template <class R, class ... ArgTypes>
451 bool operator!=(const function<R(ArgTypes...)>&, nullptr_t) noexcept;
452
453template <class R, class ... ArgTypes>
454 bool operator!=(nullptr_t, const function<R(ArgTypes...)>&) noexcept;
455
456// specialized algorithms:
457template <class R, class ... ArgTypes>
458 void swap(function<R(ArgTypes...)>&, function<R(ArgTypes...)>&) noexcept;
459
460template <class T> struct hash;
461
462template <> struct hash<bool>;
463template <> struct hash<char>;
464template <> struct hash<signed char>;
465template <> struct hash<unsigned char>;
466template <> struct hash<char16_t>;
467template <> struct hash<char32_t>;
468template <> struct hash<wchar_t>;
469template <> struct hash<short>;
470template <> struct hash<unsigned short>;
471template <> struct hash<int>;
472template <> struct hash<unsigned int>;
473template <> struct hash<long>;
474template <> struct hash<long long>;
475template <> struct hash<unsigned long>;
476template <> struct hash<unsigned long long>;
477
478template <> struct hash<float>;
479template <> struct hash<double>;
480template <> struct hash<long double>;
481
482template<class T> struct hash<T*>;
483template <> struct hash<nullptr_t>; // C++17
484
485} // std
486
487POLICY: For non-variadic implementations, the number of arguments is limited
488 to 3. It is hoped that the need for non-variadic implementations
489 will be minimal.
490
491*/
492
493#include <__config>
494#include <type_traits>
495#include <typeinfo>
496#include <exception>
497#include <memory>
498#include <tuple>
499#include <utility>
500#include <version>
501
502#include <__functional_base>
503
504#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
505#pragma GCC system_header
506#endif
507
508_LIBCPP_BEGIN_NAMESPACE_STD
509
510#if _LIBCPP_STD_VER > 11
511template <class _Tp = void>
512#else
513template <class _Tp>
514#endif
515struct _LIBCPP_TEMPLATE_VIS plus : binary_function<_Tp, _Tp, _Tp>
516{
517 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
518 _Tp operator()(const _Tp& __x, const _Tp& __y) const
519 {return __x + __y;}
520};
521
522#if _LIBCPP_STD_VER > 11
523template <>
524struct _LIBCPP_TEMPLATE_VIS plus<void>
525{
526 template <class _T1, class _T2>
527 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
528 auto operator()(_T1&& __t, _T2&& __u) const
529 _NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) + _VSTD::forward<_T2>(__u)))
530 -> decltype (_VSTD::forward<_T1>(__t) + _VSTD::forward<_T2>(__u))
531 { return _VSTD::forward<_T1>(__t) + _VSTD::forward<_T2>(__u); }
532 typedef void is_transparent;
533};
534#endif
535
536
537#if _LIBCPP_STD_VER > 11
538template <class _Tp = void>
539#else
540template <class _Tp>
541#endif
542struct _LIBCPP_TEMPLATE_VIS minus : binary_function<_Tp, _Tp, _Tp>
543{
544 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
545 _Tp operator()(const _Tp& __x, const _Tp& __y) const
546 {return __x - __y;}
547};
548
549#if _LIBCPP_STD_VER > 11
550template <>
551struct _LIBCPP_TEMPLATE_VIS minus<void>
552{
553 template <class _T1, class _T2>
554 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
555 auto operator()(_T1&& __t, _T2&& __u) const
556 _NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) - _VSTD::forward<_T2>(__u)))
557 -> decltype (_VSTD::forward<_T1>(__t) - _VSTD::forward<_T2>(__u))
558 { return _VSTD::forward<_T1>(__t) - _VSTD::forward<_T2>(__u); }
559 typedef void is_transparent;
560};
561#endif
562
563
564#if _LIBCPP_STD_VER > 11
565template <class _Tp = void>
566#else
567template <class _Tp>
568#endif
569struct _LIBCPP_TEMPLATE_VIS multiplies : binary_function<_Tp, _Tp, _Tp>
570{
571 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
572 _Tp operator()(const _Tp& __x, const _Tp& __y) const
573 {return __x * __y;}
574};
575
576#if _LIBCPP_STD_VER > 11
577template <>
578struct _LIBCPP_TEMPLATE_VIS multiplies<void>
579{
580 template <class _T1, class _T2>
581 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
582 auto operator()(_T1&& __t, _T2&& __u) const
583 _NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) * _VSTD::forward<_T2>(__u)))
584 -> decltype (_VSTD::forward<_T1>(__t) * _VSTD::forward<_T2>(__u))
585 { return _VSTD::forward<_T1>(__t) * _VSTD::forward<_T2>(__u); }
586 typedef void is_transparent;
587};
588#endif
589
590
591#if _LIBCPP_STD_VER > 11
592template <class _Tp = void>
593#else
594template <class _Tp>
595#endif
596struct _LIBCPP_TEMPLATE_VIS divides : binary_function<_Tp, _Tp, _Tp>
597{
598 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
599 _Tp operator()(const _Tp& __x, const _Tp& __y) const
600 {return __x / __y;}
601};
602
603#if _LIBCPP_STD_VER > 11
604template <>
605struct _LIBCPP_TEMPLATE_VIS divides<void>
606{
607 template <class _T1, class _T2>
608 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
609 auto operator()(_T1&& __t, _T2&& __u) const
610 _NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) / _VSTD::forward<_T2>(__u)))
611 -> decltype (_VSTD::forward<_T1>(__t) / _VSTD::forward<_T2>(__u))
612 { return _VSTD::forward<_T1>(__t) / _VSTD::forward<_T2>(__u); }
613 typedef void is_transparent;
614};
615#endif
616
617
618#if _LIBCPP_STD_VER > 11
619template <class _Tp = void>
620#else
621template <class _Tp>
622#endif
623struct _LIBCPP_TEMPLATE_VIS modulus : binary_function<_Tp, _Tp, _Tp>
624{
625 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
626 _Tp operator()(const _Tp& __x, const _Tp& __y) const
627 {return __x % __y;}
628};
629
630#if _LIBCPP_STD_VER > 11
631template <>
632struct _LIBCPP_TEMPLATE_VIS modulus<void>
633{
634 template <class _T1, class _T2>
635 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
636 auto operator()(_T1&& __t, _T2&& __u) const
637 _NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) % _VSTD::forward<_T2>(__u)))
638 -> decltype (_VSTD::forward<_T1>(__t) % _VSTD::forward<_T2>(__u))
639 { return _VSTD::forward<_T1>(__t) % _VSTD::forward<_T2>(__u); }
640 typedef void is_transparent;
641};
642#endif
643
644
645#if _LIBCPP_STD_VER > 11
646template <class _Tp = void>
647#else
648template <class _Tp>
649#endif
650struct _LIBCPP_TEMPLATE_VIS negate : unary_function<_Tp, _Tp>
651{
652 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
653 _Tp operator()(const _Tp& __x) const
654 {return -__x;}
655};
656
657#if _LIBCPP_STD_VER > 11
658template <>
659struct _LIBCPP_TEMPLATE_VIS negate<void>
660{
661 template <class _Tp>
662 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
663 auto operator()(_Tp&& __x) const
664 _NOEXCEPT_(noexcept(- _VSTD::forward<_Tp>(__x)))
665 -> decltype (- _VSTD::forward<_Tp>(__x))
666 { return - _VSTD::forward<_Tp>(__x); }
667 typedef void is_transparent;
668};
669#endif
670
671
672#if _LIBCPP_STD_VER > 11
673template <class _Tp = void>
674#else
675template <class _Tp>
676#endif
677struct _LIBCPP_TEMPLATE_VIS equal_to : binary_function<_Tp, _Tp, bool>
678{
679 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
680 bool operator()(const _Tp& __x, const _Tp& __y) const
681 {return __x == __y;}
682};
683
684#if _LIBCPP_STD_VER > 11
685template <>
686struct _LIBCPP_TEMPLATE_VIS equal_to<void>
687{
688 template <class _T1, class _T2>
689 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
690 auto operator()(_T1&& __t, _T2&& __u) const
691 _NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) == _VSTD::forward<_T2>(__u)))
692 -> decltype (_VSTD::forward<_T1>(__t) == _VSTD::forward<_T2>(__u))
693 { return _VSTD::forward<_T1>(__t) == _VSTD::forward<_T2>(__u); }
694 typedef void is_transparent;
695};
696#endif
697
698
699#if _LIBCPP_STD_VER > 11
700template <class _Tp = void>
701#else
702template <class _Tp>
703#endif
704struct _LIBCPP_TEMPLATE_VIS not_equal_to : binary_function<_Tp, _Tp, bool>
705{
706 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
707 bool operator()(const _Tp& __x, const _Tp& __y) const
708 {return __x != __y;}
709};
710
711#if _LIBCPP_STD_VER > 11
712template <>
713struct _LIBCPP_TEMPLATE_VIS not_equal_to<void>
714{
715 template <class _T1, class _T2>
716 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
717 auto operator()(_T1&& __t, _T2&& __u) const
718 _NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) != _VSTD::forward<_T2>(__u)))
719 -> decltype (_VSTD::forward<_T1>(__t) != _VSTD::forward<_T2>(__u))
720 { return _VSTD::forward<_T1>(__t) != _VSTD::forward<_T2>(__u); }
721 typedef void is_transparent;
722};
723#endif
724
725
726#if _LIBCPP_STD_VER > 11
727template <class _Tp = void>
728#else
729template <class _Tp>
730#endif
731struct _LIBCPP_TEMPLATE_VIS greater : binary_function<_Tp, _Tp, bool>
732{
733 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
734 bool operator()(const _Tp& __x, const _Tp& __y) const
735 {return __x > __y;}
736};
737
738#if _LIBCPP_STD_VER > 11
739template <>
740struct _LIBCPP_TEMPLATE_VIS greater<void>
741{
742 template <class _T1, class _T2>
743 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
744 auto operator()(_T1&& __t, _T2&& __u) const
745 _NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) > _VSTD::forward<_T2>(__u)))
746 -> decltype (_VSTD::forward<_T1>(__t) > _VSTD::forward<_T2>(__u))
747 { return _VSTD::forward<_T1>(__t) > _VSTD::forward<_T2>(__u); }
748 typedef void is_transparent;
749};
750#endif
751
752
753// less in <__functional_base>
754
755#if _LIBCPP_STD_VER > 11
756template <class _Tp = void>
757#else
758template <class _Tp>
759#endif
760struct _LIBCPP_TEMPLATE_VIS greater_equal : binary_function<_Tp, _Tp, bool>
761{
762 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
763 bool operator()(const _Tp& __x, const _Tp& __y) const
764 {return __x >= __y;}
765};
766
767#if _LIBCPP_STD_VER > 11
768template <>
769struct _LIBCPP_TEMPLATE_VIS greater_equal<void>
770{
771 template <class _T1, class _T2>
772 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
773 auto operator()(_T1&& __t, _T2&& __u) const
774 _NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) >= _VSTD::forward<_T2>(__u)))
775 -> decltype (_VSTD::forward<_T1>(__t) >= _VSTD::forward<_T2>(__u))
776 { return _VSTD::forward<_T1>(__t) >= _VSTD::forward<_T2>(__u); }
777 typedef void is_transparent;
778};
779#endif
780
781
782#if _LIBCPP_STD_VER > 11
783template <class _Tp = void>
784#else
785template <class _Tp>
786#endif
787struct _LIBCPP_TEMPLATE_VIS less_equal : binary_function<_Tp, _Tp, bool>
788{
789 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
790 bool operator()(const _Tp& __x, const _Tp& __y) const
791 {return __x <= __y;}
792};
793
794#if _LIBCPP_STD_VER > 11
795template <>
796struct _LIBCPP_TEMPLATE_VIS less_equal<void>
797{
798 template <class _T1, class _T2>
799 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
800 auto operator()(_T1&& __t, _T2&& __u) const
801 _NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) <= _VSTD::forward<_T2>(__u)))
802 -> decltype (_VSTD::forward<_T1>(__t) <= _VSTD::forward<_T2>(__u))
803 { return _VSTD::forward<_T1>(__t) <= _VSTD::forward<_T2>(__u); }
804 typedef void is_transparent;
805};
806#endif
807
808
809#if _LIBCPP_STD_VER > 11
810template <class _Tp = void>
811#else
812template <class _Tp>
813#endif
814struct _LIBCPP_TEMPLATE_VIS logical_and : binary_function<_Tp, _Tp, bool>
815{
816 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
817 bool operator()(const _Tp& __x, const _Tp& __y) const
818 {return __x && __y;}
819};
820
821#if _LIBCPP_STD_VER > 11
822template <>
823struct _LIBCPP_TEMPLATE_VIS logical_and<void>
824{
825 template <class _T1, class _T2>
826 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
827 auto operator()(_T1&& __t, _T2&& __u) const
828 _NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) && _VSTD::forward<_T2>(__u)))
829 -> decltype (_VSTD::forward<_T1>(__t) && _VSTD::forward<_T2>(__u))
830 { return _VSTD::forward<_T1>(__t) && _VSTD::forward<_T2>(__u); }
831 typedef void is_transparent;
832};
833#endif
834
835
836#if _LIBCPP_STD_VER > 11
837template <class _Tp = void>
838#else
839template <class _Tp>
840#endif
841struct _LIBCPP_TEMPLATE_VIS logical_or : binary_function<_Tp, _Tp, bool>
842{
843 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
844 bool operator()(const _Tp& __x, const _Tp& __y) const
845 {return __x || __y;}
846};
847
848#if _LIBCPP_STD_VER > 11
849template <>
850struct _LIBCPP_TEMPLATE_VIS logical_or<void>
851{
852 template <class _T1, class _T2>
853 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
854 auto operator()(_T1&& __t, _T2&& __u) const
855 _NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) || _VSTD::forward<_T2>(__u)))
856 -> decltype (_VSTD::forward<_T1>(__t) || _VSTD::forward<_T2>(__u))
857 { return _VSTD::forward<_T1>(__t) || _VSTD::forward<_T2>(__u); }
858 typedef void is_transparent;
859};
860#endif
861
862
863#if _LIBCPP_STD_VER > 11
864template <class _Tp = void>
865#else
866template <class _Tp>
867#endif
868struct _LIBCPP_TEMPLATE_VIS logical_not : unary_function<_Tp, bool>
869{
870 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
871 bool operator()(const _Tp& __x) const
872 {return !__x;}
873};
874
875#if _LIBCPP_STD_VER > 11
876template <>
877struct _LIBCPP_TEMPLATE_VIS logical_not<void>
878{
879 template <class _Tp>
880 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
881 auto operator()(_Tp&& __x) const
882 _NOEXCEPT_(noexcept(!_VSTD::forward<_Tp>(__x)))
883 -> decltype (!_VSTD::forward<_Tp>(__x))
884 { return !_VSTD::forward<_Tp>(__x); }
885 typedef void is_transparent;
886};
887#endif
888
889
890#if _LIBCPP_STD_VER > 11
891template <class _Tp = void>
892#else
893template <class _Tp>
894#endif
895struct _LIBCPP_TEMPLATE_VIS bit_and : binary_function<_Tp, _Tp, _Tp>
896{
897 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
898 _Tp operator()(const _Tp& __x, const _Tp& __y) const
899 {return __x & __y;}
900};
901
902#if _LIBCPP_STD_VER > 11
903template <>
904struct _LIBCPP_TEMPLATE_VIS bit_and<void>
905{
906 template <class _T1, class _T2>
907 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
908 auto operator()(_T1&& __t, _T2&& __u) const
909 _NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) & _VSTD::forward<_T2>(__u)))
910 -> decltype (_VSTD::forward<_T1>(__t) & _VSTD::forward<_T2>(__u))
911 { return _VSTD::forward<_T1>(__t) & _VSTD::forward<_T2>(__u); }
912 typedef void is_transparent;
913};
914#endif
915
916
917#if _LIBCPP_STD_VER > 11
918template <class _Tp = void>
919#else
920template <class _Tp>
921#endif
922struct _LIBCPP_TEMPLATE_VIS bit_or : binary_function<_Tp, _Tp, _Tp>
923{
924 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
925 _Tp operator()(const _Tp& __x, const _Tp& __y) const
926 {return __x | __y;}
927};
928
929#if _LIBCPP_STD_VER > 11
930template <>
931struct _LIBCPP_TEMPLATE_VIS bit_or<void>
932{
933 template <class _T1, class _T2>
934 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
935 auto operator()(_T1&& __t, _T2&& __u) const
936 _NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) | _VSTD::forward<_T2>(__u)))
937 -> decltype (_VSTD::forward<_T1>(__t) | _VSTD::forward<_T2>(__u))
938 { return _VSTD::forward<_T1>(__t) | _VSTD::forward<_T2>(__u); }
939 typedef void is_transparent;
940};
941#endif
942
943
944#if _LIBCPP_STD_VER > 11
945template <class _Tp = void>
946#else
947template <class _Tp>
948#endif
949struct _LIBCPP_TEMPLATE_VIS bit_xor : binary_function<_Tp, _Tp, _Tp>
950{
951 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
952 _Tp operator()(const _Tp& __x, const _Tp& __y) const
953 {return __x ^ __y;}
954};
955
956#if _LIBCPP_STD_VER > 11
957template <>
958struct _LIBCPP_TEMPLATE_VIS bit_xor<void>
959{
960 template <class _T1, class _T2>
961 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
962 auto operator()(_T1&& __t, _T2&& __u) const
963 _NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) ^ _VSTD::forward<_T2>(__u)))
964 -> decltype (_VSTD::forward<_T1>(__t) ^ _VSTD::forward<_T2>(__u))
965 { return _VSTD::forward<_T1>(__t) ^ _VSTD::forward<_T2>(__u); }
966 typedef void is_transparent;
967};
968#endif
969
970
971#if _LIBCPP_STD_VER > 11
972template <class _Tp = void>
973struct _LIBCPP_TEMPLATE_VIS bit_not : unary_function<_Tp, _Tp>
974{
975 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
976 _Tp operator()(const _Tp& __x) const
977 {return ~__x;}
978};
979
980template <>
981struct _LIBCPP_TEMPLATE_VIS bit_not<void>
982{
983 template <class _Tp>
984 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
985 auto operator()(_Tp&& __x) const
986 _NOEXCEPT_(noexcept(~_VSTD::forward<_Tp>(__x)))
987 -> decltype (~_VSTD::forward<_Tp>(__x))
988 { return ~_VSTD::forward<_Tp>(__x); }
989 typedef void is_transparent;
990};
991#endif
992
993template <class _Predicate>
994class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX17 unary_negate
995 : public unary_function<typename _Predicate::argument_type, bool>
996{
997 _Predicate __pred_;
998public:
999 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
1000 explicit unary_negate(const _Predicate& __pred)
1001 : __pred_(__pred) {}
1002 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
1003 bool operator()(const typename _Predicate::argument_type& __x) const
1004 {return !__pred_(__x);}
1005};
1006
1007template <class _Predicate>
1008_LIBCPP_DEPRECATED_IN_CXX17 inline _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
1009unary_negate<_Predicate>
1010not1(const _Predicate& __pred) {return unary_negate<_Predicate>(__pred);}
1011
1012template <class _Predicate>
1013class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX17 binary_negate
1014 : public binary_function<typename _Predicate::first_argument_type,
1015 typename _Predicate::second_argument_type,
1016 bool>
1017{
1018 _Predicate __pred_;
1019public:
1020 _LIBCPP_INLINE_VISIBILITY explicit _LIBCPP_CONSTEXPR_AFTER_CXX11
1021 binary_negate(const _Predicate& __pred) : __pred_(__pred) {}
1022
1023 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
1024 bool operator()(const typename _Predicate::first_argument_type& __x,
1025 const typename _Predicate::second_argument_type& __y) const
1026 {return !__pred_(__x, __y);}
1027};
1028
1029template <class _Predicate>
1030_LIBCPP_DEPRECATED_IN_CXX17 inline _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
1031binary_negate<_Predicate>
1032not2(const _Predicate& __pred) {return binary_negate<_Predicate>(__pred);}
1033
1034#if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_BINDERS)
1035template <class __Operation>
1036class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 binder1st
1037 : public unary_function<typename __Operation::second_argument_type,
1038 typename __Operation::result_type>
1039{
1040protected:
1041 __Operation op;
1042 typename __Operation::first_argument_type value;
1043public:
1044 _LIBCPP_INLINE_VISIBILITY binder1st(const __Operation& __x,
1045 const typename __Operation::first_argument_type __y)
1046 : op(__x), value(__y) {}
1047 _LIBCPP_INLINE_VISIBILITY typename __Operation::result_type operator()
1048 (typename __Operation::second_argument_type& __x) const
1049 {return op(value, __x);}
1050 _LIBCPP_INLINE_VISIBILITY typename __Operation::result_type operator()
1051 (const typename __Operation::second_argument_type& __x) const
1052 {return op(value, __x);}
1053};
1054
1055template <class __Operation, class _Tp>
1056_LIBCPP_DEPRECATED_IN_CXX11 inline _LIBCPP_INLINE_VISIBILITY
1057binder1st<__Operation>
1058bind1st(const __Operation& __op, const _Tp& __x)
1059 {return binder1st<__Operation>(__op, __x);}
1060
1061template <class __Operation>
1062class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 binder2nd
1063 : public unary_function<typename __Operation::first_argument_type,
1064 typename __Operation::result_type>
1065{
1066protected:
1067 __Operation op;
1068 typename __Operation::second_argument_type value;
1069public:
1070 _LIBCPP_INLINE_VISIBILITY
1071 binder2nd(const __Operation& __x, const typename __Operation::second_argument_type __y)
1072 : op(__x), value(__y) {}
1073 _LIBCPP_INLINE_VISIBILITY typename __Operation::result_type operator()
1074 ( typename __Operation::first_argument_type& __x) const
1075 {return op(__x, value);}
1076 _LIBCPP_INLINE_VISIBILITY typename __Operation::result_type operator()
1077 (const typename __Operation::first_argument_type& __x) const
1078 {return op(__x, value);}
1079};
1080
1081template <class __Operation, class _Tp>
1082_LIBCPP_DEPRECATED_IN_CXX11 inline _LIBCPP_INLINE_VISIBILITY
1083binder2nd<__Operation>
1084bind2nd(const __Operation& __op, const _Tp& __x)
1085 {return binder2nd<__Operation>(__op, __x);}
1086
1087template <class _Arg, class _Result>
1088class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 pointer_to_unary_function
1089 : public unary_function<_Arg, _Result>
1090{
1091 _Result (*__f_)(_Arg);
1092public:
1093 _LIBCPP_INLINE_VISIBILITY explicit pointer_to_unary_function(_Result (*__f)(_Arg))
1094 : __f_(__f) {}
1095 _LIBCPP_INLINE_VISIBILITY _Result operator()(_Arg __x) const
1096 {return __f_(__x);}
1097};
1098
1099template <class _Arg, class _Result>
1100_LIBCPP_DEPRECATED_IN_CXX11 inline _LIBCPP_INLINE_VISIBILITY
1101pointer_to_unary_function<_Arg,_Result>
1102ptr_fun(_Result (*__f)(_Arg))
1103 {return pointer_to_unary_function<_Arg,_Result>(__f);}
1104
1105template <class _Arg1, class _Arg2, class _Result>
1106class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 pointer_to_binary_function
1107 : public binary_function<_Arg1, _Arg2, _Result>
1108{
1109 _Result (*__f_)(_Arg1, _Arg2);
1110public:
1111 _LIBCPP_INLINE_VISIBILITY explicit pointer_to_binary_function(_Result (*__f)(_Arg1, _Arg2))
1112 : __f_(__f) {}
1113 _LIBCPP_INLINE_VISIBILITY _Result operator()(_Arg1 __x, _Arg2 __y) const
1114 {return __f_(__x, __y);}
1115};
1116
1117template <class _Arg1, class _Arg2, class _Result>
1118_LIBCPP_DEPRECATED_IN_CXX11 inline _LIBCPP_INLINE_VISIBILITY
1119pointer_to_binary_function<_Arg1,_Arg2,_Result>
1120ptr_fun(_Result (*__f)(_Arg1,_Arg2))
1121 {return pointer_to_binary_function<_Arg1,_Arg2,_Result>(__f);}
1122
1123template<class _Sp, class _Tp>
1124class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 mem_fun_t
1125 : public unary_function<_Tp*, _Sp>
1126{
1127 _Sp (_Tp::*__p_)();
1128public:
1129 _LIBCPP_INLINE_VISIBILITY explicit mem_fun_t(_Sp (_Tp::*__p)())
1130 : __p_(__p) {}
1131 _LIBCPP_INLINE_VISIBILITY _Sp operator()(_Tp* __p) const
1132 {return (__p->*__p_)();}
1133};
1134
1135template<class _Sp, class _Tp, class _Ap>
1136class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 mem_fun1_t
1137 : public binary_function<_Tp*, _Ap, _Sp>
1138{
1139 _Sp (_Tp::*__p_)(_Ap);
1140public:
1141 _LIBCPP_INLINE_VISIBILITY explicit mem_fun1_t(_Sp (_Tp::*__p)(_Ap))
1142 : __p_(__p) {}
1143 _LIBCPP_INLINE_VISIBILITY _Sp operator()(_Tp* __p, _Ap __x) const
1144 {return (__p->*__p_)(__x);}
1145};
1146
1147template<class _Sp, class _Tp>
1148_LIBCPP_DEPRECATED_IN_CXX11 inline _LIBCPP_INLINE_VISIBILITY
1149mem_fun_t<_Sp,_Tp>
1150mem_fun(_Sp (_Tp::*__f)())
1151 {return mem_fun_t<_Sp,_Tp>(__f);}
1152
1153template<class _Sp, class _Tp, class _Ap>
1154_LIBCPP_DEPRECATED_IN_CXX11 inline _LIBCPP_INLINE_VISIBILITY
1155mem_fun1_t<_Sp,_Tp,_Ap>
1156mem_fun(_Sp (_Tp::*__f)(_Ap))
1157 {return mem_fun1_t<_Sp,_Tp,_Ap>(__f);}
1158
1159template<class _Sp, class _Tp>
1160class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 mem_fun_ref_t
1161 : public unary_function<_Tp, _Sp>
1162{
1163 _Sp (_Tp::*__p_)();
1164public:
1165 _LIBCPP_INLINE_VISIBILITY explicit mem_fun_ref_t(_Sp (_Tp::*__p)())
1166 : __p_(__p) {}
1167 _LIBCPP_INLINE_VISIBILITY _Sp operator()(_Tp& __p) const
1168 {return (__p.*__p_)();}
1169};
1170
1171template<class _Sp, class _Tp, class _Ap>
1172class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 mem_fun1_ref_t
1173 : public binary_function<_Tp, _Ap, _Sp>
1174{
1175 _Sp (_Tp::*__p_)(_Ap);
1176public:
1177 _LIBCPP_INLINE_VISIBILITY explicit mem_fun1_ref_t(_Sp (_Tp::*__p)(_Ap))
1178 : __p_(__p) {}
1179 _LIBCPP_INLINE_VISIBILITY _Sp operator()(_Tp& __p, _Ap __x) const
1180 {return (__p.*__p_)(__x);}
1181};
1182
1183template<class _Sp, class _Tp>
1184_LIBCPP_DEPRECATED_IN_CXX11 inline _LIBCPP_INLINE_VISIBILITY
1185mem_fun_ref_t<_Sp,_Tp>
1186mem_fun_ref(_Sp (_Tp::*__f)())
1187 {return mem_fun_ref_t<_Sp,_Tp>(__f);}
1188
1189template<class _Sp, class _Tp, class _Ap>
1190_LIBCPP_DEPRECATED_IN_CXX11 inline _LIBCPP_INLINE_VISIBILITY
1191mem_fun1_ref_t<_Sp,_Tp,_Ap>
1192mem_fun_ref(_Sp (_Tp::*__f)(_Ap))
1193 {return mem_fun1_ref_t<_Sp,_Tp,_Ap>(__f);}
1194
1195template <class _Sp, class _Tp>
1196class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 const_mem_fun_t
1197 : public unary_function<const _Tp*, _Sp>
1198{
1199 _Sp (_Tp::*__p_)() const;
1200public:
1201 _LIBCPP_INLINE_VISIBILITY explicit const_mem_fun_t(_Sp (_Tp::*__p)() const)
1202 : __p_(__p) {}
1203 _LIBCPP_INLINE_VISIBILITY _Sp operator()(const _Tp* __p) const
1204 {return (__p->*__p_)();}
1205};
1206
1207template <class _Sp, class _Tp, class _Ap>
1208class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 const_mem_fun1_t
1209 : public binary_function<const _Tp*, _Ap, _Sp>
1210{
1211 _Sp (_Tp::*__p_)(_Ap) const;
1212public:
1213 _LIBCPP_INLINE_VISIBILITY explicit const_mem_fun1_t(_Sp (_Tp::*__p)(_Ap) const)
1214 : __p_(__p) {}
1215 _LIBCPP_INLINE_VISIBILITY _Sp operator()(const _Tp* __p, _Ap __x) const
1216 {return (__p->*__p_)(__x);}
1217};
1218
1219template <class _Sp, class _Tp>
1220_LIBCPP_DEPRECATED_IN_CXX11 inline _LIBCPP_INLINE_VISIBILITY
1221const_mem_fun_t<_Sp,_Tp>
1222mem_fun(_Sp (_Tp::*__f)() const)
1223 {return const_mem_fun_t<_Sp,_Tp>(__f);}
1224
1225template <class _Sp, class _Tp, class _Ap>
1226_LIBCPP_DEPRECATED_IN_CXX11 inline _LIBCPP_INLINE_VISIBILITY
1227const_mem_fun1_t<_Sp,_Tp,_Ap>
1228mem_fun(_Sp (_Tp::*__f)(_Ap) const)
1229 {return const_mem_fun1_t<_Sp,_Tp,_Ap>(__f);}
1230
1231template <class _Sp, class _Tp>
1232class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 const_mem_fun_ref_t
1233 : public unary_function<_Tp, _Sp>
1234{
1235 _Sp (_Tp::*__p_)() const;
1236public:
1237 _LIBCPP_INLINE_VISIBILITY explicit const_mem_fun_ref_t(_Sp (_Tp::*__p)() const)
1238 : __p_(__p) {}
1239 _LIBCPP_INLINE_VISIBILITY _Sp operator()(const _Tp& __p) const
1240 {return (__p.*__p_)();}
1241};
1242
1243template <class _Sp, class _Tp, class _Ap>
1244class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 const_mem_fun1_ref_t
1245 : public binary_function<_Tp, _Ap, _Sp>
1246{
1247 _Sp (_Tp::*__p_)(_Ap) const;
1248public:
1249 _LIBCPP_INLINE_VISIBILITY explicit const_mem_fun1_ref_t(_Sp (_Tp::*__p)(_Ap) const)
1250 : __p_(__p) {}
1251 _LIBCPP_INLINE_VISIBILITY _Sp operator()(const _Tp& __p, _Ap __x) const
1252 {return (__p.*__p_)(__x);}
1253};
1254
1255template <class _Sp, class _Tp>
1256_LIBCPP_DEPRECATED_IN_CXX11 inline _LIBCPP_INLINE_VISIBILITY
1257const_mem_fun_ref_t<_Sp,_Tp>
1258mem_fun_ref(_Sp (_Tp::*__f)() const)
1259 {return const_mem_fun_ref_t<_Sp,_Tp>(__f);}
1260
1261template <class _Sp, class _Tp, class _Ap>
1262_LIBCPP_DEPRECATED_IN_CXX11 inline _LIBCPP_INLINE_VISIBILITY
1263const_mem_fun1_ref_t<_Sp,_Tp,_Ap>
1264mem_fun_ref(_Sp (_Tp::*__f)(_Ap) const)
1265 {return const_mem_fun1_ref_t<_Sp,_Tp,_Ap>(__f);}
1266#endif
1267
1268////////////////////////////////////////////////////////////////////////////////
1269// MEMFUN
1270//==============================================================================
1271
1272template <class _Tp>
1273class __mem_fn
1274 : public __weak_result_type<_Tp>
1275{
1276public:
1277 // types
1278 typedef _Tp type;
1279private:
1280 type __f_;
1281
1282public:
1283 _LIBCPP_INLINE_VISIBILITY __mem_fn(type __f) _NOEXCEPT : __f_(__f) {}
1284
1285#ifndef _LIBCPP_CXX03_LANG
1286 // invoke
1287 template <class... _ArgTypes>
1288 _LIBCPP_INLINE_VISIBILITY
1289 typename __invoke_return<type, _ArgTypes...>::type
1290 operator() (_ArgTypes&&... __args) const {
1291 return __invoke(__f_, _VSTD::forward<_ArgTypes>(__args)...);
1292 }
1293#else
1294
1295 template <class _A0>
1296 _LIBCPP_INLINE_VISIBILITY
1297 typename __invoke_return0<type, _A0>::type
1298 operator() (_A0& __a0) const {
1299 return __invoke(__f_, __a0);
1300 }
1301
1302 template <class _A0>
1303 _LIBCPP_INLINE_VISIBILITY
1304 typename __invoke_return0<type, _A0 const>::type
1305 operator() (_A0 const& __a0) const {
1306 return __invoke(__f_, __a0);
1307 }
1308
1309 template <class _A0, class _A1>
1310 _LIBCPP_INLINE_VISIBILITY
1311 typename __invoke_return1<type, _A0, _A1>::type
1312 operator() (_A0& __a0, _A1& __a1) const {
1313 return __invoke(__f_, __a0, __a1);
1314 }
1315
1316 template <class _A0, class _A1>
1317 _LIBCPP_INLINE_VISIBILITY
1318 typename __invoke_return1<type, _A0 const, _A1>::type
1319 operator() (_A0 const& __a0, _A1& __a1) const {
1320 return __invoke(__f_, __a0, __a1);
1321 }
1322
1323 template <class _A0, class _A1>
1324 _LIBCPP_INLINE_VISIBILITY
1325 typename __invoke_return1<type, _A0, _A1 const>::type
1326 operator() (_A0& __a0, _A1 const& __a1) const {
1327 return __invoke(__f_, __a0, __a1);
1328 }
1329
1330 template <class _A0, class _A1>
1331 _LIBCPP_INLINE_VISIBILITY
1332 typename __invoke_return1<type, _A0 const, _A1 const>::type
1333 operator() (_A0 const& __a0, _A1 const& __a1) const {
1334 return __invoke(__f_, __a0, __a1);
1335 }
1336
1337 template <class _A0, class _A1, class _A2>
1338 _LIBCPP_INLINE_VISIBILITY
1339 typename __invoke_return2<type, _A0, _A1, _A2>::type
1340 operator() (_A0& __a0, _A1& __a1, _A2& __a2) const {
1341 return __invoke(__f_, __a0, __a1, __a2);
1342 }
1343
1344 template <class _A0, class _A1, class _A2>
1345 _LIBCPP_INLINE_VISIBILITY
1346 typename __invoke_return2<type, _A0 const, _A1, _A2>::type
1347 operator() (_A0 const& __a0, _A1& __a1, _A2& __a2) const {
1348 return __invoke(__f_, __a0, __a1, __a2);
1349 }
1350
1351 template <class _A0, class _A1, class _A2>
1352 _LIBCPP_INLINE_VISIBILITY
1353 typename __invoke_return2<type, _A0, _A1 const, _A2>::type
1354 operator() (_A0& __a0, _A1 const& __a1, _A2& __a2) const {
1355 return __invoke(__f_, __a0, __a1, __a2);
1356 }
1357
1358 template <class _A0, class _A1, class _A2>
1359 _LIBCPP_INLINE_VISIBILITY
1360 typename __invoke_return2<type, _A0, _A1, _A2 const>::type
1361 operator() (_A0& __a0, _A1& __a1, _A2 const& __a2) const {
1362 return __invoke(__f_, __a0, __a1, __a2);
1363 }
1364
1365 template <class _A0, class _A1, class _A2>
1366 _LIBCPP_INLINE_VISIBILITY
1367 typename __invoke_return2<type, _A0 const, _A1 const, _A2>::type
1368 operator() (_A0 const& __a0, _A1 const& __a1, _A2& __a2) const {
1369 return __invoke(__f_, __a0, __a1, __a2);
1370 }
1371
1372 template <class _A0, class _A1, class _A2>
1373 _LIBCPP_INLINE_VISIBILITY
1374 typename __invoke_return2<type, _A0 const, _A1, _A2 const>::type
1375 operator() (_A0 const& __a0, _A1& __a1, _A2 const& __a2) const {
1376 return __invoke(__f_, __a0, __a1, __a2);
1377 }
1378
1379 template <class _A0, class _A1, class _A2>
1380 _LIBCPP_INLINE_VISIBILITY
1381 typename __invoke_return2<type, _A0, _A1 const, _A2 const>::type
1382 operator() (_A0& __a0, _A1 const& __a1, _A2 const& __a2) const {
1383 return __invoke(__f_, __a0, __a1, __a2);
1384 }
1385
1386 template <class _A0, class _A1, class _A2>
1387 _LIBCPP_INLINE_VISIBILITY
1388 typename __invoke_return2<type, _A0 const, _A1 const, _A2 const>::type
1389 operator() (_A0 const& __a0, _A1 const& __a1, _A2 const& __a2) const {
1390 return __invoke(__f_, __a0, __a1, __a2);
1391 }
1392#endif
1393};
1394
1395template<class _Rp, class _Tp>
1396inline _LIBCPP_INLINE_VISIBILITY
1397__mem_fn<_Rp _Tp::*>
1398mem_fn(_Rp _Tp::* __pm) _NOEXCEPT
1399{
1400 return __mem_fn<_Rp _Tp::*>(__pm);
1401}
1402
1403////////////////////////////////////////////////////////////////////////////////
1404// FUNCTION
1405//==============================================================================
1406
1407// bad_function_call
1408
1409class _LIBCPP_EXCEPTION_ABI bad_function_call
1410 : public exception
1411{
1412#ifdef _LIBCPP_ABI_BAD_FUNCTION_CALL_KEY_FUNCTION
1413public:
1414 virtual ~bad_function_call() _NOEXCEPT;
1415
1416 virtual const char* what() const _NOEXCEPT;
1417#endif
1418};
1419
1420_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
1421void __throw_bad_function_call()
1422{
1423#ifndef _LIBCPP_NO_EXCEPTIONS
1424 throw bad_function_call();
1425#else
1426 _VSTD::abort();
1427#endif
1428}
1429
1430template<class _Fp> class _LIBCPP_TEMPLATE_VIS function; // undefined
1431
1432namespace __function
1433{
1434
1435template<class _Rp>
1436struct __maybe_derive_from_unary_function
1437{
1438};
1439
1440template<class _Rp, class _A1>
1441struct __maybe_derive_from_unary_function<_Rp(_A1)>
1442 : public unary_function<_A1, _Rp>
1443{
1444};
1445
1446template<class _Rp>
1447struct __maybe_derive_from_binary_function
1448{
1449};
1450
1451template<class _Rp, class _A1, class _A2>
1452struct __maybe_derive_from_binary_function<_Rp(_A1, _A2)>
1453 : public binary_function<_A1, _A2, _Rp>
1454{
1455};
1456
1457template <class _Fp>
1458_LIBCPP_INLINE_VISIBILITY
1459bool __not_null(_Fp const&) { return true; }
1460
1461template <class _Fp>
1462_LIBCPP_INLINE_VISIBILITY
1463bool __not_null(_Fp* __ptr) { return __ptr; }
1464
1465template <class _Ret, class _Class>
1466_LIBCPP_INLINE_VISIBILITY
1467bool __not_null(_Ret _Class::*__ptr) { return __ptr; }
1468
1469template <class _Fp>
1470_LIBCPP_INLINE_VISIBILITY
1471bool __not_null(function<_Fp> const& __f) { return !!__f; }
1472
1473} // namespace __function
1474
1475#ifndef _LIBCPP_CXX03_LANG
1476
1477namespace __function {
1478
1479// __alloc_func holds a functor and an allocator.
1480
1481template <class _Fp, class _Ap, class _FB> class __alloc_func;
1482template <class _Fp, class _FB>
1483class __default_alloc_func;
1484
1485template <class _Fp, class _Ap, class _Rp, class... _ArgTypes>
1486class __alloc_func<_Fp, _Ap, _Rp(_ArgTypes...)>
1487{
1488 __compressed_pair<_Fp, _Ap> __f_;
1489
1490 public:
1491 typedef _LIBCPP_NODEBUG_TYPE _Fp _Target;
1492 typedef _LIBCPP_NODEBUG_TYPE _Ap _Alloc;
1493
1494 _LIBCPP_INLINE_VISIBILITY
1495 const _Target& __target() const { return __f_.first(); }
1496
1497 // WIN32 APIs may define __allocator, so use __get_allocator instead.
1498 _LIBCPP_INLINE_VISIBILITY
1499 const _Alloc& __get_allocator() const { return __f_.second(); }
1500
1501 _LIBCPP_INLINE_VISIBILITY
1502 explicit __alloc_func(_Target&& __f)
1503 : __f_(piecewise_construct, _VSTD::forward_as_tuple(_VSTD::move(__f)),
1504 _VSTD::forward_as_tuple())
1505 {
1506 }
1507
1508 _LIBCPP_INLINE_VISIBILITY
1509 explicit __alloc_func(const _Target& __f, const _Alloc& __a)
1510 : __f_(piecewise_construct, _VSTD::forward_as_tuple(__f),
1511 _VSTD::forward_as_tuple(__a))
1512 {
1513 }
1514
1515 _LIBCPP_INLINE_VISIBILITY
1516 explicit __alloc_func(const _Target& __f, _Alloc&& __a)
1517 : __f_(piecewise_construct, _VSTD::forward_as_tuple(__f),
1518 _VSTD::forward_as_tuple(_VSTD::move(__a)))
1519 {
1520 }
1521
1522 _LIBCPP_INLINE_VISIBILITY
1523 explicit __alloc_func(_Target&& __f, _Alloc&& __a)
1524 : __f_(piecewise_construct, _VSTD::forward_as_tuple(_VSTD::move(__f)),
1525 _VSTD::forward_as_tuple(_VSTD::move(__a)))
1526 {
1527 }
1528
1529 _LIBCPP_INLINE_VISIBILITY
1530 _Rp operator()(_ArgTypes&&... __arg)
1531 {
1532 typedef __invoke_void_return_wrapper<_Rp> _Invoker;
1533 return _Invoker::__call(__f_.first(),
1534 _VSTD::forward<_ArgTypes>(__arg)...);
1535 }
1536
1537 _LIBCPP_INLINE_VISIBILITY
1538 __alloc_func* __clone() const
1539 {
1540 typedef allocator_traits<_Alloc> __alloc_traits;
1541 typedef
1542 typename __rebind_alloc_helper<__alloc_traits, __alloc_func>::type
1543 _AA;
1544 _AA __a(__f_.second());
1545 typedef __allocator_destructor<_AA> _Dp;
1546 unique_ptr<__alloc_func, _Dp> __hold(__a.allocate(1), _Dp(__a, 1));
1547 ::new ((void*)__hold.get()) __alloc_func(__f_.first(), _Alloc(__a));
1548 return __hold.release();
1549 }
1550
1551 _LIBCPP_INLINE_VISIBILITY
1552 void destroy() _NOEXCEPT { __f_.~__compressed_pair<_Target, _Alloc>(); }
1553
1554 static void __destroy_and_delete(__alloc_func* __f) {
1555 typedef allocator_traits<_Alloc> __alloc_traits;
1556 typedef typename __rebind_alloc_helper<__alloc_traits, __alloc_func>::type
1557 _FunAlloc;
1558 _FunAlloc __a(__f->__get_allocator());
1559 __f->destroy();
1560 __a.deallocate(__f, 1);
1561 }
1562};
1563
1564template <class _Fp, class _Rp, class... _ArgTypes>
1565class __default_alloc_func<_Fp, _Rp(_ArgTypes...)> {
1566 _Fp __f_;
1567
1568public:
1569 typedef _LIBCPP_NODEBUG_TYPE _Fp _Target;
1570
1571 _LIBCPP_INLINE_VISIBILITY
1572 const _Target& __target() const { return __f_; }
1573
1574 _LIBCPP_INLINE_VISIBILITY
1575 explicit __default_alloc_func(_Target&& __f) : __f_(std::move(__f)) {}
1576
1577 _LIBCPP_INLINE_VISIBILITY
1578 explicit __default_alloc_func(const _Target& __f) : __f_(__f) {}
1579
1580 _LIBCPP_INLINE_VISIBILITY
1581 _Rp operator()(_ArgTypes&&... __arg) {
1582 typedef __invoke_void_return_wrapper<_Rp> _Invoker;
1583 return _Invoker::__call(__f_, _VSTD::forward<_ArgTypes>(__arg)...);
1584 }
1585
1586 _LIBCPP_INLINE_VISIBILITY
1587 __default_alloc_func* __clone() const {
1588 __builtin_new_allocator::__holder_t __hold =
1589 __builtin_new_allocator::__allocate_type<__default_alloc_func>(1);
1590 __default_alloc_func* __res =
1591 ::new (__hold.get()) __default_alloc_func(__f_);
1592 (void)__hold.release();
1593 return __res;
1594 }
1595
1596 _LIBCPP_INLINE_VISIBILITY
1597 void destroy() _NOEXCEPT { __f_.~_Target(); }
1598
1599 static void __destroy_and_delete(__default_alloc_func* __f) {
1600 __f->destroy();
1601 __builtin_new_allocator::__deallocate_type<__default_alloc_func>(__f, 1);
1602 }
1603};
1604
1605// __base provides an abstract interface for copyable functors.
1606
1607template<class _Fp> class __base;
1608
1609template<class _Rp, class ..._ArgTypes>
1610class __base<_Rp(_ArgTypes...)>
1611{
1612 __base(const __base&);
1613 __base& operator=(const __base&);
1614public:
1615 _LIBCPP_INLINE_VISIBILITY __base() {}
1616 _LIBCPP_INLINE_VISIBILITY virtual ~__base() {}
1617 virtual __base* __clone() const = 0;
1618 virtual void __clone(__base*) const = 0;
1619 virtual void destroy() _NOEXCEPT = 0;
1620 virtual void destroy_deallocate() _NOEXCEPT = 0;
1621 virtual _Rp operator()(_ArgTypes&& ...) = 0;
1622#ifndef _LIBCPP_NO_RTTI
1623 virtual const void* target(const type_info&) const _NOEXCEPT = 0;
1624 virtual const std::type_info& target_type() const _NOEXCEPT = 0;
1625#endif // _LIBCPP_NO_RTTI
1626};
1627
1628// __func implements __base for a given functor type.
1629
1630template<class _FD, class _Alloc, class _FB> class __func;
1631
1632template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
1633class __func<_Fp, _Alloc, _Rp(_ArgTypes...)>
1634 : public __base<_Rp(_ArgTypes...)>
1635{
1636 __alloc_func<_Fp, _Alloc, _Rp(_ArgTypes...)> __f_;
1637public:
1638 _LIBCPP_INLINE_VISIBILITY
1639 explicit __func(_Fp&& __f)
1640 : __f_(_VSTD::move(__f)) {}
1641
1642 _LIBCPP_INLINE_VISIBILITY
1643 explicit __func(const _Fp& __f, const _Alloc& __a)
1644 : __f_(__f, __a) {}
1645
1646 _LIBCPP_INLINE_VISIBILITY
1647 explicit __func(const _Fp& __f, _Alloc&& __a)
1648 : __f_(__f, _VSTD::move(__a)) {}
1649
1650 _LIBCPP_INLINE_VISIBILITY
1651 explicit __func(_Fp&& __f, _Alloc&& __a)
1652 : __f_(_VSTD::move(__f), _VSTD::move(__a)) {}
1653
1654 virtual __base<_Rp(_ArgTypes...)>* __clone() const;
1655 virtual void __clone(__base<_Rp(_ArgTypes...)>*) const;
1656 virtual void destroy() _NOEXCEPT;
1657 virtual void destroy_deallocate() _NOEXCEPT;
1658 virtual _Rp operator()(_ArgTypes&&... __arg);
1659#ifndef _LIBCPP_NO_RTTI
1660 virtual const void* target(const type_info&) const _NOEXCEPT;
1661 virtual const std::type_info& target_type() const _NOEXCEPT;
1662#endif // _LIBCPP_NO_RTTI
1663};
1664
1665template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
1666__base<_Rp(_ArgTypes...)>*
1667__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::__clone() const
1668{
1669 typedef allocator_traits<_Alloc> __alloc_traits;
1670 typedef typename __rebind_alloc_helper<__alloc_traits, __func>::type _Ap;
1671 _Ap __a(__f_.__get_allocator());
1672 typedef __allocator_destructor<_Ap> _Dp;
1673 unique_ptr<__func, _Dp> __hold(__a.allocate(1), _Dp(__a, 1));
1674 ::new ((void*)__hold.get()) __func(__f_.__target(), _Alloc(__a));
1675 return __hold.release();
1676}
1677
1678template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
1679void
1680__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::__clone(__base<_Rp(_ArgTypes...)>* __p) const
1681{
1682 ::new (__p) __func(__f_.__target(), __f_.__get_allocator());
1683}
1684
1685template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
1686void
1687__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::destroy() _NOEXCEPT
1688{
1689 __f_.destroy();
1690}
1691
1692template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
1693void
1694__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::destroy_deallocate() _NOEXCEPT
1695{
1696 typedef allocator_traits<_Alloc> __alloc_traits;
1697 typedef typename __rebind_alloc_helper<__alloc_traits, __func>::type _Ap;
1698 _Ap __a(__f_.__get_allocator());
1699 __f_.destroy();
1700 __a.deallocate(this, 1);
1701}
1702
1703template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
1704_Rp
1705__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::operator()(_ArgTypes&& ... __arg)
1706{
1707 return __f_(_VSTD::forward<_ArgTypes>(__arg)...);
1708}
1709
1710#ifndef _LIBCPP_NO_RTTI
1711
1712template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
1713const void*
1714__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::target(const type_info& __ti) const _NOEXCEPT
1715{
1716 if (__ti == typeid(_Fp))
1717 return &__f_.__target();
1718 return (const void*)0;
1719}
1720
1721template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
1722const std::type_info&
1723__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::target_type() const _NOEXCEPT
1724{
1725 return typeid(_Fp);
1726}
1727
1728#endif // _LIBCPP_NO_RTTI
1729
1730// __value_func creates a value-type from a __func.
1731
1732template <class _Fp> class __value_func;
1733
1734template <class _Rp, class... _ArgTypes> class __value_func<_Rp(_ArgTypes...)>
1735{
1736 typename aligned_storage<3 * sizeof(void*)>::type __buf_;
1737
1738 typedef __base<_Rp(_ArgTypes...)> __func;
1739 __func* __f_;
1740
1741 _LIBCPP_NO_CFI static __func* __as_base(void* p)
1742 {
1743 return reinterpret_cast<__func*>(p);
1744 }
1745
1746 public:
1747 _LIBCPP_INLINE_VISIBILITY
1748 __value_func() _NOEXCEPT : __f_(0) {}
1749
1750 template <class _Fp, class _Alloc>
1751 _LIBCPP_INLINE_VISIBILITY __value_func(_Fp&& __f, const _Alloc& __a)
1752 : __f_(0)
1753 {
1754 typedef allocator_traits<_Alloc> __alloc_traits;
1755 typedef __function::__func<_Fp, _Alloc, _Rp(_ArgTypes...)> _Fun;
1756 typedef typename __rebind_alloc_helper<__alloc_traits, _Fun>::type
1757 _FunAlloc;
1758
1759 if (__function::__not_null(__f))
1760 {
1761 _FunAlloc __af(__a);
1762 if (sizeof(_Fun) <= sizeof(__buf_) &&
1763 is_nothrow_copy_constructible<_Fp>::value &&
1764 is_nothrow_copy_constructible<_FunAlloc>::value)
1765 {
1766 __f_ =
1767 ::new ((void*)&__buf_) _Fun(_VSTD::move(__f), _Alloc(__af));
1768 }
1769 else
1770 {
1771 typedef __allocator_destructor<_FunAlloc> _Dp;
1772 unique_ptr<__func, _Dp> __hold(__af.allocate(1), _Dp(__af, 1));
1773 ::new ((void*)__hold.get()) _Fun(_VSTD::move(__f), _Alloc(__a));
1774 __f_ = __hold.release();
1775 }
1776 }
1777 }
1778
1779 template <class _Fp,
1780 class = typename enable_if<!is_same<typename decay<_Fp>::type, __value_func>::value>::type>
1781 _LIBCPP_INLINE_VISIBILITY explicit __value_func(_Fp&& __f)
1782 : __value_func(std::forward<_Fp>(__f), allocator<_Fp>()) {}
1783
1784 _LIBCPP_INLINE_VISIBILITY
1785 __value_func(const __value_func& __f)
1786 {
1787 if (__f.__f_ == 0)
1788 __f_ = 0;
1789 else if ((void*)__f.__f_ == &__f.__buf_)
1790 {
1791 __f_ = __as_base(&__buf_);
1792 __f.__f_->__clone(__f_);
1793 }
1794 else
1795 __f_ = __f.__f_->__clone();
1796 }
1797
1798 _LIBCPP_INLINE_VISIBILITY
1799 __value_func(__value_func&& __f) _NOEXCEPT
1800 {
1801 if (__f.__f_ == 0)
1802 __f_ = 0;
1803 else if ((void*)__f.__f_ == &__f.__buf_)
1804 {
1805 __f_ = __as_base(&__buf_);
1806 __f.__f_->__clone(__f_);
1807 }
1808 else
1809 {
1810 __f_ = __f.__f_;
1811 __f.__f_ = 0;
1812 }
1813 }
1814
1815 _LIBCPP_INLINE_VISIBILITY
1816 ~__value_func()
1817 {
1818 if ((void*)__f_ == &__buf_)
1819 __f_->destroy();
1820 else if (__f_)
1821 __f_->destroy_deallocate();
1822 }
1823
1824 _LIBCPP_INLINE_VISIBILITY
1825 __value_func& operator=(__value_func&& __f)
1826 {
1827 *this = nullptr;
1828 if (__f.__f_ == 0)
1829 __f_ = 0;
1830 else if ((void*)__f.__f_ == &__f.__buf_)
1831 {
1832 __f_ = __as_base(&__buf_);
1833 __f.__f_->__clone(__f_);
1834 }
1835 else
1836 {
1837 __f_ = __f.__f_;
1838 __f.__f_ = 0;
1839 }
1840 return *this;
1841 }
1842
1843 _LIBCPP_INLINE_VISIBILITY
1844 __value_func& operator=(nullptr_t)
1845 {
1846 __func* __f = __f_;
1847 __f_ = 0;
1848 if ((void*)__f == &__buf_)
1849 __f->destroy();
1850 else if (__f)
1851 __f->destroy_deallocate();
1852 return *this;
1853 }
1854
1855 _LIBCPP_INLINE_VISIBILITY
1856 _Rp operator()(_ArgTypes&&... __args) const
1857 {
1858 if (__f_ == 0)
1859 __throw_bad_function_call();
1860 return (*__f_)(_VSTD::forward<_ArgTypes>(__args)...);
1861 }
1862
1863 _LIBCPP_INLINE_VISIBILITY
1864 void swap(__value_func& __f) _NOEXCEPT
1865 {
1866 if (&__f == this)
1867 return;
1868 if ((void*)__f_ == &__buf_ && (void*)__f.__f_ == &__f.__buf_)
1869 {
1870 typename aligned_storage<sizeof(__buf_)>::type __tempbuf;
1871 __func* __t = __as_base(&__tempbuf);
1872 __f_->__clone(__t);
1873 __f_->destroy();
1874 __f_ = 0;
1875 __f.__f_->__clone(__as_base(&__buf_));
1876 __f.__f_->destroy();
1877 __f.__f_ = 0;
1878 __f_ = __as_base(&__buf_);
1879 __t->__clone(__as_base(&__f.__buf_));
1880 __t->destroy();
1881 __f.__f_ = __as_base(&__f.__buf_);
1882 }
1883 else if ((void*)__f_ == &__buf_)
1884 {
1885 __f_->__clone(__as_base(&__f.__buf_));
1886 __f_->destroy();
1887 __f_ = __f.__f_;
1888 __f.__f_ = __as_base(&__f.__buf_);
1889 }
1890 else if ((void*)__f.__f_ == &__f.__buf_)
1891 {
1892 __f.__f_->__clone(__as_base(&__buf_));
1893 __f.__f_->destroy();
1894 __f.__f_ = __f_;
1895 __f_ = __as_base(&__buf_);
1896 }
1897 else
1898 _VSTD::swap(__f_, __f.__f_);
1899 }
1900
1901 _LIBCPP_INLINE_VISIBILITY
1902 _LIBCPP_EXPLICIT operator bool() const _NOEXCEPT { return __f_ != 0; }
1903
1904#ifndef _LIBCPP_NO_RTTI
1905 _LIBCPP_INLINE_VISIBILITY
1906 const std::type_info& target_type() const _NOEXCEPT
1907 {
1908 if (__f_ == 0)
1909 return typeid(void);
1910 return __f_->target_type();
1911 }
1912
1913 template <typename _Tp>
1914 _LIBCPP_INLINE_VISIBILITY const _Tp* target() const _NOEXCEPT
1915 {
1916 if (__f_ == 0)
1917 return 0;
1918 return (const _Tp*)__f_->target(typeid(_Tp));
1919 }
1920#endif // _LIBCPP_NO_RTTI
1921};
1922
1923// Storage for a functor object, to be used with __policy to manage copy and
1924// destruction.
1925union __policy_storage
1926{
1927 mutable char __small[sizeof(void*) * 2];
1928 void* __large;
1929};
1930
1931// True if _Fun can safely be held in __policy_storage.__small.
1932template <typename _Fun>
1933struct __use_small_storage
1934 : public _VSTD::integral_constant<
1935 bool, sizeof(_Fun) <= sizeof(__policy_storage) &&
1936 _LIBCPP_ALIGNOF(_Fun) <= _LIBCPP_ALIGNOF(__policy_storage) &&
1937 _VSTD::is_trivially_copy_constructible<_Fun>::value &&
1938 _VSTD::is_trivially_destructible<_Fun>::value> {};
1939
1940// Policy contains information about how to copy, destroy, and move the
1941// underlying functor. You can think of it as a vtable of sorts.
1942struct __policy
1943{
1944 // Used to copy or destroy __large values. null for trivial objects.
1945 void* (*const __clone)(const void*);
1946 void (*const __destroy)(void*);
1947
1948 // True if this is the null policy (no value).
1949 const bool __is_null;
1950
1951 // The target type. May be null if RTTI is disabled.
1952 const std::type_info* const __type_info;
1953
1954 // Returns a pointer to a static policy object suitable for the functor
1955 // type.
1956 template <typename _Fun>
1957 _LIBCPP_INLINE_VISIBILITY static const __policy* __create()
1958 {
1959 return __choose_policy<_Fun>(__use_small_storage<_Fun>());
1960 }
1961
1962 _LIBCPP_INLINE_VISIBILITY
1963 static const __policy* __create_empty()
1964 {
1965 static const _LIBCPP_CONSTEXPR __policy __policy_ = {nullptr, nullptr,
1966 true,
1967#ifndef _LIBCPP_NO_RTTI
1968 &typeid(void)
1969#else
1970 nullptr
1971#endif
1972 };
1973 return &__policy_;
1974 }
1975
1976 private:
1977 template <typename _Fun> static void* __large_clone(const void* __s)
1978 {
1979 const _Fun* __f = static_cast<const _Fun*>(__s);
1980 return __f->__clone();
1981 }
1982
1983 template <typename _Fun>
1984 static void __large_destroy(void* __s) {
1985 _Fun::__destroy_and_delete(static_cast<_Fun*>(__s));
1986 }
1987
1988 template <typename _Fun>
1989 _LIBCPP_INLINE_VISIBILITY static const __policy*
1990 __choose_policy(/* is_small = */ false_type) {
1991 static const _LIBCPP_CONSTEXPR __policy __policy_ = {
1992 &__large_clone<_Fun>, &__large_destroy<_Fun>, false,
1993#ifndef _LIBCPP_NO_RTTI
1994 &typeid(typename _Fun::_Target)
1995#else
1996 nullptr
1997#endif
1998 };
1999 return &__policy_;
2000 }
2001
2002 template <typename _Fun>
2003 _LIBCPP_INLINE_VISIBILITY static const __policy*
2004 __choose_policy(/* is_small = */ true_type)
2005 {
2006 static const _LIBCPP_CONSTEXPR __policy __policy_ = {
2007 nullptr, nullptr, false,
2008#ifndef _LIBCPP_NO_RTTI
2009 &typeid(typename _Fun::_Target)
2010#else
2011 nullptr
2012#endif
2013 };
2014 return &__policy_;
2015 }
2016};
2017
2018// Used to choose between perfect forwarding or pass-by-value. Pass-by-value is
2019// faster for types that can be passed in registers.
2020template <typename _Tp>
2021using __fast_forward =
2022 typename _VSTD::conditional<_VSTD::is_scalar<_Tp>::value, _Tp, _Tp&&>::type;
2023
2024// __policy_invoker calls an instance of __alloc_func held in __policy_storage.
2025
2026template <class _Fp> struct __policy_invoker;
2027
2028template <class _Rp, class... _ArgTypes>
2029struct __policy_invoker<_Rp(_ArgTypes...)>
2030{
2031 typedef _Rp (*__Call)(const __policy_storage*,
2032 __fast_forward<_ArgTypes>...);
2033
2034 __Call __call_;
2035
2036 // Creates an invoker that throws bad_function_call.
2037 _LIBCPP_INLINE_VISIBILITY
2038 __policy_invoker() : __call_(&__call_empty) {}
2039
2040 // Creates an invoker that calls the given instance of __func.
2041 template <typename _Fun>
2042 _LIBCPP_INLINE_VISIBILITY static __policy_invoker __create()
2043 {
2044 return __policy_invoker(&__call_impl<_Fun>);
2045 }
2046
2047 private:
2048 _LIBCPP_INLINE_VISIBILITY
2049 explicit __policy_invoker(__Call __c) : __call_(__c) {}
2050
2051 static _Rp __call_empty(const __policy_storage*,
2052 __fast_forward<_ArgTypes>...)
2053 {
2054 __throw_bad_function_call();
2055 }
2056
2057 template <typename _Fun>
2058 static _Rp __call_impl(const __policy_storage* __buf,
2059 __fast_forward<_ArgTypes>... __args)
2060 {
2061 _Fun* __f = reinterpret_cast<_Fun*>(__use_small_storage<_Fun>::value
2062 ? &__buf->__small
2063 : __buf->__large);
2064 return (*__f)(_VSTD::forward<_ArgTypes>(__args)...);
2065 }
2066};
2067
2068// __policy_func uses a __policy and __policy_invoker to create a type-erased,
2069// copyable functor.
2070
2071template <class _Fp> class __policy_func;
2072
2073template <class _Rp, class... _ArgTypes> class __policy_func<_Rp(_ArgTypes...)>
2074{
2075 // Inline storage for small objects.
2076 __policy_storage __buf_;
2077
2078 // Calls the value stored in __buf_. This could technically be part of
2079 // policy, but storing it here eliminates a level of indirection inside
2080 // operator().
2081 typedef __function::__policy_invoker<_Rp(_ArgTypes...)> __invoker;
2082 __invoker __invoker_;
2083
2084 // The policy that describes how to move / copy / destroy __buf_. Never
2085 // null, even if the function is empty.
2086 const __policy* __policy_;
2087
2088 public:
2089 _LIBCPP_INLINE_VISIBILITY
2090 __policy_func() : __policy_(__policy::__create_empty()) {}
2091
2092 template <class _Fp, class _Alloc>
2093 _LIBCPP_INLINE_VISIBILITY __policy_func(_Fp&& __f, const _Alloc& __a)
2094 : __policy_(__policy::__create_empty())
2095 {
2096 typedef __alloc_func<_Fp, _Alloc, _Rp(_ArgTypes...)> _Fun;
2097 typedef allocator_traits<_Alloc> __alloc_traits;
2098 typedef typename __rebind_alloc_helper<__alloc_traits, _Fun>::type
2099 _FunAlloc;
2100
2101 if (__function::__not_null(__f))
2102 {
2103 __invoker_ = __invoker::template __create<_Fun>();
2104 __policy_ = __policy::__create<_Fun>();
2105
2106 _FunAlloc __af(__a);
2107 if (__use_small_storage<_Fun>())
2108 {
2109 ::new ((void*)&__buf_.__small)
2110 _Fun(_VSTD::move(__f), _Alloc(__af));
2111 }
2112 else
2113 {
2114 typedef __allocator_destructor<_FunAlloc> _Dp;
2115 unique_ptr<_Fun, _Dp> __hold(__af.allocate(1), _Dp(__af, 1));
2116 ::new ((void*)__hold.get())
2117 _Fun(_VSTD::move(__f), _Alloc(__af));
2118 __buf_.__large = __hold.release();
2119 }
2120 }
2121 }
2122
2123 template <class _Fp, class = typename enable_if<!is_same<typename decay<_Fp>::type, __policy_func>::value>::type>
2124 _LIBCPP_INLINE_VISIBILITY explicit __policy_func(_Fp&& __f)
2125 : __policy_(__policy::__create_empty()) {
2126 typedef __default_alloc_func<_Fp, _Rp(_ArgTypes...)> _Fun;
2127
2128 if (__function::__not_null(__f)) {
2129 __invoker_ = __invoker::template __create<_Fun>();
2130 __policy_ = __policy::__create<_Fun>();
2131 if (__use_small_storage<_Fun>()) {
2132 ::new ((void*)&__buf_.__small) _Fun(_VSTD::move(__f));
2133 } else {
2134 __builtin_new_allocator::__holder_t __hold =
2135 __builtin_new_allocator::__allocate_type<_Fun>(1);
2136 __buf_.__large = ::new (__hold.get()) _Fun(_VSTD::move(__f));
2137 (void)__hold.release();
2138 }
2139 }
2140 }
2141
2142 _LIBCPP_INLINE_VISIBILITY
2143 __policy_func(const __policy_func& __f)
2144 : __buf_(__f.__buf_), __invoker_(__f.__invoker_),
2145 __policy_(__f.__policy_)
2146 {
2147 if (__policy_->__clone)
2148 __buf_.__large = __policy_->__clone(__f.__buf_.__large);
2149 }
2150
2151 _LIBCPP_INLINE_VISIBILITY
2152 __policy_func(__policy_func&& __f)
2153 : __buf_(__f.__buf_), __invoker_(__f.__invoker_),
2154 __policy_(__f.__policy_)
2155 {
2156 if (__policy_->__destroy)
2157 {
2158 __f.__policy_ = __policy::__create_empty();
2159 __f.__invoker_ = __invoker();
2160 }
2161 }
2162
2163 _LIBCPP_INLINE_VISIBILITY
2164 ~__policy_func()
2165 {
2166 if (__policy_->__destroy)
2167 __policy_->__destroy(__buf_.__large);
2168 }
2169
2170 _LIBCPP_INLINE_VISIBILITY
2171 __policy_func& operator=(__policy_func&& __f)
2172 {
2173 *this = nullptr;
2174 __buf_ = __f.__buf_;
2175 __invoker_ = __f.__invoker_;
2176 __policy_ = __f.__policy_;
2177 __f.__policy_ = __policy::__create_empty();
2178 __f.__invoker_ = __invoker();
2179 return *this;
2180 }
2181
2182 _LIBCPP_INLINE_VISIBILITY
2183 __policy_func& operator=(nullptr_t)
2184 {
2185 const __policy* __p = __policy_;
2186 __policy_ = __policy::__create_empty();
2187 __invoker_ = __invoker();
2188 if (__p->__destroy)
2189 __p->__destroy(__buf_.__large);
2190 return *this;
2191 }
2192
2193 _LIBCPP_INLINE_VISIBILITY
2194 _Rp operator()(_ArgTypes&&... __args) const
2195 {
2196 return __invoker_.__call_(_VSTD::addressof(__buf_),
2197 _VSTD::forward<_ArgTypes>(__args)...);
2198 }
2199
2200 _LIBCPP_INLINE_VISIBILITY
2201 void swap(__policy_func& __f)
2202 {
2203 _VSTD::swap(__invoker_, __f.__invoker_);
2204 _VSTD::swap(__policy_, __f.__policy_);
2205 _VSTD::swap(__buf_, __f.__buf_);
2206 }
2207
2208 _LIBCPP_INLINE_VISIBILITY
2209 explicit operator bool() const _NOEXCEPT
2210 {
2211 return !__policy_->__is_null;
2212 }
2213
2214#ifndef _LIBCPP_NO_RTTI
2215 _LIBCPP_INLINE_VISIBILITY
2216 const std::type_info& target_type() const _NOEXCEPT
2217 {
2218 return *__policy_->__type_info;
2219 }
2220
2221 template <typename _Tp>
2222 _LIBCPP_INLINE_VISIBILITY const _Tp* target() const _NOEXCEPT
2223 {
2224 if (__policy_->__is_null || typeid(_Tp) != *__policy_->__type_info)
2225 return nullptr;
2226 if (__policy_->__clone) // Out of line storage.
2227 return reinterpret_cast<const _Tp*>(__buf_.__large);
2228 else
2229 return reinterpret_cast<const _Tp*>(&__buf_.__small);
2230 }
2231#endif // _LIBCPP_NO_RTTI
2232};
2233
2234} // __function
2235
2236template<class _Rp, class ..._ArgTypes>
2237class _LIBCPP_TEMPLATE_VIS function<_Rp(_ArgTypes...)>
2238 : public __function::__maybe_derive_from_unary_function<_Rp(_ArgTypes...)>,
2239 public __function::__maybe_derive_from_binary_function<_Rp(_ArgTypes...)>
2240{
2241#ifndef _LIBCPP_ABI_OPTIMIZED_FUNCTION
2242 typedef __function::__value_func<_Rp(_ArgTypes...)> __func;
2243#else
2244 typedef __function::__policy_func<_Rp(_ArgTypes...)> __func;
2245#endif
2246
2247 __func __f_;
2248
2249 template <class _Fp, bool = _And<
2250 _IsNotSame<__uncvref_t<_Fp>, function>,
2251 __invokable<_Fp&, _ArgTypes...>
2252 >::value>
2253 struct __callable;
2254 template <class _Fp>
2255 struct __callable<_Fp, true>
2256 {
2257 static const bool value = is_same<void, _Rp>::value ||
2258 is_convertible<typename __invoke_of<_Fp&, _ArgTypes...>::type,
2259 _Rp>::value;
2260 };
2261 template <class _Fp>
2262 struct __callable<_Fp, false>
2263 {
2264 static const bool value = false;
2265 };
2266
2267 template <class _Fp>
2268 using _EnableIfCallable = typename enable_if<__callable<_Fp>::value>::type;
2269public:
2270 typedef _Rp result_type;
2271
2272 // construct/copy/destroy:
2273 _LIBCPP_INLINE_VISIBILITY
2274 function() _NOEXCEPT { }
2275 _LIBCPP_INLINE_VISIBILITY
2276 function(nullptr_t) _NOEXCEPT {}
2277 function(const function&);
2278 function(function&&) _NOEXCEPT;
2279 template<class _Fp, class = _EnableIfCallable<_Fp>>
2280 function(_Fp);
2281
2282#if _LIBCPP_STD_VER <= 14
2283 template<class _Alloc>
2284 _LIBCPP_INLINE_VISIBILITY
2285 function(allocator_arg_t, const _Alloc&) _NOEXCEPT {}
2286 template<class _Alloc>
2287 _LIBCPP_INLINE_VISIBILITY
2288 function(allocator_arg_t, const _Alloc&, nullptr_t) _NOEXCEPT {}
2289 template<class _Alloc>
2290 function(allocator_arg_t, const _Alloc&, const function&);
2291 template<class _Alloc>
2292 function(allocator_arg_t, const _Alloc&, function&&);
2293 template<class _Fp, class _Alloc, class = _EnableIfCallable<_Fp>>
2294 function(allocator_arg_t, const _Alloc& __a, _Fp __f);
2295#endif
2296
2297 function& operator=(const function&);
2298 function& operator=(function&&) _NOEXCEPT;
2299 function& operator=(nullptr_t) _NOEXCEPT;
2300 template<class _Fp, class = _EnableIfCallable<_Fp>>
2301 function& operator=(_Fp&&);
2302
2303 ~function();
2304
2305 // function modifiers:
2306 void swap(function&) _NOEXCEPT;
2307
2308#if _LIBCPP_STD_VER <= 14
2309 template<class _Fp, class _Alloc>
2310 _LIBCPP_INLINE_VISIBILITY
2311 void assign(_Fp&& __f, const _Alloc& __a)
2312 {function(allocator_arg, __a, _VSTD::forward<_Fp>(__f)).swap(*this);}
2313#endif
2314
2315 // function capacity:
2316 _LIBCPP_INLINE_VISIBILITY
2317 _LIBCPP_EXPLICIT operator bool() const _NOEXCEPT {
2318 return static_cast<bool>(__f_);
2319 }
2320
2321 // deleted overloads close possible hole in the type system
2322 template<class _R2, class... _ArgTypes2>
2323 bool operator==(const function<_R2(_ArgTypes2...)>&) const = delete;
2324 template<class _R2, class... _ArgTypes2>
2325 bool operator!=(const function<_R2(_ArgTypes2...)>&) const = delete;
2326public:
2327 // function invocation:
2328 _Rp operator()(_ArgTypes...) const;
2329
2330#ifndef _LIBCPP_NO_RTTI
2331 // function target access:
2332 const std::type_info& target_type() const _NOEXCEPT;
2333 template <typename _Tp> _Tp* target() _NOEXCEPT;
2334 template <typename _Tp> const _Tp* target() const _NOEXCEPT;
2335#endif // _LIBCPP_NO_RTTI
2336};
2337
2338template<class _Rp, class ..._ArgTypes>
2339function<_Rp(_ArgTypes...)>::function(const function& __f) : __f_(__f.__f_) {}
2340
2341#if _LIBCPP_STD_VER <= 14
2342template<class _Rp, class ..._ArgTypes>
2343template <class _Alloc>
2344function<_Rp(_ArgTypes...)>::function(allocator_arg_t, const _Alloc&,
2345 const function& __f) : __f_(__f.__f_) {}
2346#endif
2347
2348template <class _Rp, class... _ArgTypes>
2349function<_Rp(_ArgTypes...)>::function(function&& __f) _NOEXCEPT
2350 : __f_(_VSTD::move(__f.__f_)) {}
2351
2352#if _LIBCPP_STD_VER <= 14
2353template<class _Rp, class ..._ArgTypes>
2354template <class _Alloc>
2355function<_Rp(_ArgTypes...)>::function(allocator_arg_t, const _Alloc&,
2356 function&& __f)
2357 : __f_(_VSTD::move(__f.__f_)) {}
2358#endif
2359
2360template <class _Rp, class... _ArgTypes>
2361template <class _Fp, class>
2362function<_Rp(_ArgTypes...)>::function(_Fp __f) : __f_(_VSTD::move(__f)) {}
2363
2364#if _LIBCPP_STD_VER <= 14
2365template <class _Rp, class... _ArgTypes>
2366template <class _Fp, class _Alloc, class>
2367function<_Rp(_ArgTypes...)>::function(allocator_arg_t, const _Alloc& __a,
2368 _Fp __f)
2369 : __f_(_VSTD::move(__f), __a) {}
2370#endif
2371
2372template<class _Rp, class ..._ArgTypes>
2373function<_Rp(_ArgTypes...)>&
2374function<_Rp(_ArgTypes...)>::operator=(const function& __f)
2375{
2376 function(__f).swap(*this);
2377 return *this;
2378}
2379
2380template<class _Rp, class ..._ArgTypes>
2381function<_Rp(_ArgTypes...)>&
2382function<_Rp(_ArgTypes...)>::operator=(function&& __f) _NOEXCEPT
2383{
2384 __f_ = std::move(__f.__f_);
2385 return *this;
2386}
2387
2388template<class _Rp, class ..._ArgTypes>
2389function<_Rp(_ArgTypes...)>&
2390function<_Rp(_ArgTypes...)>::operator=(nullptr_t) _NOEXCEPT
2391{
2392 __f_ = nullptr;
2393 return *this;
2394}
2395
2396template<class _Rp, class ..._ArgTypes>
2397template <class _Fp, class>
2398function<_Rp(_ArgTypes...)>&
2399function<_Rp(_ArgTypes...)>::operator=(_Fp&& __f)
2400{
2401 function(_VSTD::forward<_Fp>(__f)).swap(*this);
2402 return *this;
2403}
2404
2405template<class _Rp, class ..._ArgTypes>
2406function<_Rp(_ArgTypes...)>::~function() {}
2407
2408template<class _Rp, class ..._ArgTypes>
2409void
2410function<_Rp(_ArgTypes...)>::swap(function& __f) _NOEXCEPT
2411{
2412 __f_.swap(__f.__f_);
2413}
2414
2415template<class _Rp, class ..._ArgTypes>
2416_Rp
2417function<_Rp(_ArgTypes...)>::operator()(_ArgTypes... __arg) const
2418{
2419 return __f_(_VSTD::forward<_ArgTypes>(__arg)...);
2420}
2421
2422#ifndef _LIBCPP_NO_RTTI
2423
2424template<class _Rp, class ..._ArgTypes>
2425const std::type_info&
2426function<_Rp(_ArgTypes...)>::target_type() const _NOEXCEPT
2427{
2428 return __f_.target_type();
2429}
2430
2431template<class _Rp, class ..._ArgTypes>
2432template <typename _Tp>
2433_Tp*
2434function<_Rp(_ArgTypes...)>::target() _NOEXCEPT
2435{
2436 return (_Tp*)(__f_.template target<_Tp>());
2437}
2438
2439template<class _Rp, class ..._ArgTypes>
2440template <typename _Tp>
2441const _Tp*
2442function<_Rp(_ArgTypes...)>::target() const _NOEXCEPT
2443{
2444 return __f_.template target<_Tp>();
2445}
2446
2447#endif // _LIBCPP_NO_RTTI
2448
2449template <class _Rp, class... _ArgTypes>
2450inline _LIBCPP_INLINE_VISIBILITY
2451bool
2452operator==(const function<_Rp(_ArgTypes...)>& __f, nullptr_t) _NOEXCEPT {return !__f;}
2453
2454template <class _Rp, class... _ArgTypes>
2455inline _LIBCPP_INLINE_VISIBILITY
2456bool
2457operator==(nullptr_t, const function<_Rp(_ArgTypes...)>& __f) _NOEXCEPT {return !__f;}
2458
2459template <class _Rp, class... _ArgTypes>
2460inline _LIBCPP_INLINE_VISIBILITY
2461bool
2462operator!=(const function<_Rp(_ArgTypes...)>& __f, nullptr_t) _NOEXCEPT {return (bool)__f;}
2463
2464template <class _Rp, class... _ArgTypes>
2465inline _LIBCPP_INLINE_VISIBILITY
2466bool
2467operator!=(nullptr_t, const function<_Rp(_ArgTypes...)>& __f) _NOEXCEPT {return (bool)__f;}
2468
2469template <class _Rp, class... _ArgTypes>
2470inline _LIBCPP_INLINE_VISIBILITY
2471void
2472swap(function<_Rp(_ArgTypes...)>& __x, function<_Rp(_ArgTypes...)>& __y) _NOEXCEPT
2473{return __x.swap(__y);}
2474
2475#else // _LIBCPP_CXX03_LANG
2476
2477#include <__functional_03>
2478
2479#endif
2480
2481////////////////////////////////////////////////////////////////////////////////
2482// BIND
2483//==============================================================================
2484
2485template<class _Tp> struct __is_bind_expression : public false_type {};
2486template<class _Tp> struct _LIBCPP_TEMPLATE_VIS is_bind_expression
2487 : public __is_bind_expression<typename remove_cv<_Tp>::type> {};
2488
2489#if _LIBCPP_STD_VER > 14
2490template <class _Tp>
2491_LIBCPP_INLINE_VAR constexpr size_t is_bind_expression_v = is_bind_expression<_Tp>::value;
2492#endif
2493
2494template<class _Tp> struct __is_placeholder : public integral_constant<int, 0> {};
2495template<class _Tp> struct _LIBCPP_TEMPLATE_VIS is_placeholder
2496 : public __is_placeholder<typename remove_cv<_Tp>::type> {};
2497
2498#if _LIBCPP_STD_VER > 14
2499template <class _Tp>
2500_LIBCPP_INLINE_VAR constexpr size_t is_placeholder_v = is_placeholder<_Tp>::value;
2501#endif
2502
2503namespace placeholders
2504{
2505
2506template <int _Np> struct __ph {};
2507
2508#if defined(_LIBCPP_CXX03_LANG) || defined(_LIBCPP_BUILDING_LIBRARY)
2509_LIBCPP_FUNC_VIS extern const __ph<1> _1;
2510_LIBCPP_FUNC_VIS extern const __ph<2> _2;
2511_LIBCPP_FUNC_VIS extern const __ph<3> _3;
2512_LIBCPP_FUNC_VIS extern const __ph<4> _4;
2513_LIBCPP_FUNC_VIS extern const __ph<5> _5;
2514_LIBCPP_FUNC_VIS extern const __ph<6> _6;
2515_LIBCPP_FUNC_VIS extern const __ph<7> _7;
2516_LIBCPP_FUNC_VIS extern const __ph<8> _8;
2517_LIBCPP_FUNC_VIS extern const __ph<9> _9;
2518_LIBCPP_FUNC_VIS extern const __ph<10> _10;
2519#else
2520/* _LIBCPP_INLINE_VAR */ constexpr __ph<1> _1{};
2521/* _LIBCPP_INLINE_VAR */ constexpr __ph<2> _2{};
2522/* _LIBCPP_INLINE_VAR */ constexpr __ph<3> _3{};
2523/* _LIBCPP_INLINE_VAR */ constexpr __ph<4> _4{};
2524/* _LIBCPP_INLINE_VAR */ constexpr __ph<5> _5{};
2525/* _LIBCPP_INLINE_VAR */ constexpr __ph<6> _6{};
2526/* _LIBCPP_INLINE_VAR */ constexpr __ph<7> _7{};
2527/* _LIBCPP_INLINE_VAR */ constexpr __ph<8> _8{};
2528/* _LIBCPP_INLINE_VAR */ constexpr __ph<9> _9{};
2529/* _LIBCPP_INLINE_VAR */ constexpr __ph<10> _10{};
2530#endif // defined(_LIBCPP_CXX03_LANG) || defined(_LIBCPP_BUILDING_LIBRARY)
2531
2532} // placeholders
2533
2534template<int _Np>
2535struct __is_placeholder<placeholders::__ph<_Np> >
2536 : public integral_constant<int, _Np> {};
2537
2538
2539#ifndef _LIBCPP_CXX03_LANG
2540
2541template <class _Tp, class _Uj>
2542inline _LIBCPP_INLINE_VISIBILITY
2543_Tp&
2544__mu(reference_wrapper<_Tp> __t, _Uj&)
2545{
2546 return __t.get();
2547}
2548
2549template <class _Ti, class ..._Uj, size_t ..._Indx>
2550inline _LIBCPP_INLINE_VISIBILITY
2551typename __invoke_of<_Ti&, _Uj...>::type
2552__mu_expand(_Ti& __ti, tuple<_Uj...>& __uj, __tuple_indices<_Indx...>)
2553{
2554 return __ti(_VSTD::forward<_Uj>(_VSTD::get<_Indx>(__uj))...);
2555}
2556
2557template <class _Ti, class ..._Uj>
2558inline _LIBCPP_INLINE_VISIBILITY
2559typename _EnableIf
2560<
2561 is_bind_expression<_Ti>::value,
2562 __invoke_of<_Ti&, _Uj...>
2563>::type
2564__mu(_Ti& __ti, tuple<_Uj...>& __uj)
2565{
2566 typedef typename __make_tuple_indices<sizeof...(_Uj)>::type __indices;
2567 return __mu_expand(__ti, __uj, __indices());
2568}
2569
2570template <bool IsPh, class _Ti, class _Uj>
2571struct __mu_return2 {};
2572
2573template <class _Ti, class _Uj>
2574struct __mu_return2<true, _Ti, _Uj>
2575{
2576 typedef typename tuple_element<is_placeholder<_Ti>::value - 1, _Uj>::type type;
2577};
2578
2579template <class _Ti, class _Uj>
2580inline _LIBCPP_INLINE_VISIBILITY
2581typename enable_if
2582<
2583 0 < is_placeholder<_Ti>::value,
2584 typename __mu_return2<0 < is_placeholder<_Ti>::value, _Ti, _Uj>::type
2585>::type
2586__mu(_Ti&, _Uj& __uj)
2587{
2588 const size_t _Indx = is_placeholder<_Ti>::value - 1;
2589 return _VSTD::forward<typename tuple_element<_Indx, _Uj>::type>(_VSTD::get<_Indx>(__uj));
2590}
2591
2592template <class _Ti, class _Uj>
2593inline _LIBCPP_INLINE_VISIBILITY
2594typename enable_if
2595<
2596 !is_bind_expression<_Ti>::value &&
2597 is_placeholder<_Ti>::value == 0 &&
2598 !__is_reference_wrapper<_Ti>::value,
2599 _Ti&
2600>::type
2601__mu(_Ti& __ti, _Uj&)
2602{
2603 return __ti;
2604}
2605
2606template <class _Ti, bool IsReferenceWrapper, bool IsBindEx, bool IsPh,
2607 class _TupleUj>
2608struct __mu_return_impl;
2609
2610template <bool _Invokable, class _Ti, class ..._Uj>
2611struct __mu_return_invokable // false
2612{
2613 typedef __nat type;
2614};
2615
2616template <class _Ti, class ..._Uj>
2617struct __mu_return_invokable<true, _Ti, _Uj...>
2618{
2619 typedef typename __invoke_of<_Ti&, _Uj...>::type type;
2620};
2621
2622template <class _Ti, class ..._Uj>
2623struct __mu_return_impl<_Ti, false, true, false, tuple<_Uj...> >
2624 : public __mu_return_invokable<__invokable<_Ti&, _Uj...>::value, _Ti, _Uj...>
2625{
2626};
2627
2628template <class _Ti, class _TupleUj>
2629struct __mu_return_impl<_Ti, false, false, true, _TupleUj>
2630{
2631 typedef typename tuple_element<is_placeholder<_Ti>::value - 1,
2632 _TupleUj>::type&& type;
2633};
2634
2635template <class _Ti, class _TupleUj>
2636struct __mu_return_impl<_Ti, true, false, false, _TupleUj>
2637{
2638 typedef typename _Ti::type& type;
2639};
2640
2641template <class _Ti, class _TupleUj>
2642struct __mu_return_impl<_Ti, false, false, false, _TupleUj>
2643{
2644 typedef _Ti& type;
2645};
2646
2647template <class _Ti, class _TupleUj>
2648struct __mu_return
2649 : public __mu_return_impl<_Ti,
2650 __is_reference_wrapper<_Ti>::value,
2651 is_bind_expression<_Ti>::value,
2652 0 < is_placeholder<_Ti>::value &&
2653 is_placeholder<_Ti>::value <= tuple_size<_TupleUj>::value,
2654 _TupleUj>
2655{
2656};
2657
2658template <class _Fp, class _BoundArgs, class _TupleUj>
2659struct __is_valid_bind_return
2660{
2661 static const bool value = false;
2662};
2663
2664template <class _Fp, class ..._BoundArgs, class _TupleUj>
2665struct __is_valid_bind_return<_Fp, tuple<_BoundArgs...>, _TupleUj>
2666{
2667 static const bool value = __invokable<_Fp,
2668 typename __mu_return<_BoundArgs, _TupleUj>::type...>::value;
2669};
2670
2671template <class _Fp, class ..._BoundArgs, class _TupleUj>
2672struct __is_valid_bind_return<_Fp, const tuple<_BoundArgs...>, _TupleUj>
2673{
2674 static const bool value = __invokable<_Fp,
2675 typename __mu_return<const _BoundArgs, _TupleUj>::type...>::value;
2676};
2677
2678template <class _Fp, class _BoundArgs, class _TupleUj,
2679 bool = __is_valid_bind_return<_Fp, _BoundArgs, _TupleUj>::value>
2680struct __bind_return;
2681
2682template <class _Fp, class ..._BoundArgs, class _TupleUj>
2683struct __bind_return<_Fp, tuple<_BoundArgs...>, _TupleUj, true>
2684{
2685 typedef typename __invoke_of
2686 <
2687 _Fp&,
2688 typename __mu_return
2689 <
2690 _BoundArgs,
2691 _TupleUj
2692 >::type...
2693 >::type type;
2694};
2695
2696template <class _Fp, class ..._BoundArgs, class _TupleUj>
2697struct __bind_return<_Fp, const tuple<_BoundArgs...>, _TupleUj, true>
2698{
2699 typedef typename __invoke_of
2700 <
2701 _Fp&,
2702 typename __mu_return
2703 <
2704 const _BoundArgs,
2705 _TupleUj
2706 >::type...
2707 >::type type;
2708};
2709
2710template <class _Fp, class _BoundArgs, size_t ..._Indx, class _Args>
2711inline _LIBCPP_INLINE_VISIBILITY
2712typename __bind_return<_Fp, _BoundArgs, _Args>::type
2713__apply_functor(_Fp& __f, _BoundArgs& __bound_args, __tuple_indices<_Indx...>,
2714 _Args&& __args)
2715{
2716 return _VSTD::__invoke(__f, _VSTD::__mu(_VSTD::get<_Indx>(__bound_args), __args)...);
2717}
2718
2719template<class _Fp, class ..._BoundArgs>
2720class __bind
2721 : public __weak_result_type<typename decay<_Fp>::type>
2722{
2723protected:
2724 typedef typename decay<_Fp>::type _Fd;
2725 typedef tuple<typename decay<_BoundArgs>::type...> _Td;
2726private:
2727 _Fd __f_;
2728 _Td __bound_args_;
2729
2730 typedef typename __make_tuple_indices<sizeof...(_BoundArgs)>::type __indices;
2731public:
2732 template <class _Gp, class ..._BA,
2733 class = typename enable_if
2734 <
2735 is_constructible<_Fd, _Gp>::value &&
2736 !is_same<typename remove_reference<_Gp>::type,
2737 __bind>::value
2738 >::type>
2739 _LIBCPP_INLINE_VISIBILITY
2740 explicit __bind(_Gp&& __f, _BA&& ...__bound_args)
2741 : __f_(_VSTD::forward<_Gp>(__f)),
2742 __bound_args_(_VSTD::forward<_BA>(__bound_args)...) {}
2743
2744 template <class ..._Args>
2745 _LIBCPP_INLINE_VISIBILITY
2746 typename __bind_return<_Fd, _Td, tuple<_Args&&...> >::type
2747 operator()(_Args&& ...__args)
2748 {
2749 return _VSTD::__apply_functor(__f_, __bound_args_, __indices(),
2750 tuple<_Args&&...>(_VSTD::forward<_Args>(__args)...));
2751 }
2752
2753 template <class ..._Args>
2754 _LIBCPP_INLINE_VISIBILITY
2755 typename __bind_return<const _Fd, const _Td, tuple<_Args&&...> >::type
2756 operator()(_Args&& ...__args) const
2757 {
2758 return _VSTD::__apply_functor(__f_, __bound_args_, __indices(),
2759 tuple<_Args&&...>(_VSTD::forward<_Args>(__args)...));
2760 }
2761};
2762
2763template<class _Fp, class ..._BoundArgs>
2764struct __is_bind_expression<__bind<_Fp, _BoundArgs...> > : public true_type {};
2765
2766template<class _Rp, class _Fp, class ..._BoundArgs>
2767class __bind_r
2768 : public __bind<_Fp, _BoundArgs...>
2769{
2770 typedef __bind<_Fp, _BoundArgs...> base;
2771 typedef typename base::_Fd _Fd;
2772 typedef typename base::_Td _Td;
2773public:
2774 typedef _Rp result_type;
2775
2776
2777 template <class _Gp, class ..._BA,
2778 class = typename enable_if
2779 <
2780 is_constructible<_Fd, _Gp>::value &&
2781 !is_same<typename remove_reference<_Gp>::type,
2782 __bind_r>::value
2783 >::type>
2784 _LIBCPP_INLINE_VISIBILITY
2785 explicit __bind_r(_Gp&& __f, _BA&& ...__bound_args)
2786 : base(_VSTD::forward<_Gp>(__f),
2787 _VSTD::forward<_BA>(__bound_args)...) {}
2788
2789 template <class ..._Args>
2790 _LIBCPP_INLINE_VISIBILITY
2791 typename enable_if
2792 <
2793 is_convertible<typename __bind_return<_Fd, _Td, tuple<_Args&&...> >::type,
2794 result_type>::value || is_void<_Rp>::value,
2795 result_type
2796 >::type
2797 operator()(_Args&& ...__args)
2798 {
2799 typedef __invoke_void_return_wrapper<_Rp> _Invoker;
2800 return _Invoker::__call(static_cast<base&>(*this), _VSTD::forward<_Args>(__args)...);
2801 }
2802
2803 template <class ..._Args>
2804 _LIBCPP_INLINE_VISIBILITY
2805 typename enable_if
2806 <
2807 is_convertible<typename __bind_return<const _Fd, const _Td, tuple<_Args&&...> >::type,
2808 result_type>::value || is_void<_Rp>::value,
2809 result_type
2810 >::type
2811 operator()(_Args&& ...__args) const
2812 {
2813 typedef __invoke_void_return_wrapper<_Rp> _Invoker;
2814 return _Invoker::__call(static_cast<base const&>(*this), _VSTD::forward<_Args>(__args)...);
2815 }
2816};
2817
2818template<class _Rp, class _Fp, class ..._BoundArgs>
2819struct __is_bind_expression<__bind_r<_Rp, _Fp, _BoundArgs...> > : public true_type {};
2820
2821template<class _Fp, class ..._BoundArgs>
2822inline _LIBCPP_INLINE_VISIBILITY
2823__bind<_Fp, _BoundArgs...>
2824bind(_Fp&& __f, _BoundArgs&&... __bound_args)
2825{
2826 typedef __bind<_Fp, _BoundArgs...> type;
2827 return type(_VSTD::forward<_Fp>(__f), _VSTD::forward<_BoundArgs>(__bound_args)...);
2828}
2829
2830template<class _Rp, class _Fp, class ..._BoundArgs>
2831inline _LIBCPP_INLINE_VISIBILITY
2832__bind_r<_Rp, _Fp, _BoundArgs...>
2833bind(_Fp&& __f, _BoundArgs&&... __bound_args)
2834{
2835 typedef __bind_r<_Rp, _Fp, _BoundArgs...> type;
2836 return type(_VSTD::forward<_Fp>(__f), _VSTD::forward<_BoundArgs>(__bound_args)...);
2837}
2838
2839#endif // _LIBCPP_CXX03_LANG
2840
2841#if _LIBCPP_STD_VER > 14
2842
2843template <class _Fn, class ..._Args>
2844invoke_result_t<_Fn, _Args...>
2845invoke(_Fn&& __f, _Args&&... __args)
2846 noexcept(is_nothrow_invocable_v<_Fn, _Args...>)
2847{
2848 return _VSTD::__invoke(_VSTD::forward<_Fn>(__f), _VSTD::forward<_Args>(__args)...);
2849}
2850
2851template <class _DecayFunc>
2852class _LIBCPP_TEMPLATE_VIS __not_fn_imp {
2853 _DecayFunc __fd;
2854
2855public:
2856 __not_fn_imp() = delete;
2857
2858 template <class ..._Args>
2859 _LIBCPP_INLINE_VISIBILITY
2860 auto operator()(_Args&& ...__args) &
2861 noexcept(noexcept(!_VSTD::invoke(__fd, _VSTD::forward<_Args>(__args)...)))
2862 -> decltype( !_VSTD::invoke(__fd, _VSTD::forward<_Args>(__args)...))
2863 { return !_VSTD::invoke(__fd, _VSTD::forward<_Args>(__args)...); }
2864
2865 template <class ..._Args>
2866 _LIBCPP_INLINE_VISIBILITY
2867 auto operator()(_Args&& ...__args) &&
2868 noexcept(noexcept(!_VSTD::invoke(_VSTD::move(__fd), _VSTD::forward<_Args>(__args)...)))
2869 -> decltype( !_VSTD::invoke(_VSTD::move(__fd), _VSTD::forward<_Args>(__args)...))
2870 { return !_VSTD::invoke(_VSTD::move(__fd), _VSTD::forward<_Args>(__args)...); }
2871
2872 template <class ..._Args>
2873 _LIBCPP_INLINE_VISIBILITY
2874 auto operator()(_Args&& ...__args) const&
2875 noexcept(noexcept(!_VSTD::invoke(__fd, _VSTD::forward<_Args>(__args)...)))
2876 -> decltype( !_VSTD::invoke(__fd, _VSTD::forward<_Args>(__args)...))
2877 { return !_VSTD::invoke(__fd, _VSTD::forward<_Args>(__args)...); }
2878
2879
2880 template <class ..._Args>
2881 _LIBCPP_INLINE_VISIBILITY
2882 auto operator()(_Args&& ...__args) const&&
2883 noexcept(noexcept(!_VSTD::invoke(_VSTD::move(__fd), _VSTD::forward<_Args>(__args)...)))
2884 -> decltype( !_VSTD::invoke(_VSTD::move(__fd), _VSTD::forward<_Args>(__args)...))
2885 { return !_VSTD::invoke(_VSTD::move(__fd), _VSTD::forward<_Args>(__args)...); }
2886
2887private:
2888 template <class _RawFunc,
2889 class = enable_if_t<!is_same<decay_t<_RawFunc>, __not_fn_imp>::value>>
2890 _LIBCPP_INLINE_VISIBILITY
2891 explicit __not_fn_imp(_RawFunc&& __rf)
2892 : __fd(_VSTD::forward<_RawFunc>(__rf)) {}
2893
2894 template <class _RawFunc>
2895 friend inline _LIBCPP_INLINE_VISIBILITY
2896 __not_fn_imp<decay_t<_RawFunc>> not_fn(_RawFunc&&);
2897};
2898
2899template <class _RawFunc>
2900inline _LIBCPP_INLINE_VISIBILITY
2901__not_fn_imp<decay_t<_RawFunc>> not_fn(_RawFunc&& __fn) {
2902 return __not_fn_imp<decay_t<_RawFunc>>(_VSTD::forward<_RawFunc>(__fn));
2903}
2904
2905#endif
2906
2907// struct hash<T*> in <memory>
2908
2909template <class _BinaryPredicate, class _ForwardIterator1, class _ForwardIterator2>
2910pair<_ForwardIterator1, _ForwardIterator1> _LIBCPP_CONSTEXPR_AFTER_CXX11
2911__search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
2912 _ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __pred,
2913 forward_iterator_tag, forward_iterator_tag)
2914{
2915 if (__first2 == __last2)
2916 return make_pair(__first1, __first1); // Everything matches an empty sequence
2917 while (true)
2918 {
2919 // Find first element in sequence 1 that matchs *__first2, with a mininum of loop checks
2920 while (true)
2921 {
2922 if (__first1 == __last1) // return __last1 if no element matches *__first2
2923 return make_pair(__last1, __last1);
2924 if (__pred(*__first1, *__first2))
2925 break;
2926 ++__first1;
2927 }
2928 // *__first1 matches *__first2, now match elements after here
2929 _ForwardIterator1 __m1 = __first1;
2930 _ForwardIterator2 __m2 = __first2;
2931 while (true)
2932 {
2933 if (++__m2 == __last2) // If pattern exhausted, __first1 is the answer (works for 1 element pattern)
2934 return make_pair(__first1, __m1);
2935 if (++__m1 == __last1) // Otherwise if source exhaused, pattern not found
2936 return make_pair(__last1, __last1);
2937 if (!__pred(*__m1, *__m2)) // if there is a mismatch, restart with a new __first1
2938 {
2939 ++__first1;
2940 break;
2941 } // else there is a match, check next elements
2942 }
2943 }
2944}
2945
2946template <class _BinaryPredicate, class _RandomAccessIterator1, class _RandomAccessIterator2>
2947_LIBCPP_CONSTEXPR_AFTER_CXX11
2948pair<_RandomAccessIterator1, _RandomAccessIterator1>
2949__search(_RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1,
2950 _RandomAccessIterator2 __first2, _RandomAccessIterator2 __last2, _BinaryPredicate __pred,
2951 random_access_iterator_tag, random_access_iterator_tag)
2952{
2953 typedef typename iterator_traits<_RandomAccessIterator1>::difference_type _D1;
2954 typedef typename iterator_traits<_RandomAccessIterator2>::difference_type _D2;
2955 // Take advantage of knowing source and pattern lengths. Stop short when source is smaller than pattern
2956 const _D2 __len2 = __last2 - __first2;
2957 if (__len2 == 0)
2958 return make_pair(__first1, __first1);
2959 const _D1 __len1 = __last1 - __first1;
2960 if (__len1 < __len2)
2961 return make_pair(__last1, __last1);
2962 const _RandomAccessIterator1 __s = __last1 - (__len2 - 1); // Start of pattern match can't go beyond here
2963
2964 while (true)
2965 {
2966 while (true)
2967 {
2968 if (__first1 == __s)
2969 return make_pair(__last1, __last1);
2970 if (__pred(*__first1, *__first2))
2971 break;
2972 ++__first1;
2973 }
2974
2975 _RandomAccessIterator1 __m1 = __first1;
2976 _RandomAccessIterator2 __m2 = __first2;
2977 while (true)
2978 {
2979 if (++__m2 == __last2)
2980 return make_pair(__first1, __first1 + __len2);
2981 ++__m1; // no need to check range on __m1 because __s guarantees we have enough source
2982 if (!__pred(*__m1, *__m2))
2983 {
2984 ++__first1;
2985 break;
2986 }
2987 }
2988 }
2989}
2990
2991#if _LIBCPP_STD_VER > 14
2992
2993// default searcher
2994template<class _ForwardIterator, class _BinaryPredicate = equal_to<>>
2995class _LIBCPP_TYPE_VIS default_searcher {
2996public:
2997 _LIBCPP_INLINE_VISIBILITY
2998 default_searcher(_ForwardIterator __f, _ForwardIterator __l,
2999 _BinaryPredicate __p = _BinaryPredicate())
3000 : __first_(__f), __last_(__l), __pred_(__p) {}
3001
3002 template <typename _ForwardIterator2>
3003 _LIBCPP_INLINE_VISIBILITY
3004 pair<_ForwardIterator2, _ForwardIterator2>
3005 operator () (_ForwardIterator2 __f, _ForwardIterator2 __l) const
3006 {
3007 return _VSTD::__search(__f, __l, __first_, __last_, __pred_,
3008 typename _VSTD::iterator_traits<_ForwardIterator>::iterator_category(),
3009 typename _VSTD::iterator_traits<_ForwardIterator2>::iterator_category());
3010 }
3011
3012private:
3013 _ForwardIterator __first_;
3014 _ForwardIterator __last_;
3015 _BinaryPredicate __pred_;
3016 };
3017
3018#endif // _LIBCPP_STD_VER > 14
3019
3020#if _LIBCPP_STD_VER > 17
3021template <class _Tp>
3022using unwrap_reference_t = typename unwrap_reference<_Tp>::type;
3023
3024template <class _Tp>
3025using unwrap_ref_decay_t = typename unwrap_ref_decay<_Tp>::type;
3026#endif // > C++17
3027
3028template <class _Container, class _Predicate>
3029inline void __libcpp_erase_if_container( _Container& __c, _Predicate __pred)
3030{
3031 for (typename _Container::iterator __iter = __c.begin(), __last = __c.end(); __iter != __last;)
3032 {
3033 if (__pred(*__iter))
3034 __iter = __c.erase(__iter);
3035 else
3036 ++__iter;
3037 }
3038}
3039
3040_LIBCPP_END_NAMESPACE_STD
3041
3042#endif // _LIBCPP_FUNCTIONAL
3043