OSDN Git Service

7a33e88be01ec9853a6825ed71ed69c8468d2096
[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     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() _GLIBCXX_NOEXCEPT { return *this; }
74
75       const _Base&
76       _M_base() const _GLIBCXX_NOEXCEPT { 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) noexcept
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() _GLIBCXX_NOEXCEPT
152       {
153         __profcxx_vector_destruct(this, this->capacity(), this->size());
154         __profcxx_vector_destruct2(this);
155       }
156
157       vector&
158       operator=(const vector& __x)
159       {
160         static_cast<_Base&>(*this) = __x;
161         return *this;
162       }
163
164 #ifdef __GXX_EXPERIMENTAL_CXX0X__
165       vector&
166       operator=(vector&& __x)
167       {
168         // NB: DR 1204.
169         // NB: DR 675.
170         this->clear();
171         this->swap(__x);
172         return *this;
173       }
174
175       vector&
176       operator=(initializer_list<value_type> __l)
177       {
178         static_cast<_Base&>(*this) = __l;
179         return *this;
180       }
181 #endif
182
183       using _Base::assign;
184       using _Base::get_allocator;
185
186
187       // iterators:
188       iterator
189       begin() _GLIBCXX_NOEXCEPT
190       { return iterator(_Base::begin(), this); }
191
192       const_iterator
193       begin() const _GLIBCXX_NOEXCEPT
194       { return const_iterator(_Base::begin(), this); }
195
196       iterator
197       end() _GLIBCXX_NOEXCEPT
198       { return iterator(_Base::end(), this); }
199
200       const_iterator
201       end() const _GLIBCXX_NOEXCEPT
202       { return const_iterator(_Base::end(), this); }
203
204       reverse_iterator
205       rbegin() _GLIBCXX_NOEXCEPT
206       { return reverse_iterator(end()); }
207
208       const_reverse_iterator
209       rbegin() const _GLIBCXX_NOEXCEPT
210       { return const_reverse_iterator(end()); }
211
212       reverse_iterator
213       rend() _GLIBCXX_NOEXCEPT
214       { return reverse_iterator(begin()); }
215
216       const_reverse_iterator
217       rend() const _GLIBCXX_NOEXCEPT
218       { return const_reverse_iterator(begin()); }
219
220 #ifdef __GXX_EXPERIMENTAL_CXX0X__
221       const_iterator
222       cbegin() const noexcept
223       { return const_iterator(_Base::begin(), this); }
224
225       const_iterator
226       cend() const noexcept
227       { return const_iterator(_Base::end(), this); }
228
229       const_reverse_iterator
230       crbegin() const noexcept
231       { return const_reverse_iterator(end()); }
232
233       const_reverse_iterator
234       crend() const noexcept
235       { return const_reverse_iterator(begin()); }
236 #endif
237
238       // 23.2.4.2 capacity:
239       using _Base::size;
240       using _Base::max_size;
241
242 #ifdef __GXX_EXPERIMENTAL_CXX0X__
243       void
244       resize(size_type __sz)
245       {
246         __profcxx_vector_invalid_operator(this);
247         _M_profile_resize(this, this->capacity(), __sz);
248         _Base::resize(__sz);
249       }
250
251       void
252       resize(size_type __sz, const _Tp& __c)
253       {
254         __profcxx_vector_invalid_operator(this);
255         _M_profile_resize(this, this->capacity(), __sz);
256         _Base::resize(__sz, __c);
257       }
258 #else
259       void
260       resize(size_type __sz, _Tp __c = _Tp())
261       {
262         __profcxx_vector_invalid_operator(this);
263         _M_profile_resize(this, this->capacity(), __sz);
264         _Base::resize(__sz, __c);
265       }
266 #endif
267
268 #ifdef __GXX_EXPERIMENTAL_CXX0X__
269       using _Base::shrink_to_fit;
270 #endif
271
272       using _Base::empty;
273
274       // element access:
275       reference
276       operator[](size_type __n)
277       {
278         __profcxx_vector_invalid_operator(this);
279         return _M_base()[__n];
280       }
281       const_reference
282       operator[](size_type __n) const
283       {
284         __profcxx_vector_invalid_operator(this);
285         return _M_base()[__n];
286       }
287
288       using _Base::at;
289
290       reference
291       front()
292       { 
293         return _Base::front();
294       }
295
296       const_reference
297       front() const
298       {
299         return _Base::front();
300       }
301
302       reference
303       back()
304       {
305         return _Base::back();
306       }
307
308       const_reference
309       back() const
310       {
311         return _Base::back();
312       }
313
314       // _GLIBCXX_RESOLVE_LIB_DEFECTS
315       // DR 464. Suggestion for new member functions in standard containers.
316       using _Base::data;
317
318       // 23.2.4.3 modifiers:
319       void
320       push_back(const _Tp& __x)
321       {
322         size_type __old_size = this->capacity();
323         _Base::push_back(__x);
324         _M_profile_resize(this, __old_size, this->capacity());
325       }
326
327 #ifdef __GXX_EXPERIMENTAL_CXX0X__
328       void
329       push_back(_Tp&& __x)
330       {
331         size_type __old_size = this->capacity();
332         _Base::push_back(__x);
333         _M_profile_resize(this, __old_size, this->capacity());
334       }
335
336 #endif
337
338       iterator
339       insert(iterator __position, const _Tp& __x)
340       {
341         __profcxx_vector_insert(this, __position.base() - _Base::begin(),
342                                 this->size());
343         size_type __old_size = this->capacity();
344         typename _Base::iterator __res = _Base::insert(__position.base(), __x);
345         _M_profile_resize(this, __old_size, this->capacity());
346         return iterator(__res, this);
347       }
348
349 #ifdef __GXX_EXPERIMENTAL_CXX0X__
350       iterator
351       insert(iterator __position, _Tp&& __x)
352       {
353         __profcxx_vector_insert(this, __position.base() - _Base::begin(),
354                                 this->size());
355         size_type __old_size = this->capacity();
356         typename _Base::iterator __res = _Base::insert(__position.base(), __x);
357         _M_profile_resize(this, __old_size, this->capacity());
358         return iterator(__res, this);
359       }
360
361       void
362       insert(iterator __position, initializer_list<value_type> __l)
363       { this->insert(__position, __l.begin(), __l.end()); }
364 #endif
365
366 #ifdef __GXX_EXPERIMENTAL_CXX0X__
367       void
368       swap(vector&& __x)
369       {
370         _Base::swap(__x);
371       }
372 #endif
373
374       void
375       swap(vector& __x)
376       {
377         _Base::swap(__x);
378       }
379
380       void
381       insert(iterator __position, size_type __n, const _Tp& __x)
382       {
383         __profcxx_vector_insert(this, __position.base() - _Base::begin(),
384                                 this->size());
385         size_type __old_size = this->capacity();
386         _Base::insert(__position, __n, __x);
387         _M_profile_resize(this, __old_size, this->capacity());
388       }
389
390       template<class _InputIterator>
391       void
392       insert(iterator __position,
393              _InputIterator __first, _InputIterator __last)
394       {
395         __profcxx_vector_insert(this, __position.base()-_Base::begin(),
396                                 this->size());
397         size_type __old_size = this->capacity();
398         _Base::insert(__position, __first, __last);
399         _M_profile_resize(this, __old_size, this->capacity());
400       }
401
402
403       iterator
404       erase(iterator __position)
405       {
406         typename _Base::iterator __res = _Base::erase(__position.base());
407         return iterator(__res, this);
408       }
409
410       iterator
411       erase(iterator __first, iterator __last)
412       {
413         // _GLIBCXX_RESOLVE_LIB_DEFECTS
414         // 151. can't currently clear() empty container
415         typename _Base::iterator __res = _Base::erase(__first.base(),
416                                                       __last.base());
417         return iterator(__res, this);
418       }
419
420       void
421       clear() _GLIBCXX_NOEXCEPT
422       {
423         __profcxx_vector_destruct(this, this->capacity(), this->size());
424         __profcxx_vector_destruct2(this);
425         _Base::clear();
426       }
427
428       inline void _M_profile_find() const 
429       { 
430         __profcxx_vector_find(this, size()); 
431       }
432
433       inline void _M_profile_iterate(int __rewind = 0) const 
434       { 
435         __profcxx_vector_iterate(this); 
436       }
437
438     private:
439       void _M_profile_resize(void* obj, size_type __old_size, 
440                              size_type __new_size)
441       {
442         if (__old_size < __new_size) {
443           __profcxx_vector_resize(this, this->size(), __new_size);
444           __profcxx_vector_resize2(this, this->size(), __new_size);
445         }
446       }
447     };
448
449   template<typename _Tp, typename _Alloc>
450     inline bool
451     operator==(const vector<_Tp, _Alloc>& __lhs,
452            const vector<_Tp, _Alloc>& __rhs)
453     { return __lhs._M_base() == __rhs._M_base(); }
454
455   template<typename _Tp, typename _Alloc>
456     inline bool
457     operator!=(const vector<_Tp, _Alloc>& __lhs,
458            const vector<_Tp, _Alloc>& __rhs)
459     { return __lhs._M_base() != __rhs._M_base(); }
460
461   template<typename _Tp, typename _Alloc>
462     inline bool
463     operator<(const vector<_Tp, _Alloc>& __lhs,
464           const vector<_Tp, _Alloc>& __rhs)
465     { return __lhs._M_base() < __rhs._M_base(); }
466
467   template<typename _Tp, typename _Alloc>
468     inline bool
469     operator<=(const vector<_Tp, _Alloc>& __lhs,
470            const vector<_Tp, _Alloc>& __rhs)
471     { return __lhs._M_base() <= __rhs._M_base(); }
472
473   template<typename _Tp, typename _Alloc>
474     inline bool
475     operator>=(const vector<_Tp, _Alloc>& __lhs,
476            const vector<_Tp, _Alloc>& __rhs)
477     { return __lhs._M_base() >= __rhs._M_base(); }
478
479   template<typename _Tp, typename _Alloc>
480     inline bool
481     operator>(const vector<_Tp, _Alloc>& __lhs,
482           const vector<_Tp, _Alloc>& __rhs)
483     { return __lhs._M_base() > __rhs._M_base(); }
484
485   template<typename _Tp, typename _Alloc>
486     inline void
487     swap(vector<_Tp, _Alloc>& __lhs, vector<_Tp, _Alloc>& __rhs)
488     { __lhs.swap(__rhs); }
489
490 #ifdef __GXX_EXPERIMENTAL_CXX0X__
491   template<typename _Tp, typename _Alloc>
492     inline void
493     swap(vector<_Tp, _Alloc>&& __lhs, vector<_Tp, _Alloc>& __rhs)
494     { __lhs.swap(__rhs); }
495
496   template<typename _Tp, typename _Alloc>
497     inline void
498     swap(vector<_Tp, _Alloc>& __lhs, vector<_Tp, _Alloc>&& __rhs)
499     { __lhs.swap(__rhs); }
500 #endif
501
502 } // namespace __profile
503
504 #ifdef __GXX_EXPERIMENTAL_CXX0X__
505   // DR 1182.
506   /// std::hash specialization for vector<bool>.
507   template<typename _Alloc>
508     struct hash<__profile::vector<bool, _Alloc>>
509     : public __hash_base<size_t, __profile::vector<bool, _Alloc>>
510     {
511       size_t
512       operator()(const __profile::vector<bool, _Alloc>& __b) const
513       { return std::hash<_GLIBCXX_STD_C::vector<bool, _Alloc>>()
514           (__b._M_base()); }
515     };
516 #endif
517
518 } // namespace std
519
520 #endif