--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ossrv_pub/boost_apis/boost/lambda/loops.hpp Tue Feb 02 02:01:42 2010 +0200
@@ -0,0 +1,505 @@
+// Boost Lambda Library -- loops.hpp ----------------------------------------
+
+// Copyright (C) 1999, 2000 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)
+// Copyright (C) 2000 Gary Powell (powellg@amazon.com)
+// Copyright (c) 2001-2002 Joel de Guzman
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// For more information, see www.boost.org
+
+// --------------------------------------------------------------------------
+
+#if !defined(BOOST_LAMBDA_LOOPS_HPP)
+#define BOOST_LAMBDA_LOOPS_HPP
+
+#include "boost/lambda/core.hpp"
+
+namespace boost {
+namespace lambda {
+
+// -- loop control structure actions ----------------------
+
+class forloop_action {};
+class forloop_no_body_action {};
+class whileloop_action {};
+class whileloop_no_body_action {};
+class dowhileloop_action {};
+class dowhileloop_no_body_action {};
+
+
+// For loop
+template <class Arg1, class Arg2, class Arg3, class Arg4>
+inline const
+lambda_functor<
+ lambda_functor_base<
+ forloop_action,
+ tuple<lambda_functor<Arg1>, lambda_functor<Arg2>,
+ lambda_functor<Arg3>, lambda_functor<Arg4> >
+ >
+>
+for_loop(const lambda_functor<Arg1>& a1, const lambda_functor<Arg2>& a2,
+ const lambda_functor<Arg3>& a3, const lambda_functor<Arg4>& a4) {
+ return
+ lambda_functor_base<
+ forloop_action,
+ tuple<lambda_functor<Arg1>, lambda_functor<Arg2>,
+ lambda_functor<Arg3>, lambda_functor<Arg4> >
+ >
+ ( tuple<lambda_functor<Arg1>, lambda_functor<Arg2>,
+ lambda_functor<Arg3>, lambda_functor<Arg4> >(a1, a2, a3, a4)
+ );
+}
+
+// No body case.
+template <class Arg1, class Arg2, class Arg3>
+inline const
+lambda_functor<
+ lambda_functor_base<
+ forloop_no_body_action,
+ tuple<lambda_functor<Arg1>, lambda_functor<Arg2>, lambda_functor<Arg3> >
+ >
+>
+for_loop(const lambda_functor<Arg1>& a1, const lambda_functor<Arg2>& a2,
+ const lambda_functor<Arg3>& a3) {
+ return
+ lambda_functor_base<
+ forloop_no_body_action,
+ tuple<lambda_functor<Arg1>, lambda_functor<Arg2>,
+ lambda_functor<Arg3> >
+ >
+ ( tuple<lambda_functor<Arg1>, lambda_functor<Arg2>,
+ lambda_functor<Arg3> >(a1, a2, a3) );
+}
+
+// While loop
+template <class Arg1, class Arg2>
+inline const
+lambda_functor<
+ lambda_functor_base<
+ whileloop_action,
+ tuple<lambda_functor<Arg1>, lambda_functor<Arg2> >
+ >
+>
+while_loop(const lambda_functor<Arg1>& a1, const lambda_functor<Arg2>& a2) {
+ return
+ lambda_functor_base<
+ whileloop_action,
+ tuple<lambda_functor<Arg1>, lambda_functor<Arg2> >
+ >
+ ( tuple<lambda_functor<Arg1>, lambda_functor<Arg2> >(a1, a2));
+}
+
+// No body case.
+template <class Arg1>
+inline const
+lambda_functor<
+ lambda_functor_base<
+ whileloop_no_body_action,
+ tuple<lambda_functor<Arg1> >
+ >
+>
+while_loop(const lambda_functor<Arg1>& a1) {
+ return
+ lambda_functor_base<
+ whileloop_no_body_action,
+ tuple<lambda_functor<Arg1> >
+ >
+ ( tuple<lambda_functor<Arg1> >(a1) );
+}
+
+
+// Do While loop
+template <class Arg1, class Arg2>
+inline const
+lambda_functor<
+ lambda_functor_base<
+ dowhileloop_action,
+ tuple<lambda_functor<Arg1>, lambda_functor<Arg2> >
+ >
+>
+do_while_loop(const lambda_functor<Arg1>& a1, const lambda_functor<Arg2>& a2) {
+ return
+ lambda_functor_base<
+ dowhileloop_action,
+ tuple<lambda_functor<Arg1>, lambda_functor<Arg2> >
+ >
+ ( tuple<lambda_functor<Arg1>, lambda_functor<Arg2> >(a1, a2));
+}
+
+// No body case.
+template <class Arg1>
+inline const
+lambda_functor<
+ lambda_functor_base<
+ dowhileloop_no_body_action,
+ tuple<lambda_functor<Arg1> >
+ >
+>
+do_while_loop(const lambda_functor<Arg1>& a1) {
+ return
+ lambda_functor_base<
+ dowhileloop_no_body_action,
+ tuple<lambda_functor<Arg1> >
+ >
+ ( tuple<lambda_functor<Arg1> >(a1));
+}
+
+
+// Control loop lambda_functor_base specializations.
+
+// Specialization for for_loop.
+template<class Args>
+class
+lambda_functor_base<forloop_action, Args> {
+public:
+ Args args;
+ template <class T> struct sig { typedef void type; };
+public:
+ explicit lambda_functor_base(const Args& a) : args(a) {}
+
+ template<class RET, CALL_TEMPLATE_ARGS>
+ RET call(CALL_FORMAL_ARGS) const {
+ for(detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS);
+ detail::select(boost::tuples::get<1>(args), CALL_ACTUAL_ARGS);
+ detail::select(boost::tuples::get<2>(args), CALL_ACTUAL_ARGS))
+
+ detail::select(boost::tuples::get<3>(args), CALL_ACTUAL_ARGS);
+ }
+};
+
+// No body case
+template<class Args>
+class
+lambda_functor_base<forloop_no_body_action, Args> {
+public:
+ Args args;
+ template <class T> struct sig { typedef void type; };
+public:
+ explicit lambda_functor_base(const Args& a) : args(a) {}
+
+ template<class RET, CALL_TEMPLATE_ARGS>
+ RET call(CALL_FORMAL_ARGS) const {
+ for(detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS);
+ detail::select(boost::tuples::get<1>(args), CALL_ACTUAL_ARGS);
+ detail::select(boost::tuples::get<2>(args), CALL_ACTUAL_ARGS)) {}
+ }
+};
+
+
+// Specialization for while_loop.
+template<class Args>
+class
+lambda_functor_base<whileloop_action, Args> {
+public:
+ Args args;
+ template <class T> struct sig { typedef void type; };
+public:
+ explicit lambda_functor_base(const Args& a) : args(a) {}
+
+ template<class RET, CALL_TEMPLATE_ARGS>
+ RET call(CALL_FORMAL_ARGS) const {
+ while(detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS))
+
+ detail::select(boost::tuples::get<1>(args), CALL_ACTUAL_ARGS);
+ }
+};
+
+// No body case
+template<class Args>
+class
+lambda_functor_base<whileloop_no_body_action, Args> {
+public:
+ Args args;
+ template <class T> struct sig { typedef void type; };
+public:
+ explicit lambda_functor_base(const Args& a) : args(a) {}
+
+ template<class RET, CALL_TEMPLATE_ARGS>
+ RET call(CALL_FORMAL_ARGS) const {
+ while(detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS)) {}
+ }
+};
+
+// Specialization for do_while_loop.
+// Note that the first argument is the condition.
+template<class Args>
+class
+lambda_functor_base<dowhileloop_action, Args> {
+public:
+ Args args;
+ template <class T> struct sig { typedef void type; };
+public:
+ explicit lambda_functor_base(const Args& a) : args(a) {}
+
+ template<class RET, CALL_TEMPLATE_ARGS>
+ RET call(CALL_FORMAL_ARGS) const {
+ do {
+ detail::select(boost::tuples::get<1>(args), CALL_ACTUAL_ARGS);
+ } while (detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS) );
+ }
+};
+
+// No body case
+template<class Args>
+class
+lambda_functor_base<dowhileloop_no_body_action, Args> {
+public:
+ Args args;
+ template <class T> struct sig { typedef void type; };
+public:
+ explicit lambda_functor_base(const Args& a) : args(a) {}
+
+ template<class RET, CALL_TEMPLATE_ARGS>
+ RET call(CALL_FORMAL_ARGS) const {
+ do {} while (detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS) );
+ }
+};
+
+ // The code below is from Joel de Guzman, some name changes etc.
+ // has been made.
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// while_composite
+//
+// This composite has the form:
+//
+// while_(condition)
+// [
+// statement
+// ]
+//
+// While the condition (an lambda_functor) evaluates to true, statement
+// (another lambda_functor) is executed. The result type of this is void.
+// Note the trailing underscore after while_.
+//
+///////////////////////////////////////////////////////////////////////////////
+template <typename CondT, typename DoT>
+struct while_composite {
+
+ typedef while_composite<CondT, DoT> self_t;
+
+ template <class SigArgs>
+ struct sig { typedef void type; };
+
+ while_composite(CondT const& cond_, DoT const& do__)
+ : cond(cond_), do_(do__) {}
+
+ template <class Ret, CALL_TEMPLATE_ARGS>
+ Ret call(CALL_FORMAL_ARGS) const
+ {
+ while (cond.internal_call(CALL_ACTUAL_ARGS))
+ do_.internal_call(CALL_ACTUAL_ARGS);
+ }
+
+ CondT cond;
+ DoT do_;
+};
+
+//////////////////////////////////
+template <typename CondT>
+struct while_gen {
+
+ while_gen(CondT const& cond_)
+ : cond(cond_) {}
+
+ template <typename DoT>
+ lambda_functor<while_composite<
+ typename as_lambda_functor<CondT>::type,
+ typename as_lambda_functor<DoT>::type> >
+ operator[](DoT const& do_) const
+ {
+ typedef while_composite<
+ typename as_lambda_functor<CondT>::type,
+ typename as_lambda_functor<DoT>::type>
+ result;
+
+ return result(
+ to_lambda_functor(cond),
+ to_lambda_functor(do_));
+ }
+
+ CondT cond;
+};
+
+//////////////////////////////////
+template <typename CondT>
+inline while_gen<CondT>
+while_(CondT const& cond)
+{
+ return while_gen<CondT>(cond);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// do_composite
+//
+// This composite has the form:
+//
+// do_
+// [
+// statement
+// ]
+// .while_(condition)
+//
+// While the condition (an lambda_functor) evaluates to true, statement
+// (another lambda_functor) is executed. The statement is executed at least
+// once. The result type of this is void. Note the trailing
+// underscore after do_ and the the leading dot and the trailing
+// underscore before and after .while_.
+//
+///////////////////////////////////////////////////////////////////////////////
+template <typename DoT, typename CondT>
+struct do_composite {
+
+ typedef do_composite<DoT, CondT> self_t;
+
+ template <class SigArgs>
+ struct sig { typedef void type; };
+
+ do_composite(DoT const& do__, CondT const& cond_)
+ : do_(do__), cond(cond_) {}
+
+ template <class Ret, CALL_TEMPLATE_ARGS>
+ Ret call(CALL_FORMAL_ARGS) const
+ {
+ do
+ do_.internal_call(CALL_ACTUAL_ARGS);
+ while (cond.internal_call(CALL_ACTUAL_ARGS));
+ }
+
+ DoT do_;
+ CondT cond;
+};
+
+////////////////////////////////////
+template <typename DoT>
+struct do_gen2 {
+
+ do_gen2(DoT const& do__)
+ : do_(do__) {}
+
+ template <typename CondT>
+ lambda_functor<do_composite<
+ typename as_lambda_functor<DoT>::type,
+ typename as_lambda_functor<CondT>::type> >
+ while_(CondT const& cond) const
+ {
+ typedef do_composite<
+ typename as_lambda_functor<DoT>::type,
+ typename as_lambda_functor<CondT>::type>
+ result;
+
+ return result(
+ to_lambda_functor(do_),
+ to_lambda_functor(cond));
+ }
+
+ DoT do_;
+};
+
+////////////////////////////////////
+struct do_gen {
+
+ template <typename DoT>
+ do_gen2<DoT>
+ operator[](DoT const& do_) const
+ {
+ return do_gen2<DoT>(do_);
+ }
+};
+
+do_gen const do_ = do_gen();
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// for_composite
+//
+// This statement has the form:
+//
+// for_(init, condition, step)
+// [
+// statement
+// ]
+//
+// Where init, condition, step and statement are all lambda_functors. init
+// is executed once before entering the for-loop. The for-loop
+// exits once condition evaluates to false. At each loop iteration,
+// step and statement is called. The result of this statement is
+// void. Note the trailing underscore after for_.
+//
+///////////////////////////////////////////////////////////////////////////////
+template <typename InitT, typename CondT, typename StepT, typename DoT>
+struct for_composite {
+
+ template <class SigArgs>
+ struct sig { typedef void type; };
+
+ for_composite(
+ InitT const& init_,
+ CondT const& cond_,
+ StepT const& step_,
+ DoT const& do__)
+ : init(init_), cond(cond_), step(step_), do_(do__) {}
+
+ template <class Ret, CALL_TEMPLATE_ARGS>
+ Ret
+ call(CALL_FORMAL_ARGS) const
+ {
+ for (init.internal_call(CALL_ACTUAL_ARGS); cond.internal_call(CALL_ACTUAL_ARGS); step.internal_call(CALL_ACTUAL_ARGS))
+ do_.internal_call(CALL_ACTUAL_ARGS);
+ }
+
+ InitT init; CondT cond; StepT step; DoT do_; // lambda_functors
+};
+
+//////////////////////////////////
+template <typename InitT, typename CondT, typename StepT>
+struct for_gen {
+
+ for_gen(
+ InitT const& init_,
+ CondT const& cond_,
+ StepT const& step_)
+ : init(init_), cond(cond_), step(step_) {}
+
+ template <typename DoT>
+ lambda_functor<for_composite<
+ typename as_lambda_functor<InitT>::type,
+ typename as_lambda_functor<CondT>::type,
+ typename as_lambda_functor<StepT>::type,
+ typename as_lambda_functor<DoT>::type> >
+ operator[](DoT const& do_) const
+ {
+ typedef for_composite<
+ typename as_lambda_functor<InitT>::type,
+ typename as_lambda_functor<CondT>::type,
+ typename as_lambda_functor<StepT>::type,
+ typename as_lambda_functor<DoT>::type>
+ result;
+
+ return result(
+ to_lambda_functor(init),
+ to_lambda_functor(cond),
+ to_lambda_functor(step),
+ to_lambda_functor(do_));
+ }
+
+ InitT init; CondT cond; StepT step;
+};
+
+//////////////////////////////////
+template <typename InitT, typename CondT, typename StepT>
+inline for_gen<InitT, CondT, StepT>
+for_(InitT const& init, CondT const& cond, StepT const& step)
+{
+ return for_gen<InitT, CondT, StepT>(init, cond, step);
+}
+
+} // lambda
+} // boost
+
+#endif // BOOST_LAMBDA_LOOPS_HPP