This file is indexed.

/usr/include/dune/grid/test/checkiterators.hh is in libdune-grid-dev 2.5.1-1.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
#ifndef DUNE_GRID_TEST_CHECKITERATORS_HH
#define DUNE_GRID_TEST_CHECKITERATORS_HH

#include <map>

#include <dune/common/forloop.hh>
#include <dune/common/exceptions.hh>
#include <dune/common/test/iteratortest.hh>

#include <dune/grid/common/capabilities.hh>

template<class T>
class NoopFunctor {
public:
  NoopFunctor() {}
  void operator()(const T& t){}
};

// CheckCodimIterators
// -------------------

template< class GridView, int codim,
    bool hasEntity = Dune::Capabilities::hasEntity< typename GridView::Grid, codim >::v >
struct CheckCodimIterators;

template< class GridView, int codim >
struct CheckCodimIterators< GridView, codim, false >
{
  static void apply ( const GridView &gridView )
  {
    std::cerr << "Warning: Not checking iterators for codimension " << codim
              << ", because the corresponding entities are not implemented." << std::endl;
  }
};

template< class GridView, int codim >
struct CheckCodimIterators< GridView, codim, true >
{
  static void apply ( const GridView &gridView );
};


// CheckIterators
// --------------

template< class GridView >
class CheckIterators
{
  template< int codim >
  struct CheckCodim;

public:
  static void apply ( const GridView &gridView )
  {
    std::cout << "Checking iterators for higher codimension..." << std::endl;
    Dune::ForLoop< CheckCodim, 1, GridView::dimension >::apply( gridView );
  }
};


// CheckIterators::CheckCodim
// --------------------------

template< class GridView >
template< int codim >
struct CheckIterators< GridView >::CheckCodim
{
  static void apply ( const GridView &gridView )
  {
    return CheckCodimIterators< GridView, codim >::apply( gridView );
  }
};


// Implementation of CheckCodimIterators
// -------------------------------------

template< class GridView, int codim >
inline void CheckCodimIterators< GridView, codim, true >
::apply ( const GridView &gridView )
{
  typedef typename GridView::Grid::Traits::LocalIdSet LocalIdSet;
  typedef typename LocalIdSet::IdType IdType;

  typedef typename GridView::template Codim< codim >::Iterator CodimIterator;
  typedef typename GridView::template Codim< 0 >::Iterator ElementIterator;

  const LocalIdSet &idSet = gridView.grid().localIdSet();

  std::map< IdType, int > count;
  int size = 0;

  const CodimIterator codimEnd = gridView.template end< codim >();
  for( CodimIterator it = gridView.template begin< codim >(); it != codimEnd; ++it )
  {
    ++count[ idSet.id( *it ) ];
    ++size;
  }

  const ElementIterator elementEnd = gridView.template end< 0 >();
  for( ElementIterator it = gridView.template begin< 0 >(); it != elementEnd; ++it )
  {
    const typename ElementIterator::Entity &entity = *it;
    for( std::size_t i = 0; i < entity.subEntities(codim); ++i )
    {
      IdType id = idSet.subId( entity, i, codim );
      if( count[ id ] != 1 )
      {
        std::cerr << "Error: Codim " << codim << " iterator"
                  << " visited entity " << id
                  << " " << count[ id ] << " times." << std::endl;
        assert( count[ id ] == 1 );
      }
    }
  }

  // check forward iterator semantics
  typedef typename GridView::template Codim<codim>::Entity Entity;
  NoopFunctor<Entity> op;
  if(0 != testForwardIterator(gridView.template begin<codim>(),
                               gridView.template end<codim>(), op))
    DUNE_THROW(Dune::Exception, "Iterator does not fulfill the forward iterator concept");

}



template< class GridView >
inline void checkIterators ( const GridView &gridView )
{
  CheckIterators< GridView >::apply( gridView );
}

#endif // DUNE_GRID_TEST_CHECKITERATORS_HH