00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029 #ifndef _GLIBCXX_PROFILE_DEQUE
00030 #define _GLIBCXX_PROFILE_DEQUE 1
00031
00032 #include <deque>
00033
00034 namespace std
00035 {
00036 namespace __profile
00037 {
00038
00039 template<typename _Tp, typename _Allocator = std::allocator<_Tp> >
00040 class deque
00041 : public _GLIBCXX_STD_D::deque<_Tp, _Allocator>
00042 {
00043 typedef _GLIBCXX_STD_D::deque<_Tp, _Allocator> _Base;
00044
00045 public:
00046 typedef typename _Base::reference reference;
00047 typedef typename _Base::const_reference const_reference;
00048
00049 typedef typename _Base::iterator iterator;
00050 typedef typename _Base::const_iterator const_iterator;
00051 typedef typename _Base::reverse_iterator reverse_iterator;
00052 typedef typename _Base::const_reverse_iterator const_reverse_iterator;
00053
00054 typedef typename _Base::size_type size_type;
00055 typedef typename _Base::difference_type difference_type;
00056
00057 typedef _Tp value_type;
00058 typedef _Allocator allocator_type;
00059 typedef typename _Base::pointer pointer;
00060 typedef typename _Base::const_pointer const_pointer;
00061
00062
00063 explicit deque(const _Allocator& __a = _Allocator())
00064 : _Base(__a) { }
00065
00066 explicit deque(size_type __n, const _Tp& __value = _Tp(),
00067 const _Allocator& __a = _Allocator())
00068 : _Base(__n, __value, __a) { }
00069
00070 template<class _InputIterator>
00071 deque(_InputIterator __first, _InputIterator __last,
00072 const _Allocator& __a = _Allocator())
00073 : _Base(__first, __last, __a)
00074 { }
00075
00076 deque(const deque& __x)
00077 : _Base(__x) { }
00078
00079 deque(const _Base& __x)
00080 : _Base(__x) { }
00081
00082 #ifdef __GXX_EXPERIMENTAL_CXX0X__
00083 deque(deque&& __x)
00084 : _Base(std::forward<deque>(__x))
00085 { }
00086
00087 deque(initializer_list<value_type> __l,
00088 const allocator_type& __a = allocator_type())
00089 : _Base(__l, __a) { }
00090 #endif
00091
00092 ~deque() { }
00093
00094 deque&
00095 operator=(const deque& __x)
00096 {
00097 *static_cast<_Base*>(this) = __x;
00098 return *this;
00099 }
00100
00101 #ifdef __GXX_EXPERIMENTAL_CXX0X__
00102 deque&
00103 operator=(deque&& __x)
00104 {
00105
00106
00107 this->clear();
00108 this->swap(__x);
00109 return *this;
00110 }
00111
00112 deque&
00113 operator=(initializer_list<value_type> __l)
00114 {
00115 *static_cast<_Base*>(this) = __l;
00116 return *this;
00117 }
00118 #endif
00119
00120 template<class _InputIterator>
00121 void
00122 assign(_InputIterator __first, _InputIterator __last)
00123 {
00124 _Base::assign(__first, __last);
00125 }
00126
00127 void
00128 assign(size_type __n, const _Tp& __t)
00129 {
00130 _Base::assign(__n, __t);
00131 }
00132
00133 #ifdef __GXX_EXPERIMENTAL_CXX0X__
00134 void
00135 assign(initializer_list<value_type> __l)
00136 {
00137 _Base::assign(__l);
00138 }
00139 #endif
00140
00141 using _Base::get_allocator;
00142
00143
00144 iterator
00145 begin()
00146 { return iterator(_Base::begin()); }
00147
00148 const_iterator
00149 begin() const
00150 { return const_iterator(_Base::begin()); }
00151
00152 iterator
00153 end()
00154 { return iterator(_Base::end()); }
00155
00156 const_iterator
00157 end() const
00158 { return const_iterator(_Base::end()); }
00159
00160 reverse_iterator
00161 rbegin()
00162 { return reverse_iterator(end()); }
00163
00164 const_reverse_iterator
00165 rbegin() const
00166 { return const_reverse_iterator(end()); }
00167
00168 reverse_iterator
00169 rend()
00170 { return reverse_iterator(begin()); }
00171
00172 const_reverse_iterator
00173 rend() const
00174 { return const_reverse_iterator(begin()); }
00175
00176 #ifdef __GXX_EXPERIMENTAL_CXX0X__
00177 const_iterator
00178 cbegin() const
00179 { return const_iterator(_Base::begin()); }
00180
00181 const_iterator
00182 cend() const
00183 { return const_iterator(_Base::end()); }
00184
00185 const_reverse_iterator
00186 crbegin() const
00187 { return const_reverse_iterator(end()); }
00188
00189 const_reverse_iterator
00190 crend() const
00191 { return const_reverse_iterator(begin()); }
00192 #endif
00193
00194
00195 using _Base::size;
00196 using _Base::max_size;
00197
00198 void
00199 resize(size_type __sz, _Tp __c = _Tp())
00200 {
00201 _Base::resize(__sz, __c);
00202 }
00203
00204 #ifdef __GXX_EXPERIMENTAL_CXX0X__
00205 using _Base::shrink_to_fit;
00206 #endif
00207
00208 using _Base::empty;
00209
00210
00211 reference
00212 operator[](size_type __n)
00213 {
00214 return _M_base()[__n];
00215 }
00216
00217 const_reference
00218 operator[](size_type __n) const
00219 {
00220 return _M_base()[__n];
00221 }
00222
00223 using _Base::at;
00224
00225 reference
00226 front()
00227 {
00228 return _Base::front();
00229 }
00230
00231 const_reference
00232 front() const
00233 {
00234 return _Base::front();
00235 }
00236
00237 reference
00238 back()
00239 {
00240 return _Base::back();
00241 }
00242
00243 const_reference
00244 back() const
00245 {
00246 return _Base::back();
00247 }
00248
00249
00250 void
00251 push_front(const _Tp& __x)
00252 {
00253 _Base::push_front(__x);
00254 }
00255
00256 void
00257 push_back(const _Tp& __x)
00258 {
00259 _Base::push_back(__x);
00260 }
00261
00262 #ifdef __GXX_EXPERIMENTAL_CXX0X__
00263 void
00264 push_front(_Tp&& __x)
00265 { emplace_front(std::move(__x)); }
00266
00267 void
00268 push_back(_Tp&& __x)
00269 { emplace_back(std::move(__x)); }
00270
00271 template<typename... _Args>
00272 void
00273 emplace_front(_Args&&... __args)
00274 {
00275 _Base::emplace_front(std::forward<_Args>(__args)...);
00276 }
00277
00278 template<typename... _Args>
00279 void
00280 emplace_back(_Args&&... __args)
00281 {
00282 _Base::emplace_back(std::forward<_Args>(__args)...);
00283 }
00284
00285 template<typename... _Args>
00286 iterator
00287 emplace(iterator __position, _Args&&... __args)
00288 {
00289 typename _Base::iterator __res = _Base::emplace(__position,
00290 std::forward<_Args>(__args)...);
00291 return iterator(__res);
00292 }
00293 #endif
00294
00295 iterator
00296 insert(iterator __position, const _Tp& __x)
00297 {
00298 typename _Base::iterator __res = _Base::insert(__position, __x);
00299 return iterator(__res);
00300 }
00301
00302 #ifdef __GXX_EXPERIMENTAL_CXX0X__
00303 iterator
00304 insert(iterator __position, _Tp&& __x)
00305 { return emplace(__position, std::move(__x)); }
00306
00307 void
00308 insert(iterator __p, initializer_list<value_type> __l)
00309 {
00310 _Base::insert(__p, __l);
00311 }
00312 #endif
00313
00314 void
00315 insert(iterator __position, size_type __n, const _Tp& __x)
00316 {
00317 _Base::insert(__position, __n, __x);
00318 }
00319
00320 template<class _InputIterator>
00321 void
00322 insert(iterator __position,
00323 _InputIterator __first, _InputIterator __last)
00324 {
00325 _Base::insert(__position, __first, __last);
00326 }
00327
00328 void
00329 pop_front()
00330 {
00331 _Base::pop_front();
00332 }
00333
00334 void
00335 pop_back()
00336 {
00337 _Base::pop_back();
00338 }
00339
00340 iterator
00341 erase(iterator __position)
00342 {
00343 if (__position == begin() || __position == end()-1)
00344 {
00345 return iterator(_Base::erase(__position));
00346 }
00347 else
00348 {
00349 typename _Base::iterator __res = _Base::erase(__position);
00350 return iterator(__res);
00351 }
00352 }
00353
00354 iterator
00355 erase(iterator __first, iterator __last)
00356 {
00357
00358
00359 return iterator(_Base::erase(__first, __last));
00360 }
00361
00362 void
00363 swap(deque& __x)
00364 {
00365 _Base::swap(__x);
00366 }
00367
00368 void
00369 clear()
00370 {
00371 _Base::clear();
00372 }
00373
00374 _Base&
00375 _M_base() { return *this; }
00376
00377 const _Base&
00378 _M_base() const { return *this; }
00379 };
00380
00381 template<typename _Tp, typename _Alloc>
00382 inline bool
00383 operator==(const deque<_Tp, _Alloc>& __lhs,
00384 const deque<_Tp, _Alloc>& __rhs)
00385 { return __lhs._M_base() == __rhs._M_base(); }
00386
00387 template<typename _Tp, typename _Alloc>
00388 inline bool
00389 operator!=(const deque<_Tp, _Alloc>& __lhs,
00390 const deque<_Tp, _Alloc>& __rhs)
00391 { return __lhs._M_base() != __rhs._M_base(); }
00392
00393 template<typename _Tp, typename _Alloc>
00394 inline bool
00395 operator<(const deque<_Tp, _Alloc>& __lhs,
00396 const deque<_Tp, _Alloc>& __rhs)
00397 { return __lhs._M_base() < __rhs._M_base(); }
00398
00399 template<typename _Tp, typename _Alloc>
00400 inline bool
00401 operator<=(const deque<_Tp, _Alloc>& __lhs,
00402 const deque<_Tp, _Alloc>& __rhs)
00403 { return __lhs._M_base() <= __rhs._M_base(); }
00404
00405 template<typename _Tp, typename _Alloc>
00406 inline bool
00407 operator>=(const deque<_Tp, _Alloc>& __lhs,
00408 const deque<_Tp, _Alloc>& __rhs)
00409 { return __lhs._M_base() >= __rhs._M_base(); }
00410
00411 template<typename _Tp, typename _Alloc>
00412 inline bool
00413 operator>(const deque<_Tp, _Alloc>& __lhs,
00414 const deque<_Tp, _Alloc>& __rhs)
00415 { return __lhs._M_base() > __rhs._M_base(); }
00416
00417 template<typename _Tp, typename _Alloc>
00418 inline void
00419 swap(deque<_Tp, _Alloc>& __lhs, deque<_Tp, _Alloc>& __rhs)
00420 { __lhs.swap(__rhs); }
00421
00422 }
00423 }
00424
00425 #endif