← Back to branch summary

~ubuntu-branches/ubuntu/vivid/emscripten/vivid

« back to all changes in this revision

Viewing changes to system/include/libcxx/functional

  • Committer: Package Import Robot
  • Author(s): Sylvestre Ledru
  • Date: 2013-05-02 13:11:51 UTC
  • Revision ID: package-import@ubuntu.com-20130502131151-q8dvteqr1ef2x7xz
Tags: upstream-1.4.1~20130504~adb56cb
Import upstream version 1.4.1~20130504~adb56cb

Show diffs side-by-side

added added

removed removed

Lines of Context:
system/include/libcxx/functional
 
1
// -*- C++ -*-
 
2
//===------------------------ functional ----------------------------------===//
 
3
//
 
4
//                     The LLVM Compiler Infrastructure
 
5
//
 
6
// This file is dual licensed under the MIT and the University of Illinois Open
 
7
// Source Licenses. See LICENSE.TXT for details.
 
8
//
 
9
//===----------------------------------------------------------------------===//
 
10
 
 
11
#ifndef _LIBCPP_FUNCTIONAL
 
12
#define _LIBCPP_FUNCTIONAL
 
13
 
 
14
/*
 
15
    functional synopsis
 
16
 
 
17
namespace std
 
18
{
 
19
 
 
20
template <class Arg, class Result>
 
21
struct unary_function
 
22
{
 
23
    typedef Arg    argument_type;
 
24
    typedef Result result_type;
 
25
};
 
26
 
 
27
template <class Arg1, class Arg2, class Result>
 
28
struct binary_function
 
29
{
 
30
    typedef Arg1   first_argument_type;
 
31
    typedef Arg2   second_argument_type;
 
32
    typedef Result result_type;
 
33
};
 
34
 
 
35
template <class T>
 
36
class reference_wrapper
 
37
    : public unary_function<T1, R> // if wrapping a unary functor
 
38
    : public binary_function<T1, T2, R> // if wraping a binary functor
 
39
{
 
40
public:
 
41
    // types
 
42
    typedef T type;
 
43
    typedef see below result_type; // Not always defined
 
44
 
 
45
    // construct/copy/destroy
 
46
    reference_wrapper(T&) noexcept;
 
47
    reference_wrapper(T&&) = delete; // do not bind to temps
 
48
    reference_wrapper(const reference_wrapper<T>& x) noexcept;
 
49
 
 
50
    // assignment
 
51
    reference_wrapper& operator=(const reference_wrapper<T>& x) noexcept;
 
52
 
 
53
    // access
 
54
    operator T& () const noexcept;
 
55
    T& get() const noexcept;
 
56
 
 
57
    // invoke
 
58
    template <class... ArgTypes>
 
59
      typename result_of<T(ArgTypes...)>::type
 
60
          operator() (ArgTypes&&...) const;
 
61
};
 
62
 
 
63
template <class T> reference_wrapper<T> ref(T& t) noexcept;
 
64
template <class T> void ref(const T&& t) = delete;
 
65
template <class T> reference_wrapper<T> ref(reference_wrapper<T>t) noexcept;
 
66
 
 
67
template <class T> reference_wrapper<const T> cref(const T& t) noexcept;
 
68
template <class T> void cref(const T&& t) = delete;
 
69
template <class T> reference_wrapper<const T> cref(reference_wrapper<T> t) noexcept;
 
70
 
 
71
template <class T>
 
72
struct plus : binary_function<T, T, T>
 
73
{
 
74
    T operator()(const T& x, const T& y) const;
 
75
};
 
76
 
 
77
template <class T>
 
78
struct minus : binary_function<T, T, T>
 
79
{
 
80
    T operator()(const T& x, const T& y) const;
 
81
};
 
82
 
 
83
template <class T>
 
84
struct multiplies : binary_function<T, T, T>
 
85
{
 
86
    T operator()(const T& x, const T& y) const;
 
87
};
 
88
 
 
89
template <class T>
 
90
struct divides : binary_function<T, T, T>
 
91
{
 
92
    T operator()(const T& x, const T& y) const;
 
93
};
 
94
 
 
95
template <class T>
 
96
struct modulus : binary_function<T, T, T>
 
97
{
 
98
    T operator()(const T& x, const T& y) const;
 
99
};
 
100
 
 
101
template <class T>
 
102
struct negate : unary_function<T, T>
 
103
{
 
104
    T operator()(const T& x) const;
 
105
};
 
106
 
 
107
template <class T>
 
108
struct equal_to : binary_function<T, T, bool>
 
109
{
 
110
    bool operator()(const T& x, const T& y) const;
 
111
};
 
112
 
 
113
template <class T>
 
114
struct not_equal_to : binary_function<T, T, bool>
 
115
{
 
116
    bool operator()(const T& x, const T& y) const;
 
117
};
 
118
 
 
119
template <class T>
 
120
struct greater : binary_function<T, T, bool>
 
121
{
 
122
    bool operator()(const T& x, const T& y) const;
 
123
};
 
124
 
 
125
template <class T>
 
126
struct less : binary_function<T, T, bool>
 
127
{
 
128
    bool operator()(const T& x, const T& y) const;
 
129
};
 
130
 
 
131
template <class T>
 
132
struct greater_equal : binary_function<T, T, bool>
 
133
{
 
134
    bool operator()(const T& x, const T& y) const;
 
135
};
 
136
 
 
137
template <class T>
 
138
struct less_equal : binary_function<T, T, bool>
 
139
{
 
140
    bool operator()(const T& x, const T& y) const;
 
141
};
 
142
 
 
143
template <class T>
 
144
struct logical_and : binary_function<T, T, bool>
 
145
{
 
146
    bool operator()(const T& x, const T& y) const;
 
147
};
 
148
 
 
149
template <class T>
 
150
struct logical_or : binary_function<T, T, bool>
 
151
{
 
152
    bool operator()(const T& x, const T& y) const;
 
153
};
 
154
 
 
155
template <class T>
 
156
struct logical_not : unary_function<T, bool>
 
157
{
 
158
    bool operator()(const T& x) const;
 
159
};
 
160
 
 
161
template <class Predicate>
 
162
class unary_negate
 
163
    : public unary_function<typename Predicate::argument_type, bool>
 
164
{
 
165
public:
 
166
    explicit unary_negate(const Predicate& pred);
 
167
    bool operator()(const typename Predicate::argument_type& x) const;
 
168
};
 
169
 
 
170
template <class Predicate> unary_negate<Predicate> not1(const Predicate& pred);
 
171
 
 
172
template <class Predicate>
 
173
class binary_negate
 
174
    : public binary_function<typename Predicate::first_argument_type,
 
175
                             typename Predicate::second_argument_type,
 
176
                             bool>
 
177
{
 
178
public:
 
179
    explicit binary_negate(const Predicate& pred);
 
180
    bool operator()(const typename Predicate::first_argument_type& x,
 
181
                    const typename Predicate::second_argument_type& y) const;
 
182
};
 
183
 
 
184
template <class Predicate> binary_negate<Predicate> not2(const Predicate& pred);
 
185
 
 
186
template<class T> struct is_bind_expression;
 
187
template<class T> struct is_placeholder;
 
188
 
 
189
template<class Fn, class... BoundArgs>
 
190
  unspecified bind(Fn&&, BoundArgs&&...);
 
191
template<class R, class Fn, class... BoundArgs>
 
192
  unspecified bind(Fn&&, BoundArgs&&...);
 
193
 
 
194
namespace placeholders {
 
195
  // M is the implementation-defined number of placeholders
 
196
  extern unspecified _1;
 
197
  extern unspecified _2;
 
198
  .
 
199
  .
 
200
  .
 
201
  extern unspecified _Mp;
 
202
}
 
203
 
 
204
template <class Operation>
 
205
class binder1st
 
206
    : public unary_function<typename Operation::second_argument_type,
 
207
                            typename Operation::result_type>
 
208
{
 
209
protected:
 
210
    Operation                               op;
 
211
    typename Operation::first_argument_type value;
 
212
public:
 
213
    binder1st(const Operation& x, const typename Operation::first_argument_type y);
 
214
    typename Operation::result_type operator()(      typename Operation::second_argument_type& x) const;
 
215
    typename Operation::result_type operator()(const typename Operation::second_argument_type& x) const;
 
216
};
 
217
 
 
218
template <class Operation, class T>
 
219
binder1st<Operation> bind1st(const Operation& op, const T& x);
 
220
 
 
221
template <class Operation>
 
222
class binder2nd
 
223
    : public unary_function<typename Operation::first_argument_type,
 
224
                            typename Operation::result_type>
 
225
{
 
226
protected:
 
227
    Operation                                op;
 
228
    typename Operation::second_argument_type value;
 
229
public:
 
230
    binder2nd(const Operation& x, const typename Operation::second_argument_type y);
 
231
    typename Operation::result_type operator()(      typename Operation::first_argument_type& x) const;
 
232
    typename Operation::result_type operator()(const typename Operation::first_argument_type& x) const;
 
233
};
 
234
 
 
235
template <class Operation, class T>
 
236
binder2nd<Operation> bind2nd(const Operation& op, const T& x);
 
237
 
 
238
template <class Arg, class Result>
 
239
class pointer_to_unary_function : public unary_function<Arg, Result>
 
240
{
 
241
public:
 
242
    explicit pointer_to_unary_function(Result (*f)(Arg));
 
243
    Result operator()(Arg x) const;
 
244
};
 
245
 
 
246
template <class Arg, class Result>
 
247
pointer_to_unary_function<Arg,Result> ptr_fun(Result (*f)(Arg));
 
248
 
 
249
template <class Arg1, class Arg2, class Result>
 
250
class pointer_to_binary_function : public binary_function<Arg1, Arg2, Result>
 
251
{
 
252
public:
 
253
    explicit pointer_to_binary_function(Result (*f)(Arg1, Arg2));
 
254
    Result operator()(Arg1 x, Arg2 y) const;
 
255
};
 
256
 
 
257
template <class Arg1, class Arg2, class Result>
 
258
pointer_to_binary_function<Arg1,Arg2,Result> ptr_fun(Result (*f)(Arg1,Arg2));
 
259
 
 
260
template<class S, class T>
 
261
class mem_fun_t : public unary_function<T*, S>
 
262
{
 
263
public:
 
264
    explicit mem_fun_t(S (T::*p)());
 
265
    S operator()(T* p) const;
 
266
};
 
267
 
 
268
template<class S, class T, class A>
 
269
class mem_fun1_t : public binary_function<T*, A, S>
 
270
{
 
271
public:
 
272
    explicit mem_fun1_t(S (T::*p)(A));
 
273
    S operator()(T* p, A x) const;
 
274
};
 
275
 
 
276
template<class S, class T>          mem_fun_t<S,T>    mem_fun(S (T::*f)());
 
277
template<class S, class T, class A> mem_fun1_t<S,T,A> mem_fun(S (T::*f)(A));
 
278
 
 
279
template<class S, class T>
 
280
class mem_fun_ref_t : public unary_function<T, S>
 
281
{
 
282
public:
 
283
    explicit mem_fun_ref_t(S (T::*p)());
 
284
    S operator()(T& p) const;
 
285
};
 
286
 
 
287
template<class S, class T, class A>
 
288
class mem_fun1_ref_t : public binary_function<T, A, S>
 
289
{
 
290
public:
 
291
    explicit mem_fun1_ref_t(S (T::*p)(A));
 
292
    S operator()(T& p, A x) const;
 
293
};
 
294
 
 
295
template<class S, class T>          mem_fun_ref_t<S,T>    mem_fun_ref(S (T::*f)());
 
296
template<class S, class T, class A> mem_fun1_ref_t<S,T,A> mem_fun_ref(S (T::*f)(A));
 
297
 
 
298
template <class S, class T>
 
299
class const_mem_fun_t : public unary_function<const T*, S>
 
300
{
 
301
public:
 
302
    explicit const_mem_fun_t(S (T::*p)() const);
 
303
    S operator()(const T* p) const;
 
304
};
 
305
 
 
306
template <class S, class T, class A>
 
307
class const_mem_fun1_t : public binary_function<const T*, A, S>
 
308
{
 
309
public:
 
310
    explicit const_mem_fun1_t(S (T::*p)(A) const);
 
311
    S operator()(const T* p, A x) const;
 
312
};
 
313
 
 
314
template <class S, class T>          const_mem_fun_t<S,T>    mem_fun(S (T::*f)() const);
 
315
template <class S, class T, class A> const_mem_fun1_t<S,T,A> mem_fun(S (T::*f)(A) const);
 
316
 
 
317
template <class S, class T>
 
318
class const_mem_fun_ref_t : public unary_function<T, S>
 
319
{
 
320
public:
 
321
    explicit const_mem_fun_ref_t(S (T::*p)() const);
 
322
    S operator()(const T& p) const;
 
323
};
 
324
 
 
325
template <class S, class T, class A>
 
326
class const_mem_fun1_ref_t : public binary_function<T, A, S>
 
327
{
 
328
public:
 
329
    explicit const_mem_fun1_ref_t(S (T::*p)(A) const);
 
330
    S operator()(const T& p, A x) const;
 
331
};
 
332
 
 
333
template <class S, class T>          const_mem_fun_ref_t<S,T>    mem_fun_ref(S (T::*f)() const);
 
334
template <class S, class T, class A> const_mem_fun1_ref_t<S,T,A> mem_fun_ref(S (T::*f)(A) const);
 
335
 
 
336
template<class R, class T> unspecified mem_fn(R T::*);
 
337
template<class R, class T, class... Args> unspecified mem_fn(R (T::*)(Args...));
 
338
template<class R, class T, class... Args> unspecified mem_fn(R (T::*)(Args...) const);
 
339
template<class R, class T, class... Args> unspecified mem_fn(R (T::*)(Args...) volatile);
 
340
template<class R, class T, class... Args> unspecified mem_fn(R (T::*)(Args...) const volatile);
 
341
template<class R, class T, class... Args> unspecified mem_fn(R (T::*)(Args...) &);
 
342
template<class R, class T, class... Args> unspecified mem_fn(R (T::*)(Args...) const &);
 
343
template<class R, class T, class... Args> unspecified mem_fn(R (T::*)(Args...) volatile &);
 
344
template<class R, class T, class... Args> unspecified mem_fn(R (T::*)(Args...) const volatile &);
 
345
template<class R, class T, class... Args> unspecified mem_fn(R (T::*)(Args...) &&);
 
346
template<class R, class T, class... Args> unspecified mem_fn(R (T::*)(Args...) const &&);
 
347
template<class R, class T, class... Args> unspecified mem_fn(R (T::*)(Args...) volatile &&);
 
348
template<class R, class T, class... Args> unspecified mem_fn(R (T::*)(Args...) const volatile &&);
 
349
 
 
350
class bad_function_call
 
351
    : public exception
 
352
{
 
353
};
 
354
 
 
355
template<class> class function; // undefined
 
356
 
 
357
template<class R, class... ArgTypes>
 
358
class function<R(ArgTypes...)>
 
359
  : public unary_function<T1, R>      // iff sizeof...(ArgTypes) == 1 and
 
360
                                      // ArgTypes contains T1
 
361
  : public binary_function<T1, T2, R> // iff sizeof...(ArgTypes) == 2 and
 
362
                                      // ArgTypes contains T1 and T2
 
363
{
 
364
public:
 
365
    typedef R result_type;
 
366
 
 
367
    // construct/copy/destroy:
 
368
    function() noexcept;
 
369
    function(nullptr_t) noexcept;
 
370
    function(const function&);
 
371
    function(function&&) noexcept;
 
372
    template<class F>
 
373
      function(F);
 
374
    template<Allocator Alloc>
 
375
      function(allocator_arg_t, const Alloc&) noexcept;
 
376
    template<Allocator Alloc>
 
377
      function(allocator_arg_t, const Alloc&, nullptr_t) noexcept;
 
378
    template<Allocator Alloc>
 
379
      function(allocator_arg_t, const Alloc&, const function&);
 
380
    template<Allocator Alloc>
 
381
      function(allocator_arg_t, const Alloc&, function&&);
 
382
    template<class F, Allocator Alloc>
 
383
      function(allocator_arg_t, const Alloc&, F);
 
384
 
 
385
    function& operator=(const function&);
 
386
    function& operator=(function&&) noexcept;
 
387
    function& operator=(nullptr_t) noexcept;
 
388
    template<class F>
 
389
      function& operator=(F&&);
 
390
    template<class F>
 
391
      function& operator=(reference_wrapper<F>) noexcept;
 
392
 
 
393
    ~function();
 
394
 
 
395
    // function modifiers:
 
396
    void swap(function&) noexcept;
 
397
    template<class F, class Alloc>
 
398
      void assign(F&&, const Alloc&);
 
399
 
 
400
    // function capacity:
 
401
    explicit operator bool() const noexcept;
 
402
 
 
403
    // function invocation:
 
404
    R operator()(ArgTypes...) const;
 
405
 
 
406
    // function target access:
 
407
    const std::type_info& target_type() const noexcept;
 
408
    template <typename T>       T* target() noexcept;
 
409
    template <typename T> const T* target() const noexcept;
 
410
};
 
411
 
 
412
// Null pointer comparisons:
 
413
template <class R, class ... ArgTypes>
 
414
  bool operator==(const function<R(ArgTypes...)>&, nullptr_t) noexcept;
 
415
 
 
416
template <class R, class ... ArgTypes>
 
417
  bool operator==(nullptr_t, const function<R(ArgTypes...)>&) noexcept;
 
418
 
 
419
template <class R, class ... ArgTypes>
 
420
  bool operator!=(const function<R(ArgTypes...)>&, nullptr_t) noexcept;
 
421
 
 
422
template <class  R, class ... ArgTypes>
 
423
  bool operator!=(nullptr_t, const function<R(ArgTypes...)>&) noexcept;
 
424
 
 
425
// specialized algorithms:
 
426
template <class  R, class ... ArgTypes>
 
427
  void swap(function<R(ArgTypes...)>&, function<R(ArgTypes...)>&) noexcept;
 
428
 
 
429
template <class T> struct hash;
 
430
 
 
431
template <> struct hash<bool>;
 
432
template <> struct hash<char>;
 
433
template <> struct hash<signed char>;
 
434
template <> struct hash<unsigned char>;
 
435
template <> struct hash<char16_t>;
 
436
template <> struct hash<char32_t>;
 
437
template <> struct hash<wchar_t>;
 
438
template <> struct hash<short>;
 
439
template <> struct hash<unsigned short>;
 
440
template <> struct hash<int>;
 
441
template <> struct hash<unsigned int>;
 
442
template <> struct hash<long>;
 
443
template <> struct hash<long long>;
 
444
template <> struct hash<unsigned long>;
 
445
template <> struct hash<unsigned long long>;
 
446
 
 
447
template <> struct hash<float>;
 
448
template <> struct hash<double>;
 
449
template <> struct hash<long double>;
 
450
 
 
451
template<class T> struct hash<T*>;
 
452
 
 
453
}  // std
 
454
 
 
455
POLICY:  For non-variadic implementations, the number of arguments is limited
 
456
         to 3.  It is hoped that the need for non-variadic implementations
 
457
         will be minimal.
 
458
 
 
459
*/
 
460
 
 
461
#include <__config>
 
462
#include <type_traits>
 
463
#include <typeinfo>
 
464
#include <exception>
 
465
#include <memory>
 
466
#include <tuple>
 
467
 
 
468
#include <__functional_base>
 
469
 
 
470
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 
471
#pragma GCC system_header
 
472
#endif
 
473
 
 
474
_LIBCPP_BEGIN_NAMESPACE_STD
 
475
 
 
476
template <class _Tp>
 
477
struct _LIBCPP_TYPE_VIS plus : binary_function<_Tp, _Tp, _Tp>
 
478
{
 
479
    _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x, const _Tp& __y) const
 
480
        {return __x + __y;}
 
481
};
 
482
 
 
483
template <class _Tp>
 
484
struct _LIBCPP_TYPE_VIS minus : binary_function<_Tp, _Tp, _Tp>
 
485
{
 
486
    _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x, const _Tp& __y) const
 
487
        {return __x - __y;}
 
488
};
 
489
 
 
490
template <class _Tp>
 
491
struct _LIBCPP_TYPE_VIS multiplies : binary_function<_Tp, _Tp, _Tp>
 
492
{
 
493
    _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x, const _Tp& __y) const
 
494
        {return __x * __y;}
 
495
};
 
496
 
 
497
template <class _Tp>
 
498
struct _LIBCPP_TYPE_VIS divides : binary_function<_Tp, _Tp, _Tp>
 
499
{
 
500
    _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x, const _Tp& __y) const
 
501
        {return __x / __y;}
 
502
};
 
503
 
 
504
template <class _Tp>
 
505
struct _LIBCPP_TYPE_VIS modulus : binary_function<_Tp, _Tp, _Tp>
 
506
{
 
507
    _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x, const _Tp& __y) const
 
508
        {return __x % __y;}
 
509
};
 
510
 
 
511
template <class _Tp>
 
512
struct _LIBCPP_TYPE_VIS negate : unary_function<_Tp, _Tp>
 
513
{
 
514
    _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x) const
 
515
        {return -__x;}
 
516
};
 
517
 
 
518
template <class _Tp>
 
519
struct _LIBCPP_TYPE_VIS equal_to : binary_function<_Tp, _Tp, bool>
 
520
{
 
521
    _LIBCPP_INLINE_VISIBILITY bool operator()(const _Tp& __x, const _Tp& __y) const
 
522
        {return __x == __y;}
 
523
};
 
524
 
 
525
template <class _Tp>
 
526
struct _LIBCPP_TYPE_VIS not_equal_to : binary_function<_Tp, _Tp, bool>
 
527
{
 
528
    _LIBCPP_INLINE_VISIBILITY bool operator()(const _Tp& __x, const _Tp& __y) const
 
529
        {return __x != __y;}
 
530
};
 
531
 
 
532
template <class _Tp>
 
533
struct _LIBCPP_TYPE_VIS greater : binary_function<_Tp, _Tp, bool>
 
534
{
 
535
    _LIBCPP_INLINE_VISIBILITY bool operator()(const _Tp& __x, const _Tp& __y) const
 
536
        {return __x > __y;}
 
537
};
 
538
 
 
539
// less in <__functional_base>
 
540
 
 
541
template <class _Tp>
 
542
struct _LIBCPP_TYPE_VIS greater_equal : binary_function<_Tp, _Tp, bool>
 
543
{
 
544
    _LIBCPP_INLINE_VISIBILITY bool operator()(const _Tp& __x, const _Tp& __y) const
 
545
        {return __x >= __y;}
 
546
};
 
547
 
 
548
template <class _Tp>
 
549
struct _LIBCPP_TYPE_VIS less_equal : binary_function<_Tp, _Tp, bool>
 
550
{
 
551
    _LIBCPP_INLINE_VISIBILITY bool operator()(const _Tp& __x, const _Tp& __y) const
 
552
        {return __x <= __y;}
 
553
};
 
554
 
 
555
template <class _Tp>
 
556
struct _LIBCPP_TYPE_VIS logical_and : binary_function<_Tp, _Tp, bool>
 
557
{
 
558
    _LIBCPP_INLINE_VISIBILITY bool operator()(const _Tp& __x, const _Tp& __y) const
 
559
        {return __x && __y;}
 
560
};
 
561
 
 
562
template <class _Tp>
 
563
struct _LIBCPP_TYPE_VIS logical_or : binary_function<_Tp, _Tp, bool>
 
564
{
 
565
    _LIBCPP_INLINE_VISIBILITY bool operator()(const _Tp& __x, const _Tp& __y) const
 
566
        {return __x || __y;}
 
567
};
 
568
 
 
569
template <class _Tp>
 
570
struct _LIBCPP_TYPE_VIS logical_not : unary_function<_Tp, bool>
 
571
{
 
572
    _LIBCPP_INLINE_VISIBILITY bool operator()(const _Tp& __x) const
 
573
        {return !__x;}
 
574
};
 
575
 
 
576
template <class _Tp>
 
577
struct _LIBCPP_TYPE_VIS bit_and : binary_function<_Tp, _Tp, _Tp>
 
578
{
 
579
    _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x, const _Tp& __y) const
 
580
        {return __x & __y;}
 
581
};
 
582
 
 
583
template <class _Tp>
 
584
struct _LIBCPP_TYPE_VIS bit_or : binary_function<_Tp, _Tp, _Tp>
 
585
{
 
586
    _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x, const _Tp& __y) const
 
587
        {return __x | __y;}
 
588
};
 
589
 
 
590
template <class _Tp>
 
591
struct _LIBCPP_TYPE_VIS bit_xor : binary_function<_Tp, _Tp, _Tp>
 
592
{
 
593
    _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x, const _Tp& __y) const
 
594
        {return __x ^ __y;}
 
595
};
 
596
 
 
597
template <class _Predicate>
 
598
class _LIBCPP_TYPE_VIS unary_negate
 
599
    : public unary_function<typename _Predicate::argument_type, bool>
 
600
{
 
601
    _Predicate __pred_;
 
602
public:
 
603
    _LIBCPP_INLINE_VISIBILITY explicit unary_negate(const _Predicate& __pred)
 
604
        : __pred_(__pred) {}
 
605
    _LIBCPP_INLINE_VISIBILITY bool operator()(const typename _Predicate::argument_type& __x) const
 
606
        {return !__pred_(__x);}
 
607
};
 
608
 
 
609
template <class _Predicate>
 
610
inline _LIBCPP_INLINE_VISIBILITY
 
611
unary_negate<_Predicate>
 
612
not1(const _Predicate& __pred) {return unary_negate<_Predicate>(__pred);}
 
613
 
 
614
template <class _Predicate>
 
615
class _LIBCPP_TYPE_VIS binary_negate
 
616
    : public binary_function<typename _Predicate::first_argument_type,
 
617
                             typename _Predicate::second_argument_type,
 
618
                             bool>
 
619
{
 
620
    _Predicate __pred_;
 
621
public:
 
622
    _LIBCPP_INLINE_VISIBILITY explicit binary_negate(const _Predicate& __pred)
 
623
        : __pred_(__pred) {}
 
624
    _LIBCPP_INLINE_VISIBILITY bool operator()(const typename _Predicate::first_argument_type& __x,
 
625
                    const typename _Predicate::second_argument_type& __y) const
 
626
        {return !__pred_(__x, __y);}
 
627
};
 
628
 
 
629
template <class _Predicate>
 
630
inline _LIBCPP_INLINE_VISIBILITY
 
631
binary_negate<_Predicate>
 
632
not2(const _Predicate& __pred) {return binary_negate<_Predicate>(__pred);}
 
633
 
 
634
template <class __Operation>
 
635
class _LIBCPP_TYPE_VIS binder1st
 
636
    : public unary_function<typename __Operation::second_argument_type,
 
637
                            typename __Operation::result_type>
 
638
{
 
639
protected:
 
640
    __Operation                               op;
 
641
    typename __Operation::first_argument_type value;
 
642
public:
 
643
    _LIBCPP_INLINE_VISIBILITY binder1st(const __Operation& __x,
 
644
                               const typename __Operation::first_argument_type __y)
 
645
        : op(__x), value(__y) {}
 
646
    _LIBCPP_INLINE_VISIBILITY typename __Operation::result_type operator()
 
647
        (typename __Operation::second_argument_type& __x) const
 
648
            {return op(value, __x);}
 
649
    _LIBCPP_INLINE_VISIBILITY typename __Operation::result_type operator()
 
650
        (const typename __Operation::second_argument_type& __x) const
 
651
            {return op(value, __x);}
 
652
};
 
653
 
 
654
template <class __Operation, class _Tp>
 
655
inline _LIBCPP_INLINE_VISIBILITY
 
656
binder1st<__Operation>
 
657
bind1st(const __Operation& __op, const _Tp& __x)
 
658
    {return binder1st<__Operation>(__op, __x);}
 
659
 
 
660
template <class __Operation>
 
661
class _LIBCPP_TYPE_VIS binder2nd
 
662
    : public unary_function<typename __Operation::first_argument_type,
 
663
                            typename __Operation::result_type>
 
664
{
 
665
protected:
 
666
    __Operation                                op;
 
667
    typename __Operation::second_argument_type value;
 
668
public:
 
669
    _LIBCPP_INLINE_VISIBILITY
 
670
    binder2nd(const __Operation& __x, const typename __Operation::second_argument_type __y)
 
671
        : op(__x), value(__y) {}
 
672
    _LIBCPP_INLINE_VISIBILITY typename __Operation::result_type operator()
 
673
        (      typename __Operation::first_argument_type& __x) const
 
674
            {return op(__x, value);}
 
675
    _LIBCPP_INLINE_VISIBILITY typename __Operation::result_type operator()
 
676
        (const typename __Operation::first_argument_type& __x) const
 
677
            {return op(__x, value);}
 
678
};
 
679
 
 
680
template <class __Operation, class _Tp>
 
681
inline _LIBCPP_INLINE_VISIBILITY
 
682
binder2nd<__Operation>
 
683
bind2nd(const __Operation& __op, const _Tp& __x)
 
684
    {return binder2nd<__Operation>(__op, __x);}
 
685
 
 
686
template <class _Arg, class _Result>
 
687
class _LIBCPP_TYPE_VIS pointer_to_unary_function
 
688
    : public unary_function<_Arg, _Result>
 
689
{
 
690
    _Result (*__f_)(_Arg);
 
691
public:
 
692
    _LIBCPP_INLINE_VISIBILITY explicit pointer_to_unary_function(_Result (*__f)(_Arg))
 
693
        : __f_(__f) {}
 
694
    _LIBCPP_INLINE_VISIBILITY _Result operator()(_Arg __x) const
 
695
        {return __f_(__x);}
 
696
};
 
697
 
 
698
template <class _Arg, class _Result>
 
699
inline _LIBCPP_INLINE_VISIBILITY
 
700
pointer_to_unary_function<_Arg,_Result>
 
701
ptr_fun(_Result (*__f)(_Arg))
 
702
    {return pointer_to_unary_function<_Arg,_Result>(__f);}
 
703
 
 
704
template <class _Arg1, class _Arg2, class _Result>
 
705
class _LIBCPP_TYPE_VIS pointer_to_binary_function
 
706
    : public binary_function<_Arg1, _Arg2, _Result>
 
707
{
 
708
    _Result (*__f_)(_Arg1, _Arg2);
 
709
public:
 
710
    _LIBCPP_INLINE_VISIBILITY explicit pointer_to_binary_function(_Result (*__f)(_Arg1, _Arg2))
 
711
        : __f_(__f) {}
 
712
    _LIBCPP_INLINE_VISIBILITY _Result operator()(_Arg1 __x, _Arg2 __y) const
 
713
        {return __f_(__x, __y);}
 
714
};
 
715
 
 
716
template <class _Arg1, class _Arg2, class _Result>
 
717
inline _LIBCPP_INLINE_VISIBILITY
 
718
pointer_to_binary_function<_Arg1,_Arg2,_Result>
 
719
ptr_fun(_Result (*__f)(_Arg1,_Arg2))
 
720
    {return pointer_to_binary_function<_Arg1,_Arg2,_Result>(__f);}
 
721
 
 
722
template<class _Sp, class _Tp>
 
723
class _LIBCPP_TYPE_VIS mem_fun_t : public unary_function<_Tp*, _Sp>
 
724
{
 
725
    _Sp (_Tp::*__p_)();
 
726
public:
 
727
    _LIBCPP_INLINE_VISIBILITY explicit mem_fun_t(_Sp (_Tp::*__p)())
 
728
        : __p_(__p) {}
 
729
    _LIBCPP_INLINE_VISIBILITY _Sp operator()(_Tp* __p) const
 
730
        {return (__p->*__p_)();}
 
731
};
 
732
 
 
733
template<class _Sp, class _Tp, class _Ap>
 
734
class _LIBCPP_TYPE_VIS mem_fun1_t : public binary_function<_Tp*, _Ap, _Sp>
 
735
{
 
736
    _Sp (_Tp::*__p_)(_Ap);
 
737
public:
 
738
    _LIBCPP_INLINE_VISIBILITY explicit mem_fun1_t(_Sp (_Tp::*__p)(_Ap))
 
739
        : __p_(__p) {}
 
740
    _LIBCPP_INLINE_VISIBILITY _Sp operator()(_Tp* __p, _Ap __x) const
 
741
        {return (__p->*__p_)(__x);}
 
742
};
 
743
 
 
744
template<class _Sp, class _Tp>
 
745
inline _LIBCPP_INLINE_VISIBILITY
 
746
mem_fun_t<_Sp,_Tp>
 
747
mem_fun(_Sp (_Tp::*__f)())
 
748
    {return mem_fun_t<_Sp,_Tp>(__f);}
 
749
 
 
750
template<class _Sp, class _Tp, class _Ap>
 
751
inline _LIBCPP_INLINE_VISIBILITY
 
752
mem_fun1_t<_Sp,_Tp,_Ap>
 
753
mem_fun(_Sp (_Tp::*__f)(_Ap))
 
754
    {return mem_fun1_t<_Sp,_Tp,_Ap>(__f);}
 
755
 
 
756
template<class _Sp, class _Tp>
 
757
class _LIBCPP_TYPE_VIS mem_fun_ref_t : public unary_function<_Tp, _Sp>
 
758
{
 
759
    _Sp (_Tp::*__p_)();
 
760
public:
 
761
    _LIBCPP_INLINE_VISIBILITY explicit mem_fun_ref_t(_Sp (_Tp::*__p)())
 
762
        : __p_(__p) {}
 
763
    _LIBCPP_INLINE_VISIBILITY _Sp operator()(_Tp& __p) const
 
764
        {return (__p.*__p_)();}
 
765
};
 
766
 
 
767
template<class _Sp, class _Tp, class _Ap>
 
768
class _LIBCPP_TYPE_VIS mem_fun1_ref_t : public binary_function<_Tp, _Ap, _Sp>
 
769
{
 
770
    _Sp (_Tp::*__p_)(_Ap);
 
771
public:
 
772
    _LIBCPP_INLINE_VISIBILITY explicit mem_fun1_ref_t(_Sp (_Tp::*__p)(_Ap))
 
773
        : __p_(__p) {}
 
774
    _LIBCPP_INLINE_VISIBILITY _Sp operator()(_Tp& __p, _Ap __x) const
 
775
        {return (__p.*__p_)(__x);}
 
776
};
 
777
 
 
778
template<class _Sp, class _Tp>
 
779
inline _LIBCPP_INLINE_VISIBILITY
 
780
mem_fun_ref_t<_Sp,_Tp>
 
781
mem_fun_ref(_Sp (_Tp::*__f)())
 
782
    {return mem_fun_ref_t<_Sp,_Tp>(__f);}
 
783
 
 
784
template<class _Sp, class _Tp, class _Ap>
 
785
inline _LIBCPP_INLINE_VISIBILITY
 
786
mem_fun1_ref_t<_Sp,_Tp,_Ap>
 
787
mem_fun_ref(_Sp (_Tp::*__f)(_Ap))
 
788
    {return mem_fun1_ref_t<_Sp,_Tp,_Ap>(__f);}
 
789
 
 
790
template <class _Sp, class _Tp>
 
791
class _LIBCPP_TYPE_VIS const_mem_fun_t : public unary_function<const _Tp*, _Sp>
 
792
{
 
793
    _Sp (_Tp::*__p_)() const;
 
794
public:
 
795
    _LIBCPP_INLINE_VISIBILITY explicit const_mem_fun_t(_Sp (_Tp::*__p)() const)
 
796
        : __p_(__p) {}
 
797
    _LIBCPP_INLINE_VISIBILITY _Sp operator()(const _Tp* __p) const
 
798
        {return (__p->*__p_)();}
 
799
};
 
800
 
 
801
template <class _Sp, class _Tp, class _Ap>
 
802
class _LIBCPP_TYPE_VIS const_mem_fun1_t : public binary_function<const _Tp*, _Ap, _Sp>
 
803
{
 
804
    _Sp (_Tp::*__p_)(_Ap) const;
 
805
public:
 
806
    _LIBCPP_INLINE_VISIBILITY explicit const_mem_fun1_t(_Sp (_Tp::*__p)(_Ap) const)
 
807
        : __p_(__p) {}
 
808
    _LIBCPP_INLINE_VISIBILITY _Sp operator()(const _Tp* __p, _Ap __x) const
 
809
        {return (__p->*__p_)(__x);}
 
810
};
 
811
 
 
812
template <class _Sp, class _Tp>
 
813
inline _LIBCPP_INLINE_VISIBILITY
 
814
const_mem_fun_t<_Sp,_Tp>
 
815
mem_fun(_Sp (_Tp::*__f)() const)
 
816
    {return const_mem_fun_t<_Sp,_Tp>(__f);}
 
817
 
 
818
template <class _Sp, class _Tp, class _Ap>
 
819
inline _LIBCPP_INLINE_VISIBILITY
 
820
const_mem_fun1_t<_Sp,_Tp,_Ap>
 
821
mem_fun(_Sp (_Tp::*__f)(_Ap) const)
 
822
    {return const_mem_fun1_t<_Sp,_Tp,_Ap>(__f);}
 
823
 
 
824
template <class _Sp, class _Tp>
 
825
class _LIBCPP_TYPE_VIS const_mem_fun_ref_t : public unary_function<_Tp, _Sp>
 
826
{
 
827
    _Sp (_Tp::*__p_)() const;
 
828
public:
 
829
    _LIBCPP_INLINE_VISIBILITY explicit const_mem_fun_ref_t(_Sp (_Tp::*__p)() const)
 
830
        : __p_(__p) {}
 
831
    _LIBCPP_INLINE_VISIBILITY _Sp operator()(const _Tp& __p) const
 
832
        {return (__p.*__p_)();}
 
833
};
 
834
 
 
835
template <class _Sp, class _Tp, class _Ap>
 
836
class _LIBCPP_TYPE_VIS const_mem_fun1_ref_t
 
837
    : public binary_function<_Tp, _Ap, _Sp>
 
838
{
 
839
    _Sp (_Tp::*__p_)(_Ap) const;
 
840
public:
 
841
    _LIBCPP_INLINE_VISIBILITY explicit const_mem_fun1_ref_t(_Sp (_Tp::*__p)(_Ap) const)
 
842
        : __p_(__p) {}
 
843
    _LIBCPP_INLINE_VISIBILITY _Sp operator()(const _Tp& __p, _Ap __x) const
 
844
        {return (__p.*__p_)(__x);}
 
845
};
 
846
 
 
847
template <class _Sp, class _Tp>
 
848
inline _LIBCPP_INLINE_VISIBILITY
 
849
const_mem_fun_ref_t<_Sp,_Tp>
 
850
mem_fun_ref(_Sp (_Tp::*__f)() const)
 
851
    {return const_mem_fun_ref_t<_Sp,_Tp>(__f);}
 
852
 
 
853
template <class _Sp, class _Tp, class _Ap>
 
854
inline _LIBCPP_INLINE_VISIBILITY
 
855
const_mem_fun1_ref_t<_Sp,_Tp,_Ap>
 
856
mem_fun_ref(_Sp (_Tp::*__f)(_Ap) const)
 
857
    {return const_mem_fun1_ref_t<_Sp,_Tp,_Ap>(__f);}
 
858
 
 
859
#ifdef _LIBCPP_HAS_NO_VARIADICS
 
860
 
 
861
#include <__functional_03>
 
862
 
 
863
#else  // _LIBCPP_HAS_NO_VARIADICS
 
864
 
 
865
template <class _Tp>
 
866
class __mem_fn
 
867
    : public __weak_result_type<_Tp>
 
868
{
 
869
public:
 
870
    // types
 
871
    typedef _Tp type;
 
872
private:
 
873
    type __f_;
 
874
 
 
875
public:
 
876
    _LIBCPP_INLINE_VISIBILITY __mem_fn(type __f) : __f_(__f) {}
 
877
 
 
878
    // invoke
 
879
    template <class... _ArgTypes>
 
880
       _LIBCPP_INLINE_VISIBILITY
 
881
       typename __invoke_return<type, _ArgTypes...>::type
 
882
          operator() (_ArgTypes&&... __args)
 
883
          {
 
884
              return __invoke(__f_, _VSTD::forward<_ArgTypes>(__args)...);
 
885
          }
 
886
};
 
887
 
 
888
template<class _Rp, class _Tp>
 
889
inline _LIBCPP_INLINE_VISIBILITY
 
890
__mem_fn<_Rp _Tp::*>
 
891
mem_fn(_Rp _Tp::* __pm)
 
892
{
 
893
    return __mem_fn<_Rp _Tp::*>(__pm);
 
894
}
 
895
 
 
896
template<class _Rp, class _Tp, class ..._Args>
 
897
inline _LIBCPP_INLINE_VISIBILITY
 
898
__mem_fn<_Rp (_Tp::*)(_Args...)>
 
899
mem_fn(_Rp (_Tp::* __pm)(_Args...))
 
900
{
 
901
    return __mem_fn<_Rp (_Tp::*)(_Args...)>(__pm);
 
902
}
 
903
 
 
904
template<class _Rp, class _Tp, class ..._Args>
 
905
inline _LIBCPP_INLINE_VISIBILITY
 
906
__mem_fn<_Rp (_Tp::*)(_Args...) const>
 
907
mem_fn(_Rp (_Tp::* __pm)(_Args...) const)
 
908
{
 
909
    return __mem_fn<_Rp (_Tp::*)(_Args...) const>(__pm);
 
910
}
 
911
 
 
912
template<class _Rp, class _Tp, class ..._Args>
 
913
inline _LIBCPP_INLINE_VISIBILITY
 
914
__mem_fn<_Rp (_Tp::*)(_Args...) volatile>
 
915
mem_fn(_Rp (_Tp::* __pm)(_Args...) volatile)
 
916
{
 
917
    return __mem_fn<_Rp (_Tp::*)(_Args...) volatile>(__pm);
 
918
}
 
919
 
 
920
template<class _Rp, class _Tp, class ..._Args>
 
921
inline _LIBCPP_INLINE_VISIBILITY
 
922
__mem_fn<_Rp (_Tp::*)(_Args...) const volatile>
 
923
mem_fn(_Rp (_Tp::* __pm)(_Args...) const volatile)
 
924
{
 
925
    return __mem_fn<_Rp (_Tp::*)(_Args...) const volatile>(__pm);
 
926
}
 
927
 
 
928
// bad_function_call
 
929
 
 
930
class _LIBCPP_EXCEPTION_ABI bad_function_call
 
931
    : public exception
 
932
{
 
933
};
 
934
 
 
935
template<class _Fp> class _LIBCPP_TYPE_VIS function; // undefined
 
936
 
 
937
namespace __function
 
938
{
 
939
 
 
940
template<class _Rp, class ..._ArgTypes>
 
941
struct __maybe_derive_from_unary_function
 
942
{
 
943
};
 
944
 
 
945
template<class _Rp, class _A1>
 
946
struct __maybe_derive_from_unary_function<_Rp(_A1)>
 
947
    : public unary_function<_A1, _Rp>
 
948
{
 
949
};
 
950
 
 
951
template<class _Rp, class ..._ArgTypes>
 
952
struct __maybe_derive_from_binary_function
 
953
{
 
954
};
 
955
 
 
956
template<class _Rp, class _A1, class _A2>
 
957
struct __maybe_derive_from_binary_function<_Rp(_A1, _A2)>
 
958
    : public binary_function<_A1, _A2, _Rp>
 
959
{
 
960
};
 
961
 
 
962
template<class _Fp> class __base;
 
963
 
 
964
template<class _Rp, class ..._ArgTypes>
 
965
class __base<_Rp(_ArgTypes...)>
 
966
{
 
967
    __base(const __base&);
 
968
    __base& operator=(const __base&);
 
969
public:
 
970
    _LIBCPP_INLINE_VISIBILITY __base() {}
 
971
    _LIBCPP_INLINE_VISIBILITY virtual ~__base() {}
 
972
    virtual __base* __clone() const = 0;
 
973
    virtual void __clone(__base*) const = 0;
 
974
    virtual void destroy() _NOEXCEPT = 0;
 
975
    virtual void destroy_deallocate() _NOEXCEPT = 0;
 
976
    virtual _Rp operator()(_ArgTypes&& ...) = 0;
 
977
#ifndef _LIBCPP_NO_RTTI
 
978
    virtual const void* target(const type_info&) const _NOEXCEPT = 0;
 
979
    virtual const std::type_info& target_type() const _NOEXCEPT = 0;
 
980
#endif  // _LIBCPP_NO_RTTI
 
981
};
 
982
 
 
983
template<class _FD, class _Alloc, class _FB> class __func;
 
984
 
 
985
template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
 
986
class __func<_Fp, _Alloc, _Rp(_ArgTypes...)>
 
987
    : public  __base<_Rp(_ArgTypes...)>
 
988
{
 
989
    __compressed_pair<_Fp, _Alloc> __f_;
 
990
public:
 
991
    _LIBCPP_INLINE_VISIBILITY
 
992
    explicit __func(_Fp&& __f)
 
993
        : __f_(piecewise_construct, _VSTD::forward_as_tuple(_VSTD::move(__f)),
 
994
                                    _VSTD::forward_as_tuple()) {}
 
995
    _LIBCPP_INLINE_VISIBILITY
 
996
    explicit __func(const _Fp& __f, const _Alloc& __a)
 
997
        : __f_(piecewise_construct, _VSTD::forward_as_tuple(__f),
 
998
                                    _VSTD::forward_as_tuple(__a)) {}
 
999
 
 
1000
    _LIBCPP_INLINE_VISIBILITY
 
1001
    explicit __func(const _Fp& __f, _Alloc&& __a)
 
1002
        : __f_(piecewise_construct, _VSTD::forward_as_tuple(__f),
 
1003
                                    _VSTD::forward_as_tuple(_VSTD::move(__a))) {}
 
1004
 
 
1005
    _LIBCPP_INLINE_VISIBILITY
 
1006
    explicit __func(_Fp&& __f, _Alloc&& __a)
 
1007
        : __f_(piecewise_construct, _VSTD::forward_as_tuple(_VSTD::move(__f)),
 
1008
                                    _VSTD::forward_as_tuple(_VSTD::move(__a))) {}
 
1009
    virtual __base<_Rp(_ArgTypes...)>* __clone() const;
 
1010
    virtual void __clone(__base<_Rp(_ArgTypes...)>*) const;
 
1011
    virtual void destroy() _NOEXCEPT;
 
1012
    virtual void destroy_deallocate() _NOEXCEPT;
 
1013
    virtual _Rp operator()(_ArgTypes&& ... __arg);
 
1014
#ifndef _LIBCPP_NO_RTTI
 
1015
    virtual const void* target(const type_info&) const _NOEXCEPT;
 
1016
    virtual const std::type_info& target_type() const _NOEXCEPT;
 
1017
#endif  // _LIBCPP_NO_RTTI
 
1018
};
 
1019
 
 
1020
template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
 
1021
__base<_Rp(_ArgTypes...)>*
 
1022
__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::__clone() const
 
1023
{
 
1024
    typedef typename _Alloc::template rebind<__func>::other _Ap;
 
1025
    _Ap __a(__f_.second());
 
1026
    typedef __allocator_destructor<_Ap> _Dp;
 
1027
    unique_ptr<__func, _Dp> __hold(__a.allocate(1), _Dp(__a, 1));
 
1028
    ::new (__hold.get()) __func(__f_.first(), _Alloc(__a));
 
1029
    return __hold.release();
 
1030
}
 
1031
 
 
1032
template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
 
1033
void
 
1034
__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::__clone(__base<_Rp(_ArgTypes...)>* __p) const
 
1035
{
 
1036
    ::new (__p) __func(__f_.first(), __f_.second());
 
1037
}
 
1038
 
 
1039
template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
 
1040
void
 
1041
__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::destroy() _NOEXCEPT
 
1042
{
 
1043
    __f_.~__compressed_pair<_Fp, _Alloc>();
 
1044
}
 
1045
 
 
1046
template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
 
1047
void
 
1048
__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::destroy_deallocate() _NOEXCEPT
 
1049
{
 
1050
    typedef typename _Alloc::template rebind<__func>::other _Ap;
 
1051
    _Ap __a(__f_.second());
 
1052
    __f_.~__compressed_pair<_Fp, _Alloc>();
 
1053
    __a.deallocate(this, 1);
 
1054
}
 
1055
 
 
1056
template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
 
1057
_Rp
 
1058
__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::operator()(_ArgTypes&& ... __arg)
 
1059
{
 
1060
    return __invoke(__f_.first(), _VSTD::forward<_ArgTypes>(__arg)...);
 
1061
}
 
1062
 
 
1063
#ifndef _LIBCPP_NO_RTTI
 
1064
 
 
1065
template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
 
1066
const void*
 
1067
__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::target(const type_info& __ti) const _NOEXCEPT
 
1068
{
 
1069
    if (__ti == typeid(_Fp))
 
1070
        return &__f_.first();
 
1071
    return (const void*)0;
 
1072
}
 
1073
 
 
1074
template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
 
1075
const std::type_info&
 
1076
__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::target_type() const _NOEXCEPT
 
1077
{
 
1078
    return typeid(_Fp);
 
1079
}
 
1080
 
 
1081
#endif  // _LIBCPP_NO_RTTI
 
1082
 
 
1083
}  // __function
 
1084
 
 
1085
template<class _Rp, class ..._ArgTypes>
 
1086
class _LIBCPP_TYPE_VIS function<_Rp(_ArgTypes...)>
 
1087
    : public __function::__maybe_derive_from_unary_function<_Rp(_ArgTypes...)>,
 
1088
      public __function::__maybe_derive_from_binary_function<_Rp(_ArgTypes...)>
 
1089
{
 
1090
    typedef __function::__base<_Rp(_ArgTypes...)> __base;
 
1091
    typename aligned_storage<3*sizeof(void*)>::type __buf_;
 
1092
    __base* __f_;
 
1093
 
 
1094
    template <class _Fp>
 
1095
        _LIBCPP_INLINE_VISIBILITY
 
1096
        static bool __not_null(const _Fp&) {return true;}
 
1097
    template <class _R2, class ..._Ap>
 
1098
        _LIBCPP_INLINE_VISIBILITY
 
1099
        static bool __not_null(_R2 (*__p)(_Ap...)) {return __p;}
 
1100
    template <class _R2, class _Cp, class ..._Ap>
 
1101
        _LIBCPP_INLINE_VISIBILITY
 
1102
        static bool __not_null(_R2 (_Cp::*__p)(_Ap...)) {return __p;}
 
1103
    template <class _R2, class _Cp, class ..._Ap>
 
1104
        _LIBCPP_INLINE_VISIBILITY
 
1105
        static bool __not_null(_R2 (_Cp::*__p)(_Ap...) const) {return __p;}
 
1106
    template <class _R2, class _Cp, class ..._Ap>
 
1107
        _LIBCPP_INLINE_VISIBILITY
 
1108
        static bool __not_null(_R2 (_Cp::*__p)(_Ap...) volatile) {return __p;}
 
1109
    template <class _R2, class _Cp, class ..._Ap>
 
1110
        _LIBCPP_INLINE_VISIBILITY
 
1111
        static bool __not_null(_R2 (_Cp::*__p)(_Ap...) const volatile) {return __p;}
 
1112
    template <class _R2, class ..._Ap>
 
1113
        _LIBCPP_INLINE_VISIBILITY
 
1114
        static bool __not_null(const function<_Rp(_Ap...)>& __p) {return __p;}
 
1115
 
 
1116
    template <class _Fp, bool = !is_same<_Fp, function>::value &&
 
1117
                                __invokable<_Fp&, _ArgTypes...>::value>
 
1118
        struct __callable;
 
1119
    template <class _Fp>
 
1120
        struct __callable<_Fp, true>
 
1121
        {
 
1122
            static const bool value =
 
1123
                is_convertible<typename __invoke_of<_Fp&, _ArgTypes...>::type,
 
1124
                               _Rp>::value;
 
1125
        };
 
1126
    template <class _Fp>
 
1127
        struct __callable<_Fp, false>
 
1128
        {
 
1129
            static const bool value = false;
 
1130
        };
 
1131
public:
 
1132
    typedef _Rp result_type;
 
1133
 
 
1134
    // construct/copy/destroy:
 
1135
    _LIBCPP_INLINE_VISIBILITY
 
1136
    function() _NOEXCEPT : __f_(0) {}
 
1137
    _LIBCPP_INLINE_VISIBILITY
 
1138
    function(nullptr_t) _NOEXCEPT : __f_(0) {}
 
1139
    function(const function&);
 
1140
    function(function&&) _NOEXCEPT;
 
1141
    template<class _Fp>
 
1142
      function(_Fp,
 
1143
               typename enable_if<__callable<_Fp>::value>::type* = 0);
 
1144
 
 
1145
    template<class _Alloc>
 
1146
      _LIBCPP_INLINE_VISIBILITY
 
1147
      function(allocator_arg_t, const _Alloc&) _NOEXCEPT : __f_(0) {}
 
1148
    template<class _Alloc>
 
1149
      _LIBCPP_INLINE_VISIBILITY
 
1150
      function(allocator_arg_t, const _Alloc&, nullptr_t) _NOEXCEPT : __f_(0) {}
 
1151
    template<class _Alloc>
 
1152
      function(allocator_arg_t, const _Alloc&, const function&);
 
1153
    template<class _Alloc>
 
1154
      function(allocator_arg_t, const _Alloc&, function&&);
 
1155
    template<class _Fp, class _Alloc>
 
1156
      function(allocator_arg_t, const _Alloc& __a, _Fp __f,
 
1157
               typename enable_if<__callable<_Fp>::value>::type* = 0);
 
1158
 
 
1159
    function& operator=(const function&);
 
1160
    function& operator=(function&&) _NOEXCEPT;
 
1161
    function& operator=(nullptr_t) _NOEXCEPT;
 
1162
    template<class _Fp>
 
1163
      typename enable_if
 
1164
      <
 
1165
        __callable<typename decay<_Fp>::type>::value,
 
1166
        function&
 
1167
      >::type
 
1168
      operator=(_Fp&&);
 
1169
 
 
1170
    ~function();
 
1171
 
 
1172
    // function modifiers:
 
1173
    void swap(function&) _NOEXCEPT;
 
1174
    template<class _Fp, class _Alloc>
 
1175
      _LIBCPP_INLINE_VISIBILITY
 
1176
      void assign(_Fp&& __f, const _Alloc& __a)
 
1177
        {function(allocator_arg, __a, _VSTD::forward<_Fp>(__f)).swap(*this);}
 
1178
 
 
1179
    // function capacity:
 
1180
    _LIBCPP_INLINE_VISIBILITY
 
1181
        _LIBCPP_EXPLICIT operator bool() const _NOEXCEPT {return __f_;}
 
1182
 
 
1183
    // deleted overloads close possible hole in the type system
 
1184
    template<class _R2, class... _ArgTypes2>
 
1185
      bool operator==(const function<_R2(_ArgTypes2...)>&) const = delete;
 
1186
    template<class _R2, class... _ArgTypes2>
 
1187
      bool operator!=(const function<_R2(_ArgTypes2...)>&) const = delete;
 
1188
public:
 
1189
    // function invocation:
 
1190
    _Rp operator()(_ArgTypes...) const;
 
1191
 
 
1192
#ifndef _LIBCPP_NO_RTTI
 
1193
    // function target access:
 
1194
    const std::type_info& target_type() const _NOEXCEPT;
 
1195
    template <typename _Tp> _Tp* target() _NOEXCEPT;
 
1196
    template <typename _Tp> const _Tp* target() const _NOEXCEPT;
 
1197
#endif  // _LIBCPP_NO_RTTI
 
1198
};
 
1199
 
 
1200
template<class _Rp, class ..._ArgTypes>
 
1201
function<_Rp(_ArgTypes...)>::function(const function& __f)
 
1202
{
 
1203
    if (__f.__f_ == 0)
 
1204
        __f_ = 0;
 
1205
    else if (__f.__f_ == (const __base*)&__f.__buf_)
 
1206
    {
 
1207
        __f_ = (__base*)&__buf_;
 
1208
        __f.__f_->__clone(__f_);
 
1209
    }
 
1210
    else
 
1211
        __f_ = __f.__f_->__clone();
 
1212
}
 
1213
 
 
1214
template<class _Rp, class ..._ArgTypes>
 
1215
template <class _Alloc>
 
1216
function<_Rp(_ArgTypes...)>::function(allocator_arg_t, const _Alloc&,
 
1217
                                     const function& __f)
 
1218
{
 
1219
    if (__f.__f_ == 0)
 
1220
        __f_ = 0;
 
1221
    else if (__f.__f_ == (const __base*)&__f.__buf_)
 
1222
    {
 
1223
        __f_ = (__base*)&__buf_;
 
1224
        __f.__f_->__clone(__f_);
 
1225
    }
 
1226
    else
 
1227
        __f_ = __f.__f_->__clone();
 
1228
}
 
1229
 
 
1230
template<class _Rp, class ..._ArgTypes>
 
1231
function<_Rp(_ArgTypes...)>::function(function&& __f) _NOEXCEPT
 
1232
{
 
1233
    if (__f.__f_ == 0)
 
1234
        __f_ = 0;
 
1235
    else if (__f.__f_ == (__base*)&__f.__buf_)
 
1236
    {
 
1237
        __f_ = (__base*)&__buf_;
 
1238
        __f.__f_->__clone(__f_);
 
1239
    }
 
1240
    else
 
1241
    {
 
1242
        __f_ = __f.__f_;
 
1243
        __f.__f_ = 0;
 
1244
    }
 
1245
}
 
1246
 
 
1247
template<class _Rp, class ..._ArgTypes>
 
1248
template <class _Alloc>
 
1249
function<_Rp(_ArgTypes...)>::function(allocator_arg_t, const _Alloc&,
 
1250
                                     function&& __f)
 
1251
{
 
1252
    if (__f.__f_ == 0)
 
1253
        __f_ = 0;
 
1254
    else if (__f.__f_ == (__base*)&__f.__buf_)
 
1255
    {
 
1256
        __f_ = (__base*)&__buf_;
 
1257
        __f.__f_->__clone(__f_);
 
1258
    }
 
1259
    else
 
1260
    {
 
1261
        __f_ = __f.__f_;
 
1262
        __f.__f_ = 0;
 
1263
    }
 
1264
}
 
1265
 
 
1266
template<class _Rp, class ..._ArgTypes>
 
1267
template <class _Fp>
 
1268
function<_Rp(_ArgTypes...)>::function(_Fp __f,
 
1269
                                     typename enable_if<__callable<_Fp>::value>::type*)
 
1270
    : __f_(0)
 
1271
{
 
1272
    if (__not_null(__f))
 
1273
    {
 
1274
        typedef __function::__func<_Fp, allocator<_Fp>, _Rp(_ArgTypes...)> _FF;
 
1275
        if (sizeof(_FF) <= sizeof(__buf_) && is_nothrow_copy_constructible<_Fp>::value)
 
1276
        {
 
1277
            __f_ = (__base*)&__buf_;
 
1278
            ::new (__f_) _FF(_VSTD::move(__f));
 
1279
        }
 
1280
        else
 
1281
        {
 
1282
            typedef allocator<_FF> _Ap;
 
1283
            _Ap __a;
 
1284
            typedef __allocator_destructor<_Ap> _Dp;
 
1285
            unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1));
 
1286
            ::new (__hold.get()) _FF(_VSTD::move(__f), allocator<_Fp>(__a));
 
1287
            __f_ = __hold.release();
 
1288
        }
 
1289
    }
 
1290
}
 
1291
 
 
1292
template<class _Rp, class ..._ArgTypes>
 
1293
template <class _Fp, class _Alloc>
 
1294
function<_Rp(_ArgTypes...)>::function(allocator_arg_t, const _Alloc& __a0, _Fp __f,
 
1295
                                     typename enable_if<__callable<_Fp>::value>::type*)
 
1296
    : __f_(0)
 
1297
{
 
1298
    typedef allocator_traits<_Alloc> __alloc_traits;
 
1299
    if (__not_null(__f))
 
1300
    {
 
1301
        typedef __function::__func<_Fp, _Alloc, _Rp(_ArgTypes...)> _FF;
 
1302
        if (sizeof(_FF) <= sizeof(__buf_) && is_nothrow_copy_constructible<_Fp>::value)
 
1303
        {
 
1304
            __f_ = (__base*)&__buf_;
 
1305
            ::new (__f_) _FF(_VSTD::move(__f));
 
1306
        }
 
1307
        else
 
1308
        {
 
1309
            typedef typename __alloc_traits::template
 
1310
#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES
 
1311
                rebind_alloc<_FF>
 
1312
#else
 
1313
                rebind_alloc<_FF>::other
 
1314
#endif
 
1315
                                                         _Ap;
 
1316
            _Ap __a(__a0);
 
1317
            typedef __allocator_destructor<_Ap> _Dp;
 
1318
            unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1));
 
1319
            ::new (__hold.get()) _FF(_VSTD::move(__f), _Alloc(__a));
 
1320
            __f_ = __hold.release();
 
1321
        }
 
1322
    }
 
1323
}
 
1324
 
 
1325
template<class _Rp, class ..._ArgTypes>
 
1326
function<_Rp(_ArgTypes...)>&
 
1327
function<_Rp(_ArgTypes...)>::operator=(const function& __f)
 
1328
{
 
1329
    function(__f).swap(*this);
 
1330
    return *this;
 
1331
}
 
1332
 
 
1333
template<class _Rp, class ..._ArgTypes>
 
1334
function<_Rp(_ArgTypes...)>&
 
1335
function<_Rp(_ArgTypes...)>::operator=(function&& __f) _NOEXCEPT
 
1336
{
 
1337
    if (__f_ == (__base*)&__buf_)
 
1338
        __f_->destroy();
 
1339
    else if (__f_)
 
1340
        __f_->destroy_deallocate();
 
1341
    __f_ = 0;
 
1342
    if (__f.__f_ == 0)
 
1343
        __f_ = 0;
 
1344
    else if (__f.__f_ == (__base*)&__f.__buf_)
 
1345
    {
 
1346
        __f_ = (__base*)&__buf_;
 
1347
        __f.__f_->__clone(__f_);
 
1348
    }
 
1349
    else
 
1350
    {
 
1351
        __f_ = __f.__f_;
 
1352
        __f.__f_ = 0;
 
1353
    }
 
1354
    return *this;
 
1355
}
 
1356
 
 
1357
template<class _Rp, class ..._ArgTypes>
 
1358
function<_Rp(_ArgTypes...)>&
 
1359
function<_Rp(_ArgTypes...)>::operator=(nullptr_t) _NOEXCEPT
 
1360
{
 
1361
    if (__f_ == (__base*)&__buf_)
 
1362
        __f_->destroy();
 
1363
    else if (__f_)
 
1364
        __f_->destroy_deallocate();
 
1365
    __f_ = 0;
 
1366
    return *this;
 
1367
}
 
1368
 
 
1369
template<class _Rp, class ..._ArgTypes>
 
1370
template <class _Fp>
 
1371
typename enable_if
 
1372
<
 
1373
    function<_Rp(_ArgTypes...)>::template __callable<typename decay<_Fp>::type>::value,
 
1374
    function<_Rp(_ArgTypes...)>&
 
1375
>::type
 
1376
function<_Rp(_ArgTypes...)>::operator=(_Fp&& __f)
 
1377
{
 
1378
    function(_VSTD::forward<_Fp>(__f)).swap(*this);
 
1379
    return *this;
 
1380
}
 
1381
 
 
1382
template<class _Rp, class ..._ArgTypes>
 
1383
function<_Rp(_ArgTypes...)>::~function()
 
1384
{
 
1385
    if (__f_ == (__base*)&__buf_)
 
1386
        __f_->destroy();
 
1387
    else if (__f_)
 
1388
        __f_->destroy_deallocate();
 
1389
}
 
1390
 
 
1391
template<class _Rp, class ..._ArgTypes>
 
1392
void
 
1393
function<_Rp(_ArgTypes...)>::swap(function& __f) _NOEXCEPT
 
1394
{
 
1395
    if (__f_ == (__base*)&__buf_ && __f.__f_ == (__base*)&__f.__buf_)
 
1396
    {
 
1397
        typename aligned_storage<sizeof(__buf_)>::type __tempbuf;
 
1398
        __base* __t = (__base*)&__tempbuf;
 
1399
        __f_->__clone(__t);
 
1400
        __f_->destroy();
 
1401
        __f_ = 0;
 
1402
        __f.__f_->__clone((__base*)&__buf_);
 
1403
        __f.__f_->destroy();
 
1404
        __f.__f_ = 0;
 
1405
        __f_ = (__base*)&__buf_;
 
1406
        __t->__clone((__base*)&__f.__buf_);
 
1407
        __t->destroy();
 
1408
        __f.__f_ = (__base*)&__f.__buf_;
 
1409
    }
 
1410
    else if (__f_ == (__base*)&__buf_)
 
1411
    {
 
1412
        __f_->__clone((__base*)&__f.__buf_);
 
1413
        __f_->destroy();
 
1414
        __f_ = __f.__f_;
 
1415
        __f.__f_ = (__base*)&__f.__buf_;
 
1416
    }
 
1417
    else if (__f.__f_ == (__base*)&__f.__buf_)
 
1418
    {
 
1419
        __f.__f_->__clone((__base*)&__buf_);
 
1420
        __f.__f_->destroy();
 
1421
        __f.__f_ = __f_;
 
1422
        __f_ = (__base*)&__buf_;
 
1423
    }
 
1424
    else
 
1425
        _VSTD::swap(__f_, __f.__f_);
 
1426
}
 
1427
 
 
1428
template<class _Rp, class ..._ArgTypes>
 
1429
_Rp
 
1430
function<_Rp(_ArgTypes...)>::operator()(_ArgTypes... __arg) const
 
1431
{
 
1432
#ifndef _LIBCPP_NO_EXCEPTIONS
 
1433
    if (__f_ == 0)
 
1434
        throw bad_function_call();
 
1435
#endif  // _LIBCPP_NO_EXCEPTIONS
 
1436
    return (*__f_)(_VSTD::forward<_ArgTypes>(__arg)...);
 
1437
}
 
1438
 
 
1439
#ifndef _LIBCPP_NO_RTTI
 
1440
 
 
1441
template<class _Rp, class ..._ArgTypes>
 
1442
const std::type_info&
 
1443
function<_Rp(_ArgTypes...)>::target_type() const _NOEXCEPT
 
1444
{
 
1445
    if (__f_ == 0)
 
1446
        return typeid(void);
 
1447
    return __f_->target_type();
 
1448
}
 
1449
 
 
1450
template<class _Rp, class ..._ArgTypes>
 
1451
template <typename _Tp>
 
1452
_Tp*
 
1453
function<_Rp(_ArgTypes...)>::target() _NOEXCEPT
 
1454
{
 
1455
    if (__f_ == 0)
 
1456
        return (_Tp*)0;
 
1457
    return (_Tp*)__f_->target(typeid(_Tp));
 
1458
}
 
1459
 
 
1460
template<class _Rp, class ..._ArgTypes>
 
1461
template <typename _Tp>
 
1462
const _Tp*
 
1463
function<_Rp(_ArgTypes...)>::target() const _NOEXCEPT
 
1464
{
 
1465
    if (__f_ == 0)
 
1466
        return (const _Tp*)0;
 
1467
    return (const _Tp*)__f_->target(typeid(_Tp));
 
1468
}
 
1469
 
 
1470
#endif  // _LIBCPP_NO_RTTI
 
1471
 
 
1472
template <class _Rp, class... _ArgTypes>
 
1473
inline _LIBCPP_INLINE_VISIBILITY
 
1474
bool
 
1475
operator==(const function<_Rp(_ArgTypes...)>& __f, nullptr_t) _NOEXCEPT {return !__f;}
 
1476
 
 
1477
template <class _Rp, class... _ArgTypes>
 
1478
inline _LIBCPP_INLINE_VISIBILITY
 
1479
bool
 
1480
operator==(nullptr_t, const function<_Rp(_ArgTypes...)>& __f) _NOEXCEPT {return !__f;}
 
1481
 
 
1482
template <class _Rp, class... _ArgTypes>
 
1483
inline _LIBCPP_INLINE_VISIBILITY
 
1484
bool
 
1485
operator!=(const function<_Rp(_ArgTypes...)>& __f, nullptr_t) _NOEXCEPT {return (bool)__f;}
 
1486
 
 
1487
template <class _Rp, class... _ArgTypes>
 
1488
inline _LIBCPP_INLINE_VISIBILITY
 
1489
bool
 
1490
operator!=(nullptr_t, const function<_Rp(_ArgTypes...)>& __f) _NOEXCEPT {return (bool)__f;}
 
1491
 
 
1492
template <class _Rp, class... _ArgTypes>
 
1493
inline _LIBCPP_INLINE_VISIBILITY
 
1494
void
 
1495
swap(function<_Rp(_ArgTypes...)>& __x, function<_Rp(_ArgTypes...)>& __y) _NOEXCEPT
 
1496
{return __x.swap(__y);}
 
1497
 
 
1498
template<class _Tp> struct __is_bind_expression : public false_type {};
 
1499
template<class _Tp> struct _LIBCPP_TYPE_VIS is_bind_expression
 
1500
    : public __is_bind_expression<typename remove_cv<_Tp>::type> {};
 
1501
 
 
1502
template<class _Tp> struct __is_placeholder : public integral_constant<int, 0> {};
 
1503
template<class _Tp> struct _LIBCPP_TYPE_VIS is_placeholder
 
1504
    : public __is_placeholder<typename remove_cv<_Tp>::type> {};
 
1505
 
 
1506
namespace placeholders
 
1507
{
 
1508
 
 
1509
template <int _Np> struct __ph {};
 
1510
 
 
1511
extern __ph<1>   _1;
 
1512
extern __ph<2>   _2;
 
1513
extern __ph<3>   _3;
 
1514
extern __ph<4>   _4;
 
1515
extern __ph<5>   _5;
 
1516
extern __ph<6>   _6;
 
1517
extern __ph<7>   _7;
 
1518
extern __ph<8>   _8;
 
1519
extern __ph<9>   _9;
 
1520
extern __ph<10> _10;
 
1521
 
 
1522
}  // placeholders
 
1523
 
 
1524
template<int _Np>
 
1525
struct __is_placeholder<placeholders::__ph<_Np> >
 
1526
    : public integral_constant<int, _Np> {};
 
1527
 
 
1528
template <class _Tp, class _Uj>
 
1529
inline _LIBCPP_INLINE_VISIBILITY
 
1530
_Tp&
 
1531
__mu(reference_wrapper<_Tp> __t, _Uj&)
 
1532
{
 
1533
    return __t.get();
 
1534
}
 
1535
 
 
1536
template <class _Ti, class ..._Uj, size_t ..._Indx>
 
1537
inline _LIBCPP_INLINE_VISIBILITY
 
1538
typename __invoke_of<_Ti&, _Uj...>::type
 
1539
__mu_expand(_Ti& __ti, tuple<_Uj...>& __uj, __tuple_indices<_Indx...>)
 
1540
{
 
1541
    return __ti(_VSTD::forward<_Uj>(get<_Indx>(__uj))...);
 
1542
}
 
1543
 
 
1544
template <class _Ti, class ..._Uj>
 
1545
inline _LIBCPP_INLINE_VISIBILITY
 
1546
typename enable_if
 
1547
<
 
1548
    is_bind_expression<_Ti>::value,
 
1549
    typename __invoke_of<_Ti&, _Uj...>::type
 
1550
>::type
 
1551
__mu(_Ti& __ti, tuple<_Uj...>& __uj)
 
1552
{
 
1553
    typedef typename __make_tuple_indices<sizeof...(_Uj)>::type __indices;
 
1554
    return  __mu_expand(__ti, __uj, __indices());
 
1555
}
 
1556
 
 
1557
template <bool IsPh, class _Ti, class _Uj>
 
1558
struct __mu_return2 {};
 
1559
 
 
1560
template <class _Ti, class _Uj>
 
1561
struct __mu_return2<true, _Ti, _Uj>
 
1562
{
 
1563
    typedef typename tuple_element<is_placeholder<_Ti>::value - 1, _Uj>::type type;
 
1564
};
 
1565
 
 
1566
template <class _Ti, class _Uj>
 
1567
inline _LIBCPP_INLINE_VISIBILITY
 
1568
typename enable_if
 
1569
<
 
1570
    0 < is_placeholder<_Ti>::value,
 
1571
    typename __mu_return2<0 < is_placeholder<_Ti>::value, _Ti, _Uj>::type
 
1572
>::type
 
1573
__mu(_Ti&, _Uj& __uj)
 
1574
{
 
1575
    const size_t _Indx = is_placeholder<_Ti>::value - 1;
 
1576
    return _VSTD::forward<typename tuple_element<_Indx, _Uj>::type>(get<_Indx>(__uj));
 
1577
}
 
1578
 
 
1579
template <class _Ti, class _Uj>
 
1580
inline _LIBCPP_INLINE_VISIBILITY
 
1581
typename enable_if
 
1582
<
 
1583
    !is_bind_expression<_Ti>::value &&
 
1584
    is_placeholder<_Ti>::value == 0 &&
 
1585
    !__is_reference_wrapper<_Ti>::value,
 
1586
    _Ti&
 
1587
>::type
 
1588
__mu(_Ti& __ti, _Uj&)
 
1589
{
 
1590
    return __ti;
 
1591
}
 
1592
 
 
1593
template <class _Ti, bool IsReferenceWrapper, bool IsBindEx, bool IsPh,
 
1594
          class _TupleUj>
 
1595
struct ____mu_return;
 
1596
 
 
1597
template <class _Ti, class ..._Uj>
 
1598
struct ____mu_return<_Ti, false, true, false, tuple<_Uj...> >
 
1599
{
 
1600
    typedef typename __invoke_of<_Ti&, _Uj...>::type type;
 
1601
};
 
1602
 
 
1603
template <class _Ti, class _TupleUj>
 
1604
struct ____mu_return<_Ti, false, false, true, _TupleUj>
 
1605
{
 
1606
    typedef typename tuple_element<is_placeholder<_Ti>::value - 1,
 
1607
                                   _TupleUj>::type&& type;
 
1608
};
 
1609
 
 
1610
template <class _Ti, class _TupleUj>
 
1611
struct ____mu_return<_Ti, true, false, false, _TupleUj>
 
1612
{
 
1613
    typedef typename _Ti::type& type;
 
1614
};
 
1615
 
 
1616
template <class _Ti, class _TupleUj>
 
1617
struct ____mu_return<_Ti, false, false, false, _TupleUj>
 
1618
{
 
1619
    typedef _Ti& type;
 
1620
};
 
1621
 
 
1622
template <class _Ti, class _TupleUj>
 
1623
struct __mu_return
 
1624
    : public ____mu_return<_Ti,
 
1625
                           __is_reference_wrapper<_Ti>::value,
 
1626
                           is_bind_expression<_Ti>::value,
 
1627
                           0 < is_placeholder<_Ti>::value &&
 
1628
                           is_placeholder<_Ti>::value <= tuple_size<_TupleUj>::value,
 
1629
                           _TupleUj>
 
1630
{
 
1631
};
 
1632
 
 
1633
template <class _Fp, class _BoundArgs, class _TupleUj>
 
1634
struct _is_valid_bind_return
 
1635
{
 
1636
    static const bool value = false;
 
1637
};
 
1638
 
 
1639
template <class _Fp, class ..._BoundArgs, class _TupleUj>
 
1640
struct _is_valid_bind_return<_Fp, tuple<_BoundArgs...>, _TupleUj>
 
1641
{
 
1642
    static const bool value = __invokable<_Fp,
 
1643
                    typename __mu_return<_BoundArgs, _TupleUj>::type...>::value;
 
1644
};
 
1645
 
 
1646
template <class _Fp, class ..._BoundArgs, class _TupleUj>
 
1647
struct _is_valid_bind_return<_Fp, const tuple<_BoundArgs...>, _TupleUj>
 
1648
{
 
1649
    static const bool value = __invokable<_Fp,
 
1650
                    typename __mu_return<const _BoundArgs, _TupleUj>::type...>::value;
 
1651
};
 
1652
 
 
1653
template <class _Fp, class _BoundArgs, class _TupleUj,
 
1654
          bool = _is_valid_bind_return<_Fp, _BoundArgs, _TupleUj>::value>
 
1655
struct __bind_return;
 
1656
 
 
1657
template <class _Fp, class ..._BoundArgs, class _TupleUj>
 
1658
struct __bind_return<_Fp, tuple<_BoundArgs...>, _TupleUj, true>
 
1659
{
 
1660
    typedef typename __invoke_of
 
1661
    <
 
1662
        _Fp&,
 
1663
        typename __mu_return
 
1664
        <
 
1665
            _BoundArgs,
 
1666
            _TupleUj
 
1667
        >::type...
 
1668
    >::type type;
 
1669
};
 
1670
 
 
1671
template <class _Fp, class ..._BoundArgs, class _TupleUj>
 
1672
struct __bind_return<_Fp, const tuple<_BoundArgs...>, _TupleUj, true>
 
1673
{
 
1674
    typedef typename __invoke_of
 
1675
    <
 
1676
        _Fp&,
 
1677
        typename __mu_return
 
1678
        <
 
1679
            const _BoundArgs,
 
1680
            _TupleUj
 
1681
        >::type...
 
1682
    >::type type;
 
1683
};
 
1684
 
 
1685
template <class _Fp, class _BoundArgs, size_t ..._Indx, class _Args>
 
1686
inline _LIBCPP_INLINE_VISIBILITY
 
1687
typename __bind_return<_Fp, _BoundArgs, _Args>::type
 
1688
__apply_functor(_Fp& __f, _BoundArgs& __bound_args, __tuple_indices<_Indx...>,
 
1689
                _Args&& __args)
 
1690
{
 
1691
    return __invoke(__f, __mu(get<_Indx>(__bound_args), __args)...);
 
1692
}
 
1693
 
 
1694
template<class _Fp, class ..._BoundArgs>
 
1695
class __bind
 
1696
    : public __weak_result_type<typename decay<_Fp>::type>
 
1697
{
 
1698
protected:
 
1699
    typedef typename decay<_Fp>::type _Fd;
 
1700
    typedef tuple<typename decay<_BoundArgs>::type...> _Td;
 
1701
private:
 
1702
    _Fd __f_;
 
1703
    _Td __bound_args_;
 
1704
 
 
1705
    typedef typename __make_tuple_indices<sizeof...(_BoundArgs)>::type __indices;
 
1706
public:
 
1707
#ifdef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
 
1708
 
 
1709
    _LIBCPP_INLINE_VISIBILITY
 
1710
    __bind(const __bind& __b)
 
1711
        : __f_(__b.__f_),
 
1712
          __bound_args_(__b.__bound_args_) {}
 
1713
 
 
1714
    _LIBCPP_INLINE_VISIBILITY
 
1715
    __bind& operator=(const __bind& __b)
 
1716
    {
 
1717
        __f_ = __b.__f_;
 
1718
        __bound_args_ = __b.__bound_args_;
 
1719
        return *this;
 
1720
    }
 
1721
 
 
1722
    _LIBCPP_INLINE_VISIBILITY
 
1723
    __bind(__bind&& __b)
 
1724
        : __f_(_VSTD::move(__b.__f_)),
 
1725
          __bound_args_(_VSTD::move(__b.__bound_args_)) {}
 
1726
 
 
1727
    _LIBCPP_INLINE_VISIBILITY
 
1728
    __bind& operator=(__bind&& __b)
 
1729
    {
 
1730
        __f_ = _VSTD::move(__b.__f_);
 
1731
        __bound_args_ = _VSTD::move(__b.__bound_args_);
 
1732
        return *this;
 
1733
    }
 
1734
 
 
1735
#endif  // _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
 
1736
 
 
1737
    template <class _Gp, class ..._BA,
 
1738
              class = typename enable_if
 
1739
                               <
 
1740
                                  is_constructible<_Fd, _Gp>::value
 
1741
                               >::type>
 
1742
      _LIBCPP_INLINE_VISIBILITY
 
1743
      explicit __bind(_Gp&& __f, _BA&& ...__bound_args)
 
1744
        : __f_(_VSTD::forward<_Gp>(__f)),
 
1745
          __bound_args_(_VSTD::forward<_BA>(__bound_args)...) {}
 
1746
 
 
1747
    template <class ..._Args>
 
1748
        _LIBCPP_INLINE_VISIBILITY
 
1749
        typename __bind_return<_Fd, _Td, tuple<_Args&&...> >::type
 
1750
        operator()(_Args&& ...__args)
 
1751
        {
 
1752
            return __apply_functor(__f_, __bound_args_, __indices(),
 
1753
                                  tuple<_Args&&...>(_VSTD::forward<_Args>(__args)...));
 
1754
        }
 
1755
 
 
1756
    template <class ..._Args>
 
1757
        _LIBCPP_INLINE_VISIBILITY
 
1758
        typename __bind_return<const _Fd, const _Td, tuple<_Args&&...> >::type
 
1759
        operator()(_Args&& ...__args) const
 
1760
        {
 
1761
            return __apply_functor(__f_, __bound_args_, __indices(),
 
1762
                                   tuple<_Args&&...>(_VSTD::forward<_Args>(__args)...));
 
1763
        }
 
1764
};
 
1765
 
 
1766
template<class _Fp, class ..._BoundArgs>
 
1767
struct __is_bind_expression<__bind<_Fp, _BoundArgs...> > : public true_type {};
 
1768
 
 
1769
template<class _Rp, class _Fp, class ..._BoundArgs>
 
1770
class __bind_r
 
1771
    : public __bind<_Fp, _BoundArgs...>
 
1772
{
 
1773
    typedef __bind<_Fp, _BoundArgs...> base;
 
1774
    typedef typename base::_Fd _Fd;
 
1775
    typedef typename base::_Td _Td;
 
1776
public:
 
1777
    typedef _Rp result_type;
 
1778
 
 
1779
#ifdef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
 
1780
 
 
1781
    _LIBCPP_INLINE_VISIBILITY
 
1782
    __bind_r(const __bind_r& __b)
 
1783
        : base(_VSTD::forward<const base&>(__b)) {}
 
1784
 
 
1785
    _LIBCPP_INLINE_VISIBILITY
 
1786
    __bind_r& operator=(const __bind_r& __b)
 
1787
    {
 
1788
        base::operator=(_VSTD::forward<const base&>(__b));
 
1789
        return *this;
 
1790
    }
 
1791
 
 
1792
    _LIBCPP_INLINE_VISIBILITY
 
1793
    __bind_r(__bind_r&& __b)
 
1794
        : base(_VSTD::forward<base>(__b)) {}
 
1795
 
 
1796
    _LIBCPP_INLINE_VISIBILITY
 
1797
    __bind_r& operator=(__bind_r&& __b)
 
1798
    {
 
1799
        base::operator=(_VSTD::forward<base>(__b));
 
1800
        return *this;
 
1801
    }
 
1802
 
 
1803
#endif  // _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
 
1804
 
 
1805
    template <class _Gp, class ..._BA>
 
1806
      _LIBCPP_INLINE_VISIBILITY
 
1807
      explicit __bind_r(_Gp&& __f, _BA&& ...__bound_args)
 
1808
        : base(_VSTD::forward<_Gp>(__f),
 
1809
               _VSTD::forward<_BA>(__bound_args)...) {}
 
1810
 
 
1811
    template <class ..._Args>
 
1812
        _LIBCPP_INLINE_VISIBILITY
 
1813
        typename enable_if
 
1814
        <
 
1815
            is_convertible<typename __bind_return<_Fd, _Td, tuple<_Args&&...> >::type,
 
1816
                           result_type>::value,
 
1817
            result_type
 
1818
        >::type
 
1819
        operator()(_Args&& ...__args)
 
1820
        {
 
1821
            return base::operator()(_VSTD::forward<_Args>(__args)...);
 
1822
        }
 
1823
 
 
1824
    template <class ..._Args>
 
1825
        _LIBCPP_INLINE_VISIBILITY
 
1826
        typename enable_if
 
1827
        <
 
1828
            is_convertible<typename __bind_return<const _Fd, const _Td, tuple<_Args&&...> >::type,
 
1829
                           result_type>::value,
 
1830
            result_type
 
1831
        >::type
 
1832
        operator()(_Args&& ...__args) const
 
1833
        {
 
1834
            return base::operator()(_VSTD::forward<_Args>(__args)...);
 
1835
        }
 
1836
};
 
1837
 
 
1838
template<class _Rp, class _Fp, class ..._BoundArgs>
 
1839
struct __is_bind_expression<__bind_r<_Rp, _Fp, _BoundArgs...> > : public true_type {};
 
1840
 
 
1841
template<class _Fp, class ..._BoundArgs>
 
1842
inline _LIBCPP_INLINE_VISIBILITY
 
1843
__bind<_Fp, _BoundArgs...>
 
1844
bind(_Fp&& __f, _BoundArgs&&... __bound_args)
 
1845
{
 
1846
    typedef __bind<_Fp, _BoundArgs...> type;
 
1847
    return type(_VSTD::forward<_Fp>(__f), _VSTD::forward<_BoundArgs>(__bound_args)...);
 
1848
}
 
1849
 
 
1850
template<class _Rp, class _Fp, class ..._BoundArgs>
 
1851
inline _LIBCPP_INLINE_VISIBILITY
 
1852
__bind_r<_Rp, _Fp, _BoundArgs...>
 
1853
bind(_Fp&& __f, _BoundArgs&&... __bound_args)
 
1854
{
 
1855
    typedef __bind_r<_Rp, _Fp, _BoundArgs...> type;
 
1856
    return type(_VSTD::forward<_Fp>(__f), _VSTD::forward<_BoundArgs>(__bound_args)...);
 
1857
}
 
1858
 
 
1859
#endif  // _LIBCPP_HAS_NO_VARIADICS
 
1860
 
 
1861
template <>
 
1862
struct _LIBCPP_TYPE_VIS hash<bool>
 
1863
    : public unary_function<bool, size_t>
 
1864
{
 
1865
    _LIBCPP_INLINE_VISIBILITY
 
1866
    size_t operator()(bool __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
 
1867
};
 
1868
 
 
1869
template <>
 
1870
struct _LIBCPP_TYPE_VIS hash<char>
 
1871
    : public unary_function<char, size_t>
 
1872
{
 
1873
    _LIBCPP_INLINE_VISIBILITY
 
1874
    size_t operator()(char __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
 
1875
};
 
1876
 
 
1877
template <>
 
1878
struct _LIBCPP_TYPE_VIS hash<signed char>
 
1879
    : public unary_function<signed char, size_t>
 
1880
{
 
1881
    _LIBCPP_INLINE_VISIBILITY
 
1882
    size_t operator()(signed char __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
 
1883
};
 
1884
 
 
1885
template <>
 
1886
struct _LIBCPP_TYPE_VIS hash<unsigned char>
 
1887
    : public unary_function<unsigned char, size_t>
 
1888
{
 
1889
    _LIBCPP_INLINE_VISIBILITY
 
1890
    size_t operator()(unsigned char __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
 
1891
};
 
1892
 
 
1893
#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
 
1894
 
 
1895
template <>
 
1896
struct _LIBCPP_TYPE_VIS hash<char16_t>
 
1897
    : public unary_function<char16_t, size_t>
 
1898
{
 
1899
    _LIBCPP_INLINE_VISIBILITY
 
1900
    size_t operator()(char16_t __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
 
1901
};
 
1902
 
 
1903
template <>
 
1904
struct _LIBCPP_TYPE_VIS hash<char32_t>
 
1905
    : public unary_function<char32_t, size_t>
 
1906
{
 
1907
    _LIBCPP_INLINE_VISIBILITY
 
1908
    size_t operator()(char32_t __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
 
1909
};
 
1910
 
 
1911
#endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
 
1912
 
 
1913
template <>
 
1914
struct _LIBCPP_TYPE_VIS hash<wchar_t>
 
1915
    : public unary_function<wchar_t, size_t>
 
1916
{
 
1917
    _LIBCPP_INLINE_VISIBILITY
 
1918
    size_t operator()(wchar_t __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
 
1919
};
 
1920
 
 
1921
template <>
 
1922
struct _LIBCPP_TYPE_VIS hash<short>
 
1923
    : public unary_function<short, size_t>
 
1924
{
 
1925
    _LIBCPP_INLINE_VISIBILITY
 
1926
    size_t operator()(short __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
 
1927
};
 
1928
 
 
1929
template <>
 
1930
struct _LIBCPP_TYPE_VIS hash<unsigned short>
 
1931
    : public unary_function<unsigned short, size_t>
 
1932
{
 
1933
    _LIBCPP_INLINE_VISIBILITY
 
1934
    size_t operator()(unsigned short __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
 
1935
};
 
1936
 
 
1937
template <>
 
1938
struct _LIBCPP_TYPE_VIS hash<int>
 
1939
    : public unary_function<int, size_t>
 
1940
{
 
1941
    _LIBCPP_INLINE_VISIBILITY
 
1942
    size_t operator()(int __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
 
1943
};
 
1944
 
 
1945
template <>
 
1946
struct _LIBCPP_TYPE_VIS hash<unsigned int>
 
1947
    : public unary_function<unsigned int, size_t>
 
1948
{
 
1949
    _LIBCPP_INLINE_VISIBILITY
 
1950
    size_t operator()(unsigned int __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
 
1951
};
 
1952
 
 
1953
template <>
 
1954
struct _LIBCPP_TYPE_VIS hash<long>
 
1955
    : public unary_function<long, size_t>
 
1956
{
 
1957
    _LIBCPP_INLINE_VISIBILITY
 
1958
    size_t operator()(long __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
 
1959
};
 
1960
 
 
1961
template <>
 
1962
struct _LIBCPP_TYPE_VIS hash<unsigned long>
 
1963
    : public unary_function<unsigned long, size_t>
 
1964
{
 
1965
    _LIBCPP_INLINE_VISIBILITY
 
1966
    size_t operator()(unsigned long __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
 
1967
};
 
1968
 
 
1969
template <>
 
1970
struct _LIBCPP_TYPE_VIS hash<long long>
 
1971
    : public __scalar_hash<long long>
 
1972
{
 
1973
};
 
1974
 
 
1975
template <>
 
1976
struct _LIBCPP_TYPE_VIS hash<unsigned long long>
 
1977
    : public __scalar_hash<unsigned long long>
 
1978
{
 
1979
};
 
1980
 
 
1981
template <>
 
1982
struct _LIBCPP_TYPE_VIS hash<float>
 
1983
    : public __scalar_hash<float>
 
1984
{
 
1985
    _LIBCPP_INLINE_VISIBILITY
 
1986
    size_t operator()(float __v) const _NOEXCEPT
 
1987
    {
 
1988
        // -0.0 and 0.0 should return same hash
 
1989
       if (__v == 0)
 
1990
           return 0;
 
1991
        return __scalar_hash<float>::operator()(__v);
 
1992
    }
 
1993
};
 
1994
 
 
1995
template <>
 
1996
struct _LIBCPP_TYPE_VIS hash<double>
 
1997
    : public __scalar_hash<double>
 
1998
{
 
1999
    _LIBCPP_INLINE_VISIBILITY
 
2000
    size_t operator()(double __v) const _NOEXCEPT
 
2001
    {
 
2002
        // -0.0 and 0.0 should return same hash
 
2003
       if (__v == 0)
 
2004
           return 0;
 
2005
        return __scalar_hash<double>::operator()(__v);
 
2006
    }
 
2007
};
 
2008
 
 
2009
template <>
 
2010
struct _LIBCPP_TYPE_VIS hash<long double>
 
2011
    : public __scalar_hash<long double>
 
2012
{
 
2013
    _LIBCPP_INLINE_VISIBILITY
 
2014
    size_t operator()(long double __v) const _NOEXCEPT
 
2015
    {
 
2016
        // -0.0 and 0.0 should return same hash
 
2017
        if (__v == 0)
 
2018
            return 0;
 
2019
#if defined(__i386__)
 
2020
        // Zero out padding bits
 
2021
        union
 
2022
        {
 
2023
            long double __t;
 
2024
            struct
 
2025
            {
 
2026
                size_t __a;
 
2027
                size_t __b;
 
2028
                size_t __c;
 
2029
                size_t __d;
 
2030
            };
 
2031
        } __u;
 
2032
        __u.__a = 0;
 
2033
        __u.__b = 0;
 
2034
        __u.__c = 0;
 
2035
        __u.__d = 0;
 
2036
        __u.__t = __v;
 
2037
        return __u.__a ^ __u.__b ^ __u.__c ^ __u.__d;
 
2038
#elif defined(__x86_64__)
 
2039
        // Zero out padding bits
 
2040
        union
 
2041
        {
 
2042
            long double __t;
 
2043
            struct
 
2044
            {
 
2045
                size_t __a;
 
2046
                size_t __b;
 
2047
            };
 
2048
        } __u;
 
2049
        __u.__a = 0;
 
2050
        __u.__b = 0;
 
2051
        __u.__t = __v;
 
2052
        return __u.__a ^ __u.__b;
 
2053
#else
 
2054
        return __scalar_hash<long double>::operator()(__v);
 
2055
#endif
 
2056
    }
 
2057
};
 
2058
 
 
2059
// struct hash<T*> in <memory>
 
2060
 
 
2061
_LIBCPP_END_NAMESPACE_STD
 
2062
 
 
2063
#endif  // _LIBCPP_FUNCTIONAL