Line data Source code
1 : // Raw memory manipulators -*- C++ -*-
2 :
3 : // Copyright (C) 2001-2013 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 : namespace std _GLIBCXX_VISIBILITY(default)
60 : {
61 : _GLIBCXX_BEGIN_NAMESPACE_VERSION
62 :
63 : template<bool _TrivialValueTypes>
64 : struct __uninitialized_copy
65 : {
66 : template<typename _InputIterator, typename _ForwardIterator>
67 : static _ForwardIterator
68 : __uninit_copy(_InputIterator __first, _InputIterator __last,
69 : _ForwardIterator __result)
70 : {
71 12 : _ForwardIterator __cur = __result;
72 : __try
73 : {
74 84 : for (; __first != __last; ++__first, ++__cur)
75 36 : std::_Construct(std::__addressof(*__cur), *__first);
76 12 : return __cur;
77 0 : }
78 : __catch(...)
79 : {
80 0 : std::_Destroy(__result, __cur);
81 0 : __throw_exception_again;
82 0 : }
83 0 : }
84 : };
85 :
86 : template<>
87 : struct __uninitialized_copy<true>
88 : {
89 : template<typename _InputIterator, typename _ForwardIterator>
90 : static _ForwardIterator
91 : __uninit_copy(_InputIterator __first, _InputIterator __last,
92 : _ForwardIterator __result)
93 : { return std::copy(__first, __last, __result); }
94 : };
95 :
96 : /**
97 : * @brief Copies the range [first,last) into result.
98 : * @param __first An input iterator.
99 : * @param __last An input iterator.
100 : * @param __result An output iterator.
101 : * @return __result + (__first - __last)
102 : *
103 : * Like copy(), but does not require an initialized output range.
104 : */
105 : template<typename _InputIterator, typename _ForwardIterator>
106 : inline _ForwardIterator
107 : uninitialized_copy(_InputIterator __first, _InputIterator __last,
108 : _ForwardIterator __result)
109 : {
110 : typedef typename iterator_traits<_InputIterator>::value_type
111 : _ValueType1;
112 : typedef typename iterator_traits<_ForwardIterator>::value_type
113 : _ValueType2;
114 :
115 12 : return std::__uninitialized_copy<(__is_trivial(_ValueType1)
116 : && __is_trivial(_ValueType2))>::
117 12 : __uninit_copy(__first, __last, __result);
118 : }
119 :
120 :
121 : template<bool _TrivialValueType>
122 : struct __uninitialized_fill
123 : {
124 : template<typename _ForwardIterator, typename _Tp>
125 : static void
126 : __uninit_fill(_ForwardIterator __first, _ForwardIterator __last,
127 : const _Tp& __x)
128 : {
129 : _ForwardIterator __cur = __first;
130 : __try
131 : {
132 : for (; __cur != __last; ++__cur)
133 : std::_Construct(std::__addressof(*__cur), __x);
134 : }
135 : __catch(...)
136 : {
137 : std::_Destroy(__first, __cur);
138 : __throw_exception_again;
139 : }
140 : }
141 : };
142 :
143 : template<>
144 : struct __uninitialized_fill<true>
145 : {
146 : template<typename _ForwardIterator, typename _Tp>
147 : static void
148 : __uninit_fill(_ForwardIterator __first, _ForwardIterator __last,
149 : const _Tp& __x)
150 : { std::fill(__first, __last, __x); }
151 : };
152 :
153 : /**
154 : * @brief Copies the value x into the range [first,last).
155 : * @param __first An input iterator.
156 : * @param __last An input iterator.
157 : * @param __x The source value.
158 : * @return Nothing.
159 : *
160 : * Like fill(), but does not require an initialized output range.
161 : */
162 : template<typename _ForwardIterator, typename _Tp>
163 : inline void
164 : uninitialized_fill(_ForwardIterator __first, _ForwardIterator __last,
165 : const _Tp& __x)
166 : {
167 : typedef typename iterator_traits<_ForwardIterator>::value_type
168 : _ValueType;
169 :
170 : std::__uninitialized_fill<__is_trivial(_ValueType)>::
171 : __uninit_fill(__first, __last, __x);
172 : }
173 :
174 :
175 : template<bool _TrivialValueType>
176 : struct __uninitialized_fill_n
177 : {
178 : template<typename _ForwardIterator, typename _Size, typename _Tp>
179 : static void
180 : __uninit_fill_n(_ForwardIterator __first, _Size __n,
181 : const _Tp& __x)
182 : {
183 : _ForwardIterator __cur = __first;
184 : __try
185 : {
186 : for (; __n > 0; --__n, ++__cur)
187 : std::_Construct(std::__addressof(*__cur), __x);
188 : }
189 : __catch(...)
190 : {
191 : std::_Destroy(__first, __cur);
192 : __throw_exception_again;
193 : }
194 : }
195 : };
196 :
197 : template<>
198 : struct __uninitialized_fill_n<true>
199 : {
200 : template<typename _ForwardIterator, typename _Size, typename _Tp>
201 : static void
202 : __uninit_fill_n(_ForwardIterator __first, _Size __n,
203 : const _Tp& __x)
204 : { std::fill_n(__first, __n, __x); }
205 : };
206 :
207 : /**
208 : * @brief Copies the value x into the range [first,first+n).
209 : * @param __first An input iterator.
210 : * @param __n The number of copies to make.
211 : * @param __x The source value.
212 : * @return Nothing.
213 : *
214 : * Like fill_n(), but does not require an initialized output range.
215 : */
216 : template<typename _ForwardIterator, typename _Size, typename _Tp>
217 : inline void
218 : uninitialized_fill_n(_ForwardIterator __first, _Size __n, const _Tp& __x)
219 : {
220 : typedef typename iterator_traits<_ForwardIterator>::value_type
221 : _ValueType;
222 :
223 : std::__uninitialized_fill_n<__is_trivial(_ValueType)>::
224 : __uninit_fill_n(__first, __n, __x);
225 : }
226 :
227 : // Extensions: versions of uninitialized_copy, uninitialized_fill,
228 : // and uninitialized_fill_n that take an allocator parameter.
229 : // We dispatch back to the standard versions when we're given the
230 : // default allocator. For nondefault allocators we do not use
231 : // any of the POD optimizations.
232 :
233 : template<typename _InputIterator, typename _ForwardIterator,
234 : typename _Allocator>
235 : _ForwardIterator
236 : __uninitialized_copy_a(_InputIterator __first, _InputIterator __last,
237 : _ForwardIterator __result, _Allocator& __alloc)
238 : {
239 : _ForwardIterator __cur = __result;
240 : __try
241 : {
242 : typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
243 : for (; __first != __last; ++__first, ++__cur)
244 : __traits::construct(__alloc, std::__addressof(*__cur), *__first);
245 : return __cur;
246 : }
247 : __catch(...)
248 : {
249 : std::_Destroy(__result, __cur, __alloc);
250 : __throw_exception_again;
251 : }
252 : }
253 :
254 : template<typename _InputIterator, typename _ForwardIterator, typename _Tp>
255 : inline _ForwardIterator
256 : __uninitialized_copy_a(_InputIterator __first, _InputIterator __last,
257 : _ForwardIterator __result, allocator<_Tp>&)
258 12 : { return std::uninitialized_copy(__first, __last, __result); }
259 :
260 : template<typename _InputIterator, typename _ForwardIterator,
261 : typename _Allocator>
262 : inline _ForwardIterator
263 : __uninitialized_move_a(_InputIterator __first, _InputIterator __last,
264 : _ForwardIterator __result, _Allocator& __alloc)
265 : {
266 : return std::__uninitialized_copy_a(_GLIBCXX_MAKE_MOVE_ITERATOR(__first),
267 : _GLIBCXX_MAKE_MOVE_ITERATOR(__last),
268 : __result, __alloc);
269 : }
270 :
271 : template<typename _InputIterator, typename _ForwardIterator,
272 : typename _Allocator>
273 : inline _ForwardIterator
274 : __uninitialized_move_if_noexcept_a(_InputIterator __first,
275 : _InputIterator __last,
276 : _ForwardIterator __result,
277 : _Allocator& __alloc)
278 : {
279 : return std::__uninitialized_copy_a
280 : (_GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(__first),
281 : _GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(__last), __result, __alloc);
282 : }
283 :
284 : template<typename _ForwardIterator, typename _Tp, typename _Allocator>
285 : void
286 : __uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last,
287 : const _Tp& __x, _Allocator& __alloc)
288 : {
289 : _ForwardIterator __cur = __first;
290 : __try
291 : {
292 : typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
293 : for (; __cur != __last; ++__cur)
294 : __traits::construct(__alloc, std::__addressof(*__cur), __x);
295 : }
296 : __catch(...)
297 : {
298 : std::_Destroy(__first, __cur, __alloc);
299 : __throw_exception_again;
300 : }
301 : }
302 :
303 : template<typename _ForwardIterator, typename _Tp, typename _Tp2>
304 : inline void
305 : __uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last,
306 : const _Tp& __x, allocator<_Tp2>&)
307 : { std::uninitialized_fill(__first, __last, __x); }
308 :
309 : template<typename _ForwardIterator, typename _Size, typename _Tp,
310 : typename _Allocator>
311 : void
312 : __uninitialized_fill_n_a(_ForwardIterator __first, _Size __n,
313 : const _Tp& __x, _Allocator& __alloc)
314 : {
315 : _ForwardIterator __cur = __first;
316 : __try
317 : {
318 : typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
319 : for (; __n > 0; --__n, ++__cur)
320 : __traits::construct(__alloc, std::__addressof(*__cur), __x);
321 : }
322 : __catch(...)
323 : {
324 : std::_Destroy(__first, __cur, __alloc);
325 : __throw_exception_again;
326 : }
327 : }
328 :
329 : template<typename _ForwardIterator, typename _Size, typename _Tp,
330 : typename _Tp2>
331 : inline void
332 : __uninitialized_fill_n_a(_ForwardIterator __first, _Size __n,
333 : const _Tp& __x, allocator<_Tp2>&)
334 : { std::uninitialized_fill_n(__first, __n, __x); }
335 :
336 :
337 : // Extensions: __uninitialized_copy_move, __uninitialized_move_copy,
338 : // __uninitialized_fill_move, __uninitialized_move_fill.
339 : // All of these algorithms take a user-supplied allocator, which is used
340 : // for construction and destruction.
341 :
342 : // __uninitialized_copy_move
343 : // Copies [first1, last1) into [result, result + (last1 - first1)), and
344 : // move [first2, last2) into
345 : // [result, result + (last1 - first1) + (last2 - first2)).
346 : template<typename _InputIterator1, typename _InputIterator2,
347 : typename _ForwardIterator, typename _Allocator>
348 : inline _ForwardIterator
349 : __uninitialized_copy_move(_InputIterator1 __first1,
350 : _InputIterator1 __last1,
351 : _InputIterator2 __first2,
352 : _InputIterator2 __last2,
353 : _ForwardIterator __result,
354 : _Allocator& __alloc)
355 : {
356 : _ForwardIterator __mid = std::__uninitialized_copy_a(__first1, __last1,
357 : __result,
358 : __alloc);
359 : __try
360 : {
361 : return std::__uninitialized_move_a(__first2, __last2, __mid, __alloc);
362 : }
363 : __catch(...)
364 : {
365 : std::_Destroy(__result, __mid, __alloc);
366 : __throw_exception_again;
367 : }
368 : }
369 :
370 : // __uninitialized_move_copy
371 : // Moves [first1, last1) into [result, result + (last1 - first1)), and
372 : // copies [first2, last2) into
373 : // [result, result + (last1 - first1) + (last2 - first2)).
374 : template<typename _InputIterator1, typename _InputIterator2,
375 : typename _ForwardIterator, typename _Allocator>
376 : inline _ForwardIterator
377 : __uninitialized_move_copy(_InputIterator1 __first1,
378 : _InputIterator1 __last1,
379 : _InputIterator2 __first2,
380 : _InputIterator2 __last2,
381 : _ForwardIterator __result,
382 : _Allocator& __alloc)
383 : {
384 : _ForwardIterator __mid = std::__uninitialized_move_a(__first1, __last1,
385 : __result,
386 : __alloc);
387 : __try
388 : {
389 : return std::__uninitialized_copy_a(__first2, __last2, __mid, __alloc);
390 : }
391 : __catch(...)
392 : {
393 : std::_Destroy(__result, __mid, __alloc);
394 : __throw_exception_again;
395 : }
396 : }
397 :
398 : // __uninitialized_fill_move
399 : // Fills [result, mid) with x, and moves [first, last) into
400 : // [mid, mid + (last - first)).
401 : template<typename _ForwardIterator, typename _Tp, typename _InputIterator,
402 : typename _Allocator>
403 : inline _ForwardIterator
404 : __uninitialized_fill_move(_ForwardIterator __result, _ForwardIterator __mid,
405 : const _Tp& __x, _InputIterator __first,
406 : _InputIterator __last, _Allocator& __alloc)
407 : {
408 : std::__uninitialized_fill_a(__result, __mid, __x, __alloc);
409 : __try
410 : {
411 : return std::__uninitialized_move_a(__first, __last, __mid, __alloc);
412 : }
413 : __catch(...)
414 : {
415 : std::_Destroy(__result, __mid, __alloc);
416 : __throw_exception_again;
417 : }
418 : }
419 :
420 : // __uninitialized_move_fill
421 : // Moves [first1, last1) into [first2, first2 + (last1 - first1)), and
422 : // fills [first2 + (last1 - first1), last2) with x.
423 : template<typename _InputIterator, typename _ForwardIterator, typename _Tp,
424 : typename _Allocator>
425 : inline void
426 : __uninitialized_move_fill(_InputIterator __first1, _InputIterator __last1,
427 : _ForwardIterator __first2,
428 : _ForwardIterator __last2, const _Tp& __x,
429 : _Allocator& __alloc)
430 : {
431 : _ForwardIterator __mid2 = std::__uninitialized_move_a(__first1, __last1,
432 : __first2,
433 : __alloc);
434 : __try
435 : {
436 : std::__uninitialized_fill_a(__mid2, __last2, __x, __alloc);
437 : }
438 : __catch(...)
439 : {
440 : std::_Destroy(__first2, __mid2, __alloc);
441 : __throw_exception_again;
442 : }
443 : }
444 :
445 : #if __cplusplus >= 201103L
446 : // Extensions: __uninitialized_default, __uninitialized_default_n,
447 : // __uninitialized_default_a, __uninitialized_default_n_a.
448 :
449 : template<bool _TrivialValueType>
450 : struct __uninitialized_default_1
451 : {
452 : template<typename _ForwardIterator>
453 : static void
454 : __uninit_default(_ForwardIterator __first, _ForwardIterator __last)
455 : {
456 : _ForwardIterator __cur = __first;
457 : __try
458 : {
459 : for (; __cur != __last; ++__cur)
460 : std::_Construct(std::__addressof(*__cur));
461 : }
462 : __catch(...)
463 : {
464 : std::_Destroy(__first, __cur);
465 : __throw_exception_again;
466 : }
467 : }
468 : };
469 :
470 : template<>
471 : struct __uninitialized_default_1<true>
472 : {
473 : template<typename _ForwardIterator>
474 : static void
475 : __uninit_default(_ForwardIterator __first, _ForwardIterator __last)
476 : {
477 : typedef typename iterator_traits<_ForwardIterator>::value_type
478 : _ValueType;
479 :
480 : std::fill(__first, __last, _ValueType());
481 : }
482 : };
483 :
484 : template<bool _TrivialValueType>
485 : struct __uninitialized_default_n_1
486 : {
487 : template<typename _ForwardIterator, typename _Size>
488 : static void
489 : __uninit_default_n(_ForwardIterator __first, _Size __n)
490 : {
491 : _ForwardIterator __cur = __first;
492 : __try
493 : {
494 : for (; __n > 0; --__n, ++__cur)
495 : std::_Construct(std::__addressof(*__cur));
496 : }
497 : __catch(...)
498 : {
499 : std::_Destroy(__first, __cur);
500 : __throw_exception_again;
501 : }
502 : }
503 : };
504 :
505 : template<>
506 : struct __uninitialized_default_n_1<true>
507 : {
508 : template<typename _ForwardIterator, typename _Size>
509 : static void
510 : __uninit_default_n(_ForwardIterator __first, _Size __n)
511 : {
512 : typedef typename iterator_traits<_ForwardIterator>::value_type
513 : _ValueType;
514 :
515 : std::fill_n(__first, __n, _ValueType());
516 : }
517 : };
518 :
519 : // __uninitialized_default
520 : // Fills [first, last) with std::distance(first, last) default
521 : // constructed value_types(s).
522 : template<typename _ForwardIterator>
523 : inline void
524 : __uninitialized_default(_ForwardIterator __first,
525 : _ForwardIterator __last)
526 : {
527 : typedef typename iterator_traits<_ForwardIterator>::value_type
528 : _ValueType;
529 :
530 : std::__uninitialized_default_1<__is_trivial(_ValueType)>::
531 : __uninit_default(__first, __last);
532 : }
533 :
534 : // __uninitialized_default_n
535 : // Fills [first, first + n) with n default constructed value_type(s).
536 : template<typename _ForwardIterator, typename _Size>
537 : inline void
538 : __uninitialized_default_n(_ForwardIterator __first, _Size __n)
539 : {
540 : typedef typename iterator_traits<_ForwardIterator>::value_type
541 : _ValueType;
542 :
543 : std::__uninitialized_default_n_1<__is_trivial(_ValueType)>::
544 : __uninit_default_n(__first, __n);
545 : }
546 :
547 :
548 : // __uninitialized_default_a
549 : // Fills [first, last) with std::distance(first, last) default
550 : // constructed value_types(s), constructed with the allocator alloc.
551 : template<typename _ForwardIterator, typename _Allocator>
552 : void
553 : __uninitialized_default_a(_ForwardIterator __first,
554 : _ForwardIterator __last,
555 : _Allocator& __alloc)
556 : {
557 : _ForwardIterator __cur = __first;
558 : __try
559 : {
560 : typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
561 : for (; __cur != __last; ++__cur)
562 : __traits::construct(__alloc, std::__addressof(*__cur));
563 : }
564 : __catch(...)
565 : {
566 : std::_Destroy(__first, __cur, __alloc);
567 : __throw_exception_again;
568 : }
569 : }
570 :
571 : template<typename _ForwardIterator, typename _Tp>
572 : inline void
573 : __uninitialized_default_a(_ForwardIterator __first,
574 : _ForwardIterator __last,
575 : allocator<_Tp>&)
576 : { std::__uninitialized_default(__first, __last); }
577 :
578 :
579 : // __uninitialized_default_n_a
580 : // Fills [first, first + n) with n default constructed value_types(s),
581 : // constructed with the allocator alloc.
582 : template<typename _ForwardIterator, typename _Size, typename _Allocator>
583 : void
584 : __uninitialized_default_n_a(_ForwardIterator __first, _Size __n,
585 : _Allocator& __alloc)
586 : {
587 : _ForwardIterator __cur = __first;
588 : __try
589 : {
590 : typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
591 : for (; __n > 0; --__n, ++__cur)
592 : __traits::construct(__alloc, std::__addressof(*__cur));
593 : }
594 : __catch(...)
595 : {
596 : std::_Destroy(__first, __cur, __alloc);
597 : __throw_exception_again;
598 : }
599 : }
600 :
601 : template<typename _ForwardIterator, typename _Size, typename _Tp>
602 : inline void
603 : __uninitialized_default_n_a(_ForwardIterator __first, _Size __n,
604 : allocator<_Tp>&)
605 : { std::__uninitialized_default_n(__first, __n); }
606 :
607 :
608 : template<typename _InputIterator, typename _Size,
609 : typename _ForwardIterator>
610 : _ForwardIterator
611 : __uninitialized_copy_n(_InputIterator __first, _Size __n,
612 : _ForwardIterator __result, input_iterator_tag)
613 : {
614 : _ForwardIterator __cur = __result;
615 : __try
616 : {
617 : for (; __n > 0; --__n, ++__first, ++__cur)
618 : std::_Construct(std::__addressof(*__cur), *__first);
619 : return __cur;
620 : }
621 : __catch(...)
622 : {
623 : std::_Destroy(__result, __cur);
624 : __throw_exception_again;
625 : }
626 : }
627 :
628 : template<typename _RandomAccessIterator, typename _Size,
629 : typename _ForwardIterator>
630 : inline _ForwardIterator
631 : __uninitialized_copy_n(_RandomAccessIterator __first, _Size __n,
632 : _ForwardIterator __result,
633 : random_access_iterator_tag)
634 : { return std::uninitialized_copy(__first, __first + __n, __result); }
635 :
636 : /**
637 : * @brief Copies the range [first,first+n) into result.
638 : * @param __first An input iterator.
639 : * @param __n The number of elements to copy.
640 : * @param __result An output iterator.
641 : * @return __result + __n
642 : *
643 : * Like copy_n(), but does not require an initialized output range.
644 : */
645 : template<typename _InputIterator, typename _Size, typename _ForwardIterator>
646 : inline _ForwardIterator
647 : uninitialized_copy_n(_InputIterator __first, _Size __n,
648 : _ForwardIterator __result)
649 : { return std::__uninitialized_copy_n(__first, __n, __result,
650 : std::__iterator_category(__first)); }
651 : #endif
652 :
653 : _GLIBCXX_END_NAMESPACE_VERSION
654 : } // namespace
655 :
656 : #endif /* _STL_UNINITIALIZED_H */
|
