libstdc++
predefined_ops.h
Go to the documentation of this file.
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.
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  template<typename _Iterator, typename _Value>
54  bool
55  operator()(_Iterator __it, _Value& __val) const
56  { return *__it < __val; }
57  };
58 
59  inline _Iter_less_val
60  __iter_less_val()
61  { return _Iter_less_val(); }
62 
63  inline _Iter_less_val
64  __iter_comp_val(_Iter_less_iter)
65  { return _Iter_less_val(); }
66 
67  struct _Val_less_iter
68  {
69  template<typename _Value, typename _Iterator>
70  bool
71  operator()(_Value& __val, _Iterator __it) const
72  { return __val < *__it; }
73  };
74 
75  inline _Val_less_iter
76  __val_less_iter()
77  { return _Val_less_iter(); }
78 
79  inline _Val_less_iter
80  __val_comp_iter(_Iter_less_iter)
81  { return _Val_less_iter(); }
82 
83  struct _Iter_equal_to_iter
84  {
85  template<typename _Iterator1, typename _Iterator2>
86  bool
87  operator()(_Iterator1 __it1, _Iterator2 __it2) const
88  { return *__it1 == *__it2; }
89  };
90 
91  inline _Iter_equal_to_iter
92  __iter_equal_to_iter()
93  { return _Iter_equal_to_iter(); }
94 
95  struct _Iter_equal_to_val
96  {
97  template<typename _Iterator, typename _Value>
98  bool
99  operator()(_Iterator __it, _Value& __val) const
100  { return *__it == __val; }
101  };
102 
103  inline _Iter_equal_to_val
104  __iter_equal_to_val()
105  { return _Iter_equal_to_val(); }
106 
107  inline _Iter_equal_to_val
108  __iter_comp_val(_Iter_equal_to_iter)
109  { return _Iter_equal_to_val(); }
110 
111  template<typename _Compare>
112  struct _Iter_comp_iter
113  {
114  _Compare _M_comp;
115 
116  explicit _GLIBCXX14_CONSTEXPR
117  _Iter_comp_iter(_Compare __comp)
118  : _M_comp(_GLIBCXX_MOVE(__comp))
119  { }
120 
121  template<typename _Iterator1, typename _Iterator2>
122  _GLIBCXX14_CONSTEXPR
123  bool
124  operator()(_Iterator1 __it1, _Iterator2 __it2)
125  { return bool(_M_comp(*__it1, *__it2)); }
126  };
127 
128  template<typename _Compare>
129  _GLIBCXX14_CONSTEXPR
130  inline _Iter_comp_iter<_Compare>
131  __iter_comp_iter(_Compare __comp)
132  { return _Iter_comp_iter<_Compare>(_GLIBCXX_MOVE(__comp)); }
133 
134  template<typename _Compare>
135  struct _Iter_comp_val
136  {
137  _Compare _M_comp;
138 
139  explicit
140  _Iter_comp_val(_Compare __comp)
141  : _M_comp(_GLIBCXX_MOVE(__comp))
142  { }
143 
144  template<typename _Iterator, typename _Value>
145  bool
146  operator()(_Iterator __it, _Value& __val)
147  { return bool(_M_comp(*__it, __val)); }
148  };
149 
150  template<typename _Compare>
151  inline _Iter_comp_val<_Compare>
152  __iter_comp_val(_Compare __comp)
153  { return _Iter_comp_val<_Compare>(_GLIBCXX_MOVE(__comp)); }
154 
155  template<typename _Compare>
156  inline _Iter_comp_val<_Compare>
157  __iter_comp_val(_Iter_comp_iter<_Compare> __comp)
158  { return _Iter_comp_val<_Compare>(_GLIBCXX_MOVE(__comp._M_comp)); }
159 
160  template<typename _Compare>
161  struct _Val_comp_iter
162  {
163  _Compare _M_comp;
164 
165  explicit
166  _Val_comp_iter(_Compare __comp)
167  : _M_comp(_GLIBCXX_MOVE(__comp))
168  { }
169 
170  template<typename _Value, typename _Iterator>
171  bool
172  operator()(_Value& __val, _Iterator __it)
173  { return bool(_M_comp(__val, *__it)); }
174  };
175 
176  template<typename _Compare>
177  inline _Val_comp_iter<_Compare>
178  __val_comp_iter(_Compare __comp)
179  { return _Val_comp_iter<_Compare>(_GLIBCXX_MOVE(__comp)); }
180 
181  template<typename _Compare>
182  inline _Val_comp_iter<_Compare>
183  __val_comp_iter(_Iter_comp_iter<_Compare> __comp)
184  { return _Val_comp_iter<_Compare>(_GLIBCXX_MOVE(__comp._M_comp)); }
185 
186  template<typename _Value>
187  struct _Iter_equals_val
188  {
189  _Value& _M_value;
190 
191  explicit
192  _Iter_equals_val(_Value& __value)
193  : _M_value(__value)
194  { }
195 
196  template<typename _Iterator>
197  bool
198  operator()(_Iterator __it)
199  { return *__it == _M_value; }
200  };
201 
202  template<typename _Value>
203  inline _Iter_equals_val<_Value>
204  __iter_equals_val(_Value& __val)
205  { return _Iter_equals_val<_Value>(__val); }
206 
207  template<typename _Iterator1>
208  struct _Iter_equals_iter
209  {
210  typename std::iterator_traits<_Iterator1>::reference _M_ref;
211 
212  explicit
213  _Iter_equals_iter(_Iterator1 __it1)
214  : _M_ref(*__it1)
215  { }
216 
217  template<typename _Iterator2>
218  bool
219  operator()(_Iterator2 __it2)
220  { return *__it2 == _M_ref; }
221  };
222 
223  template<typename _Iterator>
224  inline _Iter_equals_iter<_Iterator>
225  __iter_comp_iter(_Iter_equal_to_iter, _Iterator __it)
226  { return _Iter_equals_iter<_Iterator>(__it); }
227 
228  template<typename _Predicate>
229  struct _Iter_pred
230  {
231  _Predicate _M_pred;
232 
233  explicit
234  _Iter_pred(_Predicate __pred)
235  : _M_pred(_GLIBCXX_MOVE(__pred))
236  { }
237 
238  template<typename _Iterator>
239  bool
240  operator()(_Iterator __it)
241  { return bool(_M_pred(*__it)); }
242  };
243 
244  template<typename _Predicate>
245  inline _Iter_pred<_Predicate>
246  __pred_iter(_Predicate __pred)
247  { return _Iter_pred<_Predicate>(_GLIBCXX_MOVE(__pred)); }
248 
249  template<typename _Compare, typename _Value>
250  struct _Iter_comp_to_val
251  {
252  _Compare _M_comp;
253  _Value& _M_value;
254 
255  _Iter_comp_to_val(_Compare __comp, _Value& __value)
256  : _M_comp(_GLIBCXX_MOVE(__comp)), _M_value(__value)
257  { }
258 
259  template<typename _Iterator>
260  bool
261  operator()(_Iterator __it)
262  { return bool(_M_comp(*__it, _M_value)); }
263  };
264 
265  template<typename _Compare, typename _Value>
266  _Iter_comp_to_val<_Compare, _Value>
267  __iter_comp_val(_Compare __comp, _Value &__val)
268  {
269  return _Iter_comp_to_val<_Compare, _Value>(_GLIBCXX_MOVE(__comp), __val);
270  }
271 
272  template<typename _Compare, typename _Iterator1>
273  struct _Iter_comp_to_iter
274  {
275  _Compare _M_comp;
276  typename std::iterator_traits<_Iterator1>::reference _M_ref;
277 
278  _Iter_comp_to_iter(_Compare __comp, _Iterator1 __it1)
279  : _M_comp(_GLIBCXX_MOVE(__comp)), _M_ref(*__it1)
280  { }
281 
282  template<typename _Iterator2>
283  bool
284  operator()(_Iterator2 __it2)
285  { return bool(_M_comp(*__it2, _M_ref)); }
286  };
287 
288  template<typename _Compare, typename _Iterator>
289  inline _Iter_comp_to_iter<_Compare, _Iterator>
290  __iter_comp_iter(_Iter_comp_iter<_Compare> __comp, _Iterator __it)
291  {
292  return _Iter_comp_to_iter<_Compare, _Iterator>(
293  _GLIBCXX_MOVE(__comp._M_comp), __it);
294  }
295 
296  template<typename _Predicate>
297  struct _Iter_negate
298  {
299  _Predicate _M_pred;
300 
301  explicit
302  _Iter_negate(_Predicate __pred)
303  : _M_pred(_GLIBCXX_MOVE(__pred))
304  { }
305 
306  template<typename _Iterator>
307  bool
308  operator()(_Iterator __it)
309  { return !bool(_M_pred(*__it)); }
310  };
311 
312  template<typename _Predicate>
313  inline _Iter_negate<_Predicate>
314  __negate(_Iter_pred<_Predicate> __pred)
315  { return _Iter_negate<_Predicate>(_GLIBCXX_MOVE(__pred._M_pred)); }
316 
317 } // namespace __ops
318 } // namespace __gnu_cxx
319 
320 #endif
GNU extensions for public use.