libdune-common-dev 2.2.1-2 / usr / include / dune / common / forloop.hh

This file is indexed.

/usr/include/dune/common/forloop.hh is in libdune-common-dev 2.2.1-2.

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
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
// -*- tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set ts=8 sw=2 et sts=2:

#ifndef DUNE_COMMON_FORLOOP_HH
#define DUNE_COMMON_FORLOOP_HH

/** \file
 * \brief A static for loop for template meta-programming
 */

#include <dune/common/static_assert.hh>

namespace Dune
{

  // GenericForLoop
  // --------------

  template< template< class, class > class Operation, template< int > class Value, int first, int last >
  class GenericForLoop
  : public Operation< Value< first >, GenericForLoop< Operation, Value, first+1, last > >
  {
    dune_static_assert( (first <= last), "GenericForLoop: first > last" );
  };

  template< template< class, class > class Operation, template< int > class Value, int last >
  class GenericForLoop< Operation, Value, last, last >
  : public Value< last >
  {};



  // ForLoopHelper
  // -------------

  namespace ForLoopHelper
  {

    template< class A, class B >
    struct Apply
    {
      static void apply ()
      {
        A::apply();
        B::apply();
      }

      template< class T1 >
      static void apply ( T1 &p1 )
      {
        A::apply( p1 );
        B::apply( p1 );
      }

      template< class T1, class T2 >
      static void apply ( T1 &p1, T2 &p2 )
      {
        A::apply( p1, p2 );
        B::apply( p1, p2 );
      }

      template< class T1, class T2, class T3 >
      static void apply ( T1 &p1, T2 &p2, T3 &p3 )
      {
        A::apply( p1, p2, p3 );
        B::apply( p1, p2, p3 );
      }

      template< class T1, class T2, class T3, class T4 >
      static void apply ( T1 &p1, T2 &p2, T3 &p3, T4 &p4 )
      {
        A::apply( p1, p2, p3, p4 );
        B::apply( p1, p2, p3, p4 );
      }

      template< class T1, class T2, class T3, class T4, class T5 >
      static void apply ( T1 &p1, T2 &p2, T3 &p3, T4 &p4, T5 &p5 )
      {
        A::apply( p1, p2, p3, p4, p5 );
        B::apply( p1, p2, p3, p4, p5 );
      }

      template< class T1, class T2, class T3, class T4, class T5, class T6 >
      static void apply ( T1 &p1, T2 &p2, T3 &p3, T4 &p4, T5 &p5, T6 &p6 )
      {
        A::apply( p1, p2, p3, p4, p5, p6 );
        B::apply( p1, p2, p3, p4, p5, p6 );
      }

      template< class T1, class T2, class T3, class T4, class T5, class T6,
                class T7 >
      static void apply ( T1 &p1, T2 &p2, T3 &p3, T4 &p4, T5 &p5, T6 &p6,
                          T7 &p7 )
      {
        A::apply( p1, p2, p3, p4, p5, p6, p7 );
        B::apply( p1, p2, p3, p4, p5, p6, p7 );
      }

      template< class T1, class T2, class T3, class T4, class T5, class T6,
                class T7, class T8 >
      static void apply ( T1 &p1, T2 &p2, T3 &p3, T4 &p4, T5 &p5, T6 &p6,
                          T7 &p7, T8 &p8 )
      {
        A::apply( p1, p2, p3, p4, p5, p6, p7, p8 );
        B::apply( p1, p2, p3, p4, p5, p6, p7, p8 );
      }

      template< class T1, class T2, class T3, class T4, class T5, class T6,
                class T7, class T8, class T9 >
      static void apply ( T1 &p1, T2 &p2, T3 &p3, T4 &p4, T5 &p5, T6 &p6,
                          T7 &p7, T8 &p8, T9 &p9 )
      {
        A::apply( p1, p2, p3, p4, p5, p6, p7, p8, p9 );
        B::apply( p1, p2, p3, p4, p5, p6, p7, p8, p9 );
      }

      template< class T1, class T2, class T3, class T4, class T5, class T6,
                class T7, class T8, class T9, class T10 >
      static void apply ( T1 &p1, T2 &p2, T3 &p3, T4 &p4, T5 &p5, T6 &p6,
                          T7 &p7, T8 &p8, T9 &p9, T10 &p10 )
      {
        A::apply( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10 );
        B::apply( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10 );
      }

      template< class T1, class T2, class T3, class T4, class T5, class T6,
                class T7, class T8, class T9, class T10, class T11 >
      static void apply ( T1 &p1, T2 &p2, T3 &p3, T4 &p4, T5 &p5, T6 &p6,
                          T7 &p7, T8 &p8, T9 &p9, T10 &p10, T11 &p11 )
      {
        A::apply( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11 );
        B::apply( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11 );
      }

      template< class T1, class T2, class T3, class T4, class T5, class T6,
                class T7, class T8, class T9, class T10, class T11, class T12 >
      static void apply ( T1 &p1, T2 &p2, T3 &p3, T4 &p4, T5 &p5, T6 &p6,
                          T7 &p7, T8 &p8, T9 &p9, T10 &p10, T11 &p11,
                          T12 &p12 )
      {
        A::apply( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12 );
        B::apply( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12 );
      }

      template< class T1, class T2, class T3, class T4, class T5, class T6,
                class T7, class T8, class T9, class T10, class T11, class T12,
                class T13>
      static void apply ( T1 &p1, T2 &p2, T3 &p3, T4 &p4, T5 &p5, T6 &p6,
                          T7 &p7, T8 &p8, T9 &p9, T10 &p10, T11 &p11,
                          T12 &p12, T13 &p13 )
      {
        A::apply( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13 );
        B::apply( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13 );
      }
    };

  }



  /** \class ForLoop
   * @brief A static loop using TMP
   *
   * The ForLoop takes a 
   *   \code template<int i> class Operation \endcode
   * template argument with a static apply method
   * which is called for i=first...last (first<=last are int template arguments).
   * A specialization for class template class Operation for i=first
   * or i=last is not required. The class Operation must provide a
   * static void function apply(...). Arguments (as references) 
   * can be passed through the ForLoop to this function 
   * (up to 5 at the moment).
   *
   * It is possible to pass a subclass to the ForLoop 
   * (since no specialization is needed).
   *
   * Example of usage:
   * \code
template<class Tuple>
struct PrintTupleTypes
{
  template <int i>
  struct Operation
  {
    template<class Stream>
    static void apply(Stream &stream, const std::string &prefix)
    {
      stream << prefix << i << ": "
             << className<typename tuple_element<i, Tuple>::type>()
             << std::endl;
    }
  };
  template<class Stream>
  static void print(Stream &stream, const std::string &prefix)
  {
    // cannot attach on-the-fly in the argument to ForLoop<..>::apply() since
    // that would yield an rvalue
    std::string extended_prefix = prefix+"  ";

    stream << prefix << "tuple<" << std::endl;
    ForLoop<Operation, 0, tuple_size<Tuple>::value-1>::
      apply(stream, extended_prefix);
    stream << prefix << ">" << std::endl;
  }
};
   * \endcode
   *
   * \note Don't use any rvalues as the arguments to apply().
   *
   * Rvalues will bind to const-references, but not to references that are
   * non-const.  Since we do want to support modifiable arguments to apply(),
   * we have to use non-const references as arguments.  Supporting const
   * references as well would lead to an insane number of overloads which all
   * have to be written more-or-less by hand.
   *
   * Examples of rvalues are: literals (1.0, 0, "huhu"), the results of
   * functions returning an object (std::make_pair(0, 1.0)) and temporary
   * object constructions (std::string("hello"));
   */
  template< template< int > class Operation, int first, int last >
  class ForLoop
  : public GenericForLoop< ForLoopHelper::Apply, Operation, first, last >
  {
    dune_static_assert( (first <= last), "ForLoop: first > last" );
  };

}

#endif // #ifndef DUNE_COMMON_FORLOOP_HH

APT Browse - Built by Thomas Orozco.