This file is indexed.

/usr/include/rheolef/space_component.h is in librheolef-dev 6.6-1build2.

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
#ifndef _RHEOLEF_SPACE_COMPONENT_H
#define _RHEOLEF_SPACE_COMPONENT_H
///
/// This file is part of Rheolef.
///
/// Copyright (C) 2000-2009 Pierre Saramito <Pierre.Saramito@imag.fr>
///
/// Rheolef is free software; you can redistribute it and/or modify
/// it under the terms of the GNU General Public License as published by
/// the Free Software Foundation; either version 2 of the License, or
/// (at your option) any later version.
///
/// Rheolef is distributed in the hope that it will be useful,
/// but WITHOUT ANY WARRANTY; without even the implied warranty of
/// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
/// GNU General Public License for more details.
///
/// You should have received a copy of the GNU General Public License
/// along with Rheolef; if not, write to the Free Software
/// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
///
/// =========================================================================

#include "rheolef/space.h"

namespace rheolef {

template<class T, class M>
class space_component {
public:

  typedef typename space_basic<T,M>::size_type size_type;

// allocators:

  explicit space_component (space_constitution<T,M>& sc)
    : _constit(sc) {}
  space_component (const space_component<T,M>& x) 
    : _constit(x._constit) {}

// implicit conversion to space:

  operator space_basic<T,M>() const { return space_basic<T,M>(_constit); }

// accessor:

  space_component<T,M> operator[] (size_type i_comp) const {
	space_component<T,M> sub (_constit [i_comp]);
        return sub;
  }

// modifier:

  void block (std::string dom_name) {
	_constit.do_act (space_act(dom_name, space_act::block));
  }
  void block (const domain_indirect_basic<M>& dom) {
	_constit.do_act (space_act(dom.name(), space_act::block));
  }

protected:
// data:
   space_constitution<T,M>& _constit; // non-const reference: block() modify the _constit
};
// ===========================================================================
// const version
// ===========================================================================
template<class T, class M>
class space_component_const {
public:

  typedef typename space_basic<T,M>::size_type size_type;

// allocators:

  explicit space_component_const (const space_constitution<T,M>& sc)
    : _constit(sc) {}
  space_component_const (const space_component_const<T,M>& x) 
    : _constit(x._constit) {}
  space_component_const (const space_component<T,M>& x) 
    : _constit(x._constit) {}

// implicit conversion to space:

  operator space_basic<T,M>() const { return space_basic<T,M>(_constit); }

// accessor:

#ifdef TODO
  space_component_const<T,M> operator[] (size_type i_comp) const {
	space_component_const<T,M> sub (_constit [i_comp]);
        return sub;
  }
#endif // TODO

protected:
// data:
   const space_constitution<T,M>& _constit;
};
// ========================================
// inlined
// ========================================
template <class T, class M>
inline
space_component<T,M>
space_base_rep<T,M>::operator[] (size_type i_comp) 
{
  return space_component<T,M> (_constit [i_comp]);
}
template <class T, class M>
inline
space_component_const<T,M>
space_base_rep<T,M>::operator[] (size_type i_comp) const
{
  return space_component_const<T,M> (_constit [i_comp]);
}

} // namespace rheolef
#endif // _RHEOLEF_SPACE_COMPONENT_H