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