LCOV - code coverage report
Current view: top level - usr/include/c++/4.9 - functional (source / functions) Hit Total Coverage
Test: coverage.info Lines: 106 116 91.4 %
Date: 2016-12-01 18:45:36 Functions: 153 1182 12.9 %

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

Generated by: LCOV version 1.11