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