l4/pkg/l4re-core/libstdc++-v3/contrib/libstdc++-v3-4.9/include/profile/deque

   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
  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
  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