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