xref: /freebsd/contrib/llvm-project/libcxx/include/__functional/function.h (revision da5432eda807c4b7232d030d5157d5b417ea4f52) 
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 <__assert>
14 #include <__config>
15 #include <__functional/binary_function.h>
16 #include <__functional/invoke.h>
17 #include <__functional/unary_function.h>
18 #include <__iterator/iterator_traits.h>
19 #include <__memory/addressof.h>
20 #include <__memory/allocator.h>
21 #include <__memory/allocator_destructor.h>
22 #include <__memory/allocator_traits.h>
23 #include <__memory/builtin_new_allocator.h>
24 #include <__memory/compressed_pair.h>
25 #include <__memory/unique_ptr.h>
26 #include <__type_traits/strip_signature.h>
27 #include <__utility/forward.h>
28 #include <__utility/move.h>
29 #include <__utility/piecewise_construct.h>
30 #include <__utility/swap.h>
31 #include <exception>
32 #include <new>
33 #include <tuple>
34 #include <type_traits>
35 #include <typeinfo>
36 
37 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
38 #  pragma GCC system_header
39 #endif
40 
41 #ifndef _LIBCPP_CXX03_LANG
42 
43 _LIBCPP_BEGIN_NAMESPACE_STD
44 
45 // bad_function_call
46 
47 _LIBCPP_DIAGNOSTIC_PUSH
48 _LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wweak-vtables")
49 class _LIBCPP_EXCEPTION_ABI bad_function_call
50     : public exception
51 {
52 public:
53 // Note that when a key function is not used, every translation unit that uses
54 // bad_function_call will end up containing a weak definition of the vtable and
55 // typeinfo.
56 #ifdef _LIBCPP_ABI_BAD_FUNCTION_CALL_KEY_FUNCTION
57     ~bad_function_call() _NOEXCEPT override;
58 #else
59     ~bad_function_call() _NOEXCEPT override {}
60 #endif
61 
62 #ifdef _LIBCPP_ABI_BAD_FUNCTION_CALL_GOOD_WHAT_MESSAGE
63     const char* what() const _NOEXCEPT override;
64 #endif
65 };
66 _LIBCPP_DIAGNOSTIC_POP
67 
68 _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
69 void __throw_bad_function_call()
70 {
71 #ifndef _LIBCPP_NO_EXCEPTIONS
72     throw bad_function_call();
73 #else
74     _VSTD::abort();
75 #endif
76 }
77 
78 template<class _Fp> class _LIBCPP_TEMPLATE_VIS function; // undefined
79 
80 namespace __function
81 {
82 
83 template<class _Rp>
84 struct __maybe_derive_from_unary_function
85 {
86 };
87 
88 template<class _Rp, class _A1>
89 struct __maybe_derive_from_unary_function<_Rp(_A1)>
90     : public __unary_function<_A1, _Rp>
91 {
92 };
93 
94 template<class _Rp>
95 struct __maybe_derive_from_binary_function
96 {
97 };
98 
99 template<class _Rp, class _A1, class _A2>
100 struct __maybe_derive_from_binary_function<_Rp(_A1, _A2)>
101     : public __binary_function<_A1, _A2, _Rp>
102 {
103 };
104 
105 template <class _Fp>
106 _LIBCPP_INLINE_VISIBILITY
107 bool __not_null(_Fp const&) { return true; }
108 
109 template <class _Fp>
110 _LIBCPP_INLINE_VISIBILITY
111 bool __not_null(_Fp* __ptr) { return __ptr; }
112 
113 template <class _Ret, class _Class>
114 _LIBCPP_INLINE_VISIBILITY
115 bool __not_null(_Ret _Class::*__ptr) { return __ptr; }
116 
117 template <class _Fp>
118 _LIBCPP_INLINE_VISIBILITY
119 bool __not_null(function<_Fp> const& __f) { return !!__f; }
120 
121 #ifdef _LIBCPP_HAS_EXTENSION_BLOCKS
122 template <class _Rp, class ..._Args>
123 _LIBCPP_INLINE_VISIBILITY
124 bool __not_null(_Rp (^__p)(_Args...)) { return __p; }
125 #endif
126 
127 } // namespace __function
128 
129 namespace __function {
130 
131 // __alloc_func holds a functor and an allocator.
132 
133 template <class _Fp, class _Ap, class _FB> class __alloc_func;
134 template <class _Fp, class _FB>
135 class __default_alloc_func;
136 
137 template <class _Fp, class _Ap, class _Rp, class... _ArgTypes>
138 class __alloc_func<_Fp, _Ap, _Rp(_ArgTypes...)>
139 {
140     __compressed_pair<_Fp, _Ap> __f_;
141 
142   public:
143     typedef _LIBCPP_NODEBUG _Fp _Target;
144     typedef _LIBCPP_NODEBUG _Ap _Alloc;
145 
146     _LIBCPP_INLINE_VISIBILITY
147     const _Target& __target() const { return __f_.first(); }
148 
149     // WIN32 APIs may define __allocator, so use __get_allocator instead.
150     _LIBCPP_INLINE_VISIBILITY
151     const _Alloc& __get_allocator() const { return __f_.second(); }
152 
153     _LIBCPP_INLINE_VISIBILITY
154     explicit __alloc_func(_Target&& __f)
155         : __f_(piecewise_construct, _VSTD::forward_as_tuple(_VSTD::move(__f)),
156                _VSTD::forward_as_tuple())
157     {
158     }
159 
160     _LIBCPP_INLINE_VISIBILITY
161     explicit __alloc_func(const _Target& __f, const _Alloc& __a)
162         : __f_(piecewise_construct, _VSTD::forward_as_tuple(__f),
163                _VSTD::forward_as_tuple(__a))
164     {
165     }
166 
167     _LIBCPP_INLINE_VISIBILITY
168     explicit __alloc_func(const _Target& __f, _Alloc&& __a)
169         : __f_(piecewise_construct, _VSTD::forward_as_tuple(__f),
170                _VSTD::forward_as_tuple(_VSTD::move(__a)))
171     {
172     }
173 
174     _LIBCPP_INLINE_VISIBILITY
175     explicit __alloc_func(_Target&& __f, _Alloc&& __a)
176         : __f_(piecewise_construct, _VSTD::forward_as_tuple(_VSTD::move(__f)),
177                _VSTD::forward_as_tuple(_VSTD::move(__a)))
178     {
179     }
180 
181     _LIBCPP_INLINE_VISIBILITY
182     _Rp operator()(_ArgTypes&&... __arg)
183     {
184         typedef __invoke_void_return_wrapper<_Rp> _Invoker;
185         return _Invoker::__call(__f_.first(),
186                                 _VSTD::forward<_ArgTypes>(__arg)...);
187     }
188 
189     _LIBCPP_INLINE_VISIBILITY
190     __alloc_func* __clone() const
191     {
192         typedef allocator_traits<_Alloc> __alloc_traits;
193         typedef __rebind_alloc<__alloc_traits, __alloc_func> _AA;
194         _AA __a(__f_.second());
195         typedef __allocator_destructor<_AA> _Dp;
196         unique_ptr<__alloc_func, _Dp> __hold(__a.allocate(1), _Dp(__a, 1));
197         ::new ((void*)__hold.get()) __alloc_func(__f_.first(), _Alloc(__a));
198         return __hold.release();
199     }
200 
201     _LIBCPP_INLINE_VISIBILITY
202     void destroy() _NOEXCEPT { __f_.~__compressed_pair<_Target, _Alloc>(); }
203 
204     static void __destroy_and_delete(__alloc_func* __f) {
205       typedef allocator_traits<_Alloc> __alloc_traits;
206       typedef __rebind_alloc<__alloc_traits, __alloc_func> _FunAlloc;
207       _FunAlloc __a(__f->__get_allocator());
208       __f->destroy();
209       __a.deallocate(__f, 1);
210     }
211 };
212 
213 template <class _Fp, class _Rp, class... _ArgTypes>
214 class __default_alloc_func<_Fp, _Rp(_ArgTypes...)> {
215   _Fp __f_;
216 
217 public:
218   typedef _LIBCPP_NODEBUG _Fp _Target;
219 
220   _LIBCPP_INLINE_VISIBILITY
221   const _Target& __target() const { return __f_; }
222 
223   _LIBCPP_INLINE_VISIBILITY
224   explicit __default_alloc_func(_Target&& __f) : __f_(_VSTD::move(__f)) {}
225 
226   _LIBCPP_INLINE_VISIBILITY
227   explicit __default_alloc_func(const _Target& __f) : __f_(__f) {}
228 
229   _LIBCPP_INLINE_VISIBILITY
230   _Rp operator()(_ArgTypes&&... __arg) {
231     typedef __invoke_void_return_wrapper<_Rp> _Invoker;
232     return _Invoker::__call(__f_, _VSTD::forward<_ArgTypes>(__arg)...);
233   }
234 
235   _LIBCPP_INLINE_VISIBILITY
236   __default_alloc_func* __clone() const {
237       __builtin_new_allocator::__holder_t __hold =
238         __builtin_new_allocator::__allocate_type<__default_alloc_func>(1);
239     __default_alloc_func* __res =
240         ::new ((void*)__hold.get()) __default_alloc_func(__f_);
241     (void)__hold.release();
242     return __res;
243   }
244 
245   _LIBCPP_INLINE_VISIBILITY
246   void destroy() _NOEXCEPT { __f_.~_Target(); }
247 
248   static void __destroy_and_delete(__default_alloc_func* __f) {
249     __f->destroy();
250       __builtin_new_allocator::__deallocate_type<__default_alloc_func>(__f, 1);
251   }
252 };
253 
254 // __base provides an abstract interface for copyable functors.
255 
256 template<class _Fp> class _LIBCPP_TEMPLATE_VIS __base;
257 
258 template<class _Rp, class ..._ArgTypes>
259 class __base<_Rp(_ArgTypes...)>
260 {
261     __base(const __base&);
262     __base& operator=(const __base&);
263 public:
264     _LIBCPP_INLINE_VISIBILITY __base() {}
265     _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual ~__base() {}
266     virtual __base* __clone() const = 0;
267     virtual void __clone(__base*) const = 0;
268     virtual void destroy() _NOEXCEPT = 0;
269     virtual void destroy_deallocate() _NOEXCEPT = 0;
270     virtual _Rp operator()(_ArgTypes&& ...) = 0;
271 #ifndef _LIBCPP_HAS_NO_RTTI
272     virtual const void* target(const type_info&) const _NOEXCEPT = 0;
273     virtual const std::type_info& target_type() const _NOEXCEPT = 0;
274 #endif // _LIBCPP_HAS_NO_RTTI
275 };
276 
277 // __func implements __base for a given functor type.
278 
279 template<class _FD, class _Alloc, class _FB> class __func;
280 
281 template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
282 class __func<_Fp, _Alloc, _Rp(_ArgTypes...)>
283     : public  __base<_Rp(_ArgTypes...)>
284 {
285     __alloc_func<_Fp, _Alloc, _Rp(_ArgTypes...)> __f_;
286 public:
287     _LIBCPP_INLINE_VISIBILITY
288     explicit __func(_Fp&& __f)
289         : __f_(_VSTD::move(__f)) {}
290 
291     _LIBCPP_INLINE_VISIBILITY
292     explicit __func(const _Fp& __f, const _Alloc& __a)
293         : __f_(__f, __a) {}
294 
295     _LIBCPP_INLINE_VISIBILITY
296     explicit __func(const _Fp& __f, _Alloc&& __a)
297         : __f_(__f, _VSTD::move(__a)) {}
298 
299     _LIBCPP_INLINE_VISIBILITY
300     explicit __func(_Fp&& __f, _Alloc&& __a)
301         : __f_(_VSTD::move(__f), _VSTD::move(__a)) {}
302 
303     virtual __base<_Rp(_ArgTypes...)>* __clone() const;
304     virtual void __clone(__base<_Rp(_ArgTypes...)>*) const;
305     virtual void destroy() _NOEXCEPT;
306     virtual void destroy_deallocate() _NOEXCEPT;
307     virtual _Rp operator()(_ArgTypes&&... __arg);
308 #ifndef _LIBCPP_HAS_NO_RTTI
309     virtual const void* target(const type_info&) const _NOEXCEPT;
310     virtual const std::type_info& target_type() const _NOEXCEPT;
311 #endif // _LIBCPP_HAS_NO_RTTI
312 };
313 
314 template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
315 __base<_Rp(_ArgTypes...)>*
316 __func<_Fp, _Alloc, _Rp(_ArgTypes...)>::__clone() const
317 {
318     typedef allocator_traits<_Alloc> __alloc_traits;
319     typedef __rebind_alloc<__alloc_traits, __func> _Ap;
320     _Ap __a(__f_.__get_allocator());
321     typedef __allocator_destructor<_Ap> _Dp;
322     unique_ptr<__func, _Dp> __hold(__a.allocate(1), _Dp(__a, 1));
323     ::new ((void*)__hold.get()) __func(__f_.__target(), _Alloc(__a));
324     return __hold.release();
325 }
326 
327 template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
328 void
329 __func<_Fp, _Alloc, _Rp(_ArgTypes...)>::__clone(__base<_Rp(_ArgTypes...)>* __p) const
330 {
331     ::new ((void*)__p) __func(__f_.__target(), __f_.__get_allocator());
332 }
333 
334 template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
335 void
336 __func<_Fp, _Alloc, _Rp(_ArgTypes...)>::destroy() _NOEXCEPT
337 {
338     __f_.destroy();
339 }
340 
341 template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
342 void
343 __func<_Fp, _Alloc, _Rp(_ArgTypes...)>::destroy_deallocate() _NOEXCEPT
344 {
345     typedef allocator_traits<_Alloc> __alloc_traits;
346     typedef __rebind_alloc<__alloc_traits, __func> _Ap;
347     _Ap __a(__f_.__get_allocator());
348     __f_.destroy();
349     __a.deallocate(this, 1);
350 }
351 
352 template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
353 _Rp
354 __func<_Fp, _Alloc, _Rp(_ArgTypes...)>::operator()(_ArgTypes&& ... __arg)
355 {
356     return __f_(_VSTD::forward<_ArgTypes>(__arg)...);
357 }
358 
359 #ifndef _LIBCPP_HAS_NO_RTTI
360 
361 template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
362 const void*
363 __func<_Fp, _Alloc, _Rp(_ArgTypes...)>::target(const type_info& __ti) const _NOEXCEPT
364 {
365     if (__ti == typeid(_Fp))
366         return _VSTD::addressof(__f_.__target());
367     return nullptr;
368 }
369 
370 template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
371 const std::type_info&
372 __func<_Fp, _Alloc, _Rp(_ArgTypes...)>::target_type() const _NOEXCEPT
373 {
374     return typeid(_Fp);
375 }
376 
377 #endif // _LIBCPP_HAS_NO_RTTI
378 
379 // __value_func creates a value-type from a __func.
380 
381 template <class _Fp> class __value_func;
382 
383 template <class _Rp, class... _ArgTypes> class __value_func<_Rp(_ArgTypes...)>
384 {
385     _LIBCPP_SUPPRESS_DEPRECATED_PUSH
386     typename aligned_storage<3 * sizeof(void*)>::type __buf_;
387     _LIBCPP_SUPPRESS_DEPRECATED_POP
388 
389     typedef __base<_Rp(_ArgTypes...)> __func;
390     __func* __f_;
391 
392     _LIBCPP_NO_CFI static __func* __as_base(void* __p)
393     {
394         return reinterpret_cast<__func*>(__p);
395     }
396 
397   public:
398     _LIBCPP_INLINE_VISIBILITY
399     __value_func() _NOEXCEPT : __f_(nullptr) {}
400 
401     template <class _Fp, class _Alloc>
402     _LIBCPP_INLINE_VISIBILITY __value_func(_Fp&& __f, const _Alloc& __a)
403         : __f_(nullptr)
404     {
405         typedef allocator_traits<_Alloc> __alloc_traits;
406         typedef __function::__func<_Fp, _Alloc, _Rp(_ArgTypes...)> _Fun;
407         typedef __rebind_alloc<__alloc_traits, _Fun> _FunAlloc;
408 
409         if (__function::__not_null(__f))
410         {
411             _FunAlloc __af(__a);
412             if (sizeof(_Fun) <= sizeof(__buf_) &&
413                 is_nothrow_copy_constructible<_Fp>::value &&
414                 is_nothrow_copy_constructible<_FunAlloc>::value)
415             {
416                 __f_ =
417                     ::new ((void*)&__buf_) _Fun(_VSTD::move(__f), _Alloc(__af));
418             }
419             else
420             {
421                 typedef __allocator_destructor<_FunAlloc> _Dp;
422                 unique_ptr<__func, _Dp> __hold(__af.allocate(1), _Dp(__af, 1));
423                 ::new ((void*)__hold.get()) _Fun(_VSTD::move(__f), _Alloc(__a));
424                 __f_ = __hold.release();
425             }
426         }
427     }
428 
429     template <class _Fp,
430         class = typename enable_if<!is_same<typename decay<_Fp>::type, __value_func>::value>::type>
431     _LIBCPP_INLINE_VISIBILITY explicit __value_func(_Fp&& __f)
432         : __value_func(_VSTD::forward<_Fp>(__f), allocator<_Fp>()) {}
433 
434     _LIBCPP_INLINE_VISIBILITY
435     __value_func(const __value_func& __f)
436     {
437         if (__f.__f_ == nullptr)
438             __f_ = nullptr;
439         else if ((void*)__f.__f_ == &__f.__buf_)
440         {
441             __f_ = __as_base(&__buf_);
442             __f.__f_->__clone(__f_);
443         }
444         else
445             __f_ = __f.__f_->__clone();
446     }
447 
448     _LIBCPP_INLINE_VISIBILITY
449     __value_func(__value_func&& __f) _NOEXCEPT
450     {
451         if (__f.__f_ == nullptr)
452             __f_ = nullptr;
453         else if ((void*)__f.__f_ == &__f.__buf_)
454         {
455             __f_ = __as_base(&__buf_);
456             __f.__f_->__clone(__f_);
457         }
458         else
459         {
460             __f_ = __f.__f_;
461             __f.__f_ = nullptr;
462         }
463     }
464 
465     _LIBCPP_INLINE_VISIBILITY
466     ~__value_func()
467     {
468         if ((void*)__f_ == &__buf_)
469             __f_->destroy();
470         else if (__f_)
471             __f_->destroy_deallocate();
472     }
473 
474     _LIBCPP_INLINE_VISIBILITY
475     __value_func& operator=(__value_func&& __f)
476     {
477         *this = nullptr;
478         if (__f.__f_ == nullptr)
479             __f_ = nullptr;
480         else if ((void*)__f.__f_ == &__f.__buf_)
481         {
482             __f_ = __as_base(&__buf_);
483             __f.__f_->__clone(__f_);
484         }
485         else
486         {
487             __f_ = __f.__f_;
488             __f.__f_ = nullptr;
489         }
490         return *this;
491     }
492 
493     _LIBCPP_INLINE_VISIBILITY
494     __value_func& operator=(nullptr_t)
495     {
496         __func* __f = __f_;
497         __f_ = nullptr;
498         if ((void*)__f == &__buf_)
499             __f->destroy();
500         else if (__f)
501             __f->destroy_deallocate();
502         return *this;
503     }
504 
505     _LIBCPP_INLINE_VISIBILITY
506     _Rp operator()(_ArgTypes&&... __args) const
507     {
508         if (__f_ == nullptr)
509             __throw_bad_function_call();
510         return (*__f_)(_VSTD::forward<_ArgTypes>(__args)...);
511     }
512 
513     _LIBCPP_INLINE_VISIBILITY
514     void swap(__value_func& __f) _NOEXCEPT
515     {
516         if (&__f == this)
517             return;
518         if ((void*)__f_ == &__buf_ && (void*)__f.__f_ == &__f.__buf_)
519         {
520             _LIBCPP_SUPPRESS_DEPRECATED_PUSH
521             typename aligned_storage<sizeof(__buf_)>::type __tempbuf;
522             _LIBCPP_SUPPRESS_DEPRECATED_POP
523             __func* __t = __as_base(&__tempbuf);
524             __f_->__clone(__t);
525             __f_->destroy();
526             __f_ = nullptr;
527             __f.__f_->__clone(__as_base(&__buf_));
528             __f.__f_->destroy();
529             __f.__f_ = nullptr;
530             __f_ = __as_base(&__buf_);
531             __t->__clone(__as_base(&__f.__buf_));
532             __t->destroy();
533             __f.__f_ = __as_base(&__f.__buf_);
534         }
535         else if ((void*)__f_ == &__buf_)
536         {
537             __f_->__clone(__as_base(&__f.__buf_));
538             __f_->destroy();
539             __f_ = __f.__f_;
540             __f.__f_ = __as_base(&__f.__buf_);
541         }
542         else if ((void*)__f.__f_ == &__f.__buf_)
543         {
544             __f.__f_->__clone(__as_base(&__buf_));
545             __f.__f_->destroy();
546             __f.__f_ = __f_;
547             __f_ = __as_base(&__buf_);
548         }
549         else
550             _VSTD::swap(__f_, __f.__f_);
551     }
552 
553     _LIBCPP_INLINE_VISIBILITY
554     explicit operator bool() const _NOEXCEPT { return __f_ != nullptr; }
555 
556 #ifndef _LIBCPP_HAS_NO_RTTI
557     _LIBCPP_INLINE_VISIBILITY
558     const std::type_info& target_type() const _NOEXCEPT
559     {
560         if (__f_ == nullptr)
561             return typeid(void);
562         return __f_->target_type();
563     }
564 
565     template <typename _Tp>
566     _LIBCPP_INLINE_VISIBILITY const _Tp* target() const _NOEXCEPT
567     {
568         if (__f_ == nullptr)
569             return nullptr;
570         return (const _Tp*)__f_->target(typeid(_Tp));
571     }
572 #endif // _LIBCPP_HAS_NO_RTTI
573 };
574 
575 // Storage for a functor object, to be used with __policy to manage copy and
576 // destruction.
577 union __policy_storage
578 {
579     mutable char __small[sizeof(void*) * 2];
580     void* __large;
581 };
582 
583 // True if _Fun can safely be held in __policy_storage.__small.
584 template <typename _Fun>
585 struct __use_small_storage
586     : public integral_constant<
587           bool, sizeof(_Fun) <= sizeof(__policy_storage) &&
588                     _LIBCPP_ALIGNOF(_Fun) <= _LIBCPP_ALIGNOF(__policy_storage) &&
589                     is_trivially_copy_constructible<_Fun>::value &&
590                     is_trivially_destructible<_Fun>::value> {};
591 
592 // Policy contains information about how to copy, destroy, and move the
593 // underlying functor. You can think of it as a vtable of sorts.
594 struct __policy
595 {
596     // Used to copy or destroy __large values. null for trivial objects.
597     void* (*const __clone)(const void*);
598     void (*const __destroy)(void*);
599 
600     // True if this is the null policy (no value).
601     const bool __is_null;
602 
603     // The target type. May be null if RTTI is disabled.
604     const std::type_info* const __type_info;
605 
606     // Returns a pointer to a static policy object suitable for the functor
607     // type.
608     template <typename _Fun>
609     _LIBCPP_INLINE_VISIBILITY static const __policy* __create()
610     {
611         return __choose_policy<_Fun>(__use_small_storage<_Fun>());
612     }
613 
614     _LIBCPP_INLINE_VISIBILITY
615     static const __policy* __create_empty()
616     {
617         static const _LIBCPP_CONSTEXPR __policy __policy_ = {nullptr, nullptr,
618                                                              true,
619 #ifndef _LIBCPP_HAS_NO_RTTI
620                                                              &typeid(void)
621 #else
622                                                              nullptr
623 #endif
624         };
625         return &__policy_;
626     }
627 
628   private:
629     template <typename _Fun> static void* __large_clone(const void* __s)
630     {
631         const _Fun* __f = static_cast<const _Fun*>(__s);
632         return __f->__clone();
633     }
634 
635     template <typename _Fun>
636     static void __large_destroy(void* __s) {
637       _Fun::__destroy_and_delete(static_cast<_Fun*>(__s));
638     }
639 
640     template <typename _Fun>
641     _LIBCPP_INLINE_VISIBILITY static const __policy*
642     __choose_policy(/* is_small = */ false_type) {
643       static const _LIBCPP_CONSTEXPR __policy __policy_ = {
644           &__large_clone<_Fun>, &__large_destroy<_Fun>, false,
645 #ifndef _LIBCPP_HAS_NO_RTTI
646           &typeid(typename _Fun::_Target)
647 #else
648           nullptr
649 #endif
650       };
651         return &__policy_;
652     }
653 
654     template <typename _Fun>
655     _LIBCPP_INLINE_VISIBILITY static const __policy*
656         __choose_policy(/* is_small = */ true_type)
657     {
658         static const _LIBCPP_CONSTEXPR __policy __policy_ = {
659             nullptr, nullptr, false,
660 #ifndef _LIBCPP_HAS_NO_RTTI
661             &typeid(typename _Fun::_Target)
662 #else
663             nullptr
664 #endif
665         };
666         return &__policy_;
667     }
668 };
669 
670 // Used to choose between perfect forwarding or pass-by-value. Pass-by-value is
671 // faster for types that can be passed in registers.
672 template <typename _Tp>
673 using __fast_forward = __conditional_t<is_scalar<_Tp>::value, _Tp, _Tp&&>;
674 
675 // __policy_invoker calls an instance of __alloc_func held in __policy_storage.
676 
677 template <class _Fp> struct __policy_invoker;
678 
679 template <class _Rp, class... _ArgTypes>
680 struct __policy_invoker<_Rp(_ArgTypes...)>
681 {
682     typedef _Rp (*__Call)(const __policy_storage*,
683                           __fast_forward<_ArgTypes>...);
684 
685     __Call __call_;
686 
687     // Creates an invoker that throws bad_function_call.
688     _LIBCPP_INLINE_VISIBILITY
689     __policy_invoker() : __call_(&__call_empty) {}
690 
691     // Creates an invoker that calls the given instance of __func.
692     template <typename _Fun>
693     _LIBCPP_INLINE_VISIBILITY static __policy_invoker __create()
694     {
695         return __policy_invoker(&__call_impl<_Fun>);
696     }
697 
698   private:
699     _LIBCPP_INLINE_VISIBILITY
700     explicit __policy_invoker(__Call __c) : __call_(__c) {}
701 
702     static _Rp __call_empty(const __policy_storage*,
703                             __fast_forward<_ArgTypes>...)
704     {
705         __throw_bad_function_call();
706     }
707 
708     template <typename _Fun>
709     static _Rp __call_impl(const __policy_storage* __buf,
710                            __fast_forward<_ArgTypes>... __args)
711     {
712         _Fun* __f = reinterpret_cast<_Fun*>(__use_small_storage<_Fun>::value
713                                                 ? &__buf->__small
714                                                 : __buf->__large);
715         return (*__f)(_VSTD::forward<_ArgTypes>(__args)...);
716     }
717 };
718 
719 // __policy_func uses a __policy and __policy_invoker to create a type-erased,
720 // copyable functor.
721 
722 template <class _Fp> class __policy_func;
723 
724 template <class _Rp, class... _ArgTypes> class __policy_func<_Rp(_ArgTypes...)>
725 {
726     // Inline storage for small objects.
727     __policy_storage __buf_;
728 
729     // Calls the value stored in __buf_. This could technically be part of
730     // policy, but storing it here eliminates a level of indirection inside
731     // operator().
732     typedef __function::__policy_invoker<_Rp(_ArgTypes...)> __invoker;
733     __invoker __invoker_;
734 
735     // The policy that describes how to move / copy / destroy __buf_. Never
736     // null, even if the function is empty.
737     const __policy* __policy_;
738 
739   public:
740     _LIBCPP_INLINE_VISIBILITY
741     __policy_func() : __policy_(__policy::__create_empty()) {}
742 
743     template <class _Fp, class _Alloc>
744     _LIBCPP_INLINE_VISIBILITY __policy_func(_Fp&& __f, const _Alloc& __a)
745         : __policy_(__policy::__create_empty())
746     {
747         typedef __alloc_func<_Fp, _Alloc, _Rp(_ArgTypes...)> _Fun;
748         typedef allocator_traits<_Alloc> __alloc_traits;
749         typedef __rebind_alloc<__alloc_traits, _Fun> _FunAlloc;
750 
751         if (__function::__not_null(__f))
752         {
753             __invoker_ = __invoker::template __create<_Fun>();
754             __policy_ = __policy::__create<_Fun>();
755 
756             _FunAlloc __af(__a);
757             if (__use_small_storage<_Fun>())
758             {
759                 ::new ((void*)&__buf_.__small)
760                     _Fun(_VSTD::move(__f), _Alloc(__af));
761             }
762             else
763             {
764                 typedef __allocator_destructor<_FunAlloc> _Dp;
765                 unique_ptr<_Fun, _Dp> __hold(__af.allocate(1), _Dp(__af, 1));
766                 ::new ((void*)__hold.get())
767                     _Fun(_VSTD::move(__f), _Alloc(__af));
768                 __buf_.__large = __hold.release();
769             }
770         }
771     }
772 
773     template <class _Fp, class = typename enable_if<!is_same<typename decay<_Fp>::type, __policy_func>::value>::type>
774     _LIBCPP_INLINE_VISIBILITY explicit __policy_func(_Fp&& __f)
775         : __policy_(__policy::__create_empty()) {
776       typedef __default_alloc_func<_Fp, _Rp(_ArgTypes...)> _Fun;
777 
778       if (__function::__not_null(__f)) {
779         __invoker_ = __invoker::template __create<_Fun>();
780         __policy_ = __policy::__create<_Fun>();
781         if (__use_small_storage<_Fun>()) {
782           ::new ((void*)&__buf_.__small) _Fun(_VSTD::move(__f));
783         } else {
784           __builtin_new_allocator::__holder_t __hold =
785               __builtin_new_allocator::__allocate_type<_Fun>(1);
786           __buf_.__large = ::new ((void*)__hold.get()) _Fun(_VSTD::move(__f));
787           (void)__hold.release();
788         }
789       }
790     }
791 
792     _LIBCPP_INLINE_VISIBILITY
793     __policy_func(const __policy_func& __f)
794         : __buf_(__f.__buf_), __invoker_(__f.__invoker_),
795           __policy_(__f.__policy_)
796     {
797         if (__policy_->__clone)
798             __buf_.__large = __policy_->__clone(__f.__buf_.__large);
799     }
800 
801     _LIBCPP_INLINE_VISIBILITY
802     __policy_func(__policy_func&& __f)
803         : __buf_(__f.__buf_), __invoker_(__f.__invoker_),
804           __policy_(__f.__policy_)
805     {
806         if (__policy_->__destroy)
807         {
808             __f.__policy_ = __policy::__create_empty();
809             __f.__invoker_ = __invoker();
810         }
811     }
812 
813     _LIBCPP_INLINE_VISIBILITY
814     ~__policy_func()
815     {
816         if (__policy_->__destroy)
817             __policy_->__destroy(__buf_.__large);
818     }
819 
820     _LIBCPP_INLINE_VISIBILITY
821     __policy_func& operator=(__policy_func&& __f)
822     {
823         *this = nullptr;
824         __buf_ = __f.__buf_;
825         __invoker_ = __f.__invoker_;
826         __policy_ = __f.__policy_;
827         __f.__policy_ = __policy::__create_empty();
828         __f.__invoker_ = __invoker();
829         return *this;
830     }
831 
832     _LIBCPP_INLINE_VISIBILITY
833     __policy_func& operator=(nullptr_t)
834     {
835         const __policy* __p = __policy_;
836         __policy_ = __policy::__create_empty();
837         __invoker_ = __invoker();
838         if (__p->__destroy)
839             __p->__destroy(__buf_.__large);
840         return *this;
841     }
842 
843     _LIBCPP_INLINE_VISIBILITY
844     _Rp operator()(_ArgTypes&&... __args) const
845     {
846         return __invoker_.__call_(_VSTD::addressof(__buf_),
847                                   _VSTD::forward<_ArgTypes>(__args)...);
848     }
849 
850     _LIBCPP_INLINE_VISIBILITY
851     void swap(__policy_func& __f)
852     {
853         _VSTD::swap(__invoker_, __f.__invoker_);
854         _VSTD::swap(__policy_, __f.__policy_);
855         _VSTD::swap(__buf_, __f.__buf_);
856     }
857 
858     _LIBCPP_INLINE_VISIBILITY
859     explicit operator bool() const _NOEXCEPT
860     {
861         return !__policy_->__is_null;
862     }
863 
864 #ifndef _LIBCPP_HAS_NO_RTTI
865     _LIBCPP_INLINE_VISIBILITY
866     const std::type_info& target_type() const _NOEXCEPT
867     {
868         return *__policy_->__type_info;
869     }
870 
871     template <typename _Tp>
872     _LIBCPP_INLINE_VISIBILITY const _Tp* target() const _NOEXCEPT
873     {
874         if (__policy_->__is_null || typeid(_Tp) != *__policy_->__type_info)
875             return nullptr;
876         if (__policy_->__clone) // Out of line storage.
877             return reinterpret_cast<const _Tp*>(__buf_.__large);
878         else
879             return reinterpret_cast<const _Tp*>(&__buf_.__small);
880     }
881 #endif // _LIBCPP_HAS_NO_RTTI
882 };
883 
884 #if defined(_LIBCPP_HAS_BLOCKS_RUNTIME)
885 
886 extern "C" void *_Block_copy(const void *);
887 extern "C" void _Block_release(const void *);
888 
889 template<class _Rp1, class ..._ArgTypes1, class _Alloc, class _Rp, class ..._ArgTypes>
890 class __func<_Rp1(^)(_ArgTypes1...), _Alloc, _Rp(_ArgTypes...)>
891     : public  __base<_Rp(_ArgTypes...)>
892 {
893     typedef _Rp1(^__block_type)(_ArgTypes1...);
894     __block_type __f_;
895 
896 public:
897     _LIBCPP_INLINE_VISIBILITY
898     explicit __func(__block_type const& __f)
899 #ifdef _LIBCPP_HAS_OBJC_ARC
900         : __f_(__f)
901 #else
902         : __f_(reinterpret_cast<__block_type>(__f ? _Block_copy(__f) : nullptr))
903 #endif
904     { }
905 
906     // [TODO] add && to save on a retain
907 
908     _LIBCPP_INLINE_VISIBILITY
909     explicit __func(__block_type __f, const _Alloc& /* unused */)
910 #ifdef _LIBCPP_HAS_OBJC_ARC
911         : __f_(__f)
912 #else
913         : __f_(reinterpret_cast<__block_type>(__f ? _Block_copy(__f) : nullptr))
914 #endif
915     { }
916 
917     virtual __base<_Rp(_ArgTypes...)>* __clone() const {
918         _LIBCPP_ASSERT(false,
919             "Block pointers are just pointers, so they should always fit into "
920             "std::function's small buffer optimization. This function should "
921             "never be invoked.");
922         return nullptr;
923     }
924 
925     virtual void __clone(__base<_Rp(_ArgTypes...)>* __p) const {
926         ::new ((void*)__p) __func(__f_);
927     }
928 
929     virtual void destroy() _NOEXCEPT {
930 #ifndef _LIBCPP_HAS_OBJC_ARC
931         if (__f_)
932             _Block_release(__f_);
933 #endif
934         __f_ = 0;
935     }
936 
937     virtual void destroy_deallocate() _NOEXCEPT {
938         _LIBCPP_ASSERT(false,
939             "Block pointers are just pointers, so they should always fit into "
940             "std::function's small buffer optimization. This function should "
941             "never be invoked.");
942     }
943 
944     virtual _Rp operator()(_ArgTypes&& ... __arg) {
945         return _VSTD::__invoke(__f_, _VSTD::forward<_ArgTypes>(__arg)...);
946     }
947 
948 #ifndef _LIBCPP_HAS_NO_RTTI
949     virtual const void* target(type_info const& __ti) const _NOEXCEPT {
950         if (__ti == typeid(__func::__block_type))
951             return &__f_;
952         return (const void*)nullptr;
953     }
954 
955     virtual const std::type_info& target_type() const _NOEXCEPT {
956         return typeid(__func::__block_type);
957     }
958 #endif // _LIBCPP_HAS_NO_RTTI
959 };
960 
961 #endif // _LIBCPP_HAS_EXTENSION_BLOCKS
962 
963 } // namespace __function
964 
965 template<class _Rp, class ..._ArgTypes>
966 class _LIBCPP_TEMPLATE_VIS function<_Rp(_ArgTypes...)>
967     : public __function::__maybe_derive_from_unary_function<_Rp(_ArgTypes...)>,
968       public __function::__maybe_derive_from_binary_function<_Rp(_ArgTypes...)>
969 {
970 #ifndef _LIBCPP_ABI_OPTIMIZED_FUNCTION
971     typedef __function::__value_func<_Rp(_ArgTypes...)> __func;
972 #else
973     typedef __function::__policy_func<_Rp(_ArgTypes...)> __func;
974 #endif
975 
976     __func __f_;
977 
978     template <class _Fp, bool = _And<
979         _IsNotSame<__remove_cvref_t<_Fp>, function>,
980         __invokable<_Fp, _ArgTypes...>
981     >::value>
982     struct __callable;
983     template <class _Fp>
984         struct __callable<_Fp, true>
985         {
986             static const bool value = is_void<_Rp>::value ||
987                 __is_core_convertible<typename __invoke_of<_Fp, _ArgTypes...>::type,
988                                       _Rp>::value;
989         };
990     template <class _Fp>
991         struct __callable<_Fp, false>
992         {
993             static const bool value = false;
994         };
995 
996   template <class _Fp>
997   using _EnableIfLValueCallable = typename enable_if<__callable<_Fp&>::value>::type;
998 public:
999     typedef _Rp result_type;
1000 
1001     // construct/copy/destroy:
1002     _LIBCPP_INLINE_VISIBILITY
1003     function() _NOEXCEPT { }
1004     _LIBCPP_INLINE_VISIBILITY
1005     function(nullptr_t) _NOEXCEPT {}
1006     function(const function&);
1007     function(function&&) _NOEXCEPT;
1008     template<class _Fp, class = _EnableIfLValueCallable<_Fp>>
1009     function(_Fp);
1010 
1011 #if _LIBCPP_STD_VER <= 14
1012     template<class _Alloc>
1013       _LIBCPP_INLINE_VISIBILITY
1014       function(allocator_arg_t, const _Alloc&) _NOEXCEPT {}
1015     template<class _Alloc>
1016       _LIBCPP_INLINE_VISIBILITY
1017       function(allocator_arg_t, const _Alloc&, nullptr_t) _NOEXCEPT {}
1018     template<class _Alloc>
1019       function(allocator_arg_t, const _Alloc&, const function&);
1020     template<class _Alloc>
1021       function(allocator_arg_t, const _Alloc&, function&&);
1022     template<class _Fp, class _Alloc, class = _EnableIfLValueCallable<_Fp>>
1023       function(allocator_arg_t, const _Alloc& __a, _Fp __f);
1024 #endif
1025 
1026     function& operator=(const function&);
1027     function& operator=(function&&) _NOEXCEPT;
1028     function& operator=(nullptr_t) _NOEXCEPT;
1029     template<class _Fp, class = _EnableIfLValueCallable<typename decay<_Fp>::type>>
1030     function& operator=(_Fp&&);
1031 
1032     ~function();
1033 
1034     // function modifiers:
1035     void swap(function&) _NOEXCEPT;
1036 
1037 #if _LIBCPP_STD_VER <= 14
1038     template<class _Fp, class _Alloc>
1039       _LIBCPP_INLINE_VISIBILITY
1040       void assign(_Fp&& __f, const _Alloc& __a)
1041         {function(allocator_arg, __a, _VSTD::forward<_Fp>(__f)).swap(*this);}
1042 #endif
1043 
1044     // function capacity:
1045     _LIBCPP_INLINE_VISIBILITY
1046     explicit operator bool() const _NOEXCEPT {
1047       return static_cast<bool>(__f_);
1048     }
1049 
1050     // deleted overloads close possible hole in the type system
1051     template<class _R2, class... _ArgTypes2>
1052       bool operator==(const function<_R2(_ArgTypes2...)>&) const = delete;
1053     template<class _R2, class... _ArgTypes2>
1054       bool operator!=(const function<_R2(_ArgTypes2...)>&) const = delete;
1055 public:
1056     // function invocation:
1057     _Rp operator()(_ArgTypes...) const;
1058 
1059 #ifndef _LIBCPP_HAS_NO_RTTI
1060     // function target access:
1061     const std::type_info& target_type() const _NOEXCEPT;
1062     template <typename _Tp> _Tp* target() _NOEXCEPT;
1063     template <typename _Tp> const _Tp* target() const _NOEXCEPT;
1064 #endif // _LIBCPP_HAS_NO_RTTI
1065 };
1066 
1067 #if _LIBCPP_STD_VER >= 17
1068 template<class _Rp, class ..._Ap>
1069 function(_Rp(*)(_Ap...)) -> function<_Rp(_Ap...)>;
1070 
1071 template<class _Fp, class _Stripped = typename __strip_signature<decltype(&_Fp::operator())>::type>
1072 function(_Fp) -> function<_Stripped>;
1073 #endif // _LIBCPP_STD_VER >= 17
1074 
1075 template<class _Rp, class ..._ArgTypes>
1076 function<_Rp(_ArgTypes...)>::function(const function& __f) : __f_(__f.__f_) {}
1077 
1078 #if _LIBCPP_STD_VER <= 14
1079 template<class _Rp, class ..._ArgTypes>
1080 template <class _Alloc>
1081 function<_Rp(_ArgTypes...)>::function(allocator_arg_t, const _Alloc&,
1082                                      const function& __f) : __f_(__f.__f_) {}
1083 #endif
1084 
1085 template <class _Rp, class... _ArgTypes>
1086 function<_Rp(_ArgTypes...)>::function(function&& __f) _NOEXCEPT
1087     : __f_(_VSTD::move(__f.__f_)) {}
1088 
1089 #if _LIBCPP_STD_VER <= 14
1090 template<class _Rp, class ..._ArgTypes>
1091 template <class _Alloc>
1092 function<_Rp(_ArgTypes...)>::function(allocator_arg_t, const _Alloc&,
1093                                       function&& __f)
1094     : __f_(_VSTD::move(__f.__f_)) {}
1095 #endif
1096 
1097 template <class _Rp, class... _ArgTypes>
1098 template <class _Fp, class>
1099 function<_Rp(_ArgTypes...)>::function(_Fp __f) : __f_(_VSTD::move(__f)) {}
1100 
1101 #if _LIBCPP_STD_VER <= 14
1102 template <class _Rp, class... _ArgTypes>
1103 template <class _Fp, class _Alloc, class>
1104 function<_Rp(_ArgTypes...)>::function(allocator_arg_t, const _Alloc& __a,
1105                                       _Fp __f)
1106     : __f_(_VSTD::move(__f), __a) {}
1107 #endif
1108 
1109 template<class _Rp, class ..._ArgTypes>
1110 function<_Rp(_ArgTypes...)>&
1111 function<_Rp(_ArgTypes...)>::operator=(const function& __f)
1112 {
1113     function(__f).swap(*this);
1114     return *this;
1115 }
1116 
1117 template<class _Rp, class ..._ArgTypes>
1118 function<_Rp(_ArgTypes...)>&
1119 function<_Rp(_ArgTypes...)>::operator=(function&& __f) _NOEXCEPT
1120 {
1121     __f_ = _VSTD::move(__f.__f_);
1122     return *this;
1123 }
1124 
1125 template<class _Rp, class ..._ArgTypes>
1126 function<_Rp(_ArgTypes...)>&
1127 function<_Rp(_ArgTypes...)>::operator=(nullptr_t) _NOEXCEPT
1128 {
1129     __f_ = nullptr;
1130     return *this;
1131 }
1132 
1133 template<class _Rp, class ..._ArgTypes>
1134 template <class _Fp, class>
1135 function<_Rp(_ArgTypes...)>&
1136 function<_Rp(_ArgTypes...)>::operator=(_Fp&& __f)
1137 {
1138     function(_VSTD::forward<_Fp>(__f)).swap(*this);
1139     return *this;
1140 }
1141 
1142 template<class _Rp, class ..._ArgTypes>
1143 function<_Rp(_ArgTypes...)>::~function() {}
1144 
1145 template<class _Rp, class ..._ArgTypes>
1146 void
1147 function<_Rp(_ArgTypes...)>::swap(function& __f) _NOEXCEPT
1148 {
1149     __f_.swap(__f.__f_);
1150 }
1151 
1152 template<class _Rp, class ..._ArgTypes>
1153 _Rp
1154 function<_Rp(_ArgTypes...)>::operator()(_ArgTypes... __arg) const
1155 {
1156     return __f_(_VSTD::forward<_ArgTypes>(__arg)...);
1157 }
1158 
1159 #ifndef _LIBCPP_HAS_NO_RTTI
1160 
1161 template<class _Rp, class ..._ArgTypes>
1162 const std::type_info&
1163 function<_Rp(_ArgTypes...)>::target_type() const _NOEXCEPT
1164 {
1165     return __f_.target_type();
1166 }
1167 
1168 template<class _Rp, class ..._ArgTypes>
1169 template <typename _Tp>
1170 _Tp*
1171 function<_Rp(_ArgTypes...)>::target() _NOEXCEPT
1172 {
1173     return (_Tp*)(__f_.template target<_Tp>());
1174 }
1175 
1176 template<class _Rp, class ..._ArgTypes>
1177 template <typename _Tp>
1178 const _Tp*
1179 function<_Rp(_ArgTypes...)>::target() const _NOEXCEPT
1180 {
1181     return __f_.template target<_Tp>();
1182 }
1183 
1184 #endif // _LIBCPP_HAS_NO_RTTI
1185 
1186 template <class _Rp, class... _ArgTypes>
1187 inline _LIBCPP_INLINE_VISIBILITY
1188 bool
1189 operator==(const function<_Rp(_ArgTypes...)>& __f, nullptr_t) _NOEXCEPT {return !__f;}
1190 
1191 template <class _Rp, class... _ArgTypes>
1192 inline _LIBCPP_INLINE_VISIBILITY
1193 bool
1194 operator==(nullptr_t, const function<_Rp(_ArgTypes...)>& __f) _NOEXCEPT {return !__f;}
1195 
1196 template <class _Rp, class... _ArgTypes>
1197 inline _LIBCPP_INLINE_VISIBILITY
1198 bool
1199 operator!=(const function<_Rp(_ArgTypes...)>& __f, nullptr_t) _NOEXCEPT {return (bool)__f;}
1200 
1201 template <class _Rp, class... _ArgTypes>
1202 inline _LIBCPP_INLINE_VISIBILITY
1203 bool
1204 operator!=(nullptr_t, const function<_Rp(_ArgTypes...)>& __f) _NOEXCEPT {return (bool)__f;}
1205 
1206 template <class _Rp, class... _ArgTypes>
1207 inline _LIBCPP_INLINE_VISIBILITY
1208 void
1209 swap(function<_Rp(_ArgTypes...)>& __x, function<_Rp(_ArgTypes...)>& __y) _NOEXCEPT
1210 {return __x.swap(__y);}
1211 
1212 _LIBCPP_END_NAMESPACE_STD
1213 
1214 #endif // _LIBCPP_CXX03_LANG
1215 
1216 #endif // _LIBCPP___FUNCTIONAL_FUNCTION_H
1217