43 #ifndef _GLIBCXX_FUNCTIONAL
44 #define _GLIBCXX_FUNCTIONAL 1
46 #pragma GCC system_header
51 #if __cplusplus >= 201103L
60 namespace std _GLIBCXX_VISIBILITY(default)
62 _GLIBCXX_BEGIN_NAMESPACE_VERSION
64 template<
typename _MemberPo
inter>
66 template<
typename _Tp,
typename _Class>
67 _Mem_fn<_Tp _Class::*>
68 mem_fn(_Tp _Class::*) noexcept;
73 template<
bool _Has_result_type, typename _Functor>
77 template<
typename _Functor>
79 {
typedef typename _Functor::result_type result_type; };
85 template<
typename _Functor>
91 template<
typename _Res,
typename... _ArgTypes>
93 {
typedef _Res result_type; };
95 template<
typename _Res,
typename... _ArgTypes>
97 {
typedef _Res result_type; };
99 template<
typename _Res,
typename... _ArgTypes>
100 struct _Weak_result_type_impl<_Res(_ArgTypes...) const>
101 {
typedef _Res result_type; };
103 template<
typename _Res,
typename... _ArgTypes>
104 struct _Weak_result_type_impl<_Res(_ArgTypes......) const>
105 {
typedef _Res result_type; };
107 template<
typename _Res,
typename... _ArgTypes>
108 struct _Weak_result_type_impl<_Res(_ArgTypes...) volatile>
109 {
typedef _Res result_type; };
111 template<
typename _Res,
typename... _ArgTypes>
112 struct _Weak_result_type_impl<_Res(_ArgTypes......) volatile>
113 {
typedef _Res result_type; };
115 template<
typename _Res,
typename... _ArgTypes>
116 struct _Weak_result_type_impl<_Res(_ArgTypes...) const volatile>
117 {
typedef _Res result_type; };
119 template<
typename _Res,
typename... _ArgTypes>
120 struct _Weak_result_type_impl<_Res(_ArgTypes......) const volatile>
121 {
typedef _Res result_type; };
124 template<
typename _Res,
typename... _ArgTypes>
126 {
typedef _Res result_type; };
128 template<
typename _Res,
typename... _ArgTypes>
130 {
typedef _Res result_type; };
133 template<
typename _Res,
typename... _ArgTypes>
135 {
typedef _Res result_type; };
137 template<
typename _Res,
typename... _ArgTypes>
139 {
typedef _Res result_type; };
142 template<
typename _Res,
typename _Class,
typename... _ArgTypes>
144 {
typedef _Res result_type; };
146 template<
typename _Res,
typename _Class,
typename... _ArgTypes>
148 {
typedef _Res result_type; };
151 template<
typename _Res,
typename _Class,
typename... _ArgTypes>
153 {
typedef _Res result_type; };
155 template<
typename _Res,
typename _Class,
typename... _ArgTypes>
157 {
typedef _Res result_type; };
160 template<
typename _Res,
typename _Class,
typename... _ArgTypes>
162 {
typedef _Res result_type; };
164 template<
typename _Res,
typename _Class,
typename... _ArgTypes>
166 {
typedef _Res result_type; };
169 template<
typename _Res,
typename _Class,
typename... _ArgTypes>
172 {
typedef _Res result_type; };
174 template<
typename _Res,
typename _Class,
typename... _ArgTypes>
177 {
typedef _Res result_type; };
183 template<
typename _Functor>
189 template<
typename _Tp>
193 template<
typename _T1,
typename _Res>
198 static __two __test(...);
201 static const bool value =
sizeof(__test((_Tp*)0)) == 1;
205 template<
typename _Tp>
209 template<
typename _T1,
typename _T2,
typename _Res>
214 static __two __test(...);
217 static const bool value =
sizeof(__test((_Tp*)0)) == 1;
224 template<
typename _Functor,
typename... _Args>
230 typename result_of<_Functor&(_Args&&...)>::type
234 return __f(std::forward<_Args>(__args)...);
237 template<
typename _Functor,
typename... _Args>
240 (is_member_pointer<_Functor>::value
241 && !is_function<_Functor>::value
242 && !is_function<typename remove_pointer<_Functor>::type>::value),
243 typename result_of<_Functor(_Args&&...)>::type
245 __invoke(_Functor& __f, _Args&&... __args)
247 return std::mem_fn(__f)(std::forward<_Args>(__args)...);
251 template<
typename _Functor,
typename... _Args>
254 (is_pointer<_Functor>::value
255 && is_function<typename remove_pointer<_Functor>::type>::value),
256 typename result_of<_Functor(_Args&&...)>::type
258 __invoke(_Functor __f, _Args&&... __args)
260 return __f(std::forward<_Args>(__args)...);
268 template<
bool _Unary,
bool _Binary,
typename _Tp>
272 template<
typename _Tp>
278 template<
typename _Tp>
282 typedef typename _Tp::argument_type argument_type;
286 template<
typename _Tp>
287 struct _Reference_wrapper_base_impl<false, true, _Tp>
288 : _Weak_result_type<_Tp>
290 typedef typename _Tp::first_argument_type first_argument_type;
291 typedef typename _Tp::second_argument_type second_argument_type;
295 template<
typename _Tp>
296 struct _Reference_wrapper_base_impl<true, true, _Tp>
297 : _Weak_result_type<_Tp>
299 typedef typename _Tp::argument_type argument_type;
300 typedef typename _Tp::first_argument_type first_argument_type;
301 typedef typename _Tp::second_argument_type second_argument_type;
314 template<typename _Tp>
317 __has_argument_type<_Tp>::value,
318 __has_first_argument_type<_Tp>::value
319 && __has_second_argument_type<_Tp>::value,
324 template<
typename _Res,
typename _T1>
329 template<
typename _Res,
typename _T1>
330 struct _Reference_wrapper_base<_Res(_T1) const>
331 : unary_function<_T1, _Res>
334 template<
typename _Res,
typename _T1>
335 struct _Reference_wrapper_base<_Res(_T1) volatile>
336 : unary_function<_T1, _Res>
339 template<
typename _Res,
typename _T1>
340 struct _Reference_wrapper_base<_Res(_T1) const volatile>
341 : unary_function<_T1, _Res>
345 template<
typename _Res,
typename _T1,
typename _T2>
346 struct _Reference_wrapper_base<_Res(_T1, _T2)>
347 : binary_function<_T1, _T2, _Res>
350 template<
typename _Res,
typename _T1,
typename _T2>
351 struct _Reference_wrapper_base<_Res(_T1, _T2) const>
352 : binary_function<_T1, _T2, _Res>
355 template<
typename _Res,
typename _T1,
typename _T2>
356 struct _Reference_wrapper_base<_Res(_T1, _T2) volatile>
357 : binary_function<_T1, _T2, _Res>
360 template<
typename _Res,
typename _T1,
typename _T2>
361 struct _Reference_wrapper_base<_Res(_T1, _T2) const volatile>
362 : binary_function<_T1, _T2, _Res>
366 template<
typename _Res,
typename _T1>
367 struct _Reference_wrapper_base<_Res(*)(_T1)>
368 : unary_function<_T1, _Res>
372 template<
typename _Res,
typename _T1,
typename _T2>
373 struct _Reference_wrapper_base<_Res(*)(_T1, _T2)>
374 : binary_function<_T1, _T2, _Res>
378 template<
typename _Res,
typename _T1>
379 struct _Reference_wrapper_base<_Res (_T1::*)()>
380 : unary_function<_T1*, _Res>
384 template<
typename _Res,
typename _T1,
typename _T2>
385 struct _Reference_wrapper_base<_Res (_T1::*)(_T2)>
386 : binary_function<_T1*, _T2, _Res>
390 template<
typename _Res,
typename _T1>
391 struct _Reference_wrapper_base<_Res (_T1::*)() const>
392 : unary_function<const _T1*, _Res>
396 template<
typename _Res,
typename _T1,
typename _T2>
397 struct _Reference_wrapper_base<_Res (_T1::*)(_T2) const>
398 : binary_function<const _T1*, _T2, _Res>
402 template<
typename _Res,
typename _T1>
403 struct _Reference_wrapper_base<_Res (_T1::*)() volatile>
404 : unary_function<volatile _T1*, _Res>
408 template<
typename _Res,
typename _T1,
typename _T2>
409 struct _Reference_wrapper_base<_Res (_T1::*)(_T2) volatile>
410 : binary_function<volatile _T1*, _T2, _Res>
414 template<
typename _Res,
typename _T1>
415 struct _Reference_wrapper_base<_Res (_T1::*)() const volatile>
416 : unary_function<const volatile _T1*, _Res>
420 template<
typename _Res,
typename _T1,
typename _T2>
421 struct _Reference_wrapper_base<_Res (_T1::*)(_T2) const volatile>
422 : binary_function<const volatile _T1*, _T2, _Res>
430 template<
typename _Tp>
446 : _M_data(__inref._M_data)
452 _M_data = __inref._M_data;
456 operator _Tp&()
const noexcept
457 {
return this->
get(); }
463 template<
typename... _Args>
464 typename result_of<_Tp&(_Args&&...)>::type
465 operator()(_Args&&... __args)
const
467 return __invoke(
get(), std::forward<_Args>(__args)...);
473 template<
typename _Tp>
479 template<
typename _Tp>
480 inline reference_wrapper<const _Tp>
484 template<
typename _Tp>
485 void ref(
const _Tp&&) =
delete;
487 template<
typename _Tp>
488 void cref(
const _Tp&&) =
delete;
491 template<
typename _Tp>
492 inline reference_wrapper<_Tp>
494 {
return ref(__t.get()); }
497 template<
typename _Tp>
498 inline reference_wrapper<const _Tp>
500 {
return cref(__t.get()); }
504 template<
typename... _Types>
505 struct _Pack : integral_constant<size_t, sizeof...(_Types)>
508 template<
typename _From,
typename _To,
bool = _From::value == _To::value>
512 template<
typename... _From,
typename... _To>
513 struct _AllConvertible<_Pack<_From...>, _Pack<_To...>, true>
514 : __and_<is_convertible<_From, _To>...>
517 template<
typename _Tp1,
typename _Tp2>
518 using _NotSame = __not_<is_same<typename std::decay<_Tp1>::type,
519 typename std::decay<_Tp2>::type>>;
526 template<
typename _Res,
typename... _ArgTypes>
530 template<
typename _Res,
typename _T1>
535 template<
typename _Res,
typename _T1,
typename _T2>
540 template<
typename _Res,
typename _Class,
typename... _ArgTypes>
541 class _Mem_fn<_Res (_Class::*)(_ArgTypes...)>
544 typedef _Res (_Class::*_Functor)(_ArgTypes...);
546 template<
typename _Tp,
typename... _Args>
548 _M_call(_Tp&& __object,
const volatile _Class *,
549 _Args&&... __args)
const
551 return (std::forward<_Tp>(__object).*__pmf)
552 (std::forward<_Args>(__args)...);
555 template<
typename _Tp,
typename... _Args>
557 _M_call(_Tp&& __ptr,
const volatile void *, _Args&&... __args)
const
558 {
return ((*__ptr).*__pmf)(std::forward<_Args>(__args)...); }
561 template<
typename... _Args>
562 using _RequireValidArgs
563 = _Require<_AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;
567 template<
typename _Tp,
typename... _Args>
568 using _RequireValidArgs2
569 = _Require<_NotSame<_Class, _Tp>, _NotSame<_Class*, _Tp>,
570 _AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;
574 template<
typename _Tp,
typename... _Args>
575 using _RequireValidArgs3
576 = _Require<is_base_of<_Class, _Tp>,
577 _AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;
580 typedef _Res result_type;
582 explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { }
585 template<
typename... _Args,
typename _Req = _RequireValidArgs<_Args...>>
587 operator()(_Class& __object, _Args&&... __args)
const
588 {
return (__object.*__pmf)(std::forward<_Args>(__args)...); }
590 template<
typename... _Args,
typename _Req = _RequireValidArgs<_Args...>>
592 operator()(_Class&& __object, _Args&&... __args)
const
594 return (std::move(__object).*__pmf)(std::forward<_Args>(__args)...);
598 template<
typename... _Args,
typename _Req = _RequireValidArgs<_Args...>>
600 operator()(_Class* __object, _Args&&... __args)
const
601 {
return (__object->*__pmf)(std::forward<_Args>(__args)...); }
604 template<
typename _Tp,
typename... _Args,
605 typename _Req = _RequireValidArgs2<_Tp, _Args...>>
607 operator()(_Tp&& __object, _Args&&... __args)
const
609 return _M_call(std::forward<_Tp>(__object), &__object,
610 std::forward<_Args>(__args)...);
613 template<
typename _Tp,
typename... _Args,
614 typename _Req = _RequireValidArgs3<_Tp, _Args...>>
617 {
return operator()(__ref.get(), std::forward<_Args>(__args)...); }
624 template<
typename _Res,
typename _Class,
typename... _ArgTypes>
625 class _Mem_fn<_Res (_Class::*)(_ArgTypes...) const>
629 typedef _Res (_Class::*_Functor)(_ArgTypes...)
const;
631 template<
typename _Tp,
typename... _Args>
633 _M_call(_Tp&& __object,
const volatile _Class *,
634 _Args&&... __args)
const
636 return (std::forward<_Tp>(__object).*__pmf)
637 (std::forward<_Args>(__args)...);
640 template<
typename _Tp,
typename... _Args>
642 _M_call(_Tp&& __ptr,
const volatile void *, _Args&&... __args)
const
643 {
return ((*__ptr).*__pmf)(std::forward<_Args>(__args)...); }
645 template<
typename... _Args>
646 using _RequireValidArgs
647 = _Require<_AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;
649 template<
typename _Tp,
typename... _Args>
650 using _RequireValidArgs2
651 = _Require<_NotSame<_Class, _Tp>, _NotSame<const _Class*, _Tp>,
652 _AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;
654 template<
typename _Tp,
typename... _Args>
655 using _RequireValidArgs3
656 = _Require<is_base_of<_Class, _Tp>,
657 _AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;
660 typedef _Res result_type;
662 explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { }
665 template<
typename... _Args,
typename _Req = _RequireValidArgs<_Args...>>
667 operator()(
const _Class& __object, _Args&&... __args)
const
668 {
return (__object.*__pmf)(std::forward<_Args>(__args)...); }
670 template<
typename... _Args,
typename _Req = _RequireValidArgs<_Args...>>
672 operator()(
const _Class&& __object, _Args&&... __args)
const
674 return (std::move(__object).*__pmf)(std::forward<_Args>(__args)...);
678 template<
typename... _Args,
typename _Req = _RequireValidArgs<_Args...>>
680 operator()(
const _Class* __object, _Args&&... __args)
const
681 {
return (__object->*__pmf)(std::forward<_Args>(__args)...); }
684 template<
typename _Tp,
typename... _Args,
685 typename _Req = _RequireValidArgs2<_Tp, _Args...>>
686 _Res operator()(_Tp&& __object, _Args&&... __args)
const
688 return _M_call(std::forward<_Tp>(__object), &__object,
689 std::forward<_Args>(__args)...);
692 template<
typename _Tp,
typename... _Args,
693 typename _Req = _RequireValidArgs3<_Tp, _Args...>>
696 {
return operator()(__ref.get(), std::forward<_Args>(__args)...); }
703 template<
typename _Res,
typename _Class,
typename... _ArgTypes>
704 class _Mem_fn<_Res (_Class::*)(_ArgTypes...) volatile>
708 typedef _Res (_Class::*_Functor)(_ArgTypes...)
volatile;
710 template<
typename _Tp,
typename... _Args>
712 _M_call(_Tp&& __object,
const volatile _Class *,
713 _Args&&... __args)
const
715 return (std::forward<_Tp>(__object).*__pmf)
716 (std::forward<_Args>(__args)...);
719 template<
typename _Tp,
typename... _Args>
721 _M_call(_Tp&& __ptr,
const volatile void *, _Args&&... __args)
const
722 {
return ((*__ptr).*__pmf)(std::forward<_Args>(__args)...); }
724 template<
typename... _Args>
725 using _RequireValidArgs
726 = _Require<_AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;
728 template<
typename _Tp,
typename... _Args>
729 using _RequireValidArgs2
730 = _Require<_NotSame<_Class, _Tp>, _NotSame<volatile _Class*, _Tp>,
731 _AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;
733 template<
typename _Tp,
typename... _Args>
734 using _RequireValidArgs3
735 = _Require<is_base_of<_Class, _Tp>,
736 _AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;
739 typedef _Res result_type;
741 explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { }
744 template<
typename... _Args,
typename _Req = _RequireValidArgs<_Args...>>
746 operator()(
volatile _Class& __object, _Args&&... __args)
const
747 {
return (__object.*__pmf)(std::forward<_Args>(__args)...); }
749 template<
typename... _Args,
typename _Req = _RequireValidArgs<_Args...>>
751 operator()(
volatile _Class&& __object, _Args&&... __args)
const
753 return (std::move(__object).*__pmf)(std::forward<_Args>(__args)...);
757 template<
typename... _Args,
typename _Req = _RequireValidArgs<_Args...>>
759 operator()(
volatile _Class* __object, _Args&&... __args)
const
760 {
return (__object->*__pmf)(std::forward<_Args>(__args)...); }
763 template<
typename _Tp,
typename... _Args,
764 typename _Req = _RequireValidArgs2<_Tp, _Args...>>
766 operator()(_Tp&& __object, _Args&&... __args)
const
768 return _M_call(std::forward<_Tp>(__object), &__object,
769 std::forward<_Args>(__args)...);
772 template<
typename _Tp,
typename... _Args,
773 typename _Req = _RequireValidArgs3<_Tp, _Args...>>
776 {
return operator()(__ref.get(), std::forward<_Args>(__args)...); }
783 template<
typename _Res,
typename _Class,
typename... _ArgTypes>
784 class _Mem_fn<_Res (_Class::*)(_ArgTypes...) const volatile>
788 typedef _Res (_Class::*_Functor)(_ArgTypes...)
const volatile;
790 template<
typename _Tp,
typename... _Args>
792 _M_call(_Tp&& __object,
const volatile _Class *,
793 _Args&&... __args)
const
795 return (std::forward<_Tp>(__object).*__pmf)
796 (std::forward<_Args>(__args)...);
799 template<
typename _Tp,
typename... _Args>
801 _M_call(_Tp&& __ptr,
const volatile void *, _Args&&... __args)
const
802 {
return ((*__ptr).*__pmf)(std::forward<_Args>(__args)...); }
804 template<
typename... _Args>
805 using _RequireValidArgs
806 = _Require<_AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;
808 template<
typename _Tp,
typename... _Args>
809 using _RequireValidArgs2
810 = _Require<_NotSame<_Class, _Tp>,
811 _NotSame<const volatile _Class*, _Tp>,
812 _AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;
814 template<
typename _Tp,
typename... _Args>
815 using _RequireValidArgs3
816 = _Require<is_base_of<_Class, _Tp>,
817 _AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;
820 typedef _Res result_type;
822 explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { }
825 template<
typename... _Args,
typename _Req = _RequireValidArgs<_Args...>>
827 operator()(
const volatile _Class& __object, _Args&&... __args)
const
828 {
return (__object.*__pmf)(std::forward<_Args>(__args)...); }
830 template<
typename... _Args,
typename _Req = _RequireValidArgs<_Args...>>
832 operator()(
const volatile _Class&& __object, _Args&&... __args)
const
834 return (std::move(__object).*__pmf)(std::forward<_Args>(__args)...);
838 template<
typename... _Args,
typename _Req = _RequireValidArgs<_Args...>>
840 operator()(
const volatile _Class* __object, _Args&&... __args)
const
841 {
return (__object->*__pmf)(std::forward<_Args>(__args)...); }
844 template<
typename _Tp,
typename... _Args,
845 typename _Req = _RequireValidArgs2<_Tp, _Args...>>
846 _Res operator()(_Tp&& __object, _Args&&... __args)
const
848 return _M_call(std::forward<_Tp>(__object), &__object,
849 std::forward<_Args>(__args)...);
852 template<
typename _Tp,
typename... _Args,
853 typename _Req = _RequireValidArgs3<_Tp, _Args...>>
856 {
return operator()(__ref.get(), std::forward<_Args>(__args)...); }
863 template<
typename _Tp,
bool>
864 struct _Mem_fn_const_or_non
866 typedef const _Tp& type;
869 template<
typename _Tp>
870 struct _Mem_fn_const_or_non<_Tp, false>
875 template<
typename _Res,
typename _Class>
876 class _Mem_fn<_Res _Class::*>
878 using __pm_type = _Res _Class::*;
883 template<
typename _Tp>
885 _M_call(_Tp&& __object,
const _Class *) const noexcept
886 -> decltype(std::
forward<_Tp>(__object).*std::
declval<__pm_type&>())
887 {
return std::forward<_Tp>(__object).*__pm; }
889 template<
typename _Tp,
typename _Up>
891 _M_call(_Tp&& __object, _Up *
const *) const noexcept
892 -> decltype((*std::
forward<_Tp>(__object)).*std::
declval<__pm_type&>())
893 {
return (*std::forward<_Tp>(__object)).*__pm; }
895 template<
typename _Tp>
897 _M_call(_Tp&& __ptr,
const volatile void*) const
898 noexcept(noexcept((*__ptr).*std::
declval<__pm_type&>()))
899 -> decltype((*__ptr).*std::
declval<__pm_type&>())
900 {
return (*__ptr).*__pm; }
904 _Mem_fn(_Res _Class::*__pm) noexcept : __pm(__pm) { }
908 operator()(_Class& __object)
const noexcept
909 {
return __object.*__pm; }
912 operator()(
const _Class& __object)
const noexcept
913 {
return __object.*__pm; }
916 operator()(_Class&& __object) const noexcept
917 {
return std::forward<_Class>(__object).*__pm; }
920 operator()(
const _Class&& __object) const noexcept
921 {
return std::forward<const _Class>(__object).*__pm; }
925 operator()(_Class* __object)
const noexcept
926 {
return __object->*__pm; }
929 operator()(
const _Class* __object)
const noexcept
930 {
return __object->*__pm; }
933 template<
typename _Tp,
typename _Req = _Require<_NotSame<_Class*, _Tp>>>
935 operator()(_Tp&& __unknown) const
936 noexcept(noexcept(std::
declval<_Mem_fn*>()->_M_call
937 (std::
forward<_Tp>(__unknown), &__unknown)))
938 -> decltype(this->_M_call(std::
forward<_Tp>(__unknown), &__unknown))
939 {
return _M_call(std::forward<_Tp>(__unknown), &__unknown); }
941 template<
typename _Tp,
typename _Req = _Require<is_base_of<_Class, _Tp>>>
943 operator()(reference_wrapper<_Tp> __ref)
const
944 noexcept(noexcept(std::declval<_Mem_fn&>()(__ref.get())))
945 -> decltype((*
this)(__ref.get()))
946 {
return (*
this)(__ref.get()); }
959 template<
typename _Tp,
typename _Class>
960 inline _Mem_fn<_Tp _Class::*>
963 return _Mem_fn<_Tp _Class::*>(__pm);
972 template<
typename _Tp>
981 template<
typename _Tp>
991 _GLIBCXX_END_NAMESPACE_VERSION
997 namespace placeholders
999 _GLIBCXX_BEGIN_NAMESPACE_VERSION
1033 _GLIBCXX_END_NAMESPACE_VERSION
1036 _GLIBCXX_BEGIN_NAMESPACE_VERSION
1057 struct _No_tuple_element;
1064 template<std::
size_t __i,
typename _Tuple,
bool _IsSafe>
1073 template<std::
size_t __i,
typename _Tuple>
1076 typedef _No_tuple_element type;
1083 template<std::
size_t __i,
typename _Tuple>
1086 (__i < tuple_size<_Tuple>::value)>
1100 template<typename _Arg,
1101 bool _IsBindExp = is_bind_expression<_Arg>::value,
1102 bool _IsPlaceholder = (is_placeholder<_Arg>::value > 0)>
1109 template<typename _Tp>
1110 class
_Mu<reference_wrapper<_Tp>, false, false>
1113 typedef _Tp& result_type;
1119 template<
typename _CVRef,
typename _Tuple>
1121 operator()(_CVRef& __arg, _Tuple&)
const volatile
1122 {
return __arg.get(); }
1130 template<
typename _Arg>
1134 template<
typename _CVArg,
typename... _Args>
1136 operator()(_CVArg& __arg,
1138 -> decltype(__arg(declval<_Args>()...))
1141 typedef typename _Build_index_tuple<
sizeof...(_Args)>::__type
1143 return this->__call(__arg, __tuple, _Indexes());
1149 template<
typename _CVArg,
typename... _Args, std::size_t... _Indexes>
1152 const _Index_tuple<_Indexes...>&)
const volatile
1153 -> decltype(__arg(declval<_Args>()...))
1155 return __arg(std::forward<_Args>(get<_Indexes>(__tuple))...);
1164 template<
typename _Arg>
1168 template<
typename _Signature>
class result;
1170 template<
typename _CVMu,
typename _CVArg,
typename _Tuple>
1171 class result<_CVMu(_CVArg, _Tuple)>
1181 typedef typename add_rvalue_reference<__base_type>::type type;
1184 template<
typename _Tuple>
1185 typename result<_Mu(_Arg, _Tuple)>::type
1186 operator()(
const volatile _Arg&, _Tuple& __tuple)
const volatile
1188 return std::forward<typename result<_Mu(_Arg, _Tuple)>::type>(
1189 ::std::get<(is_placeholder<_Arg>::value - 1)>(__tuple));
1198 template<
typename _Arg>
1202 template<
typename _Signature>
struct result;
1204 template<
typename _CVMu,
typename _CVArg,
typename _Tuple>
1205 struct result<_CVMu(_CVArg, _Tuple)>
1207 typedef typename add_lvalue_reference<_CVArg>::type type;
1211 template<
typename _CVArg,
typename _Tuple>
1213 operator()(_CVArg&& __arg, _Tuple&)
const volatile
1214 {
return std::forward<_CVArg>(__arg); }
1222 template<
typename _Tp>
1228 __do_wrap(
const _Tp& __x)
1232 __do_wrap(_Tp&& __x)
1233 {
return static_cast<_Tp&&
>(__x); }
1241 template<
typename _Tp,
typename _Class>
1244 typedef _Mem_fn<_Tp _Class::*> type;
1247 __do_wrap(_Tp _Class::* __pm)
1248 {
return type(__pm); }
1262 template<std::size_t _Ind,
typename... _Tp>
1264 __volget(
volatile tuple<_Tp...>& __tuple)
1265 ->
typename tuple_element<_Ind, tuple<_Tp...>>::type
volatile&
1266 {
return std::get<_Ind>(
const_cast<tuple<_Tp...
>&>(__tuple)); }
1269 template<std::size_t _Ind,
typename... _Tp>
1271 __volget(
const volatile tuple<_Tp...>& __tuple)
1272 ->
typename tuple_element<_Ind, tuple<_Tp...>>::type
const volatile&
1273 {
return std::get<_Ind>(
const_cast<const tuple<_Tp...
>&>(__tuple)); }
1276 template<
typename _Signature>
1279 template<
typename _Functor,
typename... _Bound_args>
1280 class _Bind<_Functor(_Bound_args...)>
1283 typedef _Bind __self_type;
1284 typedef typename _Build_index_tuple<
sizeof...(_Bound_args)>::__type
1288 tuple<_Bound_args...> _M_bound_args;
1291 template<
typename _Result,
typename... _Args, std::size_t... _Indexes>
1296 (get<_Indexes>(_M_bound_args), __args)...);
1300 template<
typename _Result,
typename... _Args, std::size_t... _Indexes>
1305 (get<_Indexes>(_M_bound_args), __args)...);
1309 template<
typename _Result,
typename... _Args, std::size_t... _Indexes>
1311 __call_v(tuple<_Args...>&& __args,
1312 _Index_tuple<_Indexes...>)
volatile
1314 return _M_f(_Mu<_Bound_args>()
1315 (__volget<_Indexes>(_M_bound_args), __args)...);
1319 template<
typename _Result,
typename... _Args, std::size_t... _Indexes>
1321 __call_c_v(tuple<_Args...>&& __args,
1322 _Index_tuple<_Indexes...>)
const volatile
1324 return _M_f(_Mu<_Bound_args>()
1325 (__volget<_Indexes>(_M_bound_args), __args)...);
1329 template<
typename... _Args>
1330 explicit _Bind(
const _Functor& __f, _Args&&... __args)
1331 : _M_f(__f), _M_bound_args(std::
forward<_Args>(__args)...)
1334 template<
typename... _Args>
1335 explicit _Bind(_Functor&& __f, _Args&&... __args)
1336 : _M_f(std::move(__f)), _M_bound_args(std::
forward<_Args>(__args)...)
1339 _Bind(
const _Bind&) =
default;
1342 : _M_f(std::move(__b._M_f)), _M_bound_args(std::move(__b._M_bound_args))
1346 template<
typename... _Args,
typename _Result
1347 = decltype( std::declval<_Functor>()(
1348 _Mu<_Bound_args>()( std::declval<_Bound_args&>(),
1351 operator()(_Args&&... __args)
1353 return this->__call<_Result>(
1354 std::forward_as_tuple(std::forward<_Args>(__args)...),
1359 template<
typename... _Args,
typename _Result
1360 = decltype(
std::declval<
typename enable_if<(
sizeof...(_Args) >= 0),
1361 typename add_const<_Functor>::type>::type>()(
1362 _Mu<_Bound_args>()( std::declval<const _Bound_args&>(),
1365 operator()(_Args&&... __args)
const
1367 return this->__call_c<_Result>(
1368 std::forward_as_tuple(std::forward<_Args>(__args)...),
1373 template<
typename... _Args,
typename _Result
1374 = decltype(
std::declval<
typename enable_if<(
sizeof...(_Args) >= 0),
1375 typename add_volatile<_Functor>::type>::type>()(
1376 _Mu<_Bound_args>()( std::declval<volatile _Bound_args&>(),
1379 operator()(_Args&&... __args)
volatile
1381 return this->__call_v<_Result>(
1382 std::forward_as_tuple(std::forward<_Args>(__args)...),
1387 template<
typename... _Args,
typename _Result
1388 = decltype(
std::declval<
typename enable_if<(
sizeof...(_Args) >= 0),
1389 typename add_cv<_Functor>::type>::type>()(
1390 _Mu<_Bound_args>()( std::declval<const volatile _Bound_args&>(),
1393 operator()(_Args&&... __args)
const volatile
1395 return this->__call_c_v<_Result>(
1396 std::forward_as_tuple(std::forward<_Args>(__args)...),
1402 template<
typename _Result,
typename _Signature>
1405 template<
typename _Result,
typename _Functor,
typename... _Bound_args>
1409 typedef typename _Build_index_tuple<
sizeof...(_Bound_args)>::__type
1413 tuple<_Bound_args...> _M_bound_args;
1416 template<
typename _Res>
1417 struct __enable_if_void :
enable_if<is_void<_Res>::value, int> { };
1418 template<
typename _Res>
1419 struct __disable_if_void :
enable_if<!is_void<_Res>::value, int> { };
1422 template<
typename _Res,
typename... _Args, std::size_t... _Indexes>
1424 __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
1425 typename __disable_if_void<_Res>::type = 0)
1427 return _M_f(_Mu<_Bound_args>()
1428 (get<_Indexes>(_M_bound_args), __args)...);
1432 template<
typename _Res,
typename... _Args, std::size_t... _Indexes>
1434 __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
1435 typename __enable_if_void<_Res>::type = 0)
1437 _M_f(_Mu<_Bound_args>()
1438 (get<_Indexes>(_M_bound_args), __args)...);
1442 template<
typename _Res,
typename... _Args, std::size_t... _Indexes>
1444 __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
1445 typename __disable_if_void<_Res>::type = 0)
const
1447 return _M_f(_Mu<_Bound_args>()
1448 (get<_Indexes>(_M_bound_args), __args)...);
1452 template<
typename _Res,
typename... _Args, std::size_t... _Indexes>
1454 __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
1455 typename __enable_if_void<_Res>::type = 0)
const
1457 _M_f(_Mu<_Bound_args>()
1458 (get<_Indexes>(_M_bound_args), __args)...);
1462 template<
typename _Res,
typename... _Args, std::size_t... _Indexes>
1464 __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
1465 typename __disable_if_void<_Res>::type = 0)
volatile
1467 return _M_f(_Mu<_Bound_args>()
1468 (__volget<_Indexes>(_M_bound_args), __args)...);
1472 template<
typename _Res,
typename... _Args, std::size_t... _Indexes>
1474 __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
1475 typename __enable_if_void<_Res>::type = 0)
volatile
1477 _M_f(_Mu<_Bound_args>()
1478 (__volget<_Indexes>(_M_bound_args), __args)...);
1482 template<
typename _Res,
typename... _Args, std::size_t... _Indexes>
1484 __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
1485 typename __disable_if_void<_Res>::type = 0)
const volatile
1487 return _M_f(_Mu<_Bound_args>()
1488 (__volget<_Indexes>(_M_bound_args), __args)...);
1492 template<
typename _Res,
typename... _Args, std::size_t... _Indexes>
1494 __call(tuple<_Args...>&& __args,
1495 _Index_tuple<_Indexes...>,
1496 typename __enable_if_void<_Res>::type = 0)
const volatile
1498 _M_f(_Mu<_Bound_args>()
1499 (__volget<_Indexes>(_M_bound_args), __args)...);
1503 typedef _Result result_type;
1505 template<
typename... _Args>
1506 explicit _Bind_result(
const _Functor& __f, _Args&&... __args)
1507 : _M_f(__f), _M_bound_args(std::
forward<_Args>(__args)...)
1510 template<
typename... _Args>
1511 explicit _Bind_result(_Functor&& __f, _Args&&... __args)
1512 : _M_f(std::move(__f)), _M_bound_args(std::
forward<_Args>(__args)...)
1515 _Bind_result(
const _Bind_result&) =
default;
1517 _Bind_result(_Bind_result&& __b)
1518 : _M_f(std::move(__b._M_f)), _M_bound_args(std::move(__b._M_bound_args))
1522 template<
typename... _Args>
1524 operator()(_Args&&... __args)
1526 return this->__call<_Result>(
1527 std::forward_as_tuple(std::forward<_Args>(__args)...),
1532 template<
typename... _Args>
1534 operator()(_Args&&... __args)
const
1536 return this->__call<_Result>(
1537 std::forward_as_tuple(std::forward<_Args>(__args)...),
1542 template<
typename... _Args>
1544 operator()(_Args&&... __args)
volatile
1546 return this->__call<_Result>(
1547 std::forward_as_tuple(std::forward<_Args>(__args)...),
1552 template<
typename... _Args>
1554 operator()(_Args&&... __args)
const volatile
1556 return this->__call<_Result>(
1557 std::forward_as_tuple(std::forward<_Args>(__args)...),
1566 template<
typename _Signature>
1574 template<
typename _Signature>
1582 template<
typename _Signature>
1590 template<
typename _Signature>
1598 template<
typename _Result,
typename _Signature>
1606 template<
typename _Result,
typename _Signature>
1614 template<
typename _Result,
typename _Signature>
1622 template<
typename _Result,
typename _Signature>
1629 template<typename _Tp, typename _Tp2 = typename decay<_Tp>::type>
1630 using __is_socketlike = __or_<is_integral<_Tp2>,
is_enum<_Tp2>>;
1632 template<
bool _SocketLike,
typename _Func,
typename... _BoundArgs>
1637 typedef typename __maybe_type::type __func_type;
1644 template<
typename _Func,
typename... _BoundArgs>
1645 struct _Bind_helper<true, _Func, _BoundArgs...>
1652 template<
typename _Func,
typename... _BoundArgs>
1654 _Bind_helper<__is_socketlike<_Func>::value, _Func, _BoundArgs...>::type
1655 bind(_Func&& __f, _BoundArgs&&... __args)
1657 typedef _Bind_helper<
false, _Func, _BoundArgs...> __helper_type;
1658 typedef typename __helper_type::__maybe_type __maybe_type;
1659 typedef typename __helper_type::type __result_type;
1660 return __result_type(__maybe_type::__do_wrap(std::forward<_Func>(__f)),
1661 std::forward<_BoundArgs>(__args)...);
1664 template<
typename _Result,
typename _Func,
typename... _BoundArgs>
1665 struct _Bindres_helper
1667 typedef _Maybe_wrap_member_pointer<typename decay<_Func>::type>
1669 typedef typename __maybe_type::type __functor_type;
1670 typedef _Bind_result<_Result,
1671 __functor_type(
typename decay<_BoundArgs>::type...)>
1679 template<
typename _Result,
typename _Func,
typename... _BoundArgs>
1681 typename _Bindres_helper<_Result, _Func, _BoundArgs...>::type
1682 bind(_Func&& __f, _BoundArgs&&... __args)
1684 typedef _Bindres_helper<_Result, _Func, _BoundArgs...> __helper_type;
1685 typedef typename __helper_type::__maybe_type __maybe_type;
1686 typedef typename __helper_type::type __result_type;
1687 return __result_type(__maybe_type::__do_wrap(std::forward<_Func>(__f)),
1688 std::forward<_BoundArgs>(__args)...);
1691 template<
typename _Signature>
1692 struct _Bind_simple;
1694 template<
typename _Callable,
typename... _Args>
1695 struct _Bind_simple<_Callable(_Args...)>
1697 typedef typename result_of<_Callable(_Args...)>::type result_type;
1699 template<
typename... _Args2,
typename =
typename
1700 enable_if<
sizeof...(_Args) ==
sizeof...(_Args2)>::type>
1702 _Bind_simple(
const _Callable& __callable, _Args2&&... __args)
1703 : _M_bound(__callable, std::
forward<_Args2>(__args)...)
1706 template<
typename... _Args2,
typename =
typename
1707 enable_if<
sizeof...(_Args) ==
sizeof...(_Args2)>::type>
1709 _Bind_simple(_Callable&& __callable, _Args2&&... __args)
1710 : _M_bound(std::move(__callable), std::
forward<_Args2>(__args)...)
1713 _Bind_simple(
const _Bind_simple&) =
default;
1714 _Bind_simple(_Bind_simple&&) =
default;
1719 typedef typename _Build_index_tuple<
sizeof...(_Args)>::__type _Indices;
1720 return _M_invoke(_Indices());
1725 template<std::size_t... _Indices>
1726 typename result_of<_Callable(_Args...)>::type
1727 _M_invoke(_Index_tuple<_Indices...>)
1731 return std::forward<_Callable>(std::get<0>(_M_bound))(
1732 std::forward<_Args>(std::get<_Indices+1>(_M_bound))...);
1738 template<
typename _Func,
typename... _BoundArgs>
1739 struct _Bind_simple_helper
1741 typedef _Maybe_wrap_member_pointer<typename decay<_Func>::type>
1743 typedef typename __maybe_type::type __func_type;
1744 typedef _Bind_simple<__func_type(typename decay<_BoundArgs>::type...)>
1750 template<
typename _Callable,
typename... _Args>
1751 typename _Bind_simple_helper<_Callable, _Args...>::__type
1752 __bind_simple(_Callable&& __callable, _Args&&... __args)
1754 typedef _Bind_simple_helper<_Callable, _Args...> __helper_type;
1755 typedef typename __helper_type::__maybe_type __maybe_type;
1756 typedef typename __helper_type::__type __result_type;
1757 return __result_type(
1758 __maybe_type::__do_wrap( std::forward<_Callable>(__callable)),
1759 std::forward<_Args>(__args)...);
1772 const char*
what()
const noexcept;
1780 template<
typename _Tp>
1783 || is_member_pointer<_Tp>::value)>
1786 class _Undefined_class;
1791 const void* _M_const_object;
1792 void (*_M_function_pointer)();
1793 void (_Undefined_class::*_M_member_pointer)();
1798 void* _M_access() {
return &_M_pod_data[0]; }
1799 const void* _M_access()
const {
return &_M_pod_data[0]; }
1801 template<
typename _Tp>
1804 {
return *
static_cast<_Tp*
>(_M_access()); }
1806 template<
typename _Tp>
1809 {
return *
static_cast<const _Tp*
>(_M_access()); }
1811 _Nocopy_types _M_unused;
1812 char _M_pod_data[
sizeof(_Nocopy_types)];
1815 enum _Manager_operation
1825 template<
typename _Tp>
1826 struct _Simple_type_wrapper
1828 _Simple_type_wrapper(_Tp __value) : __value(__value) { }
1833 template<
typename _Tp>
1834 struct __is_location_invariant<_Simple_type_wrapper<_Tp> >
1835 : __is_location_invariant<_Tp>
1840 template<
typename _Functor>
1842 __callable_functor(_Functor& __f)
1845 template<
typename _Member,
typename _Class>
1846 inline _Mem_fn<_Member _Class::*>
1847 __callable_functor(_Member _Class::* &__p)
1850 template<
typename _Member,
typename _Class>
1851 inline _Mem_fn<_Member _Class::*>
1852 __callable_functor(_Member _Class::*
const &__p)
1855 template<
typename _Member,
typename _Class>
1856 inline _Mem_fn<_Member _Class::*>
1857 __callable_functor(_Member _Class::*
volatile &__p)
1860 template<
typename _Member,
typename _Class>
1861 inline _Mem_fn<_Member _Class::*>
1862 __callable_functor(_Member _Class::*
const volatile &__p)
1865 template<
typename _Signature>
1872 static const std::size_t _M_max_size =
sizeof(_Nocopy_types);
1873 static const std::size_t _M_max_align = __alignof__(_Nocopy_types);
1875 template<
typename _Functor>
1879 static const bool __stored_locally =
1881 &&
sizeof(_Functor) <= _M_max_size
1882 && __alignof__(_Functor) <= _M_max_align
1883 && (_M_max_align % __alignof__(_Functor) == 0));
1889 _M_get_pointer(
const _Any_data& __source)
1891 const _Functor* __ptr =
1893 : __source._M_access<_Functor*>();
1894 return const_cast<_Functor*
>(__ptr);
1900 _M_clone(_Any_data& __dest,
const _Any_data& __source,
true_type)
1902 new (__dest._M_access()) _Functor(__source._M_access<_Functor>());
1908 _M_clone(_Any_data& __dest,
const _Any_data& __source,
false_type)
1910 __dest._M_access<_Functor*>() =
1911 new _Functor(*__source._M_access<_Functor*>());
1917 _M_destroy(_Any_data& __victim,
true_type)
1919 __victim._M_access<_Functor>().~_Functor();
1926 delete __victim._M_access<_Functor*>();
1931 _M_manager(_Any_data& __dest,
const _Any_data& __source,
1932 _Manager_operation __op)
1937 case __get_type_info:
1938 __dest._M_access<
const type_info*>() = &
typeid(_Functor);
1941 case __get_functor_ptr:
1942 __dest._M_access<_Functor*>() = _M_get_pointer(__source);
1945 case __clone_functor:
1946 _M_clone(__dest, __source, _Local_storage());
1949 case __destroy_functor:
1950 _M_destroy(__dest, _Local_storage());
1957 _M_init_functor(_Any_data& __functor, _Functor&& __f)
1958 { _M_init_functor(__functor, std::move(__f), _Local_storage()); }
1960 template<
typename _Signature>
1962 _M_not_empty_function(
const function<_Signature>& __f)
1963 {
return static_cast<bool>(__f); }
1965 template<
typename _Tp>
1967 _M_not_empty_function(
const _Tp*& __fp)
1970 template<
typename _Class,
typename _Tp>
1972 _M_not_empty_function(_Tp _Class::*
const& __mp)
1975 template<
typename _Tp>
1977 _M_not_empty_function(
const _Tp&)
1982 _M_init_functor(_Any_data& __functor, _Functor&& __f,
true_type)
1983 {
new (__functor._M_access()) _Functor(std::move(__f)); }
1986 _M_init_functor(_Any_data& __functor, _Functor&& __f,
false_type)
1987 { __functor._M_access<_Functor*>() =
new _Functor(std::move(__f)); }
1990 template<
typename _Functor>
1991 class _Ref_manager :
public _Base_manager<_Functor*>
1993 typedef _Function_base::_Base_manager<_Functor*> _Base;
1997 _M_manager(_Any_data& __dest,
const _Any_data& __source,
1998 _Manager_operation __op)
2003 case __get_type_info:
2004 __dest._M_access<
const type_info*>() = &
typeid(_Functor);
2007 case __get_functor_ptr:
2008 __dest._M_access<_Functor*>() = *_Base::_M_get_pointer(__source);
2013 _Base::_M_manager(__dest, __source, __op);
2030 _M_manager(_M_functor, _M_functor, __destroy_functor);
2034 bool _M_empty()
const {
return !_M_manager; }
2036 typedef bool (*_Manager_type)(_Any_data&,
const _Any_data&,
2037 _Manager_operation);
2039 _Any_data _M_functor;
2040 _Manager_type _M_manager;
2043 template<
typename _Signature,
typename _Functor>
2044 class _Function_handler;
2046 template<
typename _Res,
typename _Functor,
typename... _ArgTypes>
2047 class _Function_handler<_Res(_ArgTypes...), _Functor>
2048 :
public _Function_base::_Base_manager<_Functor>
2050 typedef _Function_base::_Base_manager<_Functor> _Base;
2054 _M_invoke(
const _Any_data& __functor, _ArgTypes... __args)
2056 return (*_Base::_M_get_pointer(__functor))(
2057 std::forward<_ArgTypes>(__args)...);
2061 template<
typename _Functor,
typename... _ArgTypes>
2062 class _Function_handler<void(_ArgTypes...), _Functor>
2063 :
public _Function_base::_Base_manager<_Functor>
2065 typedef _Function_base::_Base_manager<_Functor> _Base;
2069 _M_invoke(
const _Any_data& __functor, _ArgTypes... __args)
2071 (*_Base::_M_get_pointer(__functor))(
2072 std::forward<_ArgTypes>(__args)...);
2076 template<
typename _Res,
typename _Functor,
typename... _ArgTypes>
2077 class _Function_handler<_Res(_ArgTypes...), reference_wrapper<_Functor> >
2078 :
public _Function_base::_Ref_manager<_Functor>
2080 typedef _Function_base::_Ref_manager<_Functor> _Base;
2084 _M_invoke(
const _Any_data& __functor, _ArgTypes... __args)
2086 return __callable_functor(**_Base::_M_get_pointer(__functor))(
2087 std::forward<_ArgTypes>(__args)...);
2091 template<
typename _Functor,
typename... _ArgTypes>
2092 class _Function_handler<void(_ArgTypes...), reference_wrapper<_Functor> >
2093 :
public _Function_base::_Ref_manager<_Functor>
2095 typedef _Function_base::_Ref_manager<_Functor> _Base;
2099 _M_invoke(
const _Any_data& __functor, _ArgTypes... __args)
2101 __callable_functor(**_Base::_M_get_pointer(__functor))(
2102 std::forward<_ArgTypes>(__args)...);
2106 template<
typename _Class,
typename _Member,
typename _Res,
2107 typename... _ArgTypes>
2108 class _Function_handler<_Res(_ArgTypes...), _Member _Class::*>
2109 :
public _Function_handler<void(_ArgTypes...), _Member _Class::*>
2111 typedef _Function_handler<void(_ArgTypes...), _Member _Class::*>
2116 _M_invoke(
const _Any_data& __functor, _ArgTypes... __args)
2118 return std::mem_fn(_Base::_M_get_pointer(__functor)->__value)(
2119 std::forward<_ArgTypes>(__args)...);
2123 template<
typename _Class,
typename _Member,
typename... _ArgTypes>
2124 class _Function_handler<void(_ArgTypes...), _Member _Class::*>
2125 :
public _Function_base::_Base_manager<
2126 _Simple_type_wrapper< _Member _Class::* > >
2128 typedef _Member _Class::* _Functor;
2129 typedef _Simple_type_wrapper<_Functor> _Wrapper;
2130 typedef _Function_base::_Base_manager<_Wrapper> _Base;
2134 _M_manager(_Any_data& __dest,
const _Any_data& __source,
2135 _Manager_operation __op)
2140 case __get_type_info:
2141 __dest._M_access<
const type_info*>() = &
typeid(_Functor);
2144 case __get_functor_ptr:
2145 __dest._M_access<_Functor*>() =
2146 &_Base::_M_get_pointer(__source)->__value;
2150 _Base::_M_manager(__dest, __source, __op);
2156 _M_invoke(
const _Any_data& __functor, _ArgTypes... __args)
2158 std::mem_fn(_Base::_M_get_pointer(__functor)->__value)(
2159 std::forward<_ArgTypes>(__args)...);
2169 template<
typename _Res,
typename... _ArgTypes>
2170 class function<_Res(_ArgTypes...)>
2174 typedef _Res _Signature_type(_ArgTypes...);
2176 template<
typename _Functor>
2177 using _Invoke = decltype(__callable_functor(std::declval<_Functor&>())
2178 (std::declval<_ArgTypes>()...) );
2180 template<
typename _CallRes,
typename _Res1>
2184 template<
typename _CallRes>
2185 struct _CheckResult<_CallRes, void>
2188 template<
typename _Functor>
2189 using _Callable = _CheckResult<_Invoke<_Functor>, _Res>;
2191 template<
typename _Cond,
typename _Tp>
2195 typedef _Res result_type;
2210 function(nullptr_t) noexcept
2221 function(
const function& __x);
2253 template<
typename _Functor,
2254 typename = _Requires<_Callable<_Functor>,
void>>
2270 operator=(
const function& __x)
2272 function(__x).swap(*
this);
2288 operator=(
function&& __x)
2290 function(std::move(__x)).swap(*
this);
2302 operator=(nullptr_t)
2306 _M_manager(_M_functor, _M_functor, __destroy_functor);
2329 template<
typename _Functor>
2330 _Requires<_Callable<_Functor>,
function&>
2331 operator=(_Functor&& __f)
2333 function(std::forward<_Functor>(__f)).swap(*
this);
2338 template<
typename _Functor>
2342 function(__f).swap(*
this);
2355 void swap(
function& __x)
2357 std::swap(_M_functor, __x._M_functor);
2358 std::swap(_M_manager, __x._M_manager);
2359 std::swap(_M_invoker, __x._M_invoker);
2383 explicit operator bool() const noexcept
2384 {
return !_M_empty(); }
2396 _Res operator()(_ArgTypes... __args)
const;
2409 const type_info& target_type() const noexcept;
2420 template<typename _Functor> _Functor* target() noexcept;
2423 template<typename _Functor> const _Functor* target() const noexcept;
2427 typedef _Res (*_Invoker_type)(
const _Any_data&, _ArgTypes...);
2428 _Invoker_type _M_invoker;
2432 template<
typename _Res,
typename... _ArgTypes>
2433 function<_Res(_ArgTypes...)>::
2434 function(
const function& __x)
2437 if (static_cast<bool>(__x))
2439 _M_invoker = __x._M_invoker;
2440 _M_manager = __x._M_manager;
2441 __x._M_manager(_M_functor, __x._M_functor, __clone_functor);
2445 template<
typename _Res,
typename... _ArgTypes>
2446 template<
typename _Functor,
typename>
2447 function<_Res(_ArgTypes...)>::
2448 function(_Functor __f)
2451 typedef _Function_handler<_Signature_type, _Functor> _My_handler;
2453 if (_My_handler::_M_not_empty_function(__f))
2455 _My_handler::_M_init_functor(_M_functor, std::move(__f));
2456 _M_invoker = &_My_handler::_M_invoke;
2457 _M_manager = &_My_handler::_M_manager;
2461 template<
typename _Res,
typename... _ArgTypes>
2463 function<_Res(_ArgTypes...)>::
2464 operator()(_ArgTypes... __args)
const
2467 __throw_bad_function_call();
2468 return _M_invoker(_M_functor, std::forward<_ArgTypes>(__args)...);
2472 template<
typename _Res,
typename... _ArgTypes>
2474 function<_Res(_ArgTypes...)>::
2475 target_type() const noexcept
2479 _Any_data __typeinfo_result;
2480 _M_manager(__typeinfo_result, _M_functor, __get_type_info);
2481 return *__typeinfo_result._M_access<
const type_info*>();
2484 return typeid(void);
2487 template<
typename _Res,
typename... _ArgTypes>
2488 template<
typename _Functor>
2490 function<_Res(_ArgTypes...)>::
2493 if (
typeid(_Functor) == target_type() && _M_manager)
2496 if (_M_manager(__ptr, _M_functor, __get_functor_ptr)
2500 return __ptr._M_access<_Functor*>();
2506 template<
typename _Res,
typename... _ArgTypes>
2507 template<
typename _Functor>
2509 function<_Res(_ArgTypes...)>::
2510 target() const noexcept
2512 if (
typeid(_Functor) == target_type() && _M_manager)
2515 _M_manager(__ptr, _M_functor, __get_functor_ptr);
2516 return __ptr._M_access<
const _Functor*>();
2532 template<
typename _Res,
typename... _Args>
2534 operator==(
const function<_Res(_Args...)>& __f, nullptr_t) noexcept
2535 {
return !
static_cast<bool>(__f); }
2538 template<
typename _Res,
typename... _Args>
2540 operator==(nullptr_t,
const function<_Res(_Args...)>& __f) noexcept
2541 {
return !
static_cast<bool>(__f); }
2550 template<
typename _Res,
typename... _Args>
2552 operator!=(
const function<_Res(_Args...)>& __f, nullptr_t) noexcept
2553 {
return static_cast<bool>(__f); }
2556 template<
typename _Res,
typename... _Args>
2558 operator!=(nullptr_t,
const function<_Res(_Args...)>& __f) noexcept
2559 {
return static_cast<bool>(__f); }
2568 template<
typename _Res,
typename... _Args>
2570 swap(
function<_Res(_Args...)>& __x,
function<_Res(_Args...)>& __y)
2573 _GLIBCXX_END_NAMESPACE_VERSION
2578 #endif // _GLIBCXX_FUNCTIONAL