Ugly, not-to-be-pushed sucking in of all of Boost to get windows to work.
[dyninst.git] / external / boost / lambda / loops.hpp
1 // Boost Lambda Library -- loops.hpp ----------------------------------------
2
3 // Copyright (C) 1999, 2000 Jaakko J√§rvi (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