vector.tcc

Go to the documentation of this file.
00001 // Vector implementation (out of line) -*- C++ -*-
00002 
00003 // Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007
00004 // Free Software Foundation, Inc.
00005 //
00006 // This file is part of the GNU ISO C++ Library.  This library is free
00007 // software; you can redistribute it and/or modify it under the
00008 // terms of the GNU General Public License as published by the
00009 // Free Software Foundation; either version 2, or (at your option)
00010 // any later version.
00011 
00012 // This library is distributed in the hope that it will be useful,
00013 // but WITHOUT ANY WARRANTY; without even the implied warranty of
00014 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00015 // GNU General Public License for more details.
00016 
00017 // You should have received a copy of the GNU General Public License along
00018 // with this library; see the file COPYING.  If not, write to the Free
00019 // Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
00020 // USA.
00021 
00022 // As a special exception, you may use this file as part of a free software
00023 // library without restriction.  Specifically, if other files instantiate
00024 // templates or use macros or inline functions from this file, or you compile
00025 // this file and link it with other files to produce an executable, this
00026 // file does not by itself cause the resulting executable to be covered by
00027 // the GNU General Public License.  This exception does not however
00028 // invalidate any other reasons why the executable file might be covered by
00029 // the GNU General Public License.
00030 
00031 /*
00032  *
00033  * Copyright (c) 1994
00034  * Hewlett-Packard Company
00035  *
00036  * Permission to use, copy, modify, distribute and sell this software
00037  * and its documentation for any purpose is hereby granted without fee,
00038  * provided that the above copyright notice appear in all copies and
00039  * that both that copyright notice and this permission notice appear
00040  * in supporting documentation.  Hewlett-Packard Company makes no
00041  * representations about the suitability of this software for any
00042  * purpose.  It is provided "as is" without express or implied warranty.
00043  *
00044  *
00045  * Copyright (c) 1996
00046  * Silicon Graphics Computer Systems, Inc.
00047  *
00048  * Permission to use, copy, modify, distribute and sell this software
00049  * and its documentation for any purpose is hereby granted without fee,
00050  * provided that the above copyright notice appear in all copies and
00051  * that both that copyright notice and this permission notice appear
00052  * in supporting documentation.  Silicon Graphics makes no
00053  * representations about the suitability of this  software for any
00054  * purpose.  It is provided "as is" without express or implied warranty.
00055  */
00056 
00057 /** @file vector.tcc
00058  *  This is an internal header file, included by other library headers.
00059  *  You should not attempt to use it directly.
00060  */
00061 
00062 #ifndef _VECTOR_TCC
00063 #define _VECTOR_TCC 1
00064 
00065 _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D)
00066 
00067   template<typename _Tp, typename _Alloc>
00068     void
00069     vector<_Tp, _Alloc>::
00070     reserve(size_type __n)
00071     {
00072       if (__n > this->max_size())
00073     __throw_length_error(__N("vector::reserve"));
00074       if (this->capacity() < __n)
00075     {
00076       const size_type __old_size = size();
00077       pointer __tmp = _M_allocate_and_copy(__n,
00078          _GLIBCXX_MAKE_MOVE_ITERATOR(this->_M_impl._M_start),
00079          _GLIBCXX_MAKE_MOVE_ITERATOR(this->_M_impl._M_finish));
00080       std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
00081             _M_get_Tp_allocator());
00082       _M_deallocate(this->_M_impl._M_start,
00083             this->_M_impl._M_end_of_storage
00084             - this->_M_impl._M_start);
00085       this->_M_impl._M_start = __tmp;
00086       this->_M_impl._M_finish = __tmp + __old_size;
00087       this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n;
00088     }
00089     }
00090 
00091   template<typename _Tp, typename _Alloc>
00092     typename vector<_Tp, _Alloc>::iterator
00093     vector<_Tp, _Alloc>::
00094     insert(iterator __position, const value_type& __x)
00095     {
00096       const size_type __n = __position - begin();
00097       if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage
00098       && __position == end())
00099     {
00100       this->_M_impl.construct(this->_M_impl._M_finish, __x);
00101       ++this->_M_impl._M_finish;
00102     }
00103       else
00104     {
00105 #ifdef __GXX_EXPERIMENTAL_CXX0X__
00106       if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
00107         {
00108           _Tp __x_copy = __x;
00109           _M_insert_aux(__position, std::move(__x_copy));
00110         }
00111       else
00112 #endif
00113         _M_insert_aux(__position, __x);
00114     }
00115       return iterator(this->_M_impl._M_start + __n);
00116     }
00117 
00118   template<typename _Tp, typename _Alloc>
00119     typename vector<_Tp, _Alloc>::iterator
00120     vector<_Tp, _Alloc>::
00121     erase(iterator __position)
00122     {
00123       if (__position + 1 != end())
00124     _GLIBCXX_MOVE3(__position + 1, end(), __position);
00125       --this->_M_impl._M_finish;
00126       this->_M_impl.destroy(this->_M_impl._M_finish);
00127       return __position;
00128     }
00129 
00130   template<typename _Tp, typename _Alloc>
00131     typename vector<_Tp, _Alloc>::iterator
00132     vector<_Tp, _Alloc>::
00133     erase(iterator __first, iterator __last)
00134     {
00135       if (__last != end())
00136     _GLIBCXX_MOVE3(__last, end(), __first);
00137       _M_erase_at_end(__first.base() + (end() - __last));
00138       return __first;
00139     }
00140 
00141   template<typename _Tp, typename _Alloc>
00142     vector<_Tp, _Alloc>&
00143     vector<_Tp, _Alloc>::
00144     operator=(const vector<_Tp, _Alloc>& __x)
00145     {
00146       if (&__x != this)
00147     {
00148       const size_type __xlen = __x.size();
00149       if (__xlen > capacity())
00150         {
00151           pointer __tmp = _M_allocate_and_copy(__xlen, __x.begin(),
00152                            __x.end());
00153           std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
00154                 _M_get_Tp_allocator());
00155           _M_deallocate(this->_M_impl._M_start,
00156                 this->_M_impl._M_end_of_storage
00157                 - this->_M_impl._M_start);
00158           this->_M_impl._M_start = __tmp;
00159           this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __xlen;
00160         }
00161       else if (size() >= __xlen)
00162         {
00163           std::_Destroy(std::copy(__x.begin(), __x.end(), begin()),
00164                 end(), _M_get_Tp_allocator());
00165         }
00166       else
00167         {
00168           std::copy(__x._M_impl._M_start, __x._M_impl._M_start + size(),
00169             this->_M_impl._M_start);
00170           std::__uninitialized_copy_a(__x._M_impl._M_start + size(),
00171                       __x._M_impl._M_finish,
00172                       this->_M_impl._M_finish,
00173                       _M_get_Tp_allocator());
00174         }
00175       this->_M_impl._M_finish = this->_M_impl._M_start + __xlen;
00176     }
00177       return *this;
00178     }
00179 
00180   template<typename _Tp, typename _Alloc>
00181     void
00182     vector<_Tp, _Alloc>::
00183     _M_fill_assign(size_t __n, const value_type& __val)
00184     {
00185       if (__n > capacity())
00186     {
00187       vector __tmp(__n, __val, _M_get_Tp_allocator());
00188       __tmp.swap(*this);
00189     }
00190       else if (__n > size())
00191     {
00192       std::fill(begin(), end(), __val);
00193       std::__uninitialized_fill_n_a(this->_M_impl._M_finish,
00194                     __n - size(), __val,
00195                     _M_get_Tp_allocator());
00196       this->_M_impl._M_finish += __n - size();
00197     }
00198       else
00199         _M_erase_at_end(std::fill_n(this->_M_impl._M_start, __n, __val));
00200     }
00201 
00202   template<typename _Tp, typename _Alloc>
00203     template<typename _InputIterator>
00204       void
00205       vector<_Tp, _Alloc>::
00206       _M_assign_aux(_InputIterator __first, _InputIterator __last,
00207             std::input_iterator_tag)
00208       {
00209     pointer __cur(this->_M_impl._M_start);
00210     for (; __first != __last && __cur != this->_M_impl._M_finish;
00211          ++__cur, ++__first)
00212       *__cur = *__first;
00213     if (__first == __last)
00214       _M_erase_at_end(__cur);
00215     else
00216       insert(end(), __first, __last);
00217       }
00218 
00219   template<typename _Tp, typename _Alloc>
00220     template<typename _ForwardIterator>
00221       void
00222       vector<_Tp, _Alloc>::
00223       _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
00224             std::forward_iterator_tag)
00225       {
00226     const size_type __len = std::distance(__first, __last);
00227 
00228     if (__len > capacity())
00229       {
00230         pointer __tmp(_M_allocate_and_copy(__len, __first, __last));
00231         std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
00232               _M_get_Tp_allocator());
00233         _M_deallocate(this->_M_impl._M_start,
00234               this->_M_impl._M_end_of_storage
00235               - this->_M_impl._M_start);
00236         this->_M_impl._M_start = __tmp;
00237         this->_M_impl._M_finish = this->_M_impl._M_start + __len;
00238         this->_M_impl._M_end_of_storage = this->_M_impl._M_finish;
00239       }
00240     else if (size() >= __len)
00241       _M_erase_at_end(std::copy(__first, __last, this->_M_impl._M_start));
00242     else
00243       {
00244         _ForwardIterator __mid = __first;
00245         std::advance(__mid, size());
00246         std::copy(__first, __mid, this->_M_impl._M_start);
00247         this->_M_impl._M_finish =
00248           std::__uninitialized_copy_a(__mid, __last,
00249                       this->_M_impl._M_finish,
00250                       _M_get_Tp_allocator());
00251       }
00252       }
00253 
00254 #ifdef __GXX_EXPERIMENTAL_CXX0X__
00255   template<typename _Tp, typename _Alloc>
00256     template<typename... _Args>
00257       typename vector<_Tp, _Alloc>::iterator
00258       vector<_Tp, _Alloc>::
00259       emplace(iterator __position, _Args&&... __args)
00260       {
00261     const size_type __n = __position - begin();
00262     if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage
00263         && __position == end())
00264       {
00265         this->_M_impl.construct(this->_M_impl._M_finish,
00266                     std::forward<_Args>(__args)...);
00267         ++this->_M_impl._M_finish;
00268       }
00269     else
00270       _M_insert_aux(__position, std::forward<_Args>(__args)...);
00271     return iterator(this->_M_impl._M_start + __n);
00272       }
00273 
00274   template<typename _Tp, typename _Alloc>
00275     template<typename... _Args>
00276       void
00277       vector<_Tp, _Alloc>::
00278       _M_insert_aux(iterator __position, _Args&&... __args)
00279 #else
00280   template<typename _Tp, typename _Alloc>
00281     void
00282     vector<_Tp, _Alloc>::
00283     _M_insert_aux(iterator __position, const _Tp& __x)
00284 #endif
00285     {
00286       if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
00287     {
00288       this->_M_impl.construct(this->_M_impl._M_finish,
00289                   _GLIBCXX_MOVE(*(this->_M_impl._M_finish
00290                           - 1)));
00291       ++this->_M_impl._M_finish;
00292 #ifndef __GXX_EXPERIMENTAL_CXX0X__
00293       _Tp __x_copy = __x;
00294 #endif
00295       _GLIBCXX_MOVE_BACKWARD3(__position.base(),
00296                   this->_M_impl._M_finish - 2,
00297                   this->_M_impl._M_finish - 1);
00298 #ifndef __GXX_EXPERIMENTAL_CXX0X__
00299       *__position = __x_copy;
00300 #else
00301       *__position = _Tp(std::forward<_Args>(__args)...);
00302 #endif
00303     }
00304       else
00305     {
00306       const size_type __len =
00307         _M_check_len(size_type(1), "vector::_M_insert_aux");
00308       pointer __new_start(this->_M_allocate(__len));
00309       pointer __new_finish(__new_start);
00310       try
00311         {
00312 #ifdef __GXX_EXPERIMENTAL_CXX0X__
00313           this->_M_impl.construct(__new_start + (__position - begin()),
00314                       std::forward<_Args>(__args)...);
00315 #endif
00316           __new_finish =
00317         std::__uninitialized_move_a(this->_M_impl._M_start,
00318                         __position.base(), __new_start,
00319                         _M_get_Tp_allocator());
00320 #ifndef __GXX_EXPERIMENTAL_CXX0X__
00321           this->_M_impl.construct(__new_finish, __x);
00322 #endif
00323           ++__new_finish;
00324           __new_finish =
00325         std::__uninitialized_move_a(__position.base(),
00326                         this->_M_impl._M_finish,
00327                         __new_finish,
00328                         _M_get_Tp_allocator());
00329         }
00330       catch(...)
00331         {
00332           std::_Destroy(__new_start, __new_finish, _M_get_Tp_allocator());
00333           _M_deallocate(__new_start, __len);
00334           __throw_exception_again;
00335         }
00336       std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
00337             _M_get_Tp_allocator());
00338       _M_deallocate(this->_M_impl._M_start,
00339             this->_M_impl._M_end_of_storage
00340             - this->_M_impl._M_start);
00341       this->_M_impl._M_start = __new_start;
00342       this->_M_impl._M_finish = __new_finish;
00343       this->_M_impl._M_end_of_storage = __new_start + __len;
00344     }
00345     }
00346 
00347   template<typename _Tp, typename _Alloc>
00348     void
00349     vector<_Tp, _Alloc>::
00350     _M_fill_insert(iterator __position, size_type __n, const value_type& __x)
00351     {
00352       if (__n != 0)
00353     {
00354 #ifdef __GXX_EXPERIMENTAL_CXX0X__
00355       value_type __x_copy = __x;
00356 #endif
00357       if (size_type(this->_M_impl._M_end_of_storage
00358             - this->_M_impl._M_finish) >= __n)
00359         {
00360 #ifndef __GXX_EXPERIMENTAL_CXX0X__
00361           value_type __x_copy = __x;
00362 #endif
00363           const size_type __elems_after = end() - __position;
00364           pointer __old_finish(this->_M_impl._M_finish);
00365           if (__elems_after > __n)
00366         {
00367           std::__uninitialized_move_a(this->_M_impl._M_finish - __n,
00368                           this->_M_impl._M_finish,
00369                           this->_M_impl._M_finish,
00370                           _M_get_Tp_allocator());
00371           this->_M_impl._M_finish += __n;
00372           _GLIBCXX_MOVE_BACKWARD3(__position.base(),
00373                       __old_finish - __n, __old_finish);
00374           std::fill(__position.base(), __position.base() + __n,
00375                 __x_copy);
00376         }
00377           else
00378         {
00379           std::__uninitialized_fill_n_a(this->_M_impl._M_finish,
00380                         __n - __elems_after,
00381                         __x_copy,
00382                         _M_get_Tp_allocator());
00383           this->_M_impl._M_finish += __n - __elems_after;
00384           std::__uninitialized_move_a(__position.base(), __old_finish,
00385                           this->_M_impl._M_finish,
00386                           _M_get_Tp_allocator());
00387           this->_M_impl._M_finish += __elems_after;
00388           std::fill(__position.base(), __old_finish, __x_copy);
00389         }
00390         }
00391       else
00392         {
00393           const size_type __len =
00394         _M_check_len(__n, "vector::_M_fill_insert");
00395           pointer __new_start(this->_M_allocate(__len));
00396           pointer __new_finish(__new_start);
00397           try
00398         {
00399           __new_finish =
00400             std::__uninitialized_move_a(this->_M_impl._M_start,
00401                         __position.base(),
00402                         __new_start,
00403                         _M_get_Tp_allocator());
00404 #ifdef __GXX_EXPERIMENTAL_CXX0X__
00405           std::__uninitialized_fill_n_a(__new_finish, __n, __x_copy,
00406 #else
00407           std::__uninitialized_fill_n_a(__new_finish, __n, __x,
00408 #endif
00409                         _M_get_Tp_allocator());
00410           __new_finish += __n;
00411           __new_finish =
00412             std::__uninitialized_move_a(__position.base(),
00413                         this->_M_impl._M_finish,
00414                         __new_finish,
00415                         _M_get_Tp_allocator());
00416         }
00417           catch(...)
00418         {
00419           std::_Destroy(__new_start, __new_finish,
00420                 _M_get_Tp_allocator());
00421           _M_deallocate(__new_start, __len);
00422           __throw_exception_again;
00423         }
00424           std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
00425                 _M_get_Tp_allocator());
00426           _M_deallocate(this->_M_impl._M_start,
00427                 this->_M_impl._M_end_of_storage
00428                 - this->_M_impl._M_start);
00429           this->_M_impl._M_start = __new_start;
00430           this->_M_impl._M_finish = __new_finish;
00431           this->_M_impl._M_end_of_storage = __new_start + __len;
00432         }
00433     }
00434     }
00435 
00436   template<typename _Tp, typename _Alloc>
00437     template<typename _InputIterator>
00438       void
00439       vector<_Tp, _Alloc>::
00440       _M_range_insert(iterator __pos, _InputIterator __first,
00441               _InputIterator __last, std::input_iterator_tag)
00442       {
00443     for (; __first != __last; ++__first)
00444       {
00445         __pos = insert(__pos, *__first);
00446         ++__pos;
00447       }
00448       }
00449 
00450   template<typename _Tp, typename _Alloc>
00451     template<typename _ForwardIterator>
00452       void
00453       vector<_Tp, _Alloc>::
00454       _M_range_insert(iterator __position, _ForwardIterator __first,
00455               _ForwardIterator __last, std::forward_iterator_tag)
00456       {
00457     if (__first != __last)
00458       {
00459         const size_type __n = std::distance(__first, __last);
00460         if (size_type(this->_M_impl._M_end_of_storage
00461               - this->_M_impl._M_finish) >= __n)
00462           {
00463         const size_type __elems_after = end() - __position;
00464         pointer __old_finish(this->_M_impl._M_finish);
00465         if (__elems_after > __n)
00466           {
00467             std::__uninitialized_move_a(this->_M_impl._M_finish - __n,
00468                         this->_M_impl._M_finish,
00469                         this->_M_impl._M_finish,
00470                         _M_get_Tp_allocator());
00471             this->_M_impl._M_finish += __n;
00472             _GLIBCXX_MOVE_BACKWARD3(__position.base(),
00473                         __old_finish - __n, __old_finish);
00474             std::copy(__first, __last, __position);
00475           }
00476         else
00477           {
00478             _ForwardIterator __mid = __first;
00479             std::advance(__mid, __elems_after);
00480             std::__uninitialized_copy_a(__mid, __last,
00481                         this->_M_impl._M_finish,
00482                         _M_get_Tp_allocator());
00483             this->_M_impl._M_finish += __n - __elems_after;
00484             std::__uninitialized_move_a(__position.base(),
00485                         __old_finish,
00486                         this->_M_impl._M_finish,
00487                         _M_get_Tp_allocator());
00488             this->_M_impl._M_finish += __elems_after;
00489             std::copy(__first, __mid, __position);
00490           }
00491           }
00492         else
00493           {
00494         const size_type __len =
00495           _M_check_len(__n, "vector::_M_range_insert");
00496         pointer __new_start(this->_M_allocate(__len));
00497         pointer __new_finish(__new_start);
00498         try
00499           {
00500             __new_finish =
00501               std::__uninitialized_move_a(this->_M_impl._M_start,
00502                           __position.base(),
00503                           __new_start,
00504                           _M_get_Tp_allocator());
00505             __new_finish =
00506               std::__uninitialized_copy_a(__first, __last,
00507                           __new_finish,
00508                           _M_get_Tp_allocator());
00509             __new_finish =
00510               std::__uninitialized_move_a(__position.base(),
00511                           this->_M_impl._M_finish,
00512                           __new_finish,
00513                           _M_get_Tp_allocator());
00514           }
00515         catch(...)
00516           {
00517             std::_Destroy(__new_start, __new_finish,
00518                   _M_get_Tp_allocator());
00519             _M_deallocate(__new_start, __len);
00520             __throw_exception_again;
00521           }
00522         std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
00523                   _M_get_Tp_allocator());
00524         _M_deallocate(this->_M_impl._M_start,
00525                   this->_M_impl._M_end_of_storage
00526                   - this->_M_impl._M_start);
00527         this->_M_impl._M_start = __new_start;
00528         this->_M_impl._M_finish = __new_finish;
00529         this->_M_impl._M_end_of_storage = __new_start + __len;
00530           }
00531       }
00532       }
00533 
00534 
00535   // vector<bool>
00536 
00537   template<typename _Alloc>
00538     void
00539     vector<bool, _Alloc>::
00540     reserve(size_type __n)
00541     {
00542       if (__n > this->max_size())
00543     __throw_length_error(__N("vector::reserve"));
00544       if (this->capacity() < __n)
00545     {
00546       _Bit_type* __q = this->_M_allocate(__n);
00547       this->_M_impl._M_finish = _M_copy_aligned(begin(), end(),
00548                             iterator(__q, 0));
00549       this->_M_deallocate();
00550       this->_M_impl._M_start = iterator(__q, 0);
00551       this->_M_impl._M_end_of_storage = (__q + (__n + int(_S_word_bit) - 1)
00552                          / int(_S_word_bit));
00553     }
00554     }
00555 
00556   template<typename _Alloc>
00557     void
00558     vector<bool, _Alloc>::
00559     _M_fill_insert(iterator __position, size_type __n, bool __x)
00560     {
00561       if (__n == 0)
00562     return;
00563       if (capacity() - size() >= __n)
00564     {
00565       std::copy_backward(__position, end(),
00566                  this->_M_impl._M_finish + difference_type(__n));
00567       std::fill(__position, __position + difference_type(__n), __x);
00568       this->_M_impl._M_finish += difference_type(__n);
00569     }
00570       else
00571     {
00572       const size_type __len = 
00573         _M_check_len(__n, "vector<bool>::_M_fill_insert");
00574       _Bit_type * __q = this->_M_allocate(__len);
00575       iterator __i = _M_copy_aligned(begin(), __position,
00576                      iterator(__q, 0));
00577       std::fill(__i, __i + difference_type(__n), __x);
00578       this->_M_impl._M_finish = std::copy(__position, end(),
00579                           __i + difference_type(__n));
00580       this->_M_deallocate();
00581       this->_M_impl._M_end_of_storage = (__q + ((__len
00582                              + int(_S_word_bit) - 1)
00583                             / int(_S_word_bit)));
00584       this->_M_impl._M_start = iterator(__q, 0);
00585     }
00586     }
00587 
00588   template<typename _Alloc>
00589     template<typename _ForwardIterator>
00590       void
00591       vector<bool, _Alloc>::
00592       _M_insert_range(iterator __position, _ForwardIterator __first, 
00593               _ForwardIterator __last, std::forward_iterator_tag)
00594       {
00595     if (__first != __last)
00596       {
00597         size_type __n = std::distance(__first, __last);
00598         if (capacity() - size() >= __n)
00599           {
00600         std::copy_backward(__position, end(),
00601                    this->_M_impl._M_finish
00602                    + difference_type(__n));
00603         std::copy(__first, __last, __position);
00604         this->_M_impl._M_finish += difference_type(__n);
00605           }
00606         else
00607           {
00608         const size_type __len =
00609           _M_check_len(__n, "vector<bool>::_M_insert_range");
00610         _Bit_type * __q = this->_M_allocate(__len);
00611         iterator __i = _M_copy_aligned(begin(), __position,
00612                            iterator(__q, 0));
00613         __i = std::copy(__first, __last, __i);
00614         this->_M_impl._M_finish = std::copy(__position, end(), __i);
00615         this->_M_deallocate();
00616         this->_M_impl._M_end_of_storage = (__q
00617                            + ((__len
00618                                + int(_S_word_bit) - 1)
00619                               / int(_S_word_bit)));
00620         this->_M_impl._M_start = iterator(__q, 0);
00621           }
00622       }
00623       }
00624 
00625   template<typename _Alloc>
00626     void
00627     vector<bool, _Alloc>::
00628     _M_insert_aux(iterator __position, bool __x)
00629     {
00630       if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_of_storage)
00631     {
00632       std::copy_backward(__position, this->_M_impl._M_finish, 
00633                  this->_M_impl._M_finish + 1);
00634       *__position = __x;
00635       ++this->_M_impl._M_finish;
00636     }
00637       else
00638     {
00639       const size_type __len =
00640         _M_check_len(size_type(1), "vector<bool>::_M_insert_aux");
00641       _Bit_type * __q = this->_M_allocate(__len);
00642       iterator __i = _M_copy_aligned(begin(), __position,
00643                      iterator(__q, 0));
00644       *__i++ = __x;
00645       this->_M_impl._M_finish = std::copy(__position, end(), __i);
00646       this->_M_deallocate();
00647       this->_M_impl._M_end_of_storage = (__q + ((__len
00648                              + int(_S_word_bit) - 1)
00649                             / int(_S_word_bit)));
00650       this->_M_impl._M_start = iterator(__q, 0);
00651     }
00652     }
00653 
00654 _GLIBCXX_END_NESTED_NAMESPACE
00655 
00656 #endif /* _VECTOR_TCC */

Generated on Wed Mar 26 00:43:33 2008 for libstdc++ by  doxygen 1.5.1