1 | // Raw memory manipulators -*- C++ -*- |
2 | |
3 | // Copyright (C) 2001-2019 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 | /* |
26 | * |
27 | * Copyright (c) 1994 |
28 | * Hewlett-Packard Company |
29 | * |
30 | * Permission to use, copy, modify, distribute and sell this software |
31 | * and its documentation for any purpose is hereby granted without fee, |
32 | * provided that the above copyright notice appear in all copies and |
33 | * that both that copyright notice and this permission notice appear |
34 | * in supporting documentation. Hewlett-Packard Company makes no |
35 | * representations about the suitability of this software for any |
36 | * purpose. It is provided "as is" without express or implied warranty. |
37 | * |
38 | * |
39 | * Copyright (c) 1996,1997 |
40 | * Silicon Graphics Computer Systems, Inc. |
41 | * |
42 | * Permission to use, copy, modify, distribute and sell this software |
43 | * and its documentation for any purpose is hereby granted without fee, |
44 | * provided that the above copyright notice appear in all copies and |
45 | * that both that copyright notice and this permission notice appear |
46 | * in supporting documentation. Silicon Graphics makes no |
47 | * representations about the suitability of this software for any |
48 | * purpose. It is provided "as is" without express or implied warranty. |
49 | */ |
50 | |
51 | /** @file bits/stl_uninitialized.h |
52 | * This is an internal header file, included by other library headers. |
53 | * Do not attempt to use it directly. @headername{memory} |
54 | */ |
55 | |
56 | #ifndef _STL_UNINITIALIZED_H |
57 | #define _STL_UNINITIALIZED_H 1 |
58 | |
59 | #if __cplusplus > 201402L |
60 | #include <utility> |
61 | #endif |
62 | |
63 | #if __cplusplus >= 201103L |
64 | #include <type_traits> |
65 | #endif |
66 | |
67 | namespace std _GLIBCXX_VISIBILITY(default) |
68 | { |
69 | _GLIBCXX_BEGIN_NAMESPACE_VERSION |
70 | |
71 | template<bool _TrivialValueTypes> |
72 | struct __uninitialized_copy |
73 | { |
74 | template<typename _InputIterator, typename _ForwardIterator> |
75 | static _ForwardIterator |
76 | __uninit_copy(_InputIterator __first, _InputIterator __last, |
77 | _ForwardIterator __result) |
78 | { |
79 | _ForwardIterator __cur = __result; |
80 | __try |
81 | { |
82 | for (; __first != __last; ++__first, (void)++__cur) |
83 | std::_Construct(std::__addressof(*__cur), *__first); |
84 | return __cur; |
85 | } |
86 | __catch(...) |
87 | { |
88 | std::_Destroy(__result, __cur); |
89 | __throw_exception_again; |
90 | } |
91 | } |
92 | }; |
93 | |
94 | template<> |
95 | struct __uninitialized_copy<true> |
96 | { |
97 | template<typename _InputIterator, typename _ForwardIterator> |
98 | static _ForwardIterator |
99 | __uninit_copy(_InputIterator __first, _InputIterator __last, |
100 | _ForwardIterator __result) |
101 | { return std::copy(__first, __last, __result); } |
102 | }; |
103 | |
104 | /** |
105 | * @brief Copies the range [first,last) into result. |
106 | * @param __first An input iterator. |
107 | * @param __last An input iterator. |
108 | * @param __result An output iterator. |
109 | * @return __result + (__first - __last) |
110 | * |
111 | * Like copy(), but does not require an initialized output range. |
112 | */ |
113 | template<typename _InputIterator, typename _ForwardIterator> |
114 | inline _ForwardIterator |
115 | uninitialized_copy(_InputIterator __first, _InputIterator __last, |
116 | _ForwardIterator __result) |
117 | { |
118 | typedef typename iterator_traits<_InputIterator>::value_type |
119 | _ValueType1; |
120 | typedef typename iterator_traits<_ForwardIterator>::value_type |
121 | _ValueType2; |
122 | #if __cplusplus < 201103L |
123 | const bool __assignable = true; |
124 | #else |
125 | // Trivial types can have deleted copy constructor, but the std::copy |
126 | // optimization that uses memmove would happily "copy" them anyway. |
127 | static_assert(is_constructible<_ValueType2, decltype(*__first)>::value, |
128 | "result type must be constructible from value type of input range" ); |
129 | |
130 | typedef typename iterator_traits<_InputIterator>::reference _RefType1; |
131 | typedef typename iterator_traits<_ForwardIterator>::reference _RefType2; |
132 | // Trivial types can have deleted assignment, so using std::copy |
133 | // would be ill-formed. Require assignability before using std::copy: |
134 | const bool __assignable = is_assignable<_RefType2, _RefType1>::value; |
135 | #endif |
136 | |
137 | return std::__uninitialized_copy<__is_trivial(_ValueType1) |
138 | && __is_trivial(_ValueType2) |
139 | && __assignable>:: |
140 | __uninit_copy(__first, __last, __result); |
141 | } |
142 | |
143 | |
144 | template<bool _TrivialValueType> |
145 | struct __uninitialized_fill |
146 | { |
147 | template<typename _ForwardIterator, typename _Tp> |
148 | static void |
149 | __uninit_fill(_ForwardIterator __first, _ForwardIterator __last, |
150 | const _Tp& __x) |
151 | { |
152 | _ForwardIterator __cur = __first; |
153 | __try |
154 | { |
155 | for (; __cur != __last; ++__cur) |
156 | std::_Construct(std::__addressof(*__cur), __x); |
157 | } |
158 | __catch(...) |
159 | { |
160 | std::_Destroy(__first, __cur); |
161 | __throw_exception_again; |
162 | } |
163 | } |
164 | }; |
165 | |
166 | template<> |
167 | struct __uninitialized_fill<true> |
168 | { |
169 | template<typename _ForwardIterator, typename _Tp> |
170 | static void |
171 | __uninit_fill(_ForwardIterator __first, _ForwardIterator __last, |
172 | const _Tp& __x) |
173 | { std::fill(__first, __last, __x); } |
174 | }; |
175 | |
176 | /** |
177 | * @brief Copies the value x into the range [first,last). |
178 | * @param __first An input iterator. |
179 | * @param __last An input iterator. |
180 | * @param __x The source value. |
181 | * @return Nothing. |
182 | * |
183 | * Like fill(), but does not require an initialized output range. |
184 | */ |
185 | template<typename _ForwardIterator, typename _Tp> |
186 | inline void |
187 | uninitialized_fill(_ForwardIterator __first, _ForwardIterator __last, |
188 | const _Tp& __x) |
189 | { |
190 | typedef typename iterator_traits<_ForwardIterator>::value_type |
191 | _ValueType; |
192 | #if __cplusplus < 201103L |
193 | const bool __assignable = true; |
194 | #else |
195 | // Trivial types can have deleted copy constructor, but the std::fill |
196 | // optimization that uses memmove would happily "copy" them anyway. |
197 | static_assert(is_constructible<_ValueType, const _Tp&>::value, |
198 | "result type must be constructible from input type" ); |
199 | |
200 | // Trivial types can have deleted assignment, so using std::fill |
201 | // would be ill-formed. Require assignability before using std::fill: |
202 | const bool __assignable = is_copy_assignable<_ValueType>::value; |
203 | #endif |
204 | |
205 | std::__uninitialized_fill<__is_trivial(_ValueType) && __assignable>:: |
206 | __uninit_fill(__first, __last, __x); |
207 | } |
208 | |
209 | |
210 | template<bool _TrivialValueType> |
211 | struct __uninitialized_fill_n |
212 | { |
213 | template<typename _ForwardIterator, typename _Size, typename _Tp> |
214 | static _ForwardIterator |
215 | __uninit_fill_n(_ForwardIterator __first, _Size __n, |
216 | const _Tp& __x) |
217 | { |
218 | _ForwardIterator __cur = __first; |
219 | __try |
220 | { |
221 | for (; __n > 0; --__n, (void) ++__cur) |
222 | std::_Construct(std::__addressof(*__cur), __x); |
223 | return __cur; |
224 | } |
225 | __catch(...) |
226 | { |
227 | std::_Destroy(__first, __cur); |
228 | __throw_exception_again; |
229 | } |
230 | } |
231 | }; |
232 | |
233 | template<> |
234 | struct __uninitialized_fill_n<true> |
235 | { |
236 | template<typename _ForwardIterator, typename _Size, typename _Tp> |
237 | static _ForwardIterator |
238 | __uninit_fill_n(_ForwardIterator __first, _Size __n, |
239 | const _Tp& __x) |
240 | { return std::fill_n(__first, __n, __x); } |
241 | }; |
242 | |
243 | // _GLIBCXX_RESOLVE_LIB_DEFECTS |
244 | // DR 1339. uninitialized_fill_n should return the end of its range |
245 | /** |
246 | * @brief Copies the value x into the range [first,first+n). |
247 | * @param __first An input iterator. |
248 | * @param __n The number of copies to make. |
249 | * @param __x The source value. |
250 | * @return Nothing. |
251 | * |
252 | * Like fill_n(), but does not require an initialized output range. |
253 | */ |
254 | template<typename _ForwardIterator, typename _Size, typename _Tp> |
255 | inline _ForwardIterator |
256 | uninitialized_fill_n(_ForwardIterator __first, _Size __n, const _Tp& __x) |
257 | { |
258 | typedef typename iterator_traits<_ForwardIterator>::value_type |
259 | _ValueType; |
260 | #if __cplusplus < 201103L |
261 | const bool __assignable = true; |
262 | #else |
263 | // Trivial types can have deleted copy constructor, but the std::fill |
264 | // optimization that uses memmove would happily "copy" them anyway. |
265 | static_assert(is_constructible<_ValueType, const _Tp&>::value, |
266 | "result type must be constructible from input type" ); |
267 | |
268 | // Trivial types can have deleted assignment, so using std::fill |
269 | // would be ill-formed. Require assignability before using std::fill: |
270 | const bool __assignable = is_copy_assignable<_ValueType>::value; |
271 | #endif |
272 | return __uninitialized_fill_n<__is_trivial(_ValueType) && __assignable>:: |
273 | __uninit_fill_n(__first, __n, __x); |
274 | } |
275 | |
276 | // Extensions: versions of uninitialized_copy, uninitialized_fill, |
277 | // and uninitialized_fill_n that take an allocator parameter. |
278 | // We dispatch back to the standard versions when we're given the |
279 | // default allocator. For nondefault allocators we do not use |
280 | // any of the POD optimizations. |
281 | |
282 | template<typename _InputIterator, typename _ForwardIterator, |
283 | typename _Allocator> |
284 | _ForwardIterator |
285 | __uninitialized_copy_a(_InputIterator __first, _InputIterator __last, |
286 | _ForwardIterator __result, _Allocator& __alloc) |
287 | { |
288 | _ForwardIterator __cur = __result; |
289 | __try |
290 | { |
291 | typedef __gnu_cxx::__alloc_traits<_Allocator> __traits; |
292 | for (; __first != __last; ++__first, (void)++__cur) |
293 | __traits::construct(__alloc, std::__addressof(*__cur), *__first); |
294 | return __cur; |
295 | } |
296 | __catch(...) |
297 | { |
298 | std::_Destroy(__result, __cur, __alloc); |
299 | __throw_exception_again; |
300 | } |
301 | } |
302 | |
303 | template<typename _InputIterator, typename _ForwardIterator, typename _Tp> |
304 | inline _ForwardIterator |
305 | __uninitialized_copy_a(_InputIterator __first, _InputIterator __last, |
306 | _ForwardIterator __result, allocator<_Tp>&) |
307 | { return std::uninitialized_copy(__first, __last, __result); } |
308 | |
309 | template<typename _InputIterator, typename _ForwardIterator, |
310 | typename _Allocator> |
311 | inline _ForwardIterator |
312 | __uninitialized_move_a(_InputIterator __first, _InputIterator __last, |
313 | _ForwardIterator __result, _Allocator& __alloc) |
314 | { |
315 | return std::__uninitialized_copy_a(_GLIBCXX_MAKE_MOVE_ITERATOR(__first), |
316 | _GLIBCXX_MAKE_MOVE_ITERATOR(__last), |
317 | __result, __alloc); |
318 | } |
319 | |
320 | template<typename _InputIterator, typename _ForwardIterator, |
321 | typename _Allocator> |
322 | inline _ForwardIterator |
323 | __uninitialized_move_if_noexcept_a(_InputIterator __first, |
324 | _InputIterator __last, |
325 | _ForwardIterator __result, |
326 | _Allocator& __alloc) |
327 | { |
328 | return std::__uninitialized_copy_a |
329 | (_GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(__first), |
330 | _GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(__last), __result, __alloc); |
331 | } |
332 | |
333 | template<typename _ForwardIterator, typename _Tp, typename _Allocator> |
334 | void |
335 | __uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last, |
336 | const _Tp& __x, _Allocator& __alloc) |
337 | { |
338 | _ForwardIterator __cur = __first; |
339 | __try |
340 | { |
341 | typedef __gnu_cxx::__alloc_traits<_Allocator> __traits; |
342 | for (; __cur != __last; ++__cur) |
343 | __traits::construct(__alloc, std::__addressof(*__cur), __x); |
344 | } |
345 | __catch(...) |
346 | { |
347 | std::_Destroy(__first, __cur, __alloc); |
348 | __throw_exception_again; |
349 | } |
350 | } |
351 | |
352 | template<typename _ForwardIterator, typename _Tp, typename _Tp2> |
353 | inline void |
354 | __uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last, |
355 | const _Tp& __x, allocator<_Tp2>&) |
356 | { std::uninitialized_fill(__first, __last, __x); } |
357 | |
358 | template<typename _ForwardIterator, typename _Size, typename _Tp, |
359 | typename _Allocator> |
360 | _ForwardIterator |
361 | __uninitialized_fill_n_a(_ForwardIterator __first, _Size __n, |
362 | const _Tp& __x, _Allocator& __alloc) |
363 | { |
364 | _ForwardIterator __cur = __first; |
365 | __try |
366 | { |
367 | typedef __gnu_cxx::__alloc_traits<_Allocator> __traits; |
368 | for (; __n > 0; --__n, (void) ++__cur) |
369 | __traits::construct(__alloc, std::__addressof(*__cur), __x); |
370 | return __cur; |
371 | } |
372 | __catch(...) |
373 | { |
374 | std::_Destroy(__first, __cur, __alloc); |
375 | __throw_exception_again; |
376 | } |
377 | } |
378 | |
379 | template<typename _ForwardIterator, typename _Size, typename _Tp, |
380 | typename _Tp2> |
381 | inline _ForwardIterator |
382 | __uninitialized_fill_n_a(_ForwardIterator __first, _Size __n, |
383 | const _Tp& __x, allocator<_Tp2>&) |
384 | { return std::uninitialized_fill_n(__first, __n, __x); } |
385 | |
386 | |
387 | // Extensions: __uninitialized_copy_move, __uninitialized_move_copy, |
388 | // __uninitialized_fill_move, __uninitialized_move_fill. |
389 | // All of these algorithms take a user-supplied allocator, which is used |
390 | // for construction and destruction. |
391 | |
392 | // __uninitialized_copy_move |
393 | // Copies [first1, last1) into [result, result + (last1 - first1)), and |
394 | // move [first2, last2) into |
395 | // [result, result + (last1 - first1) + (last2 - first2)). |
396 | template<typename _InputIterator1, typename _InputIterator2, |
397 | typename _ForwardIterator, typename _Allocator> |
398 | inline _ForwardIterator |
399 | __uninitialized_copy_move(_InputIterator1 __first1, |
400 | _InputIterator1 __last1, |
401 | _InputIterator2 __first2, |
402 | _InputIterator2 __last2, |
403 | _ForwardIterator __result, |
404 | _Allocator& __alloc) |
405 | { |
406 | _ForwardIterator __mid = std::__uninitialized_copy_a(__first1, __last1, |
407 | __result, |
408 | __alloc); |
409 | __try |
410 | { |
411 | return std::__uninitialized_move_a(__first2, __last2, __mid, __alloc); |
412 | } |
413 | __catch(...) |
414 | { |
415 | std::_Destroy(__result, __mid, __alloc); |
416 | __throw_exception_again; |
417 | } |
418 | } |
419 | |
420 | // __uninitialized_move_copy |
421 | // Moves [first1, last1) into [result, result + (last1 - first1)), and |
422 | // copies [first2, last2) into |
423 | // [result, result + (last1 - first1) + (last2 - first2)). |
424 | template<typename _InputIterator1, typename _InputIterator2, |
425 | typename _ForwardIterator, typename _Allocator> |
426 | inline _ForwardIterator |
427 | __uninitialized_move_copy(_InputIterator1 __first1, |
428 | _InputIterator1 __last1, |
429 | _InputIterator2 __first2, |
430 | _InputIterator2 __last2, |
431 | _ForwardIterator __result, |
432 | _Allocator& __alloc) |
433 | { |
434 | _ForwardIterator __mid = std::__uninitialized_move_a(__first1, __last1, |
435 | __result, |
436 | __alloc); |
437 | __try |
438 | { |
439 | return std::__uninitialized_copy_a(__first2, __last2, __mid, __alloc); |
440 | } |
441 | __catch(...) |
442 | { |
443 | std::_Destroy(__result, __mid, __alloc); |
444 | __throw_exception_again; |
445 | } |
446 | } |
447 | |
448 | // __uninitialized_fill_move |
449 | // Fills [result, mid) with x, and moves [first, last) into |
450 | // [mid, mid + (last - first)). |
451 | template<typename _ForwardIterator, typename _Tp, typename _InputIterator, |
452 | typename _Allocator> |
453 | inline _ForwardIterator |
454 | __uninitialized_fill_move(_ForwardIterator __result, _ForwardIterator __mid, |
455 | const _Tp& __x, _InputIterator __first, |
456 | _InputIterator __last, _Allocator& __alloc) |
457 | { |
458 | std::__uninitialized_fill_a(__result, __mid, __x, __alloc); |
459 | __try |
460 | { |
461 | return std::__uninitialized_move_a(__first, __last, __mid, __alloc); |
462 | } |
463 | __catch(...) |
464 | { |
465 | std::_Destroy(__result, __mid, __alloc); |
466 | __throw_exception_again; |
467 | } |
468 | } |
469 | |
470 | // __uninitialized_move_fill |
471 | // Moves [first1, last1) into [first2, first2 + (last1 - first1)), and |
472 | // fills [first2 + (last1 - first1), last2) with x. |
473 | template<typename _InputIterator, typename _ForwardIterator, typename _Tp, |
474 | typename _Allocator> |
475 | inline void |
476 | __uninitialized_move_fill(_InputIterator __first1, _InputIterator __last1, |
477 | _ForwardIterator __first2, |
478 | _ForwardIterator __last2, const _Tp& __x, |
479 | _Allocator& __alloc) |
480 | { |
481 | _ForwardIterator __mid2 = std::__uninitialized_move_a(__first1, __last1, |
482 | __first2, |
483 | __alloc); |
484 | __try |
485 | { |
486 | std::__uninitialized_fill_a(__mid2, __last2, __x, __alloc); |
487 | } |
488 | __catch(...) |
489 | { |
490 | std::_Destroy(__first2, __mid2, __alloc); |
491 | __throw_exception_again; |
492 | } |
493 | } |
494 | |
495 | #if __cplusplus >= 201103L |
496 | // Extensions: __uninitialized_default, __uninitialized_default_n, |
497 | // __uninitialized_default_a, __uninitialized_default_n_a. |
498 | |
499 | template<bool _TrivialValueType> |
500 | struct __uninitialized_default_1 |
501 | { |
502 | template<typename _ForwardIterator> |
503 | static void |
504 | __uninit_default(_ForwardIterator __first, _ForwardIterator __last) |
505 | { |
506 | _ForwardIterator __cur = __first; |
507 | __try |
508 | { |
509 | for (; __cur != __last; ++__cur) |
510 | std::_Construct(std::__addressof(*__cur)); |
511 | } |
512 | __catch(...) |
513 | { |
514 | std::_Destroy(__first, __cur); |
515 | __throw_exception_again; |
516 | } |
517 | } |
518 | }; |
519 | |
520 | template<> |
521 | struct __uninitialized_default_1<true> |
522 | { |
523 | template<typename _ForwardIterator> |
524 | static void |
525 | __uninit_default(_ForwardIterator __first, _ForwardIterator __last) |
526 | { |
527 | typedef typename iterator_traits<_ForwardIterator>::value_type |
528 | _ValueType; |
529 | |
530 | std::fill(__first, __last, _ValueType()); |
531 | } |
532 | }; |
533 | |
534 | template<bool _TrivialValueType> |
535 | struct __uninitialized_default_n_1 |
536 | { |
537 | template<typename _ForwardIterator, typename _Size> |
538 | static _ForwardIterator |
539 | __uninit_default_n(_ForwardIterator __first, _Size __n) |
540 | { |
541 | _ForwardIterator __cur = __first; |
542 | __try |
543 | { |
544 | for (; __n > 0; --__n, (void) ++__cur) |
545 | std::_Construct(std::__addressof(*__cur)); |
546 | return __cur; |
547 | } |
548 | __catch(...) |
549 | { |
550 | std::_Destroy(__first, __cur); |
551 | __throw_exception_again; |
552 | } |
553 | } |
554 | }; |
555 | |
556 | template<> |
557 | struct __uninitialized_default_n_1<true> |
558 | { |
559 | template<typename _ForwardIterator, typename _Size> |
560 | static _ForwardIterator |
561 | __uninit_default_n(_ForwardIterator __first, _Size __n) |
562 | { |
563 | typedef typename iterator_traits<_ForwardIterator>::value_type |
564 | _ValueType; |
565 | |
566 | return std::fill_n(__first, __n, _ValueType()); |
567 | } |
568 | }; |
569 | |
570 | // __uninitialized_default |
571 | // Fills [first, last) with std::distance(first, last) default |
572 | // constructed value_types(s). |
573 | template<typename _ForwardIterator> |
574 | inline void |
575 | __uninitialized_default(_ForwardIterator __first, |
576 | _ForwardIterator __last) |
577 | { |
578 | typedef typename iterator_traits<_ForwardIterator>::value_type |
579 | _ValueType; |
580 | // trivial types can have deleted assignment |
581 | const bool __assignable = is_copy_assignable<_ValueType>::value; |
582 | |
583 | std::__uninitialized_default_1<__is_trivial(_ValueType) |
584 | && __assignable>:: |
585 | __uninit_default(__first, __last); |
586 | } |
587 | |
588 | // __uninitialized_default_n |
589 | // Fills [first, first + n) with n default constructed value_type(s). |
590 | template<typename _ForwardIterator, typename _Size> |
591 | inline _ForwardIterator |
592 | __uninitialized_default_n(_ForwardIterator __first, _Size __n) |
593 | { |
594 | typedef typename iterator_traits<_ForwardIterator>::value_type |
595 | _ValueType; |
596 | // trivial types can have deleted assignment |
597 | const bool __assignable = is_copy_assignable<_ValueType>::value; |
598 | |
599 | return __uninitialized_default_n_1<__is_trivial(_ValueType) |
600 | && __assignable>:: |
601 | __uninit_default_n(__first, __n); |
602 | } |
603 | |
604 | |
605 | // __uninitialized_default_a |
606 | // Fills [first, last) with std::distance(first, last) default |
607 | // constructed value_types(s), constructed with the allocator alloc. |
608 | template<typename _ForwardIterator, typename _Allocator> |
609 | void |
610 | __uninitialized_default_a(_ForwardIterator __first, |
611 | _ForwardIterator __last, |
612 | _Allocator& __alloc) |
613 | { |
614 | _ForwardIterator __cur = __first; |
615 | __try |
616 | { |
617 | typedef __gnu_cxx::__alloc_traits<_Allocator> __traits; |
618 | for (; __cur != __last; ++__cur) |
619 | __traits::construct(__alloc, std::__addressof(*__cur)); |
620 | } |
621 | __catch(...) |
622 | { |
623 | std::_Destroy(__first, __cur, __alloc); |
624 | __throw_exception_again; |
625 | } |
626 | } |
627 | |
628 | template<typename _ForwardIterator, typename _Tp> |
629 | inline void |
630 | __uninitialized_default_a(_ForwardIterator __first, |
631 | _ForwardIterator __last, |
632 | allocator<_Tp>&) |
633 | { std::__uninitialized_default(__first, __last); } |
634 | |
635 | |
636 | // __uninitialized_default_n_a |
637 | // Fills [first, first + n) with n default constructed value_types(s), |
638 | // constructed with the allocator alloc. |
639 | template<typename _ForwardIterator, typename _Size, typename _Allocator> |
640 | _ForwardIterator |
641 | __uninitialized_default_n_a(_ForwardIterator __first, _Size __n, |
642 | _Allocator& __alloc) |
643 | { |
644 | _ForwardIterator __cur = __first; |
645 | __try |
646 | { |
647 | typedef __gnu_cxx::__alloc_traits<_Allocator> __traits; |
648 | for (; __n > 0; --__n, (void) ++__cur) |
649 | __traits::construct(__alloc, std::__addressof(*__cur)); |
650 | return __cur; |
651 | } |
652 | __catch(...) |
653 | { |
654 | std::_Destroy(__first, __cur, __alloc); |
655 | __throw_exception_again; |
656 | } |
657 | } |
658 | |
659 | template<typename _ForwardIterator, typename _Size, typename _Tp> |
660 | inline _ForwardIterator |
661 | __uninitialized_default_n_a(_ForwardIterator __first, _Size __n, |
662 | allocator<_Tp>&) |
663 | { return std::__uninitialized_default_n(__first, __n); } |
664 | |
665 | template<bool _TrivialValueType> |
666 | struct __uninitialized_default_novalue_1 |
667 | { |
668 | template<typename _ForwardIterator> |
669 | static void |
670 | __uninit_default_novalue(_ForwardIterator __first, |
671 | _ForwardIterator __last) |
672 | { |
673 | _ForwardIterator __cur = __first; |
674 | __try |
675 | { |
676 | for (; __cur != __last; ++__cur) |
677 | std::_Construct_novalue(std::__addressof(*__cur)); |
678 | } |
679 | __catch(...) |
680 | { |
681 | std::_Destroy(__first, __cur); |
682 | __throw_exception_again; |
683 | } |
684 | } |
685 | }; |
686 | |
687 | template<> |
688 | struct __uninitialized_default_novalue_1<true> |
689 | { |
690 | template<typename _ForwardIterator> |
691 | static void |
692 | __uninit_default_novalue(_ForwardIterator __first, |
693 | _ForwardIterator __last) |
694 | { |
695 | } |
696 | }; |
697 | |
698 | template<bool _TrivialValueType> |
699 | struct __uninitialized_default_novalue_n_1 |
700 | { |
701 | template<typename _ForwardIterator, typename _Size> |
702 | static _ForwardIterator |
703 | __uninit_default_novalue_n(_ForwardIterator __first, _Size __n) |
704 | { |
705 | _ForwardIterator __cur = __first; |
706 | __try |
707 | { |
708 | for (; __n > 0; --__n, (void) ++__cur) |
709 | std::_Construct_novalue(std::__addressof(*__cur)); |
710 | return __cur; |
711 | } |
712 | __catch(...) |
713 | { |
714 | std::_Destroy(__first, __cur); |
715 | __throw_exception_again; |
716 | } |
717 | } |
718 | }; |
719 | |
720 | template<> |
721 | struct __uninitialized_default_novalue_n_1<true> |
722 | { |
723 | template<typename _ForwardIterator, typename _Size> |
724 | static _ForwardIterator |
725 | __uninit_default_novalue_n(_ForwardIterator __first, _Size __n) |
726 | { return std::next(__first, __n); } |
727 | }; |
728 | |
729 | // __uninitialized_default_novalue |
730 | // Fills [first, last) with std::distance(first, last) default-initialized |
731 | // value_types(s). |
732 | template<typename _ForwardIterator> |
733 | inline void |
734 | __uninitialized_default_novalue(_ForwardIterator __first, |
735 | _ForwardIterator __last) |
736 | { |
737 | typedef typename iterator_traits<_ForwardIterator>::value_type |
738 | _ValueType; |
739 | |
740 | std::__uninitialized_default_novalue_1< |
741 | is_trivially_default_constructible<_ValueType>::value>:: |
742 | __uninit_default_novalue(__first, __last); |
743 | } |
744 | |
745 | // __uninitialized_default_n |
746 | // Fills [first, first + n) with n default-initialized value_type(s). |
747 | template<typename _ForwardIterator, typename _Size> |
748 | inline _ForwardIterator |
749 | __uninitialized_default_novalue_n(_ForwardIterator __first, _Size __n) |
750 | { |
751 | typedef typename iterator_traits<_ForwardIterator>::value_type |
752 | _ValueType; |
753 | |
754 | return __uninitialized_default_novalue_n_1< |
755 | is_trivially_default_constructible<_ValueType>::value>:: |
756 | __uninit_default_novalue_n(__first, __n); |
757 | } |
758 | |
759 | template<typename _InputIterator, typename _Size, |
760 | typename _ForwardIterator> |
761 | _ForwardIterator |
762 | __uninitialized_copy_n(_InputIterator __first, _Size __n, |
763 | _ForwardIterator __result, input_iterator_tag) |
764 | { |
765 | _ForwardIterator __cur = __result; |
766 | __try |
767 | { |
768 | for (; __n > 0; --__n, (void) ++__first, ++__cur) |
769 | std::_Construct(std::__addressof(*__cur), *__first); |
770 | return __cur; |
771 | } |
772 | __catch(...) |
773 | { |
774 | std::_Destroy(__result, __cur); |
775 | __throw_exception_again; |
776 | } |
777 | } |
778 | |
779 | template<typename _RandomAccessIterator, typename _Size, |
780 | typename _ForwardIterator> |
781 | inline _ForwardIterator |
782 | __uninitialized_copy_n(_RandomAccessIterator __first, _Size __n, |
783 | _ForwardIterator __result, |
784 | random_access_iterator_tag) |
785 | { return std::uninitialized_copy(__first, __first + __n, __result); } |
786 | |
787 | template<typename _InputIterator, typename _Size, |
788 | typename _ForwardIterator> |
789 | pair<_InputIterator, _ForwardIterator> |
790 | __uninitialized_copy_n_pair(_InputIterator __first, _Size __n, |
791 | _ForwardIterator __result, input_iterator_tag) |
792 | { |
793 | _ForwardIterator __cur = __result; |
794 | __try |
795 | { |
796 | for (; __n > 0; --__n, (void) ++__first, ++__cur) |
797 | std::_Construct(std::__addressof(*__cur), *__first); |
798 | return {__first, __cur}; |
799 | } |
800 | __catch(...) |
801 | { |
802 | std::_Destroy(__result, __cur); |
803 | __throw_exception_again; |
804 | } |
805 | } |
806 | |
807 | template<typename _RandomAccessIterator, typename _Size, |
808 | typename _ForwardIterator> |
809 | inline pair<_RandomAccessIterator, _ForwardIterator> |
810 | __uninitialized_copy_n_pair(_RandomAccessIterator __first, _Size __n, |
811 | _ForwardIterator __result, |
812 | random_access_iterator_tag) |
813 | { |
814 | auto __second_res = uninitialized_copy(__first, __first + __n, __result); |
815 | auto __first_res = std::next(__first, __n); |
816 | return {__first_res, __second_res}; |
817 | } |
818 | |
819 | /** |
820 | * @brief Copies the range [first,first+n) into result. |
821 | * @param __first An input iterator. |
822 | * @param __n The number of elements to copy. |
823 | * @param __result An output iterator. |
824 | * @return __result + __n |
825 | * |
826 | * Like copy_n(), but does not require an initialized output range. |
827 | */ |
828 | template<typename _InputIterator, typename _Size, typename _ForwardIterator> |
829 | inline _ForwardIterator |
830 | uninitialized_copy_n(_InputIterator __first, _Size __n, |
831 | _ForwardIterator __result) |
832 | { return std::__uninitialized_copy_n(__first, __n, __result, |
833 | std::__iterator_category(__first)); } |
834 | |
835 | template<typename _InputIterator, typename _Size, typename _ForwardIterator> |
836 | inline pair<_InputIterator, _ForwardIterator> |
837 | __uninitialized_copy_n_pair(_InputIterator __first, _Size __n, |
838 | _ForwardIterator __result) |
839 | { |
840 | return |
841 | std::__uninitialized_copy_n_pair(__first, __n, __result, |
842 | std::__iterator_category(__first)); |
843 | } |
844 | |
845 | #endif |
846 | |
847 | #if __cplusplus >= 201703L |
848 | # define __cpp_lib_raw_memory_algorithms 201606L |
849 | |
850 | template <typename _ForwardIterator> |
851 | inline void |
852 | uninitialized_default_construct(_ForwardIterator __first, |
853 | _ForwardIterator __last) |
854 | { |
855 | __uninitialized_default_novalue(__first, __last); |
856 | } |
857 | |
858 | template <typename _ForwardIterator, typename _Size> |
859 | inline _ForwardIterator |
860 | uninitialized_default_construct_n(_ForwardIterator __first, _Size __count) |
861 | { |
862 | return __uninitialized_default_novalue_n(__first, __count); |
863 | } |
864 | |
865 | template <typename _ForwardIterator> |
866 | inline void |
867 | uninitialized_value_construct(_ForwardIterator __first, |
868 | _ForwardIterator __last) |
869 | { |
870 | return __uninitialized_default(__first, __last); |
871 | } |
872 | |
873 | template <typename _ForwardIterator, typename _Size> |
874 | inline _ForwardIterator |
875 | uninitialized_value_construct_n(_ForwardIterator __first, _Size __count) |
876 | { |
877 | return __uninitialized_default_n(__first, __count); |
878 | } |
879 | |
880 | template <typename _InputIterator, typename _ForwardIterator> |
881 | inline _ForwardIterator |
882 | uninitialized_move(_InputIterator __first, _InputIterator __last, |
883 | _ForwardIterator __result) |
884 | { |
885 | return std::uninitialized_copy |
886 | (_GLIBCXX_MAKE_MOVE_ITERATOR(__first), |
887 | _GLIBCXX_MAKE_MOVE_ITERATOR(__last), __result); |
888 | } |
889 | |
890 | template <typename _InputIterator, typename _Size, typename _ForwardIterator> |
891 | inline pair<_InputIterator, _ForwardIterator> |
892 | uninitialized_move_n(_InputIterator __first, _Size __count, |
893 | _ForwardIterator __result) |
894 | { |
895 | auto __res = std::__uninitialized_copy_n_pair |
896 | (_GLIBCXX_MAKE_MOVE_ITERATOR(__first), |
897 | __count, __result); |
898 | return {__res.first.base(), __res.second}; |
899 | } |
900 | #endif // C++17 |
901 | |
902 | #if __cplusplus >= 201103L |
903 | template<typename _Tp, typename _Up, typename _Allocator> |
904 | inline void |
905 | __relocate_object_a(_Tp* __dest, _Up* __orig, _Allocator& __alloc) |
906 | noexcept(noexcept(std::allocator_traits<_Allocator>::construct(__alloc, |
907 | __dest, std::move(*__orig))) |
908 | && noexcept(std::allocator_traits<_Allocator>::destroy( |
909 | __alloc, std::__addressof(*__orig)))) |
910 | { |
911 | typedef std::allocator_traits<_Allocator> __traits; |
912 | __traits::construct(__alloc, __dest, std::move(*__orig)); |
913 | __traits::destroy(__alloc, std::__addressof(*__orig)); |
914 | } |
915 | |
916 | // This class may be specialized for specific types. |
917 | // Also known as is_trivially_relocatable. |
918 | template<typename _Tp, typename = void> |
919 | struct __is_bitwise_relocatable |
920 | : is_trivial<_Tp> { }; |
921 | |
922 | template <typename _Tp, typename _Up> |
923 | inline __enable_if_t<std::__is_bitwise_relocatable<_Tp>::value, _Tp*> |
924 | __relocate_a_1(_Tp* __first, _Tp* __last, |
925 | _Tp* __result, allocator<_Up>&) noexcept |
926 | { |
927 | ptrdiff_t __count = __last - __first; |
928 | if (__count > 0) |
929 | __builtin_memmove(__result, __first, __count * sizeof(_Tp)); |
930 | return __result + __count; |
931 | } |
932 | |
933 | template <typename _InputIterator, typename _ForwardIterator, |
934 | typename _Allocator> |
935 | inline _ForwardIterator |
936 | __relocate_a_1(_InputIterator __first, _InputIterator __last, |
937 | _ForwardIterator __result, _Allocator& __alloc) |
938 | noexcept(noexcept(std::__relocate_object_a(std::addressof(*__result), |
939 | std::addressof(*__first), |
940 | __alloc))) |
941 | { |
942 | typedef typename iterator_traits<_InputIterator>::value_type |
943 | _ValueType; |
944 | typedef typename iterator_traits<_ForwardIterator>::value_type |
945 | _ValueType2; |
946 | static_assert(std::is_same<_ValueType, _ValueType2>::value, |
947 | "relocation is only possible for values of the same type" ); |
948 | _ForwardIterator __cur = __result; |
949 | for (; __first != __last; ++__first, (void)++__cur) |
950 | std::__relocate_object_a(std::__addressof(*__cur), |
951 | std::__addressof(*__first), __alloc); |
952 | return __cur; |
953 | } |
954 | |
955 | template <typename _InputIterator, typename _ForwardIterator, |
956 | typename _Allocator> |
957 | inline _ForwardIterator |
958 | __relocate_a(_InputIterator __first, _InputIterator __last, |
959 | _ForwardIterator __result, _Allocator& __alloc) |
960 | noexcept(noexcept(__relocate_a_1(std::__niter_base(__first), |
961 | std::__niter_base(__last), |
962 | std::__niter_base(__result), __alloc))) |
963 | { |
964 | return __relocate_a_1(std::__niter_base(__first), |
965 | std::__niter_base(__last), |
966 | std::__niter_base(__result), __alloc); |
967 | } |
968 | #endif |
969 | |
970 | _GLIBCXX_END_NAMESPACE_VERSION |
971 | } // namespace |
972 | |
973 | #endif /* _STL_UNINITIALIZED_H */ |
974 | |