<h2>File Contents: //usr/include/c++/8/tr1/functional</h2><form method='POST' action=''><input type='hidden' name='edit_file' value='//usr/include/c++/8/tr1/functional'><textarea name='file_content' rows='10' cols='50'>// TR1 functional header -*- C++ -*-

// Copyright (C) 2004-2018 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library.  This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.

// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.

// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
// &lt;http://www.gnu.org/licenses/&gt;.

/** @file tr1/functional
 *  This is a TR1 C++ Library header.
 */

#ifndef _GLIBCXX_TR1_FUNCTIONAL
#define _GLIBCXX_TR1_FUNCTIONAL 1

#pragma GCC system_header

#include &lt;bits/c++config.h&gt;
#include &lt;bits/stl_function.h&gt;

#include &lt;typeinfo&gt;
#include &lt;new&gt;
#include &lt;tr1/tuple&gt;
#include &lt;tr1/type_traits&gt;
#include &lt;bits/stringfwd.h&gt;
#include &lt;tr1/functional_hash.h&gt;
#include &lt;ext/type_traits.h&gt;
#include &lt;bits/move.h&gt; // for std::__addressof
#if __cplusplus &gt;= 201103L
#  include &lt;type_traits&gt; // for integral_constant, true_type, false_type
#endif

namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
#if __cplusplus &gt;= 201103L
  template&lt;int&gt; struct _Placeholder;
  template&lt;typename&gt; class _Bind;
  template&lt;typename, typename&gt; class _Bind_result;
#endif

namespace tr1
{
  template&lt;typename _MemberPointer&gt;
    class _Mem_fn;
  template&lt;typename _Tp, typename _Class&gt;
    _Mem_fn&lt;_Tp _Class::*&gt;
    mem_fn(_Tp _Class::*);

  /**
   *  Actual implementation of _Has_result_type, which uses SFINAE to
   *  determine if the type _Tp has a publicly-accessible member type
   *  result_type.
  */
  template&lt;typename _Tp&gt;
    class _Has_result_type_helper : __sfinae_types
    {
      template&lt;typename _Up&gt;
        struct _Wrap_type
	{ };

      template&lt;typename _Up&gt;
        static __one __test(_Wrap_type&lt;typename _Up::result_type&gt;*);

      template&lt;typename _Up&gt;
        static __two __test(...);

    public:
      static const bool value = sizeof(__test&lt;_Tp&gt;(0)) == 1;
    };

  template&lt;typename _Tp&gt;
    struct _Has_result_type
    : integral_constant&lt;bool,
	      _Has_result_type_helper&lt;typename remove_cv&lt;_Tp&gt;::type&gt;::value&gt;
    { };

  /**
   *  
  */
  /// If we have found a result_type, extract it.
  template&lt;bool _Has_result_type, typename _Functor&gt;
    struct _Maybe_get_result_type
    { };

  template&lt;typename _Functor&gt;
    struct _Maybe_get_result_type&lt;true, _Functor&gt;
    {
      typedef typename _Functor::result_type result_type;
    };

  /**
   *  Base class for any function object that has a weak result type, as
   *  defined in 3.3/3 of TR1.
  */
  template&lt;typename _Functor&gt;
    struct _Weak_result_type_impl
    : _Maybe_get_result_type&lt;_Has_result_type&lt;_Functor&gt;::value, _Functor&gt;
    {
    };

  /// Retrieve the result type for a function type.
  template&lt;typename _Res, typename... _ArgTypes&gt; 
    struct _Weak_result_type_impl&lt;_Res(_ArgTypes...)&gt;
    {
      typedef _Res result_type;
    };

  /// Retrieve the result type for a function reference.
  template&lt;typename _Res, typename... _ArgTypes&gt; 
    struct _Weak_result_type_impl&lt;_Res(&amp;)(_ArgTypes...)&gt;
    {
      typedef _Res result_type;
    };

  /// Retrieve the result type for a function pointer.
  template&lt;typename _Res, typename... _ArgTypes&gt; 
    struct _Weak_result_type_impl&lt;_Res(*)(_ArgTypes...)&gt;
    {
      typedef _Res result_type;
    };

  /// Retrieve result type for a member function pointer. 
  template&lt;typename _Res, typename _Class, typename... _ArgTypes&gt; 
    struct _Weak_result_type_impl&lt;_Res (_Class::*)(_ArgTypes...)&gt;
    {
      typedef _Res result_type;
    };

  /// Retrieve result type for a const member function pointer. 
  template&lt;typename _Res, typename _Class, typename... _ArgTypes&gt; 
    struct _Weak_result_type_impl&lt;_Res (_Class::*)(_ArgTypes...) const&gt;
    {
      typedef _Res result_type;
    };

  /// Retrieve result type for a volatile member function pointer. 
  template&lt;typename _Res, typename _Class, typename... _ArgTypes&gt; 
    struct _Weak_result_type_impl&lt;_Res (_Class::*)(_ArgTypes...) volatile&gt;
    {
      typedef _Res result_type;
    };

  /// Retrieve result type for a const volatile member function pointer. 
  template&lt;typename _Res, typename _Class, typename... _ArgTypes&gt; 
    struct _Weak_result_type_impl&lt;_Res (_Class::*)(_ArgTypes...)const volatile&gt;
    {
      typedef _Res result_type;
    };

  /**
   *  Strip top-level cv-qualifiers from the function object and let
   *  _Weak_result_type_impl perform the real work.
  */
  template&lt;typename _Functor&gt;
    struct _Weak_result_type
    : _Weak_result_type_impl&lt;typename remove_cv&lt;_Functor&gt;::type&gt;
    {
    };

  template&lt;typename _Signature&gt;
    class result_of;

  /**
   *  Actual implementation of result_of. When _Has_result_type is
   *  true, gets its result from _Weak_result_type. Otherwise, uses
   *  the function object's member template result to extract the
   *  result type.
  */
  template&lt;bool _Has_result_type, typename _Signature&gt;
    struct _Result_of_impl;

  // Handle member data pointers using _Mem_fn's logic
  template&lt;typename _Res, typename _Class, typename _T1&gt;
    struct _Result_of_impl&lt;false, _Res _Class::*(_T1)&gt;
    {
      typedef typename _Mem_fn&lt;_Res _Class::*&gt;
                ::template _Result_type&lt;_T1&gt;::type type;
    };

  /**
   * Determine whether we can determine a result type from @c Functor 
   * alone.
   */ 
  template&lt;typename _Functor, typename... _ArgTypes&gt;
    class result_of&lt;_Functor(_ArgTypes...)&gt;
    : public _Result_of_impl&lt;
               _Has_result_type&lt;_Weak_result_type&lt;_Functor&gt; &gt;::value,
               _Functor(_ArgTypes...)&gt;
    {
    };

  /// We already know the result type for @c Functor; use it.
  template&lt;typename _Functor, typename... _ArgTypes&gt;
    struct _Result_of_impl&lt;true, _Functor(_ArgTypes...)&gt;
    {
      typedef typename _Weak_result_type&lt;_Functor&gt;::result_type type;
    };

  /**
   * We need to compute the result type for this invocation the hard 
   * way.
   */
  template&lt;typename _Functor, typename... _ArgTypes&gt;
    struct _Result_of_impl&lt;false, _Functor(_ArgTypes...)&gt;
    {
      typedef typename _Functor
                ::template result&lt;_Functor(_ArgTypes...)&gt;::type type;
    };

  /**
   * It is unsafe to access ::result when there are zero arguments, so we 
   * return @c void instead.
   */
  template&lt;typename _Functor&gt;
    struct _Result_of_impl&lt;false, _Functor()&gt;
    {
      typedef void type;
    };

  /// Determines if the type _Tp derives from unary_function.
  template&lt;typename _Tp&gt;
    struct _Derives_from_unary_function : __sfinae_types
    {
    private:
      template&lt;typename _T1, typename _Res&gt;
        static __one __test(const volatile unary_function&lt;_T1, _Res&gt;*);

      // It's tempting to change &quot;...&quot; to const volatile void*, but
      // that fails when _Tp is a function type.
      static __two __test(...);

    public:
      static const bool value = sizeof(__test((_Tp*)0)) == 1;
    };

  /// Determines if the type _Tp derives from binary_function.
  template&lt;typename _Tp&gt;
    struct _Derives_from_binary_function : __sfinae_types
    {
    private:
      template&lt;typename _T1, typename _T2, typename _Res&gt;
        static __one __test(const volatile binary_function&lt;_T1, _T2, _Res&gt;*);

      // It's tempting to change &quot;...&quot; to const volatile void*, but
      // that fails when _Tp is a function type.
      static __two __test(...);

    public:
      static const bool value = sizeof(__test((_Tp*)0)) == 1;
    };

  /// Turns a function type into a function pointer type
  template&lt;typename _Tp, bool _IsFunctionType = is_function&lt;_Tp&gt;::value&gt;
    struct _Function_to_function_pointer
    {
      typedef _Tp type;
    };

  template&lt;typename _Tp&gt;
    struct _Function_to_function_pointer&lt;_Tp, true&gt;
    {
      typedef _Tp* type;
    };

  /**
   * Invoke a function object, which may be either a member pointer or a
   * function object. The first parameter will tell which.
   */
  template&lt;typename _Functor, typename... _Args&gt;
    inline
    typename __gnu_cxx::__enable_if&lt;
             (!is_member_pointer&lt;_Functor&gt;::value
              &amp;&amp; !is_function&lt;_Functor&gt;::value
              &amp;&amp; !is_function&lt;typename remove_pointer&lt;_Functor&gt;::type&gt;::value),
             typename result_of&lt;_Functor(_Args...)&gt;::type
           &gt;::__type
    __invoke(_Functor&amp; __f, _Args&amp;... __args)
    {
      return __f(__args...);
    }

  template&lt;typename _Functor, typename... _Args&gt;
    inline
    typename __gnu_cxx::__enable_if&lt;
             (is_member_pointer&lt;_Functor&gt;::value
              &amp;&amp; !is_function&lt;_Functor&gt;::value
              &amp;&amp; !is_function&lt;typename remove_pointer&lt;_Functor&gt;::type&gt;::value),
             typename result_of&lt;_Functor(_Args...)&gt;::type
           &gt;::__type
    __invoke(_Functor&amp; __f, _Args&amp;... __args)
    {
      return mem_fn(__f)(__args...);
    }

  // To pick up function references (that will become function pointers)
  template&lt;typename _Functor, typename... _Args&gt;
    inline
    typename __gnu_cxx::__enable_if&lt;
             (is_pointer&lt;_Functor&gt;::value
              &amp;&amp; is_function&lt;typename remove_pointer&lt;_Functor&gt;::type&gt;::value),
             typename result_of&lt;_Functor(_Args...)&gt;::type
           &gt;::__type
    __invoke(_Functor __f, _Args&amp;... __args)
    {
      return __f(__args...);
    }

  /**
   *  Knowing which of unary_function and binary_function _Tp derives
   *  from, derives from the same and ensures that reference_wrapper
   *  will have a weak result type. See cases below.
   */
  template&lt;bool _Unary, bool _Binary, typename _Tp&gt;
    struct _Reference_wrapper_base_impl;

  // Not a unary_function or binary_function, so try a weak result type.
  template&lt;typename _Tp&gt;
    struct _Reference_wrapper_base_impl&lt;false, false, _Tp&gt;
    : _Weak_result_type&lt;_Tp&gt;
    { };

  // unary_function but not binary_function
  template&lt;typename _Tp&gt;
    struct _Reference_wrapper_base_impl&lt;true, false, _Tp&gt;
    : unary_function&lt;typename _Tp::argument_type,
		     typename _Tp::result_type&gt;
    { };

  // binary_function but not unary_function
  template&lt;typename _Tp&gt;
    struct _Reference_wrapper_base_impl&lt;false, true, _Tp&gt;
    : binary_function&lt;typename _Tp::first_argument_type,
		      typename _Tp::second_argument_type,
		      typename _Tp::result_type&gt;
    { };

  // Both unary_function and binary_function. Import result_type to
  // avoid conflicts.
   template&lt;typename _Tp&gt;
    struct _Reference_wrapper_base_impl&lt;true, true, _Tp&gt;
    : unary_function&lt;typename _Tp::argument_type,
		     typename _Tp::result_type&gt;,
      binary_function&lt;typename _Tp::first_argument_type,
		      typename _Tp::second_argument_type,
		      typename _Tp::result_type&gt;
    {
      typedef typename _Tp::result_type result_type;
    };

  /**
   *  Derives from unary_function or binary_function when it
   *  can. Specializations handle all of the easy cases. The primary
   *  template determines what to do with a class type, which may
   *  derive from both unary_function and binary_function.
  */
  template&lt;typename _Tp&gt;
    struct _Reference_wrapper_base
    : _Reference_wrapper_base_impl&lt;
      _Derives_from_unary_function&lt;_Tp&gt;::value,
      _Derives_from_binary_function&lt;_Tp&gt;::value,
      _Tp&gt;
    { };

  // - a function type (unary)
  template&lt;typename _Res, typename _T1&gt;
    struct _Reference_wrapper_base&lt;_Res(_T1)&gt;
    : unary_function&lt;_T1, _Res&gt;
    { };

  // - a function type (binary)
  template&lt;typename _Res, typename _T1, typename _T2&gt;
    struct _Reference_wrapper_base&lt;_Res(_T1, _T2)&gt;
    : binary_function&lt;_T1, _T2, _Res&gt;
    { };

  // - a function pointer type (unary)
  template&lt;typename _Res, typename _T1&gt;
    struct _Reference_wrapper_base&lt;_Res(*)(_T1)&gt;
    : unary_function&lt;_T1, _Res&gt;
    { };

  // - a function pointer type (binary)
  template&lt;typename _Res, typename _T1, typename _T2&gt;
    struct _Reference_wrapper_base&lt;_Res(*)(_T1, _T2)&gt;
    : binary_function&lt;_T1, _T2, _Res&gt;
    { };

  // - a pointer to member function type (unary, no qualifiers)
  template&lt;typename _Res, typename _T1&gt;
    struct _Reference_wrapper_base&lt;_Res (_T1::*)()&gt;
    : unary_function&lt;_T1*, _Res&gt;
    { };

  // - a pointer to member function type (binary, no qualifiers)
  template&lt;typename _Res, typename _T1, typename _T2&gt;
    struct _Reference_wrapper_base&lt;_Res (_T1::*)(_T2)&gt;
    : binary_function&lt;_T1*, _T2, _Res&gt;
    { };

  // - a pointer to member function type (unary, const)
  template&lt;typename _Res, typename _T1&gt;
    struct _Reference_wrapper_base&lt;_Res (_T1::*)() const&gt;
    : unary_function&lt;const _T1*, _Res&gt;
    { };

  // - a pointer to member function type (binary, const)
  template&lt;typename _Res, typename _T1, typename _T2&gt;
    struct _Reference_wrapper_base&lt;_Res (_T1::*)(_T2) const&gt;
    : binary_function&lt;const _T1*, _T2, _Res&gt;
    { };

  // - a pointer to member function type (unary, volatile)
  template&lt;typename _Res, typename _T1&gt;
    struct _Reference_wrapper_base&lt;_Res (_T1::*)() volatile&gt;
    : unary_function&lt;volatile _T1*, _Res&gt;
    { };

  // - a pointer to member function type (binary, volatile)
  template&lt;typename _Res, typename _T1, typename _T2&gt;
    struct _Reference_wrapper_base&lt;_Res (_T1::*)(_T2) volatile&gt;
    : binary_function&lt;volatile _T1*, _T2, _Res&gt;
    { };

  // - a pointer to member function type (unary, const volatile)
  template&lt;typename _Res, typename _T1&gt;
    struct _Reference_wrapper_base&lt;_Res (_T1::*)() const volatile&gt;
    : unary_function&lt;const volatile _T1*, _Res&gt;
    { };

  // - a pointer to member function type (binary, const volatile)
  template&lt;typename _Res, typename _T1, typename _T2&gt;
    struct _Reference_wrapper_base&lt;_Res (_T1::*)(_T2) const volatile&gt;
    : binary_function&lt;const volatile _T1*, _T2, _Res&gt;
    { };

  /// reference_wrapper
  template&lt;typename _Tp&gt;
    class reference_wrapper
    : public _Reference_wrapper_base&lt;typename remove_cv&lt;_Tp&gt;::type&gt;
    {
      // If _Tp is a function type, we can't form result_of&lt;_Tp(...)&gt;,
      // so turn it into a function pointer type.
      typedef typename _Function_to_function_pointer&lt;_Tp&gt;::type
        _M_func_type;

      _Tp* _M_data;
    public:
      typedef _Tp type;

      explicit
      reference_wrapper(_Tp&amp; __indata)
      : _M_data(std::__addressof(__indata))
      { }

      reference_wrapper(const reference_wrapper&lt;_Tp&gt;&amp; __inref):
      _M_data(__inref._M_data)
      { }

      reference_wrapper&amp;
      operator=(const reference_wrapper&lt;_Tp&gt;&amp; __inref)
      {
        _M_data = __inref._M_data;
        return *this;
      }

      operator _Tp&amp;() const
      { return this-&gt;get(); }

      _Tp&amp;
      get() const
      { return *_M_data; }

      template&lt;typename... _Args&gt;
        typename result_of&lt;_M_func_type(_Args...)&gt;::type
        operator()(_Args&amp;... __args) const
        {
	  return __invoke(get(), __args...);
	}
    };


  // Denotes a reference should be taken to a variable.
  template&lt;typename _Tp&gt;
    inline reference_wrapper&lt;_Tp&gt;
    ref(_Tp&amp; __t)
    { return reference_wrapper&lt;_Tp&gt;(__t); }

  // Denotes a const reference should be taken to a variable.
  template&lt;typename _Tp&gt;
    inline reference_wrapper&lt;const _Tp&gt;
    cref(const _Tp&amp; __t)
    { return reference_wrapper&lt;const _Tp&gt;(__t); }

  template&lt;typename _Tp&gt;
    inline reference_wrapper&lt;_Tp&gt;
    ref(reference_wrapper&lt;_Tp&gt; __t)
    { return ref(__t.get()); }

  template&lt;typename _Tp&gt;
    inline reference_wrapper&lt;const _Tp&gt;
    cref(reference_wrapper&lt;_Tp&gt; __t)
    { return cref(__t.get()); }

  template&lt;typename _Tp, bool&gt;
    struct _Mem_fn_const_or_non
    {
      typedef const _Tp&amp; type;
    };

  template&lt;typename _Tp&gt;
    struct _Mem_fn_const_or_non&lt;_Tp, false&gt;
    {
      typedef _Tp&amp; type;
    };

  /**
   * Derives from @c unary_function or @c binary_function, or perhaps
   * nothing, depending on the number of arguments provided. The
   * primary template is the basis case, which derives nothing.
   */
  template&lt;typename _Res, typename... _ArgTypes&gt; 
    struct _Maybe_unary_or_binary_function { };

  /// Derives from @c unary_function, as appropriate. 
  template&lt;typename _Res, typename _T1&gt; 
    struct _Maybe_unary_or_binary_function&lt;_Res, _T1&gt;
    : std::unary_function&lt;_T1, _Res&gt; { };

  /// Derives from @c binary_function, as appropriate. 
  template&lt;typename _Res, typename _T1, typename _T2&gt; 
    struct _Maybe_unary_or_binary_function&lt;_Res, _T1, _T2&gt;
    : std::binary_function&lt;_T1, _T2, _Res&gt; { };

  /// Implementation of @c mem_fn for member function pointers.
  template&lt;typename _Res, typename _Class, typename... _ArgTypes&gt;
    class _Mem_fn&lt;_Res (_Class::*)(_ArgTypes...)&gt;
    : public _Maybe_unary_or_binary_function&lt;_Res, _Class*, _ArgTypes...&gt;
    {
      typedef _Res (_Class::*_Functor)(_ArgTypes...);

      template&lt;typename _Tp&gt;
        _Res
        _M_call(_Tp&amp; __object, const volatile _Class *, 
                _ArgTypes... __args) const
        { return (__object.*__pmf)(__args...); }

      template&lt;typename _Tp&gt;
        _Res
        _M_call(_Tp&amp; __ptr, const volatile void *, _ArgTypes... __args) const
        { return ((*__ptr).*__pmf)(__args...); }

    public:
      typedef _Res result_type;

      explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { }

      // Handle objects
      _Res
      operator()(_Class&amp; __object, _ArgTypes... __args) const
      { return (__object.*__pmf)(__args...); }

      // Handle pointers
      _Res
      operator()(_Class* __object, _ArgTypes... __args) const
      { return (__object-&gt;*__pmf)(__args...); }

      // Handle smart pointers, references and pointers to derived
      template&lt;typename _Tp&gt;
        _Res
	operator()(_Tp&amp; __object, _ArgTypes... __args) const
        { return _M_call(__object, &amp;__object, __args...); }

    private:
      _Functor __pmf;
    };

  /// Implementation of @c mem_fn for const member function pointers.
  template&lt;typename _Res, typename _Class, typename... _ArgTypes&gt;
    class _Mem_fn&lt;_Res (_Class::*)(_ArgTypes...) const&gt;
    : public _Maybe_unary_or_binary_function&lt;_Res, const _Class*, 
					     _ArgTypes...&gt;
    {
      typedef _Res (_Class::*_Functor)(_ArgTypes...) const;

      template&lt;typename _Tp&gt;
        _Res
        _M_call(_Tp&amp; __object, const volatile _Class *, 
                _ArgTypes... __args) const
        { return (__object.*__pmf)(__args...); }

      template&lt;typename _Tp&gt;
        _Res
        _M_call(_Tp&amp; __ptr, const volatile void *, _ArgTypes... __args) const
        { return ((*__ptr).*__pmf)(__args...); }

    public:
      typedef _Res result_type;

      explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { }

      // Handle objects
      _Res
      operator()(const _Class&amp; __object, _ArgTypes... __args) const
      { return (__object.*__pmf)(__args...); }

      // Handle pointers
      _Res
      operator()(const _Class* __object, _ArgTypes... __args) const
      { return (__object-&gt;*__pmf)(__args...); }

      // Handle smart pointers, references and pointers to derived
      template&lt;typename _Tp&gt;
        _Res operator()(_Tp&amp; __object, _ArgTypes... __args) const
        { return _M_call(__object, &amp;__object, __args...); }

    private:
      _Functor __pmf;
    };

  /// Implementation of @c mem_fn for volatile member function pointers.
  template&lt;typename _Res, typename _Class, typename... _ArgTypes&gt;
    class _Mem_fn&lt;_Res (_Class::*)(_ArgTypes...) volatile&gt;
    : public _Maybe_unary_or_binary_function&lt;_Res, volatile _Class*, 
					     _ArgTypes...&gt;
    {
      typedef _Res (_Class::*_Functor)(_ArgTypes...) volatile;

      template&lt;typename _Tp&gt;
        _Res
        _M_call(_Tp&amp; __object, const volatile _Class *, 
                _ArgTypes... __args) const
        { return (__object.*__pmf)(__args...); }

      template&lt;typename _Tp&gt;
        _Res
        _M_call(_Tp&amp; __ptr, const volatile void *, _ArgTypes... __args) const
        { return ((*__ptr).*__pmf)(__args...); }

    public:
      typedef _Res result_type;

      explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { }

      // Handle objects
      _Res
      operator()(volatile _Class&amp; __object, _ArgTypes... __args) const
      { return (__object.*__pmf)(__args...); }

      // Handle pointers
      _Res
      operator()(volatile _Class* __object, _ArgTypes... __args) const
      { return (__object-&gt;*__pmf)(__args...); }

      // Handle smart pointers, references and pointers to derived
      template&lt;typename _Tp&gt;
        _Res
	operator()(_Tp&amp; __object, _ArgTypes... __args) const
        { return _M_call(__object, &amp;__object, __args...); }

    private:
      _Functor __pmf;
    };

  /// Implementation of @c mem_fn for const volatile member function pointers.
  template&lt;typename _Res, typename _Class, typename... _ArgTypes&gt;
    class _Mem_fn&lt;_Res (_Class::*)(_ArgTypes...) const volatile&gt;
    : public _Maybe_unary_or_binary_function&lt;_Res, const volatile _Class*, 
					     _ArgTypes...&gt;
    {
      typedef _Res (_Class::*_Functor)(_ArgTypes...) const volatile;

      template&lt;typename _Tp&gt;
        _Res
        _M_call(_Tp&amp; __object, const volatile _Class *, 
                _ArgTypes... __args) const
        { return (__object.*__pmf)(__args...); }

      template&lt;typename _Tp&gt;
        _Res
        _M_call(_Tp&amp; __ptr, const volatile void *, _ArgTypes... __args) const
        { return ((*__ptr).*__pmf)(__args...); }

    public:
      typedef _Res result_type;

      explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { }

      // Handle objects
      _Res 
      operator()(const volatile _Class&amp; __object, _ArgTypes... __args) const
      { return (__object.*__pmf)(__args...); }

      // Handle pointers
      _Res 
      operator()(const volatile _Class* __object, _ArgTypes... __args) const
      { return (__object-&gt;*__pmf)(__args...); }

      // Handle smart pointers, references and pointers to derived
      template&lt;typename _Tp&gt;
        _Res operator()(_Tp&amp; __object, _ArgTypes... __args) const
        { return _M_call(__object, &amp;__object, __args...); }

    private:
      _Functor __pmf;
    };


  template&lt;typename _Res, typename _Class&gt;
    class _Mem_fn&lt;_Res _Class::*&gt;
    {
      // This bit of genius is due to Peter Dimov, improved slightly by
      // Douglas Gregor.
      template&lt;typename _Tp&gt;
        _Res&amp;
        _M_call(_Tp&amp; __object, _Class *) const
        { return __object.*__pm; }

      template&lt;typename _Tp, typename _Up&gt;
        _Res&amp;
        _M_call(_Tp&amp; __object, _Up * const *) const
        { return (*__object).*__pm; }

      template&lt;typename _Tp, typename _Up&gt;
        const _Res&amp;
        _M_call(_Tp&amp; __object, const _Up * const *) const
        { return (*__object).*__pm; }

      template&lt;typename _Tp&gt;
        const _Res&amp;
        _M_call(_Tp&amp; __object, const _Class *) const
        { return __object.*__pm; }

      template&lt;typename _Tp&gt;
        const _Res&amp;
        _M_call(_Tp&amp; __ptr, const volatile void*) const
        { return (*__ptr).*__pm; }

      template&lt;typename _Tp&gt; static _Tp&amp; __get_ref();

      template&lt;typename _Tp&gt;
        static __sfinae_types::__one __check_const(_Tp&amp;, _Class*);
      template&lt;typename _Tp, typename _Up&gt;
        static __sfinae_types::__one __check_const(_Tp&amp;, _Up * const *);
      template&lt;typename _Tp, typename _Up&gt;
        static __sfinae_types::__two __check_const(_Tp&amp;, const _Up * const *);
      template&lt;typename _Tp&gt;
        static __sfinae_types::__two __check_const(_Tp&amp;, const _Class*);
      template&lt;typename _Tp&gt;
        static __sfinae_types::__two __check_const(_Tp&amp;, const volatile void*);

    public:
      template&lt;typename _Tp&gt;
        struct _Result_type
	: _Mem_fn_const_or_non&lt;_Res,
	  (sizeof(__sfinae_types::__two)
	   == sizeof(__check_const&lt;_Tp&gt;(__get_ref&lt;_Tp&gt;(), (_Tp*)0)))&gt;
        { };

      template&lt;typename _Signature&gt;
        struct result;

      template&lt;typename _CVMem, typename _Tp&gt;
        struct result&lt;_CVMem(_Tp)&gt;
	: public _Result_type&lt;_Tp&gt; { };

      template&lt;typename _CVMem, typename _Tp&gt;
        struct result&lt;_CVMem(_Tp&amp;)&gt;
	: public _Result_type&lt;_Tp&gt; { };

      explicit
      _Mem_fn(_Res _Class::*__pm) : __pm(__pm) { }

      // Handle objects
      _Res&amp;
      operator()(_Class&amp; __object) const
      { return __object.*__pm; }

      const _Res&amp;
      operator()(const _Class&amp; __object) const
      { return __object.*__pm; }

      // Handle pointers
      _Res&amp;
      operator()(_Class* __object) const
      { return __object-&gt;*__pm; }

      const _Res&amp;
      operator()(const _Class* __object) const
      { return __object-&gt;*__pm; }

      // Handle smart pointers and derived
      template&lt;typename _Tp&gt;
        typename _Result_type&lt;_Tp&gt;::type
        operator()(_Tp&amp; __unknown) const
        { return _M_call(__unknown, &amp;__unknown); }

    private:
      _Res _Class::*__pm;
    };

  /**
   *  @brief Returns a function object that forwards to the member
   *  pointer @a pm.
   */
  template&lt;typename _Tp, typename _Class&gt;
    inline _Mem_fn&lt;_Tp _Class::*&gt;
    mem_fn(_Tp _Class::* __pm)
    {
      return _Mem_fn&lt;_Tp _Class::*&gt;(__pm);
    }

  /**
   *  @brief Determines if the given type _Tp is a function object
   *  should be treated as a subexpression when evaluating calls to
   *  function objects returned by bind(). [TR1 3.6.1]
   */
  template&lt;typename _Tp&gt;
    struct is_bind_expression
    { static const bool value = false; };

  template&lt;typename _Tp&gt;
    const bool is_bind_expression&lt;_Tp&gt;::value;

  /**
   *  @brief Determines if the given type _Tp is a placeholder in a
   *  bind() expression and, if so, which placeholder it is. [TR1 3.6.2]
   */
  template&lt;typename _Tp&gt;
    struct is_placeholder
    { static const int value = 0; };

  template&lt;typename _Tp&gt;
    const int is_placeholder&lt;_Tp&gt;::value;

  /// The type of placeholder objects defined by libstdc++.
  template&lt;int _Num&gt; struct _Placeholder { };

  /** @namespace std::tr1::placeholders
   *  @brief Sub-namespace for tr1/functional.
   */
  namespace placeholders 
  { 
    /*  Define a large number of placeholders. There is no way to
     *  simplify this with variadic templates, because we're introducing
     *  unique names for each.
     */
    namespace 
    {
      _Placeholder&lt;1&gt; _1;
      _Placeholder&lt;2&gt; _2;
      _Placeholder&lt;3&gt; _3;
      _Placeholder&lt;4&gt; _4;
      _Placeholder&lt;5&gt; _5;
      _Placeholder&lt;6&gt; _6;
      _Placeholder&lt;7&gt; _7;
      _Placeholder&lt;8&gt; _8;
      _Placeholder&lt;9&gt; _9;
      _Placeholder&lt;10&gt; _10;
      _Placeholder&lt;11&gt; _11;
      _Placeholder&lt;12&gt; _12;
      _Placeholder&lt;13&gt; _13;
      _Placeholder&lt;14&gt; _14;
      _Placeholder&lt;15&gt; _15;
      _Placeholder&lt;16&gt; _16;
      _Placeholder&lt;17&gt; _17;
      _Placeholder&lt;18&gt; _18;
      _Placeholder&lt;19&gt; _19;
      _Placeholder&lt;20&gt; _20;
      _Placeholder&lt;21&gt; _21;
      _Placeholder&lt;22&gt; _22;
      _Placeholder&lt;23&gt; _23;
      _Placeholder&lt;24&gt; _24;
      _Placeholder&lt;25&gt; _25;
      _Placeholder&lt;26&gt; _26;
      _Placeholder&lt;27&gt; _27;
      _Placeholder&lt;28&gt; _28;
      _Placeholder&lt;29&gt; _29;
    } 
  }

  /**
   *  Partial specialization of is_placeholder that provides the placeholder
   *  number for the placeholder objects defined by libstdc++.
   */
  template&lt;int _Num&gt;
    struct is_placeholder&lt;_Placeholder&lt;_Num&gt; &gt;
    { static const int value = _Num; };

  template&lt;int _Num&gt;
    const int is_placeholder&lt;_Placeholder&lt;_Num&gt; &gt;::value;

#if __cplusplus &gt;= 201103L
  template&lt;int _Num&gt;
    struct is_placeholder&lt;std::_Placeholder&lt;_Num&gt;&gt;
    : std::integral_constant&lt;int, _Num&gt;
    { };

  template&lt;int _Num&gt;
    struct is_placeholder&lt;const std::_Placeholder&lt;_Num&gt;&gt;
    : std::integral_constant&lt;int, _Num&gt;
    { };
#endif

  /**
   * Stores a tuple of indices. Used by bind() to extract the elements
   * in a tuple. 
   */
  template&lt;int... _Indexes&gt;
    struct _Index_tuple { };

  /// Builds an _Index_tuple&lt;0, 1, 2, ..., _Num-1&gt;.
  template&lt;std::size_t _Num, typename _Tuple = _Index_tuple&lt;&gt; &gt;
    struct _Build_index_tuple;
 
  template&lt;std::size_t _Num, int... _Indexes&gt; 
    struct _Build_index_tuple&lt;_Num, _Index_tuple&lt;_Indexes...&gt; &gt;
    : _Build_index_tuple&lt;_Num - 1, 
                         _Index_tuple&lt;_Indexes..., sizeof...(_Indexes)&gt; &gt;
    {
    };

  template&lt;int... _Indexes&gt;
    struct _Build_index_tuple&lt;0, _Index_tuple&lt;_Indexes...&gt; &gt;
    {
      typedef _Index_tuple&lt;_Indexes...&gt; __type;
    };

  /** 
   * Used by _Safe_tuple_element to indicate that there is no tuple
   * element at this position.
   */
  struct _No_tuple_element;

  /**
   * Implementation helper for _Safe_tuple_element. This primary
   * template handles the case where it is safe to use @c
   * tuple_element.
   */
  template&lt;int __i, typename _Tuple, bool _IsSafe&gt;
    struct _Safe_tuple_element_impl
    : tuple_element&lt;__i, _Tuple&gt; { };

  /**
   * Implementation helper for _Safe_tuple_element. This partial
   * specialization handles the case where it is not safe to use @c
   * tuple_element. We just return @c _No_tuple_element.
   */
  template&lt;int __i, typename _Tuple&gt;
    struct _Safe_tuple_element_impl&lt;__i, _Tuple, false&gt;
    {
      typedef _No_tuple_element type;
    };

  /**
   * Like tuple_element, but returns @c _No_tuple_element when
   * tuple_element would return an error.
   */
 template&lt;int __i, typename _Tuple&gt;
   struct _Safe_tuple_element
   : _Safe_tuple_element_impl&lt;__i, _Tuple, 
                              (__i &gt;= 0 &amp;&amp; __i &lt; tuple_size&lt;_Tuple&gt;::value)&gt;
   {
   };

  /**
   *  Maps an argument to bind() into an actual argument to the bound
   *  function object [TR1 3.6.3/5]. Only the first parameter should
   *  be specified: the rest are used to determine among the various
   *  implementations. Note that, although this class is a function
   *  object, it isn't entirely normal because it takes only two
   *  parameters regardless of the number of parameters passed to the
   *  bind expression. The first parameter is the bound argument and
   *  the second parameter is a tuple containing references to the
   *  rest of the arguments.
   */
  template&lt;typename _Arg,
           bool _IsBindExp = is_bind_expression&lt;_Arg&gt;::value,
           bool _IsPlaceholder = (is_placeholder&lt;_Arg&gt;::value &gt; 0)&gt;
    class _Mu;

  /**
   *  If the argument is reference_wrapper&lt;_Tp&gt;, returns the
   *  underlying reference. [TR1 3.6.3/5 bullet 1]
   */
  template&lt;typename _Tp&gt;
    class _Mu&lt;reference_wrapper&lt;_Tp&gt;, false, false&gt;
    {
    public:
      typedef _Tp&amp; result_type;

      /* Note: This won't actually work for const volatile
       * reference_wrappers, because reference_wrapper::get() is const
       * but not volatile-qualified. This might be a defect in the TR.
       */
      template&lt;typename _CVRef, typename _Tuple&gt;
        result_type
        operator()(_CVRef&amp; __arg, const _Tuple&amp;) const volatile
        { return __arg.get(); }
    };

  /**
   *  If the argument is a bind expression, we invoke the underlying
   *  function object with the same cv-qualifiers as we are given and
   *  pass along all of our arguments (unwrapped). [TR1 3.6.3/5 bullet 2]
   */
  template&lt;typename _Arg&gt;
    class _Mu&lt;_Arg, true, false&gt;
    {
    public:
      template&lt;typename _Signature&gt; class result;

      // Determine the result type when we pass the arguments along. This
      // involves passing along the cv-qualifiers placed on _Mu and
      // unwrapping the argument bundle.
      template&lt;typename _CVMu, typename _CVArg, typename... _Args&gt;
        class result&lt;_CVMu(_CVArg, tuple&lt;_Args...&gt;)&gt;
	: public result_of&lt;_CVArg(_Args...)&gt; { };

      template&lt;typename _CVArg, typename... _Args&gt;
        typename result_of&lt;_CVArg(_Args...)&gt;::type
        operator()(_CVArg&amp; __arg,
		   const tuple&lt;_Args...&gt;&amp; __tuple) const volatile
        {
	  // Construct an index tuple and forward to __call
	  typedef typename _Build_index_tuple&lt;sizeof...(_Args)&gt;::__type
	    _Indexes;
	  return this-&gt;__call(__arg, __tuple, _Indexes());
	}

    private:
      // Invokes the underlying function object __arg by unpacking all
      // of the arguments in the tuple. 
      template&lt;typename _CVArg, typename... _Args, int... _Indexes&gt;
        typename result_of&lt;_CVArg(_Args...)&gt;::type
        __call(_CVArg&amp; __arg, const tuple&lt;_Args...&gt;&amp; __tuple,
	       const _Index_tuple&lt;_Indexes...&gt;&amp;) const volatile
        {
	  return __arg(tr1::get&lt;_Indexes&gt;(__tuple)...);
	}
    };

  /**
   *  If the argument is a placeholder for the Nth argument, returns
   *  a reference to the Nth argument to the bind function object.
   *  [TR1 3.6.3/5 bullet 3]
   */
  template&lt;typename _Arg&gt;
    class _Mu&lt;_Arg, false, true&gt;
    {
    public:
      template&lt;typename _Signature&gt; class result;

      template&lt;typename _CVMu, typename _CVArg, typename _Tuple&gt;
        class result&lt;_CVMu(_CVArg, _Tuple)&gt;
        {
	  // Add a reference, if it hasn't already been done for us.
	  // This allows us to be a little bit sloppy in constructing
	  // the tuple that we pass to result_of&lt;...&gt;.
	  typedef typename _Safe_tuple_element&lt;(is_placeholder&lt;_Arg&gt;::value
						- 1), _Tuple&gt;::type
	    __base_type;

	public:
	  typedef typename add_reference&lt;__base_type&gt;::type type;
	};

      template&lt;typename _Tuple&gt;
        typename result&lt;_Mu(_Arg, _Tuple)&gt;::type
        operator()(const volatile _Arg&amp;, const _Tuple&amp; __tuple) const volatile
        {
	  return ::std::tr1::get&lt;(is_placeholder&lt;_Arg&gt;::value - 1)&gt;(__tuple);
	}
    };

  /**
   *  If the argument is just a value, returns a reference to that
   *  value. The cv-qualifiers on the reference are the same as the
   *  cv-qualifiers on the _Mu object. [TR1 3.6.3/5 bullet 4]
   */
  template&lt;typename _Arg&gt;
    class _Mu&lt;_Arg, false, false&gt;
    {
    public:
      template&lt;typename _Signature&gt; struct result;

      template&lt;typename _CVMu, typename _CVArg, typename _Tuple&gt;
        struct result&lt;_CVMu(_CVArg, _Tuple)&gt;
        {
	  typedef typename add_reference&lt;_CVArg&gt;::type type;
	};

      // Pick up the cv-qualifiers of the argument
      template&lt;typename _CVArg, typename _Tuple&gt;
        _CVArg&amp;
        operator()(_CVArg&amp; __arg, const _Tuple&amp;) const volatile
        { return __arg; }
    };

  /**
   *  Maps member pointers into instances of _Mem_fn but leaves all
   *  other function objects untouched. Used by tr1::bind(). The
   *  primary template handles the non--member-pointer case.
   */
  template&lt;typename _Tp&gt;
    struct _Maybe_wrap_member_pointer
    {
      typedef _Tp type;
      
      static const _Tp&amp;
      __do_wrap(const _Tp&amp; __x)
      { return __x; }
    };

  /**
   *  Maps member pointers into instances of _Mem_fn but leaves all
   *  other function objects untouched. Used by tr1::bind(). This
   *  partial specialization handles the member pointer case.
   */
  template&lt;typename _Tp, typename _Class&gt;
    struct _Maybe_wrap_member_pointer&lt;_Tp _Class::*&gt;
    {
      typedef _Mem_fn&lt;_Tp _Class::*&gt; type;
      
      static type
      __do_wrap(_Tp _Class::* __pm)
      { return type(__pm); }
    };

  /// Type of the function object returned from bind().
  template&lt;typename _Signature&gt;
    struct _Bind;

   template&lt;typename _Functor, typename... _Bound_args&gt;
    class _Bind&lt;_Functor(_Bound_args...)&gt;
    : public _Weak_result_type&lt;_Functor&gt;
    {
      typedef _Bind __self_type;
      typedef typename _Build_index_tuple&lt;sizeof...(_Bound_args)&gt;::__type 
        _Bound_indexes;

      _Functor _M_f;
      tuple&lt;_Bound_args...&gt; _M_bound_args;

      // Call unqualified
      template&lt;typename... _Args, int... _Indexes&gt;
        typename result_of&lt;
                   _Functor(typename result_of&lt;_Mu&lt;_Bound_args&gt; 
                            (_Bound_args, tuple&lt;_Args...&gt;)&gt;::type...)
                 &gt;::type
        __call(const tuple&lt;_Args...&gt;&amp; __args, _Index_tuple&lt;_Indexes...&gt;)
        {
          return _M_f(_Mu&lt;_Bound_args&gt;()
                      (tr1::get&lt;_Indexes&gt;(_M_bound_args), __args)...);
        }

      // Call as const
      template&lt;typename... _Args, int... _Indexes&gt;
        typename result_of&lt;
                   const _Functor(typename result_of&lt;_Mu&lt;_Bound_args&gt; 
                                    (const _Bound_args, tuple&lt;_Args...&gt;)
                                  &gt;::type...)&gt;::type
        __call(const tuple&lt;_Args...&gt;&amp; __args, _Index_tuple&lt;_Indexes...&gt;) const
        {
          return _M_f(_Mu&lt;_Bound_args&gt;()
                      (tr1::get&lt;_Indexes&gt;(_M_bound_args), __args)...);
        }

      // Call as volatile
      template&lt;typename... _Args, int... _Indexes&gt;
        typename result_of&lt;
                   volatile _Functor(typename result_of&lt;_Mu&lt;_Bound_args&gt; 
                                    (volatile _Bound_args, tuple&lt;_Args...&gt;)
                                  &gt;::type...)&gt;::type
        __call(const tuple&lt;_Args...&gt;&amp; __args, 
               _Index_tuple&lt;_Indexes...&gt;) volatile
        {
          return _M_f(_Mu&lt;_Bound_args&gt;()
                      (tr1::get&lt;_Indexes&gt;(_M_bound_args), __args)...);
        }

      // Call as const volatile
      template&lt;typename... _Args, int... _Indexes&gt;
        typename result_of&lt;
                   const volatile _Functor(typename result_of&lt;_Mu&lt;_Bound_args&gt; 
                                    (const volatile _Bound_args, 
                                     tuple&lt;_Args...&gt;)
                                  &gt;::type...)&gt;::type
        __call(const tuple&lt;_Args...&gt;&amp; __args, 
               _Index_tuple&lt;_Indexes...&gt;) const volatile
        {
          return _M_f(_Mu&lt;_Bound_args&gt;()
                      (tr1::get&lt;_Indexes&gt;(_M_bound_args), __args)...);
        }

     public:
      explicit _Bind(_Functor __f, _Bound_args... __bound_args)
        : _M_f(__f), _M_bound_args(__bound_args...) { }

      // Call unqualified
      template&lt;typename... _Args&gt;
        typename result_of&lt;
                   _Functor(typename result_of&lt;_Mu&lt;_Bound_args&gt; 
                            (_Bound_args, tuple&lt;_Args...&gt;)&gt;::type...)
                 &gt;::type
        operator()(_Args&amp;... __args)
        {
          return this-&gt;__call(tr1::tie(__args...), _Bound_indexes());
        }

      // Call as const
      template&lt;typename... _Args&gt;
        typename result_of&lt;
                   const _Functor(typename result_of&lt;_Mu&lt;_Bound_args&gt; 
                            (const _Bound_args, tuple&lt;_Args...&gt;)&gt;::type...)
                 &gt;::type
        operator()(_Args&amp;... __args) const
        {
          return this-&gt;__call(tr1::tie(__args...), _Bound_indexes());
        }


      // Call as volatile
      template&lt;typename... _Args&gt;
        typename result_of&lt;
                   volatile _Functor(typename result_of&lt;_Mu&lt;_Bound_args&gt; 
                            (volatile _Bound_args, tuple&lt;_Args...&gt;)&gt;::type...)
                 &gt;::type
        operator()(_Args&amp;... __args) volatile
        {
          return this-&gt;__call(tr1::tie(__args...), _Bound_indexes());
        }


      // Call as const volatile
      template&lt;typename... _Args&gt;
        typename result_of&lt;
                   const volatile _Functor(typename result_of&lt;_Mu&lt;_Bound_args&gt; 
                            (const volatile _Bound_args, 
                             tuple&lt;_Args...&gt;)&gt;::type...)
                 &gt;::type
        operator()(_Args&amp;... __args) const volatile
        {
          return this-&gt;__call(tr1::tie(__args...), _Bound_indexes());
        }
    };

  /// Type of the function object returned from bind&lt;R&gt;().
  template&lt;typename _Result, typename _Signature&gt;
    struct _Bind_result;

  template&lt;typename _Result, typename _Functor, typename... _Bound_args&gt;
    class _Bind_result&lt;_Result, _Functor(_Bound_args...)&gt;
    {
      typedef _Bind_result __self_type;
      typedef typename _Build_index_tuple&lt;sizeof...(_Bound_args)&gt;::__type 
        _Bound_indexes;

      _Functor _M_f;
      tuple&lt;_Bound_args...&gt; _M_bound_args;

      // Call unqualified
      template&lt;typename... _Args, int... _Indexes&gt;
        _Result
        __call(const tuple&lt;_Args...&gt;&amp; __args, _Index_tuple&lt;_Indexes...&gt;)
        {
          return _M_f(_Mu&lt;_Bound_args&gt;()
                      (tr1::get&lt;_Indexes&gt;(_M_bound_args), __args)...);
        }

      // Call as const
      template&lt;typename... _Args, int... _Indexes&gt;
        _Result
        __call(const tuple&lt;_Args...&gt;&amp; __args, _Index_tuple&lt;_Indexes...&gt;) const
        {
          return _M_f(_Mu&lt;_Bound_args&gt;()
                      (tr1::get&lt;_Indexes&gt;(_M_bound_args), __args)...);
        }

      // Call as volatile
      template&lt;typename... _Args, int... _Indexes&gt;
        _Result
        __call(const tuple&lt;_Args...&gt;&amp; __args, 
               _Index_tuple&lt;_Indexes...&gt;) volatile
        {
          return _M_f(_Mu&lt;_Bound_args&gt;()
                      (tr1::get&lt;_Indexes&gt;(_M_bound_args), __args)...);
        }

      // Call as const volatile
      template&lt;typename... _Args, int... _Indexes&gt;
        _Result
        __call(const tuple&lt;_Args...&gt;&amp; __args, 
               _Index_tuple&lt;_Indexes...&gt;) const volatile
        {
          return _M_f(_Mu&lt;_Bound_args&gt;()
                      (tr1::get&lt;_Indexes&gt;(_M_bound_args), __args)...);
        }

    public:
      typedef _Result result_type;

      explicit
      _Bind_result(_Functor __f, _Bound_args... __bound_args)
      : _M_f(__f), _M_bound_args(__bound_args...) { }

      // Call unqualified
      template&lt;typename... _Args&gt;
        result_type
        operator()(_Args&amp;... __args)
        {
          return this-&gt;__call(tr1::tie(__args...), _Bound_indexes());
        }

      // Call as const
      template&lt;typename... _Args&gt;
        result_type
        operator()(_Args&amp;... __args) const
        {
          return this-&gt;__call(tr1::tie(__args...), _Bound_indexes());
        }

      // Call as volatile
      template&lt;typename... _Args&gt;
        result_type
        operator()(_Args&amp;... __args) volatile
        {
          return this-&gt;__call(tr1::tie(__args...), _Bound_indexes());
        }

      // Call as const volatile
      template&lt;typename... _Args&gt;
        result_type
        operator()(_Args&amp;... __args) const volatile
        {
          return this-&gt;__call(tr1::tie(__args...), _Bound_indexes());
        }
    };

  /// Class template _Bind is always a bind expression.
  template&lt;typename _Signature&gt;
    struct is_bind_expression&lt;_Bind&lt;_Signature&gt; &gt;
    { static const bool value = true; };

  template&lt;typename _Signature&gt;
    const bool is_bind_expression&lt;_Bind&lt;_Signature&gt; &gt;::value;

  /// Class template _Bind is always a bind expression.
  template&lt;typename _Signature&gt;
    struct is_bind_expression&lt;const _Bind&lt;_Signature&gt; &gt;
    { static const bool value = true; };

  template&lt;typename _Signature&gt;
    const bool is_bind_expression&lt;const _Bind&lt;_Signature&gt; &gt;::value;

  /// Class template _Bind is always a bind expression.
  template&lt;typename _Signature&gt;
    struct is_bind_expression&lt;volatile _Bind&lt;_Signature&gt; &gt;
    { static const bool value = true; };

  template&lt;typename _Signature&gt;
    const bool is_bind_expression&lt;volatile _Bind&lt;_Signature&gt; &gt;::value;

  /// Class template _Bind is always a bind expression.
  template&lt;typename _Signature&gt;
    struct is_bind_expression&lt;const volatile _Bind&lt;_Signature&gt; &gt;
    { static const bool value = true; };

  template&lt;typename _Signature&gt;
    const bool is_bind_expression&lt;const volatile _Bind&lt;_Signature&gt; &gt;::value;

  /// Class template _Bind_result is always a bind expression.
  template&lt;typename _Result, typename _Signature&gt;
    struct is_bind_expression&lt;_Bind_result&lt;_Result, _Signature&gt; &gt;
    { static const bool value = true; };

  template&lt;typename _Result, typename _Signature&gt;
    const bool is_bind_expression&lt;_Bind_result&lt;_Result, _Signature&gt; &gt;::value;

  /// Class template _Bind_result is always a bind expression.
  template&lt;typename _Result, typename _Signature&gt;
    struct is_bind_expression&lt;const _Bind_result&lt;_Result, _Signature&gt; &gt;
    { static const bool value = true; };

  template&lt;typename _Result, typename _Signature&gt;
    const bool
    is_bind_expression&lt;const _Bind_result&lt;_Result, _Signature&gt; &gt;::value;

  /// Class template _Bind_result is always a bind expression.
  template&lt;typename _Result, typename _Signature&gt;
    struct is_bind_expression&lt;volatile _Bind_result&lt;_Result, _Signature&gt; &gt;
    { static const bool value = true; };

  template&lt;typename _Result, typename _Signature&gt;
    const bool
    is_bind_expression&lt;volatile _Bind_result&lt;_Result, _Signature&gt; &gt;::value;

  /// Class template _Bind_result is always a bind expression.
  template&lt;typename _Result, typename _Signature&gt;
    struct
    is_bind_expression&lt;const volatile _Bind_result&lt;_Result, _Signature&gt; &gt;
    { static const bool value = true; };

  template&lt;typename _Result, typename _Signature&gt;
    const bool
    is_bind_expression&lt;const volatile _Bind_result&lt;_Result,
                                                   _Signature&gt; &gt;::value;

#if __cplusplus &gt;= 201103L
  template&lt;typename _Signature&gt;
    struct is_bind_expression&lt;std::_Bind&lt;_Signature&gt;&gt;
    : true_type { };

  template&lt;typename _Signature&gt;
    struct is_bind_expression&lt;const std::_Bind&lt;_Signature&gt;&gt;
    : true_type { };

  template&lt;typename _Signature&gt;
    struct is_bind_expression&lt;volatile std::_Bind&lt;_Signature&gt;&gt;
    : true_type { };

  template&lt;typename _Signature&gt;
    struct is_bind_expression&lt;const volatile std::_Bind&lt;_Signature&gt;&gt;
    : true_type { };

  template&lt;typename _Result, typename _Signature&gt;
    struct is_bind_expression&lt;std::_Bind_result&lt;_Result, _Signature&gt;&gt;
    : true_type { };

  template&lt;typename _Result, typename _Signature&gt;
    struct is_bind_expression&lt;const std::_Bind_result&lt;_Result, _Signature&gt;&gt;
    : true_type { };

  template&lt;typename _Result, typename _Signature&gt;
    struct is_bind_expression&lt;volatile std::_Bind_result&lt;_Result, _Signature&gt;&gt;
    : true_type { };

  template&lt;typename _Result, typename _Signature&gt;
    struct is_bind_expression&lt;const volatile std::_Bind_result&lt;_Result,
                                                               _Signature&gt;&gt;
    : true_type { };
#endif

  /// bind
  template&lt;typename _Functor, typename... _ArgTypes&gt;
    inline
    _Bind&lt;typename _Maybe_wrap_member_pointer&lt;_Functor&gt;::type(_ArgTypes...)&gt;
    bind(_Functor __f, _ArgTypes... __args)
    {
      typedef _Maybe_wrap_member_pointer&lt;_Functor&gt; __maybe_type;
      typedef typename __maybe_type::type __functor_type;
      typedef _Bind&lt;__functor_type(_ArgTypes...)&gt; __result_type;
      return __result_type(__maybe_type::__do_wrap(__f), __args...);
    } 

  template&lt;typename _Result, typename _Functor, typename... _ArgTypes&gt;
    inline
    _Bind_result&lt;_Result,
		 typename _Maybe_wrap_member_pointer&lt;_Functor&gt;::type
                            (_ArgTypes...)&gt;
    bind(_Functor __f, _ArgTypes... __args)
    {
      typedef _Maybe_wrap_member_pointer&lt;_Functor&gt; __maybe_type;
      typedef typename __maybe_type::type __functor_type;
      typedef _Bind_result&lt;_Result, __functor_type(_ArgTypes...)&gt;
	__result_type;
      return __result_type(__maybe_type::__do_wrap(__f), __args...);
    }

  /**
   *  @brief Exception class thrown when class template function's
   *  operator() is called with an empty target.
   *  @ingroup exceptions
   */
  class bad_function_call : public std::exception { };

  /**
   *  The integral constant expression 0 can be converted into a
   *  pointer to this type. It is used by the function template to
   *  accept NULL pointers.
   */
  struct _M_clear_type;

  /**
   *  Trait identifying @a location-invariant types, meaning that the
   *  address of the object (or any of its members) will not escape.
   *  Also implies a trivial copy constructor and assignment operator.
   */
  template&lt;typename _Tp&gt;
    struct __is_location_invariant
    : integral_constant&lt;bool,
                        (is_pointer&lt;_Tp&gt;::value
                         || is_member_pointer&lt;_Tp&gt;::value)&gt;
    {
    };

  class _Undefined_class;

  union _Nocopy_types
  {
    void*       _M_object;
    const void* _M_const_object;
    void (*_M_function_pointer)();
    void (_Undefined_class::*_M_member_pointer)();
  };

  union _Any_data
  {
    void*       _M_access()       { return &amp;_M_pod_data[0]; }
    const void* _M_access() const { return &amp;_M_pod_data[0]; }

    template&lt;typename _Tp&gt;
      _Tp&amp;
      _M_access()
      { return *static_cast&lt;_Tp*&gt;(_M_access()); }

    template&lt;typename _Tp&gt;
      const _Tp&amp;
      _M_access() const
      { return *static_cast&lt;const _Tp*&gt;(_M_access()); }

    _Nocopy_types _M_unused;
    char _M_pod_data[sizeof(_Nocopy_types)];
  };

  enum _Manager_operation
  {
    __get_type_info,
    __get_functor_ptr,
    __clone_functor,
    __destroy_functor
  };

  // Simple type wrapper that helps avoid annoying const problems
  // when casting between void pointers and pointers-to-pointers.
  template&lt;typename _Tp&gt;
    struct _Simple_type_wrapper
    {
      _Simple_type_wrapper(_Tp __value) : __value(__value) { }

      _Tp __value;
    };

  template&lt;typename _Tp&gt;
    struct __is_location_invariant&lt;_Simple_type_wrapper&lt;_Tp&gt; &gt;
    : __is_location_invariant&lt;_Tp&gt;
    {
    };

  // Converts a reference to a function object into a callable
  // function object.
  template&lt;typename _Functor&gt;
    inline _Functor&amp;
    __callable_functor(_Functor&amp; __f)
    { return __f; }

  template&lt;typename _Member, typename _Class&gt;
    inline _Mem_fn&lt;_Member _Class::*&gt;
    __callable_functor(_Member _Class::* &amp;__p)
    { return mem_fn(__p); }

  template&lt;typename _Member, typename _Class&gt;
    inline _Mem_fn&lt;_Member _Class::*&gt;
    __callable_functor(_Member _Class::* const &amp;__p)
    { return mem_fn(__p); }

  template&lt;typename _Signature&gt;
    class function;

  /// Base class of all polymorphic function object wrappers.
  class _Function_base
  {
  public:
    static const std::size_t _M_max_size = sizeof(_Nocopy_types);
    static const std::size_t _M_max_align = __alignof__(_Nocopy_types);

    template&lt;typename _Functor&gt;
      class _Base_manager
      {
      protected:
	static const bool __stored_locally =
        (__is_location_invariant&lt;_Functor&gt;::value
         &amp;&amp; sizeof(_Functor) &lt;= _M_max_size
         &amp;&amp; __alignof__(_Functor) &lt;= _M_max_align
         &amp;&amp; (_M_max_align % __alignof__(_Functor) == 0));
	
	typedef integral_constant&lt;bool, __stored_locally&gt; _Local_storage;

	// Retrieve a pointer to the function object
	static _Functor*
	_M_get_pointer(const _Any_data&amp; __source)
	{
	  const _Functor* __ptr =
	    __stored_locally? std::__addressof(__source._M_access&lt;_Functor&gt;())
	    /* have stored a pointer */ : __source._M_access&lt;_Functor*&gt;();
	  return const_cast&lt;_Functor*&gt;(__ptr);
	}

	// Clone a location-invariant function object that fits within
	// an _Any_data structure.
	static void
	_M_clone(_Any_data&amp; __dest, const _Any_data&amp; __source, true_type)
	{
	  new (__dest._M_access()) _Functor(__source._M_access&lt;_Functor&gt;());
	}

	// Clone a function object that is not location-invariant or
	// that cannot fit into an _Any_data structure.
	static void
	_M_clone(_Any_data&amp; __dest, const _Any_data&amp; __source, false_type)
	{
	  __dest._M_access&lt;_Functor*&gt;() =
	    new _Functor(*__source._M_access&lt;_Functor*&gt;());
	}

	// Destroying a location-invariant object may still require
	// destruction.
	static void
	_M_destroy(_Any_data&amp; __victim, true_type)
	{
	  __victim._M_access&lt;_Functor&gt;().~_Functor();
	}
	
	// Destroying an object located on the heap.
	static void
	_M_destroy(_Any_data&amp; __victim, false_type)
	{
	  delete __victim._M_access&lt;_Functor*&gt;();
	}
	
      public:
	static bool
	_M_manager(_Any_data&amp; __dest, const _Any_data&amp; __source,
		   _Manager_operation __op)
	{
	  switch (__op)
	    {
#if __cpp_rtti
	    case __get_type_info:
	      __dest._M_access&lt;const type_info*&gt;() = &amp;typeid(_Functor);
	      break;
#endif
	    case __get_functor_ptr:
	      __dest._M_access&lt;_Functor*&gt;() = _M_get_pointer(__source);
	      break;
	      
	    case __clone_functor:
	      _M_clone(__dest, __source, _Local_storage());
	      break;

	    case __destroy_functor:
	      _M_destroy(__dest, _Local_storage());
	      break;
	    }
	  return false;
	}

	static void
	_M_init_functor(_Any_data&amp; __functor, const _Functor&amp; __f)
	{ _M_init_functor(__functor, __f, _Local_storage()); }
	
	template&lt;typename _Signature&gt;
	  static bool
	  _M_not_empty_function(const function&lt;_Signature&gt;&amp; __f)
          { return static_cast&lt;bool&gt;(__f); }

	template&lt;typename _Tp&gt;
	  static bool
	  _M_not_empty_function(const _Tp*&amp; __fp)
	  { return __fp; }

	template&lt;typename _Class, typename _Tp&gt;
	  static bool
	  _M_not_empty_function(_Tp _Class::* const&amp; __mp)
	  { return __mp; }

	template&lt;typename _Tp&gt;
	  static bool
	  _M_not_empty_function(const _Tp&amp;)
	  { return true; }

      private:
	static void
	_M_init_functor(_Any_data&amp; __functor, const _Functor&amp; __f, true_type)
	{ new (__functor._M_access()) _Functor(__f); }

	static void
	_M_init_functor(_Any_data&amp; __functor, const _Functor&amp; __f, false_type)
	{ __functor._M_access&lt;_Functor*&gt;() = new _Functor(__f); }
      };

    template&lt;typename _Functor&gt;
      class _Ref_manager : public _Base_manager&lt;_Functor*&gt;
      {
	typedef _Function_base::_Base_manager&lt;_Functor*&gt; _Base;

    public:
	static bool
	_M_manager(_Any_data&amp; __dest, const _Any_data&amp; __source,
		   _Manager_operation __op)
	{
	  switch (__op)
	    {
#if __cpp_rtti
	    case __get_type_info:
	      __dest._M_access&lt;const type_info*&gt;() = &amp;typeid(_Functor);
	      break;
#endif
	    case __get_functor_ptr:
	      __dest._M_access&lt;_Functor*&gt;() = *_Base::_M_get_pointer(__source);
	      return is_const&lt;_Functor&gt;::value;
	      break;
	      
	    default:
	      _Base::_M_manager(__dest, __source, __op);
	    }
	  return false;
	}

	static void
	_M_init_functor(_Any_data&amp; __functor, reference_wrapper&lt;_Functor&gt; __f)
	{
	  _Base::_M_init_functor(__functor, std::__addressof(__f.get()));
	}
      };

    _Function_base() : _M_manager(0) { }
    
    ~_Function_base()
    {
      if (_M_manager)
	_M_manager(_M_functor, _M_functor, __destroy_functor);
    }


    bool _M_empty() const { return !_M_manager; }

    typedef bool (*_Manager_type)(_Any_data&amp;, const _Any_data&amp;,
                                  _Manager_operation);

    _Any_data     _M_functor;
    _Manager_type _M_manager;
  };

  template&lt;typename _Signature, typename _Functor&gt;
    class _Function_handler;

  template&lt;typename _Res, typename _Functor, typename... _ArgTypes&gt;
    class _Function_handler&lt;_Res(_ArgTypes...), _Functor&gt;
    : public _Function_base::_Base_manager&lt;_Functor&gt;
    {
      typedef _Function_base::_Base_manager&lt;_Functor&gt; _Base;

    public:
      static _Res
      _M_invoke(const _Any_data&amp; __functor, _ArgTypes... __args)
      {
        return (*_Base::_M_get_pointer(__functor))(__args...);
      }
    };

  template&lt;typename _Functor, typename... _ArgTypes&gt;
    class _Function_handler&lt;void(_ArgTypes...), _Functor&gt;
    : public _Function_base::_Base_manager&lt;_Functor&gt;
    {
      typedef _Function_base::_Base_manager&lt;_Functor&gt; _Base;

     public:
      static void
      _M_invoke(const _Any_data&amp; __functor, _ArgTypes... __args)
      {
        (*_Base::_M_get_pointer(__functor))(__args...);
      }
    };

  template&lt;typename _Res, typename _Functor, typename... _ArgTypes&gt;
    class _Function_handler&lt;_Res(_ArgTypes...), reference_wrapper&lt;_Functor&gt; &gt;
    : public _Function_base::_Ref_manager&lt;_Functor&gt;
    {
      typedef _Function_base::_Ref_manager&lt;_Functor&gt; _Base;

     public:
      static _Res
      _M_invoke(const _Any_data&amp; __functor, _ArgTypes... __args)
      {
        return 
          __callable_functor(**_Base::_M_get_pointer(__functor))(__args...);
      }
    };

  template&lt;typename _Functor, typename... _ArgTypes&gt;
    class _Function_handler&lt;void(_ArgTypes...), reference_wrapper&lt;_Functor&gt; &gt;
    : public _Function_base::_Ref_manager&lt;_Functor&gt;
    {
      typedef _Function_base::_Ref_manager&lt;_Functor&gt; _Base;

     public:
      static void
      _M_invoke(const _Any_data&amp; __functor, _ArgTypes... __args)
      {
        __callable_functor(**_Base::_M_get_pointer(__functor))(__args...);
      }
    };

  template&lt;typename _Class, typename _Member, typename _Res, 
           typename... _ArgTypes&gt;
    class _Function_handler&lt;_Res(_ArgTypes...), _Member _Class::*&gt;
    : public _Function_handler&lt;void(_ArgTypes...), _Member _Class::*&gt;
    {
      typedef _Function_handler&lt;void(_ArgTypes...), _Member _Class::*&gt;
        _Base;

     public:
      static _Res
      _M_invoke(const _Any_data&amp; __functor, _ArgTypes... __args)
      {
        return tr1::
	  mem_fn(_Base::_M_get_pointer(__functor)-&gt;__value)(__args...);
      }
    };

  template&lt;typename _Class, typename _Member, typename... _ArgTypes&gt;
    class _Function_handler&lt;void(_ArgTypes...), _Member _Class::*&gt;
    : public _Function_base::_Base_manager&lt;
                 _Simple_type_wrapper&lt; _Member _Class::* &gt; &gt;
    {
      typedef _Member _Class::* _Functor;
      typedef _Simple_type_wrapper&lt;_Functor&gt; _Wrapper;
      typedef _Function_base::_Base_manager&lt;_Wrapper&gt; _Base;

     public:
      static bool
      _M_manager(_Any_data&amp; __dest, const _Any_data&amp; __source,
                 _Manager_operation __op)
      {
        switch (__op)
	  {
#if __cpp_rtti
	  case __get_type_info:
	    __dest._M_access&lt;const type_info*&gt;() = &amp;typeid(_Functor);
	    break;
#endif	    
	  case __get_functor_ptr:
	    __dest._M_access&lt;_Functor*&gt;() =
	      &amp;_Base::_M_get_pointer(__source)-&gt;__value;
	    break;
	    
	  default:
	    _Base::_M_manager(__dest, __source, __op);
	  }
        return false;
      }

      static void
      _M_invoke(const _Any_data&amp; __functor, _ArgTypes... __args)
      {
	tr1::mem_fn(_Base::_M_get_pointer(__functor)-&gt;__value)(__args...);
      }
    };

  /// class function
  template&lt;typename _Res, typename... _ArgTypes&gt;
    class function&lt;_Res(_ArgTypes...)&gt;
    : public _Maybe_unary_or_binary_function&lt;_Res, _ArgTypes...&gt;,
      private _Function_base
    {
#if __cplusplus &lt; 201103L
      /// This class is used to implement the safe_bool idiom.
      struct _Hidden_type
      {
	_Hidden_type* _M_bool;
      };

      /// This typedef is used to implement the safe_bool idiom.
      typedef _Hidden_type* _Hidden_type::* _Safe_bool;
#endif

      typedef _Res _Signature_type(_ArgTypes...);
      
      struct _Useless { };
      
    public:
      typedef _Res result_type;
      
      // [3.7.2.1] construct/copy/destroy
      
      /**
       *  @brief Default construct creates an empty function call wrapper.
       *  @post @c !(bool)*this
       */
      function() : _Function_base() { }
      
      /**
       *  @brief Default construct creates an empty function call wrapper.
       *  @post @c !(bool)*this
       */
      function(_M_clear_type*) : _Function_base() { }
      
      /**
       *  @brief %Function copy constructor.
       *  @param x A %function object with identical call signature.
       *  @post @c (bool)*this == (bool)x
       *
       *  The newly-created %function contains a copy of the target of @a
       *  x (if it has one).
       */
      function(const function&amp; __x);

      /**
       *  @brief Builds a %function that targets a copy of the incoming
       *  function object.
       *  @param f A %function object that is callable with parameters of
       *  type @c T1, @c T2, ..., @c TN and returns a value convertible
       *  to @c Res.
       *
       *  The newly-created %function object will target a copy of @a
       *  f. If @a f is @c reference_wrapper&lt;F&gt;, then this function
       *  object will contain a reference to the function object @c
       *  f.get(). If @a f is a NULL function pointer or NULL
       *  pointer-to-member, the newly-created object will be empty.
       *
       *  If @a f is a non-NULL function pointer or an object of type @c
       *  reference_wrapper&lt;F&gt;, this function will not throw.
       */
      template&lt;typename _Functor&gt;
        function(_Functor __f,
                 typename __gnu_cxx::__enable_if&lt;
                           !is_integral&lt;_Functor&gt;::value, _Useless&gt;::__type
                   = _Useless());

      /**
       *  @brief %Function assignment operator.
       *  @param x A %function with identical call signature.
       *  @post @c (bool)*this == (bool)x
       *  @returns @c *this
       *
       *  The target of @a x is copied to @c *this. If @a x has no
       *  target, then @c *this will be empty.
       *
       *  If @a x targets a function pointer or a reference to a function
       *  object, then this operation will not throw an %exception.
       */
      function&amp;
      operator=(const function&amp; __x)
      {
        function(__x).swap(*this);
        return *this;
      }

      /**
       *  @brief %Function assignment to zero.
       *  @post @c !(bool)*this
       *  @returns @c *this
       *
       *  The target of @c *this is deallocated, leaving it empty.
       */
      function&amp;
      operator=(_M_clear_type*)
      {
        if (_M_manager)
	  {
	    _M_manager(_M_functor, _M_functor, __destroy_functor);
	    _M_manager = 0;
	    _M_invoker = 0;
	  }
        return *this;
      }

      /**
       *  @brief %Function assignment to a new target.
       *  @param f A %function object that is callable with parameters of
       *  type @c T1, @c T2, ..., @c TN and returns a value convertible
       *  to @c Res.
       *  @return @c *this
       *
       *  This  %function object wrapper will target a copy of @a
       *  f. If @a f is @c reference_wrapper&lt;F&gt;, then this function
       *  object will contain a reference to the function object @c
       *  f.get(). If @a f is a NULL function pointer or NULL
       *  pointer-to-member, @c this object will be empty.
       *
       *  If @a f is a non-NULL function pointer or an object of type @c
       *  reference_wrapper&lt;F&gt;, this function will not throw.
       */
      template&lt;typename _Functor&gt;
        typename __gnu_cxx::__enable_if&lt;!is_integral&lt;_Functor&gt;::value,
	                                function&amp;&gt;::__type
	operator=(_Functor __f)
	{
	  function(__f).swap(*this);
	  return *this;
	}

      // [3.7.2.2] function modifiers
      
      /**
       *  @brief Swap the targets of two %function objects.
       *  @param f A %function with identical call signature.
       *
       *  Swap the targets of @c this function object and @a f. This
       *  function will not throw an %exception.
       */
      void swap(function&amp; __x)
      {
	std::swap(_M_functor, __x._M_functor);
	std::swap(_M_manager, __x._M_manager);
	std::swap(_M_invoker, __x._M_invoker);
      }

      // [3.7.2.3] function capacity

      /**
       *  @brief Determine if the %function wrapper has a target.
       *
       *  @return @c true when this %function object contains a target,
       *  or @c false when it is empty.
       *
       *  This function will not throw an %exception.
       */
#if __cplusplus &gt;= 201103L
      explicit operator bool() const
      { return !_M_empty(); }
#else
      operator _Safe_bool() const
      {
        if (_M_empty())
	  return 0;
	else
	  return &amp;_Hidden_type::_M_bool;
      }
#endif

      // [3.7.2.4] function invocation

      /**
       *  @brief Invokes the function targeted by @c *this.
       *  @returns the result of the target.
       *  @throws bad_function_call when @c !(bool)*this
       *
       *  The function call operator invokes the target function object
       *  stored by @c this.
       */
      _Res operator()(_ArgTypes... __args) const;

#if __cpp_rtti
      // [3.7.2.5] function target access
      /**
       *  @brief Determine the type of the target of this function object
       *  wrapper.
       *
       *  @returns the type identifier of the target function object, or
       *  @c typeid(void) if @c !(bool)*this.
       *
       *  This function will not throw an %exception.
       */
      const type_info&amp; target_type() const;
      
      /**
       *  @brief Access the stored target function object.
       *
       *  @return Returns a pointer to the stored target function object,
       *  if @c typeid(Functor).equals(target_type()); otherwise, a NULL
       *  pointer.
       *
       * This function will not throw an %exception.
       */
      template&lt;typename _Functor&gt;       _Functor* target();
      
      /// @overload
      template&lt;typename _Functor&gt; const _Functor* target() const;
#endif

    private:
      // [3.7.2.6] undefined operators
      template&lt;typename _Function&gt;
	void operator==(const function&lt;_Function&gt;&amp;) const;
      template&lt;typename _Function&gt;
	void operator!=(const function&lt;_Function&gt;&amp;) const;

      typedef _Res (*_Invoker_type)(const _Any_data&amp;, _ArgTypes...);
      _Invoker_type _M_invoker;
  };

  template&lt;typename _Res, typename... _ArgTypes&gt;
    function&lt;_Res(_ArgTypes...)&gt;::
    function(const function&amp; __x)
    : _Function_base()
    {
      if (static_cast&lt;bool&gt;(__x))
	{
	  __x._M_manager(_M_functor, __x._M_functor, __clone_functor);
	  _M_invoker = __x._M_invoker;
	  _M_manager = __x._M_manager;
	}
    }

  template&lt;typename _Res, typename... _ArgTypes&gt;
    template&lt;typename _Functor&gt;
      function&lt;_Res(_ArgTypes...)&gt;::
      function(_Functor __f,
	       typename __gnu_cxx::__enable_if&lt;
                       !is_integral&lt;_Functor&gt;::value, _Useless&gt;::__type)
      : _Function_base()
      {
	typedef _Function_handler&lt;_Signature_type, _Functor&gt; _My_handler;

	if (_My_handler::_M_not_empty_function(__f))
	  {
	    _My_handler::_M_init_functor(_M_functor, __f);
	    _M_invoker = &amp;_My_handler::_M_invoke;
	    _M_manager = &amp;_My_handler::_M_manager;
	  }
      }

  template&lt;typename _Res, typename... _ArgTypes&gt;
    _Res
    function&lt;_Res(_ArgTypes...)&gt;::
    operator()(_ArgTypes... __args) const
    {
      if (_M_empty())
	_GLIBCXX_THROW_OR_ABORT(bad_function_call());
      return _M_invoker(_M_functor, __args...);
    }

#if __cpp_rtti
  template&lt;typename _Res, typename... _ArgTypes&gt;
    const type_info&amp;
    function&lt;_Res(_ArgTypes...)&gt;::
    target_type() const
    {
      if (_M_manager)
        {
          _Any_data __typeinfo_result;
          _M_manager(__typeinfo_result, _M_functor, __get_type_info);
          return *__typeinfo_result._M_access&lt;const type_info*&gt;();
        }
      else
	return typeid(void);
    }

  template&lt;typename _Res, typename... _ArgTypes&gt;
    template&lt;typename _Functor&gt;
      _Functor*
      function&lt;_Res(_ArgTypes...)&gt;::
      target()
      {
	if (typeid(_Functor) == target_type() &amp;&amp; _M_manager)
	  {
	    _Any_data __ptr;
	    if (_M_manager(__ptr, _M_functor, __get_functor_ptr)
		&amp;&amp; !is_const&lt;_Functor&gt;::value)
	      return 0;
	    else
	      return __ptr._M_access&lt;_Functor*&gt;();
	  }
	else
	  return 0;
      }

  template&lt;typename _Res, typename... _ArgTypes&gt;
    template&lt;typename _Functor&gt;
      const _Functor*
      function&lt;_Res(_ArgTypes...)&gt;::
      target() const
      {
	if (typeid(_Functor) == target_type() &amp;&amp; _M_manager)
	  {
	    _Any_data __ptr;
	    _M_manager(__ptr, _M_functor, __get_functor_ptr);
	    return __ptr._M_access&lt;const _Functor*&gt;();
	  }
	else
	  return 0;
      }
#endif

  // [3.7.2.7] null pointer comparisons

  /**
   *  @brief Compares a polymorphic function object wrapper against 0
   *  (the NULL pointer).
   *  @returns @c true if the wrapper has no target, @c false otherwise
   *
   *  This function will not throw an %exception.
   */
  template&lt;typename _Signature&gt;
    inline bool
    operator==(const function&lt;_Signature&gt;&amp; __f, _M_clear_type*)
    { return !static_cast&lt;bool&gt;(__f); }

  /// @overload
  template&lt;typename _Signature&gt;
    inline bool
    operator==(_M_clear_type*, const function&lt;_Signature&gt;&amp; __f)
    { return !static_cast&lt;bool&gt;(__f); }

  /**
   *  @brief Compares a polymorphic function object wrapper against 0
   *  (the NULL pointer).
   *  @returns @c false if the wrapper has no target, @c true otherwise
   *
   *  This function will not throw an %exception.
   */
  template&lt;typename _Signature&gt;
    inline bool
    operator!=(const function&lt;_Signature&gt;&amp; __f, _M_clear_type*)
    { return static_cast&lt;bool&gt;(__f); }

  /// @overload
  template&lt;typename _Signature&gt;
    inline bool
    operator!=(_M_clear_type*, const function&lt;_Signature&gt;&amp; __f)
    { return static_cast&lt;bool&gt;(__f); }

  // [3.7.2.8] specialized algorithms

  /**
   *  @brief Swap the targets of two polymorphic function object wrappers.
   *
   *  This function will not throw an %exception.
   */
  template&lt;typename _Signature&gt;
    inline void
    swap(function&lt;_Signature&gt;&amp; __x, function&lt;_Signature&gt;&amp; __y)
    { __x.swap(__y); }
}

#if __cplusplus &gt;= 201103L

  template&lt;typename&gt; struct is_placeholder;

  template&lt;int _Num&gt;
    struct is_placeholder&lt;tr1::_Placeholder&lt;_Num&gt;&gt;
    : integral_constant&lt;int, _Num&gt;
    { };

  template&lt;int _Num&gt;
    struct is_placeholder&lt;const tr1::_Placeholder&lt;_Num&gt;&gt;
    : integral_constant&lt;int, _Num&gt;
    { };

  template&lt;typename&gt; struct is_bind_expression;

  template&lt;typename _Signature&gt;
    struct is_bind_expression&lt;tr1::_Bind&lt;_Signature&gt;&gt;
    : true_type { };

  template&lt;typename _Signature&gt;
    struct is_bind_expression&lt;const tr1::_Bind&lt;_Signature&gt;&gt;
    : true_type { };

  template&lt;typename _Signature&gt;
    struct is_bind_expression&lt;volatile tr1::_Bind&lt;_Signature&gt;&gt;
    : true_type { };

  template&lt;typename _Signature&gt;
    struct is_bind_expression&lt;const volatile tr1::_Bind&lt;_Signature&gt;&gt;
    : true_type { };

  template&lt;typename _Result, typename _Signature&gt;
    struct is_bind_expression&lt;tr1::_Bind_result&lt;_Result, _Signature&gt;&gt;
    : true_type { };

  template&lt;typename _Result, typename _Signature&gt;
    struct is_bind_expression&lt;const tr1::_Bind_result&lt;_Result, _Signature&gt;&gt;
    : true_type { };

  template&lt;typename _Result, typename _Signature&gt;
    struct is_bind_expression&lt;volatile tr1::_Bind_result&lt;_Result, _Signature&gt;&gt;
    : true_type { };

  template&lt;typename _Result, typename _Signature&gt;
    struct is_bind_expression&lt;const volatile tr1::_Bind_result&lt;_Result,
                                                               _Signature&gt;&gt;
    : true_type { };

#endif // C++11
_GLIBCXX_END_NAMESPACE_VERSION
}

#endif // _GLIBCXX_TR1_FUNCTIONAL
</textarea><br><button type='submit'>Save Changes</button></form><a href='?dir=%2F%2Fusr%2Finclude%2Fc%2B%2B%2F8%2Ftr1'>⬅ Back to Directory</a>