LCOV - code coverage report
Current view: top level - usr/include/c++/4.9/bits - stl_uninitialized.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 14 31 45.2 %
Date: 2016-11-29 15:07:43 Functions: 39 142 27.5 %

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

Generated by: LCOV version 1.11