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