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

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

           1                 : // Types used in iterator implementation -*- C++ -*-
           2                 :
           3                 : // Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
           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-1998
          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_iterator_base_types.h
          58                 :  *  This is an internal header file, included by other library headers.
          59                 :  *  You should not attempt to use it directly.
          60                 :  *
          61                 :  *  This file contains all of the general iterator-related utility types,
          62                 :  *  such as iterator_traits and struct iterator.
          63                 :  */
          64                 :
          65                 : #ifndef _STL_ITERATOR_BASE_TYPES_H
          66                 : #define _STL_ITERATOR_BASE_TYPES_H 1
          67                 :
          68                 : #pragma GCC system_header
          69                 :
          70                 : #include <bits/c++config.h>
          71                 : #include <cstddef>
          72                 :
          73                 : _GLIBCXX_BEGIN_NAMESPACE(std)
          74                 :
          75                 :   //@{
          76                 :   /**
          77                 :    *  @defgroup iterator_tags Iterator Tags
          78                 :    *  These are empty types, used to distinguish different iterators.  The
          79                 :    *  distinction is not made by what they contain, but simply by what they
          80                 :    *  are.  Different underlying algorithms can then be used based on the
          81                 :    *  different operations supported by different iterator types.
          82                 :   */
          83                 :   ///  Marking input iterators.
          84                 :   struct input_iterator_tag {};
          85                 :   ///  Marking output iterators.
          86                 :   struct output_iterator_tag {};
          87                 :   /// Forward iterators support a superset of input iterator operations.
          88                 :   struct forward_iterator_tag : public input_iterator_tag {};
          89                 :   /// Bidirectional iterators support a superset of forward iterator
          90                 :   /// operations.
          91                 :   struct bidirectional_iterator_tag : public forward_iterator_tag {};
          92                 :   /// Random-access iterators support a superset of bidirectional iterator
          93                 :   /// operations.
          94                 :   struct random_access_iterator_tag : public bidirectional_iterator_tag {};
          95                 :   //@}
          96                 :
          97                 :
          98                 :   /**
          99                 :    *  @brief  Common %iterator class.
         100                 :    *
         101                 :    *  This class does nothing but define nested typedefs.  %Iterator classes
         102                 :    *  can inherit from this class to save some work.  The typedefs are then
         103                 :    *  used in specializations and overloading.
         104                 :    *
         105                 :    *  In particular, there are no default implementations of requirements
         106                 :    *  such as @c operator++ and the like.  (How could there be?)
         107                 :   */
         108                 :   template<typename _Category, typename _Tp, typename _Distance = ptrdiff_t,
         109                 :            typename _Pointer = _Tp*, typename _Reference = _Tp&>
         110                 :     struct iterator
         111          304336 :     {
         112                 :       /// One of the @link iterator_tags tag types@endlink.
         113                 :       typedef _Category  iterator_category;
         114                 :       /// The type "pointed to" by the iterator.
         115                 :       typedef _Tp        value_type;
         116                 :       /// Distance between iterators is represented as this type.
         117                 :       typedef _Distance  difference_type;
         118                 :       /// This type represents a pointer-to-value_type.
         119                 :       typedef _Pointer   pointer;
         120                 :       /// This type represents a reference-to-value_type.
         121                 :       typedef _Reference reference;
         122                 :     };
         123                 :
         124                 :   /**
         125                 :    *  This class does nothing but define nested typedefs.  The general
         126                 :    *  version simply "forwards" the nested typedefs from the Iterator
         127                 :    *  argument.  Specialized versions for pointers and pointers-to-const
         128                 :    *  provide tighter, more correct semantics.
         129                 :   */
         130                 :   template<typename _Iterator>
         131                 :     struct iterator_traits
         132                 :     {
         133                 :       typedef typename _Iterator::iterator_category iterator_category;
         134                 :       typedef typename _Iterator::value_type        value_type;
         135                 :       typedef typename _Iterator::difference_type   difference_type;
         136                 :       typedef typename _Iterator::pointer           pointer;
         137                 :       typedef typename _Iterator::reference         reference;
         138                 :     };
         139                 :
         140                 :   template<typename _Tp>
         141                 :     struct iterator_traits<_Tp*>
         142                 :     {
         143                 :       typedef random_access_iterator_tag iterator_category;
         144                 :       typedef _Tp                         value_type;
         145                 :       typedef ptrdiff_t                   difference_type;
         146                 :       typedef _Tp*                        pointer;
         147                 :       typedef _Tp&                        reference;
         148                 :     };
         149                 :
         150                 :   template<typename _Tp>
         151                 :     struct iterator_traits<const _Tp*>
         152                 :     {
         153                 :       typedef random_access_iterator_tag iterator_category;
         154                 :       typedef _Tp                         value_type;
         155                 :       typedef ptrdiff_t                   difference_type;
         156                 :       typedef const _Tp*                  pointer;
         157                 :       typedef const _Tp&                  reference;
         158                 :     };
         159                 :
         160                 :   /**
         161                 :    *  This function is not a part of the C++ standard but is syntactic
         162                 :    *  sugar for internal library use only.
         163                 :   */
         164                 :   template<typename _Iter>
         165                 :     inline typename iterator_traits<_Iter>::iterator_category
         166            4730 :     __iterator_category(const _Iter&)
         167            4730 :     { return typename iterator_traits<_Iter>::iterator_category(); }
         168                 :
         169                 : _GLIBCXX_END_NAMESPACE
         170                 :
         171                 : #endif /* _STL_ITERATOR_BASE_TYPES_H */
         172                 :

Generated by: LTP GCOV extension version 1.6