1// <functional> -*- C++ -*- 2 3// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 4// 2011, 2012, 2013 Free Software Foundation, Inc. 5// 6// This file is part of the GNU ISO C++ Library. This library is free 7// software; you can redistribute it and/or modify it under the 8// terms of the GNU General Public License as published by the 9// Free Software Foundation; either version 3, or (at your option) 10// any later version. 11 12// This library is distributed in the hope that it will be useful, 13// but WITHOUT ANY WARRANTY; without even the implied warranty of 14// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15// GNU General Public License for more details. 16 17// Under Section 7 of GPL version 3, you are granted additional 18// permissions described in the GCC Runtime Library Exception, version 19// 3.1, as published by the Free Software Foundation. 20 21// You should have received a copy of the GNU General Public License and 22// a copy of the GCC Runtime Library Exception along with this program; 23// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see 24// <http://www.gnu.org/licenses/>. 25 26/* 27 * Copyright (c) 1997 28 * Silicon Graphics Computer Systems, Inc. 29 * 30 * Permission to use, copy, modify, distribute and sell this software 31 * and its documentation for any purpose is hereby granted without fee, 32 * provided that the above copyright notice appear in all copies and 33 * that both that copyright notice and this permission notice appear 34 * in supporting documentation. Silicon Graphics makes no 35 * representations about the suitability of this software for any 36 * purpose. It is provided "as is" without express or implied warranty. 37 * 38 */ 39 40/** @file include/functional 41 * This is a Standard C++ Library header. 42 */ 43 44#ifndef _GLIBCXX_FUNCTIONAL 45#define _GLIBCXX_FUNCTIONAL 1 46 47#pragma GCC system_header 48 49#include <bits/c++config.h> 50#include <bits/stl_function.h> 51 52#ifdef __GXX_EXPERIMENTAL_CXX0X__ 53 54#include <typeinfo> 55#include <new> 56#include <tuple> 57#include <type_traits> 58#include <bits/functexcept.h> 59#include <bits/functional_hash.h> 60 61namespace std _GLIBCXX_VISIBILITY(default) 62{ 63_GLIBCXX_BEGIN_NAMESPACE_VERSION 64 65 template<typename _MemberPointer> 66 class _Mem_fn; 67 template<typename _Tp, typename _Class> 68 _Mem_fn<_Tp _Class::*> 69 mem_fn(_Tp _Class::*); 70 71_GLIBCXX_HAS_NESTED_TYPE(result_type) 72 73 /// If we have found a result_type, extract it. 74 template<bool _Has_result_type, typename _Functor> 75 struct _Maybe_get_result_type 76 { }; 77 78 template<typename _Functor> 79 struct _Maybe_get_result_type<true, _Functor> 80 { typedef typename _Functor::result_type result_type; }; 81 82 /** 83 * Base class for any function object that has a weak result type, as 84 * defined in 3.3/3 of TR1. 85 */ 86 template<typename _Functor> 87 struct _Weak_result_type_impl 88 : _Maybe_get_result_type<__has_result_type<_Functor>::value, _Functor> 89 { }; 90 91 /// Retrieve the result type for a function type. 92 template<typename _Res, typename... _ArgTypes> 93 struct _Weak_result_type_impl<_Res(_ArgTypes...)> 94 { typedef _Res result_type; }; 95 96 template<typename _Res, typename... _ArgTypes> 97 struct _Weak_result_type_impl<_Res(_ArgTypes......)> 98 { typedef _Res result_type; }; 99 100 template<typename _Res, typename... _ArgTypes> 101 struct _Weak_result_type_impl<_Res(_ArgTypes...) const> 102 { typedef _Res result_type; }; 103 104 template<typename _Res, typename... _ArgTypes> 105 struct _Weak_result_type_impl<_Res(_ArgTypes......) const> 106 { typedef _Res result_type; }; 107 108 template<typename _Res, typename... _ArgTypes> 109 struct _Weak_result_type_impl<_Res(_ArgTypes...) volatile> 110 { typedef _Res result_type; }; 111 112 template<typename _Res, typename... _ArgTypes> 113 struct _Weak_result_type_impl<_Res(_ArgTypes......) volatile> 114 { typedef _Res result_type; }; 115 116 template<typename _Res, typename... _ArgTypes> 117 struct _Weak_result_type_impl<_Res(_ArgTypes...) const volatile> 118 { typedef _Res result_type; }; 119 120 template<typename _Res, typename... _ArgTypes> 121 struct _Weak_result_type_impl<_Res(_ArgTypes......) const volatile> 122 { typedef _Res result_type; }; 123 124 /// Retrieve the result type for a function reference. 125 template<typename _Res, typename... _ArgTypes> 126 struct _Weak_result_type_impl<_Res(&)(_ArgTypes...)> 127 { typedef _Res result_type; }; 128 129 template<typename _Res, typename... _ArgTypes> 130 struct _Weak_result_type_impl<_Res(&)(_ArgTypes......)> 131 { typedef _Res result_type; }; 132 133 /// Retrieve the result type for a function pointer. 134 template<typename _Res, typename... _ArgTypes> 135 struct _Weak_result_type_impl<_Res(*)(_ArgTypes...)> 136 { typedef _Res result_type; }; 137 138 template<typename _Res, typename... _ArgTypes> 139 struct _Weak_result_type_impl<_Res(*)(_ArgTypes......)> 140 { typedef _Res result_type; }; 141 142 /// Retrieve result type for a member function pointer. 143 template<typename _Res, typename _Class, typename... _ArgTypes> 144 struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...)> 145 { typedef _Res result_type; }; 146 147 template<typename _Res, typename _Class, typename... _ArgTypes> 148 struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......)> 149 { typedef _Res result_type; }; 150 151 /// Retrieve result type for a const member function pointer. 152 template<typename _Res, typename _Class, typename... _ArgTypes> 153 struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...) const> 154 { typedef _Res result_type; }; 155 156 template<typename _Res, typename _Class, typename... _ArgTypes> 157 struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......) const> 158 { typedef _Res result_type; }; 159 160 /// Retrieve result type for a volatile member function pointer. 161 template<typename _Res, typename _Class, typename... _ArgTypes> 162 struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...) volatile> 163 { typedef _Res result_type; }; 164 165 template<typename _Res, typename _Class, typename... _ArgTypes> 166 struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......) volatile> 167 { typedef _Res result_type; }; 168 169 /// Retrieve result type for a const volatile member function pointer. 170 template<typename _Res, typename _Class, typename... _ArgTypes> 171 struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...) 172 const volatile> 173 { typedef _Res result_type; }; 174 175 template<typename _Res, typename _Class, typename... _ArgTypes> 176 struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......) 177 const volatile> 178 { typedef _Res result_type; }; 179 180 /** 181 * Strip top-level cv-qualifiers from the function object and let 182 * _Weak_result_type_impl perform the real work. 183 */ 184 template<typename _Functor> 185 struct _Weak_result_type 186 : _Weak_result_type_impl<typename remove_cv<_Functor>::type> 187 { }; 188 189 /// Determines if the type _Tp derives from unary_function. 190 template<typename _Tp> 191 struct _Derives_from_unary_function : __sfinae_types 192 { 193 private: 194 template<typename _T1, typename _Res> 195 static __one __test(const volatile unary_function<_T1, _Res>*); 196 197 // It's tempting to change "..." to const volatile void*, but 198 // that fails when _Tp is a function type. 199 static __two __test(...); 200 201 public: 202 static const bool value = sizeof(__test((_Tp*)0)) == 1; 203 }; 204 205 /// Determines if the type _Tp derives from binary_function. 206 template<typename _Tp> 207 struct _Derives_from_binary_function : __sfinae_types 208 { 209 private: 210 template<typename _T1, typename _T2, typename _Res> 211 static __one __test(const volatile binary_function<_T1, _T2, _Res>*); 212 213 // It's tempting to change "..." to const volatile void*, but 214 // that fails when _Tp is a function type. 215 static __two __test(...); 216 217 public: 218 static const bool value = sizeof(__test((_Tp*)0)) == 1; 219 }; 220 221 /** 222 * Invoke a function object, which may be either a member pointer or a 223 * function object. The first parameter will tell which. 224 */ 225 template<typename _Functor, typename... _Args> 226 inline 227 typename enable_if< 228 (!is_member_pointer<_Functor>::value 229 && !is_function<_Functor>::value 230 && !is_function<typename remove_pointer<_Functor>::type>::value), 231 typename result_of<_Functor(_Args&&...)>::type 232 >::type 233 __invoke(_Functor& __f, _Args&&... __args) 234 { 235 return __f(std::forward<_Args>(__args)...); 236 } 237 238 template<typename _Functor, typename... _Args> 239 inline 240 typename enable_if< 241 (is_member_pointer<_Functor>::value 242 && !is_function<_Functor>::value 243 && !is_function<typename remove_pointer<_Functor>::type>::value), 244 typename result_of<_Functor(_Args&&...)>::type 245 >::type 246 __invoke(_Functor& __f, _Args&&... __args) 247 { 248 return std::mem_fn(__f)(std::forward<_Args>(__args)...); 249 } 250 251 // To pick up function references (that will become function pointers) 252 template<typename _Functor, typename... _Args> 253 inline 254 typename enable_if< 255 (is_pointer<_Functor>::value 256 && is_function<typename remove_pointer<_Functor>::type>::value), 257 typename result_of<_Functor(_Args&&...)>::type 258 >::type 259 __invoke(_Functor __f, _Args&&... __args) 260 { 261 return __f(std::forward<_Args>(__args)...); 262 } 263 264 /** 265 * Knowing which of unary_function and binary_function _Tp derives 266 * from, derives from the same and ensures that reference_wrapper 267 * will have a weak result type. See cases below. 268 */ 269 template<bool _Unary, bool _Binary, typename _Tp> 270 struct _Reference_wrapper_base_impl; 271 272 // None of the nested argument types. 273 template<typename _Tp> 274 struct _Reference_wrapper_base_impl<false, false, _Tp> 275 : _Weak_result_type<_Tp> 276 { }; 277 278 // Nested argument_type only. 279 template<typename _Tp> 280 struct _Reference_wrapper_base_impl<true, false, _Tp> 281 : _Weak_result_type<_Tp> 282 { 283 typedef typename _Tp::argument_type argument_type; 284 }; 285 286 // Nested first_argument_type and second_argument_type only. 287 template<typename _Tp> 288 struct _Reference_wrapper_base_impl<false, true, _Tp> 289 : _Weak_result_type<_Tp> 290 { 291 typedef typename _Tp::first_argument_type first_argument_type; 292 typedef typename _Tp::second_argument_type second_argument_type; 293 }; 294 295 // All the nested argument types. 296 template<typename _Tp> 297 struct _Reference_wrapper_base_impl<true, true, _Tp> 298 : _Weak_result_type<_Tp> 299 { 300 typedef typename _Tp::argument_type argument_type; 301 typedef typename _Tp::first_argument_type first_argument_type; 302 typedef typename _Tp::second_argument_type second_argument_type; 303 }; 304 305 _GLIBCXX_HAS_NESTED_TYPE(argument_type) 306 _GLIBCXX_HAS_NESTED_TYPE(first_argument_type) 307 _GLIBCXX_HAS_NESTED_TYPE(second_argument_type) 308 309 /** 310 * Derives from unary_function or binary_function when it 311 * can. Specializations handle all of the easy cases. The primary 312 * template determines what to do with a class type, which may 313 * derive from both unary_function and binary_function. 314 */ 315 template<typename _Tp> 316 struct _Reference_wrapper_base 317 : _Reference_wrapper_base_impl< 318 __has_argument_type<_Tp>::value, 319 __has_first_argument_type<_Tp>::value 320 && __has_second_argument_type<_Tp>::value, 321 _Tp> 322 { }; 323 324 // - a function type (unary) 325 template<typename _Res, typename _T1> 326 struct _Reference_wrapper_base<_Res(_T1)> 327 : unary_function<_T1, _Res> 328 { }; 329 330 template<typename _Res, typename _T1> 331 struct _Reference_wrapper_base<_Res(_T1) const> 332 : unary_function<_T1, _Res> 333 { }; 334 335 template<typename _Res, typename _T1> 336 struct _Reference_wrapper_base<_Res(_T1) volatile> 337 : unary_function<_T1, _Res> 338 { }; 339 340 template<typename _Res, typename _T1> 341 struct _Reference_wrapper_base<_Res(_T1) const volatile> 342 : unary_function<_T1, _Res> 343 { }; 344 345 // - a function type (binary) 346 template<typename _Res, typename _T1, typename _T2> 347 struct _Reference_wrapper_base<_Res(_T1, _T2)> 348 : binary_function<_T1, _T2, _Res> 349 { }; 350 351 template<typename _Res, typename _T1, typename _T2> 352 struct _Reference_wrapper_base<_Res(_T1, _T2) const> 353 : binary_function<_T1, _T2, _Res> 354 { }; 355 356 template<typename _Res, typename _T1, typename _T2> 357 struct _Reference_wrapper_base<_Res(_T1, _T2) volatile> 358 : binary_function<_T1, _T2, _Res> 359 { }; 360 361 template<typename _Res, typename _T1, typename _T2> 362 struct _Reference_wrapper_base<_Res(_T1, _T2) const volatile> 363 : binary_function<_T1, _T2, _Res> 364 { }; 365 366 // - a function pointer type (unary) 367 template<typename _Res, typename _T1> 368 struct _Reference_wrapper_base<_Res(*)(_T1)> 369 : unary_function<_T1, _Res> 370 { }; 371 372 // - a function pointer type (binary) 373 template<typename _Res, typename _T1, typename _T2> 374 struct _Reference_wrapper_base<_Res(*)(_T1, _T2)> 375 : binary_function<_T1, _T2, _Res> 376 { }; 377 378 // - a pointer to member function type (unary, no qualifiers) 379 template<typename _Res, typename _T1> 380 struct _Reference_wrapper_base<_Res (_T1::*)()> 381 : unary_function<_T1*, _Res> 382 { }; 383 384 // - a pointer to member function type (binary, no qualifiers) 385 template<typename _Res, typename _T1, typename _T2> 386 struct _Reference_wrapper_base<_Res (_T1::*)(_T2)> 387 : binary_function<_T1*, _T2, _Res> 388 { }; 389 390 // - a pointer to member function type (unary, const) 391 template<typename _Res, typename _T1> 392 struct _Reference_wrapper_base<_Res (_T1::*)() const> 393 : unary_function<const _T1*, _Res> 394 { }; 395 396 // - a pointer to member function type (binary, const) 397 template<typename _Res, typename _T1, typename _T2> 398 struct _Reference_wrapper_base<_Res (_T1::*)(_T2) const> 399 : binary_function<const _T1*, _T2, _Res> 400 { }; 401 402 // - a pointer to member function type (unary, volatile) 403 template<typename _Res, typename _T1> 404 struct _Reference_wrapper_base<_Res (_T1::*)() volatile> 405 : unary_function<volatile _T1*, _Res> 406 { }; 407 408 // - a pointer to member function type (binary, volatile) 409 template<typename _Res, typename _T1, typename _T2> 410 struct _Reference_wrapper_base<_Res (_T1::*)(_T2) volatile> 411 : binary_function<volatile _T1*, _T2, _Res> 412 { }; 413 414 // - a pointer to member function type (unary, const volatile) 415 template<typename _Res, typename _T1> 416 struct _Reference_wrapper_base<_Res (_T1::*)() const volatile> 417 : unary_function<const volatile _T1*, _Res> 418 { }; 419 420 // - a pointer to member function type (binary, const volatile) 421 template<typename _Res, typename _T1, typename _T2> 422 struct _Reference_wrapper_base<_Res (_T1::*)(_T2) const volatile> 423 : binary_function<const volatile _T1*, _T2, _Res> 424 { }; 425 426 /** 427 * @brief Primary class template for reference_wrapper. 428 * @ingroup functors 429 * @{ 430 */ 431 template<typename _Tp> 432 class reference_wrapper 433 : public _Reference_wrapper_base<typename remove_cv<_Tp>::type> 434 { 435 _Tp* _M_data; 436 437 public: 438 typedef _Tp type; 439 440 reference_wrapper(_Tp& __indata) noexcept 441 : _M_data(std::__addressof(__indata)) 442 { } 443 444 reference_wrapper(_Tp&&) = delete; 445 446 reference_wrapper(const reference_wrapper<_Tp>& __inref) noexcept 447 : _M_data(__inref._M_data) 448 { } 449 450 reference_wrapper& 451 operator=(const reference_wrapper<_Tp>& __inref) noexcept 452 { 453 _M_data = __inref._M_data; 454 return *this; 455 } 456 457 operator _Tp&() const noexcept 458 { return this->get(); } 459 460 _Tp& 461 get() const noexcept 462 { return *_M_data; } 463 464 template<typename... _Args> 465 typename result_of<_Tp&(_Args&&...)>::type 466 operator()(_Args&&... __args) const 467 { 468 return __invoke(get(), std::forward<_Args>(__args)...); 469 } 470 }; 471 472 473 /// Denotes a reference should be taken to a variable. 474 template<typename _Tp> 475 inline reference_wrapper<_Tp> 476 ref(_Tp& __t) noexcept 477 { return reference_wrapper<_Tp>(__t); } 478 479 /// Denotes a const reference should be taken to a variable. 480 template<typename _Tp> 481 inline reference_wrapper<const _Tp> 482 cref(const _Tp& __t) noexcept 483 { return reference_wrapper<const _Tp>(__t); } 484 485 template<typename _Tp> 486 void ref(const _Tp&&) = delete; 487 488 template<typename _Tp> 489 void cref(const _Tp&&) = delete; 490 491 /// Partial specialization. 492 template<typename _Tp> 493 inline reference_wrapper<_Tp> 494 ref(reference_wrapper<_Tp> __t) noexcept 495 { return ref(__t.get()); } 496 497 /// Partial specialization. 498 template<typename _Tp> 499 inline reference_wrapper<const _Tp> 500 cref(reference_wrapper<_Tp> __t) noexcept 501 { return cref(__t.get()); } 502 503 // @} group functors 504 505 /** 506 * Derives from @c unary_function or @c binary_function, or perhaps 507 * nothing, depending on the number of arguments provided. The 508 * primary template is the basis case, which derives nothing. 509 */ 510 template<typename _Res, typename... _ArgTypes> 511 struct _Maybe_unary_or_binary_function { }; 512 513 /// Derives from @c unary_function, as appropriate. 514 template<typename _Res, typename _T1> 515 struct _Maybe_unary_or_binary_function<_Res, _T1> 516 : std::unary_function<_T1, _Res> { }; 517 518 /// Derives from @c binary_function, as appropriate. 519 template<typename _Res, typename _T1, typename _T2> 520 struct _Maybe_unary_or_binary_function<_Res, _T1, _T2> 521 : std::binary_function<_T1, _T2, _Res> { }; 522 523 /// Implementation of @c mem_fn for member function pointers. 524 template<typename _Res, typename _Class, typename... _ArgTypes> 525 class _Mem_fn<_Res (_Class::*)(_ArgTypes...)> 526 : public _Maybe_unary_or_binary_function<_Res, _Class*, _ArgTypes...> 527 { 528 typedef _Res (_Class::*_Functor)(_ArgTypes...); 529 530 template<typename _Tp> 531 _Res 532 _M_call(_Tp& __object, const volatile _Class *, 533 _ArgTypes... __args) const 534 { return (__object.*__pmf)(std::forward<_ArgTypes>(__args)...); } 535 536 template<typename _Tp> 537 _Res 538 _M_call(_Tp& __ptr, const volatile void *, _ArgTypes... __args) const 539 { return ((*__ptr).*__pmf)(std::forward<_ArgTypes>(__args)...); } 540 541 public: 542 typedef _Res result_type; 543 544 explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { } 545 546 // Handle objects 547 _Res 548 operator()(_Class& __object, _ArgTypes... __args) const 549 { return (__object.*__pmf)(std::forward<_ArgTypes>(__args)...); } 550 551 // Handle pointers 552 _Res 553 operator()(_Class* __object, _ArgTypes... __args) const 554 { return (__object->*__pmf)(std::forward<_ArgTypes>(__args)...); } 555 556 // Handle smart pointers, references and pointers to derived 557 template<typename _Tp> 558 _Res 559 operator()(_Tp& __object, _ArgTypes... __args) const 560 { 561 return _M_call(__object, &__object, 562 std::forward<_ArgTypes>(__args)...); 563 } 564 565 private: 566 _Functor __pmf; 567 }; 568 569 /// Implementation of @c mem_fn for const member function pointers. 570 template<typename _Res, typename _Class, typename... _ArgTypes> 571 class _Mem_fn<_Res (_Class::*)(_ArgTypes...) const> 572 : public _Maybe_unary_or_binary_function<_Res, const _Class*, 573 _ArgTypes...> 574 { 575 typedef _Res (_Class::*_Functor)(_ArgTypes...) const; 576 577 template<typename _Tp> 578 _Res 579 _M_call(_Tp& __object, const volatile _Class *, 580 _ArgTypes... __args) const 581 { return (__object.*__pmf)(std::forward<_ArgTypes>(__args)...); } 582 583 template<typename _Tp> 584 _Res 585 _M_call(_Tp& __ptr, const volatile void *, _ArgTypes... __args) const 586 { return ((*__ptr).*__pmf)(std::forward<_ArgTypes>(__args)...); } 587 588 public: 589 typedef _Res result_type; 590 591 explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { } 592 593 // Handle objects 594 _Res 595 operator()(const _Class& __object, _ArgTypes... __args) const 596 { return (__object.*__pmf)(std::forward<_ArgTypes>(__args)...); } 597 598 // Handle pointers 599 _Res 600 operator()(const _Class* __object, _ArgTypes... __args) const 601 { return (__object->*__pmf)(std::forward<_ArgTypes>(__args)...); } 602 603 // Handle smart pointers, references and pointers to derived 604 template<typename _Tp> 605 _Res operator()(_Tp& __object, _ArgTypes... __args) const 606 { 607 return _M_call(__object, &__object, 608 std::forward<_ArgTypes>(__args)...); 609 } 610 611 private: 612 _Functor __pmf; 613 }; 614 615 /// Implementation of @c mem_fn for volatile member function pointers. 616 template<typename _Res, typename _Class, typename... _ArgTypes> 617 class _Mem_fn<_Res (_Class::*)(_ArgTypes...) volatile> 618 : public _Maybe_unary_or_binary_function<_Res, volatile _Class*, 619 _ArgTypes...> 620 { 621 typedef _Res (_Class::*_Functor)(_ArgTypes...) volatile; 622 623 template<typename _Tp> 624 _Res 625 _M_call(_Tp& __object, const volatile _Class *, 626 _ArgTypes... __args) const 627 { return (__object.*__pmf)(std::forward<_ArgTypes>(__args)...); } 628 629 template<typename _Tp> 630 _Res 631 _M_call(_Tp& __ptr, const volatile void *, _ArgTypes... __args) const 632 { return ((*__ptr).*__pmf)(std::forward<_ArgTypes>(__args)...); } 633 634 public: 635 typedef _Res result_type; 636 637 explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { } 638 639 // Handle objects 640 _Res 641 operator()(volatile _Class& __object, _ArgTypes... __args) const 642 { return (__object.*__pmf)(std::forward<_ArgTypes>(__args)...); } 643 644 // Handle pointers 645 _Res 646 operator()(volatile _Class* __object, _ArgTypes... __args) const 647 { return (__object->*__pmf)(std::forward<_ArgTypes>(__args)...); } 648 649 // Handle smart pointers, references and pointers to derived 650 template<typename _Tp> 651 _Res 652 operator()(_Tp& __object, _ArgTypes... __args) const 653 { 654 return _M_call(__object, &__object, 655 std::forward<_ArgTypes>(__args)...); 656 } 657 658 private: 659 _Functor __pmf; 660 }; 661 662 /// Implementation of @c mem_fn for const volatile member function pointers. 663 template<typename _Res, typename _Class, typename... _ArgTypes> 664 class _Mem_fn<_Res (_Class::*)(_ArgTypes...) const volatile> 665 : public _Maybe_unary_or_binary_function<_Res, const volatile _Class*, 666 _ArgTypes...> 667 { 668 typedef _Res (_Class::*_Functor)(_ArgTypes...) const volatile; 669 670 template<typename _Tp> 671 _Res 672 _M_call(_Tp& __object, const volatile _Class *, 673 _ArgTypes... __args) const 674 { return (__object.*__pmf)(std::forward<_ArgTypes>(__args)...); } 675 676 template<typename _Tp> 677 _Res 678 _M_call(_Tp& __ptr, const volatile void *, _ArgTypes... __args) const 679 { return ((*__ptr).*__pmf)(std::forward<_ArgTypes>(__args)...); } 680 681 public: 682 typedef _Res result_type; 683 684 explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { } 685 686 // Handle objects 687 _Res 688 operator()(const volatile _Class& __object, _ArgTypes... __args) const 689 { return (__object.*__pmf)(std::forward<_ArgTypes>(__args)...); } 690 691 // Handle pointers 692 _Res 693 operator()(const volatile _Class* __object, _ArgTypes... __args) const 694 { return (__object->*__pmf)(std::forward<_ArgTypes>(__args)...); } 695 696 // Handle smart pointers, references and pointers to derived 697 template<typename _Tp> 698 _Res operator()(_Tp& __object, _ArgTypes... __args) const 699 { 700 return _M_call(__object, &__object, 701 std::forward<_ArgTypes>(__args)...); 702 } 703 704 private: 705 _Functor __pmf; 706 }; 707 708 709 template<typename _Tp, bool> 710 struct _Mem_fn_const_or_non 711 { 712 typedef const _Tp& type; 713 }; 714 715 template<typename _Tp> 716 struct _Mem_fn_const_or_non<_Tp, false> 717 { 718 typedef _Tp& type; 719 }; 720 721 template<typename _Res, typename _Class> 722 class _Mem_fn<_Res _Class::*> 723 { 724 // This bit of genius is due to Peter Dimov, improved slightly by 725 // Douglas Gregor. 726 template<typename _Tp> 727 _Res& 728 _M_call(_Tp& __object, _Class *) const 729 { return __object.*__pm; } 730 731 template<typename _Tp, typename _Up> 732 _Res& 733 _M_call(_Tp& __object, _Up * const *) const 734 { return (*__object).*__pm; } 735 736 template<typename _Tp, typename _Up> 737 const _Res& 738 _M_call(_Tp& __object, const _Up * const *) const 739 { return (*__object).*__pm; } 740 741 template<typename _Tp> 742 const _Res& 743 _M_call(_Tp& __object, const _Class *) const 744 { return __object.*__pm; } 745 746 template<typename _Tp> 747 const _Res& 748 _M_call(_Tp& __ptr, const volatile void*) const 749 { return (*__ptr).*__pm; } 750 751 template<typename _Tp> static _Tp& __get_ref(); 752 753 template<typename _Tp> 754 static __sfinae_types::__one __check_const(_Tp&, _Class*); 755 template<typename _Tp, typename _Up> 756 static __sfinae_types::__one __check_const(_Tp&, _Up * const *); 757 template<typename _Tp, typename _Up> 758 static __sfinae_types::__two __check_const(_Tp&, const _Up * const *); 759 template<typename _Tp> 760 static __sfinae_types::__two __check_const(_Tp&, const _Class*); 761 template<typename _Tp> 762 static __sfinae_types::__two __check_const(_Tp&, const volatile void*); 763 764 public: 765 template<typename _Tp> 766 struct _Result_type 767 : _Mem_fn_const_or_non<_Res, 768 (sizeof(__sfinae_types::__two) 769 == sizeof(__check_const<_Tp>(__get_ref<_Tp>(), (_Tp*)0)))> 770 { }; 771 772 template<typename _Signature> 773 struct result; 774 775 template<typename _CVMem, typename _Tp> 776 struct result<_CVMem(_Tp)> 777 : public _Result_type<_Tp> { }; 778 779 template<typename _CVMem, typename _Tp> 780 struct result<_CVMem(_Tp&)> 781 : public _Result_type<_Tp> { }; 782 783 explicit 784 _Mem_fn(_Res _Class::*__pm) : __pm(__pm) { } 785 786 // Handle objects 787 _Res& 788 operator()(_Class& __object) const 789 { return __object.*__pm; } 790 791 const _Res& 792 operator()(const _Class& __object) const 793 { return __object.*__pm; } 794 795 // Handle pointers 796 _Res& 797 operator()(_Class* __object) const 798 { return __object->*__pm; } 799 800 const _Res& 801 operator()(const _Class* __object) const 802 { return __object->*__pm; } 803 804 // Handle smart pointers and derived 805 template<typename _Tp> 806 typename _Result_type<_Tp>::type 807 operator()(_Tp& __unknown) const 808 { return _M_call(__unknown, &__unknown); } 809 810 private: 811 _Res _Class::*__pm; 812 }; 813 814 /** 815 * @brief Returns a function object that forwards to the member 816 * pointer @a pm. 817 * @ingroup functors 818 */ 819 template<typename _Tp, typename _Class> 820 inline _Mem_fn<_Tp _Class::*> 821 mem_fn(_Tp _Class::* __pm) 822 { 823 return _Mem_fn<_Tp _Class::*>(__pm); 824 } 825 826 /** 827 * @brief Determines if the given type _Tp is a function object 828 * should be treated as a subexpression when evaluating calls to 829 * function objects returned by bind(). [TR1 3.6.1] 830 * @ingroup binders 831 */ 832 template<typename _Tp> 833 struct is_bind_expression 834 : public false_type { }; 835 836 /** 837 * @brief Determines if the given type _Tp is a placeholder in a 838 * bind() expression and, if so, which placeholder it is. [TR1 3.6.2] 839 * @ingroup binders 840 */ 841 template<typename _Tp> 842 struct is_placeholder 843 : public integral_constant<int, 0> 844 { }; 845 846 /** @brief The type of placeholder objects defined by libstdc++. 847 * @ingroup binders 848 */ 849 template<int _Num> struct _Placeholder { }; 850 851 _GLIBCXX_END_NAMESPACE_VERSION 852 853 /** @namespace std::placeholders 854 * @brief ISO C++11 entities sub-namespace for functional. 855 * @ingroup binders 856 */ 857 namespace placeholders 858 { 859 _GLIBCXX_BEGIN_NAMESPACE_VERSION 860 /* Define a large number of placeholders. There is no way to 861 * simplify this with variadic templates, because we're introducing 862 * unique names for each. 863 */ 864 extern const _Placeholder<1> _1; 865 extern const _Placeholder<2> _2; 866 extern const _Placeholder<3> _3; 867 extern const _Placeholder<4> _4; 868 extern const _Placeholder<5> _5; 869 extern const _Placeholder<6> _6; 870 extern const _Placeholder<7> _7; 871 extern const _Placeholder<8> _8; 872 extern const _Placeholder<9> _9; 873 extern const _Placeholder<10> _10; 874 extern const _Placeholder<11> _11; 875 extern const _Placeholder<12> _12; 876 extern const _Placeholder<13> _13; 877 extern const _Placeholder<14> _14; 878 extern const _Placeholder<15> _15; 879 extern const _Placeholder<16> _16; 880 extern const _Placeholder<17> _17; 881 extern const _Placeholder<18> _18; 882 extern const _Placeholder<19> _19; 883 extern const _Placeholder<20> _20; 884 extern const _Placeholder<21> _21; 885 extern const _Placeholder<22> _22; 886 extern const _Placeholder<23> _23; 887 extern const _Placeholder<24> _24; 888 extern const _Placeholder<25> _25; 889 extern const _Placeholder<26> _26; 890 extern const _Placeholder<27> _27; 891 extern const _Placeholder<28> _28; 892 extern const _Placeholder<29> _29; 893 _GLIBCXX_END_NAMESPACE_VERSION 894 } 895 896 _GLIBCXX_BEGIN_NAMESPACE_VERSION 897 898 /** 899 * Partial specialization of is_placeholder that provides the placeholder 900 * number for the placeholder objects defined by libstdc++. 901 * @ingroup binders 902 */ 903 template<int _Num> 904 struct is_placeholder<_Placeholder<_Num> > 905 : public integral_constant<int, _Num> 906 { }; 907 908 template<int _Num> 909 struct is_placeholder<const _Placeholder<_Num> > 910 : public integral_constant<int, _Num> 911 { }; 912 913 /** 914 * Used by _Safe_tuple_element to indicate that there is no tuple 915 * element at this position. 916 */ 917 struct _No_tuple_element; 918 919 /** 920 * Implementation helper for _Safe_tuple_element. This primary 921 * template handles the case where it is safe to use @c 922 * tuple_element. 923 */ 924 template<std::size_t __i, typename _Tuple, bool _IsSafe> 925 struct _Safe_tuple_element_impl 926 : tuple_element<__i, _Tuple> { }; 927 928 /** 929 * Implementation helper for _Safe_tuple_element. This partial 930 * specialization handles the case where it is not safe to use @c 931 * tuple_element. We just return @c _No_tuple_element. 932 */ 933 template<std::size_t __i, typename _Tuple> 934 struct _Safe_tuple_element_impl<__i, _Tuple, false> 935 { 936 typedef _No_tuple_element type; 937 }; 938 939 /** 940 * Like tuple_element, but returns @c _No_tuple_element when 941 * tuple_element would return an error. 942 */ 943 template<std::size_t __i, typename _Tuple> 944 struct _Safe_tuple_element 945 : _Safe_tuple_element_impl<__i, _Tuple, 946 (__i < tuple_size<_Tuple>::value)> 947 { }; 948 949 /** 950 * Maps an argument to bind() into an actual argument to the bound 951 * function object [TR1 3.6.3/5]. Only the first parameter should 952 * be specified: the rest are used to determine among the various 953 * implementations. Note that, although this class is a function 954 * object, it isn't entirely normal because it takes only two 955 * parameters regardless of the number of parameters passed to the 956 * bind expression. The first parameter is the bound argument and 957 * the second parameter is a tuple containing references to the 958 * rest of the arguments. 959 */ 960 template<typename _Arg, 961 bool _IsBindExp = is_bind_expression<_Arg>::value, 962 bool _IsPlaceholder = (is_placeholder<_Arg>::value > 0)> 963 class _Mu; 964 965 /** 966 * If the argument is reference_wrapper<_Tp>, returns the 967 * underlying reference. [TR1 3.6.3/5 bullet 1] 968 */ 969 template<typename _Tp> 970 class _Mu<reference_wrapper<_Tp>, false, false> 971 { 972 public: 973 typedef _Tp& result_type; 974 975 /* Note: This won't actually work for const volatile 976 * reference_wrappers, because reference_wrapper::get() is const 977 * but not volatile-qualified. This might be a defect in the TR. 978 */ 979 template<typename _CVRef, typename _Tuple> 980 result_type 981 operator()(_CVRef& __arg, _Tuple&) const volatile 982 { return __arg.get(); } 983 }; 984 985 /** 986 * If the argument is a bind expression, we invoke the underlying 987 * function object with the same cv-qualifiers as we are given and 988 * pass along all of our arguments (unwrapped). [TR1 3.6.3/5 bullet 2] 989 */ 990 template<typename _Arg> 991 class _Mu<_Arg, true, false> 992 { 993 public: 994 template<typename _CVArg, typename... _Args> 995 auto 996 operator()(_CVArg& __arg, 997 tuple<_Args...>& __tuple) const volatile 998 -> decltype(__arg(declval<_Args>()...)) 999 { 1000 // Construct an index tuple and forward to __call 1001 typedef typename _Build_index_tuple<sizeof...(_Args)>::__type 1002 _Indexes; 1003 return this->__call(__arg, __tuple, _Indexes()); 1004 } 1005 1006 private: 1007 // Invokes the underlying function object __arg by unpacking all 1008 // of the arguments in the tuple. 1009 template<typename _CVArg, typename... _Args, std::size_t... _Indexes> 1010 auto 1011 __call(_CVArg& __arg, tuple<_Args...>& __tuple, 1012 const _Index_tuple<_Indexes...>&) const volatile 1013 -> decltype(__arg(declval<_Args>()...)) 1014 { 1015 return __arg(std::forward<_Args>(get<_Indexes>(__tuple))...); 1016 } 1017 }; 1018 1019 /** 1020 * If the argument is a placeholder for the Nth argument, returns 1021 * a reference to the Nth argument to the bind function object. 1022 * [TR1 3.6.3/5 bullet 3] 1023 */ 1024 template<typename _Arg> 1025 class _Mu<_Arg, false, true> 1026 { 1027 public: 1028 template<typename _Signature> class result; 1029 1030 template<typename _CVMu, typename _CVArg, typename _Tuple> 1031 class result<_CVMu(_CVArg, _Tuple)> 1032 { 1033 // Add a reference, if it hasn't already been done for us. 1034 // This allows us to be a little bit sloppy in constructing 1035 // the tuple that we pass to result_of<...>. 1036 typedef typename _Safe_tuple_element<(is_placeholder<_Arg>::value 1037 - 1), _Tuple>::type 1038 __base_type; 1039 1040 public: 1041 typedef typename add_rvalue_reference<__base_type>::type type; 1042 }; 1043 1044 template<typename _Tuple> 1045 typename result<_Mu(_Arg, _Tuple)>::type 1046 operator()(const volatile _Arg&, _Tuple& __tuple) const volatile 1047 { 1048 return std::forward<typename result<_Mu(_Arg, _Tuple)>::type>( 1049 ::std::get<(is_placeholder<_Arg>::value - 1)>(__tuple)); 1050 } 1051 }; 1052 1053 /** 1054 * If the argument is just a value, returns a reference to that 1055 * value. The cv-qualifiers on the reference are the same as the 1056 * cv-qualifiers on the _Mu object. [TR1 3.6.3/5 bullet 4] 1057 */ 1058 template<typename _Arg> 1059 class _Mu<_Arg, false, false> 1060 { 1061 public: 1062 template<typename _Signature> struct result; 1063 1064 template<typename _CVMu, typename _CVArg, typename _Tuple> 1065 struct result<_CVMu(_CVArg, _Tuple)> 1066 { 1067 typedef typename add_lvalue_reference<_CVArg>::type type; 1068 }; 1069 1070 // Pick up the cv-qualifiers of the argument 1071 template<typename _CVArg, typename _Tuple> 1072 _CVArg&& 1073 operator()(_CVArg&& __arg, _Tuple&) const volatile 1074 { return std::forward<_CVArg>(__arg); } 1075 }; 1076 1077 /** 1078 * Maps member pointers into instances of _Mem_fn but leaves all 1079 * other function objects untouched. Used by tr1::bind(). The 1080 * primary template handles the non--member-pointer case. 1081 */ 1082 template<typename _Tp> 1083 struct _Maybe_wrap_member_pointer 1084 { 1085 typedef _Tp type; 1086 1087 static const _Tp& 1088 __do_wrap(const _Tp& __x) 1089 { return __x; } 1090 1091 static _Tp&& 1092 __do_wrap(_Tp&& __x) 1093 { return static_cast<_Tp&&>(__x); } 1094 }; 1095 1096 /** 1097 * Maps member pointers into instances of _Mem_fn but leaves all 1098 * other function objects untouched. Used by tr1::bind(). This 1099 * partial specialization handles the member pointer case. 1100 */ 1101 template<typename _Tp, typename _Class> 1102 struct _Maybe_wrap_member_pointer<_Tp _Class::*> 1103 { 1104 typedef _Mem_fn<_Tp _Class::*> type; 1105 1106 static type 1107 __do_wrap(_Tp _Class::* __pm) 1108 { return type(__pm); } 1109 }; 1110 1111 // Specialization needed to prevent "forming reference to void" errors when 1112 // bind<void>() is called, because argument deduction instantiates 1113 // _Maybe_wrap_member_pointer<void> outside the immediate context where 1114 // SFINAE applies. 1115 template<> 1116 struct _Maybe_wrap_member_pointer<void> 1117 { 1118 typedef void type; 1119 }; 1120 1121 // std::get<I> for volatile-qualified tuples 1122 template<std::size_t _Ind, typename... _Tp> 1123 inline auto 1124 __volget(volatile tuple<_Tp...>& __tuple) 1125 -> typename tuple_element<_Ind, tuple<_Tp...>>::type volatile& 1126 { return std::get<_Ind>(const_cast<tuple<_Tp...>&>(__tuple)); } 1127 1128 // std::get<I> for const-volatile-qualified tuples 1129 template<std::size_t _Ind, typename... _Tp> 1130 inline auto 1131 __volget(const volatile tuple<_Tp...>& __tuple) 1132 -> typename tuple_element<_Ind, tuple<_Tp...>>::type const volatile& 1133 { return std::get<_Ind>(const_cast<const tuple<_Tp...>&>(__tuple)); } 1134 1135 /// Type of the function object returned from bind(). 1136 template<typename _Signature> 1137 struct _Bind; 1138 1139 template<typename _Functor, typename... _Bound_args> 1140 class _Bind<_Functor(_Bound_args...)> 1141 : public _Weak_result_type<_Functor> 1142 { 1143 typedef _Bind __self_type; 1144 typedef typename _Build_index_tuple<sizeof...(_Bound_args)>::__type 1145 _Bound_indexes; 1146 1147 _Functor _M_f; 1148 tuple<_Bound_args...> _M_bound_args; 1149 1150 // Call unqualified 1151 template<typename _Result, typename... _Args, std::size_t... _Indexes> 1152 _Result 1153 __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>) 1154 { 1155 return _M_f(_Mu<_Bound_args>() 1156 (get<_Indexes>(_M_bound_args), __args)...); 1157 } 1158 1159 // Call as const 1160 template<typename _Result, typename... _Args, std::size_t... _Indexes> 1161 _Result 1162 __call_c(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>) const 1163 { 1164 return _M_f(_Mu<_Bound_args>() 1165 (get<_Indexes>(_M_bound_args), __args)...); 1166 } 1167 1168 // Call as volatile 1169 template<typename _Result, typename... _Args, std::size_t... _Indexes> 1170 _Result 1171 __call_v(tuple<_Args...>&& __args, 1172 _Index_tuple<_Indexes...>) volatile 1173 { 1174 return _M_f(_Mu<_Bound_args>() 1175 (__volget<_Indexes>(_M_bound_args), __args)...); 1176 } 1177 1178 // Call as const volatile 1179 template<typename _Result, typename... _Args, std::size_t... _Indexes> 1180 _Result 1181 __call_c_v(tuple<_Args...>&& __args, 1182 _Index_tuple<_Indexes...>) const volatile 1183 { 1184 return _M_f(_Mu<_Bound_args>() 1185 (__volget<_Indexes>(_M_bound_args), __args)...); 1186 } 1187 1188 public: 1189 template<typename... _Args> 1190 explicit _Bind(const _Functor& __f, _Args&&... __args) 1191 : _M_f(__f), _M_bound_args(std::forward<_Args>(__args)...) 1192 { } 1193 1194 template<typename... _Args> 1195 explicit _Bind(_Functor&& __f, _Args&&... __args) 1196 : _M_f(std::move(__f)), _M_bound_args(std::forward<_Args>(__args)...) 1197 { } 1198 1199 _Bind(const _Bind&) = default; 1200 1201 _Bind(_Bind&& __b) 1202 : _M_f(std::move(__b._M_f)), _M_bound_args(std::move(__b._M_bound_args)) 1203 { } 1204 1205 // Call unqualified 1206 template<typename... _Args, typename _Result 1207 = decltype( std::declval<_Functor>()( 1208 _Mu<_Bound_args>()( std::declval<_Bound_args&>(), 1209 std::declval<tuple<_Args...>&>() )... ) )> 1210 _Result 1211 operator()(_Args&&... __args) 1212 { 1213 return this->__call<_Result>( 1214 std::forward_as_tuple(std::forward<_Args>(__args)...), 1215 _Bound_indexes()); 1216 } 1217 1218 // Call as const 1219 template<typename... _Args, typename _Result 1220 = decltype( std::declval<typename enable_if<(sizeof...(_Args) >= 0), 1221 typename add_const<_Functor>::type>::type>()( 1222 _Mu<_Bound_args>()( std::declval<const _Bound_args&>(), 1223 std::declval<tuple<_Args...>&>() )... ) )> 1224 _Result 1225 operator()(_Args&&... __args) const 1226 { 1227 return this->__call_c<_Result>( 1228 std::forward_as_tuple(std::forward<_Args>(__args)...), 1229 _Bound_indexes()); 1230 } 1231 1232 // Call as volatile 1233 template<typename... _Args, typename _Result 1234 = decltype( std::declval<typename enable_if<(sizeof...(_Args) >= 0), 1235 typename add_volatile<_Functor>::type>::type>()( 1236 _Mu<_Bound_args>()( std::declval<volatile _Bound_args&>(), 1237 std::declval<tuple<_Args...>&>() )... ) )> 1238 _Result 1239 operator()(_Args&&... __args) volatile 1240 { 1241 return this->__call_v<_Result>( 1242 std::forward_as_tuple(std::forward<_Args>(__args)...), 1243 _Bound_indexes()); 1244 } 1245 1246 // Call as const volatile 1247 template<typename... _Args, typename _Result 1248 = decltype( std::declval<typename enable_if<(sizeof...(_Args) >= 0), 1249 typename add_cv<_Functor>::type>::type>()( 1250 _Mu<_Bound_args>()( std::declval<const volatile _Bound_args&>(), 1251 std::declval<tuple<_Args...>&>() )... ) )> 1252 _Result 1253 operator()(_Args&&... __args) const volatile 1254 { 1255 return this->__call_c_v<_Result>( 1256 std::forward_as_tuple(std::forward<_Args>(__args)...), 1257 _Bound_indexes()); 1258 } 1259 }; 1260 1261 /// Type of the function object returned from bind<R>(). 1262 template<typename _Result, typename _Signature> 1263 struct _Bind_result; 1264 1265 template<typename _Result, typename _Functor, typename... _Bound_args> 1266 class _Bind_result<_Result, _Functor(_Bound_args...)> 1267 { 1268 typedef _Bind_result __self_type; 1269 typedef typename _Build_index_tuple<sizeof...(_Bound_args)>::__type 1270 _Bound_indexes; 1271 1272 _Functor _M_f; 1273 tuple<_Bound_args...> _M_bound_args; 1274 1275 // sfinae types 1276 template<typename _Res> 1277 struct __enable_if_void : enable_if<is_void<_Res>::value, int> { }; 1278 template<typename _Res> 1279 struct __disable_if_void : enable_if<!is_void<_Res>::value, int> { }; 1280 1281 // Call unqualified 1282 template<typename _Res, typename... _Args, std::size_t... _Indexes> 1283 _Result 1284 __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>, 1285 typename __disable_if_void<_Res>::type = 0) 1286 { 1287 return _M_f(_Mu<_Bound_args>() 1288 (get<_Indexes>(_M_bound_args), __args)...); 1289 } 1290 1291 // Call unqualified, return void 1292 template<typename _Res, typename... _Args, std::size_t... _Indexes> 1293 void 1294 __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>, 1295 typename __enable_if_void<_Res>::type = 0) 1296 { 1297 _M_f(_Mu<_Bound_args>() 1298 (get<_Indexes>(_M_bound_args), __args)...); 1299 } 1300 1301 // Call as const 1302 template<typename _Res, typename... _Args, std::size_t... _Indexes> 1303 _Result 1304 __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>, 1305 typename __disable_if_void<_Res>::type = 0) const 1306 { 1307 return _M_f(_Mu<_Bound_args>() 1308 (get<_Indexes>(_M_bound_args), __args)...); 1309 } 1310 1311 // Call as const, return void 1312 template<typename _Res, typename... _Args, std::size_t... _Indexes> 1313 void 1314 __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>, 1315 typename __enable_if_void<_Res>::type = 0) const 1316 { 1317 _M_f(_Mu<_Bound_args>() 1318 (get<_Indexes>(_M_bound_args), __args)...); 1319 } 1320 1321 // Call as volatile 1322 template<typename _Res, typename... _Args, std::size_t... _Indexes> 1323 _Result 1324 __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>, 1325 typename __disable_if_void<_Res>::type = 0) volatile 1326 { 1327 return _M_f(_Mu<_Bound_args>() 1328 (__volget<_Indexes>(_M_bound_args), __args)...); 1329 } 1330 1331 // Call as volatile, return void 1332 template<typename _Res, typename... _Args, std::size_t... _Indexes> 1333 void 1334 __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>, 1335 typename __enable_if_void<_Res>::type = 0) volatile 1336 { 1337 _M_f(_Mu<_Bound_args>() 1338 (__volget<_Indexes>(_M_bound_args), __args)...); 1339 } 1340 1341 // Call as const volatile 1342 template<typename _Res, typename... _Args, std::size_t... _Indexes> 1343 _Result 1344 __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>, 1345 typename __disable_if_void<_Res>::type = 0) const volatile 1346 { 1347 return _M_f(_Mu<_Bound_args>() 1348 (__volget<_Indexes>(_M_bound_args), __args)...); 1349 } 1350 1351 // Call as const volatile, return void 1352 template<typename _Res, typename... _Args, std::size_t... _Indexes> 1353 void 1354 __call(tuple<_Args...>&& __args, 1355 _Index_tuple<_Indexes...>, 1356 typename __enable_if_void<_Res>::type = 0) const volatile 1357 { 1358 _M_f(_Mu<_Bound_args>() 1359 (__volget<_Indexes>(_M_bound_args), __args)...); 1360 } 1361 1362 public: 1363 typedef _Result result_type; 1364 1365 template<typename... _Args> 1366 explicit _Bind_result(const _Functor& __f, _Args&&... __args) 1367 : _M_f(__f), _M_bound_args(std::forward<_Args>(__args)...) 1368 { } 1369 1370 template<typename... _Args> 1371 explicit _Bind_result(_Functor&& __f, _Args&&... __args) 1372 : _M_f(std::move(__f)), _M_bound_args(std::forward<_Args>(__args)...) 1373 { } 1374 1375 _Bind_result(const _Bind_result&) = default; 1376 1377 _Bind_result(_Bind_result&& __b) 1378 : _M_f(std::move(__b._M_f)), _M_bound_args(std::move(__b._M_bound_args)) 1379 { } 1380 1381 // Call unqualified 1382 template<typename... _Args> 1383 result_type 1384 operator()(_Args&&... __args) 1385 { 1386 return this->__call<_Result>( 1387 std::forward_as_tuple(std::forward<_Args>(__args)...), 1388 _Bound_indexes()); 1389 } 1390 1391 // Call as const 1392 template<typename... _Args> 1393 result_type 1394 operator()(_Args&&... __args) const 1395 { 1396 return this->__call<_Result>( 1397 std::forward_as_tuple(std::forward<_Args>(__args)...), 1398 _Bound_indexes()); 1399 } 1400 1401 // Call as volatile 1402 template<typename... _Args> 1403 result_type 1404 operator()(_Args&&... __args) volatile 1405 { 1406 return this->__call<_Result>( 1407 std::forward_as_tuple(std::forward<_Args>(__args)...), 1408 _Bound_indexes()); 1409 } 1410 1411 // Call as const volatile 1412 template<typename... _Args> 1413 result_type 1414 operator()(_Args&&... __args) const volatile 1415 { 1416 return this->__call<_Result>( 1417 std::forward_as_tuple(std::forward<_Args>(__args)...), 1418 _Bound_indexes()); 1419 } 1420 }; 1421 1422 /** 1423 * @brief Class template _Bind is always a bind expression. 1424 * @ingroup binders 1425 */ 1426 template<typename _Signature> 1427 struct is_bind_expression<_Bind<_Signature> > 1428 : public true_type { }; 1429 1430 /** 1431 * @brief Class template _Bind is always a bind expression. 1432 * @ingroup binders 1433 */ 1434 template<typename _Signature> 1435 struct is_bind_expression<const _Bind<_Signature> > 1436 : public true_type { }; 1437 1438 /** 1439 * @brief Class template _Bind is always a bind expression. 1440 * @ingroup binders 1441 */ 1442 template<typename _Signature> 1443 struct is_bind_expression<volatile _Bind<_Signature> > 1444 : public true_type { }; 1445 1446 /** 1447 * @brief Class template _Bind is always a bind expression. 1448 * @ingroup binders 1449 */ 1450 template<typename _Signature> 1451 struct is_bind_expression<const volatile _Bind<_Signature>> 1452 : public true_type { }; 1453 1454 /** 1455 * @brief Class template _Bind_result is always a bind expression. 1456 * @ingroup binders 1457 */ 1458 template<typename _Result, typename _Signature> 1459 struct is_bind_expression<_Bind_result<_Result, _Signature>> 1460 : public true_type { }; 1461 1462 /** 1463 * @brief Class template _Bind_result is always a bind expression. 1464 * @ingroup binders 1465 */ 1466 template<typename _Result, typename _Signature> 1467 struct is_bind_expression<const _Bind_result<_Result, _Signature>> 1468 : public true_type { }; 1469 1470 /** 1471 * @brief Class template _Bind_result is always a bind expression. 1472 * @ingroup binders 1473 */ 1474 template<typename _Result, typename _Signature> 1475 struct is_bind_expression<volatile _Bind_result<_Result, _Signature>> 1476 : public true_type { }; 1477 1478 /** 1479 * @brief Class template _Bind_result is always a bind expression. 1480 * @ingroup binders 1481 */ 1482 template<typename _Result, typename _Signature> 1483 struct is_bind_expression<const volatile _Bind_result<_Result, _Signature>> 1484 : public true_type { }; 1485 1486 // Trait type used to remove std::bind() from overload set via SFINAE 1487 // when first argument has integer type, so that std::bind() will 1488 // not be a better match than ::bind() from the BSD Sockets API. 1489 template<typename _Tp> 1490 class __is_socketlike 1491 { 1492 typedef typename decay<_Tp>::type _Tp2; 1493 public: 1494 static const bool value = 1495 is_integral<_Tp2>::value || is_enum<_Tp2>::value; 1496 }; 1497 1498 template<bool _SocketLike, typename _Func, typename... _BoundArgs> 1499 struct _Bind_helper 1500 { 1501 typedef _Maybe_wrap_member_pointer<typename decay<_Func>::type> 1502 __maybe_type; 1503 typedef typename __maybe_type::type __func_type; 1504 typedef _Bind<__func_type(typename decay<_BoundArgs>::type...)> type; 1505 }; 1506 1507 // Partial specialization for is_socketlike == true, does not define 1508 // nested type so std::bind() will not participate in overload resolution 1509 // when the first argument might be a socket file descriptor. 1510 template<typename _Func, typename... _BoundArgs> 1511 struct _Bind_helper<true, _Func, _BoundArgs...> 1512 { }; 1513 1514 /** 1515 * @brief Function template for std::bind. 1516 * @ingroup binders 1517 */ 1518 template<typename _Func, typename... _BoundArgs> 1519 inline typename 1520 _Bind_helper<__is_socketlike<_Func>::value, _Func, _BoundArgs...>::type 1521 bind(_Func&& __f, _BoundArgs&&... __args) 1522 { 1523 typedef _Bind_helper<false, _Func, _BoundArgs...> __helper_type; 1524 typedef typename __helper_type::__maybe_type __maybe_type; 1525 typedef typename __helper_type::type __result_type; 1526 return __result_type(__maybe_type::__do_wrap(std::forward<_Func>(__f)), 1527 std::forward<_BoundArgs>(__args)...); 1528 } 1529 1530 template<typename _Result, typename _Func, typename... _BoundArgs> 1531 struct _Bindres_helper 1532 { 1533 typedef _Maybe_wrap_member_pointer<typename decay<_Func>::type> 1534 __maybe_type; 1535 typedef typename __maybe_type::type __functor_type; 1536 typedef _Bind_result<_Result, 1537 __functor_type(typename decay<_BoundArgs>::type...)> 1538 type; 1539 }; 1540 1541 /** 1542 * @brief Function template for std::bind<R>. 1543 * @ingroup binders 1544 */ 1545 template<typename _Result, typename _Func, typename... _BoundArgs> 1546 inline 1547 typename _Bindres_helper<_Result, _Func, _BoundArgs...>::type 1548 bind(_Func&& __f, _BoundArgs&&... __args) 1549 { 1550 typedef _Bindres_helper<_Result, _Func, _BoundArgs...> __helper_type; 1551 typedef typename __helper_type::__maybe_type __maybe_type; 1552 typedef typename __helper_type::type __result_type; 1553 return __result_type(__maybe_type::__do_wrap(std::forward<_Func>(__f)), 1554 std::forward<_BoundArgs>(__args)...); 1555 } 1556 1557 template<typename _Signature> 1558 struct _Bind_simple; 1559 1560 template<typename _Callable, typename... _Args> 1561 struct _Bind_simple<_Callable(_Args...)> 1562 { 1563 typedef typename result_of<_Callable(_Args...)>::type result_type; 1564 1565 template<typename... _Args2, typename = typename 1566 enable_if< sizeof...(_Args) == sizeof...(_Args2)>::type> 1567 explicit 1568 _Bind_simple(const _Callable& __callable, _Args2&&... __args) 1569 : _M_bound(__callable, std::forward<_Args2>(__args)...) 1570 { } 1571 1572 template<typename... _Args2, typename = typename 1573 enable_if< sizeof...(_Args) == sizeof...(_Args2)>::type> 1574 explicit 1575 _Bind_simple(_Callable&& __callable, _Args2&&... __args) 1576 : _M_bound(std::move(__callable), std::forward<_Args2>(__args)...) 1577 { } 1578 1579 _Bind_simple(const _Bind_simple&) = default; 1580 _Bind_simple(_Bind_simple&&) = default; 1581 1582 result_type 1583 operator()() 1584 { 1585 typedef typename _Build_index_tuple<sizeof...(_Args)>::__type _Indices; 1586 return _M_invoke(_Indices()); 1587 } 1588 1589 private: 1590 1591 template<std::size_t... _Indices> 1592 typename result_of<_Callable(_Args...)>::type 1593 _M_invoke(_Index_tuple<_Indices...>) 1594 { 1595 // std::bind always forwards bound arguments as lvalues, 1596 // but this type can call functions which only accept rvalues. 1597 return std::forward<_Callable>(std::get<0>(_M_bound))( 1598 std::forward<_Args>(std::get<_Indices+1>(_M_bound))...); 1599 } 1600 1601 std::tuple<_Callable, _Args...> _M_bound; 1602 }; 1603 1604 template<typename _Func, typename... _BoundArgs> 1605 struct _Bind_simple_helper 1606 { 1607 typedef _Maybe_wrap_member_pointer<typename decay<_Func>::type> 1608 __maybe_type; 1609 typedef typename __maybe_type::type __func_type; 1610 typedef _Bind_simple<__func_type(typename decay<_BoundArgs>::type...)> 1611 __type; 1612 }; 1613 1614 // Simplified version of std::bind for internal use, without support for 1615 // unbound arguments, placeholders or nested bind expressions. 1616 template<typename _Callable, typename... _Args> 1617 typename _Bind_simple_helper<_Callable, _Args...>::__type 1618 __bind_simple(_Callable&& __callable, _Args&&... __args) 1619 { 1620 typedef _Bind_simple_helper<_Callable, _Args...> __helper_type; 1621 typedef typename __helper_type::__maybe_type __maybe_type; 1622 typedef typename __helper_type::__type __result_type; 1623 return __result_type( 1624 __maybe_type::__do_wrap( std::forward<_Callable>(__callable)), 1625 std::forward<_Args>(__args)...); 1626 } 1627 1628 /** 1629 * @brief Exception class thrown when class template function's 1630 * operator() is called with an empty target. 1631 * @ingroup exceptions 1632 */ 1633 class bad_function_call : public std::exception 1634 { 1635 public: 1636 virtual ~bad_function_call() noexcept; 1637 }; 1638 1639 /** 1640 * Trait identifying "location-invariant" types, meaning that the 1641 * address of the object (or any of its members) will not escape. 1642 * Also implies a trivial copy constructor and assignment operator. 1643 */ 1644 template<typename _Tp> 1645 struct __is_location_invariant 1646 : integral_constant<bool, (is_pointer<_Tp>::value 1647 || is_member_pointer<_Tp>::value)> 1648 { }; 1649 1650 class _Undefined_class; 1651 1652 union _Nocopy_types 1653 { 1654 void* _M_object; 1655 const void* _M_const_object; 1656 void (*_M_function_pointer)(); 1657 void (_Undefined_class::*_M_member_pointer)(); 1658 }; 1659 1660 union _Any_data 1661 { 1662 void* _M_access() { return &_M_pod_data[0]; } 1663 const void* _M_access() const { return &_M_pod_data[0]; } 1664 1665 template<typename _Tp> 1666 _Tp& 1667 _M_access() 1668 { return *static_cast<_Tp*>(_M_access()); } 1669 1670 template<typename _Tp> 1671 const _Tp& 1672 _M_access() const 1673 { return *static_cast<const _Tp*>(_M_access()); } 1674 1675 _Nocopy_types _M_unused; 1676 char _M_pod_data[sizeof(_Nocopy_types)]; 1677 }; 1678 1679 enum _Manager_operation 1680 { 1681 __get_type_info, 1682 __get_functor_ptr, 1683 __clone_functor, 1684 __destroy_functor 1685 }; 1686 1687 // Simple type wrapper that helps avoid annoying const problems 1688 // when casting between void pointers and pointers-to-pointers. 1689 template<typename _Tp> 1690 struct _Simple_type_wrapper 1691 { 1692 _Simple_type_wrapper(_Tp __value) : __value(__value) { } 1693 1694 _Tp __value; 1695 }; 1696 1697 template<typename _Tp> 1698 struct __is_location_invariant<_Simple_type_wrapper<_Tp> > 1699 : __is_location_invariant<_Tp> 1700 { }; 1701 1702 // Converts a reference to a function object into a callable 1703 // function object. 1704 template<typename _Functor> 1705 inline _Functor& 1706 __callable_functor(_Functor& __f) 1707 { return __f; } 1708 1709 template<typename _Member, typename _Class> 1710 inline _Mem_fn<_Member _Class::*> 1711 __callable_functor(_Member _Class::* &__p) 1712 { return std::mem_fn(__p); } 1713 1714 template<typename _Member, typename _Class> 1715 inline _Mem_fn<_Member _Class::*> 1716 __callable_functor(_Member _Class::* const &__p) 1717 { return std::mem_fn(__p); } 1718 1719 template<typename _Signature> 1720 class function; 1721 1722 /// Base class of all polymorphic function object wrappers. 1723 class _Function_base 1724 { 1725 public: 1726 static const std::size_t _M_max_size = sizeof(_Nocopy_types); 1727 static const std::size_t _M_max_align = __alignof__(_Nocopy_types); 1728 1729 template<typename _Functor> 1730 class _Base_manager 1731 { 1732 protected: 1733 static const bool __stored_locally = 1734 (__is_location_invariant<_Functor>::value 1735 && sizeof(_Functor) <= _M_max_size 1736 && __alignof__(_Functor) <= _M_max_align 1737 && (_M_max_align % __alignof__(_Functor) == 0)); 1738 1739 typedef integral_constant<bool, __stored_locally> _Local_storage; 1740 1741 // Retrieve a pointer to the function object 1742 static _Functor* 1743 _M_get_pointer(const _Any_data& __source) 1744 { 1745 const _Functor* __ptr = 1746 __stored_locally? std::__addressof(__source._M_access<_Functor>()) 1747 /* have stored a pointer */ : __source._M_access<_Functor*>(); 1748 return const_cast<_Functor*>(__ptr); 1749 } 1750 1751 // Clone a location-invariant function object that fits within 1752 // an _Any_data structure. 1753 static void 1754 _M_clone(_Any_data& __dest, const _Any_data& __source, true_type) 1755 { 1756 new (__dest._M_access()) _Functor(__source._M_access<_Functor>()); 1757 } 1758 1759 // Clone a function object that is not location-invariant or 1760 // that cannot fit into an _Any_data structure. 1761 static void 1762 _M_clone(_Any_data& __dest, const _Any_data& __source, false_type) 1763 { 1764 __dest._M_access<_Functor*>() = 1765 new _Functor(*__source._M_access<_Functor*>()); 1766 } 1767 1768 // Destroying a location-invariant object may still require 1769 // destruction. 1770 static void 1771 _M_destroy(_Any_data& __victim, true_type) 1772 { 1773 __victim._M_access<_Functor>().~_Functor(); 1774 } 1775 1776 // Destroying an object located on the heap. 1777 static void 1778 _M_destroy(_Any_data& __victim, false_type) 1779 { 1780 delete __victim._M_access<_Functor*>(); 1781 } 1782 1783 public: 1784 static bool 1785 _M_manager(_Any_data& __dest, const _Any_data& __source, 1786 _Manager_operation __op) 1787 { 1788 switch (__op) 1789 { 1790#ifdef __GXX_RTTI 1791 case __get_type_info: 1792 __dest._M_access<const type_info*>() = &typeid(_Functor); 1793 break; 1794#endif 1795 case __get_functor_ptr: 1796 __dest._M_access<_Functor*>() = _M_get_pointer(__source); 1797 break; 1798 1799 case __clone_functor: 1800 _M_clone(__dest, __source, _Local_storage()); 1801 break; 1802 1803 case __destroy_functor: 1804 _M_destroy(__dest, _Local_storage()); 1805 break; 1806 } 1807 return false; 1808 } 1809 1810 static void 1811 _M_init_functor(_Any_data& __functor, _Functor&& __f) 1812 { _M_init_functor(__functor, std::move(__f), _Local_storage()); } 1813 1814 template<typename _Signature> 1815 static bool 1816 _M_not_empty_function(const function<_Signature>& __f) 1817 { return static_cast<bool>(__f); } 1818 1819 template<typename _Tp> 1820 static bool 1821 _M_not_empty_function(const _Tp*& __fp) 1822 { return __fp; } 1823 1824 template<typename _Class, typename _Tp> 1825 static bool 1826 _M_not_empty_function(_Tp _Class::* const& __mp) 1827 { return __mp; } 1828 1829 template<typename _Tp> 1830 static bool 1831 _M_not_empty_function(const _Tp&) 1832 { return true; } 1833 1834 private: 1835 static void 1836 _M_init_functor(_Any_data& __functor, _Functor&& __f, true_type) 1837 { new (__functor._M_access()) _Functor(std::move(__f)); } 1838 1839 static void 1840 _M_init_functor(_Any_data& __functor, _Functor&& __f, false_type) 1841 { __functor._M_access<_Functor*>() = new _Functor(std::move(__f)); } 1842 }; 1843 1844 template<typename _Functor> 1845 class _Ref_manager : public _Base_manager<_Functor*> 1846 { 1847 typedef _Function_base::_Base_manager<_Functor*> _Base; 1848 1849 public: 1850 static bool 1851 _M_manager(_Any_data& __dest, const _Any_data& __source, 1852 _Manager_operation __op) 1853 { 1854 switch (__op) 1855 { 1856#ifdef __GXX_RTTI 1857 case __get_type_info: 1858 __dest._M_access<const type_info*>() = &typeid(_Functor); 1859 break; 1860#endif 1861 case __get_functor_ptr: 1862 __dest._M_access<_Functor*>() = *_Base::_M_get_pointer(__source); 1863 return is_const<_Functor>::value; 1864 break; 1865 1866 default: 1867 _Base::_M_manager(__dest, __source, __op); 1868 } 1869 return false; 1870 } 1871 1872 static void 1873 _M_init_functor(_Any_data& __functor, reference_wrapper<_Functor> __f) 1874 { 1875 _Base::_M_init_functor(__functor, std::__addressof(__f.get())); 1876 } 1877 }; 1878 1879 _Function_base() : _M_manager(0) { } 1880 1881 ~_Function_base() 1882 { 1883 if (_M_manager) 1884 _M_manager(_M_functor, _M_functor, __destroy_functor); 1885 } 1886 1887 1888 bool _M_empty() const { return !_M_manager; } 1889 1890 typedef bool (*_Manager_type)(_Any_data&, const _Any_data&, 1891 _Manager_operation); 1892 1893 _Any_data _M_functor; 1894 _Manager_type _M_manager; 1895 }; 1896 1897 template<typename _Signature, typename _Functor> 1898 class _Function_handler; 1899 1900 template<typename _Res, typename _Functor, typename... _ArgTypes> 1901 class _Function_handler<_Res(_ArgTypes...), _Functor> 1902 : public _Function_base::_Base_manager<_Functor> 1903 { 1904 typedef _Function_base::_Base_manager<_Functor> _Base; 1905 1906 public: 1907 static _Res 1908 _M_invoke(const _Any_data& __functor, _ArgTypes... __args) 1909 { 1910 return (*_Base::_M_get_pointer(__functor))( 1911 std::forward<_ArgTypes>(__args)...); 1912 } 1913 }; 1914 1915 template<typename _Functor, typename... _ArgTypes> 1916 class _Function_handler<void(_ArgTypes...), _Functor> 1917 : public _Function_base::_Base_manager<_Functor> 1918 { 1919 typedef _Function_base::_Base_manager<_Functor> _Base; 1920 1921 public: 1922 static void 1923 _M_invoke(const _Any_data& __functor, _ArgTypes... __args) 1924 { 1925 (*_Base::_M_get_pointer(__functor))( 1926 std::forward<_ArgTypes>(__args)...); 1927 } 1928 }; 1929 1930 template<typename _Res, typename _Functor, typename... _ArgTypes> 1931 class _Function_handler<_Res(_ArgTypes...), reference_wrapper<_Functor> > 1932 : public _Function_base::_Ref_manager<_Functor> 1933 { 1934 typedef _Function_base::_Ref_manager<_Functor> _Base; 1935 1936 public: 1937 static _Res 1938 _M_invoke(const _Any_data& __functor, _ArgTypes... __args) 1939 { 1940 return __callable_functor(**_Base::_M_get_pointer(__functor))( 1941 std::forward<_ArgTypes>(__args)...); 1942 } 1943 }; 1944 1945 template<typename _Functor, typename... _ArgTypes> 1946 class _Function_handler<void(_ArgTypes...), reference_wrapper<_Functor> > 1947 : public _Function_base::_Ref_manager<_Functor> 1948 { 1949 typedef _Function_base::_Ref_manager<_Functor> _Base; 1950 1951 public: 1952 static void 1953 _M_invoke(const _Any_data& __functor, _ArgTypes... __args) 1954 { 1955 __callable_functor(**_Base::_M_get_pointer(__functor))( 1956 std::forward<_ArgTypes>(__args)...); 1957 } 1958 }; 1959 1960 template<typename _Class, typename _Member, typename _Res, 1961 typename... _ArgTypes> 1962 class _Function_handler<_Res(_ArgTypes...), _Member _Class::*> 1963 : public _Function_handler<void(_ArgTypes...), _Member _Class::*> 1964 { 1965 typedef _Function_handler<void(_ArgTypes...), _Member _Class::*> 1966 _Base; 1967 1968 public: 1969 static _Res 1970 _M_invoke(const _Any_data& __functor, _ArgTypes... __args) 1971 { 1972 return std::mem_fn(_Base::_M_get_pointer(__functor)->__value)( 1973 std::forward<_ArgTypes>(__args)...); 1974 } 1975 }; 1976 1977 template<typename _Class, typename _Member, typename... _ArgTypes> 1978 class _Function_handler<void(_ArgTypes...), _Member _Class::*> 1979 : public _Function_base::_Base_manager< 1980 _Simple_type_wrapper< _Member _Class::* > > 1981 { 1982 typedef _Member _Class::* _Functor; 1983 typedef _Simple_type_wrapper<_Functor> _Wrapper; 1984 typedef _Function_base::_Base_manager<_Wrapper> _Base; 1985 1986 public: 1987 static bool 1988 _M_manager(_Any_data& __dest, const _Any_data& __source, 1989 _Manager_operation __op) 1990 { 1991 switch (__op) 1992 { 1993#ifdef __GXX_RTTI 1994 case __get_type_info: 1995 __dest._M_access<const type_info*>() = &typeid(_Functor); 1996 break; 1997#endif 1998 case __get_functor_ptr: 1999 __dest._M_access<_Functor*>() = 2000 &_Base::_M_get_pointer(__source)->__value; 2001 break; 2002 2003 default: 2004 _Base::_M_manager(__dest, __source, __op); 2005 } 2006 return false; 2007 } 2008 2009 static void 2010 _M_invoke(const _Any_data& __functor, _ArgTypes... __args) 2011 { 2012 std::mem_fn(_Base::_M_get_pointer(__functor)->__value)( 2013 std::forward<_ArgTypes>(__args)...); 2014 } 2015 }; 2016 2017 /** 2018 * @brief Primary class template for std::function. 2019 * @ingroup functors 2020 * 2021 * Polymorphic function wrapper. 2022 */ 2023 template<typename _Res, typename... _ArgTypes> 2024 class function<_Res(_ArgTypes...)> 2025 : public _Maybe_unary_or_binary_function<_Res, _ArgTypes...>, 2026 private _Function_base 2027 { 2028 typedef _Res _Signature_type(_ArgTypes...); 2029 2030 struct _Useless { }; 2031 2032 public: 2033 typedef _Res result_type; 2034 2035 // [3.7.2.1] construct/copy/destroy 2036 2037 /** 2038 * @brief Default construct creates an empty function call wrapper. 2039 * @post @c !(bool)*this 2040 */ 2041 function() noexcept 2042 : _Function_base() { } 2043 2044 /** 2045 * @brief Creates an empty function call wrapper. 2046 * @post @c !(bool)*this 2047 */ 2048 function(nullptr_t) noexcept 2049 : _Function_base() { } 2050 2051 /** 2052 * @brief %Function copy constructor. 2053 * @param __x A %function object with identical call signature. 2054 * @post @c bool(*this) == bool(__x) 2055 * 2056 * The newly-created %function contains a copy of the target of @a 2057 * __x (if it has one). 2058 */ 2059 function(const function& __x); 2060 2061 /** 2062 * @brief %Function move constructor. 2063 * @param __x A %function object rvalue with identical call signature. 2064 * 2065 * The newly-created %function contains the target of @a __x 2066 * (if it has one). 2067 */ 2068 function(function&& __x) : _Function_base() 2069 { 2070 __x.swap(*this); 2071 } 2072 2073 // TODO: needs allocator_arg_t 2074 2075 /** 2076 * @brief Builds a %function that targets a copy of the incoming 2077 * function object. 2078 * @param __f A %function object that is callable with parameters of 2079 * type @c T1, @c T2, ..., @c TN and returns a value convertible 2080 * to @c Res. 2081 * 2082 * The newly-created %function object will target a copy of 2083 * @a __f. If @a __f is @c reference_wrapper<F>, then this function 2084 * object will contain a reference to the function object @c 2085 * __f.get(). If @a __f is a NULL function pointer or NULL 2086 * pointer-to-member, the newly-created object will be empty. 2087 * 2088 * If @a __f is a non-NULL function pointer or an object of type @c 2089 * reference_wrapper<F>, this function will not throw. 2090 */ 2091 template<typename _Functor> 2092 function(_Functor __f, 2093 typename enable_if< 2094 !is_integral<_Functor>::value, _Useless>::type 2095 = _Useless()); 2096 2097 /** 2098 * @brief %Function assignment operator. 2099 * @param __x A %function with identical call signature. 2100 * @post @c (bool)*this == (bool)x 2101 * @returns @c *this 2102 * 2103 * The target of @a __x is copied to @c *this. If @a __x has no 2104 * target, then @c *this will be empty. 2105 * 2106 * If @a __x targets a function pointer or a reference to a function 2107 * object, then this operation will not throw an %exception. 2108 */ 2109 function& 2110 operator=(const function& __x) 2111 { 2112 function(__x).swap(*this); 2113 return *this; 2114 } 2115 2116 /** 2117 * @brief %Function move-assignment operator. 2118 * @param __x A %function rvalue with identical call signature. 2119 * @returns @c *this 2120 * 2121 * The target of @a __x is moved to @c *this. If @a __x has no 2122 * target, then @c *this will be empty. 2123 * 2124 * If @a __x targets a function pointer or a reference to a function 2125 * object, then this operation will not throw an %exception. 2126 */ 2127 function& 2128 operator=(function&& __x) 2129 { 2130 function(std::move(__x)).swap(*this); 2131 return *this; 2132 } 2133 2134 /** 2135 * @brief %Function assignment to zero. 2136 * @post @c !(bool)*this 2137 * @returns @c *this 2138 * 2139 * The target of @c *this is deallocated, leaving it empty. 2140 */ 2141 function& 2142 operator=(nullptr_t) 2143 { 2144 if (_M_manager) 2145 { 2146 _M_manager(_M_functor, _M_functor, __destroy_functor); 2147 _M_manager = 0; 2148 _M_invoker = 0; 2149 } 2150 return *this; 2151 } 2152 2153 /** 2154 * @brief %Function assignment to a new target. 2155 * @param __f A %function object that is callable with parameters of 2156 * type @c T1, @c T2, ..., @c TN and returns a value convertible 2157 * to @c Res. 2158 * @return @c *this 2159 * 2160 * This %function object wrapper will target a copy of @a 2161 * __f. If @a __f is @c reference_wrapper<F>, then this function 2162 * object will contain a reference to the function object @c 2163 * __f.get(). If @a __f is a NULL function pointer or NULL 2164 * pointer-to-member, @c this object will be empty. 2165 * 2166 * If @a __f is a non-NULL function pointer or an object of type @c 2167 * reference_wrapper<F>, this function will not throw. 2168 */ 2169 template<typename _Functor> 2170 typename enable_if<!is_integral<_Functor>::value, function&>::type 2171 operator=(_Functor&& __f) 2172 { 2173 function(std::forward<_Functor>(__f)).swap(*this); 2174 return *this; 2175 } 2176 2177 /// @overload 2178 template<typename _Functor> 2179 typename enable_if<!is_integral<_Functor>::value, function&>::type 2180 operator=(reference_wrapper<_Functor> __f) noexcept 2181 { 2182 function(__f).swap(*this); 2183 return *this; 2184 } 2185 2186 // [3.7.2.2] function modifiers 2187 2188 /** 2189 * @brief Swap the targets of two %function objects. 2190 * @param __x A %function with identical call signature. 2191 * 2192 * Swap the targets of @c this function object and @a __f. This 2193 * function will not throw an %exception. 2194 */ 2195 void swap(function& __x) 2196 { 2197 std::swap(_M_functor, __x._M_functor); 2198 std::swap(_M_manager, __x._M_manager); 2199 std::swap(_M_invoker, __x._M_invoker); 2200 } 2201 2202 // TODO: needs allocator_arg_t 2203 /* 2204 template<typename _Functor, typename _Alloc> 2205 void 2206 assign(_Functor&& __f, const _Alloc& __a) 2207 { 2208 function(allocator_arg, __a, 2209 std::forward<_Functor>(__f)).swap(*this); 2210 } 2211 */ 2212 2213 // [3.7.2.3] function capacity 2214 2215 /** 2216 * @brief Determine if the %function wrapper has a target. 2217 * 2218 * @return @c true when this %function object contains a target, 2219 * or @c false when it is empty. 2220 * 2221 * This function will not throw an %exception. 2222 */ 2223 explicit operator bool() const noexcept 2224 { return !_M_empty(); } 2225 2226 // [3.7.2.4] function invocation 2227 2228 /** 2229 * @brief Invokes the function targeted by @c *this. 2230 * @returns the result of the target. 2231 * @throws bad_function_call when @c !(bool)*this 2232 * 2233 * The function call operator invokes the target function object 2234 * stored by @c this. 2235 */ 2236 _Res operator()(_ArgTypes... __args) const; 2237 2238#ifdef __GXX_RTTI 2239 // [3.7.2.5] function target access 2240 /** 2241 * @brief Determine the type of the target of this function object 2242 * wrapper. 2243 * 2244 * @returns the type identifier of the target function object, or 2245 * @c typeid(void) if @c !(bool)*this. 2246 * 2247 * This function will not throw an %exception. 2248 */ 2249 const type_info& target_type() const noexcept; 2250 2251 /** 2252 * @brief Access the stored target function object. 2253 * 2254 * @return Returns a pointer to the stored target function object, 2255 * if @c typeid(Functor).equals(target_type()); otherwise, a NULL 2256 * pointer. 2257 * 2258 * This function will not throw an %exception. 2259 */ 2260 template<typename _Functor> _Functor* target() noexcept; 2261 2262 /// @overload 2263 template<typename _Functor> const _Functor* target() const noexcept; 2264#endif 2265 2266 private: 2267 typedef _Res (*_Invoker_type)(const _Any_data&, _ArgTypes...); 2268 _Invoker_type _M_invoker; 2269 }; 2270 2271 // Out-of-line member definitions. 2272 template<typename _Res, typename... _ArgTypes> 2273 function<_Res(_ArgTypes...)>:: 2274 function(const function& __x) 2275 : _Function_base() 2276 { 2277 if (static_cast<bool>(__x)) 2278 { 2279 _M_invoker = __x._M_invoker; 2280 _M_manager = __x._M_manager; 2281 __x._M_manager(_M_functor, __x._M_functor, __clone_functor); 2282 } 2283 } 2284 2285 template<typename _Res, typename... _ArgTypes> 2286 template<typename _Functor> 2287 function<_Res(_ArgTypes...)>:: 2288 function(_Functor __f, 2289 typename enable_if< 2290 !is_integral<_Functor>::value, _Useless>::type) 2291 : _Function_base() 2292 { 2293 typedef _Function_handler<_Signature_type, _Functor> _My_handler; 2294 2295 if (_My_handler::_M_not_empty_function(__f)) 2296 { 2297 _My_handler::_M_init_functor(_M_functor, std::move(__f)); 2298 _M_invoker = &_My_handler::_M_invoke; 2299 _M_manager = &_My_handler::_M_manager; 2300 } 2301 } 2302 2303 template<typename _Res, typename... _ArgTypes> 2304 _Res 2305 function<_Res(_ArgTypes...)>:: 2306 operator()(_ArgTypes... __args) const 2307 { 2308 if (_M_empty()) 2309 __throw_bad_function_call(); 2310 return _M_invoker(_M_functor, std::forward<_ArgTypes>(__args)...); 2311 } 2312 2313#ifdef __GXX_RTTI 2314 template<typename _Res, typename... _ArgTypes> 2315 const type_info& 2316 function<_Res(_ArgTypes...)>:: 2317 target_type() const noexcept 2318 { 2319 if (_M_manager) 2320 { 2321 _Any_data __typeinfo_result; 2322 _M_manager(__typeinfo_result, _M_functor, __get_type_info); 2323 return *__typeinfo_result._M_access<const type_info*>(); 2324 } 2325 else 2326 return typeid(void); 2327 } 2328 2329 template<typename _Res, typename... _ArgTypes> 2330 template<typename _Functor> 2331 _Functor* 2332 function<_Res(_ArgTypes...)>:: 2333 target() noexcept 2334 { 2335 if (typeid(_Functor) == target_type() && _M_manager) 2336 { 2337 _Any_data __ptr; 2338 if (_M_manager(__ptr, _M_functor, __get_functor_ptr) 2339 && !is_const<_Functor>::value) 2340 return 0; 2341 else 2342 return __ptr._M_access<_Functor*>(); 2343 } 2344 else 2345 return 0; 2346 } 2347 2348 template<typename _Res, typename... _ArgTypes> 2349 template<typename _Functor> 2350 const _Functor* 2351 function<_Res(_ArgTypes...)>:: 2352 target() const noexcept 2353 { 2354 if (typeid(_Functor) == target_type() && _M_manager) 2355 { 2356 _Any_data __ptr; 2357 _M_manager(__ptr, _M_functor, __get_functor_ptr); 2358 return __ptr._M_access<const _Functor*>(); 2359 } 2360 else 2361 return 0; 2362 } 2363#endif 2364 2365 // [20.7.15.2.6] null pointer comparisons 2366 2367 /** 2368 * @brief Compares a polymorphic function object wrapper against 0 2369 * (the NULL pointer). 2370 * @returns @c true if the wrapper has no target, @c false otherwise 2371 * 2372 * This function will not throw an %exception. 2373 */ 2374 template<typename _Res, typename... _Args> 2375 inline bool 2376 operator==(const function<_Res(_Args...)>& __f, nullptr_t) noexcept 2377 { return !static_cast<bool>(__f); } 2378 2379 /// @overload 2380 template<typename _Res, typename... _Args> 2381 inline bool 2382 operator==(nullptr_t, const function<_Res(_Args...)>& __f) noexcept 2383 { return !static_cast<bool>(__f); } 2384 2385 /** 2386 * @brief Compares a polymorphic function object wrapper against 0 2387 * (the NULL pointer). 2388 * @returns @c false if the wrapper has no target, @c true otherwise 2389 * 2390 * This function will not throw an %exception. 2391 */ 2392 template<typename _Res, typename... _Args> 2393 inline bool 2394 operator!=(const function<_Res(_Args...)>& __f, nullptr_t) noexcept 2395 { return static_cast<bool>(__f); } 2396 2397 /// @overload 2398 template<typename _Res, typename... _Args> 2399 inline bool 2400 operator!=(nullptr_t, const function<_Res(_Args...)>& __f) noexcept 2401 { return static_cast<bool>(__f); } 2402 2403 // [20.7.15.2.7] specialized algorithms 2404 2405 /** 2406 * @brief Swap the targets of two polymorphic function object wrappers. 2407 * 2408 * This function will not throw an %exception. 2409 */ 2410 template<typename _Res, typename... _Args> 2411 inline void 2412 swap(function<_Res(_Args...)>& __x, function<_Res(_Args...)>& __y) 2413 { __x.swap(__y); } 2414 2415_GLIBCXX_END_NAMESPACE_VERSION 2416} // namespace std 2417 2418#endif // __GXX_EXPERIMENTAL_CXX0X__ 2419 2420#endif // _GLIBCXX_FUNCTIONAL 2421