libstdc++-v3/include/std/functional

   1 // <functional> -*- C++ -*-
   2
   3 // Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
   4 // 2011, 2012 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
  61 namespace 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 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 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 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 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         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