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