LCOV - lcov.info - /usr/include/c++/4.3/bits/stl

From fb21a4dfe2c81640379f64855509fb7613530887 Mon Sep 17 00:00:00 2001 From: Enrico Zini Date: Wed, 9 Sep 2015 22:43:35 +0200 Subject: Removed wrongly added coverage report --- rep/usr/include/c++/4.3/bits/stl_stack.h.gcov.html | 369 --------------------- 1 file changed, 369 deletions(-) delete mode 100644 rep/usr/include/c++/4.3/bits/stl_stack.h.gcov.html (limited to 'rep/usr/include/c++/4.3/bits/stl_stack.h.gcov.html') diff --git a/rep/usr/include/c++/4.3/bits/stl_stack.h.gcov.html b/rep/usr/include/c++/4.3/bits/stl_stack.h.gcov.html deleted file mode 100644 index d033bc3..0000000 --- a/rep/usr/include/c++/4.3/bits/stl_stack.h.gcov.html +++ /dev/null @@ -1,369 +0,0 @@ - - - - - - - LCOV - lcov.info - /usr/include/c++/4.3/bits/stl_stack.h - - - - - - - - - - - - - -
LTP GCOV extension - code coverage report
- - - - - - - - - - - - - - - - - - - - - - - -
Current view:	directory - usr/include/c++/4.3/bits - stl_stack.h
Test:	lcov.info
Date:	2008-08-14	Instrumented lines:	12
Code covered:	100.0 %	Executed lines:	12
- - - - - - - - -
-       1                 : // Stack implementation -*- 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 stl_stack.h
-      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 _STL_STACK_H
-      63                 : #define _STL_STACK_H 1
-      64                 : 
-      65                 : #include <bits/concept_check.h>
-      66                 : #include <debug/debug.h>
-      67                 : 
-      68                 : _GLIBCXX_BEGIN_NAMESPACE(std)
-      69                 : 
-      70                 :   /**
-      71                 :    *  @brief  A standard container giving FILO behavior.
-      72                 :    *
-      73                 :    *  @ingroup Containers
-      74                 :    *  @ingroup Sequences
-      75                 :    *
-      76                 :    *  Meets many of the requirements of a
-      77                 :    *  <a href="tables.html#65">container</a>,
-      78                 :    *  but does not define anything to do with iterators.  Very few of the
-      79                 :    *  other standard container interfaces are defined.
-      80                 :    *
-      81                 :    *  This is not a true container, but an @e adaptor.  It holds
-      82                 :    *  another container, and provides a wrapper interface to that
-      83                 :    *  container.  The wrapper is what enforces strict
-      84                 :    *  first-in-last-out %stack behavior.
-      85                 :    *
-      86                 :    *  The second template parameter defines the type of the underlying
-      87                 :    *  sequence/container.  It defaults to std::deque, but it can be
-      88                 :    *  any type that supports @c back, @c push_back, and @c pop_front,
-      89                 :    *  such as std::list, std::vector, or an appropriate user-defined
-      90                 :    *  type.
-      91                 :    *
-      92                 :    *  Members not found in "normal" containers are @c container_type,
-      93                 :    *  which is a typedef for the second Sequence parameter, and @c
-      94                 :    *  push, @c pop, and @c top, which are standard %stack/FILO
-      95                 :    *  operations.
-      96                 :   */
-      97                 :   template<typename _Tp, typename _Sequence = deque<_Tp> >
-      98                 :     class stack
-      99              13 :     {
-     100                 :       // concept requirements
-     101                 :       typedef typename _Sequence::value_type _Sequence_value_type;
-     102                 :       __glibcxx_class_requires(_Tp, _SGIAssignableConcept)
-     103                 :       __glibcxx_class_requires(_Sequence, _BackInsertionSequenceConcept)
-     104                 :       __glibcxx_class_requires2(_Tp, _Sequence_value_type, _SameTypeConcept)
-     105                 : 
-     106                 :       template<typename _Tp1, typename _Seq1>
-     107                 :         friend bool
-     108                 :         operator==(const stack<_Tp1, _Seq1>&, const stack<_Tp1, _Seq1>&);
-     109                 : 
-     110                 :       template<typename _Tp1, typename _Seq1>
-     111                 :         friend bool
-     112                 :         operator<(const stack<_Tp1, _Seq1>&, const stack<_Tp1, _Seq1>&);
-     113                 : 
-     114                 :     public:
-     115                 :       typedef typename _Sequence::value_type                value_type;
-     116                 :       typedef typename _Sequence::reference                 reference;
-     117                 :       typedef typename _Sequence::const_reference           const_reference;
-     118                 :       typedef typename _Sequence::size_type                 size_type;
-     119                 :       typedef          _Sequence                            container_type;
-     120                 : 
-     121                 :     protected:
-     122                 :       //  See queue::c for notes on this name.
-     123                 :       _Sequence c;
-     124                 : 
-     125                 :     public:
-     126                 :       // XXX removed old def ctor, added def arg to this one to match 14882
-     127                 :       /**
-     128                 :        *  @brief  Default constructor creates no elements.
-     129                 :        */
-     130                 : #ifndef __GXX_EXPERIMENTAL_CXX0X__
-     131                 :       explicit
-     132              13 :       stack(const _Sequence& __c = _Sequence())
-     133              13 :       : c(__c) { }
-     134                 : #else
-     135                 :       explicit
-     136                 :       stack(const _Sequence& __c)
-     137                 :       : c(__c) { }
-     138                 : 
-     139                 :       explicit
-     140                 :       stack(_Sequence&& __c = _Sequence())
-     141                 :       : c(std::move(__c)) { }
-     142                 : #endif
-     143                 : 
-     144                 :       /**
-     145                 :        *  Returns true if the %stack is empty.
-     146                 :        */
-     147                 :       bool
-     148              32 :       empty() const
-     149              32 :       { return c.empty(); }
-     150                 : 
-     151                 :       /**  Returns the number of elements in the %stack.  */
-     152                 :       size_type
-     153                 :       size() const
-     154                 :       { return c.size(); }
-     155                 : 
-     156                 :       /**
-     157                 :        *  Returns a read/write reference to the data at the first
-     158                 :        *  element of the %stack.
-     159                 :        */
-     160                 :       reference
-     161              39 :       top()
-     162                 :       {
-     163                 :         __glibcxx_requires_nonempty();
-     164              39 :         return c.back();
-     165                 :       }
-     166                 : 
-     167                 :       /**
-     168                 :        *  Returns a read-only (constant) reference to the data at the first
-     169                 :        *  element of the %stack.
-     170                 :        */
-     171                 :       const_reference
-     172                 :       top() const
-     173                 :       {
-     174                 :         __glibcxx_requires_nonempty();
-     175                 :         return c.back();
-     176                 :       }
-     177                 : 
-     178                 :       /**
-     179                 :        *  @brief  Add data to the top of the %stack.
-     180                 :        *  @param  x  Data to be added.
-     181                 :        *
-     182                 :        *  This is a typical %stack operation.  The function creates an
-     183                 :        *  element at the top of the %stack and assigns the given data
-     184                 :        *  to it.  The time complexity of the operation depends on the
-     185                 :        *  underlying sequence.
-     186                 :        */
-     187                 : #ifndef __GXX_EXPERIMENTAL_CXX0X__
-     188                 :       void
-     189              24 :       push(const value_type& __x)
-     190              24 :       { c.push_back(__x); }
-     191                 : #else
-     192                 :       // NB: DR 756.
-     193                 :       template<typename... _Args>
-     194                 :         void
-     195                 :         push(_Args&&... __args)
-     196                 :         { c.push_back(std::forward<_Args>(__args)...); }
-     197                 : #endif
-     198                 : 
-     199                 :       /**
-     200                 :        *  @brief  Removes first element.
-     201                 :        *
-     202                 :        *  This is a typical %stack operation.  It shrinks the %stack
-     203                 :        *  by one.  The time complexity of the operation depends on the
-     204                 :        *  underlying sequence.
-     205                 :        *
-     206                 :        *  Note that no data is returned, and if the first element's
-     207                 :        *  data is needed, it should be retrieved before pop() is
-     208                 :        *  called.
-     209                 :        */
-     210                 :       void
-     211              24 :       pop()
-     212                 :       {
-     213                 :         __glibcxx_requires_nonempty();
-     214              24 :         c.pop_back();
-     215              24 :       }
-     216                 : 
-     217                 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
-     218                 :       void
-     219                 :       swap(stack&& __s)
-     220                 :       { c.swap(__s.c); }
-     221                 : #endif
-     222                 :     };
-     223                 : 
-     224                 :   /**
-     225                 :    *  @brief  Stack equality comparison.
-     226                 :    *  @param  x  A %stack.
-     227                 :    *  @param  y  A %stack of the same type as @a x.
-     228                 :    *  @return  True iff the size and elements of the stacks are equal.
-     229                 :    *
-     230                 :    *  This is an equivalence relation.  Complexity and semantics
-     231                 :    *  depend on the underlying sequence type, but the expected rules
-     232                 :    *  are: this relation is linear in the size of the sequences, and
-     233                 :    *  stacks are considered equivalent if their sequences compare
-     234                 :    *  equal.
-     235                 :   */
-     236                 :   template<typename _Tp, typename _Seq>
-     237                 :     inline bool
-     238                 :     operator==(const stack<_Tp, _Seq>& __x, const stack<_Tp, _Seq>& __y)
-     239                 :     { return __x.c == __y.c; }
-     240                 : 
-     241                 :   /**
-     242                 :    *  @brief  Stack ordering relation.
-     243                 :    *  @param  x  A %stack.
-     244                 :    *  @param  y  A %stack of the same type as @a x.
-     245                 :    *  @return  True iff @a x is lexicographically less than @a y.
-     246                 :    *
-     247                 :    *  This is an total ordering relation.  Complexity and semantics
-     248                 :    *  depend on the underlying sequence type, but the expected rules
-     249                 :    *  are: this relation is linear in the size of the sequences, the
-     250                 :    *  elements must be comparable with @c <, and
-     251                 :    *  std::lexicographical_compare() is usually used to make the
-     252                 :    *  determination.
-     253                 :   */
-     254                 :   template<typename _Tp, typename _Seq>
-     255                 :     inline bool
-     256                 :     operator<(const stack<_Tp, _Seq>& __x, const stack<_Tp, _Seq>& __y)
-     257                 :     { return __x.c < __y.c; }
-     258                 : 
-     259                 :   /// Based on operator==
-     260                 :   template<typename _Tp, typename _Seq>
-     261                 :     inline bool
-     262                 :     operator!=(const stack<_Tp, _Seq>& __x, const stack<_Tp, _Seq>& __y)
-     263                 :     { return !(__x == __y); }
-     264                 : 
-     265                 :   /// Based on operator<
-     266                 :   template<typename _Tp, typename _Seq>
-     267                 :     inline bool
-     268                 :     operator>(const stack<_Tp, _Seq>& __x, const stack<_Tp, _Seq>& __y)
-     269                 :     { return __y < __x; }
-     270                 : 
-     271                 :   /// Based on operator<
-     272                 :   template<typename _Tp, typename _Seq>
-     273                 :     inline bool
-     274                 :     operator<=(const stack<_Tp, _Seq>& __x, const stack<_Tp, _Seq>& __y)
-     275                 :     { return !(__y < __x); }
-     276                 : 
-     277                 :   /// Based on operator<
-     278                 :   template<typename _Tp, typename _Seq>
-     279                 :     inline bool
-     280                 :     operator>=(const stack<_Tp, _Seq>& __x, const stack<_Tp, _Seq>& __y)
-     281                 :     { return !(__x < __y); }
-     282                 : 
-     283                 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
-     284                 :   template<typename _Tp, typename _Seq>
-     285                 :     inline void
-     286                 :     swap(stack<_Tp, _Seq>& __x, stack<_Tp, _Seq>& __y)
-     287                 :     { __x.swap(__y); }
-     288                 : 
-     289                 :   template<typename _Tp, typename _Seq>
-     290                 :     inline void
-     291                 :     swap(stack<_Tp, _Seq>&& __x, stack<_Tp, _Seq>& __y)
-     292                 :     { __x.swap(__y); }
-     293                 : 
-     294                 :   template<typename _Tp, typename _Seq>
-     295                 :     inline void
-     296                 :     swap(stack<_Tp, _Seq>& __x, stack<_Tp, _Seq>&& __y)
-     297                 :     { __x.swap(__y); }
-     298                 : #endif
-     299                 : 
-     300                 : _GLIBCXX_END_NAMESPACE
-     301                 : 
-     302                 : #endif /* _STL_STACK_H */
-
-
- - - - -
Generated by: LTP GCOV extension version 1.6
-
- - - -- cgit v1.2.3