OSDN Git Service

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