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

       1                 : // List 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) 1996,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 list.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 _LIST_TCC
      63                 : #define _LIST_TCC 1
      64                 : 
      65                 : _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D)
      66                 : 
      67                 :   template<typename _Tp, typename _Alloc>
      68                 :     void
      69                 :     _List_base<_Tp, _Alloc>::
      70              19 :     _M_clear()
      71                 :     {
      72                 :       typedef _List_node<_Tp>  _Node;
      73              19 :       _Node* __cur = static_cast<_Node*>(this->_M_impl._M_node._M_next);
      74              60 :       while (__cur != &this->_M_impl._M_node)
      75                 :         {
      76              22 :           _Node* __tmp = __cur;
      77              22 :           __cur = static_cast<_Node*>(__cur->_M_next);
      78              22 :           _M_get_Tp_allocator().destroy(&__tmp->_M_data);
      79              22 :           _M_put_node(__tmp);
      80                 :         }
      81              19 :     }
      82                 : 
      83                 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
      84                 :   template<typename _Tp, typename _Alloc>
      85                 :     template<typename... _Args>
      86                 :       typename list<_Tp, _Alloc>::iterator
      87                 :       list<_Tp, _Alloc>::
      88                 :       emplace(iterator __position, _Args&&... __args)
      89                 :       {
      90                 :         _Node* __tmp = _M_create_node(std::forward<_Args>(__args)...);
      91                 :         __tmp->hook(__position._M_node);
      92                 :         return iterator(__tmp);
      93                 :       }
      94                 : #endif
      95                 : 
      96                 :   template<typename _Tp, typename _Alloc>
      97                 :     typename list<_Tp, _Alloc>::iterator
      98                 :     list<_Tp, _Alloc>::
      99                 :     insert(iterator __position, const value_type& __x)
     100                 :     {
     101                 :       _Node* __tmp = _M_create_node(__x);
     102                 :       __tmp->hook(__position._M_node);
     103                 :       return iterator(__tmp);
     104                 :     }
     105                 : 
     106                 :   template<typename _Tp, typename _Alloc>
     107                 :     typename list<_Tp, _Alloc>::iterator
     108                 :     list<_Tp, _Alloc>::
     109              25 :     erase(iterator __position)
     110                 :     {
     111              25 :       iterator __ret = iterator(__position._M_node->_M_next);
     112              25 :       _M_erase(__position);
     113                 :       return __ret;
     114                 :     }
     115                 : 
     116                 :   template<typename _Tp, typename _Alloc>
     117                 :     void
     118                 :     list<_Tp, _Alloc>::
     119                 :     resize(size_type __new_size, value_type __x)
     120                 :     {
     121                 :       iterator __i = begin();
     122                 :       size_type __len = 0;
     123                 :       for (; __i != end() && __len < __new_size; ++__i, ++__len)
     124                 :         ;
     125                 :       if (__len == __new_size)
     126                 :         erase(__i, end());
     127                 :       else                          // __i == end()
     128                 :         insert(end(), __new_size - __len, __x);
     129                 :     }
     130                 : 
     131                 :   template<typename _Tp, typename _Alloc>
     132                 :     list<_Tp, _Alloc>&
     133                 :     list<_Tp, _Alloc>::
     134                 :     operator=(const list& __x)
     135                 :     {
     136                 :       if (this != &__x)
     137                 :         {
     138                 :           iterator __first1 = begin();
     139                 :           iterator __last1 = end();
     140                 :           const_iterator __first2 = __x.begin();
     141                 :           const_iterator __last2 = __x.end();
     142                 :           for (; __first1 != __last1 && __first2 != __last2;
     143                 :                ++__first1, ++__first2)
     144                 :             *__first1 = *__first2;
     145                 :           if (__first2 == __last2)
     146                 :             erase(__first1, __last1);
     147                 :           else
     148                 :             insert(__last1, __first2, __last2);
     149                 :         }
     150                 :       return *this;
     151                 :     }
     152                 : 
     153                 :   template<typename _Tp, typename _Alloc>
     154                 :     void
     155                 :     list<_Tp, _Alloc>::
     156                 :     _M_fill_assign(size_type __n, const value_type& __val)
     157                 :     {
     158                 :       iterator __i = begin();
     159                 :       for (; __i != end() && __n > 0; ++__i, --__n)
     160                 :         *__i = __val;
     161                 :       if (__n > 0)
     162                 :         insert(end(), __n, __val);
     163                 :       else
     164                 :         erase(__i, end());
     165                 :     }
     166                 : 
     167                 :   template<typename _Tp, typename _Alloc>
     168                 :     template <typename _InputIterator>
     169                 :       void
     170                 :       list<_Tp, _Alloc>::
     171                 :       _M_assign_dispatch(_InputIterator __first2, _InputIterator __last2,
     172                 :                          __false_type)
     173                 :       {
     174                 :         iterator __first1 = begin();
     175                 :         iterator __last1 = end();
     176                 :         for (; __first1 != __last1 && __first2 != __last2;
     177                 :              ++__first1, ++__first2)
     178                 :           *__first1 = *__first2;
     179                 :         if (__first2 == __last2)
     180                 :           erase(__first1, __last1);
     181                 :         else
     182                 :           insert(__last1, __first2, __last2);
     183                 :       }
     184                 : 
     185                 :   template<typename _Tp, typename _Alloc>
     186                 :     void
     187                 :     list<_Tp, _Alloc>::
     188                 :     remove(const value_type& __value)
     189                 :     {
     190                 :       iterator __first = begin();
     191                 :       iterator __last = end();
     192                 :       iterator __extra = __last;
     193                 :       while (__first != __last)
     194                 :         {
     195                 :           iterator __next = __first;
     196                 :           ++__next;
     197                 :           if (*__first == __value)
     198                 :             {
     199                 :               // _GLIBCXX_RESOLVE_LIB_DEFECTS
     200                 :               // 526. Is it undefined if a function in the standard changes
     201                 :               // in parameters?
     202                 :               if (&*__first != &__value)
     203                 :                 _M_erase(__first);
     204                 :               else
     205                 :                 __extra = __first;
     206                 :             }
     207                 :           __first = __next;
     208                 :         }
     209                 :       if (__extra != __last)
     210                 :         _M_erase(__extra);
     211                 :     }
     212                 : 
     213                 :   template<typename _Tp, typename _Alloc>
     214                 :     void
     215                 :     list<_Tp, _Alloc>::
     216                 :     unique()
     217                 :     {
     218                 :       iterator __first = begin();
     219                 :       iterator __last = end();
     220                 :       if (__first == __last)
     221                 :         return;
     222                 :       iterator __next = __first;
     223                 :       while (++__next != __last)
     224                 :         {
     225                 :           if (*__first == *__next)
     226                 :             _M_erase(__next);
     227                 :           else
     228                 :             __first = __next;
     229                 :           __next = __first;
     230                 :         }
     231                 :     }
     232                 : 
     233                 :   template<typename _Tp, typename _Alloc>
     234                 :     void
     235                 :     list<_Tp, _Alloc>::
     236                 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
     237                 :     merge(list&& __x)
     238                 : #else
     239                 :     merge(list& __x)
     240                 : #endif
     241                 :     {
     242                 :       // _GLIBCXX_RESOLVE_LIB_DEFECTS
     243                 :       // 300. list::merge() specification incomplete
     244                 :       if (this != &__x)
     245                 :         {
     246                 :           _M_check_equal_allocators(__x); 
     247                 : 
     248                 :           iterator __first1 = begin();
     249                 :           iterator __last1 = end();
     250                 :           iterator __first2 = __x.begin();
     251                 :           iterator __last2 = __x.end();
     252                 :           while (__first1 != __last1 && __first2 != __last2)
     253                 :             if (*__first2 < *__first1)
     254                 :               {
     255                 :                 iterator __next = __first2;
     256                 :                 _M_transfer(__first1, __first2, ++__next);
     257                 :                 __first2 = __next;
     258                 :               }
     259                 :             else
     260                 :               ++__first1;
     261                 :           if (__first2 != __last2)
     262                 :             _M_transfer(__last1, __first2, __last2);
     263                 :         }
     264                 :     }
     265                 : 
     266                 :   template<typename _Tp, typename _Alloc>
     267                 :     template <typename _StrictWeakOrdering>
     268                 :       void
     269                 :       list<_Tp, _Alloc>::
     270                 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
     271                 :       merge(list&& __x, _StrictWeakOrdering __comp)
     272                 : #else
     273                 :       merge(list& __x, _StrictWeakOrdering __comp)
     274                 : #endif
     275                 :       {
     276                 :         // _GLIBCXX_RESOLVE_LIB_DEFECTS
     277                 :         // 300. list::merge() specification incomplete
     278                 :         if (this != &__x)
     279                 :           {
     280                 :             _M_check_equal_allocators(__x);
     281                 : 
     282                 :             iterator __first1 = begin();
     283                 :             iterator __last1 = end();
     284                 :             iterator __first2 = __x.begin();
     285                 :             iterator __last2 = __x.end();
     286                 :             while (__first1 != __last1 && __first2 != __last2)
     287                 :               if (__comp(*__first2, *__first1))
     288                 :                 {
     289                 :                   iterator __next = __first2;
     290                 :                   _M_transfer(__first1, __first2, ++__next);
     291                 :                   __first2 = __next;
     292                 :                 }
     293                 :               else
     294                 :                 ++__first1;
     295                 :             if (__first2 != __last2)
     296                 :               _M_transfer(__last1, __first2, __last2);
     297                 :           }
     298                 :       }
     299                 : 
     300                 :   template<typename _Tp, typename _Alloc>
     301                 :     void
     302                 :     list<_Tp, _Alloc>::
     303                 :     sort()
     304                 :     {
     305                 :       // Do nothing if the list has length 0 or 1.
     306                 :       if (this->_M_impl._M_node._M_next != &this->_M_impl._M_node
     307                 :           && this->_M_impl._M_node._M_next->_M_next != &this->_M_impl._M_node)
     308                 :       {
     309                 :         list __carry;
     310                 :         list __tmp[64];
     311                 :         list * __fill = &__tmp[0];
     312                 :         list * __counter;
     313                 : 
     314                 :         do
     315                 :           {
     316                 :             __carry.splice(__carry.begin(), *this, begin());
     317                 : 
     318                 :             for(__counter = &__tmp[0];
     319                 :                 __counter != __fill && !__counter->empty();
     320                 :                 ++__counter)
     321                 :               {
     322                 :                 __counter->merge(__carry);
     323                 :                 __carry.swap(*__counter);
     324                 :               }
     325                 :             __carry.swap(*__counter);
     326                 :             if (__counter == __fill)
     327                 :               ++__fill;
     328                 :           }
     329                 :         while ( !empty() );
     330                 : 
     331                 :         for (__counter = &__tmp[1]; __counter != __fill; ++__counter)
     332                 :           __counter->merge(*(__counter - 1));
     333                 :         swap( *(__fill - 1) );
     334                 :       }
     335                 :     }
     336                 : 
     337                 :   template<typename _Tp, typename _Alloc>
     338                 :     template <typename _Predicate>
     339                 :       void
     340                 :       list<_Tp, _Alloc>::
     341                 :       remove_if(_Predicate __pred)
     342                 :       {
     343                 :         iterator __first = begin();
     344                 :         iterator __last = end();
     345                 :         while (__first != __last)
     346                 :           {
     347                 :             iterator __next = __first;
     348                 :             ++__next;
     349                 :             if (__pred(*__first))
     350                 :               _M_erase(__first);
     351                 :             __first = __next;
     352                 :           }
     353                 :       }
     354                 : 
     355                 :   template<typename _Tp, typename _Alloc>
     356                 :     template <typename _BinaryPredicate>
     357                 :       void
     358                 :       list<_Tp, _Alloc>::
     359                 :       unique(_BinaryPredicate __binary_pred)
     360                 :       {
     361                 :         iterator __first = begin();
     362                 :         iterator __last = end();
     363                 :         if (__first == __last)
     364                 :           return;
     365                 :         iterator __next = __first;
     366                 :         while (++__next != __last)
     367                 :           {
     368                 :             if (__binary_pred(*__first, *__next))
     369                 :               _M_erase(__next);
     370                 :             else
     371                 :               __first = __next;
     372                 :             __next = __first;
     373                 :           }
     374                 :       }
     375                 : 
     376                 :   template<typename _Tp, typename _Alloc>
     377                 :     template <typename _StrictWeakOrdering>
     378                 :       void
     379                 :       list<_Tp, _Alloc>::
     380                 :       sort(_StrictWeakOrdering __comp)
     381                 :       {
     382                 :         // Do nothing if the list has length 0 or 1.
     383                 :         if (this->_M_impl._M_node._M_next != &this->_M_impl._M_node
     384                 :             && this->_M_impl._M_node._M_next->_M_next != &this->_M_impl._M_node)
     385                 :           {
     386                 :             list __carry;
     387                 :             list __tmp[64];
     388                 :             list * __fill = &__tmp[0];
     389                 :             list * __counter;
     390                 : 
     391                 :             do
     392                 :               {
     393                 :                 __carry.splice(__carry.begin(), *this, begin());
     394                 : 
     395                 :                 for(__counter = &__tmp[0];
     396                 :                     __counter != __fill && !__counter->empty();
     397                 :                     ++__counter)
     398                 :                   {
     399                 :                     __counter->merge(__carry, __comp);
     400                 :                     __carry.swap(*__counter);
     401                 :                   }
     402                 :                 __carry.swap(*__counter);
     403                 :                 if (__counter == __fill)
     404                 :                   ++__fill;
     405                 :               }
     406                 :             while ( !empty() );
     407                 : 
     408                 :             for (__counter = &__tmp[1]; __counter != __fill; ++__counter)
     409                 :               __counter->merge(*(__counter - 1), __comp);
     410                 :             swap(*(__fill - 1));
     411                 :           }
     412                 :       }
     413                 : 
     414                 : _GLIBCXX_END_NESTED_NAMESPACE
     415                 : 
     416                 : #endif /* _LIST_TCC */
     417                 : 

Generated by: LTP GCOV extension version 1.6