LTP GCOV extension - code coverage report
Current view: directory - usr/include/c++/4.3/bits - deque.tcc
Test: lcov.info
Date: 2008-08-14 Instrumented lines: 147
Code covered: 19.0 % Executed lines: 28

       1                 : // Deque implementation (out of line) -*- C++ -*-
       2                 : 
       3                 : // Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007
       4                 : // Free Software Foundation, Inc.
       5                 : //
       6                 : // This file is part of the GNU ISO C++ Library.  This library is free
       7                 : // software; you can redistribute it and/or modify it under the
       8                 : // terms of the GNU General Public License as published by the
       9                 : // Free Software Foundation; either version 2, or (at your option)
      10                 : // any later version.
      11                 : 
      12                 : // This library is distributed in the hope that it will be useful,
      13                 : // but WITHOUT ANY WARRANTY; without even the implied warranty of
      14                 : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      15                 : // GNU General Public License for more details.
      16                 : 
      17                 : // You should have received a copy of the GNU General Public License along
      18                 : // with this library; see the file COPYING.  If not, write to the Free
      19                 : // Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
      20                 : // USA.
      21                 : 
      22                 : // As a special exception, you may use this file as part of a free software
      23                 : // library without restriction.  Specifically, if other files instantiate
      24                 : // templates or use macros or inline functions from this file, or you compile
      25                 : // this file and link it with other files to produce an executable, this
      26                 : // file does not by itself cause the resulting executable to be covered by
      27                 : // the GNU General Public License.  This exception does not however
      28                 : // invalidate any other reasons why the executable file might be covered by
      29                 : // the GNU General Public License.
      30                 : 
      31                 : /*
      32                 :  *
      33                 :  * Copyright (c) 1994
      34                 :  * Hewlett-Packard Company
      35                 :  *
      36                 :  * Permission to use, copy, modify, distribute and sell this software
      37                 :  * and its documentation for any purpose is hereby granted without fee,
      38                 :  * provided that the above copyright notice appear in all copies and
      39                 :  * that both that copyright notice and this permission notice appear
      40                 :  * in supporting documentation.  Hewlett-Packard Company makes no
      41                 :  * representations about the suitability of this software for any
      42                 :  * purpose.  It is provided "as is" without express or implied warranty.
      43                 :  *
      44                 :  *
      45                 :  * Copyright (c) 1997
      46                 :  * Silicon Graphics Computer Systems, Inc.
      47                 :  *
      48                 :  * Permission to use, copy, modify, distribute and sell this software
      49                 :  * and its documentation for any purpose is hereby granted without fee,
      50                 :  * provided that the above copyright notice appear in all copies and
      51                 :  * that both that copyright notice and this permission notice appear
      52                 :  * in supporting documentation.  Silicon Graphics makes no
      53                 :  * representations about the suitability of this software for any
      54                 :  * purpose.  It is provided "as is" without express or implied warranty.
      55                 :  */
      56                 : 
      57                 : /** @file deque.tcc
      58                 :  *  This is an internal header file, included by other library headers.
      59                 :  *  You should not attempt to use it directly.
      60                 :  */
      61                 : 
      62                 : #ifndef _DEQUE_TCC
      63                 : #define _DEQUE_TCC 1
      64                 : 
      65                 : _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D)
      66                 : 
      67                 :   template <typename _Tp, typename _Alloc>
      68                 :     deque<_Tp, _Alloc>&
      69                 :     deque<_Tp, _Alloc>::
      70               4 :     operator=(const deque& __x)
      71                 :     {
      72               4 :       const size_type __len = size();
      73               4 :       if (&__x != this)
      74                 :         {
      75               4 :           if (__len >= __x.size())
      76               4 :             _M_erase_at_end(std::copy(__x.begin(), __x.end(),
      77                 :                                       this->_M_impl._M_start));
      78                 :           else
      79                 :             {
      80               0 :               const_iterator __mid = __x.begin() + difference_type(__len);
      81               0 :               std::copy(__x.begin(), __mid, this->_M_impl._M_start);
      82               0 :               insert(this->_M_impl._M_finish, __mid, __x.end());
      83                 :             }
      84                 :         }
      85               4 :       return *this;
      86                 :     }
      87                 : 
      88                 :   template <typename _Tp, typename _Alloc>
      89                 :     typename deque<_Tp, _Alloc>::iterator
      90                 :     deque<_Tp, _Alloc>::
      91                 :     insert(iterator __position, const value_type& __x)
      92                 :     {
      93                 :       if (__position._M_cur == this->_M_impl._M_start._M_cur)
      94                 :         {
      95                 :           push_front(__x);
      96                 :           return this->_M_impl._M_start;
      97                 :         }
      98                 :       else if (__position._M_cur == this->_M_impl._M_finish._M_cur)
      99                 :         {
     100                 :           push_back(__x);
     101                 :           iterator __tmp = this->_M_impl._M_finish;
     102                 :           --__tmp;
     103                 :           return __tmp;
     104                 :         }
     105                 :       else
     106                 :         return _M_insert_aux(__position, __x);
     107                 :     }
     108                 : 
     109                 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
     110                 :   template<typename _Tp, typename _Alloc>
     111                 :     template<typename... _Args>
     112                 :       typename deque<_Tp, _Alloc>::iterator
     113                 :       deque<_Tp, _Alloc>::
     114                 :       emplace(iterator __position, _Args&&... __args)
     115                 :       {
     116                 :         if (__position._M_cur == this->_M_impl._M_start._M_cur)
     117                 :           {
     118                 :             push_front(std::forward<_Args>(__args)...);
     119                 :             return this->_M_impl._M_start;
     120                 :           }
     121                 :         else if (__position._M_cur == this->_M_impl._M_finish._M_cur)
     122                 :           {
     123                 :             push_back(std::forward<_Args>(__args)...);
     124                 :             iterator __tmp = this->_M_impl._M_finish;
     125                 :             --__tmp;
     126                 :             return __tmp;
     127                 :           }
     128                 :         else
     129                 :           return _M_insert_aux(__position, std::forward<_Args>(__args)...);
     130                 :       }
     131                 : #endif
     132                 : 
     133                 :   template <typename _Tp, typename _Alloc>
     134                 :     typename deque<_Tp, _Alloc>::iterator
     135                 :     deque<_Tp, _Alloc>::
     136                 :     erase(iterator __position)
     137                 :     {
     138                 :       iterator __next = __position;
     139                 :       ++__next;
     140                 :       const difference_type __index = __position - begin();
     141                 :       if (static_cast<size_type>(__index) < (size() >> 1))
     142                 :         {
     143                 :           if (__position != begin())
     144                 :             _GLIBCXX_MOVE_BACKWARD3(begin(), __position, __next);
     145                 :           pop_front();
     146                 :         }
     147                 :       else
     148                 :         {
     149                 :           if (__next != end())
     150                 :             _GLIBCXX_MOVE3(__next, end(), __position);
     151                 :           pop_back();
     152                 :         }
     153                 :       return begin() + __index;
     154                 :     }
     155                 : 
     156                 :   template <typename _Tp, typename _Alloc>
     157                 :     typename deque<_Tp, _Alloc>::iterator
     158                 :     deque<_Tp, _Alloc>::
     159            1012 :     erase(iterator __first, iterator __last)
     160                 :     {
     161            1012 :       if (__first == begin() && __last == end())
     162                 :         {
     163             922 :           clear();
     164             922 :           return end();
     165                 :         }
     166                 :       else
     167                 :         {
     168              90 :           const difference_type __n = __last - __first;
     169              90 :           const difference_type __elems_before = __first - begin();
     170              90 :           if (static_cast<size_type>(__elems_before) <= (size() - __n) / 2)
     171                 :             {
     172              90 :               if (__first != begin())
     173               0 :                 _GLIBCXX_MOVE_BACKWARD3(begin(), __first, __last);
     174              90 :               _M_erase_at_begin(begin() + __n);
     175                 :             }
     176                 :           else
     177                 :             {
     178               0 :               if (__last != end())
     179               0 :                 _GLIBCXX_MOVE3(__last, end(), __first);
     180               0 :               _M_erase_at_end(end() - __n);
     181                 :             }
     182              90 :           return begin() + __elems_before;
     183                 :         }
     184                 :     }
     185                 : 
     186                 :   template <typename _Tp, class _Alloc>
     187                 :     template <typename _InputIterator>
     188                 :       void
     189                 :       deque<_Tp, _Alloc>::
     190                 :       _M_assign_aux(_InputIterator __first, _InputIterator __last,
     191                 :                     std::input_iterator_tag)
     192                 :       {
     193                 :         iterator __cur = begin();
     194                 :         for (; __first != __last && __cur != end(); ++__cur, ++__first)
     195                 :           *__cur = *__first;
     196                 :         if (__first == __last)
     197                 :           _M_erase_at_end(__cur);
     198                 :         else
     199                 :           insert(end(), __first, __last);
     200                 :       }
     201                 : 
     202                 :   template <typename _Tp, typename _Alloc>
     203                 :     void
     204                 :     deque<_Tp, _Alloc>::
     205                 :     _M_fill_insert(iterator __pos, size_type __n, const value_type& __x)
     206                 :     {
     207                 :       if (__pos._M_cur == this->_M_impl._M_start._M_cur)
     208                 :         {
     209                 :           iterator __new_start = _M_reserve_elements_at_front(__n);
     210                 :           try
     211                 :             {
     212                 :               std::__uninitialized_fill_a(__new_start, this->_M_impl._M_start,
     213                 :                                           __x, _M_get_Tp_allocator());
     214                 :               this->_M_impl._M_start = __new_start;
     215                 :             }
     216                 :           catch(...)
     217                 :             {
     218                 :               _M_destroy_nodes(__new_start._M_node,
     219                 :                                this->_M_impl._M_start._M_node);
     220                 :               __throw_exception_again;
     221                 :             }
     222                 :         }
     223                 :       else if (__pos._M_cur == this->_M_impl._M_finish._M_cur)
     224                 :         {
     225                 :           iterator __new_finish = _M_reserve_elements_at_back(__n);
     226                 :           try
     227                 :             {
     228                 :               std::__uninitialized_fill_a(this->_M_impl._M_finish,
     229                 :                                           __new_finish, __x,
     230                 :                                           _M_get_Tp_allocator());
     231                 :               this->_M_impl._M_finish = __new_finish;
     232                 :             }
     233                 :           catch(...)
     234                 :             {
     235                 :               _M_destroy_nodes(this->_M_impl._M_finish._M_node + 1,
     236                 :                                __new_finish._M_node + 1);
     237                 :               __throw_exception_again;
     238                 :             }
     239                 :         }
     240                 :       else
     241                 :         _M_insert_aux(__pos, __n, __x);
     242                 :     }
     243                 : 
     244                 :   template <typename _Tp, typename _Alloc>
     245                 :     void
     246                 :     deque<_Tp, _Alloc>::
     247                 :     _M_fill_initialize(const value_type& __value)
     248                 :     {
     249                 :       _Map_pointer __cur;
     250                 :       try
     251                 :         {
     252                 :           for (__cur = this->_M_impl._M_start._M_node;
     253                 :                __cur < this->_M_impl._M_finish._M_node;
     254                 :                ++__cur)
     255                 :             std::__uninitialized_fill_a(*__cur, *__cur + _S_buffer_size(),
     256                 :                                         __value, _M_get_Tp_allocator());
     257                 :           std::__uninitialized_fill_a(this->_M_impl._M_finish._M_first,
     258                 :                                       this->_M_impl._M_finish._M_cur,
     259                 :                                       __value, _M_get_Tp_allocator());
     260                 :         }
     261                 :       catch(...)
     262                 :         {
     263                 :           std::_Destroy(this->_M_impl._M_start, iterator(*__cur, __cur),
     264                 :                         _M_get_Tp_allocator());
     265                 :           __throw_exception_again;
     266                 :         }
     267                 :     }
     268                 : 
     269                 :   template <typename _Tp, typename _Alloc>
     270                 :     template <typename _InputIterator>
     271                 :       void
     272                 :       deque<_Tp, _Alloc>::
     273                 :       _M_range_initialize(_InputIterator __first, _InputIterator __last,
     274                 :                           std::input_iterator_tag)
     275                 :       {
     276                 :         this->_M_initialize_map(0);
     277                 :         try
     278                 :           {
     279                 :             for (; __first != __last; ++__first)
     280                 :               push_back(*__first);
     281                 :           }
     282                 :         catch(...)
     283                 :           {
     284                 :             clear();
     285                 :             __throw_exception_again;
     286                 :           }
     287                 :       }
     288                 : 
     289                 :   template <typename _Tp, typename _Alloc>
     290                 :     template <typename _ForwardIterator>
     291                 :       void
     292                 :       deque<_Tp, _Alloc>::
     293                 :       _M_range_initialize(_ForwardIterator __first, _ForwardIterator __last,
     294                 :                           std::forward_iterator_tag)
     295                 :       {
     296                 :         const size_type __n = std::distance(__first, __last);
     297                 :         this->_M_initialize_map(__n);
     298                 : 
     299                 :         _Map_pointer __cur_node;
     300                 :         try
     301                 :           {
     302                 :             for (__cur_node = this->_M_impl._M_start._M_node;
     303                 :                  __cur_node < this->_M_impl._M_finish._M_node;
     304                 :                  ++__cur_node)
     305                 :               {
     306                 :                 _ForwardIterator __mid = __first;
     307                 :                 std::advance(__mid, _S_buffer_size());
     308                 :                 std::__uninitialized_copy_a(__first, __mid, *__cur_node,
     309                 :                                             _M_get_Tp_allocator());
     310                 :                 __first = __mid;
     311                 :               }
     312                 :             std::__uninitialized_copy_a(__first, __last,
     313                 :                                         this->_M_impl._M_finish._M_first,
     314                 :                                         _M_get_Tp_allocator());
     315                 :           }
     316                 :         catch(...)
     317                 :           {
     318                 :             std::_Destroy(this->_M_impl._M_start,
     319                 :                           iterator(*__cur_node, __cur_node),
     320                 :                           _M_get_Tp_allocator());
     321                 :             __throw_exception_again;
     322                 :           }
     323                 :       }
     324                 : 
     325                 :   // Called only if _M_impl._M_finish._M_cur == _M_impl._M_finish._M_last - 1.
     326                 :   template<typename _Tp, typename _Alloc>
     327                 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
     328                 :     template<typename... _Args>
     329                 :       void
     330                 :       deque<_Tp, _Alloc>::
     331                 :       _M_push_back_aux(_Args&&... __args)
     332                 : #else
     333                 :       void
     334                 :       deque<_Tp, _Alloc>::
     335              13 :       _M_push_back_aux(const value_type& __t)
     336                 : #endif
     337                 :       {
     338              13 :         _M_reserve_map_at_back();
     339              13 :         *(this->_M_impl._M_finish._M_node + 1) = this->_M_allocate_node();
     340                 :         try
     341                 :           {
     342                 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
     343                 :             this->_M_impl.construct(this->_M_impl._M_finish._M_cur,
     344                 :                                     std::forward<_Args>(__args)...);
     345                 : #else
     346              13 :             this->_M_impl.construct(this->_M_impl._M_finish._M_cur, __t);
     347                 : #endif
     348              13 :             this->_M_impl._M_finish._M_set_node(this->_M_impl._M_finish._M_node
     349                 :                                                 + 1);
     350              13 :             this->_M_impl._M_finish._M_cur = this->_M_impl._M_finish._M_first;
     351                 :           }
     352               0 :         catch(...)
     353                 :           {
     354               0 :             _M_deallocate_node(*(this->_M_impl._M_finish._M_node + 1));
     355               0 :             __throw_exception_again;
     356                 :           }
     357              13 :       }
     358                 : 
     359                 :   // Called only if _M_impl._M_start._M_cur == _M_impl._M_start._M_first.
     360                 :   template<typename _Tp, typename _Alloc>
     361                 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
     362                 :     template<typename... _Args>
     363                 :       void
     364                 :       deque<_Tp, _Alloc>::
     365                 :       _M_push_front_aux(_Args&&... __args)
     366                 : #else
     367                 :       void
     368                 :       deque<_Tp, _Alloc>::
     369                 :       _M_push_front_aux(const value_type& __t)
     370                 : #endif
     371                 :       {
     372                 :         _M_reserve_map_at_front();
     373                 :         *(this->_M_impl._M_start._M_node - 1) = this->_M_allocate_node();
     374                 :         try
     375                 :           {
     376                 :             this->_M_impl._M_start._M_set_node(this->_M_impl._M_start._M_node
     377                 :                                                - 1);
     378                 :             this->_M_impl._M_start._M_cur = this->_M_impl._M_start._M_last - 1;
     379                 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
     380                 :             this->_M_impl.construct(this->_M_impl._M_start._M_cur,
     381                 :                                     std::forward<_Args>(__args)...);
     382                 : #else
     383                 :             this->_M_impl.construct(this->_M_impl._M_start._M_cur, __t);
     384                 : #endif
     385                 :           }
     386                 :         catch(...)
     387                 :           {
     388                 :             ++this->_M_impl._M_start;
     389                 :             _M_deallocate_node(*(this->_M_impl._M_start._M_node - 1));
     390                 :             __throw_exception_again;
     391                 :           }
     392                 :       }
     393                 : 
     394                 :   // Called only if _M_impl._M_finish._M_cur == _M_impl._M_finish._M_first.
     395                 :   template <typename _Tp, typename _Alloc>
     396                 :     void deque<_Tp, _Alloc>::
     397               0 :     _M_pop_back_aux()
     398                 :     {
     399               0 :       _M_deallocate_node(this->_M_impl._M_finish._M_first);
     400               0 :       this->_M_impl._M_finish._M_set_node(this->_M_impl._M_finish._M_node - 1);
     401               0 :       this->_M_impl._M_finish._M_cur = this->_M_impl._M_finish._M_last - 1;
     402               0 :       this->_M_impl.destroy(this->_M_impl._M_finish._M_cur);
     403               0 :     }
     404                 : 
     405                 :   // Called only if _M_impl._M_start._M_cur == _M_impl._M_start._M_last - 1.
     406                 :   // Note that if the deque has at least one element (a precondition for this
     407                 :   // member function), and if
     408                 :   //   _M_impl._M_start._M_cur == _M_impl._M_start._M_last,
     409                 :   // then the deque must have at least two nodes.
     410                 :   template <typename _Tp, typename _Alloc>
     411                 :     void deque<_Tp, _Alloc>::
     412                 :     _M_pop_front_aux()
     413                 :     {
     414                 :       this->_M_impl.destroy(this->_M_impl._M_start._M_cur);
     415                 :       _M_deallocate_node(this->_M_impl._M_start._M_first);
     416                 :       this->_M_impl._M_start._M_set_node(this->_M_impl._M_start._M_node + 1);
     417                 :       this->_M_impl._M_start._M_cur = this->_M_impl._M_start._M_first;
     418                 :     }
     419                 : 
     420                 :   template <typename _Tp, typename _Alloc>
     421                 :     template <typename _InputIterator>
     422                 :       void
     423                 :       deque<_Tp, _Alloc>::
     424                 :       _M_range_insert_aux(iterator __pos,
     425                 :                           _InputIterator __first, _InputIterator __last,
     426                 :                           std::input_iterator_tag)
     427                 :       { std::copy(__first, __last, std::inserter(*this, __pos)); }
     428                 : 
     429                 :   template <typename _Tp, typename _Alloc>
     430                 :     template <typename _ForwardIterator>
     431                 :       void
     432                 :       deque<_Tp, _Alloc>::
     433                 :       _M_range_insert_aux(iterator __pos,
     434                 :                           _ForwardIterator __first, _ForwardIterator __last,
     435               0 :                           std::forward_iterator_tag)
     436                 :       {
     437               0 :         const size_type __n = std::distance(__first, __last);
     438               0 :         if (__pos._M_cur == this->_M_impl._M_start._M_cur)
     439                 :           {
     440               0 :             iterator __new_start = _M_reserve_elements_at_front(__n);
     441                 :             try
     442                 :               {
     443               0 :                 std::__uninitialized_copy_a(__first, __last, __new_start,
     444                 :                                             _M_get_Tp_allocator());
     445               0 :                 this->_M_impl._M_start = __new_start;
     446                 :               }
     447               0 :             catch(...)
     448                 :               {
     449               0 :                 _M_destroy_nodes(__new_start._M_node,
     450                 :                                  this->_M_impl._M_start._M_node);
     451               0 :                 __throw_exception_again;
     452                 :               }
     453                 :           }
     454               0 :         else if (__pos._M_cur == this->_M_impl._M_finish._M_cur)
     455                 :           {
     456               0 :             iterator __new_finish = _M_reserve_elements_at_back(__n);
     457                 :             try
     458                 :               {
     459               0 :                 std::__uninitialized_copy_a(__first, __last,
     460                 :                                             this->_M_impl._M_finish,
     461                 :                                             _M_get_Tp_allocator());
     462               0 :                 this->_M_impl._M_finish = __new_finish;
     463                 :               }
     464               0 :             catch(...)
     465                 :               {
     466               0 :                 _M_destroy_nodes(this->_M_impl._M_finish._M_node + 1,
     467                 :                                  __new_finish._M_node + 1);
     468               0 :                 __throw_exception_again;
     469                 :               }
     470                 :           }
     471                 :         else
     472               0 :           _M_insert_aux(__pos, __first, __last, __n);
     473               0 :       }
     474                 : 
     475                 :   template<typename _Tp, typename _Alloc>
     476                 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
     477                 :     template<typename... _Args>
     478                 :       typename deque<_Tp, _Alloc>::iterator
     479                 :       deque<_Tp, _Alloc>::
     480                 :       _M_insert_aux(iterator __pos, _Args&&... __args)
     481                 :       {
     482                 :         value_type __x_copy(std::forward<_Args>(__args)...); // XXX copy
     483                 : #else
     484                 :     typename deque<_Tp, _Alloc>::iterator
     485                 :       deque<_Tp, _Alloc>::
     486                 :       _M_insert_aux(iterator __pos, const value_type& __x)
     487                 :       {
     488                 :         value_type __x_copy = __x; // XXX copy
     489                 : #endif
     490                 :         difference_type __index = __pos - this->_M_impl._M_start;
     491                 :         if (static_cast<size_type>(__index) < size() / 2)
     492                 :           {
     493                 :             push_front(_GLIBCXX_MOVE(front()));
     494                 :             iterator __front1 = this->_M_impl._M_start;
     495                 :             ++__front1;
     496                 :             iterator __front2 = __front1;
     497                 :             ++__front2;
     498                 :             __pos = this->_M_impl._M_start + __index;
     499                 :             iterator __pos1 = __pos;
     500                 :             ++__pos1;
     501                 :             _GLIBCXX_MOVE3(__front2, __pos1, __front1);
     502                 :           }
     503                 :         else
     504                 :           {
     505                 :             push_back(_GLIBCXX_MOVE(back()));
     506                 :             iterator __back1 = this->_M_impl._M_finish;
     507                 :             --__back1;
     508                 :             iterator __back2 = __back1;
     509                 :             --__back2;
     510                 :             __pos = this->_M_impl._M_start + __index;
     511                 :             _GLIBCXX_MOVE_BACKWARD3(__pos, __back2, __back1);
     512                 :           }
     513                 :         *__pos = _GLIBCXX_MOVE(__x_copy);
     514                 :         return __pos;
     515                 :       }
     516                 : 
     517                 :   template <typename _Tp, typename _Alloc>
     518                 :     void
     519                 :     deque<_Tp, _Alloc>::
     520                 :     _M_insert_aux(iterator __pos, size_type __n, const value_type& __x)
     521                 :     {
     522                 :       const difference_type __elems_before = __pos - this->_M_impl._M_start;
     523                 :       const size_type __length = this->size();
     524                 :       value_type __x_copy = __x;
     525                 :       if (__elems_before < difference_type(__length / 2))
     526                 :         {
     527                 :           iterator __new_start = _M_reserve_elements_at_front(__n);
     528                 :           iterator __old_start = this->_M_impl._M_start;
     529                 :           __pos = this->_M_impl._M_start + __elems_before;
     530                 :           try
     531                 :             {
     532                 :               if (__elems_before >= difference_type(__n))
     533                 :                 {
     534                 :                   iterator __start_n = (this->_M_impl._M_start
     535                 :                                         + difference_type(__n));
     536                 :                   std::__uninitialized_move_a(this->_M_impl._M_start,
     537                 :                                               __start_n, __new_start,
     538                 :                                               _M_get_Tp_allocator());
     539                 :                   this->_M_impl._M_start = __new_start;
     540                 :                   _GLIBCXX_MOVE3(__start_n, __pos, __old_start);
     541                 :                   std::fill(__pos - difference_type(__n), __pos, __x_copy);
     542                 :                 }
     543                 :               else
     544                 :                 {
     545                 :                   std::__uninitialized_move_fill(this->_M_impl._M_start,
     546                 :                                                  __pos, __new_start,
     547                 :                                                  this->_M_impl._M_start,
     548                 :                                                  __x_copy,
     549                 :                                                  _M_get_Tp_allocator());
     550                 :                   this->_M_impl._M_start = __new_start;
     551                 :                   std::fill(__old_start, __pos, __x_copy);
     552                 :                 }
     553                 :             }
     554                 :           catch(...)
     555                 :             {
     556                 :               _M_destroy_nodes(__new_start._M_node,
     557                 :                                this->_M_impl._M_start._M_node);
     558                 :               __throw_exception_again;
     559                 :             }
     560                 :         }
     561                 :       else
     562                 :         {
     563                 :           iterator __new_finish = _M_reserve_elements_at_back(__n);
     564                 :           iterator __old_finish = this->_M_impl._M_finish;
     565                 :           const difference_type __elems_after =
     566                 :             difference_type(__length) - __elems_before;
     567                 :           __pos = this->_M_impl._M_finish - __elems_after;
     568                 :           try
     569                 :             {
     570                 :               if (__elems_after > difference_type(__n))
     571                 :                 {
     572                 :                   iterator __finish_n = (this->_M_impl._M_finish
     573                 :                                          - difference_type(__n));
     574                 :                   std::__uninitialized_move_a(__finish_n,
     575                 :                                               this->_M_impl._M_finish,
     576                 :                                               this->_M_impl._M_finish,
     577                 :                                               _M_get_Tp_allocator());
     578                 :                   this->_M_impl._M_finish = __new_finish;
     579                 :                   _GLIBCXX_MOVE_BACKWARD3(__pos, __finish_n, __old_finish);
     580                 :                   std::fill(__pos, __pos + difference_type(__n), __x_copy);
     581                 :                 }
     582                 :               else
     583                 :                 {
     584                 :                   std::__uninitialized_fill_move(this->_M_impl._M_finish,
     585                 :                                                  __pos + difference_type(__n),
     586                 :                                                  __x_copy, __pos,
     587                 :                                                  this->_M_impl._M_finish,
     588                 :                                                  _M_get_Tp_allocator());
     589                 :                   this->_M_impl._M_finish = __new_finish;
     590                 :                   std::fill(__pos, __old_finish, __x_copy);
     591                 :                 }
     592                 :             }
     593                 :           catch(...)
     594                 :             {
     595                 :               _M_destroy_nodes(this->_M_impl._M_finish._M_node + 1,
     596                 :                                __new_finish._M_node + 1);
     597                 :               __throw_exception_again;
     598                 :             }
     599                 :         }
     600                 :     }
     601                 : 
     602                 :   template <typename _Tp, typename _Alloc>
     603                 :     template <typename _ForwardIterator>
     604                 :       void
     605                 :       deque<_Tp, _Alloc>::
     606                 :       _M_insert_aux(iterator __pos,
     607                 :                     _ForwardIterator __first, _ForwardIterator __last,
     608               0 :                     size_type __n)
     609                 :       {
     610               0 :         const difference_type __elemsbefore = __pos - this->_M_impl._M_start;
     611               0 :         const size_type __length = size();
     612               0 :         if (static_cast<size_type>(__elemsbefore) < __length / 2)
     613                 :           {
     614               0 :             iterator __new_start = _M_reserve_elements_at_front(__n);
     615               0 :             iterator __old_start = this->_M_impl._M_start;
     616               0 :             __pos = this->_M_impl._M_start + __elemsbefore;
     617                 :             try
     618                 :               {
     619               0 :                 if (__elemsbefore >= difference_type(__n))
     620                 :                   {
     621                 :                     iterator __start_n = (this->_M_impl._M_start
     622               0 :                                           + difference_type(__n));
     623               0 :                     std::__uninitialized_move_a(this->_M_impl._M_start,
     624                 :                                                 __start_n, __new_start,
     625                 :                                                 _M_get_Tp_allocator());
     626               0 :                     this->_M_impl._M_start = __new_start;
     627               0 :                     _GLIBCXX_MOVE3(__start_n, __pos, __old_start);
     628               0 :                     std::copy(__first, __last, __pos - difference_type(__n));
     629                 :                   }
     630                 :                 else
     631                 :                   {
     632               0 :                     _ForwardIterator __mid = __first;
     633               0 :                     std::advance(__mid, difference_type(__n) - __elemsbefore);
     634               0 :                     std::__uninitialized_move_copy(this->_M_impl._M_start,
     635                 :                                                    __pos, __first, __mid,
     636                 :                                                    __new_start,
     637                 :                                                    _M_get_Tp_allocator());
     638               0 :                     this->_M_impl._M_start = __new_start;
     639               0 :                     std::copy(__mid, __last, __old_start);
     640                 :                   }
     641                 :               }
     642               0 :             catch(...)
     643                 :               {
     644               0 :                 _M_destroy_nodes(__new_start._M_node,
     645                 :                                  this->_M_impl._M_start._M_node);
     646               0 :                 __throw_exception_again;
     647                 :               }
     648                 :           }
     649                 :         else
     650                 :         {
     651               0 :           iterator __new_finish = _M_reserve_elements_at_back(__n);
     652               0 :           iterator __old_finish = this->_M_impl._M_finish;
     653                 :           const difference_type __elemsafter =
     654               0 :             difference_type(__length) - __elemsbefore;
     655               0 :           __pos = this->_M_impl._M_finish - __elemsafter;
     656                 :           try
     657                 :             {
     658               0 :               if (__elemsafter > difference_type(__n))
     659                 :                 {
     660                 :                   iterator __finish_n = (this->_M_impl._M_finish
     661               0 :                                          - difference_type(__n));
     662               0 :                   std::__uninitialized_move_a(__finish_n,
     663                 :                                               this->_M_impl._M_finish,
     664                 :                                               this->_M_impl._M_finish,
     665                 :                                               _M_get_Tp_allocator());
     666               0 :                   this->_M_impl._M_finish = __new_finish;
     667               0 :                   _GLIBCXX_MOVE_BACKWARD3(__pos, __finish_n, __old_finish);
     668               0 :                   std::copy(__first, __last, __pos);
     669                 :                 }
     670                 :               else
     671                 :                 {
     672               0 :                   _ForwardIterator __mid = __first;
     673               0 :                   std::advance(__mid, __elemsafter);
     674               0 :                   std::__uninitialized_copy_move(__mid, __last, __pos,
     675                 :                                                  this->_M_impl._M_finish,
     676                 :                                                  this->_M_impl._M_finish,
     677                 :                                                  _M_get_Tp_allocator());
     678               0 :                   this->_M_impl._M_finish = __new_finish;
     679               0 :                   std::copy(__first, __mid, __pos);
     680                 :                 }
     681                 :             }
     682               0 :           catch(...)
     683                 :             {
     684               0 :               _M_destroy_nodes(this->_M_impl._M_finish._M_node + 1,
     685                 :                                __new_finish._M_node + 1);
     686               0 :               __throw_exception_again;
     687                 :             }
     688                 :         }
     689               0 :       }
     690                 : 
     691                 :    template<typename _Tp, typename _Alloc>
     692                 :      void
     693                 :      deque<_Tp, _Alloc>::
     694              26 :      _M_destroy_data_aux(iterator __first, iterator __last)
     695                 :      {
     696              26 :        for (_Map_pointer __node = __first._M_node + 1;
     697                 :             __node < __last._M_node; ++__node)
     698               0 :          std::_Destroy(*__node, *__node + _S_buffer_size(),
     699                 :                        _M_get_Tp_allocator());
     700                 : 
     701              26 :        if (__first._M_node != __last._M_node)
     702                 :          {
     703               0 :            std::_Destroy(__first._M_cur, __first._M_last,
     704                 :                          _M_get_Tp_allocator());
     705               0 :            std::_Destroy(__last._M_first, __last._M_cur,
     706                 :                          _M_get_Tp_allocator());
     707                 :          }
     708                 :        else
     709              26 :          std::_Destroy(__first._M_cur, __last._M_cur,
     710                 :                        _M_get_Tp_allocator());
     711              26 :      }
     712                 : 
     713                 :   template <typename _Tp, typename _Alloc>
     714                 :     void
     715                 :     deque<_Tp, _Alloc>::
     716               0 :     _M_new_elements_at_front(size_type __new_elems)
     717                 :     {
     718               0 :       if (this->max_size() - this->size() < __new_elems)
     719               0 :         __throw_length_error(__N("deque::_M_new_elements_at_front"));
     720                 : 
     721                 :       const size_type __new_nodes = ((__new_elems + _S_buffer_size() - 1)
     722               0 :                                      / _S_buffer_size());
     723               0 :       _M_reserve_map_at_front(__new_nodes);
     724                 :       size_type __i;
     725                 :       try
     726                 :         {
     727               0 :           for (__i = 1; __i <= __new_nodes; ++__i)
     728               0 :             *(this->_M_impl._M_start._M_node - __i) = this->_M_allocate_node();
     729                 :         }
     730               0 :       catch(...)
     731                 :         {
     732               0 :           for (size_type __j = 1; __j < __i; ++__j)
     733               0 :             _M_deallocate_node(*(this->_M_impl._M_start._M_node - __j));
     734               0 :           __throw_exception_again;
     735                 :         }
     736               0 :     }
     737                 : 
     738                 :   template <typename _Tp, typename _Alloc>
     739                 :     void
     740                 :     deque<_Tp, _Alloc>::
     741               0 :     _M_new_elements_at_back(size_type __new_elems)
     742                 :     {
     743               0 :       if (this->max_size() - this->size() < __new_elems)
     744               0 :         __throw_length_error(__N("deque::_M_new_elements_at_back"));
     745                 : 
     746                 :       const size_type __new_nodes = ((__new_elems + _S_buffer_size() - 1)
     747               0 :                                      / _S_buffer_size());
     748               0 :       _M_reserve_map_at_back(__new_nodes);
     749                 :       size_type __i;
     750                 :       try
     751                 :         {
     752               0 :           for (__i = 1; __i <= __new_nodes; ++__i)
     753               0 :             *(this->_M_impl._M_finish._M_node + __i) = this->_M_allocate_node();
     754                 :         }
     755               0 :       catch(...)
     756                 :         {
     757               0 :           for (size_type __j = 1; __j < __i; ++__j)
     758               0 :             _M_deallocate_node(*(this->_M_impl._M_finish._M_node + __j));
     759               0 :           __throw_exception_again;
     760                 :         }
     761               0 :     }
     762                 : 
     763                 :   template <typename _Tp, typename _Alloc>
     764                 :     void
     765                 :     deque<_Tp, _Alloc>::
     766               0 :     _M_reallocate_map(size_type __nodes_to_add, bool __add_at_front)
     767                 :     {
     768                 :       const size_type __old_num_nodes
     769               0 :         = this->_M_impl._M_finish._M_node - this->_M_impl._M_start._M_node + 1;
     770               0 :       const size_type __new_num_nodes = __old_num_nodes + __nodes_to_add;
     771                 : 
     772                 :       _Map_pointer __new_nstart;
     773               0 :       if (this->_M_impl._M_map_size > 2 * __new_num_nodes)
     774                 :         {
     775               0 :           __new_nstart = this->_M_impl._M_map + (this->_M_impl._M_map_size
     776                 :                                          - __new_num_nodes) / 2
     777                 :                          + (__add_at_front ? __nodes_to_add : 0);
     778               0 :           if (__new_nstart < this->_M_impl._M_start._M_node)
     779               0 :             std::copy(this->_M_impl._M_start._M_node,
     780                 :                       this->_M_impl._M_finish._M_node + 1,
     781                 :                       __new_nstart);
     782                 :           else
     783               0 :             std::copy_backward(this->_M_impl._M_start._M_node,
     784                 :                                this->_M_impl._M_finish._M_node + 1,
     785                 :                                __new_nstart + __old_num_nodes);
     786                 :         }
     787                 :       else
     788                 :         {
     789                 :           size_type __new_map_size = this->_M_impl._M_map_size
     790                 :                                      + std::max(this->_M_impl._M_map_size,
     791               0 :                                                 __nodes_to_add) + 2;
     792                 : 
     793               0 :           _Map_pointer __new_map = this->_M_allocate_map(__new_map_size);
     794               0 :           __new_nstart = __new_map + (__new_map_size - __new_num_nodes) / 2
     795                 :                          + (__add_at_front ? __nodes_to_add : 0);
     796               0 :           std::copy(this->_M_impl._M_start._M_node,
     797                 :                     this->_M_impl._M_finish._M_node + 1,
     798                 :                     __new_nstart);
     799               0 :           _M_deallocate_map(this->_M_impl._M_map, this->_M_impl._M_map_size);
     800                 : 
     801               0 :           this->_M_impl._M_map = __new_map;
     802               0 :           this->_M_impl._M_map_size = __new_map_size;
     803                 :         }
     804                 : 
     805               0 :       this->_M_impl._M_start._M_set_node(__new_nstart);
     806               0 :       this->_M_impl._M_finish._M_set_node(__new_nstart + __old_num_nodes - 1);
     807               0 :     }
     808                 : 
     809                 :   // Overload for deque::iterators, exploiting the "segmented-iterator
     810                 :   // optimization".  NB: leave const_iterators alone!
     811                 :   template<typename _Tp>
     812                 :     void
     813                 :     fill(const _Deque_iterator<_Tp, _Tp&, _Tp*>& __first,
     814                 :          const _Deque_iterator<_Tp, _Tp&, _Tp*>& __last, const _Tp& __value)
     815                 :     {
     816                 :       typedef typename _Deque_iterator<_Tp, _Tp&, _Tp*>::_Self _Self;
     817                 : 
     818                 :       for (typename _Self::_Map_pointer __node = __first._M_node + 1;
     819                 :            __node < __last._M_node; ++__node)
     820                 :         std::fill(*__node, *__node + _Self::_S_buffer_size(), __value);
     821                 : 
     822                 :       if (__first._M_node != __last._M_node)
     823                 :         {
     824                 :           std::fill(__first._M_cur, __first._M_last, __value);
     825                 :           std::fill(__last._M_first, __last._M_cur, __value);
     826                 :         }
     827                 :       else
     828                 :         std::fill(__first._M_cur, __last._M_cur, __value);
     829                 :     }
     830                 : 
     831                 : _GLIBCXX_END_NESTED_NAMESPACE
     832                 : 
     833                 : #endif

Generated by: LTP GCOV extension version 1.6