1 // Profiling deque implementation -*- C++ -*-
3 // Copyright (C) 2009, 2010 Free Software Foundation, Inc.
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)
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.
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.
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/>.
25 /** @file profile/deque
26 * This file is a GNU profile extension to the Standard C++ Library.
29 #ifndef _GLIBCXX_PROFILE_DEQUE
30 #define _GLIBCXX_PROFILE_DEQUE 1
38 /// Class std::deque wrapper with performance instrumentation.
39 template<typename _Tp, typename _Allocator = std::allocator<_Tp> >
41 : public _GLIBCXX_STD_D::deque<_Tp, _Allocator>
43 typedef _GLIBCXX_STD_D::deque<_Tp, _Allocator> _Base;
46 typedef typename _Base::reference reference;
47 typedef typename _Base::const_reference const_reference;
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;
54 typedef typename _Base::size_type size_type;
55 typedef typename _Base::difference_type difference_type;
57 typedef _Tp value_type;
58 typedef _Allocator allocator_type;
59 typedef typename _Base::pointer pointer;
60 typedef typename _Base::const_pointer const_pointer;
62 // 23.2.1.1 construct/copy/destroy:
63 explicit deque(const _Allocator& __a = _Allocator())
66 explicit deque(size_type __n, const _Tp& __value = _Tp(),
67 const _Allocator& __a = _Allocator())
68 : _Base(__n, __value, __a) { }
70 template<class _InputIterator>
71 deque(_InputIterator __first, _InputIterator __last,
72 const _Allocator& __a = _Allocator())
73 : _Base(__first, __last, __a)
76 deque(const deque& __x)
79 deque(const _Base& __x)
82 #ifdef __GXX_EXPERIMENTAL_CXX0X__
84 : _Base(std::forward<deque>(__x))
87 deque(initializer_list<value_type> __l,
88 const allocator_type& __a = allocator_type())
95 operator=(const deque& __x)
97 *static_cast<_Base*>(this) = __x;
101 #ifdef __GXX_EXPERIMENTAL_CXX0X__
103 operator=(deque&& __x)
113 operator=(initializer_list<value_type> __l)
115 *static_cast<_Base*>(this) = __l;
120 template<class _InputIterator>
122 assign(_InputIterator __first, _InputIterator __last)
124 _Base::assign(__first, __last);
128 assign(size_type __n, const _Tp& __t)
130 _Base::assign(__n, __t);
133 #ifdef __GXX_EXPERIMENTAL_CXX0X__
135 assign(initializer_list<value_type> __l)
141 using _Base::get_allocator;
146 { return iterator(_Base::begin()); }
150 { return const_iterator(_Base::begin()); }
154 { return iterator(_Base::end()); }
158 { return const_iterator(_Base::end()); }
162 { return reverse_iterator(end()); }
164 const_reverse_iterator
166 { return const_reverse_iterator(end()); }
170 { return reverse_iterator(begin()); }
172 const_reverse_iterator
174 { return const_reverse_iterator(begin()); }
176 #ifdef __GXX_EXPERIMENTAL_CXX0X__
179 { return const_iterator(_Base::begin()); }
183 { return const_iterator(_Base::end()); }
185 const_reverse_iterator
187 { return const_reverse_iterator(end()); }
189 const_reverse_iterator
191 { return const_reverse_iterator(begin()); }
194 // 23.2.1.2 capacity:
196 using _Base::max_size;
199 resize(size_type __sz, _Tp __c = _Tp())
201 _Base::resize(__sz, __c);
204 #ifdef __GXX_EXPERIMENTAL_CXX0X__
205 using _Base::shrink_to_fit;
212 operator[](size_type __n)
214 return _M_base()[__n];
218 operator[](size_type __n) const
220 return _M_base()[__n];
228 return _Base::front();
234 return _Base::front();
240 return _Base::back();
246 return _Base::back();
249 // 23.2.1.3 modifiers:
251 push_front(const _Tp& __x)
253 _Base::push_front(__x);
257 push_back(const _Tp& __x)
259 _Base::push_back(__x);
262 #ifdef __GXX_EXPERIMENTAL_CXX0X__
264 push_front(_Tp&& __x)
265 { emplace_front(std::move(__x)); }
269 { emplace_back(std::move(__x)); }
271 template<typename... _Args>
273 emplace_front(_Args&&... __args)
275 _Base::emplace_front(std::forward<_Args>(__args)...);
278 template<typename... _Args>
280 emplace_back(_Args&&... __args)
282 _Base::emplace_back(std::forward<_Args>(__args)...);
285 template<typename... _Args>
287 emplace(iterator __position, _Args&&... __args)
289 typename _Base::iterator __res = _Base::emplace(__position,
290 std::forward<_Args>(__args)...);
291 return iterator(__res);
296 insert(iterator __position, const _Tp& __x)
298 typename _Base::iterator __res = _Base::insert(__position, __x);
299 return iterator(__res);
302 #ifdef __GXX_EXPERIMENTAL_CXX0X__
304 insert(iterator __position, _Tp&& __x)
305 { return emplace(__position, std::move(__x)); }
308 insert(iterator __p, initializer_list<value_type> __l)
310 _Base::insert(__p, __l);
315 insert(iterator __position, size_type __n, const _Tp& __x)
317 _Base::insert(__position, __n, __x);
320 template<class _InputIterator>
322 insert(iterator __position,
323 _InputIterator __first, _InputIterator __last)
325 _Base::insert(__position, __first, __last);
341 erase(iterator __position)
343 if (__position == begin() || __position == end()-1)
345 return iterator(_Base::erase(__position));
349 typename _Base::iterator __res = _Base::erase(__position);
350 return iterator(__res);
355 erase(iterator __first, iterator __last)
357 // _GLIBCXX_RESOLVE_LIB_DEFECTS
358 // 151. can't currently clear() empty container
359 return iterator(_Base::erase(__first, __last));
375 _M_base() { return *this; }
378 _M_base() const { return *this; }
381 template<typename _Tp, typename _Alloc>
383 operator==(const deque<_Tp, _Alloc>& __lhs,
384 const deque<_Tp, _Alloc>& __rhs)
385 { return __lhs._M_base() == __rhs._M_base(); }
387 template<typename _Tp, typename _Alloc>
389 operator!=(const deque<_Tp, _Alloc>& __lhs,
390 const deque<_Tp, _Alloc>& __rhs)
391 { return __lhs._M_base() != __rhs._M_base(); }
393 template<typename _Tp, typename _Alloc>
395 operator<(const deque<_Tp, _Alloc>& __lhs,
396 const deque<_Tp, _Alloc>& __rhs)
397 { return __lhs._M_base() < __rhs._M_base(); }
399 template<typename _Tp, typename _Alloc>
401 operator<=(const deque<_Tp, _Alloc>& __lhs,
402 const deque<_Tp, _Alloc>& __rhs)
403 { return __lhs._M_base() <= __rhs._M_base(); }
405 template<typename _Tp, typename _Alloc>
407 operator>=(const deque<_Tp, _Alloc>& __lhs,
408 const deque<_Tp, _Alloc>& __rhs)
409 { return __lhs._M_base() >= __rhs._M_base(); }
411 template<typename _Tp, typename _Alloc>
413 operator>(const deque<_Tp, _Alloc>& __lhs,
414 const deque<_Tp, _Alloc>& __rhs)
415 { return __lhs._M_base() > __rhs._M_base(); }
417 template<typename _Tp, typename _Alloc>
419 swap(deque<_Tp, _Alloc>& __lhs, deque<_Tp, _Alloc>& __rhs)
420 { __lhs.swap(__rhs); }
422 } // namespace __profile