00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030 namespace std
00031 {
00032 _GLIBCXX_BEGIN_NAMESPACE_TR1
00033
00034 template<typename _MemberPointer>
00035 class _Mem_fn;
00036
00037
00038
00039
00040
00041
00042 template<typename _Tp>
00043 class _Has_result_type_helper : __sfinae_types
00044 {
00045 template<typename _Up>
00046 struct _Wrap_type
00047 { };
00048
00049 template<typename _Up>
00050 static __one __test(_Wrap_type<typename _Up::result_type>*);
00051
00052 template<typename _Up>
00053 static __two __test(...);
00054
00055 public:
00056 static const bool value = sizeof(__test<_Tp>(0)) == 1;
00057 };
00058
00059 template<typename _Tp>
00060 struct _Has_result_type
00061 : integral_constant<bool,
00062 _Has_result_type_helper<typename remove_cv<_Tp>::type>::value>
00063 { };
00064
00065
00066
00067
00068
00069 template<bool _Has_result_type, typename _Functor>
00070 struct _Maybe_get_result_type
00071 { };
00072
00073 template<typename _Functor>
00074 struct _Maybe_get_result_type<true, _Functor>
00075 {
00076 typedef typename _Functor::result_type result_type;
00077 };
00078
00079
00080
00081
00082
00083 template<typename _Functor>
00084 struct _Weak_result_type_impl
00085 : _Maybe_get_result_type<_Has_result_type<_Functor>::value, _Functor>
00086 {
00087 };
00088
00089
00090 template<typename _Res, typename... _ArgTypes>
00091 struct _Weak_result_type_impl<_Res(_ArgTypes...)>
00092 {
00093 typedef _Res result_type;
00094 };
00095
00096
00097 template<typename _Res, typename... _ArgTypes>
00098 struct _Weak_result_type_impl<_Res(&)(_ArgTypes...)>
00099 {
00100 typedef _Res result_type;
00101 };
00102
00103
00104 template<typename _Res, typename... _ArgTypes>
00105 struct _Weak_result_type_impl<_Res(*)(_ArgTypes...)>
00106 {
00107 typedef _Res result_type;
00108 };
00109
00110
00111 template<typename _Res, typename _Class, typename... _ArgTypes>
00112 struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...)>
00113 {
00114 typedef _Res result_type;
00115 };
00116
00117
00118 template<typename _Res, typename _Class, typename... _ArgTypes>
00119 struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...) const>
00120 {
00121 typedef _Res result_type;
00122 };
00123
00124
00125 template<typename _Res, typename _Class, typename... _ArgTypes>
00126 struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...) volatile>
00127 {
00128 typedef _Res result_type;
00129 };
00130
00131
00132 template<typename _Res, typename _Class, typename... _ArgTypes>
00133 struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...)const volatile>
00134 {
00135 typedef _Res result_type;
00136 };
00137
00138
00139
00140
00141
00142 template<typename _Functor>
00143 struct _Weak_result_type
00144 : _Weak_result_type_impl<typename remove_cv<_Functor>::type>
00145 {
00146 };
00147
00148 template<typename _Signature>
00149 class result_of;
00150
00151
00152
00153
00154
00155
00156
00157 template<bool _Has_result_type, typename _Signature>
00158 struct _Result_of_impl;
00159
00160
00161 template<typename _Res, typename _Class, typename _T1>
00162 struct _Result_of_impl<false, _Res _Class::*(_T1)>
00163 {
00164 typedef typename _Mem_fn<_Res _Class::*>
00165 ::template _Result_type<_T1>::type type;
00166 };
00167
00168
00169
00170
00171
00172 template<typename _Functor, typename... _ArgTypes>
00173 class result_of<_Functor(_ArgTypes...)>
00174 : public _Result_of_impl<
00175 _Has_result_type<_Weak_result_type<_Functor> >::value,
00176 _Functor(_ArgTypes...)>
00177 {
00178 };
00179
00180
00181 template<typename _Functor, typename... _ArgTypes>
00182 struct _Result_of_impl<true, _Functor(_ArgTypes...)>
00183 {
00184 typedef typename _Weak_result_type<_Functor>::result_type type;
00185 };
00186
00187
00188
00189
00190
00191 template<typename _Functor, typename... _ArgTypes>
00192 struct _Result_of_impl<false, _Functor(_ArgTypes...)>
00193 {
00194 typedef typename _Functor
00195 ::template result<_Functor(_ArgTypes...)>::type type;
00196 };
00197
00198
00199
00200
00201
00202 template<typename _Functor>
00203 struct _Result_of_impl<false, _Functor()>
00204 {
00205 typedef void type;
00206 };
00207
00208
00209 template<typename _Tp>
00210 struct _Derives_from_unary_function : __sfinae_types
00211 {
00212 private:
00213 template<typename _T1, typename _Res>
00214 static __one __test(const volatile unary_function<_T1, _Res>*);
00215
00216
00217
00218 static __two __test(...);
00219
00220 public:
00221 static const bool value = sizeof(__test((_Tp*)0)) == 1;
00222 };
00223
00224
00225 template<typename _Tp>
00226 struct _Derives_from_binary_function : __sfinae_types
00227 {
00228 private:
00229 template<typename _T1, typename _T2, typename _Res>
00230 static __one __test(const volatile binary_function<_T1, _T2, _Res>*);
00231
00232
00233
00234 static __two __test(...);
00235
00236 public:
00237 static const bool value = sizeof(__test((_Tp*)0)) == 1;
00238 };
00239
00240
00241 template<typename _Tp, bool _IsFunctionType = is_function<_Tp>::value>
00242 struct _Function_to_function_pointer
00243 {
00244 typedef _Tp type;
00245 };
00246
00247 template<typename _Tp>
00248 struct _Function_to_function_pointer<_Tp, true>
00249 {
00250 typedef _Tp* type;
00251 };
00252
00253
00254
00255
00256
00257 template<typename _Functor, typename... _Args>
00258 inline
00259 typename __gnu_cxx::__enable_if<
00260 (!is_member_pointer<_Functor>::value
00261 && !is_function<_Functor>::value
00262 && !is_function<typename remove_pointer<_Functor>::type>::value),
00263 typename result_of<_Functor(_Args...)>::type
00264 >::__type
00265 __invoke(_Functor& __f, _Args&... __args)
00266 {
00267 return __f(__args...);
00268 }
00269
00270 template<typename _Functor, typename... _Args>
00271 inline
00272 typename __gnu_cxx::__enable_if<
00273 (is_member_pointer<_Functor>::value
00274 && !is_function<_Functor>::value
00275 && !is_function<typename remove_pointer<_Functor>::type>::value),
00276 typename result_of<_Functor(_Args...)>::type
00277 >::__type
00278 __invoke(_Functor& __f, _Args&... __args)
00279 {
00280 return mem_fn(__f)(__args...);
00281 }
00282
00283
00284 template<typename _Functor, typename... _Args>
00285 inline
00286 typename __gnu_cxx::__enable_if<
00287 (is_pointer<_Functor>::value
00288 && is_function<typename remove_pointer<_Functor>::type>::value),
00289 typename result_of<_Functor(_Args...)>::type
00290 >::__type
00291 __invoke(_Functor __f, _Args&... __args)
00292 {
00293 return __f(__args...);
00294 }
00295
00296
00297
00298
00299
00300
00301 template<bool _Unary, bool _Binary, typename _Tp>
00302 struct _Reference_wrapper_base_impl;
00303
00304
00305 template<typename _Tp>
00306 struct _Reference_wrapper_base_impl<false, false, _Tp>
00307 : _Weak_result_type<_Tp>
00308 { };
00309
00310
00311 template<typename _Tp>
00312 struct _Reference_wrapper_base_impl<true, false, _Tp>
00313 : unary_function<typename _Tp::argument_type,
00314 typename _Tp::result_type>
00315 { };
00316
00317
00318 template<typename _Tp>
00319 struct _Reference_wrapper_base_impl<false, true, _Tp>
00320 : binary_function<typename _Tp::first_argument_type,
00321 typename _Tp::second_argument_type,
00322 typename _Tp::result_type>
00323 { };
00324
00325
00326
00327 template<typename _Tp>
00328 struct _Reference_wrapper_base_impl<true, true, _Tp>
00329 : unary_function<typename _Tp::argument_type,
00330 typename _Tp::result_type>,
00331 binary_function<typename _Tp::first_argument_type,
00332 typename _Tp::second_argument_type,
00333 typename _Tp::result_type>
00334 {
00335 typedef typename _Tp::result_type result_type;
00336 };
00337
00338
00339
00340
00341
00342
00343
00344 template<typename _Tp>
00345 struct _Reference_wrapper_base
00346 : _Reference_wrapper_base_impl<
00347 _Derives_from_unary_function<_Tp>::value,
00348 _Derives_from_binary_function<_Tp>::value,
00349 _Tp>
00350 { };
00351
00352
00353 template<typename _Res, typename _T1>
00354 struct _Reference_wrapper_base<_Res(_T1)>
00355 : unary_function<_T1, _Res>
00356 { };
00357
00358
00359 template<typename _Res, typename _T1, typename _T2>
00360 struct _Reference_wrapper_base<_Res(_T1, _T2)>
00361 : binary_function<_T1, _T2, _Res>
00362 { };
00363
00364
00365 template<typename _Res, typename _T1>
00366 struct _Reference_wrapper_base<_Res(*)(_T1)>
00367 : unary_function<_T1, _Res>
00368 { };
00369
00370
00371 template<typename _Res, typename _T1, typename _T2>
00372 struct _Reference_wrapper_base<_Res(*)(_T1, _T2)>
00373 : binary_function<_T1, _T2, _Res>
00374 { };
00375
00376
00377 template<typename _Res, typename _T1>
00378 struct _Reference_wrapper_base<_Res (_T1::*)()>
00379 : unary_function<_T1*, _Res>
00380 { };
00381
00382
00383 template<typename _Res, typename _T1, typename _T2>
00384 struct _Reference_wrapper_base<_Res (_T1::*)(_T2)>
00385 : binary_function<_T1*, _T2, _Res>
00386 { };
00387
00388
00389 template<typename _Res, typename _T1>
00390 struct _Reference_wrapper_base<_Res (_T1::*)() const>
00391 : unary_function<const _T1*, _Res>
00392 { };
00393
00394
00395 template<typename _Res, typename _T1, typename _T2>
00396 struct _Reference_wrapper_base<_Res (_T1::*)(_T2) const>
00397 : binary_function<const _T1*, _T2, _Res>
00398 { };
00399
00400
00401 template<typename _Res, typename _T1>
00402 struct _Reference_wrapper_base<_Res (_T1::*)() volatile>
00403 : unary_function<volatile _T1*, _Res>
00404 { };
00405
00406
00407 template<typename _Res, typename _T1, typename _T2>
00408 struct _Reference_wrapper_base<_Res (_T1::*)(_T2) volatile>
00409 : binary_function<volatile _T1*, _T2, _Res>
00410 { };
00411
00412
00413 template<typename _Res, typename _T1>
00414 struct _Reference_wrapper_base<_Res (_T1::*)() const volatile>
00415 : unary_function<const volatile _T1*, _Res>
00416 { };
00417
00418
00419 template<typename _Res, typename _T1, typename _T2>
00420 struct _Reference_wrapper_base<_Res (_T1::*)(_T2) const volatile>
00421 : binary_function<const volatile _T1*, _T2, _Res>
00422 { };
00423
00424
00425 template<typename _Tp>
00426 class reference_wrapper
00427 : public _Reference_wrapper_base<typename remove_cv<_Tp>::type>
00428 {
00429
00430
00431 typedef typename _Function_to_function_pointer<_Tp>::type
00432 _M_func_type;
00433
00434 _Tp* _M_data;
00435 public:
00436 typedef _Tp type;
00437
00438 explicit
00439 reference_wrapper(_Tp& __indata): _M_data(&__indata)
00440 { }
00441
00442 reference_wrapper(const reference_wrapper<_Tp>& __inref):
00443 _M_data(__inref._M_data)
00444 { }
00445
00446 reference_wrapper&
00447 operator=(const reference_wrapper<_Tp>& __inref)
00448 {
00449 _M_data = __inref._M_data;
00450 return *this;
00451 }
00452
00453 operator _Tp&() const
00454 { return this->get(); }
00455
00456 _Tp&
00457 get() const
00458 { return *_M_data; }
00459
00460 template<typename... _Args>
00461 typename result_of<_M_func_type(_Args...)>::type
00462 operator()(_Args&... __args) const
00463 {
00464 return __invoke(get(), __args...);
00465 }
00466 };
00467
00468
00469
00470 template<typename _Tp>
00471 inline reference_wrapper<_Tp>
00472 ref(_Tp& __t)
00473 { return reference_wrapper<_Tp>(__t); }
00474
00475
00476 template<typename _Tp>
00477 inline reference_wrapper<const _Tp>
00478 cref(const _Tp& __t)
00479 { return reference_wrapper<const _Tp>(__t); }
00480
00481 template<typename _Tp>
00482 inline reference_wrapper<_Tp>
00483 ref(reference_wrapper<_Tp> __t)
00484 { return ref(__t.get()); }
00485
00486 template<typename _Tp>
00487 inline reference_wrapper<const _Tp>
00488 cref(reference_wrapper<_Tp> __t)
00489 { return cref(__t.get()); }
00490
00491 template<typename _Tp, bool>
00492 struct _Mem_fn_const_or_non
00493 {
00494 typedef const _Tp& type;
00495 };
00496
00497 template<typename _Tp>
00498 struct _Mem_fn_const_or_non<_Tp, false>
00499 {
00500 typedef _Tp& type;
00501 };
00502
00503
00504
00505
00506
00507
00508 template<typename _Res, typename... _ArgTypes>
00509 struct _Maybe_unary_or_binary_function { };
00510
00511
00512 template<typename _Res, typename _T1>
00513 struct _Maybe_unary_or_binary_function<_Res, _T1>
00514 : std::unary_function<_T1, _Res> { };
00515
00516
00517 template<typename _Res, typename _T1, typename _T2>
00518 struct _Maybe_unary_or_binary_function<_Res, _T1, _T2>
00519 : std::binary_function<_T1, _T2, _Res> { };
00520
00521
00522 template<typename _Res, typename _Class, typename... _ArgTypes>
00523 class _Mem_fn<_Res (_Class::*)(_ArgTypes...)>
00524 : public _Maybe_unary_or_binary_function<_Res, _Class*, _ArgTypes...>
00525 {
00526 typedef _Res (_Class::*_Functor)(_ArgTypes...);
00527
00528 template<typename _Tp>
00529 _Res
00530 _M_call(_Tp& __object, const volatile _Class *,
00531 _ArgTypes... __args) const
00532 { return (__object.*__pmf)(__args...); }
00533
00534 template<typename _Tp>
00535 _Res
00536 _M_call(_Tp& __ptr, const volatile void *, _ArgTypes... __args) const
00537 { return ((*__ptr).*__pmf)(__args...); }
00538
00539 public:
00540 typedef _Res result_type;
00541
00542 explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { }
00543
00544
00545 _Res
00546 operator()(_Class& __object, _ArgTypes... __args) const
00547 { return (__object.*__pmf)(__args...); }
00548
00549
00550 _Res
00551 operator()(_Class* __object, _ArgTypes... __args) const
00552 { return (__object->*__pmf)(__args...); }
00553
00554
00555 template<typename _Tp>
00556 _Res
00557 operator()(_Tp& __object, _ArgTypes... __args) const
00558 { return _M_call(__object, &__object, __args...); }
00559
00560 private:
00561 _Functor __pmf;
00562 };
00563
00564
00565 template<typename _Res, typename _Class, typename... _ArgTypes>
00566 class _Mem_fn<_Res (_Class::*)(_ArgTypes...) const>
00567 : public _Maybe_unary_or_binary_function<_Res, const _Class*,
00568 _ArgTypes...>
00569 {
00570 typedef _Res (_Class::*_Functor)(_ArgTypes...) const;
00571
00572 template<typename _Tp>
00573 _Res
00574 _M_call(_Tp& __object, const volatile _Class *,
00575 _ArgTypes... __args) const
00576 { return (__object.*__pmf)(__args...); }
00577
00578 template<typename _Tp>
00579 _Res
00580 _M_call(_Tp& __ptr, const volatile void *, _ArgTypes... __args) const
00581 { return ((*__ptr).*__pmf)(__args...); }
00582
00583 public:
00584 typedef _Res result_type;
00585
00586 explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { }
00587
00588
00589 _Res
00590 operator()(const _Class& __object, _ArgTypes... __args) const
00591 { return (__object.*__pmf)(__args...); }
00592
00593
00594 _Res
00595 operator()(const _Class* __object, _ArgTypes... __args) const
00596 { return (__object->*__pmf)(__args...); }
00597
00598
00599 template<typename _Tp>
00600 _Res operator()(_Tp& __object, _ArgTypes... __args) const
00601 { return _M_call(__object, &__object, __args...); }
00602
00603 private:
00604 _Functor __pmf;
00605 };
00606
00607
00608 template<typename _Res, typename _Class, typename... _ArgTypes>
00609 class _Mem_fn<_Res (_Class::*)(_ArgTypes...) volatile>
00610 : public _Maybe_unary_or_binary_function<_Res, volatile _Class*,
00611 _ArgTypes...>
00612 {
00613 typedef _Res (_Class::*_Functor)(_ArgTypes...) volatile;
00614
00615 template<typename _Tp>
00616 _Res
00617 _M_call(_Tp& __object, const volatile _Class *,
00618 _ArgTypes... __args) const
00619 { return (__object.*__pmf)(__args...); }
00620
00621 template<typename _Tp>
00622 _Res
00623 _M_call(_Tp& __ptr, const volatile void *, _ArgTypes... __args) const
00624 { return ((*__ptr).*__pmf)(__args...); }
00625
00626 public:
00627 typedef _Res result_type;
00628
00629 explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { }
00630
00631
00632 _Res
00633 operator()(volatile _Class& __object, _ArgTypes... __args) const
00634 { return (__object.*__pmf)(__args...); }
00635
00636
00637 _Res
00638 operator()(volatile _Class* __object, _ArgTypes... __args) const
00639 { return (__object->*__pmf)(__args...); }
00640
00641
00642 template<typename _Tp>
00643 _Res
00644 operator()(_Tp& __object, _ArgTypes... __args) const
00645 { return _M_call(__object, &__object, __args...); }
00646
00647 private:
00648 _Functor __pmf;
00649 };
00650
00651
00652 template<typename _Res, typename _Class, typename... _ArgTypes>
00653 class _Mem_fn<_Res (_Class::*)(_ArgTypes...) const volatile>
00654 : public _Maybe_unary_or_binary_function<_Res, const volatile _Class*,
00655 _ArgTypes...>
00656 {
00657 typedef _Res (_Class::*_Functor)(_ArgTypes...) const volatile;
00658
00659 template<typename _Tp>
00660 _Res
00661 _M_call(_Tp& __object, const volatile _Class *,
00662 _ArgTypes... __args) const
00663 { return (__object.*__pmf)(__args...); }
00664
00665 template<typename _Tp>
00666 _Res
00667 _M_call(_Tp& __ptr, const volatile void *, _ArgTypes... __args) const
00668 { return ((*__ptr).*__pmf)(__args...); }
00669
00670 public:
00671 typedef _Res result_type;
00672
00673 explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { }
00674
00675
00676 _Res
00677 operator()(const volatile _Class& __object, _ArgTypes... __args) const
00678 { return (__object.*__pmf)(__args...); }
00679
00680
00681 _Res
00682 operator()(const volatile _Class* __object, _ArgTypes... __args) const
00683 { return (__object->*__pmf)(__args...); }
00684
00685
00686 template<typename _Tp>
00687 _Res operator()(_Tp& __object, _ArgTypes... __args) const
00688 { return _M_call(__object, &__object, __args...); }
00689
00690 private:
00691 _Functor __pmf;
00692 };
00693
00694
00695 template<typename _Res, typename _Class>
00696 class _Mem_fn<_Res _Class::*>
00697 {
00698
00699
00700 template<typename _Tp>
00701 _Res&
00702 _M_call(_Tp& __object, _Class *) const
00703 { return __object.*__pm; }
00704
00705 template<typename _Tp, typename _Up>
00706 _Res&
00707 _M_call(_Tp& __object, _Up * const *) const
00708 { return (*__object).*__pm; }
00709
00710 template<typename _Tp, typename _Up>
00711 const _Res&
00712 _M_call(_Tp& __object, const _Up * const *) const
00713 { return (*__object).*__pm; }
00714
00715 template<typename _Tp>
00716 const _Res&
00717 _M_call(_Tp& __object, const _Class *) const
00718 { return __object.*__pm; }
00719
00720 template<typename _Tp>
00721 const _Res&
00722 _M_call(_Tp& __ptr, const volatile void*) const
00723 { return (*__ptr).*__pm; }
00724
00725 template<typename _Tp> static _Tp& __get_ref();
00726
00727 template<typename _Tp>
00728 static __sfinae_types::__one __check_const(_Tp&, _Class*);
00729 template<typename _Tp, typename _Up>
00730 static __sfinae_types::__one __check_const(_Tp&, _Up * const *);
00731 template<typename _Tp, typename _Up>
00732 static __sfinae_types::__two __check_const(_Tp&, const _Up * const *);
00733 template<typename _Tp>
00734 static __sfinae_types::__two __check_const(_Tp&, const _Class*);
00735 template<typename _Tp>
00736 static __sfinae_types::__two __check_const(_Tp&, const volatile void*);
00737
00738 public:
00739 template<typename _Tp>
00740 struct _Result_type
00741 : _Mem_fn_const_or_non<_Res,
00742 (sizeof(__sfinae_types::__two)
00743 == sizeof(__check_const<_Tp>(__get_ref<_Tp>(), (_Tp*)0)))>
00744 { };
00745
00746 template<typename _Signature>
00747 struct result;
00748
00749 template<typename _CVMem, typename _Tp>
00750 struct result<_CVMem(_Tp)>
00751 : public _Result_type<_Tp> { };
00752
00753 template<typename _CVMem, typename _Tp>
00754 struct result<_CVMem(_Tp&)>
00755 : public _Result_type<_Tp> { };
00756
00757 explicit
00758 _Mem_fn(_Res _Class::*__pm) : __pm(__pm) { }
00759
00760
00761 _Res&
00762 operator()(_Class& __object) const
00763 { return __object.*__pm; }
00764
00765 const _Res&
00766 operator()(const _Class& __object) const
00767 { return __object.*__pm; }
00768
00769
00770 _Res&
00771 operator()(_Class* __object) const
00772 { return __object->*__pm; }
00773
00774 const _Res&
00775 operator()(const _Class* __object) const
00776 { return __object->*__pm; }
00777
00778
00779 template<typename _Tp>
00780 typename _Result_type<_Tp>::type
00781 operator()(_Tp& __unknown) const
00782 { return _M_call(__unknown, &__unknown); }
00783
00784 private:
00785 _Res _Class::*__pm;
00786 };
00787
00788
00789
00790
00791
00792 template<typename _Tp, typename _Class>
00793 inline _Mem_fn<_Tp _Class::*>
00794 mem_fn(_Tp _Class::* __pm)
00795 {
00796 return _Mem_fn<_Tp _Class::*>(__pm);
00797 }
00798
00799
00800
00801
00802
00803
00804 template<typename _Tp>
00805 struct is_bind_expression
00806 { static const bool value = false; };
00807
00808 template<typename _Tp>
00809 const bool is_bind_expression<_Tp>::value;
00810
00811
00812
00813
00814
00815 template<typename _Tp>
00816 struct is_placeholder
00817 { static const int value = 0; };
00818
00819 template<typename _Tp>
00820 const int is_placeholder<_Tp>::value;
00821
00822
00823 template<int _Num> struct _Placeholder { };
00824
00825
00826
00827
00828
00829
00830
00831
00832 namespace placeholders
00833 {
00834 namespace
00835 {
00836 _Placeholder<1> _1;
00837 _Placeholder<2> _2;
00838 _Placeholder<3> _3;
00839 _Placeholder<4> _4;
00840 _Placeholder<5> _5;
00841 _Placeholder<6> _6;
00842 _Placeholder<7> _7;
00843 _Placeholder<8> _8;
00844 _Placeholder<9> _9;
00845 _Placeholder<10> _10;
00846 _Placeholder<11> _11;
00847 _Placeholder<12> _12;
00848 _Placeholder<13> _13;
00849 _Placeholder<14> _14;
00850 _Placeholder<15> _15;
00851 _Placeholder<16> _16;
00852 _Placeholder<17> _17;
00853 _Placeholder<18> _18;
00854 _Placeholder<19> _19;
00855 _Placeholder<20> _20;
00856 _Placeholder<21> _21;
00857 _Placeholder<22> _22;
00858 _Placeholder<23> _23;
00859 _Placeholder<24> _24;
00860 _Placeholder<25> _25;
00861 _Placeholder<26> _26;
00862 _Placeholder<27> _27;
00863 _Placeholder<28> _28;
00864 _Placeholder<29> _29;
00865 }
00866 }
00867
00868
00869
00870
00871
00872 template<int _Num>
00873 struct is_placeholder<_Placeholder<_Num> >
00874 { static const int value = _Num; };
00875
00876 template<int _Num>
00877 const int is_placeholder<_Placeholder<_Num> >::value;
00878
00879
00880
00881
00882
00883 template<int... _Indexes>
00884 struct _Index_tuple { };
00885
00886
00887 template<std::size_t _Num, typename _Tuple = _Index_tuple<> >
00888 struct _Build_index_tuple;
00889
00890 template<std::size_t _Num, int... _Indexes>
00891 struct _Build_index_tuple<_Num, _Index_tuple<_Indexes...> >
00892 : _Build_index_tuple<_Num - 1,
00893 _Index_tuple<_Indexes..., sizeof...(_Indexes)> >
00894 {
00895 };
00896
00897 template<int... _Indexes>
00898 struct _Build_index_tuple<0, _Index_tuple<_Indexes...> >
00899 {
00900 typedef _Index_tuple<_Indexes...> __type;
00901 };
00902
00903
00904
00905
00906
00907 struct _No_tuple_element;
00908
00909
00910
00911
00912
00913
00914 template<int __i, typename _Tuple, bool _IsSafe>
00915 struct _Safe_tuple_element_impl
00916 : tuple_element<__i, _Tuple> { };
00917
00918
00919
00920
00921
00922
00923 template<int __i, typename _Tuple>
00924 struct _Safe_tuple_element_impl<__i, _Tuple, false>
00925 {
00926 typedef _No_tuple_element type;
00927 };
00928
00929
00930
00931
00932
00933 template<int __i, typename _Tuple>
00934 struct _Safe_tuple_element
00935 : _Safe_tuple_element_impl<__i, _Tuple,
00936 (__i >= 0 && __i < tuple_size<_Tuple>::value)>
00937 {
00938 };
00939
00940
00941
00942
00943
00944
00945
00946
00947
00948
00949
00950
00951 template<typename _Arg,
00952 bool _IsBindExp = is_bind_expression<_Arg>::value,
00953 bool _IsPlaceholder = (is_placeholder<_Arg>::value > 0)>
00954 class _Mu;
00955
00956
00957
00958
00959
00960 template<typename _Tp>
00961 class _Mu<reference_wrapper<_Tp>, false, false>
00962 {
00963 public:
00964 typedef _Tp& result_type;
00965
00966
00967
00968
00969
00970 template<typename _CVRef, typename _Tuple>
00971 result_type
00972 operator()(_CVRef& __arg, const _Tuple&) const volatile
00973 { return __arg.get(); }
00974 };
00975
00976
00977
00978
00979
00980
00981 template<typename _Arg>
00982 class _Mu<_Arg, true, false>
00983 {
00984 public:
00985 template<typename _Signature> class result;
00986
00987
00988
00989
00990 template<typename _CVMu, typename _CVArg, typename... _Args>
00991 class result<_CVMu(_CVArg, tuple<_Args...>)>
00992 : public result_of<_CVArg(_Args...)> { };
00993
00994 template<typename _CVArg, typename... _Args>
00995 typename result_of<_CVArg(_Args...)>::type
00996 operator()(_CVArg& __arg,
00997 const tuple<_Args...>& __tuple) const volatile
00998 {
00999
01000 typedef typename _Build_index_tuple<sizeof...(_Args)>::__type
01001 _Indexes;
01002 return this->__call(__arg, __tuple, _Indexes());
01003 }
01004
01005 private:
01006
01007
01008 template<typename _CVArg, typename... _Args, int... _Indexes>
01009 typename result_of<_CVArg(_Args...)>::type
01010 __call(_CVArg& __arg, const tuple<_Args...>& __tuple,
01011 const _Index_tuple<_Indexes...>&) const volatile
01012 {
01013 return __arg(_GLIBCXX_TR1 get<_Indexes>(__tuple)...);
01014 }
01015 };
01016
01017
01018
01019
01020
01021
01022 template<typename _Arg>
01023 class _Mu<_Arg, false, true>
01024 {
01025 public:
01026 template<typename _Signature> class result;
01027
01028 template<typename _CVMu, typename _CVArg, typename _Tuple>
01029 class result<_CVMu(_CVArg, _Tuple)>
01030 {
01031
01032
01033
01034 typedef typename _Safe_tuple_element<(is_placeholder<_Arg>::value
01035 - 1), _Tuple>::type
01036 __base_type;
01037
01038 public:
01039 #ifdef _GLIBCXX_INCLUDE_AS_CXX0X
01040 typedef typename add_lvalue_reference<__base_type>::type type;
01041 #else
01042 typedef typename add_reference<__base_type>::type type;
01043 #endif
01044 };
01045
01046 template<typename _Tuple>
01047 typename result<_Mu(_Arg, _Tuple)>::type
01048 operator()(const volatile _Arg&, const _Tuple& __tuple) const volatile
01049 {
01050 return ::std::_GLIBCXX_TR1 get<(is_placeholder<_Arg>::value
01051 - 1)>(__tuple);
01052 }
01053 };
01054
01055
01056
01057
01058
01059
01060 template<typename _Arg>
01061 class _Mu<_Arg, false, false>
01062 {
01063 public:
01064 template<typename _Signature> struct result;
01065
01066 template<typename _CVMu, typename _CVArg, typename _Tuple>
01067 struct result<_CVMu(_CVArg, _Tuple)>
01068 {
01069 #ifdef _GLIBCXX_INCLUDE_AS_CXX0X
01070 typedef typename add_lvalue_reference<_CVArg>::type type;
01071 #else
01072 typedef typename add_reference<_CVArg>::type type;
01073 #endif
01074 };
01075
01076
01077 template<typename _CVArg, typename _Tuple>
01078 _CVArg&
01079 operator()(_CVArg& __arg, const _Tuple&) const volatile
01080 { return __arg; }
01081 };
01082
01083
01084
01085
01086
01087
01088 template<typename _Tp>
01089 struct _Maybe_wrap_member_pointer
01090 {
01091 typedef _Tp type;
01092
01093 static const _Tp&
01094 __do_wrap(const _Tp& __x)
01095 { return __x; }
01096 };
01097
01098
01099
01100
01101
01102
01103 template<typename _Tp, typename _Class>
01104 struct _Maybe_wrap_member_pointer<_Tp _Class::*>
01105 {
01106 typedef _Mem_fn<_Tp _Class::*> type;
01107
01108 static type
01109 __do_wrap(_Tp _Class::* __pm)
01110 { return type(__pm); }
01111 };
01112
01113
01114 template<typename _Signature>
01115 struct _Bind;
01116
01117 template<typename _Functor, typename... _Bound_args>
01118 class _Bind<_Functor(_Bound_args...)>
01119 : public _Weak_result_type<_Functor>
01120 {
01121 typedef _Bind __self_type;
01122 typedef typename _Build_index_tuple<sizeof...(_Bound_args)>::__type
01123 _Bound_indexes;
01124
01125 _Functor _M_f;
01126 tuple<_Bound_args...> _M_bound_args;
01127
01128
01129 template<typename... _Args, int... _Indexes>
01130 typename result_of<
01131 _Functor(typename result_of<_Mu<_Bound_args>
01132 (_Bound_args, tuple<_Args...>)>::type...)
01133 >::type
01134 __call(const tuple<_Args...>& __args, _Index_tuple<_Indexes...>)
01135 {
01136 return _M_f(_Mu<_Bound_args>()
01137 (_GLIBCXX_TR1 get<_Indexes>(_M_bound_args), __args)...);
01138 }
01139
01140
01141 template<typename... _Args, int... _Indexes>
01142 typename result_of<
01143 const _Functor(typename result_of<_Mu<_Bound_args>
01144 (const _Bound_args, tuple<_Args...>)
01145 >::type...)>::type
01146 __call(const tuple<_Args...>& __args, _Index_tuple<_Indexes...>) const
01147 {
01148 return _M_f(_Mu<_Bound_args>()
01149 (_GLIBCXX_TR1 get<_Indexes>(_M_bound_args), __args)...);
01150 }
01151
01152
01153 template<typename... _Args, int... _Indexes>
01154 typename result_of<
01155 volatile _Functor(typename result_of<_Mu<_Bound_args>
01156 (volatile _Bound_args, tuple<_Args...>)
01157 >::type...)>::type
01158 __call(const tuple<_Args...>& __args,
01159 _Index_tuple<_Indexes...>) volatile
01160 {
01161 return _M_f(_Mu<_Bound_args>()
01162 (_GLIBCXX_TR1 get<_Indexes>(_M_bound_args), __args)...);
01163 }
01164
01165
01166 template<typename... _Args, int... _Indexes>
01167 typename result_of<
01168 const volatile _Functor(typename result_of<_Mu<_Bound_args>
01169 (const volatile _Bound_args,
01170 tuple<_Args...>)
01171 >::type...)>::type
01172 __call(const tuple<_Args...>& __args,
01173 _Index_tuple<_Indexes...>) const volatile
01174 {
01175 return _M_f(_Mu<_Bound_args>()
01176 (_GLIBCXX_TR1 get<_Indexes>(_M_bound_args), __args)...);
01177 }
01178
01179 public:
01180 explicit _Bind(_Functor __f, _Bound_args... __bound_args)
01181 : _M_f(__f), _M_bound_args(__bound_args...) { }
01182
01183
01184 template<typename... _Args>
01185 typename result_of<
01186 _Functor(typename result_of<_Mu<_Bound_args>
01187 (_Bound_args, tuple<_Args...>)>::type...)
01188 >::type
01189 operator()(_Args&... __args)
01190 {
01191 return this->__call(_GLIBCXX_TR1 tie(__args...), _Bound_indexes());
01192 }
01193
01194
01195 template<typename... _Args>
01196 typename result_of<
01197 const _Functor(typename result_of<_Mu<_Bound_args>
01198 (const _Bound_args, tuple<_Args...>)>::type...)
01199 >::type
01200 operator()(_Args&... __args) const
01201 {
01202 return this->__call(_GLIBCXX_TR1 tie(__args...), _Bound_indexes());
01203 }
01204
01205
01206
01207 template<typename... _Args>
01208 typename result_of<
01209 volatile _Functor(typename result_of<_Mu<_Bound_args>
01210 (volatile _Bound_args, tuple<_Args...>)>::type...)
01211 >::type
01212 operator()(_Args&... __args) volatile
01213 {
01214 return this->__call(_GLIBCXX_TR1 tie(__args...), _Bound_indexes());
01215 }
01216
01217
01218
01219 template<typename... _Args>
01220 typename result_of<
01221 const volatile _Functor(typename result_of<_Mu<_Bound_args>
01222 (const volatile _Bound_args,
01223 tuple<_Args...>)>::type...)
01224 >::type
01225 operator()(_Args&... __args) const volatile
01226 {
01227 return this->__call(_GLIBCXX_TR1 tie(__args...), _Bound_indexes());
01228 }
01229 };
01230
01231
01232 template<typename _Result, typename _Signature>
01233 struct _Bind_result;
01234
01235 template<typename _Result, typename _Functor, typename... _Bound_args>
01236 class _Bind_result<_Result, _Functor(_Bound_args...)>
01237 {
01238 typedef _Bind_result __self_type;
01239 typedef typename _Build_index_tuple<sizeof...(_Bound_args)>::__type
01240 _Bound_indexes;
01241
01242 _Functor _M_f;
01243 tuple<_Bound_args...> _M_bound_args;
01244
01245
01246 template<typename... _Args, int... _Indexes>
01247 _Result
01248 __call(const tuple<_Args...>& __args, _Index_tuple<_Indexes...>)
01249 {
01250 return _M_f(_Mu<_Bound_args>()
01251 (_GLIBCXX_TR1 get<_Indexes>(_M_bound_args), __args)...);
01252 }
01253
01254
01255 template<typename... _Args, int... _Indexes>
01256 _Result
01257 __call(const tuple<_Args...>& __args, _Index_tuple<_Indexes...>) const
01258 {
01259 return _M_f(_Mu<_Bound_args>()
01260 (_GLIBCXX_TR1 get<_Indexes>(_M_bound_args), __args)...);
01261 }
01262
01263
01264 template<typename... _Args, int... _Indexes>
01265 _Result
01266 __call(const tuple<_Args...>& __args,
01267 _Index_tuple<_Indexes...>) volatile
01268 {
01269 return _M_f(_Mu<_Bound_args>()
01270 (_GLIBCXX_TR1 get<_Indexes>(_M_bound_args), __args)...);
01271 }
01272
01273
01274 template<typename... _Args, int... _Indexes>
01275 _Result
01276 __call(const tuple<_Args...>& __args,
01277 _Index_tuple<_Indexes...>) const volatile
01278 {
01279 return _M_f(_Mu<_Bound_args>()
01280 (_GLIBCXX_TR1 get<_Indexes>(_M_bound_args), __args)...);
01281 }
01282
01283 public:
01284 typedef _Result result_type;
01285
01286 explicit
01287 _Bind_result(_Functor __f, _Bound_args... __bound_args)
01288 : _M_f(__f), _M_bound_args(__bound_args...) { }
01289
01290
01291 template<typename... _Args>
01292 result_type
01293 operator()(_Args&... __args)
01294 {
01295 return this->__call(_GLIBCXX_TR1 tie(__args...), _Bound_indexes());
01296 }
01297
01298
01299 template<typename... _Args>
01300 result_type
01301 operator()(_Args&... __args) const
01302 {
01303 return this->__call(_GLIBCXX_TR1 tie(__args...), _Bound_indexes());
01304 }
01305
01306
01307 template<typename... _Args>
01308 result_type
01309 operator()(_Args&... __args) volatile
01310 {
01311 return this->__call(_GLIBCXX_TR1 tie(__args...), _Bound_indexes());
01312 }
01313
01314
01315 template<typename... _Args>
01316 result_type
01317 operator()(_Args&... __args) const volatile
01318 {
01319 return this->__call(_GLIBCXX_TR1 tie(__args...), _Bound_indexes());
01320 }
01321 };
01322
01323
01324 template<typename _Signature>
01325 struct is_bind_expression<_Bind<_Signature> >
01326 { static const bool value = true; };
01327
01328 template<typename _Signature>
01329 const bool is_bind_expression<_Bind<_Signature> >::value;
01330
01331
01332 template<typename _Result, typename _Signature>
01333 struct is_bind_expression<_Bind_result<_Result, _Signature> >
01334 { static const bool value = true; };
01335
01336 template<typename _Result, typename _Signature>
01337 const bool is_bind_expression<_Bind_result<_Result, _Signature> >::value;
01338
01339
01340 template<typename _Functor, typename... _ArgTypes>
01341 inline
01342 _Bind<typename _Maybe_wrap_member_pointer<_Functor>::type(_ArgTypes...)>
01343 bind(_Functor __f, _ArgTypes... __args)
01344 {
01345 typedef _Maybe_wrap_member_pointer<_Functor> __maybe_type;
01346 typedef typename __maybe_type::type __functor_type;
01347 typedef _Bind<__functor_type(_ArgTypes...)> __result_type;
01348 return __result_type(__maybe_type::__do_wrap(__f), __args...);
01349 }
01350
01351 template<typename _Result, typename _Functor, typename... _ArgTypes>
01352 inline
01353 _Bind_result<_Result,
01354 typename _Maybe_wrap_member_pointer<_Functor>::type
01355 (_ArgTypes...)>
01356 bind(_Functor __f, _ArgTypes... __args)
01357 {
01358 typedef _Maybe_wrap_member_pointer<_Functor> __maybe_type;
01359 typedef typename __maybe_type::type __functor_type;
01360 typedef _Bind_result<_Result, __functor_type(_ArgTypes...)>
01361 __result_type;
01362 return __result_type(__maybe_type::__do_wrap(__f), __args...);
01363 }
01364
01365
01366
01367
01368
01369
01370 class bad_function_call : public std::exception { };
01371
01372
01373
01374
01375
01376
01377 struct _M_clear_type;
01378
01379
01380
01381
01382
01383
01384 template<typename _Tp>
01385 struct __is_location_invariant
01386 : integral_constant<bool,
01387 (is_pointer<_Tp>::value
01388 || is_member_pointer<_Tp>::value)>
01389 {
01390 };
01391
01392 class _Undefined_class;
01393
01394 union _Nocopy_types
01395 {
01396 void* _M_object;
01397 const void* _M_const_object;
01398 void (*_M_function_pointer)();
01399 void (_Undefined_class::*_M_member_pointer)();
01400 };
01401
01402 union _Any_data
01403 {
01404 void* _M_access() { return &_M_pod_data[0]; }
01405 const void* _M_access() const { return &_M_pod_data[0]; }
01406
01407 template<typename _Tp>
01408 _Tp&
01409 _M_access()
01410 { return *static_cast<_Tp*>(_M_access()); }
01411
01412 template<typename _Tp>
01413 const _Tp&
01414 _M_access() const
01415 { return *static_cast<const _Tp*>(_M_access()); }
01416
01417 _Nocopy_types _M_unused;
01418 char _M_pod_data[sizeof(_Nocopy_types)];
01419 };
01420
01421 enum _Manager_operation
01422 {
01423 __get_type_info,
01424 __get_functor_ptr,
01425 __clone_functor,
01426 __destroy_functor
01427 };
01428
01429
01430
01431 template<typename _Tp>
01432 struct _Simple_type_wrapper
01433 {
01434 _Simple_type_wrapper(_Tp __value) : __value(__value) { }
01435
01436 _Tp __value;
01437 };
01438
01439 template<typename _Tp>
01440 struct __is_location_invariant<_Simple_type_wrapper<_Tp> >
01441 : __is_location_invariant<_Tp>
01442 {
01443 };
01444
01445
01446
01447 template<typename _Functor>
01448 inline _Functor&
01449 __callable_functor(_Functor& __f)
01450 { return __f; }
01451
01452 template<typename _Member, typename _Class>
01453 inline _Mem_fn<_Member _Class::*>
01454 __callable_functor(_Member _Class::* &__p)
01455 { return mem_fn(__p); }
01456
01457 template<typename _Member, typename _Class>
01458 inline _Mem_fn<_Member _Class::*>
01459 __callable_functor(_Member _Class::* const &__p)
01460 { return mem_fn(__p); }
01461
01462 template<typename _Signature>
01463 class function;
01464
01465
01466 class _Function_base
01467 {
01468 public:
01469 static const std::size_t _M_max_size = sizeof(_Nocopy_types);
01470 static const std::size_t _M_max_align = __alignof__(_Nocopy_types);
01471
01472 template<typename _Functor>
01473 class _Base_manager
01474 {
01475 protected:
01476 static const bool __stored_locally =
01477 (__is_location_invariant<_Functor>::value
01478 && sizeof(_Functor) <= _M_max_size
01479 && __alignof__(_Functor) <= _M_max_align
01480 && (_M_max_align % __alignof__(_Functor) == 0));
01481
01482 typedef integral_constant<bool, __stored_locally> _Local_storage;
01483
01484
01485 static _Functor*
01486 _M_get_pointer(const _Any_data& __source)
01487 {
01488 const _Functor* __ptr =
01489 __stored_locally? &__source._M_access<_Functor>()
01490 : __source._M_access<_Functor*>();
01491 return const_cast<_Functor*>(__ptr);
01492 }
01493
01494
01495
01496 static void
01497 _M_clone(_Any_data& __dest, const _Any_data& __source, true_type)
01498 {
01499 new (__dest._M_access()) _Functor(__source._M_access<_Functor>());
01500 }
01501
01502
01503
01504 static void
01505 _M_clone(_Any_data& __dest, const _Any_data& __source, false_type)
01506 {
01507 __dest._M_access<_Functor*>() =
01508 new _Functor(*__source._M_access<_Functor*>());
01509 }
01510
01511
01512
01513 static void
01514 _M_destroy(_Any_data& __victim, true_type)
01515 {
01516 __victim._M_access<_Functor>().~_Functor();
01517 }
01518
01519
01520 static void
01521 _M_destroy(_Any_data& __victim, false_type)
01522 {
01523 delete __victim._M_access<_Functor*>();
01524 }
01525
01526 public:
01527 static bool
01528 _M_manager(_Any_data& __dest, const _Any_data& __source,
01529 _Manager_operation __op)
01530 {
01531 switch (__op)
01532 {
01533 #ifdef __GXX_RTTI
01534 case __get_type_info:
01535 __dest._M_access<const type_info*>() = &typeid(_Functor);
01536 break;
01537 #endif
01538 case __get_functor_ptr:
01539 __dest._M_access<_Functor*>() = _M_get_pointer(__source);
01540 break;
01541
01542 case __clone_functor:
01543 _M_clone(__dest, __source, _Local_storage());
01544 break;
01545
01546 case __destroy_functor:
01547 _M_destroy(__dest, _Local_storage());
01548 break;
01549 }
01550 return false;
01551 }
01552
01553 static void
01554 _M_init_functor(_Any_data& __functor, const _Functor& __f)
01555 { _M_init_functor(__functor, __f, _Local_storage()); }
01556
01557 template<typename _Signature>
01558 static bool
01559 _M_not_empty_function(const function<_Signature>& __f)
01560 { return __f; }
01561
01562 template<typename _Tp>
01563 static bool
01564 _M_not_empty_function(const _Tp*& __fp)
01565 { return __fp; }
01566
01567 template<typename _Class, typename _Tp>
01568 static bool
01569 _M_not_empty_function(_Tp _Class::* const& __mp)
01570 { return __mp; }
01571
01572 template<typename _Tp>
01573 static bool
01574 _M_not_empty_function(const _Tp&)
01575 { return true; }
01576
01577 private:
01578 static void
01579 _M_init_functor(_Any_data& __functor, const _Functor& __f, true_type)
01580 { new (__functor._M_access()) _Functor(__f); }
01581
01582 static void
01583 _M_init_functor(_Any_data& __functor, const _Functor& __f, false_type)
01584 { __functor._M_access<_Functor*>() = new _Functor(__f); }
01585 };
01586
01587 template<typename _Functor>
01588 class _Ref_manager : public _Base_manager<_Functor*>
01589 {
01590 typedef _Function_base::_Base_manager<_Functor*> _Base;
01591
01592 public:
01593 static bool
01594 _M_manager(_Any_data& __dest, const _Any_data& __source,
01595 _Manager_operation __op)
01596 {
01597 switch (__op)
01598 {
01599 #ifdef __GXX_RTTI
01600 case __get_type_info:
01601 __dest._M_access<const type_info*>() = &typeid(_Functor);
01602 break;
01603 #endif
01604 case __get_functor_ptr:
01605 __dest._M_access<_Functor*>() = *_Base::_M_get_pointer(__source);
01606 return is_const<_Functor>::value;
01607 break;
01608
01609 default:
01610 _Base::_M_manager(__dest, __source, __op);
01611 }
01612 return false;
01613 }
01614
01615 static void
01616 _M_init_functor(_Any_data& __functor, reference_wrapper<_Functor> __f)
01617 {
01618
01619 _Base::_M_init_functor(__functor, &__f.get());
01620 }
01621 };
01622
01623 _Function_base() : _M_manager(0) { }
01624
01625 ~_Function_base()
01626 {
01627 if (_M_manager)
01628 _M_manager(_M_functor, _M_functor, __destroy_functor);
01629 }
01630
01631
01632 bool _M_empty() const { return !_M_manager; }
01633
01634 typedef bool (*_Manager_type)(_Any_data&, const _Any_data&,
01635 _Manager_operation);
01636
01637 _Any_data _M_functor;
01638 _Manager_type _M_manager;
01639 };
01640
01641 template<typename _Signature, typename _Functor>
01642 class _Function_handler;
01643
01644 template<typename _Res, typename _Functor, typename... _ArgTypes>
01645 class _Function_handler<_Res(_ArgTypes...), _Functor>
01646 : public _Function_base::_Base_manager<_Functor>
01647 {
01648 typedef _Function_base::_Base_manager<_Functor> _Base;
01649
01650 public:
01651 static _Res
01652 _M_invoke(const _Any_data& __functor, _ArgTypes... __args)
01653 {
01654 return (*_Base::_M_get_pointer(__functor))(__args...);
01655 }
01656 };
01657
01658 template<typename _Functor, typename... _ArgTypes>
01659 class _Function_handler<void(_ArgTypes...), _Functor>
01660 : public _Function_base::_Base_manager<_Functor>
01661 {
01662 typedef _Function_base::_Base_manager<_Functor> _Base;
01663
01664 public:
01665 static void
01666 _M_invoke(const _Any_data& __functor, _ArgTypes... __args)
01667 {
01668 (*_Base::_M_get_pointer(__functor))(__args...);
01669 }
01670 };
01671
01672 template<typename _Res, typename _Functor, typename... _ArgTypes>
01673 class _Function_handler<_Res(_ArgTypes...), reference_wrapper<_Functor> >
01674 : public _Function_base::_Ref_manager<_Functor>
01675 {
01676 typedef _Function_base::_Ref_manager<_Functor> _Base;
01677
01678 public:
01679 static _Res
01680 _M_invoke(const _Any_data& __functor, _ArgTypes... __args)
01681 {
01682 return
01683 __callable_functor(**_Base::_M_get_pointer(__functor))(__args...);
01684 }
01685 };
01686
01687 template<typename _Functor, typename... _ArgTypes>
01688 class _Function_handler<void(_ArgTypes...), reference_wrapper<_Functor> >
01689 : public _Function_base::_Ref_manager<_Functor>
01690 {
01691 typedef _Function_base::_Ref_manager<_Functor> _Base;
01692
01693 public:
01694 static void
01695 _M_invoke(const _Any_data& __functor, _ArgTypes... __args)
01696 {
01697 __callable_functor(**_Base::_M_get_pointer(__functor))(__args...);
01698 }
01699 };
01700
01701 template<typename _Class, typename _Member, typename _Res,
01702 typename... _ArgTypes>
01703 class _Function_handler<_Res(_ArgTypes...), _Member _Class::*>
01704 : public _Function_handler<void(_ArgTypes...), _Member _Class::*>
01705 {
01706 typedef _Function_handler<void(_ArgTypes...), _Member _Class::*>
01707 _Base;
01708
01709 public:
01710 static _Res
01711 _M_invoke(const _Any_data& __functor, _ArgTypes... __args)
01712 {
01713 return _GLIBCXX_TR1
01714 mem_fn(_Base::_M_get_pointer(__functor)->__value)(__args...);
01715 }
01716 };
01717
01718 template<typename _Class, typename _Member, typename... _ArgTypes>
01719 class _Function_handler<void(_ArgTypes...), _Member _Class::*>
01720 : public _Function_base::_Base_manager<
01721 _Simple_type_wrapper< _Member _Class::* > >
01722 {
01723 typedef _Member _Class::* _Functor;
01724 typedef _Simple_type_wrapper<_Functor> _Wrapper;
01725 typedef _Function_base::_Base_manager<_Wrapper> _Base;
01726
01727 public:
01728 static bool
01729 _M_manager(_Any_data& __dest, const _Any_data& __source,
01730 _Manager_operation __op)
01731 {
01732 switch (__op)
01733 {
01734 #ifdef __GXX_RTTI
01735 case __get_type_info:
01736 __dest._M_access<const type_info*>() = &typeid(_Functor);
01737 break;
01738 #endif
01739 case __get_functor_ptr:
01740 __dest._M_access<_Functor*>() =
01741 &_Base::_M_get_pointer(__source)->__value;
01742 break;
01743
01744 default:
01745 _Base::_M_manager(__dest, __source, __op);
01746 }
01747 return false;
01748 }
01749
01750 static void
01751 _M_invoke(const _Any_data& __functor, _ArgTypes... __args)
01752 {
01753 _GLIBCXX_TR1
01754 mem_fn(_Base::_M_get_pointer(__functor)->__value)(__args...);
01755 }
01756 };
01757
01758
01759 template<typename _Res, typename... _ArgTypes>
01760 class function<_Res(_ArgTypes...)>
01761 : public _Maybe_unary_or_binary_function<_Res, _ArgTypes...>,
01762 private _Function_base
01763 {
01764
01765 struct _Hidden_type
01766 {
01767 _Hidden_type* _M_bool;
01768 };
01769
01770
01771 typedef _Hidden_type* _Hidden_type::* _Safe_bool;
01772
01773 typedef _Res _Signature_type(_ArgTypes...);
01774
01775 struct _Useless { };
01776
01777 public:
01778 typedef _Res result_type;
01779
01780
01781
01782
01783
01784
01785
01786 function() : _Function_base() { }
01787
01788
01789
01790
01791
01792 function(_M_clear_type*) : _Function_base() { }
01793
01794
01795
01796
01797
01798
01799
01800
01801
01802 function(const function& __x);
01803
01804
01805
01806
01807
01808
01809
01810
01811
01812
01813
01814
01815
01816
01817
01818
01819
01820 template<typename _Functor>
01821 function(_Functor __f,
01822 typename __gnu_cxx::__enable_if<
01823 !is_integral<_Functor>::value, _Useless>::__type
01824 = _Useless());
01825
01826
01827
01828
01829
01830
01831
01832
01833
01834
01835
01836
01837
01838 function&
01839 operator=(const function& __x)
01840 {
01841 function(__x).swap(*this);
01842 return *this;
01843 }
01844
01845
01846
01847
01848
01849
01850
01851
01852 function&
01853 operator=(_M_clear_type*)
01854 {
01855 if (_M_manager)
01856 {
01857 _M_manager(_M_functor, _M_functor, __destroy_functor);
01858 _M_manager = 0;
01859 _M_invoker = 0;
01860 }
01861 return *this;
01862 }
01863
01864
01865
01866
01867
01868
01869
01870
01871
01872
01873
01874
01875
01876
01877
01878
01879
01880 template<typename _Functor>
01881 typename __gnu_cxx::__enable_if<!is_integral<_Functor>::value,
01882 function&>::__type
01883 operator=(_Functor __f)
01884 {
01885 function(__f).swap(*this);
01886 return *this;
01887 }
01888
01889
01890
01891
01892
01893
01894
01895
01896
01897
01898 void swap(function& __x)
01899 {
01900 _Any_data __old_functor = _M_functor;
01901 _M_functor = __x._M_functor;
01902 __x._M_functor = __old_functor;
01903 _Manager_type __old_manager = _M_manager;
01904 _M_manager = __x._M_manager;
01905 __x._M_manager = __old_manager;
01906 _Invoker_type __old_invoker = _M_invoker;
01907 _M_invoker = __x._M_invoker;
01908 __x._M_invoker = __old_invoker;
01909 }
01910
01911
01912
01913
01914
01915
01916
01917
01918
01919
01920
01921 operator _Safe_bool() const
01922 {
01923 if (_M_empty())
01924 return 0;
01925 else
01926 return &_Hidden_type::_M_bool;
01927 }
01928
01929
01930
01931
01932
01933
01934
01935
01936
01937
01938
01939 _Res operator()(_ArgTypes... __args) const;
01940
01941 #ifdef __GXX_RTTI
01942
01943
01944
01945
01946
01947
01948
01949
01950
01951
01952 const type_info& target_type() const;
01953
01954
01955
01956
01957
01958
01959
01960
01961
01962
01963 template<typename _Functor> _Functor* target();
01964
01965
01966 template<typename _Functor> const _Functor* target() const;
01967 #endif
01968
01969 private:
01970
01971 template<typename _Function>
01972 void operator==(const function<_Function>&) const;
01973 template<typename _Function>
01974 void operator!=(const function<_Function>&) const;
01975
01976 typedef _Res (*_Invoker_type)(const _Any_data&, _ArgTypes...);
01977 _Invoker_type _M_invoker;
01978 };
01979
01980 template<typename _Res, typename... _ArgTypes>
01981 function<_Res(_ArgTypes...)>::
01982 function(const function& __x)
01983 : _Function_base()
01984 {
01985 if (__x)
01986 {
01987 _M_invoker = __x._M_invoker;
01988 _M_manager = __x._M_manager;
01989 __x._M_manager(_M_functor, __x._M_functor, __clone_functor);
01990 }
01991 }
01992
01993 template<typename _Res, typename... _ArgTypes>
01994 template<typename _Functor>
01995 function<_Res(_ArgTypes...)>::
01996 function(_Functor __f,
01997 typename __gnu_cxx::__enable_if<
01998 !is_integral<_Functor>::value, _Useless>::__type)
01999 : _Function_base()
02000 {
02001 typedef _Function_handler<_Signature_type, _Functor> _My_handler;
02002
02003 if (_My_handler::_M_not_empty_function(__f))
02004 {
02005 _M_invoker = &_My_handler::_M_invoke;
02006 _M_manager = &_My_handler::_M_manager;
02007 _My_handler::_M_init_functor(_M_functor, __f);
02008 }
02009 }
02010
02011 template<typename _Res, typename... _ArgTypes>
02012 _Res
02013 function<_Res(_ArgTypes...)>::
02014 operator()(_ArgTypes... __args) const
02015 {
02016 if (_M_empty())
02017 {
02018 #if __EXCEPTIONS
02019 throw bad_function_call();
02020 #else
02021 __builtin_abort();
02022 #endif
02023 }
02024 return _M_invoker(_M_functor, __args...);
02025 }
02026
02027 #ifdef __GXX_RTTI
02028 template<typename _Res, typename... _ArgTypes>
02029 const type_info&
02030 function<_Res(_ArgTypes...)>::
02031 target_type() const
02032 {
02033 if (_M_manager)
02034 {
02035 _Any_data __typeinfo_result;
02036 _M_manager(__typeinfo_result, _M_functor, __get_type_info);
02037 return *__typeinfo_result._M_access<const type_info*>();
02038 }
02039 else
02040 return typeid(void);
02041 }
02042
02043 template<typename _Res, typename... _ArgTypes>
02044 template<typename _Functor>
02045 _Functor*
02046 function<_Res(_ArgTypes...)>::
02047 target()
02048 {
02049 if (typeid(_Functor) == target_type() && _M_manager)
02050 {
02051 _Any_data __ptr;
02052 if (_M_manager(__ptr, _M_functor, __get_functor_ptr)
02053 && !is_const<_Functor>::value)
02054 return 0;
02055 else
02056 return __ptr._M_access<_Functor*>();
02057 }
02058 else
02059 return 0;
02060 }
02061
02062 template<typename _Res, typename... _ArgTypes>
02063 template<typename _Functor>
02064 const _Functor*
02065 function<_Res(_ArgTypes...)>::
02066 target() const
02067 {
02068 if (typeid(_Functor) == target_type() && _M_manager)
02069 {
02070 _Any_data __ptr;
02071 _M_manager(__ptr, _M_functor, __get_functor_ptr);
02072 return __ptr._M_access<const _Functor*>();
02073 }
02074 else
02075 return 0;
02076 }
02077 #endif
02078
02079
02080
02081
02082
02083
02084
02085
02086
02087
02088 template<typename _Signature>
02089 inline bool
02090 operator==(const function<_Signature>& __f, _M_clear_type*)
02091 { return !__f; }
02092
02093
02094 template<typename _Signature>
02095 inline bool
02096 operator==(_M_clear_type*, const function<_Signature>& __f)
02097 { return !__f; }
02098
02099
02100
02101
02102
02103
02104
02105
02106 template<typename _Signature>
02107 inline bool
02108 operator!=(const function<_Signature>& __f, _M_clear_type*)
02109 { return __f; }
02110
02111
02112 template<typename _Signature>
02113 inline bool
02114 operator!=(_M_clear_type*, const function<_Signature>& __f)
02115 { return __f; }
02116
02117
02118
02119
02120
02121
02122
02123
02124 template<typename _Signature>
02125 inline void
02126 swap(function<_Signature>& __x, function<_Signature>& __y)
02127 { __x.swap(__y); }
02128
02129 _GLIBCXX_END_NAMESPACE_TR1
02130 }