1 | // Functor implementations -*- C++ -*- |
2 | |
3 | // Copyright (C) 2001-2017 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 201510 |
228 | |
229 | template<> |
230 | struct plus<void> |
231 | { |
232 | template <typename _Tp, typename _Up> |
233 | _GLIBCXX14_CONSTEXPR |
234 | auto |
235 | operator()(_Tp&& __t, _Up&& __u) const |
236 | noexcept(noexcept(std::forward<_Tp>(__t) + std::forward<_Up>(__u))) |
237 | -> decltype(std::forward<_Tp>(__t) + std::forward<_Up>(__u)) |
238 | { return std::forward<_Tp>(__t) + std::forward<_Up>(__u); } |
239 | |
240 | typedef __is_transparent is_transparent; |
241 | }; |
242 | |
243 | /// One of the @link arithmetic_functors math functors@endlink. |
244 | template<> |
245 | struct minus<void> |
246 | { |
247 | template <typename _Tp, typename _Up> |
248 | _GLIBCXX14_CONSTEXPR |
249 | auto |
250 | operator()(_Tp&& __t, _Up&& __u) const |
251 | noexcept(noexcept(std::forward<_Tp>(__t) - std::forward<_Up>(__u))) |
252 | -> decltype(std::forward<_Tp>(__t) - std::forward<_Up>(__u)) |
253 | { return std::forward<_Tp>(__t) - std::forward<_Up>(__u); } |
254 | |
255 | typedef __is_transparent is_transparent; |
256 | }; |
257 | |
258 | /// One of the @link arithmetic_functors math functors@endlink. |
259 | template<> |
260 | struct multiplies<void> |
261 | { |
262 | template <typename _Tp, typename _Up> |
263 | _GLIBCXX14_CONSTEXPR |
264 | auto |
265 | operator()(_Tp&& __t, _Up&& __u) const |
266 | noexcept(noexcept(std::forward<_Tp>(__t) * std::forward<_Up>(__u))) |
267 | -> decltype(std::forward<_Tp>(__t) * std::forward<_Up>(__u)) |
268 | { return std::forward<_Tp>(__t) * std::forward<_Up>(__u); } |
269 | |
270 | typedef __is_transparent is_transparent; |
271 | }; |
272 | |
273 | /// One of the @link arithmetic_functors math functors@endlink. |
274 | template<> |
275 | struct divides<void> |
276 | { |
277 | template <typename _Tp, typename _Up> |
278 | _GLIBCXX14_CONSTEXPR |
279 | auto |
280 | operator()(_Tp&& __t, _Up&& __u) const |
281 | noexcept(noexcept(std::forward<_Tp>(__t) / std::forward<_Up>(__u))) |
282 | -> decltype(std::forward<_Tp>(__t) / std::forward<_Up>(__u)) |
283 | { return std::forward<_Tp>(__t) / std::forward<_Up>(__u); } |
284 | |
285 | typedef __is_transparent is_transparent; |
286 | }; |
287 | |
288 | /// One of the @link arithmetic_functors math functors@endlink. |
289 | template<> |
290 | struct modulus<void> |
291 | { |
292 | template <typename _Tp, typename _Up> |
293 | _GLIBCXX14_CONSTEXPR |
294 | auto |
295 | operator()(_Tp&& __t, _Up&& __u) const |
296 | noexcept(noexcept(std::forward<_Tp>(__t) % std::forward<_Up>(__u))) |
297 | -> decltype(std::forward<_Tp>(__t) % std::forward<_Up>(__u)) |
298 | { return std::forward<_Tp>(__t) % std::forward<_Up>(__u); } |
299 | |
300 | typedef __is_transparent is_transparent; |
301 | }; |
302 | |
303 | /// One of the @link arithmetic_functors math functors@endlink. |
304 | template<> |
305 | struct negate<void> |
306 | { |
307 | template <typename _Tp> |
308 | _GLIBCXX14_CONSTEXPR |
309 | auto |
310 | operator()(_Tp&& __t) const |
311 | noexcept(noexcept(-std::forward<_Tp>(__t))) |
312 | -> decltype(-std::forward<_Tp>(__t)) |
313 | { return -std::forward<_Tp>(__t); } |
314 | |
315 | typedef __is_transparent is_transparent; |
316 | }; |
317 | #endif |
318 | /** @} */ |
319 | |
320 | // 20.3.3 comparisons |
321 | /** @defgroup comparison_functors Comparison Classes |
322 | * @ingroup functors |
323 | * |
324 | * The library provides six wrapper functors for all the basic comparisons |
325 | * in C++, like @c <. |
326 | * |
327 | * @{ |
328 | */ |
329 | #if __cplusplus > 201103L |
330 | template<typename _Tp = void> |
331 | struct equal_to; |
332 | |
333 | template<typename _Tp = void> |
334 | struct not_equal_to; |
335 | |
336 | template<typename _Tp = void> |
337 | struct greater; |
338 | |
339 | template<typename _Tp = void> |
340 | struct less; |
341 | |
342 | template<typename _Tp = void> |
343 | struct greater_equal; |
344 | |
345 | template<typename _Tp = void> |
346 | struct less_equal; |
347 | #endif |
348 | |
349 | /// One of the @link comparison_functors comparison functors@endlink. |
350 | template<typename _Tp> |
351 | struct equal_to : public binary_function<_Tp, _Tp, bool> |
352 | { |
353 | _GLIBCXX14_CONSTEXPR |
354 | bool |
355 | operator()(const _Tp& __x, const _Tp& __y) const |
356 | { return __x == __y; } |
357 | }; |
358 | |
359 | /// One of the @link comparison_functors comparison functors@endlink. |
360 | template<typename _Tp> |
361 | struct not_equal_to : public binary_function<_Tp, _Tp, bool> |
362 | { |
363 | _GLIBCXX14_CONSTEXPR |
364 | bool |
365 | operator()(const _Tp& __x, const _Tp& __y) const |
366 | { return __x != __y; } |
367 | }; |
368 | |
369 | /// One of the @link comparison_functors comparison functors@endlink. |
370 | template<typename _Tp> |
371 | struct greater : public binary_function<_Tp, _Tp, bool> |
372 | { |
373 | _GLIBCXX14_CONSTEXPR |
374 | bool |
375 | operator()(const _Tp& __x, const _Tp& __y) const |
376 | { return __x > __y; } |
377 | }; |
378 | |
379 | /// One of the @link comparison_functors comparison functors@endlink. |
380 | template<typename _Tp> |
381 | struct less : public binary_function<_Tp, _Tp, bool> |
382 | { |
383 | _GLIBCXX14_CONSTEXPR |
384 | bool |
385 | operator()(const _Tp& __x, const _Tp& __y) const |
386 | { return __x < __y; } |
387 | }; |
388 | |
389 | /// One of the @link comparison_functors comparison functors@endlink. |
390 | template<typename _Tp> |
391 | struct greater_equal : public binary_function<_Tp, _Tp, bool> |
392 | { |
393 | _GLIBCXX14_CONSTEXPR |
394 | bool |
395 | operator()(const _Tp& __x, const _Tp& __y) const |
396 | { return __x >= __y; } |
397 | }; |
398 | |
399 | /// One of the @link comparison_functors comparison functors@endlink. |
400 | template<typename _Tp> |
401 | struct less_equal : public binary_function<_Tp, _Tp, bool> |
402 | { |
403 | _GLIBCXX14_CONSTEXPR |
404 | bool |
405 | operator()(const _Tp& __x, const _Tp& __y) const |
406 | { return __x <= __y; } |
407 | }; |
408 | |
409 | #if __cplusplus > 201103L |
410 | /// One of the @link comparison_functors comparison functors@endlink. |
411 | template<> |
412 | struct equal_to<void> |
413 | { |
414 | template <typename _Tp, typename _Up> |
415 | _GLIBCXX14_CONSTEXPR |
416 | auto |
417 | operator()(_Tp&& __t, _Up&& __u) const |
418 | noexcept(noexcept(std::forward<_Tp>(__t) == std::forward<_Up>(__u))) |
419 | -> decltype(std::forward<_Tp>(__t) == std::forward<_Up>(__u)) |
420 | { return std::forward<_Tp>(__t) == std::forward<_Up>(__u); } |
421 | |
422 | typedef __is_transparent is_transparent; |
423 | }; |
424 | |
425 | /// One of the @link comparison_functors comparison functors@endlink. |
426 | template<> |
427 | struct not_equal_to<void> |
428 | { |
429 | template <typename _Tp, typename _Up> |
430 | _GLIBCXX14_CONSTEXPR |
431 | auto |
432 | operator()(_Tp&& __t, _Up&& __u) const |
433 | noexcept(noexcept(std::forward<_Tp>(__t) != std::forward<_Up>(__u))) |
434 | -> decltype(std::forward<_Tp>(__t) != std::forward<_Up>(__u)) |
435 | { return std::forward<_Tp>(__t) != std::forward<_Up>(__u); } |
436 | |
437 | typedef __is_transparent is_transparent; |
438 | }; |
439 | |
440 | /// One of the @link comparison_functors comparison functors@endlink. |
441 | template<> |
442 | struct greater<void> |
443 | { |
444 | template <typename _Tp, typename _Up> |
445 | _GLIBCXX14_CONSTEXPR |
446 | auto |
447 | operator()(_Tp&& __t, _Up&& __u) const |
448 | noexcept(noexcept(std::forward<_Tp>(__t) > std::forward<_Up>(__u))) |
449 | -> decltype(std::forward<_Tp>(__t) > std::forward<_Up>(__u)) |
450 | { return std::forward<_Tp>(__t) > std::forward<_Up>(__u); } |
451 | |
452 | typedef __is_transparent is_transparent; |
453 | }; |
454 | |
455 | /// One of the @link comparison_functors comparison functors@endlink. |
456 | template<> |
457 | struct less<void> |
458 | { |
459 | template <typename _Tp, typename _Up> |
460 | _GLIBCXX14_CONSTEXPR |
461 | auto |
462 | operator()(_Tp&& __t, _Up&& __u) const |
463 | noexcept(noexcept(std::forward<_Tp>(__t) < std::forward<_Up>(__u))) |
464 | -> decltype(std::forward<_Tp>(__t) < std::forward<_Up>(__u)) |
465 | { return std::forward<_Tp>(__t) < std::forward<_Up>(__u); } |
466 | |
467 | typedef __is_transparent is_transparent; |
468 | }; |
469 | |
470 | /// One of the @link comparison_functors comparison functors@endlink. |
471 | template<> |
472 | struct greater_equal<void> |
473 | { |
474 | template <typename _Tp, typename _Up> |
475 | _GLIBCXX14_CONSTEXPR |
476 | auto |
477 | operator()(_Tp&& __t, _Up&& __u) const |
478 | noexcept(noexcept(std::forward<_Tp>(__t) >= std::forward<_Up>(__u))) |
479 | -> decltype(std::forward<_Tp>(__t) >= std::forward<_Up>(__u)) |
480 | { return std::forward<_Tp>(__t) >= std::forward<_Up>(__u); } |
481 | |
482 | typedef __is_transparent is_transparent; |
483 | }; |
484 | |
485 | /// One of the @link comparison_functors comparison functors@endlink. |
486 | template<> |
487 | struct less_equal<void> |
488 | { |
489 | template <typename _Tp, typename _Up> |
490 | _GLIBCXX14_CONSTEXPR |
491 | auto |
492 | operator()(_Tp&& __t, _Up&& __u) const |
493 | noexcept(noexcept(std::forward<_Tp>(__t) <= std::forward<_Up>(__u))) |
494 | -> decltype(std::forward<_Tp>(__t) <= std::forward<_Up>(__u)) |
495 | { return std::forward<_Tp>(__t) <= std::forward<_Up>(__u); } |
496 | |
497 | typedef __is_transparent is_transparent; |
498 | }; |
499 | #endif |
500 | /** @} */ |
501 | |
502 | // 20.3.4 logical operations |
503 | /** @defgroup logical_functors Boolean Operations Classes |
504 | * @ingroup functors |
505 | * |
506 | * Here are wrapper functors for Boolean operations: @c &&, @c ||, |
507 | * and @c !. |
508 | * |
509 | * @{ |
510 | */ |
511 | #if __cplusplus > 201103L |
512 | template<typename _Tp = void> |
513 | struct logical_and; |
514 | |
515 | template<typename _Tp = void> |
516 | struct logical_or; |
517 | |
518 | template<typename _Tp = void> |
519 | struct logical_not; |
520 | #endif |
521 | |
522 | /// One of the @link logical_functors Boolean operations functors@endlink. |
523 | template<typename _Tp> |
524 | struct logical_and : public binary_function<_Tp, _Tp, bool> |
525 | { |
526 | _GLIBCXX14_CONSTEXPR |
527 | bool |
528 | operator()(const _Tp& __x, const _Tp& __y) const |
529 | { return __x && __y; } |
530 | }; |
531 | |
532 | /// One of the @link logical_functors Boolean operations functors@endlink. |
533 | template<typename _Tp> |
534 | struct logical_or : public binary_function<_Tp, _Tp, bool> |
535 | { |
536 | _GLIBCXX14_CONSTEXPR |
537 | bool |
538 | operator()(const _Tp& __x, const _Tp& __y) const |
539 | { return __x || __y; } |
540 | }; |
541 | |
542 | /// One of the @link logical_functors Boolean operations functors@endlink. |
543 | template<typename _Tp> |
544 | struct logical_not : public unary_function<_Tp, bool> |
545 | { |
546 | _GLIBCXX14_CONSTEXPR |
547 | bool |
548 | operator()(const _Tp& __x) const |
549 | { return !__x; } |
550 | }; |
551 | |
552 | #if __cplusplus > 201103L |
553 | /// One of the @link logical_functors Boolean operations functors@endlink. |
554 | template<> |
555 | struct logical_and<void> |
556 | { |
557 | template <typename _Tp, typename _Up> |
558 | _GLIBCXX14_CONSTEXPR |
559 | auto |
560 | operator()(_Tp&& __t, _Up&& __u) const |
561 | noexcept(noexcept(std::forward<_Tp>(__t) && std::forward<_Up>(__u))) |
562 | -> decltype(std::forward<_Tp>(__t) && std::forward<_Up>(__u)) |
563 | { return std::forward<_Tp>(__t) && std::forward<_Up>(__u); } |
564 | |
565 | typedef __is_transparent is_transparent; |
566 | }; |
567 | |
568 | /// One of the @link logical_functors Boolean operations functors@endlink. |
569 | template<> |
570 | struct logical_or<void> |
571 | { |
572 | template <typename _Tp, typename _Up> |
573 | _GLIBCXX14_CONSTEXPR |
574 | auto |
575 | operator()(_Tp&& __t, _Up&& __u) const |
576 | noexcept(noexcept(std::forward<_Tp>(__t) || std::forward<_Up>(__u))) |
577 | -> decltype(std::forward<_Tp>(__t) || std::forward<_Up>(__u)) |
578 | { return std::forward<_Tp>(__t) || std::forward<_Up>(__u); } |
579 | |
580 | typedef __is_transparent is_transparent; |
581 | }; |
582 | |
583 | /// One of the @link logical_functors Boolean operations functors@endlink. |
584 | template<> |
585 | struct logical_not<void> |
586 | { |
587 | template <typename _Tp> |
588 | _GLIBCXX14_CONSTEXPR |
589 | auto |
590 | operator()(_Tp&& __t) const |
591 | noexcept(noexcept(!std::forward<_Tp>(__t))) |
592 | -> decltype(!std::forward<_Tp>(__t)) |
593 | { return !std::forward<_Tp>(__t); } |
594 | |
595 | typedef __is_transparent is_transparent; |
596 | }; |
597 | #endif |
598 | /** @} */ |
599 | |
600 | #if __cplusplus > 201103L |
601 | template<typename _Tp = void> |
602 | struct bit_and; |
603 | |
604 | template<typename _Tp = void> |
605 | struct bit_or; |
606 | |
607 | template<typename _Tp = void> |
608 | struct bit_xor; |
609 | |
610 | template<typename _Tp = void> |
611 | struct bit_not; |
612 | #endif |
613 | |
614 | // _GLIBCXX_RESOLVE_LIB_DEFECTS |
615 | // DR 660. Missing Bitwise Operations. |
616 | template<typename _Tp> |
617 | struct bit_and : public binary_function<_Tp, _Tp, _Tp> |
618 | { |
619 | _GLIBCXX14_CONSTEXPR |
620 | _Tp |
621 | operator()(const _Tp& __x, const _Tp& __y) const |
622 | { return __x & __y; } |
623 | }; |
624 | |
625 | template<typename _Tp> |
626 | struct bit_or : public binary_function<_Tp, _Tp, _Tp> |
627 | { |
628 | _GLIBCXX14_CONSTEXPR |
629 | _Tp |
630 | operator()(const _Tp& __x, const _Tp& __y) const |
631 | { return __x | __y; } |
632 | }; |
633 | |
634 | template<typename _Tp> |
635 | struct bit_xor : public binary_function<_Tp, _Tp, _Tp> |
636 | { |
637 | _GLIBCXX14_CONSTEXPR |
638 | _Tp |
639 | operator()(const _Tp& __x, const _Tp& __y) const |
640 | { return __x ^ __y; } |
641 | }; |
642 | |
643 | template<typename _Tp> |
644 | struct bit_not : public unary_function<_Tp, _Tp> |
645 | { |
646 | _GLIBCXX14_CONSTEXPR |
647 | _Tp |
648 | operator()(const _Tp& __x) const |
649 | { return ~__x; } |
650 | }; |
651 | |
652 | #if __cplusplus > 201103L |
653 | template <> |
654 | struct bit_and<void> |
655 | { |
656 | template <typename _Tp, typename _Up> |
657 | _GLIBCXX14_CONSTEXPR |
658 | auto |
659 | operator()(_Tp&& __t, _Up&& __u) const |
660 | noexcept(noexcept(std::forward<_Tp>(__t) & std::forward<_Up>(__u))) |
661 | -> decltype(std::forward<_Tp>(__t) & std::forward<_Up>(__u)) |
662 | { return std::forward<_Tp>(__t) & std::forward<_Up>(__u); } |
663 | |
664 | typedef __is_transparent is_transparent; |
665 | }; |
666 | |
667 | template <> |
668 | struct bit_or<void> |
669 | { |
670 | template <typename _Tp, typename _Up> |
671 | _GLIBCXX14_CONSTEXPR |
672 | auto |
673 | operator()(_Tp&& __t, _Up&& __u) const |
674 | noexcept(noexcept(std::forward<_Tp>(__t) | std::forward<_Up>(__u))) |
675 | -> decltype(std::forward<_Tp>(__t) | std::forward<_Up>(__u)) |
676 | { return std::forward<_Tp>(__t) | std::forward<_Up>(__u); } |
677 | |
678 | typedef __is_transparent is_transparent; |
679 | }; |
680 | |
681 | template <> |
682 | struct bit_xor<void> |
683 | { |
684 | template <typename _Tp, typename _Up> |
685 | _GLIBCXX14_CONSTEXPR |
686 | auto |
687 | operator()(_Tp&& __t, _Up&& __u) const |
688 | noexcept(noexcept(std::forward<_Tp>(__t) ^ std::forward<_Up>(__u))) |
689 | -> decltype(std::forward<_Tp>(__t) ^ std::forward<_Up>(__u)) |
690 | { return std::forward<_Tp>(__t) ^ std::forward<_Up>(__u); } |
691 | |
692 | typedef __is_transparent is_transparent; |
693 | }; |
694 | |
695 | template <> |
696 | struct bit_not<void> |
697 | { |
698 | template <typename _Tp> |
699 | _GLIBCXX14_CONSTEXPR |
700 | auto |
701 | operator()(_Tp&& __t) const |
702 | noexcept(noexcept(~std::forward<_Tp>(__t))) |
703 | -> decltype(~std::forward<_Tp>(__t)) |
704 | { return ~std::forward<_Tp>(__t); } |
705 | |
706 | typedef __is_transparent is_transparent; |
707 | }; |
708 | #endif |
709 | |
710 | // 20.3.5 negators |
711 | /** @defgroup negators Negators |
712 | * @ingroup functors |
713 | * |
714 | * The functions @c not1 and @c not2 each take a predicate functor |
715 | * and return an instance of @c unary_negate or |
716 | * @c binary_negate, respectively. These classes are functors whose |
717 | * @c operator() performs the stored predicate function and then returns |
718 | * the negation of the result. |
719 | * |
720 | * For example, given a vector of integers and a trivial predicate, |
721 | * \code |
722 | * struct IntGreaterThanThree |
723 | * : public std::unary_function<int, bool> |
724 | * { |
725 | * bool operator() (int x) { return x > 3; } |
726 | * }; |
727 | * |
728 | * std::find_if (v.begin(), v.end(), not1(IntGreaterThanThree())); |
729 | * \endcode |
730 | * The call to @c find_if will locate the first index (i) of @c v for which |
731 | * <code>!(v[i] > 3)</code> is true. |
732 | * |
733 | * The not1/unary_negate combination works on predicates taking a single |
734 | * argument. The not2/binary_negate combination works on predicates which |
735 | * take two arguments. |
736 | * |
737 | * @{ |
738 | */ |
739 | /// One of the @link negators negation functors@endlink. |
740 | template<typename _Predicate> |
741 | class unary_negate |
742 | : public unary_function<typename _Predicate::argument_type, bool> |
743 | { |
744 | protected: |
745 | _Predicate _M_pred; |
746 | |
747 | public: |
748 | _GLIBCXX14_CONSTEXPR |
749 | explicit |
750 | unary_negate(const _Predicate& __x) : _M_pred(__x) { } |
751 | |
752 | _GLIBCXX14_CONSTEXPR |
753 | bool |
754 | operator()(const typename _Predicate::argument_type& __x) const |
755 | { return !_M_pred(__x); } |
756 | }; |
757 | |
758 | /// One of the @link negators negation functors@endlink. |
759 | template<typename _Predicate> |
760 | _GLIBCXX14_CONSTEXPR |
761 | inline unary_negate<_Predicate> |
762 | not1(const _Predicate& __pred) |
763 | { return unary_negate<_Predicate>(__pred); } |
764 | |
765 | /// One of the @link negators negation functors@endlink. |
766 | template<typename _Predicate> |
767 | class binary_negate |
768 | : public binary_function<typename _Predicate::first_argument_type, |
769 | typename _Predicate::second_argument_type, bool> |
770 | { |
771 | protected: |
772 | _Predicate _M_pred; |
773 | |
774 | public: |
775 | _GLIBCXX14_CONSTEXPR |
776 | explicit |
777 | binary_negate(const _Predicate& __x) : _M_pred(__x) { } |
778 | |
779 | _GLIBCXX14_CONSTEXPR |
780 | bool |
781 | operator()(const typename _Predicate::first_argument_type& __x, |
782 | const typename _Predicate::second_argument_type& __y) const |
783 | { return !_M_pred(__x, __y); } |
784 | }; |
785 | |
786 | /// One of the @link negators negation functors@endlink. |
787 | template<typename _Predicate> |
788 | _GLIBCXX14_CONSTEXPR |
789 | inline binary_negate<_Predicate> |
790 | not2(const _Predicate& __pred) |
791 | { return binary_negate<_Predicate>(__pred); } |
792 | /** @} */ |
793 | |
794 | // 20.3.7 adaptors pointers functions |
795 | /** @defgroup pointer_adaptors Adaptors for pointers to functions |
796 | * @ingroup functors |
797 | * |
798 | * The advantage of function objects over pointers to functions is that |
799 | * the objects in the standard library declare nested typedefs describing |
800 | * their argument and result types with uniform names (e.g., @c result_type |
801 | * from the base classes @c unary_function and @c binary_function). |
802 | * Sometimes those typedefs are required, not just optional. |
803 | * |
804 | * Adaptors are provided to turn pointers to unary (single-argument) and |
805 | * binary (double-argument) functions into function objects. The |
806 | * long-winded functor @c pointer_to_unary_function is constructed with a |
807 | * function pointer @c f, and its @c operator() called with argument @c x |
808 | * returns @c f(x). The functor @c pointer_to_binary_function does the same |
809 | * thing, but with a double-argument @c f and @c operator(). |
810 | * |
811 | * The function @c ptr_fun takes a pointer-to-function @c f and constructs |
812 | * an instance of the appropriate functor. |
813 | * |
814 | * @{ |
815 | */ |
816 | /// One of the @link pointer_adaptors adaptors for function pointers@endlink. |
817 | template<typename _Arg, typename _Result> |
818 | class pointer_to_unary_function : public unary_function<_Arg, _Result> |
819 | { |
820 | protected: |
821 | _Result (*_M_ptr)(_Arg); |
822 | |
823 | public: |
824 | pointer_to_unary_function() { } |
825 | |
826 | explicit |
827 | pointer_to_unary_function(_Result (*__x)(_Arg)) |
828 | : _M_ptr(__x) { } |
829 | |
830 | _Result |
831 | operator()(_Arg __x) const |
832 | { return _M_ptr(__x); } |
833 | }; |
834 | |
835 | /// One of the @link pointer_adaptors adaptors for function pointers@endlink. |
836 | template<typename _Arg, typename _Result> |
837 | inline pointer_to_unary_function<_Arg, _Result> |
838 | ptr_fun(_Result (*__x)(_Arg)) |
839 | { return pointer_to_unary_function<_Arg, _Result>(__x); } |
840 | |
841 | /// One of the @link pointer_adaptors adaptors for function pointers@endlink. |
842 | template<typename _Arg1, typename _Arg2, typename _Result> |
843 | class pointer_to_binary_function |
844 | : public binary_function<_Arg1, _Arg2, _Result> |
845 | { |
846 | protected: |
847 | _Result (*_M_ptr)(_Arg1, _Arg2); |
848 | |
849 | public: |
850 | pointer_to_binary_function() { } |
851 | |
852 | explicit |
853 | pointer_to_binary_function(_Result (*__x)(_Arg1, _Arg2)) |
854 | : _M_ptr(__x) { } |
855 | |
856 | _Result |
857 | operator()(_Arg1 __x, _Arg2 __y) const |
858 | { return _M_ptr(__x, __y); } |
859 | }; |
860 | |
861 | /// One of the @link pointer_adaptors adaptors for function pointers@endlink. |
862 | template<typename _Arg1, typename _Arg2, typename _Result> |
863 | inline pointer_to_binary_function<_Arg1, _Arg2, _Result> |
864 | ptr_fun(_Result (*__x)(_Arg1, _Arg2)) |
865 | { return pointer_to_binary_function<_Arg1, _Arg2, _Result>(__x); } |
866 | /** @} */ |
867 | |
868 | template<typename _Tp> |
869 | struct _Identity |
870 | : public unary_function<_Tp,_Tp> |
871 | { |
872 | _Tp& |
873 | operator()(_Tp& __x) const |
874 | { return __x; } |
875 | |
876 | const _Tp& |
877 | operator()(const _Tp& __x) const |
878 | { return __x; } |
879 | }; |
880 | |
881 | template<typename _Pair> |
882 | struct _Select1st |
883 | : public unary_function<_Pair, typename _Pair::first_type> |
884 | { |
885 | typename _Pair::first_type& |
886 | operator()(_Pair& __x) const |
887 | { return __x.first; } |
888 | |
889 | const typename _Pair::first_type& |
890 | operator()(const _Pair& __x) const |
891 | { return __x.first; } |
892 | |
893 | #if __cplusplus >= 201103L |
894 | template<typename _Pair2> |
895 | typename _Pair2::first_type& |
896 | operator()(_Pair2& __x) const |
897 | { return __x.first; } |
898 | |
899 | template<typename _Pair2> |
900 | const typename _Pair2::first_type& |
901 | operator()(const _Pair2& __x) const |
902 | { return __x.first; } |
903 | #endif |
904 | }; |
905 | |
906 | template<typename _Pair> |
907 | struct _Select2nd |
908 | : public unary_function<_Pair, typename _Pair::second_type> |
909 | { |
910 | typename _Pair::second_type& |
911 | operator()(_Pair& __x) const |
912 | { return __x.second; } |
913 | |
914 | const typename _Pair::second_type& |
915 | operator()(const _Pair& __x) const |
916 | { return __x.second; } |
917 | }; |
918 | |
919 | // 20.3.8 adaptors pointers members |
920 | /** @defgroup memory_adaptors Adaptors for pointers to members |
921 | * @ingroup functors |
922 | * |
923 | * There are a total of 8 = 2^3 function objects in this family. |
924 | * (1) Member functions taking no arguments vs member functions taking |
925 | * one argument. |
926 | * (2) Call through pointer vs call through reference. |
927 | * (3) Const vs non-const member function. |
928 | * |
929 | * All of this complexity is in the function objects themselves. You can |
930 | * ignore it by using the helper function mem_fun and mem_fun_ref, |
931 | * which create whichever type of adaptor is appropriate. |
932 | * |
933 | * @{ |
934 | */ |
935 | /// One of the @link memory_adaptors adaptors for member |
936 | /// pointers@endlink. |
937 | template<typename _Ret, typename _Tp> |
938 | class mem_fun_t : public unary_function<_Tp*, _Ret> |
939 | { |
940 | public: |
941 | explicit |
942 | mem_fun_t(_Ret (_Tp::*__pf)()) |
943 | : _M_f(__pf) { } |
944 | |
945 | _Ret |
946 | operator()(_Tp* __p) const |
947 | { return (__p->*_M_f)(); } |
948 | |
949 | private: |
950 | _Ret (_Tp::*_M_f)(); |
951 | }; |
952 | |
953 | /// One of the @link memory_adaptors adaptors for member |
954 | /// pointers@endlink. |
955 | template<typename _Ret, typename _Tp> |
956 | class const_mem_fun_t : public unary_function<const _Tp*, _Ret> |
957 | { |
958 | public: |
959 | explicit |
960 | const_mem_fun_t(_Ret (_Tp::*__pf)() const) |
961 | : _M_f(__pf) { } |
962 | |
963 | _Ret |
964 | operator()(const _Tp* __p) const |
965 | { return (__p->*_M_f)(); } |
966 | |
967 | private: |
968 | _Ret (_Tp::*_M_f)() const; |
969 | }; |
970 | |
971 | /// One of the @link memory_adaptors adaptors for member |
972 | /// pointers@endlink. |
973 | template<typename _Ret, typename _Tp> |
974 | class mem_fun_ref_t : public unary_function<_Tp, _Ret> |
975 | { |
976 | public: |
977 | explicit |
978 | mem_fun_ref_t(_Ret (_Tp::*__pf)()) |
979 | : _M_f(__pf) { } |
980 | |
981 | _Ret |
982 | operator()(_Tp& __r) const |
983 | { return (__r.*_M_f)(); } |
984 | |
985 | private: |
986 | _Ret (_Tp::*_M_f)(); |
987 | }; |
988 | |
989 | /// One of the @link memory_adaptors adaptors for member |
990 | /// pointers@endlink. |
991 | template<typename _Ret, typename _Tp> |
992 | class const_mem_fun_ref_t : public unary_function<_Tp, _Ret> |
993 | { |
994 | public: |
995 | explicit |
996 | const_mem_fun_ref_t(_Ret (_Tp::*__pf)() const) |
997 | : _M_f(__pf) { } |
998 | |
999 | _Ret |
1000 | operator()(const _Tp& __r) const |
1001 | { return (__r.*_M_f)(); } |
1002 | |
1003 | private: |
1004 | _Ret (_Tp::*_M_f)() const; |
1005 | }; |
1006 | |
1007 | /// One of the @link memory_adaptors adaptors for member |
1008 | /// pointers@endlink. |
1009 | template<typename _Ret, typename _Tp, typename _Arg> |
1010 | class mem_fun1_t : public binary_function<_Tp*, _Arg, _Ret> |
1011 | { |
1012 | public: |
1013 | explicit |
1014 | mem_fun1_t(_Ret (_Tp::*__pf)(_Arg)) |
1015 | : _M_f(__pf) { } |
1016 | |
1017 | _Ret |
1018 | operator()(_Tp* __p, _Arg __x) const |
1019 | { return (__p->*_M_f)(__x); } |
1020 | |
1021 | private: |
1022 | _Ret (_Tp::*_M_f)(_Arg); |
1023 | }; |
1024 | |
1025 | /// One of the @link memory_adaptors adaptors for member |
1026 | /// pointers@endlink. |
1027 | template<typename _Ret, typename _Tp, typename _Arg> |
1028 | class const_mem_fun1_t : public binary_function<const _Tp*, _Arg, _Ret> |
1029 | { |
1030 | public: |
1031 | explicit |
1032 | const_mem_fun1_t(_Ret (_Tp::*__pf)(_Arg) const) |
1033 | : _M_f(__pf) { } |
1034 | |
1035 | _Ret |
1036 | operator()(const _Tp* __p, _Arg __x) const |
1037 | { return (__p->*_M_f)(__x); } |
1038 | |
1039 | private: |
1040 | _Ret (_Tp::*_M_f)(_Arg) const; |
1041 | }; |
1042 | |
1043 | /// One of the @link memory_adaptors adaptors for member |
1044 | /// pointers@endlink. |
1045 | template<typename _Ret, typename _Tp, typename _Arg> |
1046 | class mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret> |
1047 | { |
1048 | public: |
1049 | explicit |
1050 | mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg)) |
1051 | : _M_f(__pf) { } |
1052 | |
1053 | _Ret |
1054 | operator()(_Tp& __r, _Arg __x) const |
1055 | { return (__r.*_M_f)(__x); } |
1056 | |
1057 | private: |
1058 | _Ret (_Tp::*_M_f)(_Arg); |
1059 | }; |
1060 | |
1061 | /// One of the @link memory_adaptors adaptors for member |
1062 | /// pointers@endlink. |
1063 | template<typename _Ret, typename _Tp, typename _Arg> |
1064 | class const_mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret> |
1065 | { |
1066 | public: |
1067 | explicit |
1068 | const_mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg) const) |
1069 | : _M_f(__pf) { } |
1070 | |
1071 | _Ret |
1072 | operator()(const _Tp& __r, _Arg __x) const |
1073 | { return (__r.*_M_f)(__x); } |
1074 | |
1075 | private: |
1076 | _Ret (_Tp::*_M_f)(_Arg) const; |
1077 | }; |
1078 | |
1079 | // Mem_fun adaptor helper functions. There are only two: |
1080 | // mem_fun and mem_fun_ref. |
1081 | template<typename _Ret, typename _Tp> |
1082 | inline mem_fun_t<_Ret, _Tp> |
1083 | mem_fun(_Ret (_Tp::*__f)()) |
1084 | { return mem_fun_t<_Ret, _Tp>(__f); } |
1085 | |
1086 | template<typename _Ret, typename _Tp> |
1087 | inline const_mem_fun_t<_Ret, _Tp> |
1088 | mem_fun(_Ret (_Tp::*__f)() const) |
1089 | { return const_mem_fun_t<_Ret, _Tp>(__f); } |
1090 | |
1091 | template<typename _Ret, typename _Tp> |
1092 | inline mem_fun_ref_t<_Ret, _Tp> |
1093 | mem_fun_ref(_Ret (_Tp::*__f)()) |
1094 | { return mem_fun_ref_t<_Ret, _Tp>(__f); } |
1095 | |
1096 | template<typename _Ret, typename _Tp> |
1097 | inline const_mem_fun_ref_t<_Ret, _Tp> |
1098 | mem_fun_ref(_Ret (_Tp::*__f)() const) |
1099 | { return const_mem_fun_ref_t<_Ret, _Tp>(__f); } |
1100 | |
1101 | template<typename _Ret, typename _Tp, typename _Arg> |
1102 | inline mem_fun1_t<_Ret, _Tp, _Arg> |
1103 | mem_fun(_Ret (_Tp::*__f)(_Arg)) |
1104 | { return mem_fun1_t<_Ret, _Tp, _Arg>(__f); } |
1105 | |
1106 | template<typename _Ret, typename _Tp, typename _Arg> |
1107 | inline const_mem_fun1_t<_Ret, _Tp, _Arg> |
1108 | mem_fun(_Ret (_Tp::*__f)(_Arg) const) |
1109 | { return const_mem_fun1_t<_Ret, _Tp, _Arg>(__f); } |
1110 | |
1111 | template<typename _Ret, typename _Tp, typename _Arg> |
1112 | inline mem_fun1_ref_t<_Ret, _Tp, _Arg> |
1113 | mem_fun_ref(_Ret (_Tp::*__f)(_Arg)) |
1114 | { return mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); } |
1115 | |
1116 | template<typename _Ret, typename _Tp, typename _Arg> |
1117 | inline const_mem_fun1_ref_t<_Ret, _Tp, _Arg> |
1118 | mem_fun_ref(_Ret (_Tp::*__f)(_Arg) const) |
1119 | { return const_mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); } |
1120 | |
1121 | /** @} */ |
1122 | |
1123 | _GLIBCXX_END_NAMESPACE_VERSION |
1124 | } // namespace |
1125 | |
1126 | #if (__cplusplus < 201103L) || _GLIBCXX_USE_DEPRECATED |
1127 | # include <backward/binders.h> |
1128 | #endif |
1129 | |
1130 | #endif /* _STL_FUNCTION_H */ |
1131 | |