libstdc++
predefined_ops.h
Go to the documentation of this file.
1 // Default predicates for internal use -*- C++ -*-
2 
3 // Copyright (C) 2013-2022 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 
35 namespace __gnu_cxx
36 {
37 namespace __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
std
ISO C++ entities toplevel namespace is std.
__gnu_cxx
GNU extensions for public use.