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;
71 template<typename _Functor, typename = __void_t<>>
75 template<
typename _Functor>
77 __void_t<typename _Functor::result_type>>
78 {
typedef typename _Functor::result_type result_type; };
84 template<
typename _Functor>
90 template<
typename _Res,
typename... _ArgTypes>
92 {
typedef _Res result_type; };
94 template<
typename _Res,
typename... _ArgTypes>
96 {
typedef _Res result_type; };
98 template<
typename _Res,
typename... _ArgTypes>
99 struct _Weak_result_type_impl<_Res(_ArgTypes...) const>
100 {
typedef _Res result_type; };
102 template<
typename _Res,
typename... _ArgTypes>
103 struct _Weak_result_type_impl<_Res(_ArgTypes......) const>
104 {
typedef _Res result_type; };
106 template<
typename _Res,
typename... _ArgTypes>
107 struct _Weak_result_type_impl<_Res(_ArgTypes...) volatile>
108 {
typedef _Res result_type; };
110 template<
typename _Res,
typename... _ArgTypes>
111 struct _Weak_result_type_impl<_Res(_ArgTypes......) volatile>
112 {
typedef _Res result_type; };
114 template<
typename _Res,
typename... _ArgTypes>
115 struct _Weak_result_type_impl<_Res(_ArgTypes...) const volatile>
116 {
typedef _Res result_type; };
118 template<
typename _Res,
typename... _ArgTypes>
119 struct _Weak_result_type_impl<_Res(_ArgTypes......) const volatile>
120 {
typedef _Res result_type; };
123 template<
typename _Res,
typename... _ArgTypes>
125 {
typedef _Res result_type; };
127 template<
typename _Res,
typename... _ArgTypes>
129 {
typedef _Res result_type; };
132 template<
typename _Res,
typename... _ArgTypes>
134 {
typedef _Res result_type; };
136 template<
typename _Res,
typename... _ArgTypes>
138 {
typedef _Res result_type; };
141 template<
typename _Res,
typename _Class,
typename... _ArgTypes>
143 {
typedef _Res result_type; };
145 template<
typename _Res,
typename _Class,
typename... _ArgTypes>
147 {
typedef _Res result_type; };
150 template<
typename _Res,
typename _Class,
typename... _ArgTypes>
152 {
typedef _Res result_type; };
154 template<
typename _Res,
typename _Class,
typename... _ArgTypes>
156 {
typedef _Res result_type; };
159 template<
typename _Res,
typename _Class,
typename... _ArgTypes>
161 {
typedef _Res result_type; };
163 template<
typename _Res,
typename _Class,
typename... _ArgTypes>
165 {
typedef _Res result_type; };
168 template<
typename _Res,
typename _Class,
typename... _ArgTypes>
171 {
typedef _Res result_type; };
173 template<
typename _Res,
typename _Class,
typename... _ArgTypes>
176 {
typedef _Res result_type; };
182 template<
typename _Functor>
191 template<
typename _Functor,
typename... _Args>
197 typename result_of<_Functor&(_Args&&...)>::type
201 return __f(std::forward<_Args>(__args)...);
204 template<
typename _Functor,
typename... _Args>
207 (is_member_pointer<_Functor>::value
208 && !is_function<_Functor>::value
209 && !is_function<typename remove_pointer<_Functor>::type>::value),
210 typename result_of<_Functor(_Args&&...)>::type
212 __invoke(_Functor& __f, _Args&&... __args)
214 return std::mem_fn(__f)(std::forward<_Args>(__args)...);
218 template<
typename _Functor,
typename... _Args>
221 (is_pointer<_Functor>::value
222 && is_function<typename remove_pointer<_Functor>::type>::value),
223 typename result_of<_Functor(_Args&&...)>::type
225 __invoke(_Functor __f, _Args&&... __args)
227 return __f(std::forward<_Args>(__args)...);
235 template<
bool _Unary,
bool _Binary,
typename _Tp>
239 template<
typename _Tp>
245 template<
typename _Tp>
249 typedef typename _Tp::argument_type argument_type;
253 template<
typename _Tp>
254 struct _Reference_wrapper_base_impl<false, true, _Tp>
255 : _Weak_result_type<_Tp>
257 typedef typename _Tp::first_argument_type first_argument_type;
258 typedef typename _Tp::second_argument_type second_argument_type;
262 template<
typename _Tp>
263 struct _Reference_wrapper_base_impl<true, true, _Tp>
264 : _Weak_result_type<_Tp>
266 typedef typename _Tp::argument_type argument_type;
267 typedef typename _Tp::first_argument_type first_argument_type;
268 typedef typename _Tp::second_argument_type second_argument_type;
271 _GLIBCXX_HAS_NESTED_TYPE(argument_type)
272 _GLIBCXX_HAS_NESTED_TYPE(first_argument_type)
273 _GLIBCXX_HAS_NESTED_TYPE(second_argument_type)
281 template<typename _Tp>
284 __has_argument_type<_Tp>::value,
285 __has_first_argument_type<_Tp>::value
286 && __has_second_argument_type<_Tp>::value,
291 template<
typename _Res,
typename _T1>
296 template<
typename _Res,
typename _T1>
297 struct _Reference_wrapper_base<_Res(_T1) const>
298 : unary_function<_T1, _Res>
301 template<
typename _Res,
typename _T1>
302 struct _Reference_wrapper_base<_Res(_T1) volatile>
303 : unary_function<_T1, _Res>
306 template<
typename _Res,
typename _T1>
307 struct _Reference_wrapper_base<_Res(_T1) const volatile>
308 : unary_function<_T1, _Res>
312 template<
typename _Res,
typename _T1,
typename _T2>
313 struct _Reference_wrapper_base<_Res(_T1, _T2)>
314 : binary_function<_T1, _T2, _Res>
317 template<
typename _Res,
typename _T1,
typename _T2>
318 struct _Reference_wrapper_base<_Res(_T1, _T2) const>
319 : binary_function<_T1, _T2, _Res>
322 template<
typename _Res,
typename _T1,
typename _T2>
323 struct _Reference_wrapper_base<_Res(_T1, _T2) volatile>
324 : binary_function<_T1, _T2, _Res>
327 template<
typename _Res,
typename _T1,
typename _T2>
328 struct _Reference_wrapper_base<_Res(_T1, _T2) const volatile>
329 : binary_function<_T1, _T2, _Res>
333 template<
typename _Res,
typename _T1>
334 struct _Reference_wrapper_base<_Res(*)(_T1)>
335 : unary_function<_T1, _Res>
339 template<
typename _Res,
typename _T1,
typename _T2>
340 struct _Reference_wrapper_base<_Res(*)(_T1, _T2)>
341 : binary_function<_T1, _T2, _Res>
345 template<
typename _Res,
typename _T1>
346 struct _Reference_wrapper_base<_Res (_T1::*)()>
347 : unary_function<_T1*, _Res>
351 template<
typename _Res,
typename _T1,
typename _T2>
352 struct _Reference_wrapper_base<_Res (_T1::*)(_T2)>
353 : binary_function<_T1*, _T2, _Res>
357 template<
typename _Res,
typename _T1>
358 struct _Reference_wrapper_base<_Res (_T1::*)() const>
359 : unary_function<const _T1*, _Res>
363 template<
typename _Res,
typename _T1,
typename _T2>
364 struct _Reference_wrapper_base<_Res (_T1::*)(_T2) const>
365 : binary_function<const _T1*, _T2, _Res>
369 template<
typename _Res,
typename _T1>
370 struct _Reference_wrapper_base<_Res (_T1::*)() volatile>
371 : unary_function<volatile _T1*, _Res>
375 template<
typename _Res,
typename _T1,
typename _T2>
376 struct _Reference_wrapper_base<_Res (_T1::*)(_T2) volatile>
377 : binary_function<volatile _T1*, _T2, _Res>
381 template<
typename _Res,
typename _T1>
382 struct _Reference_wrapper_base<_Res (_T1::*)() const volatile>
383 : unary_function<const volatile _T1*, _Res>
387 template<
typename _Res,
typename _T1,
typename _T2>
388 struct _Reference_wrapper_base<_Res (_T1::*)(_T2) const volatile>
389 : binary_function<const volatile _T1*, _T2, _Res>
397 template<
typename _Tp>
417 operator _Tp&()
const noexcept
418 {
return this->
get(); }
424 template<
typename... _Args>
425 typename result_of<_Tp&(_Args&&...)>::type
426 operator()(_Args&&... __args)
const
428 return __invoke(
get(), std::forward<_Args>(__args)...);
434 template<
typename _Tp>
440 template<
typename _Tp>
441 inline reference_wrapper<const _Tp>
445 template<
typename _Tp>
446 void ref(
const _Tp&&) =
delete;
448 template<
typename _Tp>
449 void cref(
const _Tp&&) =
delete;
452 template<
typename _Tp>
453 inline reference_wrapper<_Tp>
455 {
return ref(__t.get()); }
458 template<
typename _Tp>
459 inline reference_wrapper<const _Tp>
461 {
return cref(__t.get()); }
465 template<
typename... _Types>
466 struct _Pack : integral_constant<size_t, sizeof...(_Types)>
469 template<
typename _From,
typename _To,
bool = _From::value == _To::value>
473 template<
typename... _From,
typename... _To>
474 struct _AllConvertible<_Pack<_From...>, _Pack<_To...>, true>
475 : __and_<is_convertible<_From, _To>...>
478 template<
typename _Tp1,
typename _Tp2>
479 using _NotSame = __not_<is_same<typename std::decay<_Tp1>::type,
480 typename std::decay<_Tp2>::type>>;
487 template<
typename _Res,
typename... _ArgTypes>
491 template<
typename _Res,
typename _T1>
496 template<
typename _Res,
typename _T1,
typename _T2>
500 template<
typename _Signature>
501 struct _Mem_fn_traits;
503 template<
typename _Res,
typename _Class,
typename... _ArgTypes>
504 struct _Mem_fn_traits_base
506 using __result_type = _Res;
507 using __class_type = _Class;
508 using __arg_types = _Pack<_ArgTypes...>;
514 #define _GLIBCXX_MEM_FN_TRAITS2(_CV, _REF, _LVAL, _RVAL) \
515 template<typename _Res, typename _Class, typename... _ArgTypes> \
516 struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) _CV _REF> \
517 : _Mem_fn_traits_base<_Res, _CV _Class, _ArgTypes...> \
519 using __pmf_type = _Res (_Class::*)(_ArgTypes...) _CV _REF; \
520 using __lvalue = _LVAL; \
521 using __rvalue = _RVAL; \
522 using __vararg = false_type; \
524 template<typename _Res, typename _Class, typename... _ArgTypes> \
525 struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) _CV _REF> \
526 : _Mem_fn_traits_base<_Res, _CV _Class, _ArgTypes...> \
528 using __pmf_type = _Res (_Class::*)(_ArgTypes... ...) _CV _REF; \
529 using __lvalue = _LVAL; \
530 using __rvalue = _RVAL; \
531 using __vararg = true_type; \
534 #define _GLIBCXX_MEM_FN_TRAITS(_REF, _LVAL, _RVAL) \
535 _GLIBCXX_MEM_FN_TRAITS2( , _REF, _LVAL, _RVAL) \
536 _GLIBCXX_MEM_FN_TRAITS2(const , _REF, _LVAL, _RVAL) \
537 _GLIBCXX_MEM_FN_TRAITS2(volatile , _REF, _LVAL, _RVAL) \
538 _GLIBCXX_MEM_FN_TRAITS2(const volatile, _REF, _LVAL, _RVAL)
542 _GLIBCXX_MEM_FN_TRAITS(&&,
false_type, true_type)
544 #undef _GLIBCXX_MEM_FN_TRAITS
545 #undef _GLIBCXX_MEM_FN_TRAITS2
547 template<
typename _MemFunPtr,
548 bool __is_mem_fn = is_member_function_pointer<_MemFunPtr>::value>
550 :
public _Mem_fn_traits<_MemFunPtr>::__maybe_type
552 using _Traits = _Mem_fn_traits<_MemFunPtr>;
554 using _Class =
typename _Traits::__class_type;
555 using _ArgTypes =
typename _Traits::__arg_types;
556 using _Pmf =
typename _Traits::__pmf_type;
558 using _Arity =
typename _Traits::__arity;
559 using _Varargs =
typename _Traits::__vararg;
561 template<
typename _Func,
typename... _BoundArgs>
562 friend struct _Bind_check_arity;
566 template<
typename _Args>
567 using _CheckArgs =
typename conditional<_Varargs::value,
568 __bool_constant<(_Args::value >= _ArgTypes::value)>,
569 _AllConvertible<_Args, _ArgTypes>
573 using result_type =
typename _Traits::__result_type;
575 explicit _Mem_fn_base(_Pmf __pmf) : _M_pmf(__pmf) { }
578 template<
typename... _Args,
typename _Req
579 = _Require<
typename _Traits::__lvalue,
580 _CheckArgs<_Pack<_Args...>>>>
582 operator()(_Class& __object, _Args&&... __args)
const
583 {
return (__object.*_M_pmf)(std::forward<_Args>(__args)...); }
585 template<
typename... _Args,
typename _Req
586 = _Require<
typename _Traits::__rvalue,
587 _CheckArgs<_Pack<_Args...>>>>
589 operator()(_Class&& __object, _Args&&... __args)
const
591 return (std::move(__object).*_M_pmf)(std::forward<_Args>(__args)...);
595 template<
typename... _Args,
typename _Req
596 = _Require<
typename _Traits::__lvalue,
597 _CheckArgs<_Pack<_Args...>>>>
599 operator()(_Class* __object, _Args&&... __args)
const
600 {
return (__object->*_M_pmf)(std::forward<_Args>(__args)...); }
603 template<
typename _Tp,
typename... _Args,
typename _Req
604 = _Require<_NotSame<_Class, _Tp>, _NotSame<_Class*, _Tp>,
605 _CheckArgs<_Pack<_Args...>>>>
607 operator()(_Tp&& __object, _Args&&... __args)
const
609 return _M_call(std::forward<_Tp>(__object), &__object,
610 std::forward<_Args>(__args)...);
614 template<
typename _Tp,
typename... _Args,
typename _Req
615 = _Require<is_base_of<_Class, _Tp>,
typename _Traits::__lvalue,
616 _CheckArgs<_Pack<_Args...>>>>
618 operator()(reference_wrapper<_Tp> __ref, _Args&&... __args)
const
619 {
return operator()(__ref.get(), std::forward<_Args>(__args)...); }
622 template<
typename _Tp,
typename... _Args>
624 _M_call(_Tp&& __object,
const volatile _Class *,
625 _Args&&... __args)
const
627 return (std::forward<_Tp>(__object).*_M_pmf)
628 (std::forward<_Args>(__args)...);
631 template<
typename _Tp,
typename... _Args>
633 _M_call(_Tp&& __ptr,
const volatile void *, _Args&&... __args)
const
634 {
return ((*__ptr).*_M_pmf)(std::forward<_Args>(__args)...); }
640 template<
typename _Res,
typename _Class>
641 class _Mem_fn_base<_Res _Class::*, false>
643 using __pm_type = _Res _Class::*;
648 template<
typename _Tp>
650 _M_call(_Tp&& __object,
const _Class *) const noexcept
651 -> decltype(std::
forward<_Tp>(__object).*std::declval<__pm_type&>())
652 {
return std::forward<_Tp>(__object).*_M_pm; }
654 template<
typename _Tp,
typename _Up>
656 _M_call(_Tp&& __object, _Up *
const *) const noexcept
657 -> decltype((*std::
forward<_Tp>(__object)).*std::declval<__pm_type&>())
658 {
return (*std::forward<_Tp>(__object)).*_M_pm; }
660 template<
typename _Tp>
662 _M_call(_Tp&& __ptr,
const volatile void*) const
663 noexcept(noexcept((*__ptr).*std::declval<__pm_type&>()))
664 -> decltype((*__ptr).*std::declval<__pm_type&>())
665 {
return (*__ptr).*_M_pm; }
667 using _Arity = integral_constant<size_t, 0>;
670 template<
typename _Func,
typename... _BoundArgs>
671 friend struct _Bind_check_arity;
675 _Mem_fn_base(_Res _Class::*__pm) noexcept : _M_pm(__pm) { }
679 operator()(_Class& __object)
const noexcept
680 {
return __object.*_M_pm; }
683 operator()(
const _Class& __object)
const noexcept
684 {
return __object.*_M_pm; }
687 operator()(_Class&& __object) const noexcept
688 {
return std::forward<_Class>(__object).*_M_pm; }
691 operator()(
const _Class&& __object) const noexcept
692 {
return std::forward<const _Class>(__object).*_M_pm; }
696 operator()(_Class* __object)
const noexcept
697 {
return __object->*_M_pm; }
700 operator()(
const _Class* __object)
const noexcept
701 {
return __object->*_M_pm; }
704 template<
typename _Tp,
typename _Req = _Require<_NotSame<_Class*, _Tp>>>
706 operator()(_Tp&& __unknown) const
707 noexcept(noexcept(std::declval<_Mem_fn_base*>()->_M_call
708 (std::
forward<_Tp>(__unknown), &__unknown)))
709 -> decltype(this->_M_call(std::
forward<_Tp>(__unknown), &__unknown))
710 {
return _M_call(std::forward<_Tp>(__unknown), &__unknown); }
712 template<
typename _Tp,
typename _Req = _Require<is_base_of<_Class, _Tp>>>
714 operator()(reference_wrapper<_Tp> __ref)
const
715 noexcept(noexcept(std::declval<_Mem_fn_base&>()(__ref.get())))
716 -> decltype((*
this)(__ref.get()))
717 {
return (*
this)(__ref.get()); }
723 template<
typename _Res,
typename _Class>
724 struct _Mem_fn<_Res _Class::*>
725 : _Mem_fn_base<_Res _Class::*>
727 using _Mem_fn_base<_Res _Class::*>::_Mem_fn_base;
737 template<
typename _Tp,
typename _Class>
738 inline _Mem_fn<_Tp _Class::*>
741 return _Mem_fn<_Tp _Class::*>(__pm);
750 template<
typename _Tp>
752 :
public false_type { };
759 template<
typename _Tp>
769 _GLIBCXX_END_NAMESPACE_VERSION
775 namespace placeholders
777 _GLIBCXX_BEGIN_NAMESPACE_VERSION
811 _GLIBCXX_END_NAMESPACE_VERSION
814 _GLIBCXX_BEGIN_NAMESPACE_VERSION
835 struct _No_tuple_element;
842 template<std::
size_t __i,
typename _Tuple,
bool _IsSafe>
851 template<std::
size_t __i,
typename _Tuple>
854 typedef _No_tuple_element type;
861 template<std::
size_t __i,
typename _Tuple>
864 (__i < tuple_size<_Tuple>::value)>
878 template<typename _Arg,
879 bool _IsBindExp = is_bind_expression<_Arg>::value,
880 bool _IsPlaceholder = (is_placeholder<_Arg>::value > 0)>
887 template<typename _Tp>
888 class
_Mu<reference_wrapper<_Tp>, false, false>
891 typedef _Tp& result_type;
897 template<
typename _CVRef,
typename _Tuple>
899 operator()(_CVRef& __arg, _Tuple&)
const volatile
900 {
return __arg.get(); }
908 template<
typename _Arg>
909 class _Mu<_Arg, true, false>
912 template<
typename _CVArg,
typename... _Args>
914 operator()(_CVArg& __arg,
916 -> decltype(__arg(declval<_Args>()...))
919 typedef typename _Build_index_tuple<
sizeof...(_Args)>::__type
921 return this->__call(__arg, __tuple, _Indexes());
927 template<
typename _CVArg,
typename... _Args, std::size_t... _Indexes>
930 const _Index_tuple<_Indexes...>&)
const volatile
931 -> decltype(__arg(declval<_Args>()...))
933 return __arg(std::forward<_Args>(std::get<_Indexes>(__tuple))...);
942 template<
typename _Arg>
943 class _Mu<_Arg, false, true>
946 template<
typename _Signature>
class result;
948 template<
typename _CVMu,
typename _CVArg,
typename _Tuple>
949 class result<_CVMu(_CVArg, _Tuple)>
959 typedef typename add_rvalue_reference<__base_type>::type type;
962 template<
typename _Tuple>
963 typename result<_Mu(_Arg, _Tuple)>::type
964 operator()(
const volatile _Arg&, _Tuple& __tuple)
const volatile
966 return std::forward<typename result<_Mu(_Arg, _Tuple)>::type>(
967 ::std::get<(is_placeholder<_Arg>::value - 1)>(__tuple));
976 template<
typename _Arg>
977 class _Mu<_Arg, false, false>
980 template<
typename _Signature>
struct result;
982 template<
typename _CVMu,
typename _CVArg,
typename _Tuple>
983 struct result<_CVMu(_CVArg, _Tuple)>
985 typedef typename add_lvalue_reference<_CVArg>::type type;
989 template<
typename _CVArg,
typename _Tuple>
991 operator()(_CVArg&& __arg, _Tuple&)
const volatile
992 {
return std::forward<_CVArg>(__arg); }
1000 template<
typename _Tp>
1006 __do_wrap(
const _Tp& __x)
1010 __do_wrap(_Tp&& __x)
1011 {
return static_cast<_Tp&&
>(__x); }
1019 template<
typename _Tp,
typename _Class>
1022 typedef _Mem_fn<_Tp _Class::*> type;
1025 __do_wrap(_Tp _Class::* __pm)
1026 {
return type(__pm); }
1040 template<std::size_t _Ind,
typename... _Tp>
1042 __volget(
volatile tuple<_Tp...>& __tuple)
1043 -> __tuple_element_t<_Ind, tuple<_Tp...>>
volatile&
1044 {
return std::get<_Ind>(
const_cast<tuple<_Tp...
>&>(__tuple)); }
1047 template<std::size_t _Ind,
typename... _Tp>
1049 __volget(
const volatile tuple<_Tp...>& __tuple)
1050 -> __tuple_element_t<_Ind, tuple<_Tp...>>
const volatile&
1051 {
return std::get<_Ind>(
const_cast<const tuple<_Tp...
>&>(__tuple)); }
1054 template<
typename _Signature>
1057 template<
typename _Functor,
typename... _Bound_args>
1058 class _Bind<_Functor(_Bound_args...)>
1061 typedef _Bind __self_type;
1062 typedef typename _Build_index_tuple<
sizeof...(_Bound_args)>::__type
1066 tuple<_Bound_args...> _M_bound_args;
1069 template<
typename _Result,
typename... _Args, std::size_t... _Indexes>
1074 (std::get<_Indexes>(_M_bound_args), __args)...);
1078 template<
typename _Result,
typename... _Args, std::size_t... _Indexes>
1083 (std::get<_Indexes>(_M_bound_args), __args)...);
1087 template<
typename _Result,
typename... _Args, std::size_t... _Indexes>
1089 __call_v(tuple<_Args...>&& __args,
1090 _Index_tuple<_Indexes...>)
volatile
1092 return _M_f(_Mu<_Bound_args>()
1093 (__volget<_Indexes>(_M_bound_args), __args)...);
1097 template<
typename _Result,
typename... _Args, std::size_t... _Indexes>
1099 __call_c_v(tuple<_Args...>&& __args,
1100 _Index_tuple<_Indexes...>)
const volatile
1102 return _M_f(_Mu<_Bound_args>()
1103 (__volget<_Indexes>(_M_bound_args), __args)...);
1107 template<
typename... _Args>
1108 explicit _Bind(
const _Functor& __f, _Args&&... __args)
1109 : _M_f(__f), _M_bound_args(std::
forward<_Args>(__args)...)
1112 template<
typename... _Args>
1113 explicit _Bind(_Functor&& __f, _Args&&... __args)
1114 : _M_f(std::move(__f)), _M_bound_args(std::
forward<_Args>(__args)...)
1117 _Bind(
const _Bind&) =
default;
1120 : _M_f(std::move(__b._M_f)), _M_bound_args(std::move(__b._M_bound_args))
1124 template<
typename... _Args,
typename _Result
1125 = decltype( std::declval<_Functor>()(
1126 _Mu<_Bound_args>()( std::declval<_Bound_args&>(),
1127 std::declval<tuple<_Args...>&>() )... ) )>
1129 operator()(_Args&&... __args)
1131 return this->__call<_Result>(
1132 std::forward_as_tuple(std::forward<_Args>(__args)...),
1137 template<
typename... _Args,
typename _Result
1138 = decltype( std::declval<
typename enable_if<(
sizeof...(_Args) >= 0),
1139 typename add_const<_Functor>::type>::type>()(
1140 _Mu<_Bound_args>()( std::declval<const _Bound_args&>(),
1141 std::declval<tuple<_Args...>&>() )... ) )>
1143 operator()(_Args&&... __args)
const
1145 return this->__call_c<_Result>(
1146 std::forward_as_tuple(std::forward<_Args>(__args)...),
1151 template<
typename... _Args,
typename _Result
1152 = decltype( std::declval<
typename enable_if<(
sizeof...(_Args) >= 0),
1153 typename add_volatile<_Functor>::type>::type>()(
1154 _Mu<_Bound_args>()( std::declval<volatile _Bound_args&>(),
1155 std::declval<tuple<_Args...>&>() )... ) )>
1157 operator()(_Args&&... __args)
volatile
1159 return this->__call_v<_Result>(
1160 std::forward_as_tuple(std::forward<_Args>(__args)...),
1165 template<
typename... _Args,
typename _Result
1166 = decltype( std::declval<
typename enable_if<(
sizeof...(_Args) >= 0),
1167 typename add_cv<_Functor>::type>::type>()(
1168 _Mu<_Bound_args>()( std::declval<const volatile _Bound_args&>(),
1169 std::declval<tuple<_Args...>&>() )... ) )>
1171 operator()(_Args&&... __args)
const volatile
1173 return this->__call_c_v<_Result>(
1174 std::forward_as_tuple(std::forward<_Args>(__args)...),
1180 template<
typename _Result,
typename _Signature>
1183 template<
typename _Result,
typename _Functor,
typename... _Bound_args>
1187 typedef typename _Build_index_tuple<
sizeof...(_Bound_args)>::__type
1191 tuple<_Bound_args...> _M_bound_args;
1194 template<
typename _Res>
1195 struct __enable_if_void : enable_if<is_void<_Res>::value, int> { };
1196 template<
typename _Res>
1197 struct __disable_if_void : enable_if<!is_void<_Res>::value, int> { };
1200 template<
typename _Res,
typename... _Args, std::size_t... _Indexes>
1202 __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
1203 typename __disable_if_void<_Res>::type = 0)
1205 return _M_f(_Mu<_Bound_args>()
1206 (std::get<_Indexes>(_M_bound_args), __args)...);
1210 template<
typename _Res,
typename... _Args, std::size_t... _Indexes>
1212 __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
1213 typename __enable_if_void<_Res>::type = 0)
1215 _M_f(_Mu<_Bound_args>()
1216 (std::get<_Indexes>(_M_bound_args), __args)...);
1220 template<
typename _Res,
typename... _Args, std::size_t... _Indexes>
1222 __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
1223 typename __disable_if_void<_Res>::type = 0)
const
1225 return _M_f(_Mu<_Bound_args>()
1226 (std::get<_Indexes>(_M_bound_args), __args)...);
1230 template<
typename _Res,
typename... _Args, std::size_t... _Indexes>
1232 __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
1233 typename __enable_if_void<_Res>::type = 0)
const
1235 _M_f(_Mu<_Bound_args>()
1236 (std::get<_Indexes>(_M_bound_args), __args)...);
1240 template<
typename _Res,
typename... _Args, std::size_t... _Indexes>
1242 __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
1243 typename __disable_if_void<_Res>::type = 0)
volatile
1245 return _M_f(_Mu<_Bound_args>()
1246 (__volget<_Indexes>(_M_bound_args), __args)...);
1250 template<
typename _Res,
typename... _Args, std::size_t... _Indexes>
1252 __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
1253 typename __enable_if_void<_Res>::type = 0)
volatile
1255 _M_f(_Mu<_Bound_args>()
1256 (__volget<_Indexes>(_M_bound_args), __args)...);
1260 template<
typename _Res,
typename... _Args, std::size_t... _Indexes>
1262 __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
1263 typename __disable_if_void<_Res>::type = 0)
const volatile
1265 return _M_f(_Mu<_Bound_args>()
1266 (__volget<_Indexes>(_M_bound_args), __args)...);
1270 template<
typename _Res,
typename... _Args, std::size_t... _Indexes>
1272 __call(tuple<_Args...>&& __args,
1273 _Index_tuple<_Indexes...>,
1274 typename __enable_if_void<_Res>::type = 0)
const volatile
1276 _M_f(_Mu<_Bound_args>()
1277 (__volget<_Indexes>(_M_bound_args), __args)...);
1281 typedef _Result result_type;
1283 template<
typename... _Args>
1284 explicit _Bind_result(
const _Functor& __f, _Args&&... __args)
1285 : _M_f(__f), _M_bound_args(std::
forward<_Args>(__args)...)
1288 template<
typename... _Args>
1289 explicit _Bind_result(_Functor&& __f, _Args&&... __args)
1290 : _M_f(std::move(__f)), _M_bound_args(std::
forward<_Args>(__args)...)
1293 _Bind_result(
const _Bind_result&) =
default;
1295 _Bind_result(_Bind_result&& __b)
1296 : _M_f(std::move(__b._M_f)), _M_bound_args(std::move(__b._M_bound_args))
1300 template<
typename... _Args>
1302 operator()(_Args&&... __args)
1304 return this->__call<_Result>(
1305 std::forward_as_tuple(std::forward<_Args>(__args)...),
1310 template<
typename... _Args>
1312 operator()(_Args&&... __args)
const
1314 return this->__call<_Result>(
1315 std::forward_as_tuple(std::forward<_Args>(__args)...),
1320 template<
typename... _Args>
1322 operator()(_Args&&... __args)
volatile
1324 return this->__call<_Result>(
1325 std::forward_as_tuple(std::forward<_Args>(__args)...),
1330 template<
typename... _Args>
1332 operator()(_Args&&... __args)
const volatile
1334 return this->__call<_Result>(
1335 std::forward_as_tuple(std::forward<_Args>(__args)...),
1344 template<
typename _Signature>
1346 :
public true_type { };
1352 template<
typename _Signature>
1354 :
public true_type { };
1360 template<
typename _Signature>
1362 :
public true_type { };
1368 template<
typename _Signature>
1370 :
public true_type { };
1376 template<
typename _Result,
typename _Signature>
1378 :
public true_type { };
1384 template<
typename _Result,
typename _Signature>
1386 :
public true_type { };
1392 template<
typename _Result,
typename _Signature>
1394 :
public true_type { };
1400 template<
typename _Result,
typename _Signature>
1402 :
public true_type { };
1404 template<
typename _Func,
typename... _BoundArgs>
1405 struct _Bind_check_arity { };
1407 template<
typename _Ret,
typename... _Args,
typename... _BoundArgs>
1408 struct _Bind_check_arity<_Ret (*)(_Args...), _BoundArgs...>
1410 static_assert(
sizeof...(_BoundArgs) ==
sizeof...(_Args),
1411 "Wrong number of arguments for function");
1414 template<
typename _Ret,
typename... _Args,
typename... _BoundArgs>
1415 struct _Bind_check_arity<_Ret (*)(_Args......), _BoundArgs...>
1417 static_assert(
sizeof...(_BoundArgs) >=
sizeof...(_Args),
1418 "Wrong number of arguments for function");
1421 template<
typename _Tp,
typename _Class,
typename... _BoundArgs>
1422 struct _Bind_check_arity<_Tp _Class::*, _BoundArgs...>
1424 using _Arity =
typename _Mem_fn<_Tp _Class::*>::_Arity;
1425 using _Varargs =
typename _Mem_fn<_Tp _Class::*>::_Varargs;
1426 static_assert(_Varargs::value
1427 ?
sizeof...(_BoundArgs) >= _Arity::value + 1
1428 :
sizeof...(_BoundArgs) == _Arity::value + 1,
1429 "Wrong number of arguments for pointer-to-member");
1435 template<typename _Tp, typename _Tp2 = typename decay<_Tp>::type>
1436 using __is_socketlike = __or_<is_integral<_Tp2>, is_enum<_Tp2>>;
1438 template<
bool _SocketLike,
typename _Func,
typename... _BoundArgs>
1440 : _Bind_check_arity<typename decay<_Func>::type, _BoundArgs...>
1442 typedef _Maybe_wrap_member_pointer<typename decay<_Func>::type>
1444 typedef typename __maybe_type::type __func_type;
1445 typedef _Bind<__func_type(typename decay<_BoundArgs>::type...)> type;
1451 template<
typename _Func,
typename... _BoundArgs>
1452 struct _Bind_helper<true, _Func, _BoundArgs...>
1459 template<
typename _Func,
typename... _BoundArgs>
1461 _Bind_helper<__is_socketlike<_Func>::value, _Func, _BoundArgs...>::type
1462 bind(_Func&& __f, _BoundArgs&&... __args)
1464 typedef _Bind_helper<
false, _Func, _BoundArgs...> __helper_type;
1465 typedef typename __helper_type::__maybe_type __maybe_type;
1466 typedef typename __helper_type::type __result_type;
1467 return __result_type(__maybe_type::__do_wrap(std::forward<_Func>(__f)),
1468 std::forward<_BoundArgs>(__args)...);
1471 template<
typename _Result,
typename _Func,
typename... _BoundArgs>
1472 struct _Bindres_helper
1473 : _Bind_check_arity<typename decay<_Func>::type, _BoundArgs...>
1475 typedef _Maybe_wrap_member_pointer<typename decay<_Func>::type>
1477 typedef typename __maybe_type::type __functor_type;
1478 typedef _Bind_result<_Result,
1479 __functor_type(
typename decay<_BoundArgs>::type...)>
1487 template<
typename _Result,
typename _Func,
typename... _BoundArgs>
1489 typename _Bindres_helper<_Result, _Func, _BoundArgs...>::type
1490 bind(_Func&& __f, _BoundArgs&&... __args)
1492 typedef _Bindres_helper<_Result, _Func, _BoundArgs...> __helper_type;
1493 typedef typename __helper_type::__maybe_type __maybe_type;
1494 typedef typename __helper_type::type __result_type;
1495 return __result_type(__maybe_type::__do_wrap(std::forward<_Func>(__f)),
1496 std::forward<_BoundArgs>(__args)...);
1499 template<
typename _Signature>
1500 struct _Bind_simple;
1502 template<
typename _Callable,
typename... _Args>
1503 struct _Bind_simple<_Callable(_Args...)>
1505 typedef typename result_of<_Callable(_Args...)>::type result_type;
1507 template<
typename _Tp,
typename... _Up>
1509 _Bind_simple(_Tp&& __f, _Up&&... __args)
1513 _Bind_simple(
const _Bind_simple&) =
default;
1514 _Bind_simple(_Bind_simple&&) =
default;
1519 typedef typename _Build_index_tuple<
sizeof...(_Args)>::__type _Indices;
1520 return _M_invoke(_Indices());
1524 template<std::size_t... _Indices>
1525 typename result_of<_Callable(_Args...)>::type
1526 _M_invoke(_Index_tuple<_Indices...>)
1530 return std::forward<_Callable>(std::get<0>(_M_bound))(
1531 std::forward<_Args>(std::get<_Indices+1>(_M_bound))...);
1537 template<
typename _Func,
typename... _BoundArgs>
1538 struct _Bind_simple_helper
1539 : _Bind_check_arity<typename decay<_Func>::type, _BoundArgs...>
1541 typedef _Maybe_wrap_member_pointer<typename decay<_Func>::type>
1543 typedef typename __maybe_type::type __func_type;
1544 typedef _Bind_simple<__func_type(typename decay<_BoundArgs>::type...)>
1550 template<
typename _Callable,
typename... _Args>
1551 typename _Bind_simple_helper<_Callable, _Args...>::__type
1552 __bind_simple(_Callable&& __callable, _Args&&... __args)
1554 typedef _Bind_simple_helper<_Callable, _Args...> __helper_type;
1555 typedef typename __helper_type::__maybe_type __maybe_type;
1556 typedef typename __helper_type::__type __result_type;
1557 return __result_type(
1558 __maybe_type::__do_wrap( std::forward<_Callable>(__callable)),
1559 std::forward<_Args>(__args)...);
1572 const char*
what()
const noexcept;
1581 template<
typename _Tp>
1583 : is_trivially_copyable<_Tp>
::type
1586 class _Undefined_class;
1591 const void* _M_const_object;
1592 void (*_M_function_pointer)();
1593 void (_Undefined_class::*_M_member_pointer)();
1598 void* _M_access() {
return &_M_pod_data[0]; }
1599 const void* _M_access()
const {
return &_M_pod_data[0]; }
1601 template<
typename _Tp>
1604 {
return *
static_cast<_Tp*
>(_M_access()); }
1606 template<
typename _Tp>
1609 {
return *
static_cast<const _Tp*
>(_M_access()); }
1611 _Nocopy_types _M_unused;
1612 char _M_pod_data[
sizeof(_Nocopy_types)];
1615 enum _Manager_operation
1625 template<
typename _Tp>
1626 struct _Simple_type_wrapper
1628 _Simple_type_wrapper(_Tp __value) : __value(__value) { }
1633 template<
typename _Tp>
1634 struct __is_location_invariant<_Simple_type_wrapper<_Tp> >
1635 : __is_location_invariant<_Tp>
1640 template<
typename _Functor>
1642 __callable_functor(_Functor& __f)
1645 template<
typename _Member,
typename _Class>
1646 inline _Mem_fn<_Member _Class::*>
1647 __callable_functor(_Member _Class::* &__p)
1650 template<
typename _Member,
typename _Class>
1651 inline _Mem_fn<_Member _Class::*>
1652 __callable_functor(_Member _Class::*
const &__p)
1655 template<
typename _Member,
typename _Class>
1656 inline _Mem_fn<_Member _Class::*>
1657 __callable_functor(_Member _Class::*
volatile &__p)
1660 template<
typename _Member,
typename _Class>
1661 inline _Mem_fn<_Member _Class::*>
1662 __callable_functor(_Member _Class::*
const volatile &__p)
1665 template<
typename _Signature>
1672 static const std::size_t _M_max_size =
sizeof(_Nocopy_types);
1673 static const std::size_t _M_max_align = __alignof__(_Nocopy_types);
1675 template<
typename _Functor>
1679 static const bool __stored_locally =
1681 &&
sizeof(_Functor) <= _M_max_size
1682 && __alignof__(_Functor) <= _M_max_align
1683 && (_M_max_align % __alignof__(_Functor) == 0));
1689 _M_get_pointer(
const _Any_data& __source)
1691 const _Functor* __ptr =
1693 : __source._M_access<_Functor*>();
1694 return const_cast<_Functor*
>(__ptr);
1700 _M_clone(_Any_data& __dest,
const _Any_data& __source, true_type)
1702 new (__dest._M_access()) _Functor(__source._M_access<_Functor>());
1708 _M_clone(_Any_data& __dest,
const _Any_data& __source, false_type)
1710 __dest._M_access<_Functor*>() =
1711 new _Functor(*__source._M_access<_Functor*>());
1717 _M_destroy(_Any_data& __victim, true_type)
1719 __victim._M_access<_Functor>().~_Functor();
1724 _M_destroy(_Any_data& __victim, false_type)
1726 delete __victim._M_access<_Functor*>();
1731 _M_manager(_Any_data& __dest,
const _Any_data& __source,
1732 _Manager_operation __op)
1737 case __get_type_info:
1738 __dest._M_access<
const type_info*>() = &
typeid(_Functor);
1741 case __get_functor_ptr:
1742 __dest._M_access<_Functor*>() = _M_get_pointer(__source);
1745 case __clone_functor:
1746 _M_clone(__dest, __source, _Local_storage());
1749 case __destroy_functor:
1750 _M_destroy(__dest, _Local_storage());
1757 _M_init_functor(_Any_data& __functor, _Functor&& __f)
1758 { _M_init_functor(__functor, std::move(__f), _Local_storage()); }
1760 template<
typename _Signature>
1762 _M_not_empty_function(
const function<_Signature>& __f)
1763 {
return static_cast<bool>(__f); }
1765 template<
typename _Tp>
1767 _M_not_empty_function(_Tp*
const& __fp)
1770 template<
typename _Class,
typename _Tp>
1772 _M_not_empty_function(_Tp _Class::*
const& __mp)
1775 template<
typename _Tp>
1777 _M_not_empty_function(
const _Tp&)
1782 _M_init_functor(_Any_data& __functor, _Functor&& __f, true_type)
1783 {
new (__functor._M_access()) _Functor(std::move(__f)); }
1786 _M_init_functor(_Any_data& __functor, _Functor&& __f, false_type)
1787 { __functor._M_access<_Functor*>() =
new _Functor(std::move(__f)); }
1790 template<
typename _Functor>
1791 class _Ref_manager :
public _Base_manager<_Functor*>
1793 typedef _Function_base::_Base_manager<_Functor*> _Base;
1797 _M_manager(_Any_data& __dest,
const _Any_data& __source,
1798 _Manager_operation __op)
1803 case __get_type_info:
1804 __dest._M_access<
const type_info*>() = &
typeid(_Functor);
1807 case __get_functor_ptr:
1808 __dest._M_access<_Functor*>() = *_Base::_M_get_pointer(__source);
1813 _Base::_M_manager(__dest, __source, __op);
1830 _M_manager(_M_functor, _M_functor, __destroy_functor);
1834 bool _M_empty()
const {
return !_M_manager; }
1836 typedef bool (*_Manager_type)(_Any_data&,
const _Any_data&,
1837 _Manager_operation);
1839 _Any_data _M_functor;
1840 _Manager_type _M_manager;
1843 template<
typename _Signature,
typename _Functor>
1844 class _Function_handler;
1846 template<
typename _Res,
typename _Functor,
typename... _ArgTypes>
1847 class _Function_handler<_Res(_ArgTypes...), _Functor>
1848 :
public _Function_base::_Base_manager<_Functor>
1850 typedef _Function_base::_Base_manager<_Functor> _Base;
1854 _M_invoke(
const _Any_data& __functor, _ArgTypes&&... __args)
1856 return (*_Base::_M_get_pointer(__functor))(
1857 std::forward<_ArgTypes>(__args)...);
1861 template<
typename _Functor,
typename... _ArgTypes>
1862 class _Function_handler<void(_ArgTypes...), _Functor>
1863 :
public _Function_base::_Base_manager<_Functor>
1865 typedef _Function_base::_Base_manager<_Functor> _Base;
1869 _M_invoke(
const _Any_data& __functor, _ArgTypes&&... __args)
1871 (*_Base::_M_get_pointer(__functor))(
1872 std::forward<_ArgTypes>(__args)...);
1876 template<
typename _Res,
typename _Functor,
typename... _ArgTypes>
1877 class _Function_handler<_Res(_ArgTypes...), reference_wrapper<_Functor> >
1878 :
public _Function_base::_Ref_manager<_Functor>
1880 typedef _Function_base::_Ref_manager<_Functor> _Base;
1884 _M_invoke(
const _Any_data& __functor, _ArgTypes&&... __args)
1886 return __callable_functor(**_Base::_M_get_pointer(__functor))(
1887 std::forward<_ArgTypes>(__args)...);
1891 template<
typename _Functor,
typename... _ArgTypes>
1892 class _Function_handler<void(_ArgTypes...), reference_wrapper<_Functor> >
1893 :
public _Function_base::_Ref_manager<_Functor>
1895 typedef _Function_base::_Ref_manager<_Functor> _Base;
1899 _M_invoke(
const _Any_data& __functor, _ArgTypes&&... __args)
1901 __callable_functor(**_Base::_M_get_pointer(__functor))(
1902 std::forward<_ArgTypes>(__args)...);
1906 template<
typename _Class,
typename _Member,
typename _Res,
1907 typename... _ArgTypes>
1908 class _Function_handler<_Res(_ArgTypes...), _Member _Class::*>
1909 :
public _Function_handler<void(_ArgTypes...), _Member _Class::*>
1911 typedef _Function_handler<void(_ArgTypes...), _Member _Class::*>
1916 _M_invoke(
const _Any_data& __functor, _ArgTypes&&... __args)
1918 return std::mem_fn(_Base::_M_get_pointer(__functor)->__value)(
1919 std::forward<_ArgTypes>(__args)...);
1923 template<
typename _Class,
typename _Member,
typename... _ArgTypes>
1924 class _Function_handler<void(_ArgTypes...), _Member _Class::*>
1925 :
public _Function_base::_Base_manager<
1926 _Simple_type_wrapper< _Member _Class::* > >
1928 typedef _Member _Class::* _Functor;
1929 typedef _Simple_type_wrapper<_Functor> _Wrapper;
1930 typedef _Function_base::_Base_manager<_Wrapper> _Base;
1934 _M_manager(_Any_data& __dest,
const _Any_data& __source,
1935 _Manager_operation __op)
1940 case __get_type_info:
1941 __dest._M_access<
const type_info*>() = &
typeid(_Functor);
1944 case __get_functor_ptr:
1945 __dest._M_access<_Functor*>() =
1946 &_Base::_M_get_pointer(__source)->__value;
1950 _Base::_M_manager(__dest, __source, __op);
1956 _M_invoke(
const _Any_data& __functor, _ArgTypes&&... __args)
1958 std::mem_fn(_Base::_M_get_pointer(__functor)->__value)(
1959 std::forward<_ArgTypes>(__args)...);
1963 template<
typename _From,
typename _To>
1964 using __check_func_return_type
1965 = __or_<is_void<_To>, is_convertible<_From, _To>>;
1973 template<
typename _Res,
typename... _ArgTypes>
1974 class function<_Res(_ArgTypes...)>
1978 typedef _Res _Signature_type(_ArgTypes...);
1980 template<
typename _Functor>
1981 using _Invoke = decltype(__callable_functor(std::declval<_Functor&>())
1982 (std::declval<_ArgTypes>()...) );
1986 template<
typename _Tp>
1987 using _NotSelf = __not_<is_same<_Tp, function>>;
1989 template<
typename _Functor>
1991 = __and_<_NotSelf<_Functor>,
1992 __check_func_return_type<_Invoke<_Functor>, _Res>>;
1994 template<
typename _Cond,
typename _Tp>
1995 using _Requires =
typename enable_if<_Cond::value, _Tp>::type;
1998 typedef _Res result_type;
2013 function(nullptr_t) noexcept
2024 function(
const function& __x);
2056 template<
typename _Functor,
2057 typename = _Requires<_Callable<_Functor>,
void>>
2075 function(__x).
swap(*
this);
2093 function(std::move(__x)).
swap(*
this);
2109 _M_manager(_M_functor, _M_functor, __destroy_functor);
2110 _M_manager =
nullptr;
2111 _M_invoker =
nullptr;
2132 template<
typename _Functor>
2133 _Requires<_Callable<typename decay<_Functor>::type>,
function&>
2136 function(std::forward<_Functor>(__f)).swap(*
this);
2141 template<
typename _Functor>
2145 function(__f).
swap(*
this);
2186 explicit operator bool() const noexcept
2187 {
return !_M_empty(); }
2199 _Res operator()(_ArgTypes... __args)
const;
2212 const type_info& target_type() const noexcept;
2223 template<typename _Functor> _Functor* target() noexcept;
2226 template<typename _Functor> const _Functor* target() const noexcept;
2230 using _Invoker_type = _Res (*)(
const _Any_data&, _ArgTypes&&...);
2231 _Invoker_type _M_invoker;
2235 template<
typename _Res,
typename... _ArgTypes>
2236 function<_Res(_ArgTypes...)>::
2237 function(
const function& __x)
2240 if (static_cast<bool>(__x))
2242 __x._M_manager(_M_functor, __x._M_functor, __clone_functor);
2243 _M_invoker = __x._M_invoker;
2244 _M_manager = __x._M_manager;
2248 template<
typename _Res,
typename... _ArgTypes>
2249 template<
typename _Functor,
typename>
2250 function<_Res(_ArgTypes...)>::
2251 function(_Functor __f)
2254 typedef _Function_handler<_Signature_type, _Functor> _My_handler;
2256 if (_My_handler::_M_not_empty_function(__f))
2258 _My_handler::_M_init_functor(_M_functor, std::move(__f));
2259 _M_invoker = &_My_handler::_M_invoke;
2260 _M_manager = &_My_handler::_M_manager;
2264 template<
typename _Res,
typename... _ArgTypes>
2266 function<_Res(_ArgTypes...)>::
2267 operator()(_ArgTypes... __args)
const
2270 __throw_bad_function_call();
2271 return _M_invoker(_M_functor, std::forward<_ArgTypes>(__args)...);
2275 template<
typename _Res,
typename... _ArgTypes>
2277 function<_Res(_ArgTypes...)>::
2278 target_type() const noexcept
2282 _Any_data __typeinfo_result;
2283 _M_manager(__typeinfo_result, _M_functor, __get_type_info);
2284 return *__typeinfo_result._M_access<
const type_info*>();
2287 return typeid(void);
2290 template<
typename _Res,
typename... _ArgTypes>
2291 template<
typename _Functor>
2293 function<_Res(_ArgTypes...)>::
2296 if (
typeid(_Functor) == target_type() && _M_manager)
2299 if (_M_manager(__ptr, _M_functor, __get_functor_ptr)
2303 return __ptr._M_access<_Functor*>();
2309 template<
typename _Res,
typename... _ArgTypes>
2310 template<
typename _Functor>
2312 function<_Res(_ArgTypes...)>::
2313 target() const noexcept
2315 if (
typeid(_Functor) == target_type() && _M_manager)
2318 _M_manager(__ptr, _M_functor, __get_functor_ptr);
2319 return __ptr._M_access<
const _Functor*>();
2335 template<
typename _Res,
typename... _Args>
2337 operator==(
const function<_Res(_Args...)>& __f, nullptr_t) noexcept
2338 {
return !
static_cast<bool>(__f); }
2341 template<
typename _Res,
typename... _Args>
2343 operator==(nullptr_t,
const function<_Res(_Args...)>& __f) noexcept
2344 {
return !
static_cast<bool>(__f); }
2353 template<
typename _Res,
typename... _Args>
2355 operator!=(
const function<_Res(_Args...)>& __f, nullptr_t) noexcept
2356 {
return static_cast<bool>(__f); }
2359 template<
typename _Res,
typename... _Args>
2361 operator!=(nullptr_t,
const function<_Res(_Args...)>& __f) noexcept
2362 {
return static_cast<bool>(__f); }
2371 template<
typename _Res,
typename... _Args>
2373 swap(
function<_Res(_Args...)>& __x,
function<_Res(_Args...)>& __y)
2376 _GLIBCXX_END_NAMESPACE_VERSION
2381 #endif // _GLIBCXX_FUNCTIONAL
Primary class template for reference_wrapper.
void swap(basic_filebuf< _CharT, _Traits > &__x, basic_filebuf< _CharT, _Traits > &__y)
Swap specialization for filebufs.
Determines if the given type _Tp is a function object should be treated as a subexpression when evalu...
integral_constant< bool, true > true_type
The type used as a compile-time boolean with true value.
_Requires< _Callable< typename decay< _Functor >::type >, function & > operator=(_Functor &&__f)
Function assignment to a new target.
function & operator=(function &&__x)
Function move-assignment operator.
enable_if< (!is_member_pointer< _Functor >::value &&!is_function< _Functor >::value &&!is_function< typename remove_pointer< _Functor >::type >::value), typename result_of< _Functor &(_Args &&...)>::type >::type __invoke(_Functor &__f, _Args &&...__args)
constexpr _Tp && forward(typename std::remove_reference< _Tp >::type &__t) noexcept
Forward an lvalue.
The type of placeholder objects defined by libstdc++.
Type of the function object returned from bind<R>().
Primary class template, tuple.
_Bind_helper< __is_socketlike< _Func >::value, _Func, _BoundArgs...>::type bind(_Func &&__f, _BoundArgs &&...__args)
Function template for std::bind.
integral_constant< bool, false > false_type
The type used as a compile-time boolean with false value.
function & operator=(reference_wrapper< _Functor > __f) noexcept
void swap(function &__x)
Swap the targets of two function objects.
Determines if the given type _Tp is a placeholder in a bind() expression and, if so, which placeholder it is. [TR1 3.6.2].
Base class for all library exceptions.
reference_wrapper< const _Tp > cref(const _Tp &__t) noexcept
Denotes a const reference should be taken to a variable.
reference_wrapper< _Tp > ref(_Tp &__t) noexcept
Denotes a reference should be taken to a variable.
_Tp * __addressof(_Tp &__r) noexcept
Same as C++11 std::addressof.
Base class of all polymorphic function object wrappers.
_Mem_fn< _Tp _Class::* > mem_fn(_Tp _Class::*) noexcept
Returns a function object that forwards to the member pointer pm.
Exception class thrown when class template function's operator() is called with an empty target...
Type of the function object returned from bind().
If we have found a result_type, extract it.
function & operator=(const function &__x)
Function assignment operator.
function & operator=(nullptr_t) noexcept
Function assignment to zero.
const char * what() const noexcept