stl_function.h source code [include/c++/7/bits/stl

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

std::unary_negate::_M_pred

std::binary_negate::_M_pred

std::pointer_to_unary_function::_M_ptr

std::pointer_to_binary_function::_M_ptr

std::mem_fun_t::_M_f

std::const_mem_fun_t::_M_f

std::mem_fun_ref_t::_M_f

std::const_mem_fun_ref_t::_M_f

std::mem_fun1_t::_M_f

std::const_mem_fun1_t::_M_f

std::mem_fun1_ref_t::_M_f

std::const_mem_fun1_ref_t::_M_f

Clang Project