libstdc++-v3/include/profile/deque

   1 // Profiling deque implementation -*- C++ -*-
   2
   3 // Copyright (C) 2009-2012 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