libstdc++

profile/deque
Go to the documentation of this file.
1 // Profiling deque 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/deque
26 * This file is a GNU profile extension to the Standard C++ Library.
27 */
28
29 #ifndef _GLIBCXX_PROFILE_DEQUE
30 #define _GLIBCXX_PROFILE_DEQUE 1
31
32 #include <deque>
33
34 namespace std _GLIBCXX_VISIBILITY(default)
35 {
36 namespace __profile
37 {
38 /// Class std::deque wrapper with performance instrumentation.
39 template<typename _Tp, typename _Allocator = std::allocator<_Tp> >
40 class deque
41 : public _GLIBCXX_STD_C::deque<_Tp, _Allocator>
42 {
43 typedef _GLIBCXX_STD_C::deque<_Tp, _Allocator> _Base;
44
45 public:
46 typedef typename _Base::reference reference;
47 typedef typename _Base::const_reference const_reference;
48
49 typedef typename _Base::iterator iterator;
50 typedef typename _Base::const_iterator const_iterator;
51 typedef typename _Base::reverse_iterator reverse_iterator;
52 typedef typename _Base::const_reverse_iterator const_reverse_iterator;
53
54 typedef typename _Base::size_type size_type;
55 typedef typename _Base::difference_type difference_type;
56
57 typedef _Tp value_type;
58 typedef _Allocator allocator_type;
59 typedef typename _Base::pointer pointer;
60 typedef typename _Base::const_pointer const_pointer;
61
62 // 23.2.1.1 construct/copy/destroy:
63 explicit
64 deque(const _Allocator& __a = _Allocator())
65 : _Base(__a) { }
66
67 #if __cplusplus >= 201103L
68 explicit
69 deque(size_type __n)
70 : _Base(__n) { }
71
72 deque(size_type __n, const _Tp& __value,
73 const _Allocator& __a = _Allocator())
74 : _Base(__n, __value, __a) { }
75 #else
76 explicit
77 deque(size_type __n, const _Tp& __value = _Tp(),
78 const _Allocator& __a = _Allocator())
79 : _Base(__n, __value, __a) { }
80 #endif
81
82 #if __cplusplus >= 201103L
83 template<typename _InputIterator,
84 typename = std::_RequireInputIter<_InputIterator>>
85 #else
86 template<typename _InputIterator>
87 #endif
88 deque(_InputIterator __first, _InputIterator __last,
89 const _Allocator& __a = _Allocator())
90 : _Base(__first, __last, __a)
91 { }
92
93 deque(const deque& __x)
94 : _Base(__x) { }
95
96 deque(const _Base& __x)
97 : _Base(__x) { }
98
99 #if __cplusplus >= 201103L
100 deque(deque&& __x)
101 : _Base(std::move(__x))
102 { }
103
104 deque(initializer_list<value_type> __l,
105 const allocator_type& __a = allocator_type())
106 : _Base(__l, __a) { }
107 #endif
108
109 ~deque() _GLIBCXX_NOEXCEPT { }
110
111 deque&
112 operator=(const deque& __x)
113 {
114 *static_cast<_Base*>(this) = __x;
115 return *this;
116 }
117
118 #if __cplusplus >= 201103L
119 deque&
120 operator=(deque&& __x)
121 {
122 // NB: DR 1204.
123 // NB: DR 675.
124 this->clear();
125 this->swap(__x);
126 return *this;
127 }
128
129 deque&
130 operator=(initializer_list<value_type> __l)
131 {
132 *static_cast<_Base*>(this) = __l;
133 return *this;
134 }
135 #endif
136
137 #if __cplusplus >= 201103L
138 template<typename _InputIterator,
139 typename = std::_RequireInputIter<_InputIterator>>
140 #else
141 template<typename _InputIterator>
142 #endif
143 void
144 assign(_InputIterator __first, _InputIterator __last)
145 {
146 _Base::assign(__first, __last);
147 }
148
149 void
150 assign(size_type __n, const _Tp& __t)
151 {
152 _Base::assign(__n, __t);
153 }
154
155 #if __cplusplus >= 201103L
156 void
157 assign(initializer_list<value_type> __l)
158 {
159 _Base::assign(__l);
160 }
161 #endif
162
163 using _Base::get_allocator;
164
165 // iterators:
166 iterator
167 begin() _GLIBCXX_NOEXCEPT
168 { return iterator(_Base::begin()); }
169
170 const_iterator
171 begin() const _GLIBCXX_NOEXCEPT
172 { return const_iterator(_Base::begin()); }
173
174 iterator
175 end() _GLIBCXX_NOEXCEPT
176 { return iterator(_Base::end()); }
177
178 const_iterator
179 end() const _GLIBCXX_NOEXCEPT
180 { return const_iterator(_Base::end()); }
181
182 reverse_iterator
183 rbegin() _GLIBCXX_NOEXCEPT
184 { return reverse_iterator(end()); }
185
186 const_reverse_iterator
187 rbegin() const _GLIBCXX_NOEXCEPT
188 { return const_reverse_iterator(end()); }
189
190 reverse_iterator
191 rend() _GLIBCXX_NOEXCEPT
192 { return reverse_iterator(begin()); }
193
194 const_reverse_iterator
195 rend() const _GLIBCXX_NOEXCEPT
196 { return const_reverse_iterator(begin()); }
197
198 #if __cplusplus >= 201103L
199 const_iterator
200 cbegin() const noexcept
201 { return const_iterator(_Base::begin()); }
202
203 const_iterator
204 cend() const noexcept
205 { return const_iterator(_Base::end()); }
206
207 const_reverse_iterator
208 crbegin() const noexcept
209 { return const_reverse_iterator(end()); }
210
211 const_reverse_iterator
212 crend() const noexcept
213 { return const_reverse_iterator(begin()); }
214 #endif
215
216 // 23.2.1.2 capacity:
217 using _Base::size;
218 using _Base::max_size;
219
220 #if __cplusplus >= 201103L
221 void
222 resize(size_type __sz)
223 {
224 _Base::resize(__sz);
225 }
226
227 void
228 resize(size_type __sz, const _Tp& __c)
229 {
230 _Base::resize(__sz, __c);
231 }
232 #else
233 void
234 resize(size_type __sz, _Tp __c = _Tp())
235 {
236 _Base::resize(__sz, __c);
237 }
238 #endif
239
240 #if __cplusplus >= 201103L
241 using _Base::shrink_to_fit;
242 #endif
243
244 using _Base::empty;
245
246 // element access:
247 reference
248 operator[](size_type __n)
249 {
250 return _M_base()[__n];
251 }
252
253 const_reference
254 operator[](size_type __n) const
255 {
256 return _M_base()[__n];
257 }
258
259 using _Base::at;
260
261 reference
262 front()
263 {
264 return _Base::front();
265 }
266
267 const_reference
268 front() const
269 {
270 return _Base::front();
271 }
272
273 reference
274 back()
275 {
276 return _Base::back();
277 }
278
279 const_reference
280 back() const
281 {
282 return _Base::back();
283 }
284
285 // 23.2.1.3 modifiers:
286 void
287 push_front(const _Tp& __x)
288 {
289 _Base::push_front(__x);
290 }
291
292 void
293 push_back(const _Tp& __x)
294 {
295 _Base::push_back(__x);
296 }
297
298 #if __cplusplus >= 201103L
299 void
300 push_front(_Tp&& __x)
301 { emplace_front(std::move(__x)); }
302
303 void
304 push_back(_Tp&& __x)
305 { emplace_back(std::move(__x)); }
306
307 template<typename... _Args>
308 void
309 emplace_front(_Args&&... __args)
310 {
311 _Base::emplace_front(std::forward<_Args>(__args)...);
312 }
313
314 template<typename... _Args>
315 void
316 emplace_back(_Args&&... __args)
317 {
318 _Base::emplace_back(std::forward<_Args>(__args)...);
319 }
320
321 template<typename... _Args>
322 iterator
323 emplace(iterator __position, _Args&&... __args)
324 {
325 typename _Base::iterator __res = _Base::emplace(__position,
326 std::forward<_Args>(__args)...);
327 return iterator(__res);
328 }
329 #endif
330
331 iterator
332 insert(iterator __position, const _Tp& __x)
333 {
334 typename _Base::iterator __res = _Base::insert(__position, __x);
335 return iterator(__res);
336 }
337
338 #if __cplusplus >= 201103L
339 iterator
340 insert(iterator __position, _Tp&& __x)
341 { return emplace(__position, std::move(__x)); }
342
343 void
344 insert(iterator __p, initializer_list<value_type> __l)
345 {
346 _Base::insert(__p, __l);
347 }
348 #endif
349
350 void
351 insert(iterator __position, size_type __n, const _Tp& __x)
352 {
353 _Base::insert(__position, __n, __x);
354 }
355
356 #if __cplusplus >= 201103L
357 template<typename _InputIterator,
358 typename = std::_RequireInputIter<_InputIterator>>
359 #else
360 template<typename _InputIterator>
361 #endif
362 void
363 insert(iterator __position,
364 _InputIterator __first, _InputIterator __last)
365 {
366 _Base::insert(__position, __first, __last);
367 }
368
369 void
370 pop_front()
371 {
372 _Base::pop_front();
373 }
374
375 void
376 pop_back()
377 {
378 _Base::pop_back();
379 }
380
381 iterator
382 erase(iterator __position)
383 {
384 if (__position == begin() || __position == end()-1)
385 {
386 return iterator(_Base::erase(__position));
387 }
388 else
389 {
390 typename _Base::iterator __res = _Base::erase(__position);
391 return iterator(__res);
392 }
393 }
394
395 iterator
396 erase(iterator __first, iterator __last)
397 {
398 // _GLIBCXX_RESOLVE_LIB_DEFECTS
399 // 151. can't currently clear() empty container
400 return iterator(_Base::erase(__first, __last));
401 }
402
403 void
404 swap(deque& __x)
405 {
406 _Base::swap(__x);
407 }
408
409 void
410 clear() _GLIBCXX_NOEXCEPT
411 {
412 _Base::clear();
413 }
414
415 _Base&
416 _M_base() _GLIBCXX_NOEXCEPT { return *this; }
417
418 const _Base&
419 _M_base() const _GLIBCXX_NOEXCEPT { return *this; }
420 };
421
422 template<typename _Tp, typename _Alloc>
423 inline bool
424 operator==(const deque<_Tp, _Alloc>& __lhs,
425 const deque<_Tp, _Alloc>& __rhs)
426 { return __lhs._M_base() == __rhs._M_base(); }
427
428 template<typename _Tp, typename _Alloc>
429 inline bool
430 operator!=(const deque<_Tp, _Alloc>& __lhs,
431 const deque<_Tp, _Alloc>& __rhs)
432 { return __lhs._M_base() != __rhs._M_base(); }
433
434 template<typename _Tp, typename _Alloc>
435 inline bool
436 operator<(const deque<_Tp, _Alloc>& __lhs,
437 const deque<_Tp, _Alloc>& __rhs)
438 { return __lhs._M_base() < __rhs._M_base(); }
439
440 template<typename _Tp, typename _Alloc>
441 inline bool
442 operator<=(const deque<_Tp, _Alloc>& __lhs,
443 const deque<_Tp, _Alloc>& __rhs)
444 { return __lhs._M_base() <= __rhs._M_base(); }
445
446 template<typename _Tp, typename _Alloc>
447 inline bool
448 operator>=(const deque<_Tp, _Alloc>& __lhs,
449 const deque<_Tp, _Alloc>& __rhs)
450 { return __lhs._M_base() >= __rhs._M_base(); }
451
452 template<typename _Tp, typename _Alloc>
453 inline bool
454 operator>(const deque<_Tp, _Alloc>& __lhs,
455 const deque<_Tp, _Alloc>& __rhs)
456 { return __lhs._M_base() > __rhs._M_base(); }
457
458 template<typename _Tp, typename _Alloc>
459 inline void
460 swap(deque<_Tp, _Alloc>& __lhs, deque<_Tp, _Alloc>& __rhs)
461 { __lhs.swap(__rhs); }
462
463 } // namespace __profile
464 } // namespace std
465
466 #endif