passenger 4.0.20 → 4.0.21

data/ext/boost/lambda/detail/operators.hpp

@@ -1,370 +0,0 @@
-// Boost Lambda Library - operators.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_OPERATORS_HPP
-#define BOOST_LAMBDA_OPERATORS_HPP
-
-#include "boost/lambda/detail/is_instance_of.hpp"
-
-namespace boost { 
-namespace lambda {
-
-#if defined BOOST_LAMBDA_BE1
-#error "Multiple defines of BOOST_LAMBDA_BE1"
-#endif
-
-  // For all BOOSTA_LAMBDA_BE* macros:
-
-  // CONSTA must be either 'A' or 'const A'
-  // CONSTB must be either 'B' or 'const B'
-
-  // It is stupid to have the names A and B as macro arguments, but it avoids
-  // the need to pass in emtpy macro arguments, which gives warnings on some
-  // compilers
-
-#define BOOST_LAMBDA_BE1(OPER_NAME, ACTION, CONSTA, CONSTB, CONVERSION)      \
-template<class Arg, class B>                                                 \
-inline const                                                                 \
-lambda_functor<                                                              \
-  lambda_functor_base<                                                       \
-    ACTION,                                                                  \
-    tuple<lambda_functor<Arg>, typename const_copy_argument <CONSTB>::type>  \
-  >                                                                          \
->                                                                            \
-OPER_NAME (const lambda_functor<Arg>& a, CONSTB& b) {                      \
-  return                                                                     \
-    lambda_functor_base<                                                     \
-      ACTION,                                                                \
-      tuple<lambda_functor<Arg>, typename const_copy_argument <CONSTB>::type>\
-    >                                                                        \
-   (tuple<lambda_functor<Arg>, typename const_copy_argument <CONSTB>::type>(a, b)); \
-}
-
-
-#if defined BOOST_LAMBDA_BE2
-#error "Multiple defines of BOOST_LAMBDA_BE2"
-#endif
-
-#define BOOST_LAMBDA_BE2(OPER_NAME, ACTION, CONSTA, CONSTB, CONVERSION)      \
-template<class A, class Arg>                                                 \
-inline const                                                                 \
-lambda_functor<                                                              \
-  lambda_functor_base<                                                       \
-    ACTION,                                                                  \
-    tuple<typename CONVERSION <CONSTA>::type, lambda_functor<Arg> >        \
-  >                                                                          \
->                                                                            \
-OPER_NAME (CONSTA& a, const lambda_functor<Arg>& b) {                      \
-  return                                                                     \
-    lambda_functor_base<                                                     \
-      ACTION,                                                                \
-      tuple<typename CONVERSION <CONSTA>::type, lambda_functor<Arg> >      \
-    >                                                                        \
-  (tuple<typename CONVERSION <CONSTA>::type, lambda_functor<Arg> >(a, b)); \
-}
-
-
-#if defined BOOST_LAMBDA_BE3
-#error "Multiple defines of BOOST_LAMBDA_BE3"
-#endif
-
-#define BOOST_LAMBDA_BE3(OPER_NAME, ACTION, CONSTA, CONSTB, CONVERSION)    \
-template<class ArgA, class ArgB>                                           \
-inline const                                                               \
-lambda_functor<                                                            \
-  lambda_functor_base<                                                     \
-    ACTION,                                                                \
-    tuple<lambda_functor<ArgA>, lambda_functor<ArgB> >                     \
-  >                                                                        \
->                                                                          \
-OPER_NAME (const lambda_functor<ArgA>& a, const lambda_functor<ArgB>& b) { \
-  return                                                                   \
-    lambda_functor_base<                                                   \
-      ACTION,                                                              \
-      tuple<lambda_functor<ArgA>, lambda_functor<ArgB> >                   \
-    >                                                                      \
-  (tuple<lambda_functor<ArgA>, lambda_functor<ArgB> >(a, b));              \
-}
-
-#if defined BOOST_LAMBDA_BE
-#error "Multiple defines of BOOST_LAMBDA_BE"
-#endif
-
-#define BOOST_LAMBDA_BE(OPER_NAME, ACTION, CONSTA, CONSTB, CONST_CONVERSION) \
-BOOST_LAMBDA_BE1(OPER_NAME, ACTION, CONSTA, CONSTB, CONST_CONVERSION)        \
-BOOST_LAMBDA_BE2(OPER_NAME, ACTION, CONSTA, CONSTB, CONST_CONVERSION)        \
-BOOST_LAMBDA_BE3(OPER_NAME, ACTION, CONSTA, CONSTB, CONST_CONVERSION)
-
-#define BOOST_LAMBDA_EMPTY() 
-
-BOOST_LAMBDA_BE(operator+, arithmetic_action<plus_action>, const A, const B, const_copy_argument)
-BOOST_LAMBDA_BE(operator-, arithmetic_action<minus_action>, const A, const B, const_copy_argument)
-BOOST_LAMBDA_BE(operator*, arithmetic_action<multiply_action>, const A, const B, const_copy_argument)
-BOOST_LAMBDA_BE(operator/, arithmetic_action<divide_action>, const A, const B, const_copy_argument)
-BOOST_LAMBDA_BE(operator%, arithmetic_action<remainder_action>, const A, const B, const_copy_argument)
-BOOST_LAMBDA_BE(operator<<, bitwise_action<leftshift_action>, const A, const B, const_copy_argument)
-BOOST_LAMBDA_BE(operator>>, bitwise_action<rightshift_action>, const A, const B, const_copy_argument)
-BOOST_LAMBDA_BE(operator&, bitwise_action<and_action>, const A, const B, const_copy_argument)
-BOOST_LAMBDA_BE(operator|, bitwise_action<or_action>, const A, const B, const_copy_argument)
-BOOST_LAMBDA_BE(operator^, bitwise_action<xor_action>, const A, const B, const_copy_argument)
-BOOST_LAMBDA_BE(operator&&, logical_action<and_action>, const A, const B, const_copy_argument)
-BOOST_LAMBDA_BE(operator||, logical_action<or_action>, const A, const B, const_copy_argument)
-BOOST_LAMBDA_BE(operator<, relational_action<less_action>, const A, const B, const_copy_argument)
-BOOST_LAMBDA_BE(operator>, relational_action<greater_action>, const A, const B, const_copy_argument)
-BOOST_LAMBDA_BE(operator<=, relational_action<lessorequal_action>, const A, const B, const_copy_argument)
-BOOST_LAMBDA_BE(operator>=, relational_action<greaterorequal_action>, const A, const B, const_copy_argument)
-BOOST_LAMBDA_BE(operator==, relational_action<equal_action>, const A, const B, const_copy_argument)
-BOOST_LAMBDA_BE(operator!=, relational_action<notequal_action>, const A, const B, const_copy_argument)
-
-BOOST_LAMBDA_BE(operator+=, arithmetic_assignment_action<plus_action>, A, const B, reference_argument)
-BOOST_LAMBDA_BE(operator-=, arithmetic_assignment_action<minus_action>, A, const B, reference_argument)
-BOOST_LAMBDA_BE(operator*=, arithmetic_assignment_action<multiply_action>, A, const B, reference_argument)
-BOOST_LAMBDA_BE(operator/=, arithmetic_assignment_action<divide_action>, A, const B, reference_argument)
-BOOST_LAMBDA_BE(operator%=, arithmetic_assignment_action<remainder_action>, A, const B, reference_argument)
-BOOST_LAMBDA_BE(operator<<=, bitwise_assignment_action<leftshift_action>, A, const B, reference_argument)
-BOOST_LAMBDA_BE(operator>>=, bitwise_assignment_action<rightshift_action>, A, const B, reference_argument)
-BOOST_LAMBDA_BE(operator&=, bitwise_assignment_action<and_action>, A, const B, reference_argument)
-BOOST_LAMBDA_BE(operator|=, bitwise_assignment_action<or_action>, A, const B, reference_argument)
-BOOST_LAMBDA_BE(operator^=, bitwise_assignment_action<xor_action>, A, const B, reference_argument)
-
-
-// A special trick for comma operator for correct preprocessing
-#if defined BOOST_LAMBDA_COMMA_OPERATOR_NAME
-#error "Multiple defines of BOOST_LAMBDA_COMMA_OPERATOR_NAME"
-#endif
-
-#define BOOST_LAMBDA_COMMA_OPERATOR_NAME operator,
-
-BOOST_LAMBDA_BE1(BOOST_LAMBDA_COMMA_OPERATOR_NAME, other_action<comma_action>, const A, const B, const_copy_argument)
-BOOST_LAMBDA_BE2(BOOST_LAMBDA_COMMA_OPERATOR_NAME, other_action<comma_action>, const A, const B, const_copy_argument)
-BOOST_LAMBDA_BE3(BOOST_LAMBDA_COMMA_OPERATOR_NAME, other_action<comma_action>, const A, const B, const_copy_argument)
-
-
-
-namespace detail {
-
-// special cases for ostream& << Any and istream& >> Any ---------------
-// the actual stream classes may vary and thus a specialisation for, 
-// say ostream& does not match (the general case above is chosen). 
-// Therefore we specialise for non-const reference:
-// if the left argument is a stream, we store the stream as reference
-// if it is something else, we store a const plain by default
-
-// Note that the overloading is const vs. non-const first argument
-
-#ifdef BOOST_NO_TEMPLATED_STREAMS
-template<class T> struct convert_ostream_to_ref_others_to_c_plain_by_default {
-  typedef typename detail::IF<
-                       boost::is_convertible<T*, std::ostream*>::value,
-                       T&,
-                       typename const_copy_argument <T>::type
-                     >::RET type;
-};
-
-template<class T> struct convert_istream_to_ref_others_to_c_plain_by_default {
-  typedef typename detail::IF<
-                       boost::is_convertible<T*, std::istream*>::value,
-                       T&,
-                       typename const_copy_argument <T>::type
-                     >::RET type;
-};
-#else
-
-template<class T> struct convert_ostream_to_ref_others_to_c_plain_by_default {
-  typedef typename detail::IF<
-                       is_instance_of_2<
-                         T, std::basic_ostream
-                       >::value,
-                       T&,
-                       typename const_copy_argument <T>::type
-                     >::RET type;
-};
-
-template<class T> struct convert_istream_to_ref_others_to_c_plain_by_default {
-  typedef typename detail::IF<
-                       is_instance_of_2<
-                         T, std::basic_istream
-                       >::value,
-                       T&,
-                       typename const_copy_argument <T>::type
-                     >::RET type;
-};
-#endif
-
-} // detail
-
-BOOST_LAMBDA_BE2(operator<<, bitwise_action< leftshift_action>, A, const B, detail::convert_ostream_to_ref_others_to_c_plain_by_default)
-BOOST_LAMBDA_BE2(operator>>, bitwise_action< rightshift_action>, A, const B, detail::convert_istream_to_ref_others_to_c_plain_by_default)      
-
-
-// special case for io_manipulators.
-// function references cannot be given as arguments to lambda operator
-// expressions in general. With << and >> the use of manipulators is
-// so common, that specializations are provided to make them work.
-
-template<class Arg, class Ret, class ManipArg>
-inline const 
-lambda_functor<
-  lambda_functor_base<
-    bitwise_action<leftshift_action>,
-    tuple<lambda_functor<Arg>, Ret(&)(ManipArg)> 
-  > 
->
-operator<<(const lambda_functor<Arg>& a, Ret(&b)(ManipArg))
-{
-  return 
-      lambda_functor_base<
-        bitwise_action<leftshift_action>,
-        tuple<lambda_functor<Arg>, Ret(&)(ManipArg)>
-      > 
-    ( tuple<lambda_functor<Arg>, Ret(&)(ManipArg)>(a, b) );
-}
-
-template<class Arg, class Ret, class ManipArg>
-inline const 
-lambda_functor<
-  lambda_functor_base<
-    bitwise_action<rightshift_action>,
-    tuple<lambda_functor<Arg>, Ret(&)(ManipArg)>
-  > 
->
-operator>>(const lambda_functor<Arg>& a, Ret(&b)(ManipArg))
-{
-  return 
-      lambda_functor_base<
-        bitwise_action<rightshift_action>,
-        tuple<lambda_functor<Arg>, Ret(&)(ManipArg)>
-      > 
-    ( tuple<lambda_functor<Arg>, Ret(&)(ManipArg)>(a, b) );
-}
-
-
-// (+ and -) take their arguments as const references. 
-// This has consquences with pointer artihmetic
-// E.g int a[]; ... *a = 1 works but not *(a+1) = 1. 
-// the result of a+1 would be const
-// To make the latter work too, 
-// non-const arrays are taken as non-const and stored as non-const as well.
-#if defined  BOOST_LAMBDA_PTR_ARITHMETIC_E1
-#error "Multiple defines of  BOOST_LAMBDA_PTR_ARITHMETIC_E1"
-#endif
-
-#define BOOST_LAMBDA_PTR_ARITHMETIC_E1(OPER_NAME, ACTION, CONSTB)           \
-template<class Arg, int N, class B>                                         \
-inline const                                                                \
-lambda_functor<                                                             \
-  lambda_functor_base<ACTION, tuple<lambda_functor<Arg>, CONSTB(&)[N]> >    \
->                                                                           \
-OPER_NAME (const lambda_functor<Arg>& a, CONSTB(&b)[N])                     \
-{                                                                           \
-  return                                                                    \
-    lambda_functor_base<ACTION, tuple<lambda_functor<Arg>, CONSTB(&)[N]> >  \
-  (tuple<lambda_functor<Arg>, CONSTB(&)[N]>(a, b));                         \
-}
-
-
-#if defined  BOOST_LAMBDA_PTR_ARITHMETIC_E2
-#error "Multiple defines of  BOOST_LAMBDA_PTR_ARITHMETIC_E2"
-#endif
-
-#define BOOST_LAMBDA_PTR_ARITHMETIC_E2(OPER_NAME, ACTION, CONSTA)           \
-template<int N, class A, class Arg>                                         \
-inline const                                                                \
-lambda_functor<                                                             \
-  lambda_functor_base<ACTION, tuple<CONSTA(&)[N], lambda_functor<Arg> > >   \
->                                                                           \
-OPER_NAME (CONSTA(&a)[N], const lambda_functor<Arg>& b)                     \
-{                                                                           \
-  return                                                                    \
-    lambda_functor_base<ACTION, tuple<CONSTA(&)[N], lambda_functor<Arg> > > \
-    (tuple<CONSTA(&)[N], lambda_functor<Arg> >(a, b));                      \
-}
-
-
-BOOST_LAMBDA_PTR_ARITHMETIC_E1(operator+, arithmetic_action<plus_action>, B)
-BOOST_LAMBDA_PTR_ARITHMETIC_E2(operator+, arithmetic_action<plus_action>, A)
-BOOST_LAMBDA_PTR_ARITHMETIC_E1(operator+, arithmetic_action<plus_action>,const B)
-BOOST_LAMBDA_PTR_ARITHMETIC_E2(operator+, arithmetic_action<plus_action>,const A)
-
-
-//BOOST_LAMBDA_PTR_ARITHMETIC_E1(operator-, arithmetic_action<minus_action>)
-// This is not needed, since the result of ptr-ptr is an rvalue anyway
-
-BOOST_LAMBDA_PTR_ARITHMETIC_E2(operator-, arithmetic_action<minus_action>, A)
-BOOST_LAMBDA_PTR_ARITHMETIC_E2(operator-, arithmetic_action<minus_action>, const A)
-
-
-#undef BOOST_LAMBDA_BE1
-#undef BOOST_LAMBDA_BE2
-#undef BOOST_LAMBDA_BE3
-#undef BOOST_LAMBDA_BE
-#undef BOOST_LAMBDA_COMMA_OPERATOR_NAME
-
-#undef BOOST_LAMBDA_PTR_ARITHMETIC_E1
-#undef BOOST_LAMBDA_PTR_ARITHMETIC_E2
-
-
-// ---------------------------------------------------------------------
-// unary operators -----------------------------------------------------
-// ---------------------------------------------------------------------
-
-#if defined BOOST_LAMBDA_UE
-#error "Multiple defines of BOOST_LAMBDA_UE"
-#endif
-
-#define BOOST_LAMBDA_UE(OPER_NAME, ACTION)                                 \
-template<class Arg>                                                        \
-inline const                                                               \
-lambda_functor<lambda_functor_base<ACTION, tuple<lambda_functor<Arg> > > > \
-OPER_NAME (const lambda_functor<Arg>& a)                                   \
-{                                                                          \
-  return                                                                   \
-    lambda_functor_base<ACTION, tuple<lambda_functor<Arg> > >              \
-    ( tuple<lambda_functor<Arg> >(a) );                                    \
-}
-
-
-BOOST_LAMBDA_UE(operator+, unary_arithmetic_action<plus_action>)
-BOOST_LAMBDA_UE(operator-, unary_arithmetic_action<minus_action>)
-BOOST_LAMBDA_UE(operator~, bitwise_action<not_action>)
-BOOST_LAMBDA_UE(operator!, logical_action<not_action>)
-BOOST_LAMBDA_UE(operator++, pre_increment_decrement_action<increment_action>)
-BOOST_LAMBDA_UE(operator--, pre_increment_decrement_action<decrement_action>)
-BOOST_LAMBDA_UE(operator*, other_action<contentsof_action>)
-BOOST_LAMBDA_UE(operator&, other_action<addressof_action>)
-
-#if defined BOOST_LAMBDA_POSTFIX_UE
-#error "Multiple defines of BOOST_LAMBDA_POSTFIX_UE"
-#endif
-
-#define BOOST_LAMBDA_POSTFIX_UE(OPER_NAME, ACTION)                         \
-template<class Arg>                                                        \
-inline const                                                               \
-lambda_functor<lambda_functor_base<ACTION, tuple<lambda_functor<Arg> > > > \
-OPER_NAME (const lambda_functor<Arg>& a, int)                              \
-{                                                                          \
-  return                                                                   \
-    lambda_functor_base<ACTION, tuple<lambda_functor<Arg> > >              \
-    ( tuple<lambda_functor<Arg> >(a) );                                    \
-}
-
-
-BOOST_LAMBDA_POSTFIX_UE(operator++, post_increment_decrement_action<increment_action>)
-BOOST_LAMBDA_POSTFIX_UE(operator--, post_increment_decrement_action<decrement_action>)
-
-#undef BOOST_LAMBDA_UE
-#undef BOOST_LAMBDA_POSTFIX_UE
-
-} // namespace lambda
-} // namespace boost
-
-#endif

data/ext/boost/lambda/detail/ret.hpp

@@ -1,325 +0,0 @@
-// 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_HPP
-
-namespace 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 effect
-template <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
-
-
-
-
-
-
-