1 // Profiling deque implementation -*- C++ -*- 2 3 // Copyright (C) 2009-2013 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 34 namespace std _GLIBCXX_VISIBILITY(default) 35 { 36 namespace __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 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 465 466 #endif 467
