l4/pkg/libstdc++-v3/contrib/libstdc++-v3-4.6/include/profile/vector

   1 // Profiling vector implementation -*- C++ -*-
   2
   3 // Copyright (C) 2009, 2010 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 2, 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 // You should have received a copy of the GNU General Public License along
  17 // with this library; see the file COPYING.  If not, write to the Free
  18 // Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
  19 // USA.
  20
  21 // As a special exception, you may use this file as part of a free software
  22 // library without restriction.  Specifically, if other files instantiate
  23 // templates or use macros or inline functions from this file, or you compile
  24 // this file and link it with other files to produce an executable, this
  25 // file does not by itself cause the resulting executable to be covered by
  26 // the GNU General Public License.  This exception does not however
  27 // invalidate any other reasons why the executable file might be covered by
  28 // the GNU General Public License.
  29
  30 /** @file profile/vector
  31  *  This file is a GNU profile extension to the Standard C++ Library.
  32  */
  33
  34 #ifndef _GLIBCXX_PROFILE_VECTOR
  35 #define _GLIBCXX_PROFILE_VECTOR 1
  36
  37 #include <vector>
  38 #include <utility>
  39 #include <profile/base.h>
  40 #include <profile/iterator_tracker.h>
  41
  42 namespace std _GLIBCXX_VISIBILITY(default)
  43 {
  44 namespace __profile
  45 {
  46   template<typename _Tp,
  47            typename _Allocator = std::allocator<_Tp> >
  48     class vector
  49     : public _GLIBCXX_STD_C::vector<_Tp, _Allocator>
  50     {
  51       typedef _GLIBCXX_STD_C::vector<_Tp, _Allocator> _Base;
  52
  53     public:
  54       typedef typename _Base::reference             reference;
  55       typedef typename _Base::const_reference       const_reference;
  56
  57       typedef __iterator_tracker<typename _Base::iterator, vector>
  58                                                     iterator;
  59       typedef __iterator_tracker<typename _Base::const_iterator, vector>
  60                                                     const_iterator;
  61
  62       typedef typename _Base::size_type             size_type;
  63       typedef typename _Base::difference_type       difference_type;
  64
  65       typedef _Tp                                   value_type;
  66       typedef _Allocator                            allocator_type;
  67       typedef typename _Base::pointer               pointer;
  68       typedef typename _Base::const_pointer         const_pointer;
  69       typedef std::reverse_iterator<iterator>       reverse_iterator;
  70       typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
  71
  72       _Base&
  73       _M_base()       { return *this; }
  74
  75       const _Base&
  76       _M_base() const { return *this; }
  77
  78       // 23.2.4.1 construct/copy/destroy:
  79       explicit
  80       vector(const _Allocator& __a = _Allocator())
  81       : _Base(__a)
  82       {
  83         __profcxx_vector_construct(this, this->capacity());
  84         __profcxx_vector_construct2(this);
  85       }
  86
  87 #ifdef __GXX_EXPERIMENTAL_CXX0X__
  88       explicit
  89       vector(size_type __n)
  90       :  _Base(__n)
  91       {
  92         __profcxx_vector_construct(this, this->capacity());
  93         __profcxx_vector_construct2(this);
  94       }
  95
  96       vector(size_type __n, const _Tp& __value,
  97              const _Allocator& __a = _Allocator())
  98       :  _Base(__n, __value, __a)
  99       {
 100         __profcxx_vector_construct(this, this->capacity());
 101         __profcxx_vector_construct2(this);
 102       }
 103 #else
 104       explicit
 105       vector(size_type __n, const _Tp& __value = _Tp(),
 106              const _Allocator& __a = _Allocator())
 107       :  _Base(__n, __value, __a)
 108       {
 109         __profcxx_vector_construct(this, this->capacity());
 110         __profcxx_vector_construct2(this);
 111       }
 112 #endif
 113
 114       template<class _InputIterator>
 115         vector(_InputIterator __first, _InputIterator __last,
 116                const _Allocator& __a = _Allocator())
 117         : _Base(__first, __last, __a)
 118       {
 119         __profcxx_vector_construct(this, this->capacity());
 120         __profcxx_vector_construct2(this);
 121       }
 122
 123       vector(const vector& __x)
 124       : _Base(__x)
 125       {
 126         __profcxx_vector_construct(this, this->capacity());
 127         __profcxx_vector_construct2(this);
 128       }
 129
 130       /// Construction from a release-mode vector
 131       vector(const _Base& __x)
 132       : _Base(__x)
 133       {
 134         __profcxx_vector_construct(this, this->capacity());
 135         __profcxx_vector_construct2(this);
 136       }
 137
 138 #ifdef __GXX_EXPERIMENTAL_CXX0X__
 139       vector(vector&& __x)
 140       : _Base(std::move(__x))
 141       {
 142         __profcxx_vector_construct(this, this->capacity());
 143         __profcxx_vector_construct2(this);
 144       }
 145
 146       vector(initializer_list<value_type> __l,
 147              const allocator_type& __a = allocator_type())
 148       : _Base(__l, __a) { }
 149 #endif
 150
 151       ~vector() {
 152         __profcxx_vector_destruct(this, this->capacity(), this->size());
 153         __profcxx_vector_destruct2(this);
 154       }
 155
 156       vector&
 157       operator=(const vector& __x)
 158       {
 159         static_cast<_Base&>(*this) = __x;
 160         return *this;
 161       }
 162
 163 #ifdef __GXX_EXPERIMENTAL_CXX0X__
 164       vector&
 165       operator=(vector&& __x)
 166       {
 167         // NB: DR 1204.
 168         // NB: DR 675.
 169         this->clear();
 170         this->swap(__x);
 171         return *this;
 172       }
 173
 174       vector&
 175       operator=(initializer_list<value_type> __l)
 176       {
 177         static_cast<_Base&>(*this) = __l;
 178         return *this;
 179       }
 180 #endif
 181
 182       using _Base::assign;
 183       using _Base::get_allocator;
 184
 185
 186       // iterators:
 187       iterator
 188       begin()
 189       { return iterator(_Base::begin(), this); }
 190
 191       const_iterator
 192       begin() const
 193       { return const_iterator(_Base::begin(), this); }
 194
 195       iterator
 196       end()
 197       { return iterator(_Base::end(), this); }
 198
 199       const_iterator
 200       end() const
 201       { return const_iterator(_Base::end(), this); }
 202
 203       reverse_iterator
 204       rbegin()
 205       { return reverse_iterator(end()); }
 206
 207       const_reverse_iterator
 208       rbegin() const
 209       { return const_reverse_iterator(end()); }
 210
 211       reverse_iterator
 212       rend()
 213       { return reverse_iterator(begin()); }
 214
 215       const_reverse_iterator
 216       rend() const
 217       { return const_reverse_iterator(begin()); }
 218
 219 #ifdef __GXX_EXPERIMENTAL_CXX0X__
 220       const_iterator
 221       cbegin() const
 222       { return const_iterator(_Base::begin(), this); }
 223
 224       const_iterator
 225       cend() const
 226       { return const_iterator(_Base::end(), this); }
 227
 228       const_reverse_iterator
 229       crbegin() const
 230       { return const_reverse_iterator(end()); }
 231
 232       const_reverse_iterator
 233       crend() const
 234       { return const_reverse_iterator(begin()); }
 235 #endif
 236
 237       // 23.2.4.2 capacity:
 238       using _Base::size;
 239       using _Base::max_size;
 240
 241 #ifdef __GXX_EXPERIMENTAL_CXX0X__
 242       void
 243       resize(size_type __sz)
 244       {
 245         __profcxx_vector_invalid_operator(this);
 246         _M_profile_resize(this, this->capacity(), __sz);
 247         _Base::resize(__sz);
 248       }
 249
 250       void
 251       resize(size_type __sz, const _Tp& __c)
 252       {
 253         __profcxx_vector_invalid_operator(this);
 254         _M_profile_resize(this, this->capacity(), __sz);
 255         _Base::resize(__sz, __c);
 256       }
 257 #else
 258       void
 259       resize(size_type __sz, _Tp __c = _Tp())
 260       {
 261         __profcxx_vector_invalid_operator(this);
 262         _M_profile_resize(this, this->capacity(), __sz);
 263         _Base::resize(__sz, __c);
 264       }
 265 #endif
 266
 267 #ifdef __GXX_EXPERIMENTAL_CXX0X__
 268       using _Base::shrink_to_fit;
 269 #endif
 270
 271       using _Base::empty;
 272
 273       // element access:
 274       reference
 275       operator[](size_type __n)
 276       {
 277         __profcxx_vector_invalid_operator(this);
 278         return _M_base()[__n];
 279       }
 280       const_reference
 281       operator[](size_type __n) const
 282       {
 283         __profcxx_vector_invalid_operator(this);
 284         return _M_base()[__n];
 285       }
 286
 287       using _Base::at;
 288
 289       reference
 290       front()
 291       {
 292         return _Base::front();
 293       }
 294
 295       const_reference
 296       front() const
 297       {
 298         return _Base::front();
 299       }
 300
 301       reference
 302       back()
 303       {
 304         return _Base::back();
 305       }
 306
 307       const_reference
 308       back() const
 309       {
 310         return _Base::back();
 311       }
 312
 313       // _GLIBCXX_RESOLVE_LIB_DEFECTS
 314       // DR 464. Suggestion for new member functions in standard containers.
 315       using _Base::data;
 316
 317       // 23.2.4.3 modifiers:
 318       void
 319       push_back(const _Tp& __x)
 320       {
 321         size_type __old_size = this->capacity();
 322         _Base::push_back(__x);
 323         _M_profile_resize(this, __old_size, this->capacity());
 324       }
 325
 326 #ifdef __GXX_EXPERIMENTAL_CXX0X__
 327       void
 328       push_back(_Tp&& __x)
 329       {
 330         size_type __old_size = this->capacity();
 331         _Base::push_back(__x);
 332         _M_profile_resize(this, __old_size, this->capacity());
 333       }
 334
 335 #endif
 336
 337       iterator
 338       insert(iterator __position, const _Tp& __x)
 339       {
 340         __profcxx_vector_insert(this, __position.base() - _Base::begin(),
 341                                 this->size());
 342         size_type __old_size = this->capacity();
 343         typename _Base::iterator __res = _Base::insert(__position.base(), __x);
 344         _M_profile_resize(this, __old_size, this->capacity());
 345         return iterator(__res, this);
 346       }
 347
 348 #ifdef __GXX_EXPERIMENTAL_CXX0X__
 349       iterator
 350       insert(iterator __position, _Tp&& __x)
 351       {
 352         __profcxx_vector_insert(this, __position.base() - _Base::begin(),
 353                                 this->size());
 354         size_type __old_size = this->capacity();
 355         typename _Base::iterator __res = _Base::insert(__position.base(), __x);
 356         _M_profile_resize(this, __old_size, this->capacity());
 357         return iterator(__res, this);
 358       }
 359
 360       void
 361       insert(iterator __position, initializer_list<value_type> __l)
 362       { this->insert(__position, __l.begin(), __l.end()); }
 363 #endif
 364
 365 #ifdef __GXX_EXPERIMENTAL_CXX0X__
 366       void
 367       swap(vector&& __x)
 368       {
 369         _Base::swap(__x);
 370       }
 371 #endif
 372
 373       void
 374       swap(vector& __x)
 375       {
 376         _Base::swap(__x);
 377       }
 378
 379       void
 380       insert(iterator __position, size_type __n, const _Tp& __x)
 381       {
 382         __profcxx_vector_insert(this, __position.base() - _Base::begin(),
 383                                 this->size());
 384         size_type __old_size = this->capacity();
 385         _Base::insert(__position, __n, __x);
 386         _M_profile_resize(this, __old_size, this->capacity());
 387       }
 388
 389       template<class _InputIterator>
 390       void
 391       insert(iterator __position,
 392              _InputIterator __first, _InputIterator __last)
 393       {
 394         __profcxx_vector_insert(this, __position.base()-_Base::begin(),
 395                                 this->size());
 396         size_type __old_size = this->capacity();
 397         _Base::insert(__position, __first, __last);
 398         _M_profile_resize(this, __old_size, this->capacity());
 399       }
 400
 401
 402       iterator
 403       erase(iterator __position)
 404       {
 405         typename _Base::iterator __res = _Base::erase(__position.base());
 406         return iterator(__res, this);
 407       }
 408
 409       iterator
 410       erase(iterator __first, iterator __last)
 411       {
 412         // _GLIBCXX_RESOLVE_LIB_DEFECTS
 413         // 151. can't currently clear() empty container
 414         typename _Base::iterator __res = _Base::erase(__first.base(),
 415                                                       __last.base());
 416         return iterator(__res, this);
 417       }
 418
 419       void
 420       clear()
 421       {
 422         __profcxx_vector_destruct(this, this->capacity(), this->size());
 423         __profcxx_vector_destruct2(this);
 424         _Base::clear();
 425       }
 426
 427       inline void _M_profile_find() const
 428       {
 429         __profcxx_vector_find(this, size());
 430       }
 431
 432       inline void _M_profile_iterate(int __rewind = 0) const
 433       {
 434         __profcxx_vector_iterate(this);
 435       }
 436
 437     private:
 438       void _M_profile_resize(void* obj, size_type __old_size,
 439                              size_type __new_size)
 440       {
 441         if (__old_size < __new_size) {
 442           __profcxx_vector_resize(this, this->size(), __new_size);
 443           __profcxx_vector_resize2(this, this->size(), __new_size);
 444         }
 445       }
 446     };
 447
 448   template<typename _Tp, typename _Alloc>
 449     inline bool
 450     operator==(const vector<_Tp, _Alloc>& __lhs,
 451            const vector<_Tp, _Alloc>& __rhs)
 452     { return __lhs._M_base() == __rhs._M_base(); }
 453
 454   template<typename _Tp, typename _Alloc>
 455     inline bool
 456     operator!=(const vector<_Tp, _Alloc>& __lhs,
 457            const vector<_Tp, _Alloc>& __rhs)
 458     { return __lhs._M_base() != __rhs._M_base(); }
 459
 460   template<typename _Tp, typename _Alloc>
 461     inline bool
 462     operator<(const vector<_Tp, _Alloc>& __lhs,
 463           const vector<_Tp, _Alloc>& __rhs)
 464     { return __lhs._M_base() < __rhs._M_base(); }
 465
 466   template<typename _Tp, typename _Alloc>
 467     inline bool
 468     operator<=(const vector<_Tp, _Alloc>& __lhs,
 469            const vector<_Tp, _Alloc>& __rhs)
 470     { return __lhs._M_base() <= __rhs._M_base(); }
 471
 472   template<typename _Tp, typename _Alloc>
 473     inline bool
 474     operator>=(const vector<_Tp, _Alloc>& __lhs,
 475            const vector<_Tp, _Alloc>& __rhs)
 476     { return __lhs._M_base() >= __rhs._M_base(); }
 477
 478   template<typename _Tp, typename _Alloc>
 479     inline bool
 480     operator>(const vector<_Tp, _Alloc>& __lhs,
 481           const vector<_Tp, _Alloc>& __rhs)
 482     { return __lhs._M_base() > __rhs._M_base(); }
 483
 484   template<typename _Tp, typename _Alloc>
 485     inline void
 486     swap(vector<_Tp, _Alloc>& __lhs, vector<_Tp, _Alloc>& __rhs)
 487     { __lhs.swap(__rhs); }
 488
 489 #ifdef __GXX_EXPERIMENTAL_CXX0X__
 490   template<typename _Tp, typename _Alloc>
 491     inline void
 492     swap(vector<_Tp, _Alloc>&& __lhs, vector<_Tp, _Alloc>& __rhs)
 493     { __lhs.swap(__rhs); }
 494
 495   template<typename _Tp, typename _Alloc>
 496     inline void
 497     swap(vector<_Tp, _Alloc>& __lhs, vector<_Tp, _Alloc>&& __rhs)
 498     { __lhs.swap(__rhs); }
 499 #endif
 500
 501 } // namespace __profile
 502
 503 #ifdef __GXX_EXPERIMENTAL_CXX0X__
 504   // DR 1182.
 505   /// std::hash specialization for vector<bool>.
 506   template<typename _Alloc>
 507     struct hash<__profile::vector<bool, _Alloc>>
 508     : public __hash_base<size_t, __profile::vector<bool, _Alloc>>
 509     {
 510       size_t
 511       operator()(const __profile::vector<bool, _Alloc>& __b) const
 512       { return std::hash<_GLIBCXX_STD_C::vector<bool, _Alloc>>()
 513           (__b._M_base()); }
 514     };
 515 #endif
 516
 517 } // namespace std
 518
 519 #endif