// Boost Lambda Library  ret.hpp -----------------------------------------// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)//// 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#ifndef BOOST_LAMBDA_RET_HPP#define BOOST_LAMBDA_RET_HPPnamespace boost { namespace lambda {  // TODO://  Add specializations for function references for ret, protect and unlambda//  e.g void foo(); unlambda(foo); fails, as it would add a const qualifier  // for a function type.   // on the other hand unlambda(*foo) does work// -- ret -------------------------// the explicit return type template   // TODO: It'd be nice to make ret a nop for other than lambda functors  // but causes an ambiguiyty with gcc (not with KCC), check what is the  // right interpretation.  //  // ret for others than lambda functors has no effect  // template <class U, class T>  // inline const T& ret(const T& t) { return t; }template<class RET, class Arg>inline const lambda_functor<  lambda_functor_base<    explicit_return_type_action<RET>,     tuple<lambda_functor<Arg> >  > >ret(const lambda_functor<Arg>& a1){  return      lambda_functor_base<      explicit_return_type_action<RET>,       tuple<lambda_functor<Arg> >    >     (tuple<lambda_functor<Arg> >(a1));}// protect ------------------  // protecting others than lambda functors has no effecttemplate <class T>inline const T& protect(const T& t) { return t; }template<class Arg>inline const lambda_functor<  lambda_functor_base<    protect_action,     tuple<lambda_functor<Arg> >  > >protect(const lambda_functor<Arg>& a1){  return       lambda_functor_base<        protect_action,         tuple<lambda_functor<Arg> >      >     (tuple<lambda_functor<Arg> >(a1));}   // -------------------------------------------------------------------// Hides the lambda functorness of a lambda functor. // After this, the functor is immune to argument substitution, etc.// This can be used, e.g. to make it safe to pass lambda functors as // arguments to functions, which might use them as target functions// note, unlambda and protect are different things. Protect hides the lambda// functor for one application, unlambda for good.template <class LambdaFunctor>class non_lambda_functor{  LambdaFunctor lf;public:    // This functor defines the result_type typedef.  // The result type must be deducible without knowing the arguments  template <class SigArgs> struct sig {    typedef typename       LambdaFunctor::inherited::         template sig<typename SigArgs::tail_type>::type type;  };  explicit non_lambda_functor(const LambdaFunctor& a) : lf(a) {}  typename LambdaFunctor::nullary_return_type    operator()() const {    return lf.template       call<typename LambdaFunctor::nullary_return_type>        (cnull_type(), cnull_type(), cnull_type(), cnull_type());   }  template<class A>  typename sig<tuple<const non_lambda_functor, A&> >::type   operator()(A& a) const {    return lf.template call<typename sig<tuple<const non_lambda_functor, A&> >::type >(a, cnull_type(), cnull_type(), cnull_type());   }  template<class A, class B>  typename sig<tuple<const non_lambda_functor, A&, B&> >::type   operator()(A& a, B& b) const {    return lf.template call<typename sig<tuple<const non_lambda_functor, A&, B&> >::type >(a, b, cnull_type(), cnull_type());   }  template<class A, class B, class C>  typename sig<tuple<const non_lambda_functor, A&, B&, C&> >::type   operator()(A& a, B& b, C& c) const {    return lf.template call<typename sig<tuple<const non_lambda_functor, A&, B&, C&> >::type>(a, b, c, cnull_type());   }};template <class Arg>inline const Arg& unlambda(const Arg& a) { return a; }template <class Arg>inline const non_lambda_functor<lambda_functor<Arg> > unlambda(const lambda_functor<Arg>& a){  return non_lambda_functor<lambda_functor<Arg> >(a);}  // Due to a language restriction, lambda functors cannot be made to  // accept non-const rvalue arguments. Usually iterators do not return   // temporaries, but sometimes they do. That's why a workaround is provided.  // Note, that this potentially breaks const correctness, so be careful!// any lambda functor can be turned into a const_incorrect_lambda_functor// The operator() takes arguments as consts and then casts constness// away. So this breaks const correctness!!! but is a necessary workaround// in some cases due to language limitations.// Note, that this is not a lambda_functor anymore, so it can not be used// as a sub lambda expression.template <class LambdaFunctor>struct const_incorrect_lambda_functor {  LambdaFunctor lf;public:  explicit const_incorrect_lambda_functor(const LambdaFunctor& a) : lf(a) {}  template <class SigArgs> struct sig {    typedef typename      LambdaFunctor::inherited::template         sig<typename SigArgs::tail_type>::type type;  };  // The nullary case is not needed (no arguments, no parameter type problems)  template<class A>  typename sig<tuple<const const_incorrect_lambda_functor, A&> >::type  operator()(const A& a) const {    return lf.template call<typename sig<tuple<const const_incorrect_lambda_functor, A&> >::type >(const_cast<A&>(a), cnull_type(), cnull_type(), cnull_type());  }  template<class A, class B>  typename sig<tuple<const const_incorrect_lambda_functor, A&, B&> >::type  operator()(const A& a, const B& b) const {    return lf.template call<typename sig<tuple<const const_incorrect_lambda_functor, A&, B&> >::type >(const_cast<A&>(a), const_cast<B&>(b), cnull_type(), cnull_type());  }  template<class A, class B, class C>  typename sig<tuple<const const_incorrect_lambda_functor, A&, B&, C&> >::type  operator()(const A& a, const B& b, const C& c) const {    return lf.template call<typename sig<tuple<const const_incorrect_lambda_functor, A&, B&, C&> >::type>(const_cast<A&>(a), const_cast<B&>(b), const_cast<C&>(c), cnull_type());  }};// ------------------------------------------------------------------------// any lambda functor can be turned into a const_parameter_lambda_functor// The operator() takes arguments as const.// This is useful if lambda functors are called with non-const rvalues.// Note, that this is not a lambda_functor anymore, so it can not be used// as a sub lambda expression.template <class LambdaFunctor>struct const_parameter_lambda_functor {  LambdaFunctor lf;public:  explicit const_parameter_lambda_functor(const LambdaFunctor& a) : lf(a) {}  template <class SigArgs> struct sig {    typedef typename      LambdaFunctor::inherited::template         sig<typename SigArgs::tail_type>::type type;  };  // The nullary case is not needed: no arguments, no constness problems.  template<class A>  typename sig<tuple<const const_parameter_lambda_functor, const A&> >::type  operator()(const A& a) const {    return lf.template call<typename sig<tuple<const const_parameter_lambda_functor, const A&> >::type >(a, cnull_type(), cnull_type(), cnull_type());  }  template<class A, class B>  typename sig<tuple<const const_parameter_lambda_functor, const A&, const B&> >::type  operator()(const A& a, const B& b) const {    return lf.template call<typename sig<tuple<const const_parameter_lambda_functor, const A&, const B&> >::type >(a, b, cnull_type(), cnull_type());  }  template<class A, class B, class C>  typename sig<tuple<const const_parameter_lambda_functor, const A&, const B&, const C&>>::type  operator()(const A& a, const B& b, const C& c) const {    return lf.template call<typename sig<tuple<const const_parameter_lambda_functor, const A&, const B&, const C&> >::type>(a, b, c, cnull_type());  }};template <class Arg>inline const const_incorrect_lambda_functor<lambda_functor<Arg> >break_const(const lambda_functor<Arg>& lf){  return const_incorrect_lambda_functor<lambda_functor<Arg> >(lf);}template <class Arg>inline const const_parameter_lambda_functor<lambda_functor<Arg> >const_parameters(const lambda_functor<Arg>& lf){  return const_parameter_lambda_functor<lambda_functor<Arg> >(lf);}// make void ------------------------------------------------// make_void( x ) turns a lambda functor x with some return type y into// another lambda functor, which has a void return type// when called, the original return type is discarded// we use this action. The action class will be called, which means that// the wrapped lambda functor is evaluated, but we just don't do anything// with the result.struct voidifier_action {  template<class Ret, class A> static void apply(A&) {}};template<class Args> struct return_type_N<voidifier_action, Args> {  typedef void type;};template<class Arg1>inline const lambda_functor<  lambda_functor_base<    action<1, voidifier_action>,    tuple<lambda_functor<Arg1> >  > > make_void(const lambda_functor<Arg1>& a1) { return     lambda_functor_base<      action<1, voidifier_action>,      tuple<lambda_functor<Arg1> >    >   (tuple<lambda_functor<Arg1> > (a1));}// for non-lambda functors, make_void does nothing // (the argument gets evaluated immediately)template<class Arg1>inline const lambda_functor<  lambda_functor_base<do_nothing_action, null_type> > make_void(const Arg1& a1) { return     lambda_functor_base<do_nothing_action, null_type>();}// std_functor -----------------------------------------------------//  The STL uses the result_type typedef as the convention to let binders know//  the return type of a function object. //  LL uses the sig template.//  To let LL know that the function object has the result_type typedef //  defined, it can be wrapped with the std_functor function.// Just inherit form the template parameter (the standard functor), // and provide a sig template. So we have a class which is still the// same functor + the sig template.template<class T>struct result_type_to_sig : public T {  template<class Args> struct sig { typedef typename T::result_type type; };  result_type_to_sig(const T& t) : T(t) {}};template<class F>inline result_type_to_sig<F> std_functor(const F& f) { return f; }} // namespace lambda } // namespace boost#endif