libstdc++

profile/multiset.h
Go to the documentation of this file.
1 // Profiling multiset implementation -*- C++ -*-
2
3 // Copyright (C) 2009-2013 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 profile/multiset.h
26 * This file is a GNU profile extension to the Standard C++ Library.
27 */
28
29 #ifndef _GLIBCXX_PROFILE_MULTISET_H
30 #define _GLIBCXX_PROFILE_MULTISET_H 1
31
32 #include <utility>
33
34 namespace std _GLIBCXX_VISIBILITY(default)
35 {
36 namespace __profile
37 {
38 /// Class std::multiset wrapper with performance instrumentation.
39 template<typename _Key, typename _Compare = std::less<_Key>,
40 typename _Allocator = std::allocator<_Key> >
41 class multiset
42 : public _GLIBCXX_STD_C::multiset<_Key, _Compare, _Allocator>
43 {
44 typedef _GLIBCXX_STD_C::multiset<_Key, _Compare, _Allocator> _Base;
45
46 public:
47 // types:
48 typedef _Key key_type;
49 typedef _Key value_type;
50 typedef _Compare key_compare;
51 typedef _Compare value_compare;
52 typedef _Allocator allocator_type;
53 typedef typename _Base::reference reference;
54 typedef typename _Base::const_reference const_reference;
55
56 typedef typename _Base::iterator iterator;
57 typedef typename _Base::const_iterator const_iterator;
58 typedef typename _Base::reverse_iterator reverse_iterator;
59 typedef typename _Base::const_reverse_iterator const_reverse_iterator;
60
61 typedef typename _Base::size_type size_type;
62 typedef typename _Base::difference_type difference_type;
63 typedef typename _Base::pointer pointer;
64 typedef typename _Base::const_pointer const_pointer;
65
66 // 23.3.3.1 construct/copy/destroy:
67 explicit multiset(const _Compare& __comp = _Compare(),
68 const _Allocator& __a = _Allocator())
69 : _Base(__comp, __a) { }
70
71 #if __cplusplus >= 201103L
72 template<typename _InputIterator,
73 typename = std::_RequireInputIter<_InputIterator>>
74 #else
75 template<typename _InputIterator>
76 #endif
77 multiset(_InputIterator __first, _InputIterator __last,
78 const _Compare& __comp = _Compare(),
79 const _Allocator& __a = _Allocator())
80 : _Base(__first, __last, __comp, __a) { }
81
82 multiset(const multiset& __x)
83 : _Base(__x) { }
84
85 multiset(const _Base& __x)
86 : _Base(__x) { }
87
88 #if __cplusplus >= 201103L
89 multiset(multiset&& __x)
90 noexcept(is_nothrow_copy_constructible<_Compare>::value)
91 : _Base(std::move(__x))
92 { }
93
94 multiset(initializer_list<value_type> __l,
95 const _Compare& __comp = _Compare(),
96 const allocator_type& __a = allocator_type())
97 : _Base(__l, __comp, __a) { }
98 #endif
99
100 ~multiset() _GLIBCXX_NOEXCEPT { }
101
102 multiset&
103 operator=(const multiset& __x)
104 {
105 *static_cast<_Base*>(this) = __x;
106 return *this;
107 }
108
109 #if __cplusplus >= 201103L
110 multiset&
111 operator=(multiset&& __x)
112 {
113 // NB: DR 1204.
114 // NB: DR 675.
115 this->clear();
116 this->swap(__x);
117 return *this;
118 }
119
120 multiset&
121 operator=(initializer_list<value_type> __l)
122 {
123 this->clear();
124 this->insert(__l);
125 return *this;
126 }
127 #endif
128
129 using _Base::get_allocator;
130
131 // iterators:
132 iterator
133 begin() _GLIBCXX_NOEXCEPT
134 { return iterator(_Base::begin()); }
135
136 const_iterator
137 begin() const _GLIBCXX_NOEXCEPT
138 { return const_iterator(_Base::begin()); }
139
140 iterator
141 end() _GLIBCXX_NOEXCEPT
142 { return iterator(_Base::end()); }
143
144 const_iterator
145 end() const _GLIBCXX_NOEXCEPT
146 { return const_iterator(_Base::end()); }
147
148 reverse_iterator
149 rbegin() _GLIBCXX_NOEXCEPT
150 { return reverse_iterator(end()); }
151
152 const_reverse_iterator
153 rbegin() const _GLIBCXX_NOEXCEPT
154 { return const_reverse_iterator(end()); }
155
156 reverse_iterator
157 rend() _GLIBCXX_NOEXCEPT
158 { return reverse_iterator(begin()); }
159
160 const_reverse_iterator
161 rend() const _GLIBCXX_NOEXCEPT
162 { return const_reverse_iterator(begin()); }
163
164 #if __cplusplus >= 201103L
165 const_iterator
166 cbegin() const noexcept
167 { return const_iterator(_Base::begin()); }
168
169 const_iterator
170 cend() const noexcept
171 { return const_iterator(_Base::end()); }
172
173 const_reverse_iterator
174 crbegin() const noexcept
175 { return const_reverse_iterator(end()); }
176
177 const_reverse_iterator
178 crend() const noexcept
179 { return const_reverse_iterator(begin()); }
180 #endif
181
182 // capacity:
183 using _Base::empty;
184 using _Base::size;
185 using _Base::max_size;
186
187 // modifiers:
188 #if __cplusplus >= 201103L
189 template<typename... _Args>
190 iterator
191 emplace(_Args&&... __args)
192 { return iterator(_Base::emplace(std::forward<_Args>(__args)...)); }
193
194 template<typename... _Args>
195 iterator
196 emplace_hint(const_iterator __pos, _Args&&... __args)
197 {
198 return iterator(_Base::emplace_hint(__pos,
199 std::forward<_Args>(__args)...));
200 }
201 #endif
202
203 iterator
204 insert(const value_type& __x)
205 { return iterator(_Base::insert(__x)); }
206
207 #if __cplusplus >= 201103L
208 iterator
209 insert(value_type&& __x)
210 { return iterator(_Base::insert(std::move(__x))); }
211 #endif
212
213 iterator
214 insert(const_iterator __position, const value_type& __x)
215 { return iterator(_Base::insert(__position, __x)); }
216
217 #if __cplusplus >= 201103L
218 iterator
219 insert(const_iterator __position, value_type&& __x)
220 { return iterator(_Base::insert(__position, std::move(__x))); }
221 #endif
222
223 #if __cplusplus >= 201103L
224 template<typename _InputIterator,
225 typename = std::_RequireInputIter<_InputIterator>>
226 #else
227 template<typename _InputIterator>
228 #endif
229 void
230 insert(_InputIterator __first, _InputIterator __last)
231 { _Base::insert(__first, __last); }
232
233 #if __cplusplus >= 201103L
234 void
235 insert(initializer_list<value_type> __l)
236 { _Base::insert(__l); }
237 #endif
238
239 #if __cplusplus >= 201103L
240 iterator
241 erase(const_iterator __position)
242 { return iterator(_Base::erase(__position)); }
243 #else
244 void
245 erase(iterator __position)
246 { _Base::erase(__position); }
247 #endif
248
249 size_type
250 erase(const key_type& __x)
251 {
252 std::pair<iterator, iterator> __victims = this->equal_range(__x);
253 size_type __count = 0;
254 while (__victims.first != __victims.second)
255 {
256 iterator __victim = __victims.first++;
257 _Base::erase(__victim);
258 ++__count;
259 }
260 return __count;
261 }
262
263 #if __cplusplus >= 201103L
264 iterator
265 erase(const_iterator __first, const_iterator __last)
266 { return iterator(_Base::erase(__first, __last)); }
267 #else
268 void
269 erase(iterator __first, iterator __last)
270 { _Base::erase(__first, __last); }
271 #endif
272
273 void
274 swap(multiset& __x)
275 { _Base::swap(__x); }
276
277 void
278 clear() _GLIBCXX_NOEXCEPT
279 { this->erase(begin(), end()); }
280
281 // observers:
282 using _Base::key_comp;
283 using _Base::value_comp;
284
285 // multiset operations:
286 iterator
287 find(const key_type& __x)
288 { return iterator(_Base::find(__x)); }
289
290 // _GLIBCXX_RESOLVE_LIB_DEFECTS
291 // 214. set::find() missing const overload
292 const_iterator
293 find(const key_type& __x) const
294 { return const_iterator(_Base::find(__x)); }
295
296 using _Base::count;
297
298 iterator
299 lower_bound(const key_type& __x)
300 { return iterator(_Base::lower_bound(__x)); }
301
302 // _GLIBCXX_RESOLVE_LIB_DEFECTS
303 // 214. set::find() missing const overload
304 const_iterator
305 lower_bound(const key_type& __x) const
306 { return const_iterator(_Base::lower_bound(__x)); }
307
308 iterator
309 upper_bound(const key_type& __x)
310 { return iterator(_Base::upper_bound(__x)); }
311
312 // _GLIBCXX_RESOLVE_LIB_DEFECTS
313 // 214. set::find() missing const overload
314 const_iterator
315 upper_bound(const key_type& __x) const
316 { return const_iterator(_Base::upper_bound(__x)); }
317
318 std::pair<iterator,iterator>
319 equal_range(const key_type& __x)
320 {
321 typedef typename _Base::iterator _Base_iterator;
322 std::pair<_Base_iterator, _Base_iterator> __res =
323 _Base::equal_range(__x);
324 return std::make_pair(iterator(__res.first),
325 iterator(__res.second));
326 }
327
328 // _GLIBCXX_RESOLVE_LIB_DEFECTS
329 // 214. set::find() missing const overload
330 std::pair<const_iterator,const_iterator>
331 equal_range(const key_type& __x) const
332 {
333 typedef typename _Base::const_iterator _Base_iterator;
334 std::pair<_Base_iterator, _Base_iterator> __res =
335 _Base::equal_range(__x);
336 return std::make_pair(const_iterator(__res.first),
337 const_iterator(__res.second));
338 }
339
340 _Base&
341 _M_base() _GLIBCXX_NOEXCEPT { return *this; }
342
343 const _Base&
344 _M_base() const _GLIBCXX_NOEXCEPT { return *this; }
345
346 };
347
348 template<typename _Key, typename _Compare, typename _Allocator>
349 inline bool
350 operator==(const multiset<_Key, _Compare, _Allocator>& __lhs,
351 const multiset<_Key, _Compare, _Allocator>& __rhs)
352 { return __lhs._M_base() == __rhs._M_base(); }
353
354 template<typename _Key, typename _Compare, typename _Allocator>
355 inline bool
356 operator!=(const multiset<_Key, _Compare, _Allocator>& __lhs,
357 const multiset<_Key, _Compare, _Allocator>& __rhs)
358 { return __lhs._M_base() != __rhs._M_base(); }
359
360 template<typename _Key, typename _Compare, typename _Allocator>
361 inline bool
362 operator<(const multiset<_Key, _Compare, _Allocator>& __lhs,
363 const multiset<_Key, _Compare, _Allocator>& __rhs)
364 { return __lhs._M_base() < __rhs._M_base(); }
365
366 template<typename _Key, typename _Compare, typename _Allocator>
367 inline bool
368 operator<=(const multiset<_Key, _Compare, _Allocator>& __lhs,
369 const multiset<_Key, _Compare, _Allocator>& __rhs)
370 { return __lhs._M_base() <= __rhs._M_base(); }
371
372 template<typename _Key, typename _Compare, typename _Allocator>
373 inline bool
374 operator>=(const multiset<_Key, _Compare, _Allocator>& __lhs,
375 const multiset<_Key, _Compare, _Allocator>& __rhs)
376 { return __lhs._M_base() >= __rhs._M_base(); }
377
378 template<typename _Key, typename _Compare, typename _Allocator>
379 inline bool
380 operator>(const multiset<_Key, _Compare, _Allocator>& __lhs,
381 const multiset<_Key, _Compare, _Allocator>& __rhs)
382 { return __lhs._M_base() > __rhs._M_base(); }
383
384 template<typename _Key, typename _Compare, typename _Allocator>
385 void
386 swap(multiset<_Key, _Compare, _Allocator>& __x,
387 multiset<_Key, _Compare, _Allocator>& __y)
388 { return __x.swap(__y); }
389
390 } // namespace __profile
391 } // namespace std
392
393 #endif