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