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