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