predefined_ops.h source code [include/c++/7/bits/predefined

1	// Default predicates for internal use -- C++ --
2
3	// Copyright (C) 2013-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	/** @file predefined_ops.h
26	* This is an internal header file, included by other library headers.
27	* You should not attempt to use it directly. @headername{algorithm}
28	*/
29
30	#ifndef _GLIBCXX_PREDEFINED_OPS_H
31	#define _GLIBCXX_PREDEFINED_OPS_H 1
32
33	namespace __gnu_cxx
34	{
35	namespace __ops
36	{
37	struct _Iter_less_iter
38	{
39	template<typename _Iterator1, typename _Iterator2>
40	_GLIBCXX14_CONSTEXPR
41	bool
42	operator()(_Iterator1 __it1, _Iterator2 __it2) const
43	{ return __it1 < __it2; }
44	};
45
46	_GLIBCXX14_CONSTEXPR
47	inline _Iter_less_iter
48	__iter_less_iter()
49	{ return _Iter_less_iter(); }
50
51	struct _Iter_less_val
52	{
53	#if __cplusplus >= 201103L
54	constexpr _Iter_less_val() = default;
55	#else
56	_Iter_less_val() { }
57	#endif
58
59	explicit
60	_Iter_less_val(_Iter_less_iter) { }
61
62	template<typename _Iterator, typename _Value>
63	bool
64	operator()(_Iterator __it, _Value& __val) const
65	{ return *__it < __val; }
66	};
67
68	inline _Iter_less_val
69	__iter_less_val()
70	{ return _Iter_less_val(); }
71
72	inline _Iter_less_val
73	__iter_comp_val(_Iter_less_iter)
74	{ return _Iter_less_val(); }
75
76	struct _Val_less_iter
77	{
78	#if __cplusplus >= 201103L
79	constexpr _Val_less_iter() = default;
80	#else
81	_Val_less_iter() { }
82	#endif
83
84	explicit
85	_Val_less_iter(_Iter_less_iter) { }
86
87	template<typename _Value, typename _Iterator>
88	bool
89	operator()(_Value& __val, _Iterator __it) const
90	{ return __val < *__it; }
91	};
92
93	inline _Val_less_iter
94	__val_less_iter()
95	{ return _Val_less_iter(); }
96
97	inline _Val_less_iter
98	__val_comp_iter(_Iter_less_iter)
99	{ return _Val_less_iter(); }
100
101	struct _Iter_equal_to_iter
102	{
103	template<typename _Iterator1, typename _Iterator2>
104	bool
105	operator()(_Iterator1 __it1, _Iterator2 __it2) const
106	{ return __it1 == __it2; }
107	};
108
109	inline _Iter_equal_to_iter
110	__iter_equal_to_iter()
111	{ return _Iter_equal_to_iter(); }
112
113	struct _Iter_equal_to_val
114	{
115	template<typename _Iterator, typename _Value>
116	bool
117	operator()(_Iterator __it, _Value& __val) const
118	{ return *__it == __val; }
119	};
120
121	inline _Iter_equal_to_val
122	__iter_equal_to_val()
123	{ return _Iter_equal_to_val(); }
124
125	inline _Iter_equal_to_val
126	__iter_comp_val(_Iter_equal_to_iter)
127	{ return _Iter_equal_to_val(); }
128
129	template<typename _Compare>
130	struct _Iter_comp_iter
131	{
132	_Compare _M_comp;
133
134	explicit _GLIBCXX14_CONSTEXPR
135	_Iter_comp_iter(_Compare __comp)
136	: _M_comp(_GLIBCXX_MOVE(__comp))
137	{ }
138
139	template<typename _Iterator1, typename _Iterator2>
140	_GLIBCXX14_CONSTEXPR
141	bool
142	operator()(_Iterator1 __it1, _Iterator2 __it2)
143	{ return bool(_M_comp(__it1, __it2)); }
144	};
145
146	template<typename _Compare>
147	_GLIBCXX14_CONSTEXPR
148	inline _Iter_comp_iter<_Compare>
149	__iter_comp_iter(_Compare __comp)
150	{ return _Iter_comp_iter<_Compare>(_GLIBCXX_MOVE(__comp)); }
151
152	template<typename _Compare>
153	struct _Iter_comp_val
154	{
155	_Compare _M_comp;
156
157	explicit
158	_Iter_comp_val(_Compare __comp)
159	: _M_comp(_GLIBCXX_MOVE(__comp))
160	{ }
161
162	explicit
163	_Iter_comp_val(const _Iter_comp_iter<_Compare>& __comp)
164	: _M_comp(__comp._M_comp)
165	{ }
166
167	#if __cplusplus >= 201103L
168	explicit
169	_Iter_comp_val(_Iter_comp_iter<_Compare>&& __comp)
170	: _M_comp(std::move(__comp._M_comp))
171	{ }
172	#endif
173
174	template<typename _Iterator, typename _Value>
175	bool
176	operator()(_Iterator __it, _Value& __val)
177	{ return bool(_M_comp(*__it, __val)); }
178	};
179
180	template<typename _Compare>
181	inline _Iter_comp_val<_Compare>
182	__iter_comp_val(_Compare __comp)
183	{ return _Iter_comp_val<_Compare>(_GLIBCXX_MOVE(__comp)); }
184
185	template<typename _Compare>
186	inline _Iter_comp_val<_Compare>
187	__iter_comp_val(_Iter_comp_iter<_Compare> __comp)
188	{ return _Iter_comp_val<_Compare>(_GLIBCXX_MOVE(__comp)); }
189
190	template<typename _Compare>
191	struct _Val_comp_iter
192	{
193	_Compare _M_comp;
194
195	explicit
196	_Val_comp_iter(_Compare __comp)
197	: _M_comp(_GLIBCXX_MOVE(__comp))
198	{ }
199
200	explicit
201	_Val_comp_iter(const _Iter_comp_iter<_Compare>& __comp)
202	: _M_comp(__comp._M_comp)
203	{ }
204
205	#if __cplusplus >= 201103L
206	explicit
207	_Val_comp_iter(_Iter_comp_iter<_Compare>&& __comp)
208	: _M_comp(std::move(__comp._M_comp))
209	{ }
210	#endif
211
212	template<typename _Value, typename _Iterator>
213	bool
214	operator()(_Value& __val, _Iterator __it)
215	{ return bool(_M_comp(__val, *__it)); }
216	};
217
218	template<typename _Compare>
219	inline _Val_comp_iter<_Compare>
220	__val_comp_iter(_Compare __comp)
221	{ return _Val_comp_iter<_Compare>(_GLIBCXX_MOVE(__comp)); }
222
223	template<typename _Compare>
224	inline _Val_comp_iter<_Compare>
225	__val_comp_iter(_Iter_comp_iter<_Compare> __comp)
226	{ return _Val_comp_iter<_Compare>(_GLIBCXX_MOVE(__comp)); }
227
228	template<typename _Value>
229	struct _Iter_equals_val
230	{
231	_Value& _M_value;
232
233	explicit
234	_Iter_equals_val(_Value& __value)
235	: _M_value(__value)
236	{ }
237
238	template<typename _Iterator>
239	bool
240	operator()(_Iterator __it)
241	{ return *__it == _M_value; }
242	};
243
244	template<typename _Value>
245	inline _Iter_equals_val<_Value>
246	__iter_equals_val(_Value& __val)
247	{ return _Iter_equals_val<_Value>(__val); }
248
249	template<typename _Iterator1>
250	struct _Iter_equals_iter
251	{
252	_Iterator1 _M_it1;
253
254	explicit
255	_Iter_equals_iter(_Iterator1 __it1)
256	: _M_it1(__it1)
257	{ }
258
259	template<typename _Iterator2>
260	bool
261	operator()(_Iterator2 __it2)
262	{ return __it2 == _M_it1; }
263	};
264
265	template<typename _Iterator>
266	inline _Iter_equals_iter<_Iterator>
267	__iter_comp_iter(_Iter_equal_to_iter, _Iterator __it)
268	{ return _Iter_equals_iter<_Iterator>(__it); }
269
270	template<typename _Predicate>
271	struct _Iter_pred
272	{
273	_Predicate _M_pred;
274
275	explicit
276	_Iter_pred(_Predicate __pred)
277	: _M_pred(_GLIBCXX_MOVE(__pred))
278	{ }
279
280	template<typename _Iterator>
281	bool
282	operator()(_Iterator __it)
283	{ return bool(_M_pred(*__it)); }
284	};
285
286	template<typename _Predicate>
287	inline _Iter_pred<_Predicate>
288	__pred_iter(_Predicate __pred)
289	{ return _Iter_pred<_Predicate>(_GLIBCXX_MOVE(__pred)); }
290
291	template<typename _Compare, typename _Value>
292	struct _Iter_comp_to_val
293	{
294	_Compare _M_comp;
295	_Value& _M_value;
296
297	_Iter_comp_to_val(_Compare __comp, _Value& __value)
298	: _M_comp(_GLIBCXX_MOVE(__comp)), _M_value(__value)
299	{ }
300
301	template<typename _Iterator>
302	bool
303	operator()(_Iterator __it)
304	{ return bool(_M_comp(*__it, _M_value)); }
305	};
306
307	template<typename _Compare, typename _Value>
308	_Iter_comp_to_val<_Compare, _Value>
309	__iter_comp_val(_Compare __comp, _Value &__val)
310	{
311	return _Iter_comp_to_val<_Compare, _Value>(_GLIBCXX_MOVE(__comp), __val);
312	}
313
314	template<typename _Compare, typename _Iterator1>
315	struct _Iter_comp_to_iter
316	{
317	_Compare _M_comp;
318	_Iterator1 _M_it1;
319
320	_Iter_comp_to_iter(_Compare __comp, _Iterator1 __it1)
321	: _M_comp(_GLIBCXX_MOVE(__comp)), _M_it1(__it1)
322	{ }
323
324	template<typename _Iterator2>
325	bool
326	operator()(_Iterator2 __it2)
327	{ return bool(_M_comp(__it2, _M_it1)); }
328	};
329
330	template<typename _Compare, typename _Iterator>
331	inline _Iter_comp_to_iter<_Compare, _Iterator>
332	__iter_comp_iter(_Iter_comp_iter<_Compare> __comp, _Iterator __it)
333	{
334	return _Iter_comp_to_iter<_Compare, _Iterator>(
335	_GLIBCXX_MOVE(__comp._M_comp), __it);
336	}
337
338	template<typename _Predicate>
339	struct _Iter_negate
340	{
341	_Predicate _M_pred;
342
343	explicit
344	_Iter_negate(_Predicate __pred)
345	: _M_pred(_GLIBCXX_MOVE(__pred))
346	{ }
347
348	template<typename _Iterator>
349	bool
350	operator()(_Iterator __it)
351	{ return !bool(_M_pred(*__it)); }
352	};
353
354	template<typename _Predicate>
355	inline _Iter_negate<_Predicate>
356	__negate(_Iter_pred<_Predicate> __pred)
357	{ return _Iter_negate<_Predicate>(_GLIBCXX_MOVE(__pred._M_pred)); }
358
359	} // namespace __ops
360	} // namespace __gnu_cxx
361
362	#endif
363

__gnu_cxx::__ops::_Iter_comp_iter::_M_comp

__gnu_cxx::__ops::_Iter_comp_val::_M_comp

__gnu_cxx::__ops::_Val_comp_iter::_M_comp

__gnu_cxx::__ops::_Iter_equals_val::_M_value

__gnu_cxx::__ops::_Iter_equals_iter::_M_it1

__gnu_cxx::__ops::_Iter_pred::_M_pred

__gnu_cxx::__ops::_Iter_comp_to_val::_M_comp

__gnu_cxx::__ops::_Iter_comp_to_val::_M_value

__gnu_cxx::__ops::_Iter_comp_to_iter::_M_comp

__gnu_cxx::__ops::_Iter_comp_to_iter::_M_it1

__gnu_cxx::__ops::_Iter_negate::_M_pred

Clang Project