File Coverage

/usr/include/c++/5/bits/predefined_ops.h
Criterion Covered Total %
statement 4 18 22.2
branch n/a
condition n/a
subroutine n/a
pod n/a
total 4 18 22.2


line stmt bran cond sub pod time code
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             // .
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
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
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
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
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
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
111             struct _Iter_comp_iter
112             {
113             _Compare _M_comp;
114             _GLIBCXX14_CONSTEXPR
115 1           _Iter_comp_iter(_Compare __comp)
116             : _M_comp(__comp)
117 1           { }
118              
119             template
120             _GLIBCXX14_CONSTEXPR
121             bool
122 0           operator()(_Iterator1 __it1, _Iterator2 __it2)
123 0           { return bool(_M_comp(*__it1, *__it2)); }
124             };
125              
126             template
127             _GLIBCXX14_CONSTEXPR
128             inline _Iter_comp_iter<_Compare>
129 1           __iter_comp_iter(_Compare __comp)
130 1           { return _Iter_comp_iter<_Compare>(__comp); }
131              
132             template
133             struct _Iter_comp_val
134             {
135             _Compare _M_comp;
136              
137 0           _Iter_comp_val(_Compare __comp)
138             : _M_comp(__comp)
139 0           { }
140              
141             template
142             bool
143 0           operator()(_Iterator __it, _Value& __val)
144 0           { return bool(_M_comp(*__it, __val)); }
145             };
146              
147             template
148             inline _Iter_comp_val<_Compare>
149             __iter_comp_val(_Compare __comp)
150             { return _Iter_comp_val<_Compare>(__comp); }
151              
152             template
153             inline _Iter_comp_val<_Compare>
154 0           __iter_comp_val(_Iter_comp_iter<_Compare> __comp)
155 0           { return _Iter_comp_val<_Compare>(__comp._M_comp); }
156              
157             template
158             struct _Val_comp_iter
159             {
160             _Compare _M_comp;
161              
162 0           _Val_comp_iter(_Compare __comp)
163             : _M_comp(__comp)
164 0           { }
165              
166             template
167             bool
168 0           operator()(_Value& __val, _Iterator __it)
169 0           { return bool(_M_comp(__val, *__it)); }
170             };
171              
172             template
173             inline _Val_comp_iter<_Compare>
174             __val_comp_iter(_Compare __comp)
175             { return _Val_comp_iter<_Compare>(__comp); }
176              
177             template
178             inline _Val_comp_iter<_Compare>
179 0           __val_comp_iter(_Iter_comp_iter<_Compare> __comp)
180 0           { return _Val_comp_iter<_Compare>(__comp._M_comp); }
181              
182             template
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
192             bool
193             operator()(_Iterator __it)
194             { return *__it == _M_value; }
195             };
196              
197             template
198             inline _Iter_equals_val<_Value>
199             __iter_equals_val(_Value& __val)
200             { return _Iter_equals_val<_Value>(__val); }
201              
202             template
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
212             bool
213             operator()(_Iterator2 __it2)
214             { return *__it2 == _M_ref; }
215             };
216              
217             template
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
223             struct _Iter_pred
224             {
225             _Predicate _M_pred;
226              
227             _Iter_pred(_Predicate __pred)
228             : _M_pred(__pred)
229             { }
230              
231             template
232             bool
233             operator()(_Iterator __it)
234             { return bool(_M_pred(*__it)); }
235             };
236              
237             template
238             inline _Iter_pred<_Predicate>
239             __pred_iter(_Predicate __pred)
240             { return _Iter_pred<_Predicate>(__pred); }
241              
242             template
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
253             bool
254             operator()(_Iterator __it)
255             { return bool(_M_comp(*__it, _M_value)); }
256             };
257              
258             template
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
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
274             bool
275             operator()(_Iterator2 __it2)
276             { return bool(_M_comp(*__it2, _M_ref)); }
277             };
278              
279             template
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
285             struct _Iter_negate
286             {
287             _Predicate _M_pred;
288              
289             _Iter_negate(_Predicate __pred)
290             : _M_pred(__pred)
291             { }
292              
293             template
294             bool
295             operator()(_Iterator __it)
296             { return !bool(_M_pred(*__it)); }
297             };
298              
299             template
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