1// Default predicates for internal use -*- C++ -*-
2
3// Copyright (C) 2013-2019 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
33namespace __gnu_cxx
34{
35namespace __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