STLdoc
STLdocumentation
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Macros | Functions
deque File Reference
#include <bits/stl_algobase.h>
#include <bits/allocator.h>
#include <bits/stl_construct.h>
#include <bits/stl_uninitialized.h>
#include <bits/stl_deque.h>
#include <bits/range_access.h>
#include <bits/deque.tcc>
#include <deque>

Macros

#define _GLIBCXX_DEQUE   1
 
#define _GLIBCXX_PROFILE_DEQUE   1
 

Functions

namespace std _GLIBCXX_VISIBILITY (default)
 

Detailed Description

This file is a GNU profile extension to the Standard C++ Library.

Macro Definition Documentation

#define _GLIBCXX_DEQUE   1
#define _GLIBCXX_PROFILE_DEQUE   1

Function Documentation

namespace std _GLIBCXX_VISIBILITY ( default  )

Class std::deque wrapper with performance instrumentation.

35 {
36 namespace __profile
37 {
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
__gnu_debug::operator>=
bool operator>=(const _Safe_iterator< _IteratorL, _Sequence > &__lhs, const _Safe_iterator< _IteratorR, _Sequence > &__rhs)
Definition: safe_iterator.h:644
std::__exception_ptr::operator==
bool operator==(const exception_ptr &, const exception_ptr &) _GLIBCXX_USE_NOEXCEPT __attribute__((__pure__))
__gnu_debug::operator>
bool operator>(const _Safe_iterator< _IteratorL, _Sequence > &__lhs, const _Safe_iterator< _IteratorR, _Sequence > &__rhs)
Definition: safe_iterator.h:612
std::__exception_ptr::operator!=
bool operator!=(const exception_ptr &, const exception_ptr &) _GLIBCXX_USE_NOEXCEPT __attribute__((__pure__))
std::__exception_ptr::swap
void swap(exception_ptr &__lhs, exception_ptr &__rhs)
Definition: exception_ptr.h:160
Generated on Sat Jul 22 2017 14:41:31 for STLdoc by   doxygen 1.8.6