LCOV - code coverage report
Current view: top level - c++/5/bits - stl_uninitialized.h (source / functions) Hit Total Coverage
Test: lcov-run.info Lines: 4 7 57.1 %
Date: 2019-02-15 00:00:25 Functions: 1 1 100.0 %
Branches: 5 12 41.7 %

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

Generated by: LCOV version 1.12