1 // Functor implementations -*- C++ -*-
2 
3 // Copyright (C) 2001-2016 Free Software Foundation, Inc.
4 //
5 // This file is part of the GNU ISO C++ Library.  This library is free
6 // software; you can redistribute it and/or modify it under the
7 // terms of the GNU General Public License as published by the
8 // Free Software Foundation; either version 3, or (at your option)
9 // any later version.
10 
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14 // GNU General Public License for more details.
15 
16 // Under Section 7 of GPL version 3, you are granted additional
17 // permissions described in the GCC Runtime Library Exception, version
18 // 3.1, as published by the Free Software Foundation.
19 
20 // You should have received a copy of the GNU General Public License and
21 // a copy of the GCC Runtime Library Exception along with this program;
22 // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
23 // <http://www.gnu.org/licenses/>.
24 
25 /*
26  *
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 
_GLIBCXX_VISIBILITY(default)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 
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