← Back to branch summary

~ubuntu-branches/ubuntu/saucy/deal.ii/saucy

« back to all changes in this revision

Viewing changes to contrib/boost/include/boost/lambda/loops.hpp

  • Committer: Package Import Robot
  • Author(s): "Adam C. Powell, IV", Adam C. Powell, IV, Christophe Trophime
  • Date: 2012-02-21 06:57:30 UTC
  • mfrom: (3.1.7 sid)
  • Revision ID: package-import@ubuntu.com-20120221065730-r2iz70lg557wcd2e
Tags: 7.1.0-1
http://bugs.debian.org/652057
http://bugs.debian.org/652058
http://bugs.debian.org/637655
http://bugs.debian.org/659245
[ Adam C. Powell, IV ]
* New upstream (closes: #652057).
* Updated to use PETSc and SLEPc 3.2, and forward-ported all patches.
* Removed NetCDF Build-Depends because it uses serial HDF5.
* Made Sacado cmath patch work with new configure.
* Moved -dev package symlink lines in rules to arch all section.

[ Christophe Trophime ]
* debian/rules:
   - add dh_strip --dbg-package to generate dbg package (closes: #652058)
   - add .install files to simplify rules
* Add support for mumps, arpack (closes: #637655)
* Add patch for slepc 3.2 (closes: #659245)

Show diffs side-by-side

added added

removed removed

Lines of Context:
contrib/boost/include/boost/lambda/loops.hpp
1
 
// Boost Lambda Library -- loops.hpp ----------------------------------------
2
 
 
3
 
// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
4
 
// Copyright (C) 2000 Gary Powell (powellg@amazon.com)
5
 
// Copyright (c) 2001-2002 Joel de Guzman
6
 
//
7
 
// Distributed under the Boost Software License, Version 1.0. (See
8
 
// accompanying file LICENSE_1_0.txt or copy at
9
 
// http://www.boost.org/LICENSE_1_0.txt)
10
 
//
11
 
// For more information, see www.boost.org
12
 
 
13
 
// --------------------------------------------------------------------------
14
 
 
15
 
#if !defined(BOOST_LAMBDA_LOOPS_HPP)
16
 
#define BOOST_LAMBDA_LOOPS_HPP
17
 
 
18
 
#include "boost/lambda/core.hpp"
19
 
 
20
 
namespace boost { 
21
 
namespace lambda {
22
 
 
23
 
// -- loop control structure actions ----------------------
24
 
 
25
 
class forloop_action {};
26
 
class forloop_no_body_action {};
27
 
class whileloop_action {};
28
 
class whileloop_no_body_action {};
29
 
class dowhileloop_action {};
30
 
class dowhileloop_no_body_action {};
31
 
 
32
 
 
33
 
// For loop
34
 
template <class Arg1, class Arg2, class Arg3, class Arg4>
35
 
inline const 
36
 
lambda_functor<
37
 
  lambda_functor_base<
38
 
    forloop_action, 
39
 
    tuple<lambda_functor<Arg1>, lambda_functor<Arg2>, 
40
 
          lambda_functor<Arg3>, lambda_functor<Arg4> >
41
 
  > 
42
 
>
43
 
for_loop(const lambda_functor<Arg1>& a1, const lambda_functor<Arg2>& a2, 
44
 
         const lambda_functor<Arg3>& a3, const lambda_functor<Arg4>& a4) { 
45
 
  return 
46
 
      lambda_functor_base<
47
 
        forloop_action, 
48
 
        tuple<lambda_functor<Arg1>, lambda_functor<Arg2>, 
49
 
              lambda_functor<Arg3>, lambda_functor<Arg4> >
50
 
      > 
51
 
    ( tuple<lambda_functor<Arg1>, lambda_functor<Arg2>, 
52
 
            lambda_functor<Arg3>, lambda_functor<Arg4> >(a1, a2, a3, a4)
53
 
    );
54
 
}
55
 
 
56
 
// No body case.
57
 
template <class Arg1, class Arg2, class Arg3>
58
 
inline const 
59
 
lambda_functor<
60
 
  lambda_functor_base<
61
 
    forloop_no_body_action, 
62
 
    tuple<lambda_functor<Arg1>, lambda_functor<Arg2>, lambda_functor<Arg3> >
63
 
  > 
64
 
>
65
 
for_loop(const lambda_functor<Arg1>& a1, const lambda_functor<Arg2>& a2, 
66
 
         const lambda_functor<Arg3>& a3) { 
67
 
  return 
68
 
      lambda_functor_base<
69
 
        forloop_no_body_action, 
70
 
        tuple<lambda_functor<Arg1>, lambda_functor<Arg2>, 
71
 
              lambda_functor<Arg3> >
72
 
      > 
73
 
      ( tuple<lambda_functor<Arg1>, lambda_functor<Arg2>, 
74
 
               lambda_functor<Arg3> >(a1, a2, a3) );
75
 
}
76
 
 
77
 
// While loop
78
 
template <class Arg1, class Arg2>
79
 
inline const 
80
 
lambda_functor<
81
 
  lambda_functor_base<
82
 
    whileloop_action, 
83
 
    tuple<lambda_functor<Arg1>, lambda_functor<Arg2> >
84
 
  > 
85
 
>
86
 
while_loop(const lambda_functor<Arg1>& a1, const lambda_functor<Arg2>& a2) { 
87
 
  return 
88
 
      lambda_functor_base<
89
 
        whileloop_action, 
90
 
        tuple<lambda_functor<Arg1>, lambda_functor<Arg2> >
91
 
      > 
92
 
      ( tuple<lambda_functor<Arg1>, lambda_functor<Arg2> >(a1, a2));
93
 
}
94
 
 
95
 
// No body case.
96
 
template <class Arg1>
97
 
inline const 
98
 
lambda_functor<
99
 
  lambda_functor_base<
100
 
    whileloop_no_body_action, 
101
 
    tuple<lambda_functor<Arg1> >
102
 
  > 
103
 
>
104
 
while_loop(const lambda_functor<Arg1>& a1) { 
105
 
  return 
106
 
      lambda_functor_base<
107
 
        whileloop_no_body_action, 
108
 
        tuple<lambda_functor<Arg1> >
109
 
      > 
110
 
      ( tuple<lambda_functor<Arg1> >(a1) );
111
 
}
112
 
 
113
 
 
114
 
// Do While loop
115
 
template <class Arg1, class Arg2>
116
 
inline const 
117
 
lambda_functor<
118
 
  lambda_functor_base<
119
 
    dowhileloop_action, 
120
 
    tuple<lambda_functor<Arg1>, lambda_functor<Arg2> >
121
 
  > 
122
 
>
123
 
do_while_loop(const lambda_functor<Arg1>& a1, const lambda_functor<Arg2>& a2) {
124
 
  return 
125
 
      lambda_functor_base<
126
 
        dowhileloop_action, 
127
 
        tuple<lambda_functor<Arg1>, lambda_functor<Arg2> >
128
 
      > 
129
 
      ( tuple<lambda_functor<Arg1>, lambda_functor<Arg2> >(a1, a2));
130
 
}
131
 
 
132
 
// No body case.
133
 
template <class Arg1>
134
 
inline const 
135
 
lambda_functor<
136
 
  lambda_functor_base<
137
 
    dowhileloop_no_body_action, 
138
 
    tuple<lambda_functor<Arg1> >
139
 
  > 
140
 
>
141
 
do_while_loop(const lambda_functor<Arg1>& a1) { 
142
 
  return 
143
 
      lambda_functor_base<
144
 
        dowhileloop_no_body_action, 
145
 
        tuple<lambda_functor<Arg1> >
146
 
      > 
147
 
      ( tuple<lambda_functor<Arg1> >(a1));
148
 
}
149
 
 
150
 
 
151
 
// Control loop lambda_functor_base specializations.
152
 
 
153
 
// Specialization for for_loop.
154
 
template<class Args>
155
 
class 
156
 
lambda_functor_base<forloop_action, Args> {
157
 
public:
158
 
  Args args;
159
 
  template <class T> struct sig { typedef void type; };
160
 
public:
161
 
  explicit lambda_functor_base(const Args& a) : args(a) {}
162
 
 
163
 
  template<class RET, CALL_TEMPLATE_ARGS>
164
 
  RET call(CALL_FORMAL_ARGS) const {
165
 
    for(detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS); 
166
 
        detail::select(boost::tuples::get<1>(args), CALL_ACTUAL_ARGS); 
167
 
        detail::select(boost::tuples::get<2>(args), CALL_ACTUAL_ARGS))
168
 
      
169
 
      detail::select(boost::tuples::get<3>(args), CALL_ACTUAL_ARGS);
170
 
  }
171
 
};
172
 
 
173
 
// No body case
174
 
template<class Args>
175
 
class 
176
 
lambda_functor_base<forloop_no_body_action, Args> {
177
 
public:
178
 
  Args args;
179
 
  template <class T> struct sig { typedef void type; };
180
 
public:
181
 
  explicit lambda_functor_base(const Args& a) : args(a) {}
182
 
 
183
 
  template<class RET, CALL_TEMPLATE_ARGS>
184
 
  RET call(CALL_FORMAL_ARGS) const {
185
 
    for(detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS); 
186
 
        detail::select(boost::tuples::get<1>(args), CALL_ACTUAL_ARGS); 
187
 
        detail::select(boost::tuples::get<2>(args), CALL_ACTUAL_ARGS)) {}
188
 
   }
189
 
};
190
 
 
191
 
 
192
 
// Specialization for while_loop.
193
 
template<class Args>
194
 
class 
195
 
lambda_functor_base<whileloop_action, Args> {
196
 
public:
197
 
  Args args;
198
 
  template <class T> struct sig { typedef void type; };
199
 
public:
200
 
  explicit lambda_functor_base(const Args& a) : args(a) {}
201
 
 
202
 
  template<class RET, CALL_TEMPLATE_ARGS>
203
 
  RET call(CALL_FORMAL_ARGS) const {
204
 
    while(detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS))
205
 
      
206
 
      detail::select(boost::tuples::get<1>(args), CALL_ACTUAL_ARGS);
207
 
  }
208
 
};
209
 
 
210
 
// No body case
211
 
template<class Args> 
212
 
class 
213
 
lambda_functor_base<whileloop_no_body_action, Args> {
214
 
public:
215
 
  Args args;
216
 
  template <class T> struct sig { typedef void type; };
217
 
public:
218
 
  explicit lambda_functor_base(const Args& a) : args(a) {}
219
 
 
220
 
  template<class RET, CALL_TEMPLATE_ARGS>
221
 
  RET call(CALL_FORMAL_ARGS) const {
222
 
          while(detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS)) {}
223
 
  }
224
 
};
225
 
 
226
 
// Specialization for do_while_loop.
227
 
// Note that the first argument is the condition.
228
 
template<class Args>
229
 
class 
230
 
lambda_functor_base<dowhileloop_action, Args> {
231
 
public:
232
 
  Args args;
233
 
  template <class T> struct sig { typedef void type; };
234
 
public:
235
 
  explicit lambda_functor_base(const Args& a) : args(a) {}
236
 
 
237
 
  template<class RET, CALL_TEMPLATE_ARGS>
238
 
  RET call(CALL_FORMAL_ARGS) const {
239
 
    do {
240
 
      detail::select(boost::tuples::get<1>(args), CALL_ACTUAL_ARGS);      
241
 
    } while (detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS) );
242
 
  }
243
 
};
244
 
 
245
 
// No body case
246
 
template<class Args>
247
 
class 
248
 
lambda_functor_base<dowhileloop_no_body_action, Args> {
249
 
public:
250
 
  Args args;
251
 
  template <class T> struct sig { typedef void type; };
252
 
public:
253
 
  explicit lambda_functor_base(const Args& a) : args(a) {}
254
 
 
255
 
  template<class RET, CALL_TEMPLATE_ARGS>
256
 
  RET call(CALL_FORMAL_ARGS) const {
257
 
          do {} while (detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS) );
258
 
  }
259
 
};
260
 
 
261
 
  // The code below is from Joel de Guzman, some name changes etc. 
262
 
  // has been made.
263
 
 
264
 
///////////////////////////////////////////////////////////////////////////////
265
 
//
266
 
//  while_composite
267
 
//
268
 
//      This composite has the form:
269
 
//
270
 
//          while_(condition)
271
 
//          [
272
 
//              statement
273
 
//          ]
274
 
//
275
 
//      While the condition (an lambda_functor) evaluates to true, statement
276
 
//      (another lambda_functor) is executed. The result type of this is void.
277
 
//      Note the trailing underscore after while_.
278
 
//
279
 
///////////////////////////////////////////////////////////////////////////////
280
 
template <typename CondT, typename DoT>
281
 
struct while_composite {
282
 
 
283
 
    typedef while_composite<CondT, DoT> self_t;
284
 
 
285
 
    template <class SigArgs>
286
 
    struct sig { typedef void type; };
287
 
 
288
 
    while_composite(CondT const& cond_, DoT const& do__)
289
 
    :   cond(cond_), do_(do__) {}
290
 
 
291
 
    template <class Ret, CALL_TEMPLATE_ARGS>
292
 
    Ret call(CALL_FORMAL_ARGS) const
293
 
    {
294
 
        while (cond.internal_call(CALL_ACTUAL_ARGS))
295
 
            do_.internal_call(CALL_ACTUAL_ARGS);
296
 
    }
297
 
 
298
 
    CondT cond;
299
 
    DoT do_;
300
 
};
301
 
 
302
 
//////////////////////////////////
303
 
template <typename CondT>
304
 
struct while_gen {
305
 
 
306
 
    while_gen(CondT const& cond_)
307
 
    :   cond(cond_) {}
308
 
 
309
 
    template <typename DoT>
310
 
    lambda_functor<while_composite<
311
 
        typename as_lambda_functor<CondT>::type,
312
 
        typename as_lambda_functor<DoT>::type> >
313
 
    operator[](DoT const& do_) const
314
 
    {
315
 
        typedef while_composite<
316
 
            typename as_lambda_functor<CondT>::type,
317
 
            typename as_lambda_functor<DoT>::type>
318
 
        result;
319
 
 
320
 
        return result(
321
 
            to_lambda_functor(cond),
322
 
            to_lambda_functor(do_));
323
 
    }
324
 
 
325
 
    CondT cond;
326
 
};
327
 
 
328
 
//////////////////////////////////
329
 
template <typename CondT>
330
 
inline while_gen<CondT>
331
 
while_(CondT const& cond)
332
 
{
333
 
    return while_gen<CondT>(cond);
334
 
}
335
 
 
336
 
///////////////////////////////////////////////////////////////////////////////
337
 
//
338
 
//  do_composite
339
 
//
340
 
//      This composite has the form:
341
 
//
342
 
//          do_
343
 
//          [
344
 
//              statement
345
 
//          ]
346
 
//          .while_(condition)
347
 
//
348
 
//      While the condition (an lambda_functor) evaluates to true, statement
349
 
//      (another lambda_functor) is executed. The statement is executed at least
350
 
//      once. The result type of this is void. Note the trailing
351
 
//      underscore after do_ and the the leading dot and the trailing
352
 
//      underscore before and after .while_.
353
 
//
354
 
///////////////////////////////////////////////////////////////////////////////
355
 
template <typename DoT, typename CondT>
356
 
struct do_composite {
357
 
 
358
 
    typedef do_composite<DoT, CondT> self_t;
359
 
 
360
 
    template <class SigArgs>
361
 
    struct sig { typedef void type; };
362
 
 
363
 
    do_composite(DoT const& do__, CondT const& cond_)
364
 
    :   do_(do__), cond(cond_) {}
365
 
 
366
 
    template <class Ret, CALL_TEMPLATE_ARGS>
367
 
    Ret call(CALL_FORMAL_ARGS) const
368
 
    {
369
 
        do
370
 
            do_.internal_call(CALL_ACTUAL_ARGS);
371
 
        while (cond.internal_call(CALL_ACTUAL_ARGS));
372
 
    }
373
 
 
374
 
    DoT do_;
375
 
    CondT cond;
376
 
};
377
 
 
378
 
////////////////////////////////////
379
 
template <typename DoT>
380
 
struct do_gen2 {
381
 
 
382
 
    do_gen2(DoT const& do__)
383
 
    :   do_(do__) {}
384
 
 
385
 
    template <typename CondT>
386
 
    lambda_functor<do_composite<
387
 
        typename as_lambda_functor<DoT>::type,
388
 
        typename as_lambda_functor<CondT>::type> >
389
 
    while_(CondT const& cond) const
390
 
    {
391
 
        typedef do_composite<
392
 
            typename as_lambda_functor<DoT>::type,
393
 
            typename as_lambda_functor<CondT>::type>
394
 
        result;
395
 
 
396
 
        return result(
397
 
            to_lambda_functor(do_),
398
 
            to_lambda_functor(cond));
399
 
    }
400
 
 
401
 
    DoT do_;
402
 
};
403
 
 
404
 
////////////////////////////////////
405
 
struct do_gen {
406
 
 
407
 
    template <typename DoT>
408
 
    do_gen2<DoT>
409
 
    operator[](DoT const& do_) const
410
 
    {
411
 
        return do_gen2<DoT>(do_);
412
 
    }
413
 
};
414
 
 
415
 
do_gen const do_ = do_gen();
416
 
 
417
 
///////////////////////////////////////////////////////////////////////////////
418
 
//
419
 
//  for_composite
420
 
//
421
 
//      This statement has the form:
422
 
//
423
 
//          for_(init, condition, step)
424
 
//          [
425
 
//              statement
426
 
//          ]
427
 
//
428
 
//      Where init, condition, step and statement are all lambda_functors. init
429
 
//      is executed once before entering the for-loop. The for-loop
430
 
//      exits once condition evaluates to false. At each loop iteration,
431
 
//      step and statement is called. The result of this statement is
432
 
//      void. Note the trailing underscore after for_.
433
 
//
434
 
///////////////////////////////////////////////////////////////////////////////
435
 
template <typename InitT, typename CondT, typename StepT, typename DoT>
436
 
struct for_composite {
437
 
 
438
 
    template <class SigArgs>
439
 
    struct sig { typedef void type; };
440
 
 
441
 
    for_composite(
442
 
        InitT const& init_,
443
 
        CondT const& cond_,
444
 
        StepT const& step_,
445
 
        DoT const& do__)
446
 
    :   init(init_), cond(cond_), step(step_), do_(do__) {}
447
 
 
448
 
    template <class Ret, CALL_TEMPLATE_ARGS>
449
 
    Ret
450
 
    call(CALL_FORMAL_ARGS) const
451
 
    {
452
 
        for (init.internal_call(CALL_ACTUAL_ARGS); cond.internal_call(CALL_ACTUAL_ARGS); step.internal_call(CALL_ACTUAL_ARGS))
453
 
            do_.internal_call(CALL_ACTUAL_ARGS);
454
 
    }
455
 
 
456
 
    InitT init; CondT cond; StepT step; DoT do_; //  lambda_functors
457
 
};
458
 
 
459
 
//////////////////////////////////
460
 
template <typename InitT, typename CondT, typename StepT>
461
 
struct for_gen {
462
 
 
463
 
    for_gen(
464
 
        InitT const& init_,
465
 
        CondT const& cond_,
466
 
        StepT const& step_)
467
 
    :   init(init_), cond(cond_), step(step_) {}
468
 
 
469
 
    template <typename DoT>
470
 
    lambda_functor<for_composite<
471
 
        typename as_lambda_functor<InitT>::type,
472
 
        typename as_lambda_functor<CondT>::type,
473
 
        typename as_lambda_functor<StepT>::type,
474
 
        typename as_lambda_functor<DoT>::type> >
475
 
    operator[](DoT const& do_) const
476
 
    {
477
 
        typedef for_composite<
478
 
            typename as_lambda_functor<InitT>::type,
479
 
            typename as_lambda_functor<CondT>::type,
480
 
            typename as_lambda_functor<StepT>::type,
481
 
            typename as_lambda_functor<DoT>::type>
482
 
        result;
483
 
 
484
 
        return result(
485
 
            to_lambda_functor(init),
486
 
            to_lambda_functor(cond),
487
 
            to_lambda_functor(step),
488
 
            to_lambda_functor(do_));
489
 
    }
490
 
 
491
 
    InitT init; CondT cond; StepT step;
492
 
};
493
 
 
494
 
//////////////////////////////////
495
 
template <typename InitT, typename CondT, typename StepT>
496
 
inline for_gen<InitT, CondT, StepT>
497
 
for_(InitT const& init, CondT const& cond, StepT const& step)
498
 
{
499
 
    return for_gen<InitT, CondT, StepT>(init, cond, step);
500
 
}
501
 
 
502
 
} // lambda
503
 
} // boost
504
 
 
505
 
#endif // BOOST_LAMBDA_LOOPS_HPP