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