]>
Commit | Line | Data |
---|---|---|
1218d701 SR |
1 | // Profiling vector implementation -*- C++ -*- |
2 | ||
79667f82 | 3 | // Copyright (C) 2009, 2010 Free Software Foundation, Inc. |
1218d701 SR |
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> | |
a1360f57 | 40 | #include <profile/iterator_tracker.h> |
1218d701 | 41 | |
12ffa228 | 42 | namespace std _GLIBCXX_VISIBILITY(default) |
1218d701 SR |
43 | { |
44 | namespace __profile | |
45 | { | |
1218d701 SR |
46 | template<typename _Tp, |
47 | typename _Allocator = std::allocator<_Tp> > | |
48 | class vector | |
12ffa228 | 49 | : public _GLIBCXX_STD_C::vector<_Tp, _Allocator> |
1218d701 | 50 | { |
12ffa228 | 51 | typedef _GLIBCXX_STD_C::vector<_Tp, _Allocator> _Base; |
1218d701 SR |
52 | |
53 | public: | |
54 | typedef typename _Base::reference reference; | |
55 | typedef typename _Base::const_reference const_reference; | |
56 | ||
a1360f57 SR |
57 | typedef __iterator_tracker<typename _Base::iterator, vector> |
58 | iterator; | |
59 | typedef __iterator_tracker<typename _Base::const_iterator, vector> | |
60 | const_iterator; | |
1218d701 SR |
61 | |
62 | typedef typename _Base::size_type size_type; | |
63 | typedef typename _Base::difference_type difference_type; | |
64 | ||
a1360f57 SR |
65 | typedef _Tp value_type; |
66 | typedef _Allocator allocator_type; | |
1218d701 SR |
67 | typedef typename _Base::pointer pointer; |
68 | typedef typename _Base::const_pointer const_pointer; | |
a1360f57 SR |
69 | typedef std::reverse_iterator<iterator> reverse_iterator; |
70 | typedef std::reverse_iterator<const_iterator> const_reverse_iterator; | |
71 | ||
1218d701 SR |
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: | |
dc2cf706 PC |
79 | explicit |
80 | vector(const _Allocator& __a = _Allocator()) | |
1218d701 SR |
81 | : _Base(__a) |
82 | { | |
83 | __profcxx_vector_construct(this, this->capacity()); | |
84 | __profcxx_vector_construct2(this); | |
85 | } | |
86 | ||
dc2cf706 PC |
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()) | |
1218d701 SR |
98 | : _Base(__n, __value, __a) |
99 | { | |
100 | __profcxx_vector_construct(this, this->capacity()); | |
101 | __profcxx_vector_construct2(this); | |
102 | } | |
dc2cf706 PC |
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 | |
1218d701 SR |
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) | |
5f1fd346 | 140 | : _Base(std::move(__x)) |
1218d701 SR |
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 | { | |
0462fd5e PC |
167 | // NB: DR 1204. |
168 | // NB: DR 675. | |
169 | this->clear(); | |
170 | this->swap(__x); | |
171 | return *this; | |
1218d701 SR |
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 | ||
a1360f57 SR |
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 | ||
1218d701 SR |
237 | // 23.2.4.2 capacity: |
238 | using _Base::size; | |
239 | using _Base::max_size; | |
240 | ||
dc2cf706 PC |
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 | |
1218d701 SR |
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 | } | |
dc2cf706 | 265 | #endif |
1218d701 | 266 | |
79667f82 PC |
267 | #ifdef __GXX_EXPERIMENTAL_CXX0X__ |
268 | using _Base::shrink_to_fit; | |
269 | #endif | |
270 | ||
1218d701 SR |
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 | { | |
a1360f57 SR |
340 | __profcxx_vector_insert(this, __position.base() - _Base::begin(), |
341 | this->size()); | |
1218d701 | 342 | size_type __old_size = this->capacity(); |
a1360f57 | 343 | typename _Base::iterator __res = _Base::insert(__position.base(), __x); |
1218d701 | 344 | _M_profile_resize(this, __old_size, this->capacity()); |
a1360f57 | 345 | return iterator(__res, this); |
1218d701 SR |
346 | } |
347 | ||
348 | #ifdef __GXX_EXPERIMENTAL_CXX0X__ | |
349 | iterator | |
350 | insert(iterator __position, _Tp&& __x) | |
351 | { | |
a1360f57 SR |
352 | __profcxx_vector_insert(this, __position.base() - _Base::begin(), |
353 | this->size()); | |
1218d701 | 354 | size_type __old_size = this->capacity(); |
a1360f57 | 355 | typename _Base::iterator __res = _Base::insert(__position.base(), __x); |
1218d701 | 356 | _M_profile_resize(this, __old_size, this->capacity()); |
a1360f57 | 357 | return iterator(__res, this); |
1218d701 SR |
358 | } |
359 | ||
360 | void | |
361 | insert(iterator __position, initializer_list<value_type> __l) | |
362 | { this->insert(__position, __l.begin(), __l.end()); } | |
363 | #endif | |
364 | ||
a1360f57 | 365 | #ifdef __GXX_EXPERIMENTAL_CXX0X__ |
1218d701 | 366 | void |
a1360f57 SR |
367 | swap(vector&& __x) |
368 | { | |
369 | _Base::swap(__x); | |
370 | } | |
371 | #endif | |
1218d701 | 372 | |
a1360f57 | 373 | void |
1218d701 SR |
374 | swap(vector& __x) |
375 | { | |
376 | _Base::swap(__x); | |
377 | } | |
378 | ||
1218d701 SR |
379 | void |
380 | insert(iterator __position, size_type __n, const _Tp& __x) | |
381 | { | |
a1360f57 SR |
382 | __profcxx_vector_insert(this, __position.base() - _Base::begin(), |
383 | this->size()); | |
1218d701 | 384 | size_type __old_size = this->capacity(); |
a1360f57 | 385 | _Base::insert(__position, __n, __x); |
1218d701 SR |
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 | { | |
a1360f57 SR |
394 | __profcxx_vector_insert(this, __position.base()-_Base::begin(), |
395 | this->size()); | |
1218d701 SR |
396 | size_type __old_size = this->capacity(); |
397 | _Base::insert(__position, __first, __last); | |
398 | _M_profile_resize(this, __old_size, this->capacity()); | |
399 | } | |
400 | ||
a1360f57 SR |
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 | ||
1218d701 SR |
419 | void |
420 | clear() | |
421 | { | |
422 | __profcxx_vector_destruct(this, this->capacity(), this->size()); | |
423 | __profcxx_vector_destruct2(this); | |
424 | _Base::clear(); | |
425 | } | |
426 | ||
a1360f57 | 427 | inline void _M_profile_find() const |
1218d701 | 428 | { |
a1360f57 | 429 | __profcxx_vector_find(this, size()); |
1218d701 SR |
430 | } |
431 | ||
a1360f57 | 432 | inline void _M_profile_iterate(int __rewind = 0) const |
1218d701 | 433 | { |
a1360f57 | 434 | __profcxx_vector_iterate(this); |
1218d701 SR |
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 | ||
a1360f57 SR |
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 | ||
1218d701 | 501 | } // namespace __profile |
4cd533a7 PC |
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>> | |
5d64ee19 | 508 | : public __hash_base<size_t, __profile::vector<bool, _Alloc>> |
4cd533a7 PC |
509 | { |
510 | size_t | |
95addb1b | 511 | operator()(const __profile::vector<bool, _Alloc>& __b) const |
12ffa228 | 512 | { return std::hash<_GLIBCXX_STD_C::vector<bool, _Alloc>>() |
4cd533a7 PC |
513 | (__b._M_base()); } |
514 | }; | |
515 | #endif | |
516 | ||
1218d701 SR |
517 | } // namespace std |
518 | ||
519 | #endif |