passenger 4.0.20 → 4.0.21

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

@@ -1,324 +0,0 @@
-// Boost Lambda Library -  lambda_functors.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 http://www.boost.org
-
-// ------------------------------------------------
-
-#ifndef BOOST_LAMBDA_LAMBDA_FUNCTORS_HPP
-#define BOOST_LAMBDA_LAMBDA_FUNCTORS_HPP
-
-#include <boost/config.hpp>
-#include <boost/detail/workaround.hpp>
-
-#if BOOST_WORKAROUND(BOOST_MSVC, == 1310)
-
-#include <boost/mpl/or.hpp>
-#include <boost/utility/enable_if.hpp>
-#include <boost/type_traits/is_array.hpp>
-
-#define BOOST_LAMBDA_DISABLE_IF_ARRAY1(A1, R1)\
-  typename lazy_disable_if<is_array<A1>, typename R1 >::type
-#define BOOST_LAMBDA_DISABLE_IF_ARRAY2(A1, A2, R1, R2) \
-  typename lazy_disable_if<mpl::or_<is_array<A1>, is_array<A2> >, typename R1, R2 >::type
-#define BOOST_LAMBDA_DISABLE_IF_ARRAY3(A1, A2, A3, R1, R2, R3) \
-  typename lazy_disable_if<mpl::or_<is_array<A1>, is_array<A2>, is_array<A3> >, typename R1, R2, R3 >::type
-
-#else
-
-#define BOOST_LAMBDA_DISABLE_IF_ARRAY1(A1, R1) typename R1::type
-#define BOOST_LAMBDA_DISABLE_IF_ARRAY2(A1, A2, R1, R2) typename R1, R2::type
-#define BOOST_LAMBDA_DISABLE_IF_ARRAY3(A1, A2, A3, R1, R2, R3) typename R1, R2, R3::type
-
-#endif
-
-namespace boost { 
-namespace lambda {
-
-// -- lambda_functor --------------------------------------------
-// --------------------------------------------------------------
-
-//inline const null_type const_null_type() { return null_type(); }
-
-namespace detail {
-namespace {
-
-  static const null_type constant_null_type = null_type();
-
-} // unnamed
-} // detail
-
-class unused {};
-
-#define cnull_type() detail::constant_null_type
-
-// -- free variables types -------------------------------------------------- 
- 
-  // helper to work around the case where the nullary return type deduction 
-  // is always performed, even though the functor is not nullary  
-namespace detail {
-  template<int N, class Tuple> struct get_element_or_null_type {
-    typedef typename 
-      detail::tuple_element_as_reference<N, Tuple>::type type;
-  };
-  template<int N> struct get_element_or_null_type<N, null_type> {
-    typedef null_type type;
-  };
-}
-
-template <int I> struct placeholder;
-
-template<> struct placeholder<FIRST> {
-
-  template<class SigArgs> struct sig {
-    typedef typename detail::get_element_or_null_type<0, SigArgs>::type type;
-  };
-
-  template<class RET, CALL_TEMPLATE_ARGS> 
-  RET call(CALL_FORMAL_ARGS) const { 
-    BOOST_STATIC_ASSERT(boost::is_reference<RET>::value); 
-    CALL_USE_ARGS; // does nothing, prevents warnings for unused args
-    return a; 
-  }
-};
-
-template<> struct placeholder<SECOND> {
-
-  template<class SigArgs> struct sig {
-    typedef typename detail::get_element_or_null_type<1, SigArgs>::type type;
-  };
-
-  template<class RET, CALL_TEMPLATE_ARGS> 
-  RET call(CALL_FORMAL_ARGS) const { CALL_USE_ARGS; return b; }
-};
-
-template<> struct placeholder<THIRD> {
-
-  template<class SigArgs> struct sig {
-    typedef typename detail::get_element_or_null_type<2, SigArgs>::type type;
-  };
-
-  template<class RET, CALL_TEMPLATE_ARGS> 
-  RET call(CALL_FORMAL_ARGS) const { CALL_USE_ARGS; return c; }
-};
-
-template<> struct placeholder<EXCEPTION> {
-
-  template<class SigArgs> struct sig {
-    typedef typename detail::get_element_or_null_type<3, SigArgs>::type type;
-  };
-
-  template<class RET, CALL_TEMPLATE_ARGS> 
-  RET call(CALL_FORMAL_ARGS) const { CALL_USE_ARGS; return env; }
-};
-   
-typedef const lambda_functor<placeholder<FIRST> >  placeholder1_type;
-typedef const lambda_functor<placeholder<SECOND> > placeholder2_type;
-typedef const lambda_functor<placeholder<THIRD> >  placeholder3_type;
-   
-
-///////////////////////////////////////////////////////////////////////////////
-
-
-// free variables are lambda_functors. This is to allow uniform handling with 
-// other lambda_functors.
-// -------------------------------------------------------------------
-
-#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
-#pragma warning(push)
-#pragma warning(disable:4512) //assignment operator could not be generated
-#endif
-
-// -- lambda_functor NONE ------------------------------------------------
-template <class T>
-class lambda_functor : public T 
-{
-
-BOOST_STATIC_CONSTANT(int, arity_bits = get_arity<T>::value);
- 
-public:
-  typedef T inherited;
-
-  lambda_functor() {}
-  lambda_functor(const lambda_functor& l) : inherited(l) {}
-
-  lambda_functor(const T& t) : inherited(t) {}
-
-  template <class SigArgs> struct sig {
-    typedef typename inherited::template 
-      sig<typename SigArgs::tail_type>::type type;
-  };
-
-  // Note that this return type deduction template is instantiated, even 
-  // if the nullary 
-  // operator() is not called at all. One must make sure that it does not fail.
-  typedef typename 
-    inherited::template sig<null_type>::type
-      nullary_return_type;
-
-  // Support for boost::result_of.
-  template <class Sig> struct result;
-  template <class F>
-  struct result<F()> {
-    typedef nullary_return_type type;
-  };
-  template <class F, class A>
-  struct result<F(A)> {
-    typedef typename sig<tuple<F, A> >::type type;
-  };
-  template <class F, class A, class B>
-  struct result<F(A, B)> {
-    typedef typename sig<tuple<F, A, B> >::type type;
-  };
-  template <class F, class A, class B, class C>
-  struct result<F(A, B, C)> {
-    typedef typename sig<tuple<F, A, B, C> >::type type;
-  };
-
-  nullary_return_type operator()() const { 
-    return inherited::template 
-      call<nullary_return_type>
-        (cnull_type(), cnull_type(), cnull_type(), cnull_type()); 
-  }
-
-  template<class A>
-  typename inherited::template sig<tuple<A&> >::type
-  operator()(A& a) const { 
-    return inherited::template call<
-      typename inherited::template sig<tuple<A&> >::type
-    >(a, cnull_type(), cnull_type(), cnull_type());
-  }
-
-  template<class A>
-  BOOST_LAMBDA_DISABLE_IF_ARRAY1(A, inherited::template sig<tuple<A const&> >)
-  operator()(A const& a) const { 
-    return inherited::template call<
-      typename inherited::template sig<tuple<A const&> >::type
-    >(a, cnull_type(), cnull_type(), cnull_type());
-  }
-
-  template<class A, class B>
-  typename inherited::template sig<tuple<A&, B&> >::type
-  operator()(A& a, B& b) const { 
-    return inherited::template call<
-      typename inherited::template sig<tuple<A&, B&> >::type
-    >(a, b, cnull_type(), cnull_type()); 
-  }
-
-  template<class A, class B>
-  BOOST_LAMBDA_DISABLE_IF_ARRAY2(A, B, inherited::template sig<tuple<A const&, B&> >)
-  operator()(A const& a, B& b) const { 
-    return inherited::template call<
-      typename inherited::template sig<tuple<A const&, B&> >::type
-    >(a, b, cnull_type(), cnull_type()); 
-  }
-
-  template<class A, class B>
-  BOOST_LAMBDA_DISABLE_IF_ARRAY2(A, B, inherited::template sig<tuple<A&, B const&> >)
-  operator()(A& a, B const& b) const { 
-    return inherited::template call<
-      typename inherited::template sig<tuple<A&, B const&> >::type
-    >(a, b, cnull_type(), cnull_type()); 
-  }
-
-  template<class A, class B>
-  BOOST_LAMBDA_DISABLE_IF_ARRAY2(A, B, inherited::template sig<tuple<A const&, B const&> >)
-  operator()(A const& a, B const& b) const { 
-    return inherited::template call<
-      typename inherited::template sig<tuple<A const&, B const&> >::type
-    >(a, b, cnull_type(), cnull_type()); 
-  }
-
-  template<class A, class B, class C>
-  typename inherited::template sig<tuple<A&, B&, C&> >::type
-  operator()(A& a, B& b, C& c) const
-  { 
-    return inherited::template call<
-      typename inherited::template sig<tuple<A&, B&, C&> >::type
-    >(a, b, c, cnull_type()); 
-  }
-
-  template<class A, class B, class C>
-  BOOST_LAMBDA_DISABLE_IF_ARRAY3(A, B, C, inherited::template sig<tuple<A const&, B const&, C const&> >)
-  operator()(A const& a, B const& b, C const& c) const
-  { 
-    return inherited::template call<
-      typename inherited::template sig<tuple<A const&, B const&, C const&> >::type
-    >(a, b, c, cnull_type()); 
-  }
-
-  // for internal calls with env
-  template<CALL_TEMPLATE_ARGS>
-  typename inherited::template sig<tuple<CALL_REFERENCE_TYPES> >::type
-  internal_call(CALL_FORMAL_ARGS) const { 
-     return inherited::template 
-       call<typename inherited::template 
-         sig<tuple<CALL_REFERENCE_TYPES> >::type>(CALL_ACTUAL_ARGS); 
-  }
-
-  template<class A>
-  const lambda_functor<lambda_functor_base<
-                  other_action<assignment_action>,
-                  boost::tuple<lambda_functor,
-                  typename const_copy_argument <const A>::type> > >
-  operator=(const A& a) const {
-    return lambda_functor_base<
-                  other_action<assignment_action>,
-                  boost::tuple<lambda_functor,
-                  typename const_copy_argument <const A>::type> >
-     (  boost::tuple<lambda_functor,
-             typename const_copy_argument <const A>::type>(*this, a) );
-  }
-
-  template<class A> 
-  const lambda_functor<lambda_functor_base< 
-                  other_action<subscript_action>, 
-                  boost::tuple<lambda_functor, 
-                        typename const_copy_argument <const A>::type> > > 
-  operator[](const A& a) const { 
-    return lambda_functor_base< 
-                  other_action<subscript_action>, 
-                  boost::tuple<lambda_functor, 
-                        typename const_copy_argument <const A>::type> >
-     ( boost::tuple<lambda_functor, 
-             typename const_copy_argument <const A>::type>(*this, a ) ); 
-  } 
-};
-
-#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
-#pragma warning(pop)
-#endif
-
-} // namespace lambda
-} // namespace boost
-
-// is_placeholder
-
-#include <boost/is_placeholder.hpp>
-
-namespace boost
-{
-
-template<> struct is_placeholder< lambda::lambda_functor< lambda::placeholder<lambda::FIRST> > >
-{
-    enum _vt { value = 1 };
-};
-
-template<> struct is_placeholder< lambda::lambda_functor< lambda::placeholder<lambda::SECOND> > >
-{
-    enum _vt { value = 2 };
-};
-
-template<> struct is_placeholder< lambda::lambda_functor< lambda::placeholder<lambda::THIRD> > >
-{
-    enum _vt { value = 3 };
-};
-
-} // namespace boost
-
-#endif

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

@@ -1,74 +0,0 @@
-//  lambda_fwd.hpp - Boost Lambda Library -------------------------------
-
-// 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_FWD_HPP
-#define BOOST_LAMBDA_FWD_HPP
-
-namespace boost { 
-namespace lambda { 
-
-namespace detail {
-
-template<class T> struct generate_error;
-
-}   
-// -- placeholders --------------------------------------------
-
-template <int I> struct placeholder;
-
-// function_adaptors
-template <class Func> 
-struct function_adaptor;
-
-template <int I, class Act> class action;
-
-template <class Base> 
-class lambda_functor;
-
-template <class Act, class Args> 
-class lambda_functor_base;
-
-} // namespace lambda
-} // namespace boost
-
-
-//  #define CALL_TEMPLATE_ARGS class A, class Env
-//  #define CALL_FORMAL_ARGS A& a, Env& env
-//  #define CALL_ACTUAL_ARGS a, env
-//  #define CALL_ACTUAL_ARGS_NO_ENV a
-//  #define CALL_REFERENCE_TYPES A&, Env&
-//  #define CALL_PLAIN_TYPES A, Env
-#define CALL_TEMPLATE_ARGS class A, class B, class C, class Env
-#define CALL_FORMAL_ARGS A& a, B& b, C& c, Env& env
-#define CALL_ACTUAL_ARGS a, b, c, env
-#define CALL_ACTUAL_ARGS_NO_ENV a, b, c
-#define CALL_REFERENCE_TYPES A&, B&, C&, Env&
-#define CALL_PLAIN_TYPES A, B, C, Env
-
-namespace boost {
-namespace lambda {
-namespace detail {
-
-template<class A1, class A2, class A3, class A4>
-void do_nothing(A1&, A2&, A3&, A4&) {}
-
-} // detail
-} // lambda
-} // boost
-
-// prevent the warnings from unused arguments
-#define CALL_USE_ARGS \
-::boost::lambda::detail::do_nothing(a, b, c, env)
-
-
-
-#endif

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

@@ -1,578 +0,0 @@
-// - lambda_traits.hpp --- Boost Lambda Library ----------------------------
-//
-// 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_LAMBDA_TRAITS_HPP
-#define BOOST_LAMBDA_LAMBDA_TRAITS_HPP
-
-#include "boost/type_traits/transform_traits.hpp"
-#include "boost/type_traits/cv_traits.hpp"
-#include "boost/type_traits/function_traits.hpp"
-#include "boost/type_traits/object_traits.hpp"
-#include "boost/tuple/tuple.hpp"
-
-namespace boost {
-namespace lambda {
-
-// -- if construct ------------------------------------------------
-// Proposed by Krzysztof Czarnecki and Ulrich Eisenecker
-
-namespace detail {
-
-template <bool If, class Then, class Else> struct IF { typedef Then RET; };
-
-template <class Then, class Else> struct IF<false, Then, Else> {
-  typedef Else RET;
-};
-
-
-// An if construct that doesn't instantiate the non-matching template:
-
-// Called as: 
-//  IF_type<condition, A, B>::type 
-// The matching template must define the typeded 'type'
-// I.e. A::type if condition is true, B::type if condition is false
-// Idea from Vesa Karvonen (from C&E as well I guess)
-template<class T>
-struct IF_type_
-{
-  typedef typename T::type type;
-};
-
-
-template<bool C, class T, class E>
-struct IF_type
-{
-  typedef typename
-    IF_type_<typename IF<C, T, E>::RET >::type type;
-};
-
-// helper that can be used to give typedef T to some type
-template <class T> struct identity_mapping { typedef T type; };
-
-// An if construct for finding an integral constant 'value'
-// Does not instantiate the non-matching branch
-// Called as IF_value<condition, A, B>::value
-// If condition is true A::value must be defined, otherwise B::value
-
-template<class T>
-struct IF_value_
-{
-  BOOST_STATIC_CONSTANT(int, value = T::value);
-};
-
-
-template<bool C, class T, class E>
-struct IF_value
-{
-  BOOST_STATIC_CONSTANT(int, value = (IF_value_<typename IF<C, T, E>::RET>::value));
-};
-
-
-// --------------------------------------------------------------
-
-// removes reference from other than function types:
-template<class T> class remove_reference_if_valid
-{
-
-  typedef typename boost::remove_reference<T>::type plainT;
-public:
-  typedef typename IF<
-    boost::is_function<plainT>::value,
-    T,
-    plainT
-  >::RET type;
-
-};
-
-
-template<class T> struct remove_reference_and_cv {
-   typedef typename boost::remove_cv<
-     typename boost::remove_reference<T>::type
-   >::type type;
-};
-
-
-   
-// returns a reference to the element of tuple T
-template<int N, class T> struct tuple_element_as_reference {   
-  typedef typename
-     boost::tuples::access_traits<
-       typename boost::tuples::element<N, T>::type
-     >::non_const_type type;
-};
-
-// returns the cv and reverence stripped type of a tuple element
-template<int N, class T> struct tuple_element_stripped {   
-  typedef typename
-     remove_reference_and_cv<
-       typename boost::tuples::element<N, T>::type
-     >::type type;
-};
-
-// is_lambda_functor -------------------------------------------------   
-
-template <class T> struct is_lambda_functor_ {
-  BOOST_STATIC_CONSTANT(bool, value = false);
-};
-   
-template <class Arg> struct is_lambda_functor_<lambda_functor<Arg> > {
-  BOOST_STATIC_CONSTANT(bool, value = true);
-};
-   
-} // end detail
-
-   
-template <class T> struct is_lambda_functor {
-  BOOST_STATIC_CONSTANT(bool, 
-     value = 
-       detail::is_lambda_functor_<
-         typename detail::remove_reference_and_cv<T>::type
-       >::value);
-};
-   
-
-namespace detail {
-
-// -- parameter_traits_ ---------------------------------------------
-
-// An internal parameter type traits class that respects
-// the reference_wrapper class.
-
-// The conversions performed are:
-// references -> compile_time_error
-// T1 -> T2, 
-// reference_wrapper<T> -> T&
-// const array -> ref to const array
-// array -> ref to array
-// function -> ref to function
-
-// ------------------------------------------------------------------------
-
-template<class T1, class T2> 
-struct parameter_traits_ {
-  typedef T2 type;
-};
-
-// Do not instantiate with reference types
-template<class T, class Any> struct parameter_traits_<T&, Any> {
-  typedef typename 
-    generate_error<T&>::
-      parameter_traits_class_instantiated_with_reference_type type;
-};
-
-// Arrays can't be stored as plain types; convert them to references
-template<class T, int n, class Any> struct parameter_traits_<T[n], Any> {
-  typedef T (&type)[n];
-};
-   
-template<class T, int n, class Any> 
-struct parameter_traits_<const T[n], Any> {
-  typedef const T (&type)[n];
-};
-
-template<class T, int n, class Any> 
-struct parameter_traits_<volatile T[n], Any> {
-  typedef volatile  T (&type)[n];
-};
-template<class T, int n, class Any> 
-struct parameter_traits_<const volatile T[n], Any> {
-  typedef const volatile T (&type)[n];
-};
-
-
-template<class T, class Any> 
-struct parameter_traits_<boost::reference_wrapper<T>, Any >{
-  typedef T& type;
-};
-
-template<class T, class Any> 
-struct parameter_traits_<const boost::reference_wrapper<T>, Any >{
-  typedef T& type;
-};
-
-template<class T, class Any> 
-struct parameter_traits_<volatile boost::reference_wrapper<T>, Any >{
-  typedef T& type;
-};
-
-template<class T, class Any> 
-struct parameter_traits_<const volatile boost::reference_wrapper<T>, Any >{
-  typedef T& type;
-};
-
-template<class Any>
-struct parameter_traits_<void, Any> {
-  typedef void type;
-};
-
-template<class Arg, class Any>
-struct parameter_traits_<lambda_functor<Arg>, Any > {
-  typedef lambda_functor<Arg> type;
-};
-
-template<class Arg, class Any>
-struct parameter_traits_<const lambda_functor<Arg>, Any > {
-  typedef lambda_functor<Arg> type;
-};
-
-// Are the volatile versions needed?
-template<class Arg, class Any>
-struct parameter_traits_<volatile lambda_functor<Arg>, Any > {
-  typedef lambda_functor<Arg> type;
-};
-
-template<class Arg, class Any>
-struct parameter_traits_<const volatile lambda_functor<Arg>, Any > {
-  typedef lambda_functor<Arg> type;
-};
-
-} // end namespace detail
-
-
-// ------------------------------------------------------------------------
-// traits classes for lambda expressions (bind functions, operators ...)   
-
-// must be instantiated with non-reference types
-
-// The default is const plain type -------------------------
-// const T -> const T, 
-// T -> const T, 
-// references -> compile_time_error
-// reference_wrapper<T> -> T&
-// array -> const ref array
-template<class T>
-struct const_copy_argument {
-  typedef typename 
-    detail::parameter_traits_<
-      T,
-      typename detail::IF<boost::is_function<T>::value, T&, const T>::RET
-    >::type type;
-};
-
-// T may be a function type. Without the IF test, const would be added 
-// to a function type, which is illegal.
-
-// all arrays are converted to const.
-// This traits template is used for 'const T&' parameter passing 
-// and thus the knowledge of the potential 
-// non-constness of an actual argument is lost.   
-template<class T, int n>  struct const_copy_argument <T[n]> {
-  typedef const T (&type)[n];
-};
-template<class T, int n>  struct const_copy_argument <volatile T[n]> {
-     typedef const volatile T (&type)[n];
-};
-   
-template<class T>
-struct const_copy_argument<T&> {};
-// do not instantiate with references
-  //  typedef typename detail::generate_error<T&>::references_not_allowed type;
-
-
-template<>
-struct const_copy_argument<void> {
-  typedef void type;
-};
-
-
-// Does the same as const_copy_argument, but passes references through as such
-template<class T>
-struct bound_argument_conversion {
-  typedef typename const_copy_argument<T>::type type; 
-};
-
-template<class T>
-struct bound_argument_conversion<T&> {
-  typedef T& type; 
-};
-   
-// The default is non-const reference -------------------------
-// const T -> const T&, 
-// T -> T&, 
-// references -> compile_time_error
-// reference_wrapper<T> -> T&
-template<class T>
-struct reference_argument {
-  typedef typename detail::parameter_traits_<T, T&>::type type; 
-};
-
-template<class T>
-struct reference_argument<T&> {
-  typedef typename detail::generate_error<T&>::references_not_allowed type; 
-};
-
-template<class Arg>
-struct reference_argument<lambda_functor<Arg> > {
-  typedef lambda_functor<Arg> type;
-};
-
-template<class Arg>
-struct reference_argument<const lambda_functor<Arg> > {
-  typedef lambda_functor<Arg> type;
-};
-
-// Are the volatile versions needed?
-template<class Arg>
-struct reference_argument<volatile lambda_functor<Arg> > {
-  typedef lambda_functor<Arg> type;
-};
-
-template<class Arg>
-struct reference_argument<const volatile lambda_functor<Arg> > {
-  typedef lambda_functor<Arg> type;
-};
-
-template<>
-struct reference_argument<void> {
-  typedef void type;
-};
-
-namespace detail {
-   
-// Array to pointer conversion
-template <class T>
-struct array_to_pointer { 
-  typedef T type;
-};
-
-template <class T, int N>
-struct array_to_pointer <const T[N]> { 
-  typedef const T* type;
-};
-template <class T, int N>
-struct array_to_pointer <T[N]> { 
-  typedef T* type;
-};
-
-template <class T, int N>
-struct array_to_pointer <const T (&) [N]> { 
-  typedef const T* type;
-};
-template <class T, int N>
-struct array_to_pointer <T (&) [N]> { 
-  typedef T* type;
-};
-
-
-// ---------------------------------------------------------------------------
-// The call_traits for bind
-// Respects the reference_wrapper class.
-
-// These templates are used outside of bind functions as well.
-// the bind_tuple_mapper provides a shorter notation for default
-// bound argument storing semantics, if all arguments are treated
-// uniformly.
-
-// from template<class T> foo(const T& t) : bind_traits<const T>::type
-// from template<class T> foo(T& t) : bind_traits<T>::type
-
-// Conversions:
-// T -> const T,
-// cv T -> cv T, 
-// T& -> T& 
-// reference_wrapper<T> -> T&
-// const reference_wrapper<T> -> T&
-// array -> const ref array
-
-// make bound arguments const, this is a deliberate design choice, the
-// purpose is to prevent side effects to bound arguments that are stored
-// as copies
-template<class T>
-struct bind_traits {
-  typedef const T type; 
-};
-
-template<class T>
-struct bind_traits<T&> {
-  typedef T& type; 
-};
-
-// null_types are an exception, we always want to store them as non const
-// so that other templates can assume that null_type is always without const
-template<>
-struct bind_traits<null_type> {
-  typedef null_type type;
-};
-
-// the bind_tuple_mapper, bind_type_generators may 
-// introduce const to null_type
-template<>
-struct bind_traits<const null_type> {
-  typedef null_type type;
-};
-
-// Arrays can't be stored as plain types; convert them to references.
-// All arrays are converted to const. This is because bind takes its
-// parameters as const T& and thus the knowledge of the potential 
-// non-constness of actual argument is lost.
-template<class T, int n>  struct bind_traits <T[n]> {
-  typedef const T (&type)[n];
-};
-
-template<class T, int n> 
-struct bind_traits<const T[n]> {
-  typedef const T (&type)[n];
-};
-
-template<class T, int n>  struct bind_traits<volatile T[n]> {
-  typedef const volatile T (&type)[n];
-};
-
-template<class T, int n> 
-struct bind_traits<const volatile T[n]> {
-  typedef const volatile T (&type)[n];
-};
-
-template<class R>
-struct bind_traits<R()> {
-    typedef R(&type)();
-};
-
-template<class R, class Arg1>
-struct bind_traits<R(Arg1)> {
-    typedef R(&type)(Arg1);
-};
-
-template<class R, class Arg1, class Arg2>
-struct bind_traits<R(Arg1, Arg2)> {
-    typedef R(&type)(Arg1, Arg2);
-};
-
-template<class R, class Arg1, class Arg2, class Arg3>
-struct bind_traits<R(Arg1, Arg2, Arg3)> {
-    typedef R(&type)(Arg1, Arg2, Arg3);
-};
-
-template<class R, class Arg1, class Arg2, class Arg3, class Arg4>
-struct bind_traits<R(Arg1, Arg2, Arg3, Arg4)> {
-    typedef R(&type)(Arg1, Arg2, Arg3, Arg4);
-};
-
-template<class R, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5>
-struct bind_traits<R(Arg1, Arg2, Arg3, Arg4, Arg5)> {
-    typedef R(&type)(Arg1, Arg2, Arg3, Arg4, Arg5);
-};
-
-template<class R, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6>
-struct bind_traits<R(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6)> {
-    typedef R(&type)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6);
-};
-
-template<class R, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7>
-struct bind_traits<R(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7)> {
-    typedef R(&type)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7);
-};
-
-template<class R, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Arg8>
-struct bind_traits<R(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8)> {
-    typedef R(&type)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8);
-};
-
-template<class R, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Arg8, class Arg9>
-struct bind_traits<R(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8, Arg9)> {
-    typedef R(&type)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8, Arg9);
-};
-
-template<class T> 
-struct bind_traits<reference_wrapper<T> >{
-  typedef T& type;
-};
-
-template<class T> 
-struct bind_traits<const reference_wrapper<T> >{
-  typedef T& type;
-};
-
-template<>
-struct bind_traits<void> {
-  typedef void type;
-};
-
-
-
-template <
-  class T0 = null_type, class T1 = null_type, class T2 = null_type, 
-  class T3 = null_type, class T4 = null_type, class T5 = null_type, 
-  class T6 = null_type, class T7 = null_type, class T8 = null_type, 
-  class T9 = null_type
->
-struct bind_tuple_mapper {
-  typedef
-    tuple<typename bind_traits<T0>::type, 
-          typename bind_traits<T1>::type, 
-          typename bind_traits<T2>::type, 
-          typename bind_traits<T3>::type, 
-          typename bind_traits<T4>::type, 
-          typename bind_traits<T5>::type, 
-          typename bind_traits<T6>::type, 
-          typename bind_traits<T7>::type,
-          typename bind_traits<T8>::type,
-          typename bind_traits<T9>::type> type;
-};
-
-// bind_traits, except map const T& -> const T
-  // this is needed e.g. in currying. Const reference arguments can
-  // refer to temporaries, so it is not safe to store them as references.
-  template <class T> struct remove_const_reference {
-    typedef typename bind_traits<T>::type type;
-  };
-
-  template <class T> struct remove_const_reference<const T&> {
-    typedef const T type;
-  };
-
-
-// maps the bind argument types to the resulting lambda functor type
-template <
-  class T0 = null_type, class T1 = null_type, class T2 = null_type, 
-  class T3 = null_type, class T4 = null_type, class T5 = null_type, 
-  class T6 = null_type, class T7 = null_type, class T8 = null_type, 
-  class T9 = null_type
->
-class bind_type_generator {
-
-  typedef typename
-  detail::bind_tuple_mapper<
-    T0, T1, T2, T3, T4, T5, T6, T7, T8, T9
-  >::type args_t;
-
-  BOOST_STATIC_CONSTANT(int, nof_elems = boost::tuples::length<args_t>::value);
-
-  typedef 
-    action<
-      nof_elems, 
-      function_action<nof_elems>
-    > action_type;
-
-public:
-  typedef
-    lambda_functor<
-      lambda_functor_base<
-        action_type, 
-        args_t
-      >
-    > type; 
-    
-};
-
-
-   
-} // detail
-   
-template <class T> inline const T&  make_const(const T& t) { return t; }
-
-
-} // end of namespace lambda
-} // end of namespace boost
-
-
-   
-#endif // BOOST_LAMBDA_TRAITS_HPP