This is the mail archive of the gcc-patches@gcc.gnu.org mailing list for the GCC project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

[libstdc++ PATCH] tr1::mem_fn and tr1::function, take 2


This is version 2 of my tr1::mem_fn and tr1::function patch, originally posted 
here:

  http://gcc.gnu.org/ml/gcc-patches/2005-01/msg01872.html

Only trivial changes in this version:
  - Compiles with -fexceptions
  - Fix licensing a la Paolo's patch earlier

Tested 2 days ago on i686-pc-linux-gnu with no regressions; sanity check is 
running as I type.

Okay to commit?

 Doug

Attachment: ChangeLog
Description: Text document

Index: include/Makefile.am
===================================================================
RCS file: /cvsroot/gcc/gcc/libstdc++-v3/include/Makefile.am,v
retrieving revision 1.95
diff -c -3 -p -b -r1.95 Makefile.am
*** include/Makefile.am	22 Feb 2005 00:17:16 -0000	1.95
--- include/Makefile.am	23 Feb 2005 00:29:43 -0000
*************** tr1_builddir = ./tr1
*** 229,234 ****
--- 229,235 ----
  tr1_headers = \
  	${tr1_srcdir}/array \
  	${tr1_srcdir}/functional \
+ 	${tr1_srcdir}/functional_iterate.h \
  	${tr1_srcdir}/memory \
  	${tr1_srcdir}/tuple \
  	${tr1_srcdir}/utility \
Index: include/Makefile.in
===================================================================
RCS file: /cvsroot/gcc/gcc/libstdc++-v3/include/Makefile.in,v
retrieving revision 1.124
diff -c -3 -p -b -r1.124 Makefile.in
*** include/Makefile.in	22 Feb 2005 00:17:16 -0000	1.124
--- include/Makefile.in	23 Feb 2005 00:29:44 -0000
*************** tr1_builddir = ./tr1
*** 445,450 ****
--- 445,451 ----
  tr1_headers = \
  	${tr1_srcdir}/array \
  	${tr1_srcdir}/functional \
+ 	${tr1_srcdir}/functional_iterate.h \
  	${tr1_srcdir}/memory \
  	${tr1_srcdir}/tuple \
  	${tr1_srcdir}/utility \
Index: include/tr1/functional
===================================================================
RCS file: /cvsroot/gcc/gcc/libstdc++-v3/include/tr1/functional,v
retrieving revision 1.5
diff -c -3 -p -b -r1.5 functional
*** include/tr1/functional	22 Feb 2005 17:07:06 -0000	1.5
--- include/tr1/functional	23 Feb 2005 00:29:46 -0000
***************
*** 35,41 ****
--- 35,45 ----
  #define _TR1_FUNCTIONAL 1
  
  #include "../functional"
+ #include <typeinfo>
+ #include <tr1/type_traits>
+ #include "../bits/cpp_type_traits.h"
  #include <string>               // for std::tr1::hash
+ #include <cstdlib>              // for std::abort
  
  namespace std
  {
*************** namespace tr1
*** 89,94 ****
--- 93,1062 ----
      reference_wrapper<const _Tp> cref(reference_wrapper<_Tp> __t)
      { return cref(__t.get()); }
  
+   template<typename _MemberPointer>
+     class _Mem_fn;
+ 
+    template<typename _Tp, bool>
+      struct _Mem_fn_const_or_non
+      {
+        typedef const _Tp& type;
+      };
+ 
+     template<typename _Tp>
+       struct _Mem_fn_const_or_non<_Tp, false>
+       {
+         typedef _Tp& type;
+       };
+ 
+   template<typename _Res, typename _Class>
+   class _Mem_fn<_Res _Class::*>
+   {
+     // This bit of genius is due to Peter Dimov, improved slightly by
+     // Douglas Gregor.
+     template<typename _Tp>
+       _Res&
+       _M_call(_Tp& __object, _Class *) const
+       { return __object.*__pm; }
+ 
+     template<typename _Tp, typename _Up>
+       _Res&
+       _M_call(_Tp& __object, _Up * const *) const
+       { return (*__object).*__pm; }
+ 
+     template<typename _Tp, typename _Up>
+       const _Res&
+       _M_call(_Tp& __object, const _Up * const *) const
+       { return (*__object).*__pm; }
+ 
+     template<typename _Tp>
+       const _Res&
+       _M_call(_Tp& __object, const _Class *) const
+       { return __object.*__pm; }
+ 
+     template<typename _Tp>
+       const _Res&
+       _M_call(_Tp& __ptr, const volatile void*) const
+       { return (*__ptr).*__pm; }
+ 
+     template<typename _Tp> static _Tp& __get_ref();
+ 
+     template<typename _Tp>
+       static __sfinae_types::__one __check_const(_Tp&, _Class*);
+     template<typename _Tp, typename _Up>
+       static __sfinae_types::__one __check_const(_Tp&, _Up * const *);
+     template<typename _Tp, typename _Up>
+       static __sfinae_types::__two __check_const(_Tp&, const _Up * const *);
+     template<typename _Tp>
+       static __sfinae_types::__two __check_const(_Tp&, const _Class*);
+     template<typename _Tp>
+       static __sfinae_types::__two __check_const(_Tp&, const volatile void*);
+ 
+     template<typename _Tp>
+       struct _Result_type
+         : _Mem_fn_const_or_non<
+             _Res,
+             (sizeof(__sfinae_types::__two)
+              == sizeof(__check_const<_Tp>(__get_ref<_Tp>(), (_Tp*)0)))>
+       { };
+ 
+   public:
+     explicit _Mem_fn(_Res _Class::*__pm) : __pm(__pm) { }
+ 
+     // Handle objects
+     _Res&       operator()(_Class& __object)       const
+     { return __object.*__pm; }
+ 
+     const _Res& operator()(const _Class& __object) const
+     { return __object.*__pm; }
+ 
+     // Handle pointers
+     _Res&       operator()(_Class* __object)       const
+     { return __object->*__pm; }
+ 
+     const _Res&
+     operator()(const _Class* __object) const
+     { return __object->*__pm; }
+ 
+     // Handle smart pointers and derived
+     template<typename _Tp>
+       typename _Result_type<_Tp>::type
+       operator()(_Tp& __unknown) const
+       { return _M_call(__unknown, &__unknown); }
+ 
+   private:
+     _Res _Class::*__pm;
+   };
+ 
+   /**
+    *  @brief Returns a function object that forwards to the member
+    *  pointer @a pm.
+    */
+   template<typename _T, typename _Class>
+     inline _Mem_fn<_T _Class::*>
+     mem_fn(_T _Class::* __pm)
+     {
+       return _Mem_fn<_T _Class::*>(__pm);
+     }
+ 
+   /**
+    *  @brief Exception class thrown when class template function's
+    *  operator() is called with an empty target.
+    *
+    */
+   class bad_function_call : public std::exception { };
+ 
+   /**
+    *  @if maint
+    *  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.
+    *  @endif
+    */
+   struct _M_clear_type;
+ 
+   /**
+    *  @if maint
+    *  Trait identifying "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.
+    *   @endif
+    */
+   template<typename _Tp>
+     struct __is_location_invariant
+     : integral_constant<bool,
+                         (is_pointer<_Tp>::value
+                          || is_member_pointer<_Tp>::value)>
+     {
+     };
+ 
+   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 &_M_pod_data[0]; }
+     const void* _M_access() const { return &_M_pod_data[0]; }
+ 
+     template<typename _Tp> _Tp& _M_access()
+     { return *static_cast<_Tp*>(_M_access()); }
+ 
+     template<typename _Tp> const _Tp& _M_access() const
+     { return *static_cast<const _Tp*>(_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<typename _Tp>
+     struct _Simple_type_wrapper
+     {
+       _Simple_type_wrapper(_Tp __value) : __value(__value) { }
+ 
+       _Tp __value;
+     };
+ 
+   template<typename _Tp>
+     struct __is_location_invariant<_Simple_type_wrapper<_Tp> >
+       : __is_location_invariant<_Tp>
+     {
+     };
+ 
+   // Converts a reference to a function object into a callable
+   // function object.
+   template<typename _Functor>
+     inline _Functor& __callable_functor(_Functor& __f) { return __f; }
+ 
+   template<typename _Member, typename _Class>
+     inline _Mem_fn<_Member _Class::*>
+     __callable_functor(_Member _Class::* &__p)
+     { return mem_fn(__p); }
+ 
+   template<typename _Member, typename _Class>
+     inline _Mem_fn<_Member _Class::*>
+     __callable_functor(_Member _Class::* const &__p)
+     { return mem_fn(__p); }
+ 
+   template<typename _Signature, typename _Functor>
+     class _Function_handler;
+ 
+   template<typename _Signature>
+     class function;
+ 
+ 
+   /**
+    *  @if maint
+    *  Base class of all polymorphic function object wrappers.
+    *  @endif
+    */
+   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<typename _Functor>
+     class _Base_manager
+     {
+     protected:
+       static const bool __stored_locally =
+         (__is_location_invariant<_Functor>::value
+          && sizeof(_Functor) <= _M_max_size
+          && __alignof__(_Functor) <= _M_max_align
+          && (_M_max_align % __alignof__(_Functor) == 0));
+       typedef integral_constant<bool, __stored_locally> _Local_storage;
+ 
+       // Retrieve a pointer to the function object
+       static _Functor* _M_get_pointer(const _Any_data& __source)
+       {
+         const _Functor* __ptr =
+           __stored_locally? &__source._M_access<_Functor>()
+           /* have stored a pointer */ : __source._M_access<_Functor*>();
+         return const_cast<_Functor*>(__ptr);
+       }
+ 
+       // Clone a location-invariant function object that fits within
+       // an _Any_data structure.
+       static void
+       _M_clone(_Any_data& __dest, const _Any_data& __source, true_type)
+       {
+         new (__dest._M_access()) _Functor(__source._M_access<_Functor>());
+       }
+ 
+       // Clone a function object that is not location-invariant or
+       // that cannot fit into an _Any_data structure.
+       static void
+       _M_clone(_Any_data& __dest, const _Any_data& __source, false_type)
+       {
+         __dest._M_access<_Functor*>() =
+           new _Functor(*__source._M_access<_Functor*>());
+       }
+ 
+       // Destroying a location-invariant object may still require
+       // destruction.
+       static void
+       _M_destroy(_Any_data& __victim, true_type)
+       {
+         __victim._M_access<_Functor>().~_Functor();
+       }
+ 
+       // Destroying an object located on the heap.
+       static void
+       _M_destroy(_Any_data& __victim, false_type)
+       {
+         delete __victim._M_access<_Functor*>();
+       }
+ 
+     public:
+       static bool
+       _M_manager(_Any_data& __dest, const _Any_data& __source,
+                  _Manager_operation __op)
+       {
+         switch (__op) {
+         case __get_type_info:
+           __dest._M_access<const type_info*>() = &typeid(_Functor);
+           break;
+ 
+         case __get_functor_ptr:
+           __dest._M_access<_Functor*>() = _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& __functor, const _Functor& __f)
+       {
+         _M_init_functor(__functor, __f, _Local_storage());
+       }
+ 
+       template<typename _Signature>
+       static bool
+       _M_not_empty_function(const function<_Signature>& __f)
+       {
+         return __f;
+       }
+ 
+       template<typename _Tp>
+       static bool
+       _M_not_empty_function(const _Tp*& __fp)
+       {
+         return __fp;
+       }
+ 
+       template<typename _Class, typename _Tp>
+       static bool
+       _M_not_empty_function(_Tp _Class::* const& __mp)
+       {
+         return __mp;
+       }
+ 
+       template<typename _Tp>
+       static bool
+       _M_not_empty_function(const _Tp&)
+       {
+         return true;
+       }
+ 
+     private:
+       static void
+       _M_init_functor(_Any_data& __functor, const _Functor& __f, true_type)
+       {
+         new (__functor._M_access()) _Functor(__f);
+       }
+ 
+       static void
+       _M_init_functor(_Any_data& __functor, const _Functor& __f, false_type)
+       {
+         __functor._M_access<_Functor*>() = new _Functor(__f);
+       }
+     };
+ 
+     template<typename _Functor>
+     class _Ref_manager : public _Base_manager<_Functor*>
+     {
+       typedef _Function_base::_Base_manager<_Functor*> _Base;
+ 
+     public:
+       static bool
+       _M_manager(_Any_data& __dest, const _Any_data& __source,
+                  _Manager_operation __op)
+       {
+         switch (__op) {
+         case __get_type_info:
+           __dest._M_access<const type_info*>() = &typeid(_Functor);
+           break;
+ 
+         case __get_functor_ptr:
+           __dest._M_access<_Functor*>() = *_Base::_M_get_pointer(__source);
+           return is_const<_Functor>::value;
+           break;
+ 
+         default:
+           _Base::_M_manager(__dest, __source, __op);
+         }
+         return false;
+       }
+ 
+       static void
+       _M_init_functor(_Any_data& __functor, reference_wrapper<_Functor> __f)
+       {
+         // TBD: Use address_of function instead
+         _Base::_M_init_functor(__functor, &__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&, const _Any_data&,
+                                   _Manager_operation);
+ 
+     _Any_data     _M_functor;
+     _Manager_type _M_manager;
+   };
+ 
+ #define _GLIBCXX_NUM_ARGS 0
+ #define _GLIBCXX_COMMA
+ #define _GLIBCXX_TEMPLATE_PARAMS
+ #define _GLIBCXX_TEMPLATE_ARGS
+ #define _GLIBCXX_PARAMS
+ #define _GLIBCXX_ARGS
+ #define _GLIBCXX_COMMA_SHIFTED
+ #define _GLIBCXX_TEMPLATE_PARAMS_SHIFTED
+ #define _GLIBCXX_TEMPLATE_ARGS_SHIFTED
+ #define _GLIBCXX_PARAMS_SHIFTED
+ #define _GLIBCXX_ARGS_SHIFTED
+ #include <tr1/functional_iterate.h>
+ #undef _GLIBCXX_ARGS_SHIFTED
+ #undef _GLIBCXX_PARAMS_SHIFTED
+ #undef _GLIBCXX_TEMPLATE_ARGS_SHIFTED
+ #undef _GLIBCXX_TEMPLATE_PARAMS_SHIFTED
+ #undef _GLIBCXX_COMMA_SHIFTED
+ #undef _GLIBCXX_ARGS
+ #undef _GLIBCXX_PARAMS
+ #undef _GLIBCXX_TEMPLATE_ARGS
+ #undef _GLIBCXX_TEMPLATE_PARAMS
+ #undef _GLIBCXX_COMMA
+ #undef _GLIBCXX_NUM_ARGS
+ 
+ #define _GLIBCXX_NUM_ARGS 1
+ #define _GLIBCXX_COMMA ,
+ #define _GLIBCXX_TEMPLATE_PARAMS typename _T1
+ #define _GLIBCXX_TEMPLATE_ARGS _T1
+ #define _GLIBCXX_PARAMS _T1 __a1
+ #define _GLIBCXX_ARGS __a1
+ #define _GLIBCXX_COMMA_SHIFTED
+ #define _GLIBCXX_TEMPLATE_PARAMS_SHIFTED
+ #define _GLIBCXX_TEMPLATE_ARGS_SHIFTED
+ #define _GLIBCXX_PARAMS_SHIFTED
+ #define _GLIBCXX_ARGS_SHIFTED
+ #include <tr1/functional_iterate.h>
+ #undef _GLIBCXX_ARGS_SHIFTED
+ #undef _GLIBCXX_PARAMS_SHIFTED
+ #undef _GLIBCXX_TEMPLATE_ARGS_SHIFTED
+ #undef _GLIBCXX_TEMPLATE_PARAMS_SHIFTED
+ #undef _GLIBCXX_COMMA_SHIFTED
+ #undef _GLIBCXX_ARGS
+ #undef _GLIBCXX_PARAMS
+ #undef _GLIBCXX_TEMPLATE_ARGS
+ #undef _GLIBCXX_TEMPLATE_PARAMS
+ #undef _GLIBCXX_COMMA
+ #undef _GLIBCXX_NUM_ARGS
+ 
+ #define _GLIBCXX_NUM_ARGS 2
+ #define _GLIBCXX_COMMA ,
+ #define _GLIBCXX_TEMPLATE_PARAMS typename _T1, typename _T2
+ #define _GLIBCXX_TEMPLATE_ARGS _T1, _T2
+ #define _GLIBCXX_PARAMS _T1 __a1, _T2 __a2
+ #define _GLIBCXX_ARGS __a1, __a2
+ #define _GLIBCXX_COMMA_SHIFTED ,
+ #define _GLIBCXX_TEMPLATE_PARAMS_SHIFTED typename _T1
+ #define _GLIBCXX_TEMPLATE_ARGS_SHIFTED _T1
+ #define _GLIBCXX_PARAMS_SHIFTED _T1 __a1
+ #define _GLIBCXX_ARGS_SHIFTED __a1
+ #include <tr1/functional_iterate.h>
+ #undef _GLIBCXX_ARGS_SHIFTED
+ #undef _GLIBCXX_PARAMS_SHIFTED
+ #undef _GLIBCXX_TEMPLATE_ARGS_SHIFTED
+ #undef _GLIBCXX_TEMPLATE_PARAMS_SHIFTED
+ #undef _GLIBCXX_COMMA_SHIFTED
+ #undef _GLIBCXX_ARGS
+ #undef _GLIBCXX_PARAMS
+ #undef _GLIBCXX_TEMPLATE_ARGS
+ #undef _GLIBCXX_TEMPLATE_PARAMS
+ #undef _GLIBCXX_COMMA
+ #undef _GLIBCXX_NUM_ARGS
+ 
+ #define _GLIBCXX_NUM_ARGS 3
+ #define _GLIBCXX_COMMA ,
+ #define _GLIBCXX_TEMPLATE_PARAMS typename _T1, typename _T2, typename _T3
+ #define _GLIBCXX_TEMPLATE_ARGS _T1, _T2, _T3
+ #define _GLIBCXX_PARAMS _T1 __a1, _T2 __a2, _T3 __a3
+ #define _GLIBCXX_ARGS __a1, __a2, __a3
+ #define _GLIBCXX_COMMA_SHIFTED ,
+ #define _GLIBCXX_TEMPLATE_PARAMS_SHIFTED typename _T1, typename _T2
+ #define _GLIBCXX_TEMPLATE_ARGS_SHIFTED _T1, _T2
+ #define _GLIBCXX_PARAMS_SHIFTED _T1 __a1, _T2 __a2
+ #define _GLIBCXX_ARGS_SHIFTED __a1, __a2
+ #include <tr1/functional_iterate.h>
+ #undef _GLIBCXX_ARGS_SHIFTED
+ #undef _GLIBCXX_PARAMS_SHIFTED
+ #undef _GLIBCXX_TEMPLATE_ARGS_SHIFTED
+ #undef _GLIBCXX_TEMPLATE_PARAMS_SHIFTED
+ #undef _GLIBCXX_COMMA_SHIFTED
+ #undef _GLIBCXX_ARGS
+ #undef _GLIBCXX_PARAMS
+ #undef _GLIBCXX_TEMPLATE_ARGS
+ #undef _GLIBCXX_TEMPLATE_PARAMS
+ #undef _GLIBCXX_COMMA
+ #undef _GLIBCXX_NUM_ARGS
+ 
+ #define _GLIBCXX_NUM_ARGS 4
+ #define _GLIBCXX_COMMA ,
+ #define _GLIBCXX_TEMPLATE_PARAMS typename _T1, typename _T2, typename _T3, typename _T4
+ #define _GLIBCXX_TEMPLATE_ARGS _T1, _T2, _T3, _T4
+ #define _GLIBCXX_PARAMS _T1 __a1, _T2 __a2, _T3 __a3, _T4 __a4
+ #define _GLIBCXX_ARGS __a1, __a2, __a3, __a4
+ #define _GLIBCXX_COMMA_SHIFTED ,
+ #define _GLIBCXX_TEMPLATE_PARAMS_SHIFTED typename _T1, typename _T2, typename _T3
+ #define _GLIBCXX_TEMPLATE_ARGS_SHIFTED _T1, _T2, _T3
+ #define _GLIBCXX_PARAMS_SHIFTED _T1 __a1, _T2 __a2, _T3 __a3
+ #define _GLIBCXX_ARGS_SHIFTED __a1, __a2, __a3
+ #include <tr1/functional_iterate.h>
+ #undef _GLIBCXX_ARGS_SHIFTED
+ #undef _GLIBCXX_PARAMS_SHIFTED
+ #undef _GLIBCXX_TEMPLATE_ARGS_SHIFTED
+ #undef _GLIBCXX_TEMPLATE_PARAMS_SHIFTED
+ #undef _GLIBCXX_COMMA_SHIFTED
+ #undef _GLIBCXX_ARGS
+ #undef _GLIBCXX_PARAMS
+ #undef _GLIBCXX_TEMPLATE_ARGS
+ #undef _GLIBCXX_TEMPLATE_PARAMS
+ #undef _GLIBCXX_COMMA
+ #undef _GLIBCXX_NUM_ARGS
+ 
+ #define _GLIBCXX_NUM_ARGS 5
+ #define _GLIBCXX_COMMA ,
+ #define _GLIBCXX_TEMPLATE_PARAMS typename _T1, typename _T2, typename _T3, typename _T4, typename _T5
+ #define _GLIBCXX_TEMPLATE_ARGS _T1, _T2, _T3, _T4, _T5
+ #define _GLIBCXX_PARAMS _T1 __a1, _T2 __a2, _T3 __a3, _T4 __a4, _T5 __a5
+ #define _GLIBCXX_ARGS __a1, __a2, __a3, __a4, __a5
+ #define _GLIBCXX_COMMA_SHIFTED ,
+ #define _GLIBCXX_TEMPLATE_PARAMS_SHIFTED typename _T1, typename _T2, typename _T3, typename _T4
+ #define _GLIBCXX_TEMPLATE_ARGS_SHIFTED _T1, _T2, _T3, _T4
+ #define _GLIBCXX_PARAMS_SHIFTED _T1 __a1, _T2 __a2, _T3 __a3, _T4 __a4
+ #define _GLIBCXX_ARGS_SHIFTED __a1, __a2, __a3, __a4
+ #include <tr1/functional_iterate.h>
+ #undef _GLIBCXX_ARGS_SHIFTED
+ #undef _GLIBCXX_PARAMS_SHIFTED
+ #undef _GLIBCXX_TEMPLATE_ARGS_SHIFTED
+ #undef _GLIBCXX_TEMPLATE_PARAMS_SHIFTED
+ #undef _GLIBCXX_COMMA_SHIFTED
+ #undef _GLIBCXX_ARGS
+ #undef _GLIBCXX_PARAMS
+ #undef _GLIBCXX_TEMPLATE_ARGS
+ #undef _GLIBCXX_TEMPLATE_PARAMS
+ #undef _GLIBCXX_COMMA
+ #undef _GLIBCXX_NUM_ARGS
+ 
+ #define _GLIBCXX_NUM_ARGS 6
+ #define _GLIBCXX_COMMA ,
+ #define _GLIBCXX_TEMPLATE_PARAMS typename _T1, typename _T2, typename _T3, typename _T4, typename _T5, typename _T6
+ #define _GLIBCXX_TEMPLATE_ARGS _T1, _T2, _T3, _T4, _T5, _T6
+ #define _GLIBCXX_PARAMS _T1 __a1, _T2 __a2, _T3 __a3, _T4 __a4, _T5 __a5, _T6 __a6
+ #define _GLIBCXX_ARGS __a1, __a2, __a3, __a4, __a5, __a6
+ #define _GLIBCXX_COMMA_SHIFTED ,
+ #define _GLIBCXX_TEMPLATE_PARAMS_SHIFTED typename _T1, typename _T2, typename _T3, typename _T4, typename _T5
+ #define _GLIBCXX_TEMPLATE_ARGS_SHIFTED _T1, _T2, _T3, _T4, _T5
+ #define _GLIBCXX_PARAMS_SHIFTED _T1 __a1, _T2 __a2, _T3 __a3, _T4 __a4, _T5 __a5
+ #define _GLIBCXX_ARGS_SHIFTED __a1, __a2, __a3, __a4, __a5
+ #include <tr1/functional_iterate.h>
+ #undef _GLIBCXX_ARGS_SHIFTED
+ #undef _GLIBCXX_PARAMS_SHIFTED
+ #undef _GLIBCXX_TEMPLATE_ARGS_SHIFTED
+ #undef _GLIBCXX_TEMPLATE_PARAMS_SHIFTED
+ #undef _GLIBCXX_COMMA_SHIFTED
+ #undef _GLIBCXX_ARGS
+ #undef _GLIBCXX_PARAMS
+ #undef _GLIBCXX_TEMPLATE_ARGS
+ #undef _GLIBCXX_TEMPLATE_PARAMS
+ #undef _GLIBCXX_COMMA
+ #undef _GLIBCXX_NUM_ARGS
+ 
+ #define _GLIBCXX_NUM_ARGS 7
+ #define _GLIBCXX_COMMA ,
+ #define _GLIBCXX_TEMPLATE_PARAMS typename _T1, typename _T2, typename _T3, typename _T4, typename _T5, typename _T6, typename _T7
+ #define _GLIBCXX_TEMPLATE_ARGS _T1, _T2, _T3, _T4, _T5, _T6, _T7
+ #define _GLIBCXX_PARAMS _T1 __a1, _T2 __a2, _T3 __a3, _T4 __a4, _T5 __a5, _T6 __a6, _T7 __a7
+ #define _GLIBCXX_ARGS __a1, __a2, __a3, __a4, __a5, __a6, __a7
+ #define _GLIBCXX_COMMA_SHIFTED ,
+ #define _GLIBCXX_TEMPLATE_PARAMS_SHIFTED typename _T1, typename _T2, typename _T3, typename _T4, typename _T5, typename _T6
+ #define _GLIBCXX_TEMPLATE_ARGS_SHIFTED _T1, _T2, _T3, _T4, _T5, _T6
+ #define _GLIBCXX_PARAMS_SHIFTED _T1 __a1, _T2 __a2, _T3 __a3, _T4 __a4, _T5 __a5, _T6 __a6
+ #define _GLIBCXX_ARGS_SHIFTED __a1, __a2, __a3, __a4, __a5, __a6
+ #include <tr1/functional_iterate.h>
+ #undef _GLIBCXX_ARGS_SHIFTED
+ #undef _GLIBCXX_PARAMS_SHIFTED
+ #undef _GLIBCXX_TEMPLATE_ARGS_SHIFTED
+ #undef _GLIBCXX_TEMPLATE_PARAMS_SHIFTED
+ #undef _GLIBCXX_COMMA_SHIFTED
+ #undef _GLIBCXX_ARGS
+ #undef _GLIBCXX_PARAMS
+ #undef _GLIBCXX_TEMPLATE_ARGS
+ #undef _GLIBCXX_TEMPLATE_PARAMS
+ #undef _GLIBCXX_COMMA
+ #undef _GLIBCXX_NUM_ARGS
+ 
+ #define _GLIBCXX_NUM_ARGS 8
+ #define _GLIBCXX_COMMA ,
+ #define _GLIBCXX_TEMPLATE_PARAMS typename _T1, typename _T2, typename _T3, typename _T4, typename _T5, typename _T6, typename _T7, typename _T8
+ #define _GLIBCXX_TEMPLATE_ARGS _T1, _T2, _T3, _T4, _T5, _T6, _T7, _T8
+ #define _GLIBCXX_PARAMS _T1 __a1, _T2 __a2, _T3 __a3, _T4 __a4, _T5 __a5, _T6 __a6, _T7 __a7, _T8 __a8
+ #define _GLIBCXX_ARGS __a1, __a2, __a3, __a4, __a5, __a6, __a7, __a8
+ #define _GLIBCXX_COMMA_SHIFTED ,
+ #define _GLIBCXX_TEMPLATE_PARAMS_SHIFTED typename _T1, typename _T2, typename _T3, typename _T4, typename _T5, typename _T6, typename _T7
+ #define _GLIBCXX_TEMPLATE_ARGS_SHIFTED _T1, _T2, _T3, _T4, _T5, _T6, _T7
+ #define _GLIBCXX_PARAMS_SHIFTED _T1 __a1, _T2 __a2, _T3 __a3, _T4 __a4, _T5 __a5, _T6 __a6, _T7 __a7
+ #define _GLIBCXX_ARGS_SHIFTED __a1, __a2, __a3, __a4, __a5, __a6, __a7
+ #include <tr1/functional_iterate.h>
+ #undef _GLIBCXX_ARGS_SHIFTED
+ #undef _GLIBCXX_PARAMS_SHIFTED
+ #undef _GLIBCXX_TEMPLATE_ARGS_SHIFTED
+ #undef _GLIBCXX_TEMPLATE_PARAMS_SHIFTED
+ #undef _GLIBCXX_COMMA_SHIFTED
+ #undef _GLIBCXX_ARGS
+ #undef _GLIBCXX_PARAMS
+ #undef _GLIBCXX_TEMPLATE_ARGS
+ #undef _GLIBCXX_TEMPLATE_PARAMS
+ #undef _GLIBCXX_COMMA
+ #undef _GLIBCXX_NUM_ARGS
+ 
+ #define _GLIBCXX_NUM_ARGS 9
+ #define _GLIBCXX_COMMA ,
+ #define _GLIBCXX_TEMPLATE_PARAMS typename _T1, typename _T2, typename _T3, typename _T4, typename _T5, typename _T6, typename _T7, typename _T8, typename _T9
+ #define _GLIBCXX_TEMPLATE_ARGS _T1, _T2, _T3, _T4, _T5, _T6, _T7, _T8, _T9
+ #define _GLIBCXX_PARAMS _T1 __a1, _T2 __a2, _T3 __a3, _T4 __a4, _T5 __a5, _T6 __a6, _T7 __a7, _T8 __a8, _T9 __a9
+ #define _GLIBCXX_ARGS __a1, __a2, __a3, __a4, __a5, __a6, __a7, __a8, __a9
+ #define _GLIBCXX_COMMA_SHIFTED ,
+ #define _GLIBCXX_TEMPLATE_PARAMS_SHIFTED typename _T1, typename _T2, typename _T3, typename _T4, typename _T5, typename _T6, typename _T7, typename _T8
+ #define _GLIBCXX_TEMPLATE_ARGS_SHIFTED _T1, _T2, _T3, _T4, _T5, _T6, _T7, _T8
+ #define _GLIBCXX_PARAMS_SHIFTED _T1 __a1, _T2 __a2, _T3 __a3, _T4 __a4, _T5 __a5, _T6 __a6, _T7 __a7, _T8 __a8
+ #define _GLIBCXX_ARGS_SHIFTED __a1, __a2, __a3, __a4, __a5, __a6, __a7, __a8
+ #include <tr1/functional_iterate.h>
+ #undef _GLIBCXX_ARGS_SHIFTED
+ #undef _GLIBCXX_PARAMS_SHIFTED
+ #undef _GLIBCXX_TEMPLATE_ARGS_SHIFTED
+ #undef _GLIBCXX_TEMPLATE_PARAMS_SHIFTED
+ #undef _GLIBCXX_COMMA_SHIFTED
+ #undef _GLIBCXX_ARGS
+ #undef _GLIBCXX_PARAMS
+ #undef _GLIBCXX_TEMPLATE_ARGS
+ #undef _GLIBCXX_TEMPLATE_PARAMS
+ #undef _GLIBCXX_COMMA
+ #undef _GLIBCXX_NUM_ARGS
+ 
+ #define _GLIBCXX_NUM_ARGS 10
+ #define _GLIBCXX_COMMA ,
+ #define _GLIBCXX_TEMPLATE_PARAMS typename _T1, typename _T2, typename _T3, typename _T4, typename _T5, typename _T6, typename _T7, typename _T8, typename _T9, typename _T10
+ #define _GLIBCXX_TEMPLATE_ARGS _T1, _T2, _T3, _T4, _T5, _T6, _T7, _T8, _T9, _T10
+ #define _GLIBCXX_PARAMS _T1 __a1, _T2 __a2, _T3 __a3, _T4 __a4, _T5 __a5, _T6 __a6, _T7 __a7, _T8 __a8, _T9 __a9, _T10 __a10
+ #define _GLIBCXX_ARGS __a1, __a2, __a3, __a4, __a5, __a6, __a7, __a8, __a9, __a10
+ #define _GLIBCXX_COMMA_SHIFTED ,
+ #define _GLIBCXX_TEMPLATE_PARAMS_SHIFTED typename _T1, typename _T2, typename _T3, typename _T4, typename _T5, typename _T6, typename _T7, typename _T8, typename _T9
+ #define _GLIBCXX_TEMPLATE_ARGS_SHIFTED _T1, _T2, _T3, _T4, _T5, _T6, _T7, _T8, _T9
+ #define _GLIBCXX_PARAMS_SHIFTED _T1 __a1, _T2 __a2, _T3 __a3, _T4 __a4, _T5 __a5, _T6 __a6, _T7 __a7, _T8 __a8, _T9 __a9
+ #define _GLIBCXX_ARGS_SHIFTED __a1, __a2, __a3, __a4, __a5, __a6, __a7, __a8, __a9
+ #include <tr1/functional_iterate.h>
+ #undef _GLIBCXX_ARGS_SHIFTED
+ #undef _GLIBCXX_PARAMS_SHIFTED
+ #undef _GLIBCXX_TEMPLATE_ARGS_SHIFTED
+ #undef _GLIBCXX_TEMPLATE_PARAMS_SHIFTED
+ #undef _GLIBCXX_COMMA_SHIFTED
+ #undef _GLIBCXX_ARGS
+ #undef _GLIBCXX_PARAMS
+ #undef _GLIBCXX_TEMPLATE_ARGS
+ #undef _GLIBCXX_TEMPLATE_PARAMS
+ #undef _GLIBCXX_COMMA
+ #undef _GLIBCXX_NUM_ARGS
+ 
+ #define _GLIBCXX_NUM_ARGS 11
+ #define _GLIBCXX_COMMA ,
+ #define _GLIBCXX_TEMPLATE_PARAMS typename _T1, typename _T2, typename _T3, typename _T4, typename _T5, typename _T6, typename _T7, typename _T8, typename _T9, typename _T10, typename _T11
+ #define _GLIBCXX_TEMPLATE_ARGS _T1, _T2, _T3, _T4, _T5, _T6, _T7, _T8, _T9, _T10, _T11
+ #define _GLIBCXX_PARAMS _T1 __a1, _T2 __a2, _T3 __a3, _T4 __a4, _T5 __a5, _T6 __a6, _T7 __a7, _T8 __a8, _T9 __a9, _T10 __a10, _T11 __a11
+ #define _GLIBCXX_ARGS __a1, __a2, __a3, __a4, __a5, __a6, __a7, __a8, __a9, __a10, __a11
+ #define _GLIBCXX_COMMA_SHIFTED ,
+ #define _GLIBCXX_TEMPLATE_PARAMS_SHIFTED typename _T1, typename _T2, typename _T3, typename _T4, typename _T5, typename _T6, typename _T7, typename _T8, typename _T9, typename _T10
+ #define _GLIBCXX_TEMPLATE_ARGS_SHIFTED _T1, _T2, _T3, _T4, _T5, _T6, _T7, _T8, _T9, _T10
+ #define _GLIBCXX_PARAMS_SHIFTED _T1 __a1, _T2 __a2, _T3 __a3, _T4 __a4, _T5 __a5, _T6 __a6, _T7 __a7, _T8 __a8, _T9 __a9, _T10 __a10
+ #define _GLIBCXX_ARGS_SHIFTED __a1, __a2, __a3, __a4, __a5, __a6, __a7, __a8, __a9, __a10
+ #include <tr1/functional_iterate.h>
+ #undef _GLIBCXX_ARGS_SHIFTED
+ #undef _GLIBCXX_PARAMS_SHIFTED
+ #undef _GLIBCXX_TEMPLATE_ARGS_SHIFTED
+ #undef _GLIBCXX_TEMPLATE_PARAMS_SHIFTED
+ #undef _GLIBCXX_COMMA_SHIFTED
+ #undef _GLIBCXX_ARGS
+ #undef _GLIBCXX_PARAMS
+ #undef _GLIBCXX_TEMPLATE_ARGS
+ #undef _GLIBCXX_TEMPLATE_PARAMS
+ #undef _GLIBCXX_COMMA
+ #undef _GLIBCXX_NUM_ARGS
+ 
+ #define _GLIBCXX_NUM_ARGS 12
+ #define _GLIBCXX_COMMA ,
+ #define _GLIBCXX_TEMPLATE_PARAMS typename _T1, typename _T2, typename _T3, typename _T4, typename _T5, typename _T6, typename _T7, typename _T8, typename _T9, typename _T10, typename _T11, typename _T12
+ #define _GLIBCXX_TEMPLATE_ARGS _T1, _T2, _T3, _T4, _T5, _T6, _T7, _T8, _T9, _T10, _T11, _T12
+ #define _GLIBCXX_PARAMS _T1 __a1, _T2 __a2, _T3 __a3, _T4 __a4, _T5 __a5, _T6 __a6, _T7 __a7, _T8 __a8, _T9 __a9, _T10 __a10, _T11 __a11, _T12 __a12
+ #define _GLIBCXX_ARGS __a1, __a2, __a3, __a4, __a5, __a6, __a7, __a8, __a9, __a10, __a11, __a12
+ #define _GLIBCXX_COMMA_SHIFTED ,
+ #define _GLIBCXX_TEMPLATE_PARAMS_SHIFTED typename _T1, typename _T2, typename _T3, typename _T4, typename _T5, typename _T6, typename _T7, typename _T8, typename _T9, typename _T10, typename _T11
+ #define _GLIBCXX_TEMPLATE_ARGS_SHIFTED _T1, _T2, _T3, _T4, _T5, _T6, _T7, _T8, _T9, _T10, _T11
+ #define _GLIBCXX_PARAMS_SHIFTED _T1 __a1, _T2 __a2, _T3 __a3, _T4 __a4, _T5 __a5, _T6 __a6, _T7 __a7, _T8 __a8, _T9 __a9, _T10 __a10, _T11 __a11
+ #define _GLIBCXX_ARGS_SHIFTED __a1, __a2, __a3, __a4, __a5, __a6, __a7, __a8, __a9, __a10, __a11
+ #include <tr1/functional_iterate.h>
+ #undef _GLIBCXX_ARGS_SHIFTED
+ #undef _GLIBCXX_PARAMS_SHIFTED
+ #undef _GLIBCXX_TEMPLATE_ARGS_SHIFTED
+ #undef _GLIBCXX_TEMPLATE_PARAMS_SHIFTED
+ #undef _GLIBCXX_COMMA_SHIFTED
+ #undef _GLIBCXX_ARGS
+ #undef _GLIBCXX_PARAMS
+ #undef _GLIBCXX_TEMPLATE_ARGS
+ #undef _GLIBCXX_TEMPLATE_PARAMS
+ #undef _GLIBCXX_COMMA
+ #undef _GLIBCXX_NUM_ARGS
+ 
+ #define _GLIBCXX_NUM_ARGS 13
+ #define _GLIBCXX_COMMA ,
+ #define _GLIBCXX_TEMPLATE_PARAMS typename _T1, typename _T2, typename _T3, typename _T4, typename _T5, typename _T6, typename _T7, typename _T8, typename _T9, typename _T10, typename _T11, typename _T12, typename _T13
+ #define _GLIBCXX_TEMPLATE_ARGS _T1, _T2, _T3, _T4, _T5, _T6, _T7, _T8, _T9, _T10, _T11, _T12, _T13
+ #define _GLIBCXX_PARAMS _T1 __a1, _T2 __a2, _T3 __a3, _T4 __a4, _T5 __a5, _T6 __a6, _T7 __a7, _T8 __a8, _T9 __a9, _T10 __a10, _T11 __a11, _T12 __a12, _T13 __a13
+ #define _GLIBCXX_ARGS __a1, __a2, __a3, __a4, __a5, __a6, __a7, __a8, __a9, __a10, __a11, __a12, __a13
+ #define _GLIBCXX_COMMA_SHIFTED ,
+ #define _GLIBCXX_TEMPLATE_PARAMS_SHIFTED typename _T1, typename _T2, typename _T3, typename _T4, typename _T5, typename _T6, typename _T7, typename _T8, typename _T9, typename _T10, typename _T11, typename _T12
+ #define _GLIBCXX_TEMPLATE_ARGS_SHIFTED _T1, _T2, _T3, _T4, _T5, _T6, _T7, _T8, _T9, _T10, _T11, _T12
+ #define _GLIBCXX_PARAMS_SHIFTED _T1 __a1, _T2 __a2, _T3 __a3, _T4 __a4, _T5 __a5, _T6 __a6, _T7 __a7, _T8 __a8, _T9 __a9, _T10 __a10, _T11 __a11, _T12 __a12
+ #define _GLIBCXX_ARGS_SHIFTED __a1, __a2, __a3, __a4, __a5, __a6, __a7, __a8, __a9, __a10, __a11, __a12
+ #include <tr1/functional_iterate.h>
+ #undef _GLIBCXX_ARGS_SHIFTED
+ #undef _GLIBCXX_PARAMS_SHIFTED
+ #undef _GLIBCXX_TEMPLATE_ARGS_SHIFTED
+ #undef _GLIBCXX_TEMPLATE_PARAMS_SHIFTED
+ #undef _GLIBCXX_COMMA_SHIFTED
+ #undef _GLIBCXX_ARGS
+ #undef _GLIBCXX_PARAMS
+ #undef _GLIBCXX_TEMPLATE_ARGS
+ #undef _GLIBCXX_TEMPLATE_PARAMS
+ #undef _GLIBCXX_COMMA
+ #undef _GLIBCXX_NUM_ARGS
+ 
+ #define _GLIBCXX_NUM_ARGS 14
+ #define _GLIBCXX_COMMA ,
+ #define _GLIBCXX_TEMPLATE_PARAMS typename _T1, typename _T2, typename _T3, typename _T4, typename _T5, typename _T6, typename _T7, typename _T8, typename _T9, typename _T10, typename _T11, typename _T12, typename _T13, typename _T14
+ #define _GLIBCXX_TEMPLATE_ARGS _T1, _T2, _T3, _T4, _T5, _T6, _T7, _T8, _T9, _T10, _T11, _T12, _T13, _T14
+ #define _GLIBCXX_PARAMS _T1 __a1, _T2 __a2, _T3 __a3, _T4 __a4, _T5 __a5, _T6 __a6, _T7 __a7, _T8 __a8, _T9 __a9, _T10 __a10, _T11 __a11, _T12 __a12, _T13 __a13, _T14 __a14
+ #define _GLIBCXX_ARGS __a1, __a2, __a3, __a4, __a5, __a6, __a7, __a8, __a9, __a10, __a11, __a12, __a13, __a14
+ #define _GLIBCXX_COMMA_SHIFTED ,
+ #define _GLIBCXX_TEMPLATE_PARAMS_SHIFTED typename _T1, typename _T2, typename _T3, typename _T4, typename _T5, typename _T6, typename _T7, typename _T8, typename _T9, typename _T10, typename _T11, typename _T12, typename _T13
+ #define _GLIBCXX_TEMPLATE_ARGS_SHIFTED _T1, _T2, _T3, _T4, _T5, _T6, _T7, _T8, _T9, _T10, _T11, _T12, _T13
+ #define _GLIBCXX_PARAMS_SHIFTED _T1 __a1, _T2 __a2, _T3 __a3, _T4 __a4, _T5 __a5, _T6 __a6, _T7 __a7, _T8 __a8, _T9 __a9, _T10 __a10, _T11 __a11, _T12 __a12, _T13 __a13
+ #define _GLIBCXX_ARGS_SHIFTED __a1, __a2, __a3, __a4, __a5, __a6, __a7, __a8, __a9, __a10, __a11, __a12, __a13
+ #include <tr1/functional_iterate.h>
+ #undef _GLIBCXX_ARGS_SHIFTED
+ #undef _GLIBCXX_PARAMS_SHIFTED
+ #undef _GLIBCXX_TEMPLATE_ARGS_SHIFTED
+ #undef _GLIBCXX_TEMPLATE_PARAMS_SHIFTED
+ #undef _GLIBCXX_COMMA_SHIFTED
+ #undef _GLIBCXX_ARGS
+ #undef _GLIBCXX_PARAMS
+ #undef _GLIBCXX_TEMPLATE_ARGS
+ #undef _GLIBCXX_TEMPLATE_PARAMS
+ #undef _GLIBCXX_COMMA
+ #undef _GLIBCXX_NUM_ARGS
+ 
+ #define _GLIBCXX_NUM_ARGS 15
+ #define _GLIBCXX_COMMA ,
+ #define _GLIBCXX_TEMPLATE_PARAMS typename _T1, typename _T2, typename _T3, typename _T4, typename _T5, typename _T6, typename _T7, typename _T8, typename _T9, typename _T10, typename _T11, typename _T12, typename _T13, typename _T14, typename _T15
+ #define _GLIBCXX_TEMPLATE_ARGS _T1, _T2, _T3, _T4, _T5, _T6, _T7, _T8, _T9, _T10, _T11, _T12, _T13, _T14, _T15
+ #define _GLIBCXX_PARAMS _T1 __a1, _T2 __a2, _T3 __a3, _T4 __a4, _T5 __a5, _T6 __a6, _T7 __a7, _T8 __a8, _T9 __a9, _T10 __a10, _T11 __a11, _T12 __a12, _T13 __a13, _T14 __a14, _T15 __a15
+ #define _GLIBCXX_ARGS __a1, __a2, __a3, __a4, __a5, __a6, __a7, __a8, __a9, __a10, __a11, __a12, __a13, __a14, __a15
+ #define _GLIBCXX_COMMA_SHIFTED ,
+ #define _GLIBCXX_TEMPLATE_PARAMS_SHIFTED typename _T1, typename _T2, typename _T3, typename _T4, typename _T5, typename _T6, typename _T7, typename _T8, typename _T9, typename _T10, typename _T11, typename _T12, typename _T13, typename _T14
+ #define _GLIBCXX_TEMPLATE_ARGS_SHIFTED _T1, _T2, _T3, _T4, _T5, _T6, _T7, _T8, _T9, _T10, _T11, _T12, _T13, _T14
+ #define _GLIBCXX_PARAMS_SHIFTED _T1 __a1, _T2 __a2, _T3 __a3, _T4 __a4, _T5 __a5, _T6 __a6, _T7 __a7, _T8 __a8, _T9 __a9, _T10 __a10, _T11 __a11, _T12 __a12, _T13 __a13, _T14 __a14
+ #define _GLIBCXX_ARGS_SHIFTED __a1, __a2, __a3, __a4, __a5, __a6, __a7, __a8, __a9, __a10, __a11, __a12, __a13, __a14
+ #include <tr1/functional_iterate.h>
+ #undef _GLIBCXX_ARGS_SHIFTED
+ #undef _GLIBCXX_PARAMS_SHIFTED
+ #undef _GLIBCXX_TEMPLATE_ARGS_SHIFTED
+ #undef _GLIBCXX_TEMPLATE_PARAMS_SHIFTED
+ #undef _GLIBCXX_COMMA_SHIFTED
+ #undef _GLIBCXX_ARGS
+ #undef _GLIBCXX_PARAMS
+ #undef _GLIBCXX_TEMPLATE_ARGS
+ #undef _GLIBCXX_TEMPLATE_PARAMS
+ #undef _GLIBCXX_COMMA
+ #undef _GLIBCXX_NUM_ARGS
+ 
+ #define _GLIBCXX_NUM_ARGS 16
+ #define _GLIBCXX_COMMA ,
+ #define _GLIBCXX_TEMPLATE_PARAMS typename _T1, typename _T2, typename _T3, typename _T4, typename _T5, typename _T6, typename _T7, typename _T8, typename _T9, typename _T10, typename _T11, typename _T12, typename _T13, typename _T14, typename _T15, typename _T16
+ #define _GLIBCXX_TEMPLATE_ARGS _T1, _T2, _T3, _T4, _T5, _T6, _T7, _T8, _T9, _T10, _T11, _T12, _T13, _T14, _T15, _T16
+ #define _GLIBCXX_PARAMS _T1 __a1, _T2 __a2, _T3 __a3, _T4 __a4, _T5 __a5, _T6 __a6, _T7 __a7, _T8 __a8, _T9 __a9, _T10 __a10, _T11 __a11, _T12 __a12, _T13 __a13, _T14 __a14, _T15 __a15, _T16 __a16
+ #define _GLIBCXX_ARGS __a1, __a2, __a3, __a4, __a5, __a6, __a7, __a8, __a9, __a10, __a11, __a12, __a13, __a14, __a15, __a16
+ #define _GLIBCXX_COMMA_SHIFTED ,
+ #define _GLIBCXX_TEMPLATE_PARAMS_SHIFTED typename _T1, typename _T2, typename _T3, typename _T4, typename _T5, typename _T6, typename _T7, typename _T8, typename _T9, typename _T10, typename _T11, typename _T12, typename _T13, typename _T14, typename _T15
+ #define _GLIBCXX_TEMPLATE_ARGS_SHIFTED _T1, _T2, _T3, _T4, _T5, _T6, _T7, _T8, _T9, _T10, _T11, _T12, _T13, _T14, _T15
+ #define _GLIBCXX_PARAMS_SHIFTED _T1 __a1, _T2 __a2, _T3 __a3, _T4 __a4, _T5 __a5, _T6 __a6, _T7 __a7, _T8 __a8, _T9 __a9, _T10 __a10, _T11 __a11, _T12 __a12, _T13 __a13, _T14 __a14, _T15 __a15
+ #define _GLIBCXX_ARGS_SHIFTED __a1, __a2, __a3, __a4, __a5, __a6, __a7, __a8, __a9, __a10, __a11, __a12, __a13, __a14, __a15
+ #include <tr1/functional_iterate.h>
+ #undef _GLIBCXX_ARGS_SHIFTED
+ #undef _GLIBCXX_PARAMS_SHIFTED
+ #undef _GLIBCXX_TEMPLATE_ARGS_SHIFTED
+ #undef _GLIBCXX_TEMPLATE_PARAMS_SHIFTED
+ #undef _GLIBCXX_COMMA_SHIFTED
+ #undef _GLIBCXX_ARGS
+ #undef _GLIBCXX_PARAMS
+ #undef _GLIBCXX_TEMPLATE_ARGS
+ #undef _GLIBCXX_TEMPLATE_PARAMS
+ #undef _GLIBCXX_COMMA
+ #undef _GLIBCXX_NUM_ARGS
+ 
+ #define _GLIBCXX_NUM_ARGS 17
+ #define _GLIBCXX_COMMA ,
+ #define _GLIBCXX_TEMPLATE_PARAMS typename _T1, typename _T2, typename _T3, typename _T4, typename _T5, typename _T6, typename _T7, typename _T8, typename _T9, typename _T10, typename _T11, typename _T12, typename _T13, typename _T14, typename _T15, typename _T16, typename _T17
+ #define _GLIBCXX_TEMPLATE_ARGS _T1, _T2, _T3, _T4, _T5, _T6, _T7, _T8, _T9, _T10, _T11, _T12, _T13, _T14, _T15, _T16, _T17
+ #define _GLIBCXX_PARAMS _T1 __a1, _T2 __a2, _T3 __a3, _T4 __a4, _T5 __a5, _T6 __a6, _T7 __a7, _T8 __a8, _T9 __a9, _T10 __a10, _T11 __a11, _T12 __a12, _T13 __a13, _T14 __a14, _T15 __a15, _T16 __a16, _T17 __a17
+ #define _GLIBCXX_ARGS __a1, __a2, __a3, __a4, __a5, __a6, __a7, __a8, __a9, __a10, __a11, __a12, __a13, __a14, __a15, __a16, __a17
+ #define _GLIBCXX_COMMA_SHIFTED ,
+ #define _GLIBCXX_TEMPLATE_PARAMS_SHIFTED typename _T1, typename _T2, typename _T3, typename _T4, typename _T5, typename _T6, typename _T7, typename _T8, typename _T9, typename _T10, typename _T11, typename _T12, typename _T13, typename _T14, typename _T15, typename _T16
+ #define _GLIBCXX_TEMPLATE_ARGS_SHIFTED _T1, _T2, _T3, _T4, _T5, _T6, _T7, _T8, _T9, _T10, _T11, _T12, _T13, _T14, _T15, _T16
+ #define _GLIBCXX_PARAMS_SHIFTED _T1 __a1, _T2 __a2, _T3 __a3, _T4 __a4, _T5 __a5, _T6 __a6, _T7 __a7, _T8 __a8, _T9 __a9, _T10 __a10, _T11 __a11, _T12 __a12, _T13 __a13, _T14 __a14, _T15 __a15, _T16 __a16
+ #define _GLIBCXX_ARGS_SHIFTED __a1, __a2, __a3, __a4, __a5, __a6, __a7, __a8, __a9, __a10, __a11, __a12, __a13, __a14, __a15, __a16
+ #include <tr1/functional_iterate.h>
+ #undef _GLIBCXX_ARGS_SHIFTED
+ #undef _GLIBCXX_PARAMS_SHIFTED
+ #undef _GLIBCXX_TEMPLATE_ARGS_SHIFTED
+ #undef _GLIBCXX_TEMPLATE_PARAMS_SHIFTED
+ #undef _GLIBCXX_COMMA_SHIFTED
+ #undef _GLIBCXX_ARGS
+ #undef _GLIBCXX_PARAMS
+ #undef _GLIBCXX_TEMPLATE_ARGS
+ #undef _GLIBCXX_TEMPLATE_PARAMS
+ #undef _GLIBCXX_COMMA
+ #undef _GLIBCXX_NUM_ARGS
+ 
+ #define _GLIBCXX_NUM_ARGS 18
+ #define _GLIBCXX_COMMA ,
+ #define _GLIBCXX_TEMPLATE_PARAMS typename _T1, typename _T2, typename _T3, typename _T4, typename _T5, typename _T6, typename _T7, typename _T8, typename _T9, typename _T10, typename _T11, typename _T12, typename _T13, typename _T14, typename _T15, typename _T16, typename _T17, typename _T18
+ #define _GLIBCXX_TEMPLATE_ARGS _T1, _T2, _T3, _T4, _T5, _T6, _T7, _T8, _T9, _T10, _T11, _T12, _T13, _T14, _T15, _T16, _T17, _T18
+ #define _GLIBCXX_PARAMS _T1 __a1, _T2 __a2, _T3 __a3, _T4 __a4, _T5 __a5, _T6 __a6, _T7 __a7, _T8 __a8, _T9 __a9, _T10 __a10, _T11 __a11, _T12 __a12, _T13 __a13, _T14 __a14, _T15 __a15, _T16 __a16, _T17 __a17, _T18 __a18
+ #define _GLIBCXX_ARGS __a1, __a2, __a3, __a4, __a5, __a6, __a7, __a8, __a9, __a10, __a11, __a12, __a13, __a14, __a15, __a16, __a17, __a18
+ #define _GLIBCXX_COMMA_SHIFTED ,
+ #define _GLIBCXX_TEMPLATE_PARAMS_SHIFTED typename _T1, typename _T2, typename _T3, typename _T4, typename _T5, typename _T6, typename _T7, typename _T8, typename _T9, typename _T10, typename _T11, typename _T12, typename _T13, typename _T14, typename _T15, typename _T16, typename _T17
+ #define _GLIBCXX_TEMPLATE_ARGS_SHIFTED _T1, _T2, _T3, _T4, _T5, _T6, _T7, _T8, _T9, _T10, _T11, _T12, _T13, _T14, _T15, _T16, _T17
+ #define _GLIBCXX_PARAMS_SHIFTED _T1 __a1, _T2 __a2, _T3 __a3, _T4 __a4, _T5 __a5, _T6 __a6, _T7 __a7, _T8 __a8, _T9 __a9, _T10 __a10, _T11 __a11, _T12 __a12, _T13 __a13, _T14 __a14, _T15 __a15, _T16 __a16, _T17 __a17
+ #define _GLIBCXX_ARGS_SHIFTED __a1, __a2, __a3, __a4, __a5, __a6, __a7, __a8, __a9, __a10, __a11, __a12, __a13, __a14, __a15, __a16, __a17
+ #include <tr1/functional_iterate.h>
+ #undef _GLIBCXX_ARGS_SHIFTED
+ #undef _GLIBCXX_PARAMS_SHIFTED
+ #undef _GLIBCXX_TEMPLATE_ARGS_SHIFTED
+ #undef _GLIBCXX_TEMPLATE_PARAMS_SHIFTED
+ #undef _GLIBCXX_COMMA_SHIFTED
+ #undef _GLIBCXX_ARGS
+ #undef _GLIBCXX_PARAMS
+ #undef _GLIBCXX_TEMPLATE_ARGS
+ #undef _GLIBCXX_TEMPLATE_PARAMS
+ #undef _GLIBCXX_COMMA
+ #undef _GLIBCXX_NUM_ARGS
+ 
+ #define _GLIBCXX_NUM_ARGS 19
+ #define _GLIBCXX_COMMA ,
+ #define _GLIBCXX_TEMPLATE_PARAMS typename _T1, typename _T2, typename _T3, typename _T4, typename _T5, typename _T6, typename _T7, typename _T8, typename _T9, typename _T10, typename _T11, typename _T12, typename _T13, typename _T14, typename _T15, typename _T16, typename _T17, typename _T18, typename _T19
+ #define _GLIBCXX_TEMPLATE_ARGS _T1, _T2, _T3, _T4, _T5, _T6, _T7, _T8, _T9, _T10, _T11, _T12, _T13, _T14, _T15, _T16, _T17, _T18, _T19
+ #define _GLIBCXX_PARAMS _T1 __a1, _T2 __a2, _T3 __a3, _T4 __a4, _T5 __a5, _T6 __a6, _T7 __a7, _T8 __a8, _T9 __a9, _T10 __a10, _T11 __a11, _T12 __a12, _T13 __a13, _T14 __a14, _T15 __a15, _T16 __a16, _T17 __a17, _T18 __a18, _T19 __a19
+ #define _GLIBCXX_ARGS __a1, __a2, __a3, __a4, __a5, __a6, __a7, __a8, __a9, __a10, __a11, __a12, __a13, __a14, __a15, __a16, __a17, __a18, __a19
+ #define _GLIBCXX_COMMA_SHIFTED ,
+ #define _GLIBCXX_TEMPLATE_PARAMS_SHIFTED typename _T1, typename _T2, typename _T3, typename _T4, typename _T5, typename _T6, typename _T7, typename _T8, typename _T9, typename _T10, typename _T11, typename _T12, typename _T13, typename _T14, typename _T15, typename _T16, typename _T17, typename _T18
+ #define _GLIBCXX_TEMPLATE_ARGS_SHIFTED _T1, _T2, _T3, _T4, _T5, _T6, _T7, _T8, _T9, _T10, _T11, _T12, _T13, _T14, _T15, _T16, _T17, _T18
+ #define _GLIBCXX_PARAMS_SHIFTED _T1 __a1, _T2 __a2, _T3 __a3, _T4 __a4, _T5 __a5, _T6 __a6, _T7 __a7, _T8 __a8, _T9 __a9, _T10 __a10, _T11 __a11, _T12 __a12, _T13 __a13, _T14 __a14, _T15 __a15, _T16 __a16, _T17 __a17, _T18 __a18
+ #define _GLIBCXX_ARGS_SHIFTED __a1, __a2, __a3, __a4, __a5, __a6, __a7, __a8, __a9, __a10, __a11, __a12, __a13, __a14, __a15, __a16, __a17, __a18
+ #include <tr1/functional_iterate.h>
+ #undef _GLIBCXX_ARGS_SHIFTED
+ #undef _GLIBCXX_PARAMS_SHIFTED
+ #undef _GLIBCXX_TEMPLATE_ARGS_SHIFTED
+ #undef _GLIBCXX_TEMPLATE_PARAMS_SHIFTED
+ #undef _GLIBCXX_COMMA_SHIFTED
+ #undef _GLIBCXX_ARGS
+ #undef _GLIBCXX_PARAMS
+ #undef _GLIBCXX_TEMPLATE_ARGS
+ #undef _GLIBCXX_TEMPLATE_PARAMS
+ #undef _GLIBCXX_COMMA
+ #undef _GLIBCXX_NUM_ARGS
+ 
+ #define _GLIBCXX_NUM_ARGS 20
+ #define _GLIBCXX_COMMA ,
+ #define _GLIBCXX_TEMPLATE_PARAMS typename _T1, typename _T2, typename _T3, typename _T4, typename _T5, typename _T6, typename _T7, typename _T8, typename _T9, typename _T10, typename _T11, typename _T12, typename _T13, typename _T14, typename _T15, typename _T16, typename _T17, typename _T18, typename _T19, typename _T20
+ #define _GLIBCXX_TEMPLATE_ARGS _T1, _T2, _T3, _T4, _T5, _T6, _T7, _T8, _T9, _T10, _T11, _T12, _T13, _T14, _T15, _T16, _T17, _T18, _T19, _T20
+ #define _GLIBCXX_PARAMS _T1 __a1, _T2 __a2, _T3 __a3, _T4 __a4, _T5 __a5, _T6 __a6, _T7 __a7, _T8 __a8, _T9 __a9, _T10 __a10, _T11 __a11, _T12 __a12, _T13 __a13, _T14 __a14, _T15 __a15, _T16 __a16, _T17 __a17, _T18 __a18, _T19 __a19, _T20 __a20
+ #define _GLIBCXX_ARGS __a1, __a2, __a3, __a4, __a5, __a6, __a7, __a8, __a9, __a10, __a11, __a12, __a13, __a14, __a15, __a16, __a17, __a18, __a19, __a20
+ #define _GLIBCXX_COMMA_SHIFTED ,
+ #define _GLIBCXX_TEMPLATE_PARAMS_SHIFTED typename _T1, typename _T2, typename _T3, typename _T4, typename _T5, typename _T6, typename _T7, typename _T8, typename _T9, typename _T10, typename _T11, typename _T12, typename _T13, typename _T14, typename _T15, typename _T16, typename _T17, typename _T18, typename _T19
+ #define _GLIBCXX_TEMPLATE_ARGS_SHIFTED _T1, _T2, _T3, _T4, _T5, _T6, _T7, _T8, _T9, _T10, _T11, _T12, _T13, _T14, _T15, _T16, _T17, _T18, _T19
+ #define _GLIBCXX_PARAMS_SHIFTED _T1 __a1, _T2 __a2, _T3 __a3, _T4 __a4, _T5 __a5, _T6 __a6, _T7 __a7, _T8 __a8, _T9 __a9, _T10 __a10, _T11 __a11, _T12 __a12, _T13 __a13, _T14 __a14, _T15 __a15, _T16 __a16, _T17 __a17, _T18 __a18, _T19 __a19
+ #define _GLIBCXX_ARGS_SHIFTED __a1, __a2, __a3, __a4, __a5, __a6, __a7, __a8, __a9, __a10, __a11, __a12, __a13, __a14, __a15, __a16, __a17, __a18, __a19
+ #include <tr1/functional_iterate.h>
+ #undef _GLIBCXX_ARGS_SHIFTED
+ #undef _GLIBCXX_PARAMS_SHIFTED
+ #undef _GLIBCXX_TEMPLATE_ARGS_SHIFTED
+ #undef _GLIBCXX_TEMPLATE_PARAMS_SHIFTED
+ #undef _GLIBCXX_COMMA_SHIFTED
+ #undef _GLIBCXX_ARGS
+ #undef _GLIBCXX_PARAMS
+ #undef _GLIBCXX_TEMPLATE_ARGS
+ #undef _GLIBCXX_TEMPLATE_PARAMS
+ #undef _GLIBCXX_COMMA
+ #undef _GLIBCXX_NUM_ARGS
+ 
+   // [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<typename _Signature>
+     inline bool
+     operator==(const function<_Signature>& __f, _M_clear_type*)
+     {
+       return !__f;
+     }
+ 
+   /**
+    *  @overload
+    */
+   template<typename _Signature>
+     inline bool
+     operator==(_M_clear_type*, const function<_Signature>& __f)
+     {
+       return !__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<typename _Signature>
+     inline bool
+     operator!=(const function<_Signature>& __f, _M_clear_type*)
+     {
+       return __f;
+     }
+ 
+   /**
+    *  @overload
+    */
+   template<typename _Signature>
+     inline bool
+     operator!=(_M_clear_type*, const function<_Signature>& __f)
+     {
+       return __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<typename _Signature>
+     inline void
+     swap(function<_Signature>& __x, function<_Signature>& __y)
+     {
+       __x.swap(__y);
+     }
+ 
  
  // Definition of default hash function std::tr1::hash<>.  The types for
  // which std::tr1::hash<T> is defined is in clause 6.3.3. of the PDTR.
Index: include/tr1/functional_iterate.h
===================================================================
RCS file: include/tr1/functional_iterate.h
diff -N include/tr1/functional_iterate.h
*** /dev/null	1 Jan 1970 00:00:00 -0000
--- include/tr1/functional_iterate.h	23 Feb 2005 00:29:46 -0000
***************
*** 0 ****
--- 1,700 ----
+ // TR1 functional -*- C++ -*-
+ 
+ // Copyright (C) 2005 Free Software Foundation, Inc.
+ // Writtten by Douglas Gregor <dgregor@cs.indiana.edu>
+ //
+ // 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 2, 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.
+ 
+ // You should have received a copy of the GNU General Public License along
+ // with this library; see the file COPYING.  If not, write to the Free
+ // Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ // USA.
+ 
+ // As a special exception, you may use this file as part of a free software
+ // library without restriction.  Specifically, if other files instantiate
+ // templates or use macros or inline functions from this file, or you compile
+ // this file and link it with other files to produce an executable, this
+ // file does not by itself cause the resulting executable to be covered by
+ // the GNU General Public License.  This exception does not however
+ // invalidate any other reasons why the executable file might be covered by
+ // the GNU General Public License.
+ 
+ /** @file function_iterate.h
+  *  This is an internal header file, included by other library headers.
+  *  You should not attempt to use it directly.
+  */
+ 
+ #if _GLIBCXX_NUM_ARGS > 0
+ template<typename _Res, typename _Class _GLIBCXX_COMMA_SHIFTED
+          _GLIBCXX_TEMPLATE_PARAMS_SHIFTED>
+   class _Mem_fn<_Res (_Class::*)(_GLIBCXX_TEMPLATE_ARGS_SHIFTED)>
+ #if _GLIBCXX_NUM_ARGS == 1
+   : public unary_function<_Class*, _Res>
+ #elif _GLIBCXX_NUM_ARGS == 2
+     : public binary_function<_Class*, _T1, _Res>
+ #endif
+   {
+     typedef _Res (_Class::*_Functor)(_GLIBCXX_TEMPLATE_ARGS_SHIFTED);
+ 
+     template<typename _Tp>
+       _Res
+       _M_call(_Tp& __object, const volatile _Class * _GLIBCXX_COMMA_SHIFTED
+               _GLIBCXX_PARAMS_SHIFTED) const
+       { return (__object.*__pmf)(_GLIBCXX_ARGS_SHIFTED); }
+ 
+     template<typename _Tp>
+       _Res
+       _M_call(_Tp& __ptr, const volatile void * _GLIBCXX_COMMA_SHIFTED
+               _GLIBCXX_PARAMS_SHIFTED) const
+       {  return ((*__ptr).*__pmf)(_GLIBCXX_ARGS_SHIFTED); }
+ 
+   public:
+     typedef _Res result_type;
+ 
+     explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { }
+ 
+     // Handle objects
+     _Res
+     operator()(_Class& __object _GLIBCXX_COMMA_SHIFTED
+                _GLIBCXX_PARAMS_SHIFTED) const
+     { return (__object.*__pmf)(_GLIBCXX_ARGS_SHIFTED); }
+ 
+     // Handle pointers
+     _Res
+     operator()(_Class* __object _GLIBCXX_COMMA_SHIFTED
+                _GLIBCXX_PARAMS_SHIFTED) const
+     { return (__object->*__pmf)(_GLIBCXX_ARGS_SHIFTED); }
+ 
+     // Handle smart pointers, references and pointers to derived
+     template<typename _Tp>
+       _Res
+       operator()(_Tp& __object _GLIBCXX_COMMA_SHIFTED
+                  _GLIBCXX_PARAMS_SHIFTED) const
+       {
+         return _M_call(__object, &__object _GLIBCXX_COMMA_SHIFTED
+                        _GLIBCXX_ARGS_SHIFTED);
+       }
+ 
+   private:
+     _Functor __pmf;
+   };
+ 
+ template<typename _Res, typename _Class _GLIBCXX_COMMA_SHIFTED
+          _GLIBCXX_TEMPLATE_PARAMS_SHIFTED>
+   class _Mem_fn<_Res (_Class::*)(_GLIBCXX_TEMPLATE_ARGS_SHIFTED) const>
+ #if _GLIBCXX_NUM_ARGS == 1
+   : public unary_function<const _Class*, _Res>
+ #elif _GLIBCXX_NUM_ARGS == 2
+     : public binary_function<const _Class*, _T1, _Res>
+ #endif
+   {
+     typedef _Res (_Class::*_Functor)(_GLIBCXX_TEMPLATE_ARGS_SHIFTED) const;
+ 
+      template<typename _Tp>
+       _Res
+       _M_call(_Tp& __object, const volatile _Class * _GLIBCXX_COMMA_SHIFTED
+               _GLIBCXX_PARAMS_SHIFTED) const
+       { return (__object.*__pmf)(_GLIBCXX_ARGS_SHIFTED); }
+ 
+     template<typename _Tp>
+       _Res
+       _M_call(_Tp& __ptr, const volatile void * _GLIBCXX_COMMA_SHIFTED
+               _GLIBCXX_PARAMS_SHIFTED) const
+       {  return ((*__ptr).*__pmf)(_GLIBCXX_ARGS_SHIFTED); }
+ 
+   public:
+     typedef _Res result_type;
+ 
+     explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { }
+ 
+     // Handle objects
+     _Res
+     operator()(const _Class& __object _GLIBCXX_COMMA_SHIFTED
+                _GLIBCXX_PARAMS_SHIFTED) const
+     { return (__object.*__pmf)(_GLIBCXX_ARGS_SHIFTED); }
+ 
+     // Handle pointers
+     _Res
+     operator()(const _Class* __object _GLIBCXX_COMMA_SHIFTED
+                _GLIBCXX_PARAMS_SHIFTED) const
+     { return (__object->*__pmf)(_GLIBCXX_ARGS_SHIFTED); }
+ 
+     // Handle smart pointers, references and pointers to derived
+     template<typename _Tp>
+       _Res
+       operator()(_Tp& __object _GLIBCXX_COMMA_SHIFTED
+                  _GLIBCXX_PARAMS_SHIFTED) const
+       {
+         return _M_call(__object, &__object _GLIBCXX_COMMA_SHIFTED
+                        _GLIBCXX_ARGS_SHIFTED);
+       }
+ 
+   private:
+     _Functor __pmf;
+   };
+ 
+ template<typename _Res, typename _Class _GLIBCXX_COMMA_SHIFTED
+          _GLIBCXX_TEMPLATE_PARAMS_SHIFTED>
+   class _Mem_fn<_Res (_Class::*)(_GLIBCXX_TEMPLATE_ARGS_SHIFTED) volatile>
+ #if _GLIBCXX_NUM_ARGS == 1
+   : public unary_function<volatile _Class*, _Res>
+ #elif _GLIBCXX_NUM_ARGS == 2
+     : public binary_function<volatile _Class*, _T1, _Res>
+ #endif
+   {
+     typedef _Res (_Class::*_Functor)(_GLIBCXX_TEMPLATE_ARGS_SHIFTED) volatile;
+ 
+     template<typename _Tp>
+       _Res
+       _M_call(_Tp& __object, const volatile _Class * _GLIBCXX_COMMA_SHIFTED
+               _GLIBCXX_PARAMS_SHIFTED) const
+       { return (__object.*__pmf)(_GLIBCXX_ARGS_SHIFTED); }
+ 
+     template<typename _Tp>
+       _Res
+       _M_call(_Tp& __ptr, const volatile void * _GLIBCXX_COMMA_SHIFTED
+               _GLIBCXX_PARAMS_SHIFTED) const
+       {  return ((*__ptr).*__pmf)(_GLIBCXX_ARGS_SHIFTED); }
+ 
+   public:
+     typedef _Res result_type;
+ 
+     explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { }
+ 
+     // Handle objects
+     _Res
+     operator()(volatile _Class& __object _GLIBCXX_COMMA_SHIFTED
+                _GLIBCXX_PARAMS_SHIFTED) const
+     { return (__object.*__pmf)(_GLIBCXX_ARGS_SHIFTED); }
+ 
+     // Handle pointers
+     _Res
+     operator()(volatile _Class* __object _GLIBCXX_COMMA_SHIFTED
+                _GLIBCXX_PARAMS_SHIFTED) const
+     { return (__object->*__pmf)(_GLIBCXX_ARGS_SHIFTED); }
+ 
+     // Handle smart pointers, references and pointers to derived
+     template<typename _Tp>
+       _Res
+       operator()(_Tp& __object _GLIBCXX_COMMA_SHIFTED
+                  _GLIBCXX_PARAMS_SHIFTED) const
+       {
+         return _M_call(__object, &__object _GLIBCXX_COMMA_SHIFTED
+                        _GLIBCXX_ARGS_SHIFTED);
+       }
+   private:
+     _Functor __pmf;
+   };
+ 
+ template<typename _Res, typename _Class _GLIBCXX_COMMA_SHIFTED
+          _GLIBCXX_TEMPLATE_PARAMS_SHIFTED>
+   class _Mem_fn<_Res (_Class::*)(_GLIBCXX_TEMPLATE_ARGS_SHIFTED) const volatile>
+ #if _GLIBCXX_NUM_ARGS == 1
+   : public unary_function<const volatile _Class*, _Res>
+ #elif _GLIBCXX_NUM_ARGS == 2
+     : public binary_function<const volatile _Class*, _T1, _Res>
+ #endif
+   {
+     typedef _Res (_Class::*_Functor)(_GLIBCXX_TEMPLATE_ARGS_SHIFTED)
+               const volatile;
+ 
+     template<typename _Tp>
+       _Res
+       _M_call(_Tp& __object, const volatile _Class * _GLIBCXX_COMMA_SHIFTED
+               _GLIBCXX_PARAMS_SHIFTED) const
+       { return (__object.*__pmf)(_GLIBCXX_ARGS_SHIFTED); }
+ 
+     template<typename _Tp>
+       _Res
+       _M_call(_Tp& __ptr, const volatile void * _GLIBCXX_COMMA_SHIFTED
+               _GLIBCXX_PARAMS_SHIFTED) const
+       {  return ((*__ptr).*__pmf)(_GLIBCXX_ARGS_SHIFTED); }
+ 
+   public:
+     typedef _Res result_type;
+ 
+     explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { }
+ 
+     // Handle objects
+     _Res
+     operator()(const volatile _Class& __object _GLIBCXX_COMMA_SHIFTED
+                _GLIBCXX_PARAMS_SHIFTED) const
+     { return (__object.*__pmf)(_GLIBCXX_ARGS_SHIFTED); }
+ 
+     // Handle pointers
+     _Res
+     operator()(const volatile _Class* __object _GLIBCXX_COMMA_SHIFTED
+                _GLIBCXX_PARAMS_SHIFTED) const
+     { return (__object->*__pmf)(_GLIBCXX_ARGS_SHIFTED); }
+ 
+     // Handle smart pointers, references and pointers to derived
+     template<typename _Tp>
+       _Res
+       operator()(_Tp& __object _GLIBCXX_COMMA_SHIFTED
+                  _GLIBCXX_PARAMS_SHIFTED) const
+       {
+         return _M_call(__object, &__object _GLIBCXX_COMMA_SHIFTED
+                        _GLIBCXX_ARGS_SHIFTED);
+       }
+ 
+   private:
+     _Functor __pmf;
+   };
+ #endif
+ 
+ template<typename _Signature, typename _Functor> class _Function_handler;
+ 
+ template<typename _Res, typename _Functor _GLIBCXX_COMMA
+          _GLIBCXX_TEMPLATE_PARAMS>
+ class _Function_handler<_Res(_GLIBCXX_TEMPLATE_ARGS), _Functor>
+   : public _Function_base::_Base_manager<_Functor>
+ {
+   typedef _Function_base::_Base_manager<_Functor> _Base;
+ 
+  public:
+   static _Res
+   _M_invoke(const _Any_data& __functor _GLIBCXX_COMMA _GLIBCXX_PARAMS)
+   {
+     return (*_Base::_M_get_pointer(__functor))(_GLIBCXX_ARGS);
+   }
+ };
+ 
+ template<typename _Functor _GLIBCXX_COMMA _GLIBCXX_TEMPLATE_PARAMS>
+ class _Function_handler<void(_GLIBCXX_TEMPLATE_ARGS), _Functor>
+   : public _Function_base::_Base_manager<_Functor>
+ {
+   typedef _Function_base::_Base_manager<_Functor> _Base;
+ 
+  public:
+   static void
+   _M_invoke(const _Any_data& __functor _GLIBCXX_COMMA _GLIBCXX_PARAMS)
+   {
+     (*_Base::_M_get_pointer(__functor))(_GLIBCXX_ARGS);
+   }
+ };
+ 
+ template<typename _Res, typename _Functor _GLIBCXX_COMMA
+          _GLIBCXX_TEMPLATE_PARAMS>
+ class _Function_handler<_Res(_GLIBCXX_TEMPLATE_ARGS),
+                         reference_wrapper<_Functor> >
+   : public _Function_base::_Ref_manager<_Functor>
+ {
+   typedef _Function_base::_Ref_manager<_Functor> _Base;
+ 
+  public:
+   static _Res
+   _M_invoke(const _Any_data& __functor _GLIBCXX_COMMA _GLIBCXX_PARAMS)
+   {
+     return __callable_functor(**_Base::_M_get_pointer(__functor))
+              (_GLIBCXX_ARGS);
+   }
+ };
+ 
+ template<typename _Functor _GLIBCXX_COMMA _GLIBCXX_TEMPLATE_PARAMS>
+ class _Function_handler<void(_GLIBCXX_TEMPLATE_ARGS),
+                         reference_wrapper<_Functor> >
+   : public _Function_base::_Ref_manager<_Functor>
+ {
+   typedef _Function_base::_Ref_manager<_Functor> _Base;
+ 
+  public:
+   static void
+   _M_invoke(const _Any_data& __functor _GLIBCXX_COMMA _GLIBCXX_PARAMS)
+   {
+     __callable_functor(**_Base::_M_get_pointer(__functor))(_GLIBCXX_ARGS);
+   }
+ };
+ 
+ template<typename _Class, typename _Member, typename _Res
+          _GLIBCXX_COMMA _GLIBCXX_TEMPLATE_PARAMS>
+ class _Function_handler<_Res(_GLIBCXX_TEMPLATE_ARGS), _Member _Class::*>
+   : public _Function_handler<void(_GLIBCXX_TEMPLATE_ARGS), _Member _Class::*>
+ {
+   typedef _Function_handler<void(_GLIBCXX_TEMPLATE_ARGS), _Member _Class::*>
+     _Base;
+ 
+  public:
+   static _Res
+   _M_invoke(const _Any_data& __functor _GLIBCXX_COMMA _GLIBCXX_PARAMS)
+   {
+     return std::tr1::mem_fn(_Base::_M_get_pointer(__functor)->__value)
+              (_GLIBCXX_ARGS);
+   }
+ };
+ 
+ template<typename _Class, typename _Member
+          _GLIBCXX_COMMA _GLIBCXX_TEMPLATE_PARAMS>
+ class _Function_handler<void(_GLIBCXX_TEMPLATE_ARGS), _Member _Class::*>
+   : public _Function_base::_Base_manager<
+              _Simple_type_wrapper< _Member _Class::* > >
+ {
+   typedef _Member _Class::* _Functor;
+   typedef _Simple_type_wrapper< _Functor > _Wrapper;
+   typedef _Function_base::_Base_manager<_Wrapper> _Base;
+ 
+  public:
+   static bool
+   _M_manager(_Any_data& __dest, const _Any_data& __source,
+              _Manager_operation __op)
+   {
+     switch (__op) {
+     case __get_type_info:
+       __dest._M_access<const type_info*>() = &typeid(_Functor);
+       break;
+ 
+     case __get_functor_ptr:
+       __dest._M_access<_Functor*>() =
+         &_Base::_M_get_pointer(__source)->__value;
+       break;
+ 
+     default:
+       _Base::_M_manager(__dest, __source, __op);
+     }
+     return false;
+   }
+ 
+   static void
+   _M_invoke(const _Any_data& __functor _GLIBCXX_COMMA _GLIBCXX_PARAMS)
+   {
+     std::tr1::mem_fn(_Base::_M_get_pointer(__functor)->__value)
+       (_GLIBCXX_ARGS);
+   }
+ };
+ 
+ template<typename _Res _GLIBCXX_COMMA _GLIBCXX_TEMPLATE_PARAMS>
+ class function<_Res(_GLIBCXX_TEMPLATE_ARGS)>
+ #if _GLIBCXX_NUM_ARGS == 1
+   : public unary_function<_T1, _Res>, private _Function_base
+ #elif _GLIBCXX_NUM_ARGS == 2
+   : public binary_function<_T1, _T2, _Res>, private _Function_base
+ #else
+   : private _Function_base
+ #endif
+ {
+   /**
+    *  @if maint
+    *  This class is used to implement the safe_bool idiom.
+    *  @endif
+    */
+   struct _Hidden_type
+   {
+     _Hidden_type* _M_bool;
+   };
+ 
+   /**
+    *  @if maint
+    *  This typedef is used to implement the safe_bool idiom.
+    *  @endif
+    */
+   typedef _Hidden_type* _Hidden_type::* _Safe_bool;
+ 
+   typedef _Res _Signature_type(_GLIBCXX_TEMPLATE_ARGS);
+ 
+   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.
+    *  @pre @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& __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<F>, 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<F>, this function will not throw.
+    */
+   template<typename _Functor>
+     function(_Functor __f,
+              typename __enable_if<_Useless,
+                                   !is_integral<_Functor>::value>::__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& operator=(const function& __x)
+     {
+       function(__x).swap(*this);
+       return *this;
+     }
+ 
+   /**
+    *  @brief %Function assignment to zero.
+    *  @post @c !(bool)*this
+    *  @returns @c *this
+    *
+    *  The target of @a *this is deallocated, leaving it empty.
+    */
+   function& 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<F>, 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<F>, this function will not throw.
+    */
+   template<typename _Functor>
+     typename __enable_if<function&, !is_integral<_Functor>::value>::__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& __x)
+   {
+     _Any_data __old_functor = _M_functor;
+     _M_functor = __x._M_functor;
+     __x._M_functor = __old_functor;
+     _Manager_type __old_manager = _M_manager;
+     _M_manager = __x._M_manager;
+     __x._M_manager = __old_manager;
+     _Invoker_type __old_invoker = _M_invoker;
+     _M_invoker = __x._M_invoker;
+     __x._M_invoker = __old_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.
+    */
+   operator _Safe_bool() const
+     {
+       if (_M_empty())
+         {
+           return 0;
+         }
+       else
+         {
+           return &_Hidden_type::_M_bool;
+         }
+     }
+ 
+   // [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()(_GLIBCXX_PARAMS) const;
+ 
+   // [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& 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<typename _Functor>       _Functor* target();
+ 
+   /**
+    *  @overload
+    */
+   template<typename _Functor> const _Functor* target() const;
+ 
+  private:
+   // [3.7.2.6] undefined operators
+   template<typename _Function>
+     void operator==(const function<_Function>&) const;
+   template<typename _Function>
+     void operator!=(const function<_Function>&) const;
+ 
+   typedef _Res (*_Invoker_type)(const _Any_data& _GLIBCXX_COMMA _GLIBCXX_PARAMS);
+   _Invoker_type _M_invoker;
+ };
+ 
+ template<typename _Res _GLIBCXX_COMMA _GLIBCXX_TEMPLATE_PARAMS>
+   function<_Res(_GLIBCXX_TEMPLATE_ARGS)>::function(const function& __x)
+     : _Function_base()
+   {
+     if (__x) {
+       _M_invoker = __x._M_invoker;
+       _M_manager = __x._M_manager;
+       __x._M_manager(_M_functor, __x._M_functor, __clone_functor);
+     }
+   }
+ 
+ template<typename _Res _GLIBCXX_COMMA _GLIBCXX_TEMPLATE_PARAMS>
+ template<typename _Functor>
+   function<_Res(_GLIBCXX_TEMPLATE_ARGS)>
+   ::function(_Functor __f,
+              typename __enable_if<_Useless,
+                                   !is_integral<_Functor>::value>::__type)
+     : _Function_base()
+ {
+   typedef _Function_handler<_Signature_type, _Functor> _My_handler;
+   if (_My_handler::_M_not_empty_function(__f)) {
+     _M_invoker = &_My_handler::_M_invoke;
+     _M_manager = &_My_handler::_M_manager;
+     _My_handler::_M_init_functor(_M_functor, __f);
+   }
+ }
+ 
+ template<typename _Res _GLIBCXX_COMMA _GLIBCXX_TEMPLATE_PARAMS>
+   _Res function<_Res(_GLIBCXX_TEMPLATE_ARGS)>::operator()(_GLIBCXX_PARAMS) const
+   {
+     if (_M_empty())
+       {
+ #if __EXCEPTIONS
+         throw bad_function_call();
+ #else
+         std::abort();
+ #endif
+       }
+     return _M_invoker(_M_functor _GLIBCXX_COMMA _GLIBCXX_ARGS);
+   }
+ 
+ template<typename _Res _GLIBCXX_COMMA _GLIBCXX_TEMPLATE_PARAMS>
+   const type_info&
+   function<_Res(_GLIBCXX_TEMPLATE_ARGS)>::target_type() const
+   {
+     if (_M_manager)
+       {
+         _Any_data __typeinfo_result;
+         _M_manager(__typeinfo_result, _M_functor, __get_type_info);
+         return *__typeinfo_result._M_access<const type_info*>();
+       }
+     else
+       {
+         return typeid(void);
+       }
+   }
+ 
+ template<typename _Res _GLIBCXX_COMMA _GLIBCXX_TEMPLATE_PARAMS>
+ template<typename _Functor>
+   _Functor*
+   function<_Res(_GLIBCXX_TEMPLATE_ARGS)>::target()
+   {
+     if (typeid(_Functor) == target_type() && _M_manager)
+       {
+         _Any_data __ptr;
+         if (_M_manager(__ptr, _M_functor, __get_functor_ptr)
+             && !is_const<_Functor>::value)
+           return 0;
+         else
+           return __ptr._M_access<_Functor*>();
+       }
+     else
+       {
+         return 0;
+       }
+   }
+ 
+ template<typename _Res _GLIBCXX_COMMA _GLIBCXX_TEMPLATE_PARAMS>
+ template<typename _Functor>
+   const _Functor*
+   function<_Res(_GLIBCXX_TEMPLATE_ARGS)>::target() const
+   {
+     if (typeid(_Functor) == target_type() && _M_manager)
+       {
+         _Any_data __ptr;
+         _M_manager(__ptr, _M_functor, __get_functor_ptr);
+         return __ptr._M_access<const _Functor*>();
+       }
+     else
+       {
+         return 0;
+       }
+   }
+ 
// 2005-01-26 Douglas Gregor <dgregor@cs.indiana.edu>
//
// Copyright (C) 2005 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 2, 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.
//
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING.  If not, write to the Free
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
// USA.

// 3.5 function template mem_fn
#include <tr1/functional>
#include <testsuite_hooks.h>
#include <testsuite_tr1.h>

struct X { int bar; };

struct Y : X { };

template<typename T>
struct dumb_ptr
{
  dumb_ptr(T* p) : p(p) {}

  T& operator*() const { return *p; }

 private:
  T* p;
};

// Test mem_fn with a data member
void test01()
{
  using std::tr1::mem_fn;

  X x;
  Y y;
  const X& xc = x;
  const Y& yc = y;
  X* xp = &x;
  Y* yp =&y;
  const X* xpc = xp;
  const Y* ypc = yp;
  dumb_ptr<X> xd(xp);
  dumb_ptr<Y> yd(yp);
  const dumb_ptr<X>& xdc = xd;
  const dumb_ptr<Y>& ydc = yd;

  int& bx = mem_fn(&X::bar)(x);
  const int& bxc = mem_fn(&X::bar)(xc);
  int& bxp = mem_fn(&X::bar)(xp);
  const int& bxpc = mem_fn(&X::bar)(xpc);
  const int& bxd = mem_fn(&X::bar)(xd);
  const int& bxdc = mem_fn(&X::bar)(xdc);

  int& by = mem_fn(&X::bar)(y);
  const int& byc = mem_fn(&X::bar)(yc);
  int& byp = mem_fn(&X::bar)(yp);
  const int& bypc = mem_fn(&X::bar)(ypc);
  const int& byd = mem_fn(&X::bar)(yd);
  const int& bydc = mem_fn(&X::bar)(ydc);
}

int main()
{
  test01();
  return 0;
}
// 2005-01-15 Douglas Gregor <dgregor@cs.indiana.edu>
//
// Copyright (C) 2005 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 2, 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.
//
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING.  If not, write to the Free
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
// USA.

// 3.7.2 polymorphic function object wrapper
#include <tr1/functional>
#include <testsuite_hooks.h>
#include <testsuite_tr1.h>

int truncate_float(float x) { return (int)x; }
long truncate_double(double x) { return (long)x; }

struct do_truncate_float_t
{
  do_truncate_float_t()
  {
    ++live_objects;
  }

  do_truncate_float_t(const do_truncate_float_t&)
  {
    ++live_objects;
  }

  ~do_truncate_float_t()
  {
    --live_objects;
  }

  int operator()(float x) { return (int)x; }

  static int live_objects;
};

int do_truncate_float_t::live_objects = 0;

struct do_truncate_double_t
{
  do_truncate_double_t()
  {
    ++live_objects;
  }

  do_truncate_double_t(const do_truncate_double_t&)
  {
    ++live_objects;
  }

  ~do_truncate_double_t()
  {
    --live_objects;
  }

  long operator()(double x) { return (long)x; }

  static int live_objects;
};

int do_truncate_double_t::live_objects = 0;

struct X
{
  int bar;

  int foo()                   { return 1; }
  int foo_c() const           { return 2; }
  int foo_v()  volatile       { return 3; }
  int foo_cv() const volatile { return 4; }
};

bool test = true;

// Operations on empty function<> objects
void test01()
{
  using std::tr1::function;
  using std::tr1::bad_function_call;

  // Default-construction
  function<int(float)> f1;
  VERIFY( ((bool)f1 == false) );
  VERIFY( !f1 );
  VERIFY( f1 == 0 );
  VERIFY( 0 == f1 );
  VERIFY( !(f1 != 0) );
  VERIFY( !(0 != f1) );

  // Copy-construction
  function<int(float)> f2(f1);
  VERIFY( !f2 );

  // Construct with NULL pointer
  function<int(float)> f3(0);
  VERIFY( !f3 );

  // Assignment
  f1 = f2;
  VERIFY( !f1);

  // Assignment to NULL pointer
  f1 = 0;
  VERIFY( !f1 );

  // Swap
  swap(f1, f2);
  VERIFY( !f1 );
  VERIFY( !f2 );

  // Invocation should throw bad_function_call
  bool thrown = false;
  try
    {
      f1(3.14159f);
      VERIFY( false );
    }
  catch (bad_function_call)
    {
      thrown = true;
    }
  VERIFY( thrown );

  // target_type returns typeid(void)
  VERIFY( f1.target_type() == typeid(void) );

  // target() always returns a NULL pointer
  VERIFY( f1.target<int (*)(float)>() == 0);

  // Check const version
  const function<int(float)>& f1c = f1;
  VERIFY( f1c.target<int (*)(float)>() == 0 );
  VERIFY( !f1c );
}

// Put function pointers into function<> wrappers
void test02()
{
  using std::tr1::function;

  function<int(float)> f1(truncate_float);
  VERIFY( f1 );
  VERIFY( !!f1 );
  VERIFY( !(f1 == 0) );
  VERIFY( !(0 == f1) );
  VERIFY( f1 != 0 );
  VERIFY( 0 != f1 );

  // Copy-construction
  function<int(float)> f2(f1);
  VERIFY( f2 );

  // Invocation
  VERIFY( f1(3.1f) == 3 );
  VERIFY( f2(3.1f) == 3 );

  // Assignment to zero
  f1 = 0;
  VERIFY( !f1 );

  // Swap
  f1.swap(f2);
  VERIFY( f1 );
  VERIFY( !f2 );
  VERIFY( f1(3.1f) == 3 );

  // Assignment from a function pointer
  f2 = truncate_float;
  VERIFY( f2(3.1f) == 3 );

  // target_type and target() functions
  const function<int(float)>& f1c = f1;
  VERIFY( typeid(int(*)(float)) == f1.target_type() );
  VERIFY( f2.target<int(*)(float)>() != 0 );
  VERIFY( *f2.target<int(*)(float)>() == &truncate_float );
  VERIFY( f1c.target<int(*)(float)>() != 0 );
  VERIFY( *f1c.target<int(*)(float)>() == &truncate_float );
}

// Put nearly-matching function pointers into function<> wrappers
void test03()
{
  using std::tr1::function;

  function<int(float)> f1(truncate_double);
  VERIFY( f1 );
  VERIFY( !!f1 );
  VERIFY( !(f1 == 0) );
  VERIFY( !(0 == f1) );
  VERIFY( f1 != 0 );
  VERIFY( 0 != f1 );

  // Copy-construction
  function<int(float)> f2(f1);
  VERIFY( f2 );

  // Invocation
  VERIFY( f1(3.1f) == 3 );
  VERIFY( f2(3.1f) == 3 );

  // Assignment to zero
  f1 = 0;
  VERIFY( !f1 );

  // Swap
  f1.swap(f2);
  VERIFY( f1 );
  VERIFY( !f2 );
  VERIFY( f1(3.1f) == 3 );

  // Assignment from a function pointer
  f2 = truncate_double;
  VERIFY( f2(3.1f) == 3 );

  // target_type and target() functions
  const function<int(float)>& f1c = f1;
  VERIFY( typeid(long(*)(double)) == f1.target_type() );
  VERIFY( f2.target<long(*)(double)>() != 0 );
  VERIFY( *f2.target<long(*)(double)>() == &truncate_double );
  VERIFY( f1c.target<long(*)(double)>() != 0 );
  VERIFY( *f1c.target<long(*)(double)>() == &truncate_double );
}

// Put function objects into function<> wrappers
void test04()
{
  using std::tr1::function;

  do_truncate_float_t truncate_float;

  function<int(float)> f1(truncate_float);
  VERIFY( f1 );
  VERIFY( !!f1 );
  VERIFY( !(f1 == 0) );
  VERIFY( !(0 == f1) );
  VERIFY( f1 != 0 );
  VERIFY( 0 != f1 );

  // Copy-construction
  function<int(float)> f2(f1);
  VERIFY( f2 );

  // Invocation
  VERIFY( f1(3.1f) == 3 );
  VERIFY( f2(3.1f) == 3 );

  // Assignment to zero
  f1 = 0;
  VERIFY( !f1 );

  // Swap
  f1.swap(f2);
  VERIFY( f1 );
  VERIFY( !f2 );
  VERIFY( f1(3.1f) == 3 );

  // Assignment from a function pointer
  f2 = do_truncate_float_t();
  VERIFY( f2(3.1f) == 3 );

  // target_type and target() functions
  const function<int(float)>& f1c = f1;
  VERIFY( typeid(do_truncate_float_t) == f1.target_type() );
  VERIFY( f2.target<do_truncate_float_t>() != 0 );
  VERIFY( f1c.target<do_truncate_float_t>() != 0 );
}

// Put member pointers into function<> wrappers
void test05()
{
  using std::tr1::function;

  X x;
  x.bar = 17;

  function<int(X&)> frm(&X::bar);
  VERIFY( frm );
  VERIFY( frm(x) == 17 );
  VERIFY( typeid(int X::*) == frm.target_type() );
  VERIFY( *frm.target<int X::*>() == &X::bar );

  function<int(X&)> fr(&X::foo);
  VERIFY( fr );
  VERIFY( fr(x) == 1 );
  VERIFY( typeid(int (X::*)()) == fr.target_type() );
  VERIFY( *fr.target<int (X::*)()>() == &X::foo );

  function<int(const X&)> frc(&X::foo_c);
  VERIFY( frc );
  VERIFY( frc(x) == 2 );
  VERIFY( typeid(int (X::*)() const) == frc.target_type() );
  VERIFY( *frc.target<int (X::*)() const >() == &X::foo_c );

  function<int(volatile X&)> frv(&X::foo_v);
  VERIFY( frv );
  VERIFY( frv(x) == 3 );
  VERIFY( typeid(int (X::*)() volatile) == frv.target_type() );
  VERIFY( *frv.target<int (X::*)() volatile >() == &X::foo_v );
  VERIFY( frv.target<int (X::*)() const volatile>() == 0 );

  function<int(const volatile X&)> frcv(&X::foo_cv);
  VERIFY( frcv );
  VERIFY( frcv(x) == 4 );
  VERIFY( typeid(int (X::*)() const volatile) == frcv.target_type() );
  VERIFY( *frcv.target<int (X::*)() const volatile >() == &X::foo_cv );
  VERIFY( frcv.target<int (X::*)() const>() == 0 );

  function<int(X*)> grm(&X::bar);
  VERIFY( grm );
  VERIFY( grm(&x) == 17 );
  VERIFY( typeid(int X::*) == grm.target_type() );
  VERIFY( *grm.target<int X::*>() == &X::bar );

  function<int(X*)> gr(&X::foo);
  VERIFY( gr );
  VERIFY( gr(&x) == 1 );
  VERIFY( typeid(int (X::*)()) == gr.target_type() );
  VERIFY( *gr.target<int (X::*)()>() == &X::foo );

  function<int(const X*)> grc(&X::foo_c);
  VERIFY( grc );
  VERIFY( grc(&x) == 2 );
  VERIFY( typeid(int (X::*)() const) == grc.target_type() );
  VERIFY( *grc.target<int (X::*)() const >() == &X::foo_c );

  function<int(volatile X*)> grv(&X::foo_v);
  VERIFY( grv );
  VERIFY( grv(&x) == 3 );
  VERIFY( typeid(int (X::*)() volatile) == grv.target_type() );
  VERIFY( *grv.target<int (X::*)() volatile >() == &X::foo_v );
  VERIFY( grv.target<int (X::*)() const volatile>() == 0 );

  function<int(const volatile X*)> grcv(&X::foo_cv);
  VERIFY( grcv );
  VERIFY( grcv(&x) == 4 );
  VERIFY( typeid(int (X::*)() const volatile) == grcv.target_type() );
  VERIFY( *grcv.target<int (X::*)() const volatile >() == &X::foo_cv );
  VERIFY( grcv.target<int (X::*)() const>() == 0 );
}

struct secret {};

struct noncopyable_function_object_type
{
  noncopyable_function_object_type(secret) {}

  int operator()() const { return 42; }
  int operator()()       { return 17; }

 private:
  noncopyable_function_object_type();
  noncopyable_function_object_type(const noncopyable_function_object_type&);
  void operator=(const noncopyable_function_object_type&);
};

// Put reference_wrappers into function<> wrappers
void test06()
{
  using std::tr1::function;
  using std::tr1::ref;
  using std::tr1::cref;

  secret password;
  noncopyable_function_object_type x(password);

  function<int()> f(ref(x));
  VERIFY( f );
  VERIFY( f() == 17 );
  VERIFY( f.target_type() == typeid(noncopyable_function_object_type) );
  VERIFY( f.target<noncopyable_function_object_type>() == &x );

  function<int()> g = f;
  VERIFY( g );
  VERIFY( g() == 17 );
  VERIFY( g.target_type() == typeid(noncopyable_function_object_type) );
  VERIFY( g.target<noncopyable_function_object_type>() == &x );

  function<int()> h = cref(x);
  VERIFY( h );
  VERIFY( h() == 42 );
  VERIFY( h.target_type() == typeid(noncopyable_function_object_type) );
  VERIFY( h.target<const noncopyable_function_object_type>() == &x );
  VERIFY( h.target<const noncopyable_function_object_type>() == &x );

  const function<int()>& hc = h;
  VERIFY( h.target<noncopyable_function_object_type>() == 0 );
  VERIFY( hc.target<noncopyable_function_object_type>() == &x );
}

// Put reference_wrappers to function pointers into function<> wrappers
void test07()
{
  using std::tr1::function;
  using std::tr1::ref;
  using std::tr1::cref;

  int (*fptr)(float) = truncate_float;

  function<int(float)> f1(ref(fptr));
  VERIFY( f1 );
  VERIFY( !!f1 );
  VERIFY( !(f1 == 0) );
  VERIFY( !(0 == f1) );
  VERIFY( f1 != 0 );
  VERIFY( 0 != f1 );

  // Invocation
  VERIFY( f1(3.1f) == 3 );

  // target_type and target() functions
  const function<int(float)>& f1c = f1;
  VERIFY( typeid(int(*)(float)) == f1.target_type() );
  VERIFY( f1.target<int(*)(float)>() != 0 );
  VERIFY( f1.target<int(*)(float)>() == &fptr );
  VERIFY( f1c.target<int(*)(float)>() != 0 );
  VERIFY( f1c.target<int(*)(float)>() == &fptr );

  function<int(float)> f2(cref(fptr));
  VERIFY( f2 );
  VERIFY( !!f2 );
  VERIFY( !(f2 == 0) );
  VERIFY( !(0 == f2) );
  VERIFY( f2 != 0 );
  VERIFY( 0 != f2 );

  // Invocation
  VERIFY( f2(3.1f) == 3 );

  // target_type and target() functions
  const function<int(float)>& f2c = f2;
  VERIFY( typeid(int(*)(float)) == f2.target_type() );
  VERIFY( f2.target<int(*)(float)>() == 0 );
  VERIFY( f2.target<int(* const)(float)>() == &fptr );
  VERIFY( f2c.target<int(*)(float)>() != 0 );
  VERIFY( f2c.target<int(*)(float)>() == &fptr );
}

// Put reference_wrappers to member pointers
void test08()
{
  using std::tr1::function;
  using std::tr1::ref;
  using std::tr1::cref;

  int X::* X_bar = &X::bar;
  int (X::* X_foo)() = &X::foo;
  int (X::* X_foo_c)() const = &X::foo_c;
  int (X::* X_foo_v)() volatile = &X::foo_v;
  int (X::* X_foo_cv)() const volatile = &X::foo_cv;

  X x;
  x.bar = 17;

  function<int(X&)> frm(ref(X_bar));
  VERIFY( frm );
  VERIFY( frm(x) == 17 );
  VERIFY( typeid(int X::*) == frm.target_type() );
  VERIFY( frm.target<int X::*>() == &X_bar );

  function<int(X&)> fr(ref(X_foo));
  VERIFY( fr );
  VERIFY( fr(x) == 1 );
  VERIFY( typeid(int (X::*)()) == fr.target_type() );
  VERIFY( fr.target<int (X::*)()>() == &X_foo );

  function<int(const X&)> frc(ref(X_foo_c));
  VERIFY( frc );
  VERIFY( frc(x) == 2 );
  VERIFY( typeid(int (X::*)() const) == frc.target_type() );
  VERIFY( frc.target<int (X::*)() const >() == &X_foo_c );

  function<int(volatile X&)> frv(ref(X_foo_v));
  VERIFY( frv );
  VERIFY( frv(x) == 3 );
  VERIFY( typeid(int (X::*)() volatile) == frv.target_type() );
  VERIFY( *frv.target<int (X::*)() volatile >() == X_foo_v );
  VERIFY( frv.target<int (X::*)() const volatile>() == 0 );

  function<int(const volatile X&)> frcv(ref(X_foo_cv));
  VERIFY( frcv );
  VERIFY( frcv(x) == 4 );
  VERIFY( typeid(int (X::*)() const volatile) == frcv.target_type() );
  VERIFY( *frcv.target<int (X::*)() const volatile >() == X_foo_cv );
  VERIFY( frcv.target<int (X::*)() const>() == 0 );

  function<int(X*)> grm(ref(X_bar));
  VERIFY( grm );
  VERIFY( grm(&x) == 17 );
  VERIFY( typeid(int X::*) == grm.target_type() );
  VERIFY( *grm.target<int X::*>() == X_bar );

  function<int(X*)> gr(ref(X_foo));
  VERIFY( gr );
  VERIFY( gr(&x) == 1 );
  VERIFY( typeid(int (X::*)()) == gr.target_type() );
  VERIFY( *gr.target<int (X::*)()>() == X_foo );

  function<int(const X*)> grc(ref(X_foo_c));
  VERIFY( grc );
  VERIFY( grc(&x) == 2 );
  VERIFY( typeid(int (X::*)() const) == grc.target_type() );
  VERIFY( *grc.target<int (X::*)() const >() == X_foo_c );

  function<int(volatile X*)> grv(ref(X_foo_v));
  VERIFY( grv );
  VERIFY( grv(&x) == 3 );
  VERIFY( typeid(int (X::*)() volatile) == grv.target_type() );
  VERIFY( *grv.target<int (X::*)() volatile >() == X_foo_v );
  VERIFY( grv.target<int (X::*)() const volatile>() == 0 );

  function<int(const volatile X*)> grcv(ref(X_foo_cv));
  VERIFY( grcv );
  VERIFY( grcv(&x) == 4 );
  VERIFY( typeid(int (X::*)() const volatile) == grcv.target_type() );
  VERIFY( *grcv.target<int (X::*)() const volatile >() == X_foo_cv );
  VERIFY( grcv.target<int (X::*)() const>() == 0 );

  function<int(X&)> hrm(cref(X_bar));
  VERIFY( hrm );
  VERIFY( hrm(x) == 17 );
  VERIFY( typeid(int X::*) == hrm.target_type() );
  VERIFY( hrm.target<int X::*>() == 0 );
  VERIFY( hrm.target<int X::* const>() == &X_bar );

  function<int(X&)> hr(cref(X_foo));
  VERIFY( hr );
  VERIFY( hr(x) == 1 );
  VERIFY( typeid(int (X::*)()) == hr.target_type() );
  VERIFY( hr.target<int (X::* const)()>() == &X_foo );

  function<int(const X&)> hrc(cref(X_foo_c));
  VERIFY( hrc );
  VERIFY( hrc(x) == 2 );
  VERIFY( typeid(int (X::*)() const) == hrc.target_type() );
  VERIFY( hrc.target<int (X::* const)() const >() == &X_foo_c );

  function<int(volatile X&)> hrv(cref(X_foo_v));
  VERIFY( hrv );
  VERIFY( hrv(x) == 3 );
  VERIFY( typeid(int (X::*)() volatile) == hrv.target_type() );
  VERIFY( hrv.target<int (X::* const)() volatile >() == &X_foo_v );
  VERIFY( hrv.target<int (X::* const)() const volatile>() == 0 );

  function<int(const volatile X&)> hrcv(cref(X_foo_cv));
  VERIFY( hrcv );
  VERIFY( hrcv(x) == 4 );
  VERIFY( typeid(int (X::*)() const volatile) == hrcv.target_type() );
  VERIFY( hrcv.target<int (X::* const)() const volatile >() == &X_foo_cv );
  VERIFY( hrcv.target<int (X::* const)() const>() == 0 );
}

// Put function objects into a void-returning function<> wrapper
void test09()
{
  using std::tr1::function;
  using std::tr1::ref;
  using std::tr1::cref;

  int (X::*X_foo_c)() const = &X::foo_c;
  function<void(X&)> f(&X::bar);
  f = &X::foo;
  f = ref(X_foo_c);
  f = cref(X_foo_c);

  function<void(float)> g = &truncate_float;
  g = do_truncate_float_t();
}

int main()
{
  test01();
  test02();
  test03();
  test04();
  test05();
  test06();
  test07();
  test08();
  test09();

  VERIFY( do_truncate_double_t::live_objects == 0 );
  VERIFY( do_truncate_float_t::live_objects == 0 );

  return 0;
}

Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]