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