OSDN Git Service

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