libstdc++
|
00001 // TR1 functional header -*- C++ -*- 00002 00003 // Copyright (C) 2007, 2008, 2009 Free Software Foundation, Inc. 00004 // 00005 // This file is part of the GNU ISO C++ Library. This library is free 00006 // software; you can redistribute it and/or modify it under the 00007 // terms of the GNU General Public License as published by the 00008 // Free Software Foundation; either version 3, or (at your option) 00009 // any later version. 00010 00011 // This library is distributed in the hope that it will be useful, 00012 // but WITHOUT ANY WARRANTY; without even the implied warranty of 00013 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 00014 // GNU General Public License for more details. 00015 00016 // Under Section 7 of GPL version 3, you are granted additional 00017 // permissions described in the GCC Runtime Library Exception, version 00018 // 3.1, as published by the Free Software Foundation. 00019 00020 // You should have received a copy of the GNU General Public License and 00021 // a copy of the GCC Runtime Library Exception along with this program; 00022 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see 00023 // <http://www.gnu.org/licenses/>. 00024 00025 /** @file tr1_impl/functional 00026 * This is an internal header file, included by other library headers. 00027 * You should not attempt to use it directly. 00028 */ 00029 00030 namespace std 00031 { 00032 _GLIBCXX_BEGIN_NAMESPACE_TR1 00033 00034 template<typename _MemberPointer> 00035 class _Mem_fn; 00036 00037 /** 00038 * Actual implementation of _Has_result_type, which uses SFINAE to 00039 * determine if the type _Tp has a publicly-accessible member type 00040 * result_type. 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 /// If we have found a result_type, extract it. 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 * Base class for any function object that has a weak result type, as 00081 * defined in 3.3/3 of TR1. 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 /// Retrieve the result type for a function type. 00090 template<typename _Res, typename... _ArgTypes> 00091 struct _Weak_result_type_impl<_Res(_ArgTypes...)> 00092 { 00093 typedef _Res result_type; 00094 }; 00095 00096 /// Retrieve the result type for a function reference. 00097 template<typename _Res, typename... _ArgTypes> 00098 struct _Weak_result_type_impl<_Res(&)(_ArgTypes...)> 00099 { 00100 typedef _Res result_type; 00101 }; 00102 00103 /// Retrieve the result type for a function pointer. 00104 template<typename _Res, typename... _ArgTypes> 00105 struct _Weak_result_type_impl<_Res(*)(_ArgTypes...)> 00106 { 00107 typedef _Res result_type; 00108 }; 00109 00110 /// Retrieve result type for a member function pointer. 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 /// Retrieve result type for a const member function pointer. 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 /// Retrieve result type for a volatile member function pointer. 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 /// Retrieve result type for a const volatile member function pointer. 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 * Strip top-level cv-qualifiers from the function object and let 00140 * _Weak_result_type_impl perform the real work. 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 * Actual implementation of result_of. When _Has_result_type is 00153 * true, gets its result from _Weak_result_type. Otherwise, uses 00154 * the function object's member template result to extract the 00155 * result type. 00156 */ 00157 template<bool _Has_result_type, typename _Signature> 00158 struct _Result_of_impl; 00159 00160 // Handle member data pointers using _Mem_fn's logic 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 * Determine whether we can determine a result type from @c Functor 00170 * alone. 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 /// We already know the result type for @c Functor; use it. 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 * We need to compute the result type for this invocation the hard 00189 * way. 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 * It is unsafe to access ::result when there are zero arguments, so we 00200 * return @c void instead. 00201 */ 00202 template<typename _Functor> 00203 struct _Result_of_impl<false, _Functor()> 00204 { 00205 typedef void type; 00206 }; 00207 00208 /// Determines if the type _Tp derives from unary_function. 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 // It's tempting to change "..." to const volatile void*, but 00217 // that fails when _Tp is a function type. 00218 static __two __test(...); 00219 00220 public: 00221 static const bool value = sizeof(__test((_Tp*)0)) == 1; 00222 }; 00223 00224 /// Determines if the type _Tp derives from binary_function. 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 // It's tempting to change "..." to const volatile void*, but 00233 // that fails when _Tp is a function type. 00234 static __two __test(...); 00235 00236 public: 00237 static const bool value = sizeof(__test((_Tp*)0)) == 1; 00238 }; 00239 00240 /// Turns a function type into a function pointer type 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 * Invoke a function object, which may be either a member pointer or a 00255 * function object. The first parameter will tell which. 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 // To pick up function references (that will become function pointers) 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 * Knowing which of unary_function and binary_function _Tp derives 00298 * from, derives from the same and ensures that reference_wrapper 00299 * will have a weak result type. See cases below. 00300 */ 00301 template<bool _Unary, bool _Binary, typename _Tp> 00302 struct _Reference_wrapper_base_impl; 00303 00304 // Not a unary_function or binary_function, so try a weak result type. 00305 template<typename _Tp> 00306 struct _Reference_wrapper_base_impl<false, false, _Tp> 00307 : _Weak_result_type<_Tp> 00308 { }; 00309 00310 // unary_function but not binary_function 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 // binary_function but not unary_function 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 // Both unary_function and binary_function. Import result_type to 00326 // avoid conflicts. 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 * Derives from unary_function or binary_function when it 00340 * can. Specializations handle all of the easy cases. The primary 00341 * template determines what to do with a class type, which may 00342 * derive from both unary_function and binary_function. 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 // - a function type (unary) 00353 template<typename _Res, typename _T1> 00354 struct _Reference_wrapper_base<_Res(_T1)> 00355 : unary_function<_T1, _Res> 00356 { }; 00357 00358 // - a function type (binary) 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 // - a function pointer type (unary) 00365 template<typename _Res, typename _T1> 00366 struct _Reference_wrapper_base<_Res(*)(_T1)> 00367 : unary_function<_T1, _Res> 00368 { }; 00369 00370 // - a function pointer type (binary) 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 // - a pointer to member function type (unary, no qualifiers) 00377 template<typename _Res, typename _T1> 00378 struct _Reference_wrapper_base<_Res (_T1::*)()> 00379 : unary_function<_T1*, _Res> 00380 { }; 00381 00382 // - a pointer to member function type (binary, no qualifiers) 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 // - a pointer to member function type (unary, const) 00389 template<typename _Res, typename _T1> 00390 struct _Reference_wrapper_base<_Res (_T1::*)() const> 00391 : unary_function<const _T1*, _Res> 00392 { }; 00393 00394 // - a pointer to member function type (binary, const) 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 // - a pointer to member function type (unary, volatile) 00401 template<typename _Res, typename _T1> 00402 struct _Reference_wrapper_base<_Res (_T1::*)() volatile> 00403 : unary_function<volatile _T1*, _Res> 00404 { }; 00405 00406 // - a pointer to member function type (binary, volatile) 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 // - a pointer to member function type (unary, const volatile) 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 // - a pointer to member function type (binary, const volatile) 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 /// reference_wrapper 00425 template<typename _Tp> 00426 class reference_wrapper 00427 : public _Reference_wrapper_base<typename remove_cv<_Tp>::type> 00428 { 00429 // If _Tp is a function type, we can't form result_of<_Tp(...)>, 00430 // so turn it into a function pointer type. 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 // Denotes a reference should be taken to a variable. 00470 template<typename _Tp> 00471 inline reference_wrapper<_Tp> 00472 ref(_Tp& __t) 00473 { return reference_wrapper<_Tp>(__t); } 00474 00475 // Denotes a const reference should be taken to a variable. 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 * Derives from @c unary_function or @c binary_function, or perhaps 00505 * nothing, depending on the number of arguments provided. The 00506 * primary template is the basis case, which derives nothing. 00507 */ 00508 template<typename _Res, typename... _ArgTypes> 00509 struct _Maybe_unary_or_binary_function { }; 00510 00511 /// Derives from @c unary_function, as appropriate. 00512 template<typename _Res, typename _T1> 00513 struct _Maybe_unary_or_binary_function<_Res, _T1> 00514 : std::unary_function<_T1, _Res> { }; 00515 00516 /// Derives from @c binary_function, as appropriate. 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 /// Implementation of @c mem_fn for member function pointers. 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 // Handle objects 00545 _Res 00546 operator()(_Class& __object, _ArgTypes... __args) const 00547 { return (__object.*__pmf)(__args...); } 00548 00549 // Handle pointers 00550 _Res 00551 operator()(_Class* __object, _ArgTypes... __args) const 00552 { return (__object->*__pmf)(__args...); } 00553 00554 // Handle smart pointers, references and pointers to derived 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 /// Implementation of @c mem_fn for const member function pointers. 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 // Handle objects 00589 _Res 00590 operator()(const _Class& __object, _ArgTypes... __args) const 00591 { return (__object.*__pmf)(__args...); } 00592 00593 // Handle pointers 00594 _Res 00595 operator()(const _Class* __object, _ArgTypes... __args) const 00596 { return (__object->*__pmf)(__args...); } 00597 00598 // Handle smart pointers, references and pointers to derived 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 /// Implementation of @c mem_fn for volatile member function pointers. 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 // Handle objects 00632 _Res 00633 operator()(volatile _Class& __object, _ArgTypes... __args) const 00634 { return (__object.*__pmf)(__args...); } 00635 00636 // Handle pointers 00637 _Res 00638 operator()(volatile _Class* __object, _ArgTypes... __args) const 00639 { return (__object->*__pmf)(__args...); } 00640 00641 // Handle smart pointers, references and pointers to derived 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 /// Implementation of @c mem_fn for const volatile member function pointers. 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 // Handle objects 00676 _Res 00677 operator()(const volatile _Class& __object, _ArgTypes... __args) const 00678 { return (__object.*__pmf)(__args...); } 00679 00680 // Handle pointers 00681 _Res 00682 operator()(const volatile _Class* __object, _ArgTypes... __args) const 00683 { return (__object->*__pmf)(__args...); } 00684 00685 // Handle smart pointers, references and pointers to derived 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 // This bit of genius is due to Peter Dimov, improved slightly by 00699 // Douglas Gregor. 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 // Handle objects 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 // Handle pointers 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 // Handle smart pointers and derived 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 * @brief Returns a function object that forwards to the member 00790 * pointer @a pm. 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 * @brief Determines if the given type _Tp is a function object 00801 * should be treated as a subexpression when evaluating calls to 00802 * function objects returned by bind(). [TR1 3.6.1] 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 * @brief Determines if the given type _Tp is a placeholder in a 00813 * bind() expression and, if so, which placeholder it is. [TR1 3.6.2] 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 /// The type of placeholder objects defined by libstdc++. 00823 template<int _Num> struct _Placeholder { }; 00824 00825 /** @namespace std::placeholders 00826 * @brief ISO C++ 0x entities sub namespace for functional. 00827 * 00828 * Define a large number of placeholders. There is no way to 00829 * simplify this with variadic templates, because we're introducing 00830 * unique names for each. 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 * Partial specialization of is_placeholder that provides the placeholder 00870 * number for the placeholder objects defined by libstdc++. 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 * Stores a tuple of indices. Used by bind() to extract the elements 00881 * in a tuple. 00882 */ 00883 template<int... _Indexes> 00884 struct _Index_tuple { }; 00885 00886 /// Builds an _Index_tuple<0, 1, 2, ..., _Num-1>. 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 * Used by _Safe_tuple_element to indicate that there is no tuple 00905 * element at this position. 00906 */ 00907 struct _No_tuple_element; 00908 00909 /** 00910 * Implementation helper for _Safe_tuple_element. This primary 00911 * template handles the case where it is safe to use @c 00912 * tuple_element. 00913 */ 00914 template<int __i, typename _Tuple, bool _IsSafe> 00915 struct _Safe_tuple_element_impl 00916 : tuple_element<__i, _Tuple> { }; 00917 00918 /** 00919 * Implementation helper for _Safe_tuple_element. This partial 00920 * specialization handles the case where it is not safe to use @c 00921 * tuple_element. We just return @c _No_tuple_element. 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 * Like tuple_element, but returns @c _No_tuple_element when 00931 * tuple_element would return an error. 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 * Maps an argument to bind() into an actual argument to the bound 00942 * function object [TR1 3.6.3/5]. Only the first parameter should 00943 * be specified: the rest are used to determine among the various 00944 * implementations. Note that, although this class is a function 00945 * object, it isn't entirely normal because it takes only two 00946 * parameters regardless of the number of parameters passed to the 00947 * bind expression. The first parameter is the bound argument and 00948 * the second parameter is a tuple containing references to the 00949 * rest of the arguments. 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 * If the argument is reference_wrapper<_Tp>, returns the 00958 * underlying reference. [TR1 3.6.3/5 bullet 1] 00959 */ 00960 template<typename _Tp> 00961 class _Mu<reference_wrapper<_Tp>, false, false> 00962 { 00963 public: 00964 typedef _Tp& result_type; 00965 00966 /* Note: This won't actually work for const volatile 00967 * reference_wrappers, because reference_wrapper::get() is const 00968 * but not volatile-qualified. This might be a defect in the TR. 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 * If the argument is a bind expression, we invoke the underlying 00978 * function object with the same cv-qualifiers as we are given and 00979 * pass along all of our arguments (unwrapped). [TR1 3.6.3/5 bullet 2] 00980 */ 00981 template<typename _Arg> 00982 class _Mu<_Arg, true, false> 00983 { 00984 public: 00985 template<typename _Signature> class result; 00986 00987 // Determine the result type when we pass the arguments along. This 00988 // involves passing along the cv-qualifiers placed on _Mu and 00989 // unwrapping the argument bundle. 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 // Construct an index tuple and forward to __call 01000 typedef typename _Build_index_tuple<sizeof...(_Args)>::__type 01001 _Indexes; 01002 return this->__call(__arg, __tuple, _Indexes()); 01003 } 01004 01005 private: 01006 // Invokes the underlying function object __arg by unpacking all 01007 // of the arguments in the tuple. 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 * If the argument is a placeholder for the Nth argument, returns 01019 * a reference to the Nth argument to the bind function object. 01020 * [TR1 3.6.3/5 bullet 3] 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 // Add a reference, if it hasn't already been done for us. 01032 // This allows us to be a little bit sloppy in constructing 01033 // the tuple that we pass to result_of<...>. 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 * If the argument is just a value, returns a reference to that 01057 * value. The cv-qualifiers on the reference are the same as the 01058 * cv-qualifiers on the _Mu object. [TR1 3.6.3/5 bullet 4] 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 // Pick up the cv-qualifiers of the argument 01077 template<typename _CVArg, typename _Tuple> 01078 _CVArg& 01079 operator()(_CVArg& __arg, const _Tuple&) const volatile 01080 { return __arg; } 01081 }; 01082 01083 /** 01084 * Maps member pointers into instances of _Mem_fn but leaves all 01085 * other function objects untouched. Used by tr1::bind(). The 01086 * primary template handles the non--member-pointer case. 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 * Maps member pointers into instances of _Mem_fn but leaves all 01100 * other function objects untouched. Used by tr1::bind(). This 01101 * partial specialization handles the member pointer case. 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 /// Type of the function object returned from bind(). 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 // Call unqualified 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 // Call as const 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 // Call as volatile 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 // Call as const volatile 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 // Call unqualified 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 // Call as const 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 // Call as volatile 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 // Call as const volatile 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 /// Type of the function object returned from bind<R>(). 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 // Call unqualified 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 // Call as const 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 // Call as volatile 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 // Call as const volatile 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 // Call unqualified 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 // Call as const 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 // Call as volatile 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 // Call as const volatile 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 /// Class template _Bind is always a bind expression. 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 /// Class template _Bind_result is always a bind expression. 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 /// bind 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 * @brief Exception class thrown when class template function's 01367 * operator() is called with an empty target. 01368 * 01369 */ 01370 class bad_function_call : public std::exception { }; 01371 01372 /** 01373 * The integral constant expression 0 can be converted into a 01374 * pointer to this type. It is used by the function template to 01375 * accept NULL pointers. 01376 */ 01377 struct _M_clear_type; 01378 01379 /** 01380 * Trait identifying "location-invariant" types, meaning that the 01381 * address of the object (or any of its members) will not escape. 01382 * Also implies a trivial copy constructor and assignment operator. 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 // Simple type wrapper that helps avoid annoying const problems 01430 // when casting between void pointers and pointers-to-pointers. 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 // Converts a reference to a function object into a callable 01446 // function object. 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 /// Base class of all polymorphic function object wrappers. 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 // Retrieve a pointer to the function object 01485 static _Functor* 01486 _M_get_pointer(const _Any_data& __source) 01487 { 01488 const _Functor* __ptr = 01489 __stored_locally? &__source._M_access<_Functor>() 01490 /* have stored a pointer */ : __source._M_access<_Functor*>(); 01491 return const_cast<_Functor*>(__ptr); 01492 } 01493 01494 // Clone a location-invariant function object that fits within 01495 // an _Any_data structure. 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 // Clone a function object that is not location-invariant or 01503 // that cannot fit into an _Any_data structure. 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 // Destroying a location-invariant object may still require 01512 // destruction. 01513 static void 01514 _M_destroy(_Any_data& __victim, true_type) 01515 { 01516 __victim._M_access<_Functor>().~_Functor(); 01517 } 01518 01519 // Destroying an object located on the heap. 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 // TBD: Use address_of function instead. 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 /// class function 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 /// This class is used to implement the safe_bool idiom. 01765 struct _Hidden_type 01766 { 01767 _Hidden_type* _M_bool; 01768 }; 01769 01770 /// This typedef is used to implement the safe_bool idiom. 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 // [3.7.2.1] construct/copy/destroy 01781 01782 /** 01783 * @brief Default construct creates an empty function call wrapper. 01784 * @post @c !(bool)*this 01785 */ 01786 function() : _Function_base() { } 01787 01788 /** 01789 * @brief Default construct creates an empty function call wrapper. 01790 * @post @c !(bool)*this 01791 */ 01792 function(_M_clear_type*) : _Function_base() { } 01793 01794 /** 01795 * @brief %Function copy constructor. 01796 * @param x A %function object with identical call signature. 01797 * @pre @c (bool)*this == (bool)x 01798 * 01799 * The newly-created %function contains a copy of the target of @a 01800 * x (if it has one). 01801 */ 01802 function(const function& __x); 01803 01804 /** 01805 * @brief Builds a %function that targets a copy of the incoming 01806 * function object. 01807 * @param f A %function object that is callable with parameters of 01808 * type @c T1, @c T2, ..., @c TN and returns a value convertible 01809 * to @c Res. 01810 * 01811 * The newly-created %function object will target a copy of @a 01812 * f. If @a f is @c reference_wrapper<F>, then this function 01813 * object will contain a reference to the function object @c 01814 * f.get(). If @a f is a NULL function pointer or NULL 01815 * pointer-to-member, the newly-created object will be empty. 01816 * 01817 * If @a f is a non-NULL function pointer or an object of type @c 01818 * reference_wrapper<F>, this function will not throw. 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 * @brief %Function assignment operator. 01828 * @param x A %function with identical call signature. 01829 * @post @c (bool)*this == (bool)x 01830 * @returns @c *this 01831 * 01832 * The target of @a x is copied to @c *this. If @a x has no 01833 * target, then @c *this will be empty. 01834 * 01835 * If @a x targets a function pointer or a reference to a function 01836 * object, then this operation will not throw an exception. 01837 */ 01838 function& 01839 operator=(const function& __x) 01840 { 01841 function(__x).swap(*this); 01842 return *this; 01843 } 01844 01845 /** 01846 * @brief %Function assignment to zero. 01847 * @post @c !(bool)*this 01848 * @returns @c *this 01849 * 01850 * The target of @a *this is deallocated, leaving it empty. 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 * @brief %Function assignment to a new target. 01866 * @param f A %function object that is callable with parameters of 01867 * type @c T1, @c T2, ..., @c TN and returns a value convertible 01868 * to @c Res. 01869 * @return @c *this 01870 * 01871 * This %function object wrapper will target a copy of @a 01872 * f. If @a f is @c reference_wrapper<F>, then this function 01873 * object will contain a reference to the function object @c 01874 * f.get(). If @a f is a NULL function pointer or NULL 01875 * pointer-to-member, @c this object will be empty. 01876 * 01877 * If @a f is a non-NULL function pointer or an object of type @c 01878 * reference_wrapper<F>, this function will not throw. 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 // [3.7.2.2] function modifiers 01890 01891 /** 01892 * @brief Swap the targets of two %function objects. 01893 * @param f A %function with identical call signature. 01894 * 01895 * Swap the targets of @c this function object and @a f. This 01896 * function will not throw an exception. 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 // [3.7.2.3] function capacity 01912 01913 /** 01914 * @brief Determine if the %function wrapper has a target. 01915 * 01916 * @return @c true when this %function object contains a target, 01917 * or @c false when it is empty. 01918 * 01919 * This function will not throw an exception. 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 // [3.7.2.4] function invocation 01930 01931 /** 01932 * @brief Invokes the function targeted by @c *this. 01933 * @returns the result of the target. 01934 * @throws bad_function_call when @c !(bool)*this 01935 * 01936 * The function call operator invokes the target function object 01937 * stored by @c this. 01938 */ 01939 _Res operator()(_ArgTypes... __args) const; 01940 01941 #ifdef __GXX_RTTI 01942 // [3.7.2.5] function target access 01943 /** 01944 * @brief Determine the type of the target of this function object 01945 * wrapper. 01946 * 01947 * @returns the type identifier of the target function object, or 01948 * @c typeid(void) if @c !(bool)*this. 01949 * 01950 * This function will not throw an exception. 01951 */ 01952 const type_info& target_type() const; 01953 01954 /** 01955 * @brief Access the stored target function object. 01956 * 01957 * @return Returns a pointer to the stored target function object, 01958 * if @c typeid(Functor).equals(target_type()); otherwise, a NULL 01959 * pointer. 01960 * 01961 * This function will not throw an exception. 01962 */ 01963 template<typename _Functor> _Functor* target(); 01964 01965 /// @overload 01966 template<typename _Functor> const _Functor* target() const; 01967 #endif 01968 01969 private: 01970 // [3.7.2.6] undefined operators 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 // [3.7.2.7] null pointer comparisons 02080 02081 /** 02082 * @brief Compares a polymorphic function object wrapper against 0 02083 * (the NULL pointer). 02084 * @returns @c true if the wrapper has no target, @c false otherwise 02085 * 02086 * This function will not throw an exception. 02087 */ 02088 template<typename _Signature> 02089 inline bool 02090 operator==(const function<_Signature>& __f, _M_clear_type*) 02091 { return !__f; } 02092 02093 /// @overload 02094 template<typename _Signature> 02095 inline bool 02096 operator==(_M_clear_type*, const function<_Signature>& __f) 02097 { return !__f; } 02098 02099 /** 02100 * @brief Compares a polymorphic function object wrapper against 0 02101 * (the NULL pointer). 02102 * @returns @c false if the wrapper has no target, @c true otherwise 02103 * 02104 * This function will not throw an exception. 02105 */ 02106 template<typename _Signature> 02107 inline bool 02108 operator!=(const function<_Signature>& __f, _M_clear_type*) 02109 { return __f; } 02110 02111 /// @overload 02112 template<typename _Signature> 02113 inline bool 02114 operator!=(_M_clear_type*, const function<_Signature>& __f) 02115 { return __f; } 02116 02117 // [3.7.2.8] specialized algorithms 02118 02119 /** 02120 * @brief Swap the targets of two polymorphic function object wrappers. 02121 * 02122 * This function will not throw an exception. 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 }