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
34namespace std _GLIBCXX_VISIBILITY(default)
35{
36namespace __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
479