OSDN Git Service

* include/bits/stl_vector.h (vector::_Alloc_traits): Make private.
[pf3gnuchains/gcc-fork.git] / libstdc++-v3 / include / profile / vector
1 // Profiling vector implementation -*- C++ -*-
2
3 // Copyright (C) 2009, 2010, 2011 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 #ifdef __GXX_EXPERIMENTAL_CXX0X__
54       typedef __gnu_cxx::__alloc_traits<_Allocator>  _Alloc_traits;
55 #endif
56
57     public:
58       typedef typename _Base::reference             reference;
59       typedef typename _Base::const_reference       const_reference;
60
61       typedef __iterator_tracker<typename _Base::iterator, vector>
62                                                     iterator;
63       typedef __iterator_tracker<typename _Base::const_iterator, vector>
64                                                     const_iterator;
65
66       typedef typename _Base::size_type             size_type;
67       typedef typename _Base::difference_type       difference_type;
68
69       typedef _Tp                                   value_type;
70       typedef _Allocator                            allocator_type;
71       typedef typename _Base::pointer               pointer;
72       typedef typename _Base::const_pointer         const_pointer;
73       typedef std::reverse_iterator<iterator>       reverse_iterator;
74       typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
75       
76       _Base&
77       _M_base() _GLIBCXX_NOEXCEPT { return *this; }
78
79       const _Base&
80       _M_base() const _GLIBCXX_NOEXCEPT { return *this; }
81
82       // 23.2.4.1 construct/copy/destroy:
83       explicit
84       vector(const _Allocator& __a = _Allocator())
85       : _Base(__a)
86       {
87         __profcxx_vector_construct(this, this->capacity());
88         __profcxx_vector_construct2(this);
89       }
90
91 #ifdef __GXX_EXPERIMENTAL_CXX0X__
92       explicit
93       vector(size_type __n)
94       : _Base(__n)
95       {
96         __profcxx_vector_construct(this, this->capacity());
97         __profcxx_vector_construct2(this);
98       }
99
100       vector(size_type __n, const _Tp& __value,
101              const _Allocator& __a = _Allocator())
102       :  _Base(__n, __value, __a)
103       {
104         __profcxx_vector_construct(this, this->capacity());
105         __profcxx_vector_construct2(this);
106       }
107 #else
108       explicit
109       vector(size_type __n, const _Tp& __value = _Tp(),
110              const _Allocator& __a = _Allocator())
111       : _Base(__n, __value, __a)
112       {
113         __profcxx_vector_construct(this, this->capacity());
114         __profcxx_vector_construct2(this);
115       }
116 #endif
117
118       template<class _InputIterator>
119         vector(_InputIterator __first, _InputIterator __last,
120                const _Allocator& __a = _Allocator())
121         : _Base(__first, __last, __a)
122         {
123           __profcxx_vector_construct(this, this->capacity());
124           __profcxx_vector_construct2(this);
125         }
126
127       vector(const vector& __x)
128       : _Base(__x) 
129       {
130         __profcxx_vector_construct(this, this->capacity());
131         __profcxx_vector_construct2(this);
132       }
133
134       /// Construction from a release-mode vector
135       vector(const _Base& __x)
136       : _Base(__x) 
137       { 
138         __profcxx_vector_construct(this, this->capacity());
139         __profcxx_vector_construct2(this);
140       }
141
142 #ifdef __GXX_EXPERIMENTAL_CXX0X__
143       vector(vector&& __x) noexcept
144       : _Base(std::move(__x))
145       {
146         __profcxx_vector_construct(this, this->capacity());
147         __profcxx_vector_construct2(this);
148       }
149
150       vector(const _Base& __x, const _Allocator& __a)
151       : _Base(__x) 
152       { 
153         __profcxx_vector_construct(this, this->capacity());
154         __profcxx_vector_construct2(this);
155       }
156
157       vector(vector&& __x, const _Allocator& __a) noexcept
158       : _Base(std::move(__x), __a)
159       {
160         __profcxx_vector_construct(this, this->capacity());
161         __profcxx_vector_construct2(this);
162       }
163
164       vector(initializer_list<value_type> __l,
165              const allocator_type& __a = allocator_type())
166       : _Base(__l, __a) { }
167 #endif
168
169       ~vector() _GLIBCXX_NOEXCEPT
170       {
171         __profcxx_vector_destruct(this, this->capacity(), this->size());
172         __profcxx_vector_destruct2(this);
173       }
174
175       vector&
176       operator=(const vector& __x)
177       {
178         static_cast<_Base&>(*this) = __x;
179         return *this;
180       }
181
182 #ifdef __GXX_EXPERIMENTAL_CXX0X__
183       vector&
184       operator=(vector&& __x) noexcept(_Alloc_traits::_S_nothrow_move())
185       {
186         __profcxx_vector_destruct(this, this->capacity(), this->size());
187         __profcxx_vector_destruct2(this);
188         static_cast<_Base&>(*this) = std::move(__x);
189         return *this;
190       }
191
192       vector&
193       operator=(initializer_list<value_type> __l)
194       {
195         static_cast<_Base&>(*this) = __l;
196         return *this;
197       }
198 #endif
199
200       using _Base::assign;
201       using _Base::get_allocator;
202
203
204       // iterators:
205       iterator
206       begin() _GLIBCXX_NOEXCEPT
207       { return iterator(_Base::begin(), this); }
208
209       const_iterator
210       begin() const _GLIBCXX_NOEXCEPT
211       { return const_iterator(_Base::begin(), this); }
212
213       iterator
214       end() _GLIBCXX_NOEXCEPT
215       { return iterator(_Base::end(), this); }
216
217       const_iterator
218       end() const _GLIBCXX_NOEXCEPT
219       { return const_iterator(_Base::end(), this); }
220
221       reverse_iterator
222       rbegin() _GLIBCXX_NOEXCEPT
223       { return reverse_iterator(end()); }
224
225       const_reverse_iterator
226       rbegin() const _GLIBCXX_NOEXCEPT
227       { return const_reverse_iterator(end()); }
228
229       reverse_iterator
230       rend() _GLIBCXX_NOEXCEPT
231       { return reverse_iterator(begin()); }
232
233       const_reverse_iterator
234       rend() const _GLIBCXX_NOEXCEPT
235       { return const_reverse_iterator(begin()); }
236
237 #ifdef __GXX_EXPERIMENTAL_CXX0X__
238       const_iterator
239       cbegin() const noexcept
240       { return const_iterator(_Base::begin(), this); }
241
242       const_iterator
243       cend() const noexcept
244       { return const_iterator(_Base::end(), this); }
245
246       const_reverse_iterator
247       crbegin() const noexcept
248       { return const_reverse_iterator(end()); }
249
250       const_reverse_iterator
251       crend() const noexcept
252       { return const_reverse_iterator(begin()); }
253 #endif
254
255       // 23.2.4.2 capacity:
256       using _Base::size;
257       using _Base::max_size;
258
259 #ifdef __GXX_EXPERIMENTAL_CXX0X__
260       void
261       resize(size_type __sz)
262       {
263         __profcxx_vector_invalid_operator(this);
264         _M_profile_resize(this, this->capacity(), __sz);
265         _Base::resize(__sz);
266       }
267
268       void
269       resize(size_type __sz, const _Tp& __c)
270       {
271         __profcxx_vector_invalid_operator(this);
272         _M_profile_resize(this, this->capacity(), __sz);
273         _Base::resize(__sz, __c);
274       }
275 #else
276       void
277       resize(size_type __sz, _Tp __c = _Tp())
278       {
279         __profcxx_vector_invalid_operator(this);
280         _M_profile_resize(this, this->capacity(), __sz);
281         _Base::resize(__sz, __c);
282       }
283 #endif
284
285 #ifdef __GXX_EXPERIMENTAL_CXX0X__
286       using _Base::shrink_to_fit;
287 #endif
288
289       using _Base::empty;
290
291       // element access:
292       reference
293       operator[](size_type __n)
294       {
295         __profcxx_vector_invalid_operator(this);
296         return _M_base()[__n];
297       }
298       const_reference
299       operator[](size_type __n) const
300       {
301         __profcxx_vector_invalid_operator(this);
302         return _M_base()[__n];
303       }
304
305       using _Base::at;
306
307       reference
308       front()
309       { 
310         return _Base::front();
311       }
312
313       const_reference
314       front() const
315       {
316         return _Base::front();
317       }
318
319       reference
320       back()
321       {
322         return _Base::back();
323       }
324
325       const_reference
326       back() const
327       {
328         return _Base::back();
329       }
330
331       // _GLIBCXX_RESOLVE_LIB_DEFECTS
332       // DR 464. Suggestion for new member functions in standard containers.
333       using _Base::data;
334
335       // 23.2.4.3 modifiers:
336       void
337       push_back(const _Tp& __x)
338       {
339         size_type __old_size = this->capacity();
340         _Base::push_back(__x);
341         _M_profile_resize(this, __old_size, this->capacity());
342       }
343
344 #ifdef __GXX_EXPERIMENTAL_CXX0X__
345       void
346       push_back(_Tp&& __x)
347       {
348         size_type __old_size = this->capacity();
349         _Base::push_back(std::move(__x));
350         _M_profile_resize(this, __old_size, this->capacity());
351       }
352
353 #endif
354
355       iterator
356       insert(iterator __position, const _Tp& __x)
357       {
358         __profcxx_vector_insert(this, __position.base() - _Base::begin(),
359                                 this->size());
360         size_type __old_size = this->capacity();
361         typename _Base::iterator __res = _Base::insert(__position.base(), __x);
362         _M_profile_resize(this, __old_size, this->capacity());
363         return iterator(__res, this);
364       }
365
366 #ifdef __GXX_EXPERIMENTAL_CXX0X__
367       iterator
368       insert(iterator __position, _Tp&& __x)
369       {
370         __profcxx_vector_insert(this, __position.base() - _Base::begin(),
371                                 this->size());
372         size_type __old_size = this->capacity();
373         typename _Base::iterator __res = _Base::insert(__position.base(), __x);
374         _M_profile_resize(this, __old_size, this->capacity());
375         return iterator(__res, this);
376       }
377
378       void
379       insert(iterator __position, initializer_list<value_type> __l)
380       { this->insert(__position, __l.begin(), __l.end()); }
381 #endif
382
383 #ifdef __GXX_EXPERIMENTAL_CXX0X__
384       void
385       swap(vector&& __x)
386       {
387         _Base::swap(__x);
388       }
389 #endif
390
391       void
392       swap(vector& __x)
393 #ifdef __GXX_EXPERIMENTAL_CXX0X__
394                         noexcept(_Alloc_traits::_S_nothrow_swap())
395 #endif
396       {
397         _Base::swap(__x);
398       }
399
400       void
401       insert(iterator __position, size_type __n, const _Tp& __x)
402       {
403         __profcxx_vector_insert(this, __position.base() - _Base::begin(),
404                                 this->size());
405         size_type __old_size = this->capacity();
406         _Base::insert(__position, __n, __x);
407         _M_profile_resize(this, __old_size, this->capacity());
408       }
409
410       template<class _InputIterator>
411       void
412       insert(iterator __position,
413              _InputIterator __first, _InputIterator __last)
414       {
415         __profcxx_vector_insert(this, __position.base()-_Base::begin(),
416                                 this->size());
417         size_type __old_size = this->capacity();
418         _Base::insert(__position, __first, __last);
419         _M_profile_resize(this, __old_size, this->capacity());
420       }
421
422
423       iterator
424       erase(iterator __position)
425       {
426         typename _Base::iterator __res = _Base::erase(__position.base());
427         return iterator(__res, this);
428       }
429
430       iterator
431       erase(iterator __first, iterator __last)
432       {
433         // _GLIBCXX_RESOLVE_LIB_DEFECTS
434         // 151. can't currently clear() empty container
435         typename _Base::iterator __res = _Base::erase(__first.base(),
436                                                       __last.base());
437         return iterator(__res, this);
438       }
439
440       void
441       clear() _GLIBCXX_NOEXCEPT
442       {
443         __profcxx_vector_destruct(this, this->capacity(), this->size());
444         __profcxx_vector_destruct2(this);
445         _Base::clear();
446       }
447
448       inline void _M_profile_find() const 
449       { 
450         __profcxx_vector_find(this, size()); 
451       }
452
453       inline void _M_profile_iterate(int __rewind = 0) const 
454       { 
455         __profcxx_vector_iterate(this); 
456       }
457
458     private:
459       void _M_profile_resize(void* obj, size_type __old_size, 
460                              size_type __new_size)
461       {
462         if (__old_size < __new_size) {
463           __profcxx_vector_resize(this, this->size(), __new_size);
464           __profcxx_vector_resize2(this, this->size(), __new_size);
465         }
466       }
467     };
468
469   template<typename _Tp, typename _Alloc>
470     inline bool
471     operator==(const vector<_Tp, _Alloc>& __lhs,
472            const vector<_Tp, _Alloc>& __rhs)
473     { return __lhs._M_base() == __rhs._M_base(); }
474
475   template<typename _Tp, typename _Alloc>
476     inline bool
477     operator!=(const vector<_Tp, _Alloc>& __lhs,
478            const vector<_Tp, _Alloc>& __rhs)
479     { return __lhs._M_base() != __rhs._M_base(); }
480
481   template<typename _Tp, typename _Alloc>
482     inline bool
483     operator<(const vector<_Tp, _Alloc>& __lhs,
484           const vector<_Tp, _Alloc>& __rhs)
485     { return __lhs._M_base() < __rhs._M_base(); }
486
487   template<typename _Tp, typename _Alloc>
488     inline bool
489     operator<=(const vector<_Tp, _Alloc>& __lhs,
490            const vector<_Tp, _Alloc>& __rhs)
491     { return __lhs._M_base() <= __rhs._M_base(); }
492
493   template<typename _Tp, typename _Alloc>
494     inline bool
495     operator>=(const vector<_Tp, _Alloc>& __lhs,
496            const vector<_Tp, _Alloc>& __rhs)
497     { return __lhs._M_base() >= __rhs._M_base(); }
498
499   template<typename _Tp, typename _Alloc>
500     inline bool
501     operator>(const vector<_Tp, _Alloc>& __lhs,
502           const vector<_Tp, _Alloc>& __rhs)
503     { return __lhs._M_base() > __rhs._M_base(); }
504
505   template<typename _Tp, typename _Alloc>
506     inline void
507     swap(vector<_Tp, _Alloc>& __lhs, vector<_Tp, _Alloc>& __rhs)
508     { __lhs.swap(__rhs); }
509
510 #ifdef __GXX_EXPERIMENTAL_CXX0X__
511   template<typename _Tp, typename _Alloc>
512     inline void
513     swap(vector<_Tp, _Alloc>&& __lhs, vector<_Tp, _Alloc>& __rhs)
514     { __lhs.swap(__rhs); }
515
516   template<typename _Tp, typename _Alloc>
517     inline void
518     swap(vector<_Tp, _Alloc>& __lhs, vector<_Tp, _Alloc>&& __rhs)
519     { __lhs.swap(__rhs); }
520 #endif
521
522 } // namespace __profile
523
524 #ifdef __GXX_EXPERIMENTAL_CXX0X__
525   // DR 1182.
526   /// std::hash specialization for vector<bool>.
527   template<typename _Alloc>
528     struct hash<__profile::vector<bool, _Alloc>>
529     : public __hash_base<size_t, __profile::vector<bool, _Alloc>>
530     {
531       size_t
532       operator()(const __profile::vector<bool, _Alloc>& __b) const
533       { return std::hash<_GLIBCXX_STD_C::vector<bool, _Alloc>>()
534           (__b._M_base()); }
535     };
536 #endif
537
538 } // namespace std
539
540 #endif