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