Line data Source code
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 :
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 4808 : operator()(_Iterator1 __it1, _Iterator2 __it2) const
43 4798 : { return *__it1 < *__it2; }
44 : };
45 :
46 : _GLIBCXX14_CONSTEXPR
47 : inline _Iter_less_iter
48 4775 : __iter_less_iter()
49 4775 : { 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 0 : _Iter_less_val(_Iter_less_iter) { }
61 :
62 : template<typename _Iterator, typename _Value>
63 : bool
64 2153520 : operator()(_Iterator __it, _Value& __val) const
65 2153520 : { return *__it < __val; }
66 : };
67 :
68 : inline _Iter_less_val
69 1222400 : __iter_less_val()
70 1222400 : { 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 5746 : operator()(_Value& __val, _Iterator __it) const
90 5746 : { return __val < *__it; }
91 : };
92 :
93 : inline _Val_less_iter
94 0 : __val_less_iter()
95 0 : { return _Val_less_iter(); }
96 :
97 : inline _Val_less_iter
98 4787 : __val_comp_iter(_Iter_less_iter)
99 4787 : { return _Val_less_iter(); }
100 :
101 : struct _Iter_equal_to_iter
102 : {
103 : template<typename _Iterator1, typename _Iterator2>
104 : bool
105 4791 : operator()(_Iterator1 __it1, _Iterator2 __it2) const
106 4791 : { return *__it1 == *__it2; }
107 : };
108 :
109 : inline _Iter_equal_to_iter
110 4779 : __iter_equal_to_iter()
111 4779 : { 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 26684 : _Iter_comp_iter(_Compare __comp)
136 26684 : : _M_comp(_GLIBCXX_MOVE(__comp))
137 : { }
138 :
139 : template<typename _Iterator1, typename _Iterator2>
140 : _GLIBCXX14_CONSTEXPR
141 : bool
142 421 : operator()(_Iterator1 __it1, _Iterator2 __it2)
143 421 : { return bool(_M_comp(*__it1, *__it2)); }
144 : };
145 :
146 : template<typename _Compare>
147 : _GLIBCXX14_CONSTEXPR
148 : inline _Iter_comp_iter<_Compare>
149 26684 : __iter_comp_iter(_Compare __comp)
150 26684 : { 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 0 : _Iter_comp_val(_Iter_comp_iter<_Compare>&& __comp)
170 0 : : _M_comp(std::move(__comp._M_comp))
171 : { }
172 : #endif
173 :
174 : template<typename _Iterator, typename _Value>
175 : bool
176 0 : operator()(_Iterator __it, _Value& __val)
177 0 : { 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 417 : _Val_comp_iter(_Iter_comp_iter<_Compare>&& __comp)
208 417 : : _M_comp(std::move(__comp._M_comp))
209 : { }
210 : #endif
211 :
212 : template<typename _Value, typename _Iterator>
213 : bool
214 426 : operator()(_Value& __val, _Iterator __it)
215 426 : { 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 417 : __val_comp_iter(_Iter_comp_iter<_Compare> __comp)
226 417 : { 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 115844505 : _Iter_equals_val(_Value& __value)
235 : : _M_value(__value)
236 : { }
237 :
238 : template<typename _Iterator>
239 : bool
240 4578498816 : operator()(_Iterator __it)
241 1217124563 : { return *__it == _M_value; }
242 : };
243 :
244 : template<typename _Value>
245 : inline _Iter_equals_val<_Value>
246 115844505 : __iter_equals_val(_Value& __val)
247 115844505 : { 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 0 : _Iter_equals_iter(_Iterator1 __it1)
256 : : _M_it1(__it1)
257 : { }
258 :
259 : template<typename _Iterator2>
260 : bool
261 0 : operator()(_Iterator2 __it2)
262 0 : { return *__it2 == *_M_it1; }
263 : };
264 :
265 : template<typename _Iterator>
266 : inline _Iter_equals_iter<_Iterator>
267 0 : __iter_comp_iter(_Iter_equal_to_iter, _Iterator __it)
268 0 : { return _Iter_equals_iter<_Iterator>(__it); }
269 :
270 : template<typename _Predicate>
271 0 : struct _Iter_pred
272 : {
273 : _Predicate _M_pred;
274 :
275 : explicit
276 44 : _Iter_pred(_Predicate __pred)
277 44 : : _M_pred(_GLIBCXX_MOVE(__pred))
278 0 : { }
279 :
280 : template<typename _Iterator>
281 : bool
282 241 : operator()(_Iterator __it)
283 153 : { return bool(_M_pred(*__it)); }
284 : };
285 :
286 : template<typename _Predicate>
287 : inline _Iter_pred<_Predicate>
288 44 : __pred_iter(_Predicate __pred)
289 44 : { 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
|
