File Coverage

/usr/include/c++/5/functional
Criterion Covered Total %
statement 38 50 76.0
branch 6 14 42.8
condition n/a
subroutine n/a
pod n/a
total 44 64 68.7


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