1 // Profiling deque implementation -*- C++ -*-
3 // Copyright (C) 2009 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 /** @brief 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)
112 operator=(initializer_list<value_type> __l)
114 *static_cast<_Base*>(this) = __l;
119 template<class _InputIterator>
121 assign(_InputIterator __first, _InputIterator __last)
123 _Base::assign(__first, __last);
127 assign(size_type __n, const _Tp& __t)
129 _Base::assign(__n, __t);
132 #ifdef __GXX_EXPERIMENTAL_CXX0X__
134 assign(initializer_list<value_type> __l)
140 using _Base::get_allocator;
145 { return iterator(_Base::begin()); }
149 { return const_iterator(_Base::begin()); }
153 { return iterator(_Base::end()); }
157 { return const_iterator(_Base::end()); }
161 { return reverse_iterator(end()); }
163 const_reverse_iterator
165 { return const_reverse_iterator(end()); }
169 { return reverse_iterator(begin()); }
171 const_reverse_iterator
173 { return const_reverse_iterator(begin()); }
175 #ifdef __GXX_EXPERIMENTAL_CXX0X__
178 { return const_iterator(_Base::begin()); }
182 { return const_iterator(_Base::end()); }
184 const_reverse_iterator
186 { return const_reverse_iterator(end()); }
188 const_reverse_iterator
190 { return const_reverse_iterator(begin()); }
193 // 23.2.1.2 capacity:
195 using _Base::max_size;
198 resize(size_type __sz, _Tp __c = _Tp())
200 _Base::resize(__sz, __c);
207 operator[](size_type __n)
209 return _M_base()[__n];
213 operator[](size_type __n) const
215 return _M_base()[__n];
223 return _Base::front();
229 return _Base::front();
235 return _Base::back();
241 return _Base::back();
244 // 23.2.1.3 modifiers:
246 push_front(const _Tp& __x)
248 _Base::push_front(__x);
252 push_back(const _Tp& __x)
254 _Base::push_back(__x);
257 #ifdef __GXX_EXPERIMENTAL_CXX0X__
259 push_front(_Tp&& __x)
260 { emplace_front(std::move(__x)); }
264 { emplace_back(std::move(__x)); }
266 template<typename... _Args>
268 emplace_front(_Args&&... __args)
270 _Base::emplace_front(std::forward<_Args>(__args)...);
273 template<typename... _Args>
275 emplace_back(_Args&&... __args)
277 _Base::emplace_back(std::forward<_Args>(__args)...);
280 template<typename... _Args>
282 emplace(iterator __position, _Args&&... __args)
284 typename _Base::iterator __res = _Base::emplace(__position,
285 std::forward<_Args>(__args)...);
286 return iterator(__res);
291 insert(iterator __position, const _Tp& __x)
293 typename _Base::iterator __res = _Base::insert(__position, __x);
294 return iterator(__res);
297 #ifdef __GXX_EXPERIMENTAL_CXX0X__
299 insert(iterator __position, _Tp&& __x)
300 { return emplace(__position, std::move(__x)); }
303 insert(iterator __p, initializer_list<value_type> __l)
305 _Base::insert(__p, __l);
310 insert(iterator __position, size_type __n, const _Tp& __x)
312 _Base::insert(__position, __n, __x);
315 template<class _InputIterator>
317 insert(iterator __position,
318 _InputIterator __first, _InputIterator __last)
320 _Base::insert(__position, __first, __last);
336 erase(iterator __position)
338 if (__position == begin() || __position == end()-1)
340 return iterator(_Base::erase(__position));
344 typename _Base::iterator __res = _Base::erase(__position);
345 return iterator(__res);
350 erase(iterator __first, iterator __last)
352 // _GLIBCXX_RESOLVE_LIB_DEFECTS
353 // 151. can't currently clear() empty container
354 return iterator(_Base::erase(__first, __last));
370 _M_base() { return *this; }
373 _M_base() const { return *this; }
376 template<typename _Tp, typename _Alloc>
378 operator==(const deque<_Tp, _Alloc>& __lhs,
379 const deque<_Tp, _Alloc>& __rhs)
380 { return __lhs._M_base() == __rhs._M_base(); }
382 template<typename _Tp, typename _Alloc>
384 operator!=(const deque<_Tp, _Alloc>& __lhs,
385 const deque<_Tp, _Alloc>& __rhs)
386 { return __lhs._M_base() != __rhs._M_base(); }
388 template<typename _Tp, typename _Alloc>
390 operator<(const deque<_Tp, _Alloc>& __lhs,
391 const deque<_Tp, _Alloc>& __rhs)
392 { return __lhs._M_base() < __rhs._M_base(); }
394 template<typename _Tp, typename _Alloc>
396 operator<=(const deque<_Tp, _Alloc>& __lhs,
397 const deque<_Tp, _Alloc>& __rhs)
398 { return __lhs._M_base() <= __rhs._M_base(); }
400 template<typename _Tp, typename _Alloc>
402 operator>=(const deque<_Tp, _Alloc>& __lhs,
403 const deque<_Tp, _Alloc>& __rhs)
404 { return __lhs._M_base() >= __rhs._M_base(); }
406 template<typename _Tp, typename _Alloc>
408 operator>(const deque<_Tp, _Alloc>& __lhs,
409 const deque<_Tp, _Alloc>& __rhs)
410 { return __lhs._M_base() > __rhs._M_base(); }
412 template<typename _Tp, typename _Alloc>
414 swap(deque<_Tp, _Alloc>& __lhs, deque<_Tp, _Alloc>& __rhs)
415 { __lhs.swap(__rhs); }
417 } // namespace __profile