Branch data Line data Source code
1 : : // Functor implementations -*- C++ -*-
2 : :
3 : : // Copyright (C) 2001-2015 Free Software Foundation, Inc.
4 : : //
5 : : // This file is part of the GNU ISO C++ Library. This library is free
6 : : // software; you can redistribute it and/or modify it under the
7 : : // terms of the GNU General Public License as published by the
8 : : // Free Software Foundation; either version 3, or (at your option)
9 : : // any later version.
10 : :
11 : : // This library is distributed in the hope that it will be useful,
12 : : // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 : : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 : : // GNU General Public License for more details.
15 : :
16 : : // Under Section 7 of GPL version 3, you are granted additional
17 : : // permissions described in the GCC Runtime Library Exception, version
18 : : // 3.1, as published by the Free Software Foundation.
19 : :
20 : : // You should have received a copy of the GNU General Public License and
21 : : // a copy of the GCC Runtime Library Exception along with this program;
22 : : // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
23 : : // <http://www.gnu.org/licenses/>.
24 : :
25 : : /*
26 : : *
27 : : * Copyright (c) 1994
28 : : * Hewlett-Packard Company
29 : : *
30 : : * Permission to use, copy, modify, distribute and sell this software
31 : : * and its documentation for any purpose is hereby granted without fee,
32 : : * provided that the above copyright notice appear in all copies and
33 : : * that both that copyright notice and this permission notice appear
34 : : * in supporting documentation. Hewlett-Packard Company makes no
35 : : * representations about the suitability of this software for any
36 : : * purpose. It is provided "as is" without express or implied warranty.
37 : : *
38 : : *
39 : : * Copyright (c) 1996-1998
40 : : * Silicon Graphics Computer Systems, Inc.
41 : : *
42 : : * Permission to use, copy, modify, distribute and sell this software
43 : : * and its documentation for any purpose is hereby granted without fee,
44 : : * provided that the above copyright notice appear in all copies and
45 : : * that both that copyright notice and this permission notice appear
46 : : * in supporting documentation. Silicon Graphics makes no
47 : : * representations about the suitability of this software for any
48 : : * purpose. It is provided "as is" without express or implied warranty.
49 : : */
50 : :
51 : : /** @file bits/stl_function.h
52 : : * This is an internal header file, included by other library headers.
53 : : * Do not attempt to use it directly. @headername{functional}
54 : : */
55 : :
56 : : #ifndef _STL_FUNCTION_H
57 : : #define _STL_FUNCTION_H 1
58 : :
59 : : #if __cplusplus > 201103L
60 : : #include <bits/move.h>
61 : : #endif
62 : :
63 : : namespace std _GLIBCXX_VISIBILITY(default)
64 : : {
65 : : _GLIBCXX_BEGIN_NAMESPACE_VERSION
66 : :
67 : : // 20.3.1 base classes
68 : : /** @defgroup functors Function Objects
69 : : * @ingroup utilities
70 : : *
71 : : * Function objects, or @e functors, are objects with an @c operator()
72 : : * defined and accessible. They can be passed as arguments to algorithm
73 : : * templates and used in place of a function pointer. Not only is the
74 : : * resulting expressiveness of the library increased, but the generated
75 : : * code can be more efficient than what you might write by hand. When we
76 : : * refer to @a functors, then, generally we include function pointers in
77 : : * the description as well.
78 : : *
79 : : * Often, functors are only created as temporaries passed to algorithm
80 : : * calls, rather than being created as named variables.
81 : : *
82 : : * Two examples taken from the standard itself follow. To perform a
83 : : * by-element addition of two vectors @c a and @c b containing @c double,
84 : : * and put the result in @c a, use
85 : : * \code
86 : : * transform (a.begin(), a.end(), b.begin(), a.begin(), plus<double>());
87 : : * \endcode
88 : : * To negate every element in @c a, use
89 : : * \code
90 : : * transform(a.begin(), a.end(), a.begin(), negate<double>());
91 : : * \endcode
92 : : * The addition and negation functions will be inlined directly.
93 : : *
94 : : * The standard functors are derived from structs named @c unary_function
95 : : * and @c binary_function. These two classes contain nothing but typedefs,
96 : : * to aid in generic (template) programming. If you write your own
97 : : * functors, you might consider doing the same.
98 : : *
99 : : * @{
100 : : */
101 : : /**
102 : : * This is one of the @link functors functor base classes@endlink.
103 : : */
104 : : template<typename _Arg, typename _Result>
105 : : struct unary_function
106 : : {
107 : : /// @c argument_type is the type of the argument
108 : : typedef _Arg argument_type;
109 : :
110 : : /// @c result_type is the return type
111 : : typedef _Result result_type;
112 : : };
113 : :
114 : : /**
115 : : * This is one of the @link functors functor base classes@endlink.
116 : : */
117 : : template<typename _Arg1, typename _Arg2, typename _Result>
118 : : struct binary_function
119 : : {
120 : : /// @c first_argument_type is the type of the first argument
121 : : typedef _Arg1 first_argument_type;
122 : :
123 : : /// @c second_argument_type is the type of the second argument
124 : : typedef _Arg2 second_argument_type;
125 : :
126 : : /// @c result_type is the return type
127 : : typedef _Result result_type;
128 : : };
129 : : /** @} */
130 : :
131 : : // 20.3.2 arithmetic
132 : : /** @defgroup arithmetic_functors Arithmetic Classes
133 : : * @ingroup functors
134 : : *
135 : : * Because basic math often needs to be done during an algorithm,
136 : : * the library provides functors for those operations. See the
137 : : * documentation for @link functors the base classes@endlink
138 : : * for examples of their use.
139 : : *
140 : : * @{
141 : : */
142 : :
143 : : #if __cplusplus > 201103L
144 : : struct __is_transparent; // undefined
145 : :
146 : : template<typename _Tp = void>
147 : : struct plus;
148 : :
149 : : template<typename _Tp = void>
150 : : struct minus;
151 : :
152 : : template<typename _Tp = void>
153 : : struct multiplies;
154 : :
155 : : template<typename _Tp = void>
156 : : struct divides;
157 : :
158 : : template<typename _Tp = void>
159 : : struct modulus;
160 : :
161 : : template<typename _Tp = void>
162 : : struct negate;
163 : : #endif
164 : :
165 : : /// One of the @link arithmetic_functors math functors@endlink.
166 : : template<typename _Tp>
167 : : struct plus : public binary_function<_Tp, _Tp, _Tp>
168 : : {
169 : : _GLIBCXX14_CONSTEXPR
170 : : _Tp
171 : : operator()(const _Tp& __x, const _Tp& __y) const
172 : : { return __x + __y; }
173 : : };
174 : :
175 : : /// One of the @link arithmetic_functors math functors@endlink.
176 : : template<typename _Tp>
177 : : struct minus : public binary_function<_Tp, _Tp, _Tp>
178 : : {
179 : : _GLIBCXX14_CONSTEXPR
180 : : _Tp
181 : : operator()(const _Tp& __x, const _Tp& __y) const
182 : : { return __x - __y; }
183 : : };
184 : :
185 : : /// One of the @link arithmetic_functors math functors@endlink.
186 : : template<typename _Tp>
187 : : struct multiplies : public binary_function<_Tp, _Tp, _Tp>
188 : : {
189 : : _GLIBCXX14_CONSTEXPR
190 : : _Tp
191 : : operator()(const _Tp& __x, const _Tp& __y) const
192 : : { return __x * __y; }
193 : : };
194 : :
195 : : /// One of the @link arithmetic_functors math functors@endlink.
196 : : template<typename _Tp>
197 : : struct divides : public binary_function<_Tp, _Tp, _Tp>
198 : : {
199 : : _GLIBCXX14_CONSTEXPR
200 : : _Tp
201 : : operator()(const _Tp& __x, const _Tp& __y) const
202 : : { return __x / __y; }
203 : : };
204 : :
205 : : /// One of the @link arithmetic_functors math functors@endlink.
206 : : template<typename _Tp>
207 : : struct modulus : public binary_function<_Tp, _Tp, _Tp>
208 : : {
209 : : _GLIBCXX14_CONSTEXPR
210 : : _Tp
211 : : operator()(const _Tp& __x, const _Tp& __y) const
212 : : { return __x % __y; }
213 : : };
214 : :
215 : : /// One of the @link arithmetic_functors math functors@endlink.
216 : : template<typename _Tp>
217 : : struct negate : public unary_function<_Tp, _Tp>
218 : : {
219 : : _GLIBCXX14_CONSTEXPR
220 : : _Tp
221 : : operator()(const _Tp& __x) const
222 : : { return -__x; }
223 : : };
224 : :
225 : : #if __cplusplus > 201103L
226 : :
227 : : #define __cpp_lib_transparent_operators 201210
228 : : //#define __cpp_lib_generic_associative_lookup 201304
229 : :
230 : : template<>
231 : : struct plus<void>
232 : : {
233 : : template <typename _Tp, typename _Up>
234 : : _GLIBCXX14_CONSTEXPR
235 : : auto
236 : : operator()(_Tp&& __t, _Up&& __u) const
237 : : noexcept(noexcept(std::forward<_Tp>(__t) + std::forward<_Up>(__u)))
238 : : -> decltype(std::forward<_Tp>(__t) + std::forward<_Up>(__u))
239 : : { return std::forward<_Tp>(__t) + std::forward<_Up>(__u); }
240 : :
241 : : typedef __is_transparent is_transparent;
242 : : };
243 : :
244 : : /// One of the @link arithmetic_functors math functors@endlink.
245 : : template<>
246 : : struct minus<void>
247 : : {
248 : : template <typename _Tp, typename _Up>
249 : : _GLIBCXX14_CONSTEXPR
250 : : auto
251 : : operator()(_Tp&& __t, _Up&& __u) const
252 : : noexcept(noexcept(std::forward<_Tp>(__t) - std::forward<_Up>(__u)))
253 : : -> decltype(std::forward<_Tp>(__t) - std::forward<_Up>(__u))
254 : : { return std::forward<_Tp>(__t) - std::forward<_Up>(__u); }
255 : :
256 : : typedef __is_transparent is_transparent;
257 : : };
258 : :
259 : : /// One of the @link arithmetic_functors math functors@endlink.
260 : : template<>
261 : : struct multiplies<void>
262 : : {
263 : : template <typename _Tp, typename _Up>
264 : : _GLIBCXX14_CONSTEXPR
265 : : auto
266 : : operator()(_Tp&& __t, _Up&& __u) const
267 : : noexcept(noexcept(std::forward<_Tp>(__t) * std::forward<_Up>(__u)))
268 : : -> decltype(std::forward<_Tp>(__t) * std::forward<_Up>(__u))
269 : : { return std::forward<_Tp>(__t) * std::forward<_Up>(__u); }
270 : :
271 : : typedef __is_transparent is_transparent;
272 : : };
273 : :
274 : : /// One of the @link arithmetic_functors math functors@endlink.
275 : : template<>
276 : : struct divides<void>
277 : : {
278 : : template <typename _Tp, typename _Up>
279 : : _GLIBCXX14_CONSTEXPR
280 : : auto
281 : : operator()(_Tp&& __t, _Up&& __u) const
282 : : noexcept(noexcept(std::forward<_Tp>(__t) / std::forward<_Up>(__u)))
283 : : -> decltype(std::forward<_Tp>(__t) / std::forward<_Up>(__u))
284 : : { return std::forward<_Tp>(__t) / std::forward<_Up>(__u); }
285 : :
286 : : typedef __is_transparent is_transparent;
287 : : };
288 : :
289 : : /// One of the @link arithmetic_functors math functors@endlink.
290 : : template<>
291 : : struct modulus<void>
292 : : {
293 : : template <typename _Tp, typename _Up>
294 : : _GLIBCXX14_CONSTEXPR
295 : : auto
296 : : operator()(_Tp&& __t, _Up&& __u) const
297 : : noexcept(noexcept(std::forward<_Tp>(__t) % std::forward<_Up>(__u)))
298 : : -> decltype(std::forward<_Tp>(__t) % std::forward<_Up>(__u))
299 : : { return std::forward<_Tp>(__t) % std::forward<_Up>(__u); }
300 : :
301 : : typedef __is_transparent is_transparent;
302 : : };
303 : :
304 : : /// One of the @link arithmetic_functors math functors@endlink.
305 : : template<>
306 : : struct negate<void>
307 : : {
308 : : template <typename _Tp>
309 : : _GLIBCXX14_CONSTEXPR
310 : : auto
311 : : operator()(_Tp&& __t) const
312 : : noexcept(noexcept(-std::forward<_Tp>(__t)))
313 : : -> decltype(-std::forward<_Tp>(__t))
314 : : { return -std::forward<_Tp>(__t); }
315 : :
316 : : typedef __is_transparent is_transparent;
317 : : };
318 : : #endif
319 : : /** @} */
320 : :
321 : : // 20.3.3 comparisons
322 : : /** @defgroup comparison_functors Comparison Classes
323 : : * @ingroup functors
324 : : *
325 : : * The library provides six wrapper functors for all the basic comparisons
326 : : * in C++, like @c <.
327 : : *
328 : : * @{
329 : : */
330 : : #if __cplusplus > 201103L
331 : : template<typename _Tp = void>
332 : : struct equal_to;
333 : :
334 : : template<typename _Tp = void>
335 : : struct not_equal_to;
336 : :
337 : : template<typename _Tp = void>
338 : : struct greater;
339 : :
340 : : template<typename _Tp = void>
341 : : struct less;
342 : :
343 : : template<typename _Tp = void>
344 : : struct greater_equal;
345 : :
346 : : template<typename _Tp = void>
347 : : struct less_equal;
348 : : #endif
349 : :
350 : : /// One of the @link comparison_functors comparison functors@endlink.
351 : : template<typename _Tp>
352 : : struct equal_to : public binary_function<_Tp, _Tp, bool>
353 : : {
354 : : _GLIBCXX14_CONSTEXPR
355 : : bool
356 : : operator()(const _Tp& __x, const _Tp& __y) const
357 : : { return __x == __y; }
358 : : };
359 : :
360 : : /// One of the @link comparison_functors comparison functors@endlink.
361 : : template<typename _Tp>
362 : : struct not_equal_to : public binary_function<_Tp, _Tp, bool>
363 : : {
364 : : _GLIBCXX14_CONSTEXPR
365 : : bool
366 : : operator()(const _Tp& __x, const _Tp& __y) const
367 : : { return __x != __y; }
368 : : };
369 : :
370 : : /// One of the @link comparison_functors comparison functors@endlink.
371 : : template<typename _Tp>
372 : : struct greater : public binary_function<_Tp, _Tp, bool>
373 : : {
374 : : _GLIBCXX14_CONSTEXPR
375 : : bool
376 : : operator()(const _Tp& __x, const _Tp& __y) const
377 : : { return __x > __y; }
378 : : };
379 : :
380 : : /// One of the @link comparison_functors comparison functors@endlink.
381 : : template<typename _Tp>
382 : : struct less : public binary_function<_Tp, _Tp, bool>
383 : : {
384 : : _GLIBCXX14_CONSTEXPR
385 : : bool
386 : : operator()(const _Tp& __x, const _Tp& __y) const
387 : : { return __x < __y; }
388 : : };
389 : :
390 : : /// One of the @link comparison_functors comparison functors@endlink.
391 : : template<typename _Tp>
392 : : struct greater_equal : public binary_function<_Tp, _Tp, bool>
393 : : {
394 : : _GLIBCXX14_CONSTEXPR
395 : : bool
396 : : operator()(const _Tp& __x, const _Tp& __y) const
397 : : { return __x >= __y; }
398 : : };
399 : :
400 : : /// One of the @link comparison_functors comparison functors@endlink.
401 : : template<typename _Tp>
402 : : struct less_equal : public binary_function<_Tp, _Tp, bool>
403 : : {
404 : : _GLIBCXX14_CONSTEXPR
405 : : bool
406 : : operator()(const _Tp& __x, const _Tp& __y) const
407 : : { return __x <= __y; }
408 : : };
409 : :
410 : : #if __cplusplus > 201103L
411 : : /// One of the @link comparison_functors comparison functors@endlink.
412 : : template<>
413 : : struct equal_to<void>
414 : : {
415 : : template <typename _Tp, typename _Up>
416 : : _GLIBCXX14_CONSTEXPR
417 : : auto
418 : : operator()(_Tp&& __t, _Up&& __u) const
419 : : noexcept(noexcept(std::forward<_Tp>(__t) == std::forward<_Up>(__u)))
420 : : -> decltype(std::forward<_Tp>(__t) == std::forward<_Up>(__u))
421 : : { return std::forward<_Tp>(__t) == std::forward<_Up>(__u); }
422 : :
423 : : typedef __is_transparent is_transparent;
424 : : };
425 : :
426 : : /// One of the @link comparison_functors comparison functors@endlink.
427 : : template<>
428 : : struct not_equal_to<void>
429 : : {
430 : : template <typename _Tp, typename _Up>
431 : : _GLIBCXX14_CONSTEXPR
432 : : auto
433 : : operator()(_Tp&& __t, _Up&& __u) const
434 : : noexcept(noexcept(std::forward<_Tp>(__t) != std::forward<_Up>(__u)))
435 : : -> decltype(std::forward<_Tp>(__t) != std::forward<_Up>(__u))
436 : : { return std::forward<_Tp>(__t) != std::forward<_Up>(__u); }
437 : :
438 : : typedef __is_transparent is_transparent;
439 : : };
440 : :
441 : : /// One of the @link comparison_functors comparison functors@endlink.
442 : : template<>
443 : : struct greater<void>
444 : : {
445 : : template <typename _Tp, typename _Up>
446 : : _GLIBCXX14_CONSTEXPR
447 : : auto
448 : : operator()(_Tp&& __t, _Up&& __u) const
449 : : noexcept(noexcept(std::forward<_Tp>(__t) > std::forward<_Up>(__u)))
450 : : -> decltype(std::forward<_Tp>(__t) > std::forward<_Up>(__u))
451 : : { return std::forward<_Tp>(__t) > std::forward<_Up>(__u); }
452 : :
453 : : typedef __is_transparent is_transparent;
454 : : };
455 : :
456 : : /// One of the @link comparison_functors comparison functors@endlink.
457 : : template<>
458 : : struct less<void>
459 : : {
460 : : template <typename _Tp, typename _Up>
461 : : _GLIBCXX14_CONSTEXPR
462 : : auto
463 : : operator()(_Tp&& __t, _Up&& __u) const
464 : : noexcept(noexcept(std::forward<_Tp>(__t) < std::forward<_Up>(__u)))
465 : : -> decltype(std::forward<_Tp>(__t) < std::forward<_Up>(__u))
466 : : { return std::forward<_Tp>(__t) < std::forward<_Up>(__u); }
467 : :
468 : : typedef __is_transparent is_transparent;
469 : : };
470 : :
471 : : /// One of the @link comparison_functors comparison functors@endlink.
472 : : template<>
473 : : struct greater_equal<void>
474 : : {
475 : : template <typename _Tp, typename _Up>
476 : : _GLIBCXX14_CONSTEXPR
477 : : auto
478 : : operator()(_Tp&& __t, _Up&& __u) const
479 : : noexcept(noexcept(std::forward<_Tp>(__t) >= std::forward<_Up>(__u)))
480 : : -> decltype(std::forward<_Tp>(__t) >= std::forward<_Up>(__u))
481 : : { return std::forward<_Tp>(__t) >= std::forward<_Up>(__u); }
482 : :
483 : : typedef __is_transparent is_transparent;
484 : : };
485 : :
486 : : /// One of the @link comparison_functors comparison functors@endlink.
487 : : template<>
488 : : struct less_equal<void>
489 : : {
490 : : template <typename _Tp, typename _Up>
491 : : _GLIBCXX14_CONSTEXPR
492 : : auto
493 : : operator()(_Tp&& __t, _Up&& __u) const
494 : : noexcept(noexcept(std::forward<_Tp>(__t) <= std::forward<_Up>(__u)))
495 : : -> decltype(std::forward<_Tp>(__t) <= std::forward<_Up>(__u))
496 : : { return std::forward<_Tp>(__t) <= std::forward<_Up>(__u); }
497 : :
498 : : typedef __is_transparent is_transparent;
499 : : };
500 : : #endif
501 : : /** @} */
502 : :
503 : : // 20.3.4 logical operations
504 : : /** @defgroup logical_functors Boolean Operations Classes
505 : : * @ingroup functors
506 : : *
507 : : * Here are wrapper functors for Boolean operations: @c &&, @c ||,
508 : : * and @c !.
509 : : *
510 : : * @{
511 : : */
512 : : #if __cplusplus > 201103L
513 : : template<typename _Tp = void>
514 : : struct logical_and;
515 : :
516 : : template<typename _Tp = void>
517 : : struct logical_or;
518 : :
519 : : template<typename _Tp = void>
520 : : struct logical_not;
521 : : #endif
522 : :
523 : : /// One of the @link logical_functors Boolean operations functors@endlink.
524 : : template<typename _Tp>
525 : : struct logical_and : public binary_function<_Tp, _Tp, bool>
526 : : {
527 : : _GLIBCXX14_CONSTEXPR
528 : : bool
529 : : operator()(const _Tp& __x, const _Tp& __y) const
530 : : { return __x && __y; }
531 : : };
532 : :
533 : : /// One of the @link logical_functors Boolean operations functors@endlink.
534 : : template<typename _Tp>
535 : : struct logical_or : public binary_function<_Tp, _Tp, bool>
536 : : {
537 : : _GLIBCXX14_CONSTEXPR
538 : : bool
539 : : operator()(const _Tp& __x, const _Tp& __y) const
540 : : { return __x || __y; }
541 : : };
542 : :
543 : : /// One of the @link logical_functors Boolean operations functors@endlink.
544 : : template<typename _Tp>
545 : : struct logical_not : public unary_function<_Tp, bool>
546 : : {
547 : : _GLIBCXX14_CONSTEXPR
548 : : bool
549 : : operator()(const _Tp& __x) const
550 : : { return !__x; }
551 : : };
552 : :
553 : : #if __cplusplus > 201103L
554 : : /// One of the @link logical_functors Boolean operations functors@endlink.
555 : : template<>
556 : : struct logical_and<void>
557 : : {
558 : : template <typename _Tp, typename _Up>
559 : : _GLIBCXX14_CONSTEXPR
560 : : auto
561 : : operator()(_Tp&& __t, _Up&& __u) const
562 : : noexcept(noexcept(std::forward<_Tp>(__t) && std::forward<_Up>(__u)))
563 : : -> decltype(std::forward<_Tp>(__t) && std::forward<_Up>(__u))
564 : : { return std::forward<_Tp>(__t) && std::forward<_Up>(__u); }
565 : :
566 : : typedef __is_transparent is_transparent;
567 : : };
568 : :
569 : : /// One of the @link logical_functors Boolean operations functors@endlink.
570 : : template<>
571 : : struct logical_or<void>
572 : : {
573 : : template <typename _Tp, typename _Up>
574 : : _GLIBCXX14_CONSTEXPR
575 : : auto
576 : : operator()(_Tp&& __t, _Up&& __u) const
577 : : noexcept(noexcept(std::forward<_Tp>(__t) || std::forward<_Up>(__u)))
578 : : -> decltype(std::forward<_Tp>(__t) || std::forward<_Up>(__u))
579 : : { return std::forward<_Tp>(__t) || std::forward<_Up>(__u); }
580 : :
581 : : typedef __is_transparent is_transparent;
582 : : };
583 : :
584 : : /// One of the @link logical_functors Boolean operations functors@endlink.
585 : : template<>
586 : : struct logical_not<void>
587 : : {
588 : : template <typename _Tp>
589 : : _GLIBCXX14_CONSTEXPR
590 : : auto
591 : : operator()(_Tp&& __t) const
592 : : noexcept(noexcept(!std::forward<_Tp>(__t)))
593 : : -> decltype(!std::forward<_Tp>(__t))
594 : : { return !std::forward<_Tp>(__t); }
595 : :
596 : : typedef __is_transparent is_transparent;
597 : : };
598 : : #endif
599 : : /** @} */
600 : :
601 : : #if __cplusplus > 201103L
602 : : template<typename _Tp = void>
603 : : struct bit_and;
604 : :
605 : : template<typename _Tp = void>
606 : : struct bit_or;
607 : :
608 : : template<typename _Tp = void>
609 : : struct bit_xor;
610 : :
611 : : template<typename _Tp = void>
612 : : struct bit_not;
613 : : #endif
614 : :
615 : : // _GLIBCXX_RESOLVE_LIB_DEFECTS
616 : : // DR 660. Missing Bitwise Operations.
617 : : template<typename _Tp>
618 : : struct bit_and : public binary_function<_Tp, _Tp, _Tp>
619 : : {
620 : : _GLIBCXX14_CONSTEXPR
621 : : _Tp
622 : : operator()(const _Tp& __x, const _Tp& __y) const
623 : : { return __x & __y; }
624 : : };
625 : :
626 : : template<typename _Tp>
627 : : struct bit_or : public binary_function<_Tp, _Tp, _Tp>
628 : : {
629 : : _GLIBCXX14_CONSTEXPR
630 : : _Tp
631 : : operator()(const _Tp& __x, const _Tp& __y) const
632 : : { return __x | __y; }
633 : : };
634 : :
635 : : template<typename _Tp>
636 : : struct bit_xor : public binary_function<_Tp, _Tp, _Tp>
637 : : {
638 : : _GLIBCXX14_CONSTEXPR
639 : : _Tp
640 : : operator()(const _Tp& __x, const _Tp& __y) const
641 : : { return __x ^ __y; }
642 : : };
643 : :
644 : : template<typename _Tp>
645 : : struct bit_not : public unary_function<_Tp, _Tp>
646 : : {
647 : : _GLIBCXX14_CONSTEXPR
648 : : _Tp
649 : : operator()(const _Tp& __x) const
650 : : { return ~__x; }
651 : : };
652 : :
653 : : #if __cplusplus > 201103L
654 : : template <>
655 : : struct bit_and<void>
656 : : {
657 : : template <typename _Tp, typename _Up>
658 : : _GLIBCXX14_CONSTEXPR
659 : : auto
660 : : operator()(_Tp&& __t, _Up&& __u) const
661 : : noexcept(noexcept(std::forward<_Tp>(__t) & std::forward<_Up>(__u)))
662 : : -> decltype(std::forward<_Tp>(__t) & std::forward<_Up>(__u))
663 : : { return std::forward<_Tp>(__t) & std::forward<_Up>(__u); }
664 : :
665 : : typedef __is_transparent is_transparent;
666 : : };
667 : :
668 : : template <>
669 : : struct bit_or<void>
670 : : {
671 : : template <typename _Tp, typename _Up>
672 : : _GLIBCXX14_CONSTEXPR
673 : : auto
674 : : operator()(_Tp&& __t, _Up&& __u) const
675 : : noexcept(noexcept(std::forward<_Tp>(__t) | std::forward<_Up>(__u)))
676 : : -> decltype(std::forward<_Tp>(__t) | std::forward<_Up>(__u))
677 : : { return std::forward<_Tp>(__t) | std::forward<_Up>(__u); }
678 : :
679 : : typedef __is_transparent is_transparent;
680 : : };
681 : :
682 : : template <>
683 : : struct bit_xor<void>
684 : : {
685 : : template <typename _Tp, typename _Up>
686 : : _GLIBCXX14_CONSTEXPR
687 : : auto
688 : : operator()(_Tp&& __t, _Up&& __u) const
689 : : noexcept(noexcept(std::forward<_Tp>(__t) ^ std::forward<_Up>(__u)))
690 : : -> decltype(std::forward<_Tp>(__t) ^ std::forward<_Up>(__u))
691 : : { return std::forward<_Tp>(__t) ^ std::forward<_Up>(__u); }
692 : :
693 : : typedef __is_transparent is_transparent;
694 : : };
695 : :
696 : : template <>
697 : : struct bit_not<void>
698 : : {
699 : : template <typename _Tp>
700 : : _GLIBCXX14_CONSTEXPR
701 : : auto
702 : : operator()(_Tp&& __t) const
703 : : noexcept(noexcept(~std::forward<_Tp>(__t)))
704 : : -> decltype(~std::forward<_Tp>(__t))
705 : : { return ~std::forward<_Tp>(__t); }
706 : :
707 : : typedef __is_transparent is_transparent;
708 : : };
709 : : #endif
710 : :
711 : : // 20.3.5 negators
712 : : /** @defgroup negators Negators
713 : : * @ingroup functors
714 : : *
715 : : * The functions @c not1 and @c not2 each take a predicate functor
716 : : * and return an instance of @c unary_negate or
717 : : * @c binary_negate, respectively. These classes are functors whose
718 : : * @c operator() performs the stored predicate function and then returns
719 : : * the negation of the result.
720 : : *
721 : : * For example, given a vector of integers and a trivial predicate,
722 : : * \code
723 : : * struct IntGreaterThanThree
724 : : * : public std::unary_function<int, bool>
725 : : * {
726 : : * bool operator() (int x) { return x > 3; }
727 : : * };
728 : : *
729 : : * std::find_if (v.begin(), v.end(), not1(IntGreaterThanThree()));
730 : : * \endcode
731 : : * The call to @c find_if will locate the first index (i) of @c v for which
732 : : * <code>!(v[i] > 3)</code> is true.
733 : : *
734 : : * The not1/unary_negate combination works on predicates taking a single
735 : : * argument. The not2/binary_negate combination works on predicates which
736 : : * take two arguments.
737 : : *
738 : : * @{
739 : : */
740 : : /// One of the @link negators negation functors@endlink.
741 : : template<typename _Predicate>
742 : : class unary_negate
743 : : : public unary_function<typename _Predicate::argument_type, bool>
744 : : {
745 : : protected:
746 : : _Predicate _M_pred;
747 : :
748 : : public:
749 : : _GLIBCXX14_CONSTEXPR
750 : : explicit
751 : : unary_negate(const _Predicate& __x) : _M_pred(__x) { }
752 : :
753 : : _GLIBCXX14_CONSTEXPR
754 : : bool
755 : : operator()(const typename _Predicate::argument_type& __x) const
756 : : { return !_M_pred(__x); }
757 : : };
758 : :
759 : : /// One of the @link negators negation functors@endlink.
760 : : template<typename _Predicate>
761 : : _GLIBCXX14_CONSTEXPR
762 : : inline unary_negate<_Predicate>
763 : : not1(const _Predicate& __pred)
764 : : { return unary_negate<_Predicate>(__pred); }
765 : :
766 : : /// One of the @link negators negation functors@endlink.
767 : : template<typename _Predicate>
768 : : class binary_negate
769 : : : public binary_function<typename _Predicate::first_argument_type,
770 : : typename _Predicate::second_argument_type, bool>
771 : : {
772 : : protected:
773 : : _Predicate _M_pred;
774 : :
775 : : public:
776 : : _GLIBCXX14_CONSTEXPR
777 : : explicit
778 : : binary_negate(const _Predicate& __x) : _M_pred(__x) { }
779 : :
780 : : _GLIBCXX14_CONSTEXPR
781 : : bool
782 : : operator()(const typename _Predicate::first_argument_type& __x,
783 : : const typename _Predicate::second_argument_type& __y) const
784 : : { return !_M_pred(__x, __y); }
785 : : };
786 : :
787 : : /// One of the @link negators negation functors@endlink.
788 : : template<typename _Predicate>
789 : : _GLIBCXX14_CONSTEXPR
790 : : inline binary_negate<_Predicate>
791 : : not2(const _Predicate& __pred)
792 : : { return binary_negate<_Predicate>(__pred); }
793 : : /** @} */
794 : :
795 : : // 20.3.7 adaptors pointers functions
796 : : /** @defgroup pointer_adaptors Adaptors for pointers to functions
797 : : * @ingroup functors
798 : : *
799 : : * The advantage of function objects over pointers to functions is that
800 : : * the objects in the standard library declare nested typedefs describing
801 : : * their argument and result types with uniform names (e.g., @c result_type
802 : : * from the base classes @c unary_function and @c binary_function).
803 : : * Sometimes those typedefs are required, not just optional.
804 : : *
805 : : * Adaptors are provided to turn pointers to unary (single-argument) and
806 : : * binary (double-argument) functions into function objects. The
807 : : * long-winded functor @c pointer_to_unary_function is constructed with a
808 : : * function pointer @c f, and its @c operator() called with argument @c x
809 : : * returns @c f(x). The functor @c pointer_to_binary_function does the same
810 : : * thing, but with a double-argument @c f and @c operator().
811 : : *
812 : : * The function @c ptr_fun takes a pointer-to-function @c f and constructs
813 : : * an instance of the appropriate functor.
814 : : *
815 : : * @{
816 : : */
817 : : /// One of the @link pointer_adaptors adaptors for function pointers@endlink.
818 : : template<typename _Arg, typename _Result>
819 : : class pointer_to_unary_function : public unary_function<_Arg, _Result>
820 : : {
821 : : protected:
822 : : _Result (*_M_ptr)(_Arg);
823 : :
824 : : public:
825 : : pointer_to_unary_function() { }
826 : :
827 : : explicit
828 : : pointer_to_unary_function(_Result (*__x)(_Arg))
829 : : : _M_ptr(__x) { }
830 : :
831 : : _Result
832 : : operator()(_Arg __x) const
833 : : { return _M_ptr(__x); }
834 : : };
835 : :
836 : : /// One of the @link pointer_adaptors adaptors for function pointers@endlink.
837 : : template<typename _Arg, typename _Result>
838 : : inline pointer_to_unary_function<_Arg, _Result>
839 : : ptr_fun(_Result (*__x)(_Arg))
840 : : { return pointer_to_unary_function<_Arg, _Result>(__x); }
841 : :
842 : : /// One of the @link pointer_adaptors adaptors for function pointers@endlink.
843 : : template<typename _Arg1, typename _Arg2, typename _Result>
844 : : class pointer_to_binary_function
845 : : : public binary_function<_Arg1, _Arg2, _Result>
846 : : {
847 : : protected:
848 : : _Result (*_M_ptr)(_Arg1, _Arg2);
849 : :
850 : : public:
851 : : pointer_to_binary_function() { }
852 : :
853 : : explicit
854 : : pointer_to_binary_function(_Result (*__x)(_Arg1, _Arg2))
855 : : : _M_ptr(__x) { }
856 : :
857 : : _Result
858 : : operator()(_Arg1 __x, _Arg2 __y) const
859 : : { return _M_ptr(__x, __y); }
860 : : };
861 : :
862 : : /// One of the @link pointer_adaptors adaptors for function pointers@endlink.
863 : : template<typename _Arg1, typename _Arg2, typename _Result>
864 : : inline pointer_to_binary_function<_Arg1, _Arg2, _Result>
865 : : ptr_fun(_Result (*__x)(_Arg1, _Arg2))
866 : : { return pointer_to_binary_function<_Arg1, _Arg2, _Result>(__x); }
867 : : /** @} */
868 : :
869 : : template<typename _Tp>
870 : : struct _Identity
871 : : : public unary_function<_Tp,_Tp>
872 : : {
873 : : _Tp&
874 : : operator()(_Tp& __x) const
875 : : { return __x; }
876 : :
877 : : const _Tp&
878 : : operator()(const _Tp& __x) const
879 : : { return __x; }
880 : : };
881 : :
882 : : template<typename _Pair>
883 : : struct _Select1st
884 : : : public unary_function<_Pair, typename _Pair::first_type>
885 : : {
886 : : typename _Pair::first_type&
887 : : operator()(_Pair& __x) const
888 : 0 : { return __x.first; }
889 : :
890 : : const typename _Pair::first_type&
891 : : operator()(const _Pair& __x) const
892 : : { return __x.first; }
893 : :
894 : : #if __cplusplus >= 201103L
895 : : template<typename _Pair2>
896 : : typename _Pair2::first_type&
897 : : operator()(_Pair2& __x) const
898 : : { return __x.first; }
899 : :
900 : : template<typename _Pair2>
901 : : const typename _Pair2::first_type&
902 : : operator()(const _Pair2& __x) const
903 : : { return __x.first; }
904 : : #endif
905 : : };
906 : :
907 : : template<typename _Pair>
908 : : struct _Select2nd
909 : : : public unary_function<_Pair, typename _Pair::second_type>
910 : : {
911 : : typename _Pair::second_type&
912 : : operator()(_Pair& __x) const
913 : : { return __x.second; }
914 : :
915 : : const typename _Pair::second_type&
916 : : operator()(const _Pair& __x) const
917 : : { return __x.second; }
918 : : };
919 : :
920 : : // 20.3.8 adaptors pointers members
921 : : /** @defgroup memory_adaptors Adaptors for pointers to members
922 : : * @ingroup functors
923 : : *
924 : : * There are a total of 8 = 2^3 function objects in this family.
925 : : * (1) Member functions taking no arguments vs member functions taking
926 : : * one argument.
927 : : * (2) Call through pointer vs call through reference.
928 : : * (3) Const vs non-const member function.
929 : : *
930 : : * All of this complexity is in the function objects themselves. You can
931 : : * ignore it by using the helper function mem_fun and mem_fun_ref,
932 : : * which create whichever type of adaptor is appropriate.
933 : : *
934 : : * @{
935 : : */
936 : : /// One of the @link memory_adaptors adaptors for member
937 : : /// pointers@endlink.
938 : : template<typename _Ret, typename _Tp>
939 : : class mem_fun_t : public unary_function<_Tp*, _Ret>
940 : : {
941 : : public:
942 : : explicit
943 : : mem_fun_t(_Ret (_Tp::*__pf)())
944 : : : _M_f(__pf) { }
945 : :
946 : : _Ret
947 : : operator()(_Tp* __p) const
948 : : { return (__p->*_M_f)(); }
949 : :
950 : : private:
951 : : _Ret (_Tp::*_M_f)();
952 : : };
953 : :
954 : : /// One of the @link memory_adaptors adaptors for member
955 : : /// pointers@endlink.
956 : : template<typename _Ret, typename _Tp>
957 : : class const_mem_fun_t : public unary_function<const _Tp*, _Ret>
958 : : {
959 : : public:
960 : : explicit
961 : : const_mem_fun_t(_Ret (_Tp::*__pf)() const)
962 : : : _M_f(__pf) { }
963 : :
964 : : _Ret
965 : : operator()(const _Tp* __p) const
966 : : { return (__p->*_M_f)(); }
967 : :
968 : : private:
969 : : _Ret (_Tp::*_M_f)() const;
970 : : };
971 : :
972 : : /// One of the @link memory_adaptors adaptors for member
973 : : /// pointers@endlink.
974 : : template<typename _Ret, typename _Tp>
975 : : class mem_fun_ref_t : public unary_function<_Tp, _Ret>
976 : : {
977 : : public:
978 : : explicit
979 : : mem_fun_ref_t(_Ret (_Tp::*__pf)())
980 : : : _M_f(__pf) { }
981 : :
982 : : _Ret
983 : : operator()(_Tp& __r) const
984 : : { return (__r.*_M_f)(); }
985 : :
986 : : private:
987 : : _Ret (_Tp::*_M_f)();
988 : : };
989 : :
990 : : /// One of the @link memory_adaptors adaptors for member
991 : : /// pointers@endlink.
992 : : template<typename _Ret, typename _Tp>
993 : : class const_mem_fun_ref_t : public unary_function<_Tp, _Ret>
994 : : {
995 : : public:
996 : : explicit
997 : : const_mem_fun_ref_t(_Ret (_Tp::*__pf)() const)
998 : : : _M_f(__pf) { }
999 : :
1000 : : _Ret
1001 : : operator()(const _Tp& __r) const
1002 : : { return (__r.*_M_f)(); }
1003 : :
1004 : : private:
1005 : : _Ret (_Tp::*_M_f)() const;
1006 : : };
1007 : :
1008 : : /// One of the @link memory_adaptors adaptors for member
1009 : : /// pointers@endlink.
1010 : : template<typename _Ret, typename _Tp, typename _Arg>
1011 : : class mem_fun1_t : public binary_function<_Tp*, _Arg, _Ret>
1012 : : {
1013 : : public:
1014 : : explicit
1015 : : mem_fun1_t(_Ret (_Tp::*__pf)(_Arg))
1016 : : : _M_f(__pf) { }
1017 : :
1018 : : _Ret
1019 : : operator()(_Tp* __p, _Arg __x) const
1020 : : { return (__p->*_M_f)(__x); }
1021 : :
1022 : : private:
1023 : : _Ret (_Tp::*_M_f)(_Arg);
1024 : : };
1025 : :
1026 : : /// One of the @link memory_adaptors adaptors for member
1027 : : /// pointers@endlink.
1028 : : template<typename _Ret, typename _Tp, typename _Arg>
1029 : : class const_mem_fun1_t : public binary_function<const _Tp*, _Arg, _Ret>
1030 : : {
1031 : : public:
1032 : : explicit
1033 : : const_mem_fun1_t(_Ret (_Tp::*__pf)(_Arg) const)
1034 : : : _M_f(__pf) { }
1035 : :
1036 : : _Ret
1037 : : operator()(const _Tp* __p, _Arg __x) const
1038 : : { return (__p->*_M_f)(__x); }
1039 : :
1040 : : private:
1041 : : _Ret (_Tp::*_M_f)(_Arg) const;
1042 : : };
1043 : :
1044 : : /// One of the @link memory_adaptors adaptors for member
1045 : : /// pointers@endlink.
1046 : : template<typename _Ret, typename _Tp, typename _Arg>
1047 : : class mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret>
1048 : : {
1049 : : public:
1050 : : explicit
1051 : : mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg))
1052 : : : _M_f(__pf) { }
1053 : :
1054 : : _Ret
1055 : : operator()(_Tp& __r, _Arg __x) const
1056 : : { return (__r.*_M_f)(__x); }
1057 : :
1058 : : private:
1059 : : _Ret (_Tp::*_M_f)(_Arg);
1060 : : };
1061 : :
1062 : : /// One of the @link memory_adaptors adaptors for member
1063 : : /// pointers@endlink.
1064 : : template<typename _Ret, typename _Tp, typename _Arg>
1065 : : class const_mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret>
1066 : : {
1067 : : public:
1068 : : explicit
1069 : : const_mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg) const)
1070 : : : _M_f(__pf) { }
1071 : :
1072 : : _Ret
1073 : : operator()(const _Tp& __r, _Arg __x) const
1074 : : { return (__r.*_M_f)(__x); }
1075 : :
1076 : : private:
1077 : : _Ret (_Tp::*_M_f)(_Arg) const;
1078 : : };
1079 : :
1080 : : // Mem_fun adaptor helper functions. There are only two:
1081 : : // mem_fun and mem_fun_ref.
1082 : : template<typename _Ret, typename _Tp>
1083 : : inline mem_fun_t<_Ret, _Tp>
1084 : : mem_fun(_Ret (_Tp::*__f)())
1085 : : { return mem_fun_t<_Ret, _Tp>(__f); }
1086 : :
1087 : : template<typename _Ret, typename _Tp>
1088 : : inline const_mem_fun_t<_Ret, _Tp>
1089 : : mem_fun(_Ret (_Tp::*__f)() const)
1090 : : { return const_mem_fun_t<_Ret, _Tp>(__f); }
1091 : :
1092 : : template<typename _Ret, typename _Tp>
1093 : : inline mem_fun_ref_t<_Ret, _Tp>
1094 : : mem_fun_ref(_Ret (_Tp::*__f)())
1095 : : { return mem_fun_ref_t<_Ret, _Tp>(__f); }
1096 : :
1097 : : template<typename _Ret, typename _Tp>
1098 : : inline const_mem_fun_ref_t<_Ret, _Tp>
1099 : : mem_fun_ref(_Ret (_Tp::*__f)() const)
1100 : : { return const_mem_fun_ref_t<_Ret, _Tp>(__f); }
1101 : :
1102 : : template<typename _Ret, typename _Tp, typename _Arg>
1103 : : inline mem_fun1_t<_Ret, _Tp, _Arg>
1104 : : mem_fun(_Ret (_Tp::*__f)(_Arg))
1105 : : { return mem_fun1_t<_Ret, _Tp, _Arg>(__f); }
1106 : :
1107 : : template<typename _Ret, typename _Tp, typename _Arg>
1108 : : inline const_mem_fun1_t<_Ret, _Tp, _Arg>
1109 : : mem_fun(_Ret (_Tp::*__f)(_Arg) const)
1110 : : { return const_mem_fun1_t<_Ret, _Tp, _Arg>(__f); }
1111 : :
1112 : : template<typename _Ret, typename _Tp, typename _Arg>
1113 : : inline mem_fun1_ref_t<_Ret, _Tp, _Arg>
1114 : : mem_fun_ref(_Ret (_Tp::*__f)(_Arg))
1115 : : { return mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); }
1116 : :
1117 : : template<typename _Ret, typename _Tp, typename _Arg>
1118 : : inline const_mem_fun1_ref_t<_Ret, _Tp, _Arg>
1119 : : mem_fun_ref(_Ret (_Tp::*__f)(_Arg) const)
1120 : : { return const_mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); }
1121 : :
1122 : : /** @} */
1123 : :
1124 : : _GLIBCXX_END_NAMESPACE_VERSION
1125 : : } // namespace
1126 : :
1127 : : #if (__cplusplus < 201103L) || _GLIBCXX_USE_DEPRECATED
1128 : : # include <backward/binders.h>
1129 : : #endif
1130 : :
1131 : : #endif /* _STL_FUNCTION_H */
|
