passenger 4.0.20 → 4.0.21

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

@@ -1,139 +0,0 @@
-// -- operator_actions.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 http://lambda.cs.utu.fi 
-
-#ifndef BOOST_LAMBDA_OPERATOR_ACTIONS_HPP
-#define BOOST_LAMBDA_OPERATOR_ACTIONS_HPP
-
-namespace boost { 
-namespace lambda {
-
-
-// -- artihmetic ----------------------
-
-class plus_action {};
-class minus_action {};
-class multiply_action {};
-class divide_action {};
-class remainder_action {};
-
-// -- bitwise  -------------------
-
-class leftshift_action {};
-class rightshift_action {};
-class xor_action {};
-
-
-// -- bitwise/logical -------------------
-
-class and_action {};
-class or_action {};
-class not_action {};
-
-// -- relational -------------------------
-
-class less_action {};
-class greater_action {};
-class lessorequal_action {};
-class greaterorequal_action {};
-class equal_action {};
-class notequal_action {};
-
-// -- increment/decrement ------------------------------
-
-class increment_action {};
-class decrement_action {};
-
-// -- void return ------------------------------
-
-// -- other  ------------------------------
-
-class addressof_action {};
-  // class comma_action {}; // defined in actions.hpp
-class contentsof_action {};
-// class member_pointer_action {}; (defined in member_ptr.hpp)
-
-
-// -- actioun group templates --------------------
-
-template <class Action> class arithmetic_action;
-template <class Action> class bitwise_action;
-template <class Action> class logical_action;
-template <class Action> class relational_action;
-template <class Action> class arithmetic_assignment_action;
-template <class Action> class bitwise_assignment_action;
-template <class Action> class unary_arithmetic_action;
-template <class Action> class pre_increment_decrement_action;
-template <class Action> class post_increment_decrement_action;
-
-// ---------------------------------------------------------
-
-  // actions, for which the existence of protect is checked in return type 
-  // deduction.
-
-template <class Act> struct is_protectable<arithmetic_action<Act> > {
-  BOOST_STATIC_CONSTANT(bool, value = true);
-};
-template <class Act> struct is_protectable<bitwise_action<Act> > {
-  BOOST_STATIC_CONSTANT(bool, value = true);
-};
-template <class Act> struct is_protectable<logical_action<Act> > {
-  BOOST_STATIC_CONSTANT(bool, value = true);
-};
-template <class Act> struct is_protectable<relational_action<Act> > {
-  BOOST_STATIC_CONSTANT(bool, value = true);
-};
-template <class Act> 
-struct is_protectable<arithmetic_assignment_action<Act> > {
-  BOOST_STATIC_CONSTANT(bool, value = true);
-};
-template <class Act> struct is_protectable<bitwise_assignment_action<Act> > {
-  BOOST_STATIC_CONSTANT(bool, value = true);
-};
-template <class Act> struct is_protectable<unary_arithmetic_action<Act> > {
-  BOOST_STATIC_CONSTANT(bool, value = true);
-};
-template <class Act> 
-struct is_protectable<pre_increment_decrement_action<Act> > {
-  BOOST_STATIC_CONSTANT(bool, value = true);
-};
-template <class Act> struct 
-is_protectable<post_increment_decrement_action<Act> > {
-  BOOST_STATIC_CONSTANT(bool, value = true);
-};
-
-template <> struct is_protectable<other_action<addressof_action> > {
-  BOOST_STATIC_CONSTANT(bool, value = true);
-};
-template <> struct is_protectable<other_action<contentsof_action> > {
-  BOOST_STATIC_CONSTANT(bool, value = true);
-};
-
-template<> struct is_protectable<other_action<subscript_action> > {
-  BOOST_STATIC_CONSTANT(bool, value = true);
-};
-template<> struct is_protectable<other_action<assignment_action> > {
-  BOOST_STATIC_CONSTANT(bool, value = true);
-};
-
-// NOTE: comma action is also protectable, but the specialization is
-  // in actions.hpp
-
-
-} // namespace lambda 
-} // namespace boost
-
-#endif
-
-
-
-
-
-
-

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

@@ -1,271 +0,0 @@
-// Boost Lambda Library  - operator_lambda_func_base.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_OPERATOR_LAMBDA_FUNC_BASE_HPP
-#define BOOST_LAMBDA_OPERATOR_LAMBDA_FUNC_BASE_HPP
-
-namespace boost { 
-namespace lambda {
-
-
-// These operators cannot be implemented as apply functions of action 
-// templates
-
-
-// Specialization for comma.
-template<class Args>
-class lambda_functor_base<other_action<comma_action>, Args> {
-public:
-  Args args;
-public:
-  explicit lambda_functor_base(const Args& a) : args(a) {}
-
-  template<class RET, CALL_TEMPLATE_ARGS>
-  RET call(CALL_FORMAL_ARGS) const {
-    return detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS), 
-           detail::select(boost::tuples::get<1>(args), CALL_ACTUAL_ARGS); 
-  }
-
-
-  template<class SigArgs> struct sig { 
-  private:
-    typedef typename
-      detail::deduce_argument_types<Args, SigArgs>::type rets_t;      
-  public:
-    typedef typename return_type_2_comma< // comma needs special handling
-      typename detail::element_or_null<0, rets_t>::type,
-      typename detail::element_or_null<1, rets_t>::type
-    >::type type;
-  };
-
-};  
-
-namespace detail {
-
-// helper traits to make the expression shorter, takes binary action
-// bound argument tuple, open argument tuple and gives the return type
-
-template<class Action, class Bound, class Open> class binary_rt {
-  private:
-    typedef typename
-      detail::deduce_argument_types<Bound, Open>::type rets_t;      
-  public:
-    typedef typename return_type_2_prot<
-      Action,  
-      typename detail::element_or_null<0, rets_t>::type,
-      typename detail::element_or_null<1, rets_t>::type
-    >::type type;
-};
-
-
-  // same for unary actions
-template<class Action, class Bound, class Open> class unary_rt {
-  private:
-    typedef typename
-      detail::deduce_argument_types<Bound, Open>::type rets_t;      
-  public:
-    typedef typename return_type_1_prot<
-      Action,  
-      typename detail::element_or_null<0, rets_t>::type
-    >::type type;
-};
-
-
-} // end detail
-
-// Specialization for logical and (to preserve shortcircuiting)
-// this could be done with a macro as the others, code used to be different
-template<class Args>
-class lambda_functor_base<logical_action<and_action>, Args> {
-public:
-  Args args;
-public:
-  explicit lambda_functor_base(const Args& a) : args(a) {}
-
-  template<class RET, CALL_TEMPLATE_ARGS>
-  RET call(CALL_FORMAL_ARGS) const {
-    return detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS) && 
-           detail::select(boost::tuples::get<1>(args), CALL_ACTUAL_ARGS); 
-  }
-  template<class SigArgs> struct sig { 
-    typedef typename
-      detail::binary_rt<logical_action<and_action>, Args, SigArgs>::type type;
-  };      
-};  
-
-// Specialization for logical or (to preserve shortcircuiting)
-// this could be done with a macro as the others, code used to be different
-template<class Args>
-class lambda_functor_base<logical_action< or_action>, Args> {
-public:
-  Args args;
-public:
-  explicit lambda_functor_base(const Args& a) : args(a) {}
-
-  template<class RET, CALL_TEMPLATE_ARGS>
-  RET call(CALL_FORMAL_ARGS) const {
-    return detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS) || 
-           detail::select(boost::tuples::get<1>(args), CALL_ACTUAL_ARGS); 
-  }
-
-  template<class SigArgs> struct sig { 
-    typedef typename
-      detail::binary_rt<logical_action<or_action>, Args, SigArgs>::type type;
-  };      
-};  
-
-// Specialization for subscript
-template<class Args>
-class lambda_functor_base<other_action<subscript_action>, Args> {
-public:
-  Args args;
-public:
-  explicit lambda_functor_base(const Args& a) : args(a) {}
-
-  template<class RET, CALL_TEMPLATE_ARGS>
-  RET call(CALL_FORMAL_ARGS) const {
-    return detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS) 
-           [detail::select(boost::tuples::get<1>(args), CALL_ACTUAL_ARGS)]; 
-  }
-
-  template<class SigArgs> struct sig { 
-    typedef typename
-      detail::binary_rt<other_action<subscript_action>, Args, SigArgs>::type 
-        type;
-  };      
-};  
-
-
-#define BOOST_LAMBDA_BINARY_ACTION(SYMBOL, ACTION_CLASS)  \
-template<class Args>                                                      \
-class lambda_functor_base<ACTION_CLASS, Args> {                           \
-public:                                                                   \
-  Args args;                                                              \
-public:                                                                   \
-  explicit lambda_functor_base(const Args& a) : args(a) {}                \
-                                                                          \
-  template<class RET, CALL_TEMPLATE_ARGS>                                 \
-  RET call(CALL_FORMAL_ARGS) const {                                      \
-    return detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS)  \
-           SYMBOL                                                         \
-           detail::select(boost::tuples::get<1>(args), CALL_ACTUAL_ARGS); \
-  }                                                                       \
-  template<class SigArgs> struct sig {                                    \
-    typedef typename                                                      \
-      detail::binary_rt<ACTION_CLASS, Args, SigArgs>::type type;          \
-  };                                                                      \
-};  
-
-#define BOOST_LAMBDA_PREFIX_UNARY_ACTION(SYMBOL, ACTION_CLASS)            \
-template<class Args>                                                      \
-class lambda_functor_base<ACTION_CLASS, Args> {                           \
-public:                                                                   \
-  Args args;                                                              \
-public:                                                                   \
-  explicit lambda_functor_base(const Args& a) : args(a) {}                \
-                                                                          \
-  template<class RET, CALL_TEMPLATE_ARGS>                                 \
-  RET call(CALL_FORMAL_ARGS) const {                                      \
-    return SYMBOL                                                         \
-           detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS); \
-  }                                                                       \
-  template<class SigArgs> struct sig {                                    \
-    typedef typename                                                      \
-      detail::unary_rt<ACTION_CLASS, Args, SigArgs>::type type;           \
-  };                                                                      \
-};  
-
-#define BOOST_LAMBDA_POSTFIX_UNARY_ACTION(SYMBOL, ACTION_CLASS)           \
-template<class Args>                                                      \
-class lambda_functor_base<ACTION_CLASS, Args> {                           \
-public:                                                                   \
-  Args args;                                                              \
-public:                                                                   \
-  explicit lambda_functor_base(const Args& a) : args(a) {}                \
-                                                                          \
-  template<class RET, CALL_TEMPLATE_ARGS>                                 \
-  RET call(CALL_FORMAL_ARGS) const {                                      \
-    return                                                                \
-    detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS) SYMBOL; \
-  }                                                                       \
-  template<class SigArgs> struct sig {                                    \
-    typedef typename                                                      \
-      detail::unary_rt<ACTION_CLASS, Args, SigArgs>::type type;           \
-  };                                                                      \
-};  
-
-BOOST_LAMBDA_BINARY_ACTION(+,arithmetic_action<plus_action>)
-BOOST_LAMBDA_BINARY_ACTION(-,arithmetic_action<minus_action>)
-BOOST_LAMBDA_BINARY_ACTION(*,arithmetic_action<multiply_action>)
-BOOST_LAMBDA_BINARY_ACTION(/,arithmetic_action<divide_action>)
-BOOST_LAMBDA_BINARY_ACTION(%,arithmetic_action<remainder_action>)
-
-BOOST_LAMBDA_BINARY_ACTION(<<,bitwise_action<leftshift_action>)
-BOOST_LAMBDA_BINARY_ACTION(>>,bitwise_action<rightshift_action>)
-BOOST_LAMBDA_BINARY_ACTION(&,bitwise_action<and_action>)
-BOOST_LAMBDA_BINARY_ACTION(|,bitwise_action<or_action>)
-BOOST_LAMBDA_BINARY_ACTION(^,bitwise_action<xor_action>)
-
-BOOST_LAMBDA_BINARY_ACTION(<,relational_action<less_action>)
-BOOST_LAMBDA_BINARY_ACTION(>,relational_action<greater_action>)
-BOOST_LAMBDA_BINARY_ACTION(<=,relational_action<lessorequal_action>)
-BOOST_LAMBDA_BINARY_ACTION(>=,relational_action<greaterorequal_action>)
-BOOST_LAMBDA_BINARY_ACTION(==,relational_action<equal_action>)
-BOOST_LAMBDA_BINARY_ACTION(!=,relational_action<notequal_action>)
-
-BOOST_LAMBDA_BINARY_ACTION(+=,arithmetic_assignment_action<plus_action>)
-BOOST_LAMBDA_BINARY_ACTION(-=,arithmetic_assignment_action<minus_action>)
-BOOST_LAMBDA_BINARY_ACTION(*=,arithmetic_assignment_action<multiply_action>)
-BOOST_LAMBDA_BINARY_ACTION(/=,arithmetic_assignment_action<divide_action>)
-BOOST_LAMBDA_BINARY_ACTION(%=,arithmetic_assignment_action<remainder_action>)
-
-BOOST_LAMBDA_BINARY_ACTION(<<=,bitwise_assignment_action<leftshift_action>)
-BOOST_LAMBDA_BINARY_ACTION(>>=,bitwise_assignment_action<rightshift_action>)
-BOOST_LAMBDA_BINARY_ACTION(&=,bitwise_assignment_action<and_action>)
-BOOST_LAMBDA_BINARY_ACTION(|=,bitwise_assignment_action<or_action>)
-BOOST_LAMBDA_BINARY_ACTION(^=,bitwise_assignment_action<xor_action>)
-
-BOOST_LAMBDA_BINARY_ACTION(=,other_action< assignment_action>)
-
-
-BOOST_LAMBDA_PREFIX_UNARY_ACTION(+, unary_arithmetic_action<plus_action>)
-BOOST_LAMBDA_PREFIX_UNARY_ACTION(-, unary_arithmetic_action<minus_action>)
-BOOST_LAMBDA_PREFIX_UNARY_ACTION(~, bitwise_action<not_action>)
-BOOST_LAMBDA_PREFIX_UNARY_ACTION(!, logical_action<not_action>)
-BOOST_LAMBDA_PREFIX_UNARY_ACTION(++, pre_increment_decrement_action<increment_action>)
-BOOST_LAMBDA_PREFIX_UNARY_ACTION(--, pre_increment_decrement_action<decrement_action>)
-
-BOOST_LAMBDA_PREFIX_UNARY_ACTION(&,other_action<addressof_action>)
-BOOST_LAMBDA_PREFIX_UNARY_ACTION(*,other_action<contentsof_action>)
-
-BOOST_LAMBDA_POSTFIX_UNARY_ACTION(++, post_increment_decrement_action<increment_action>)
-BOOST_LAMBDA_POSTFIX_UNARY_ACTION(--, post_increment_decrement_action<decrement_action>)
-
-
-#undef BOOST_LAMBDA_POSTFIX_UNARY_ACTION
-#undef BOOST_LAMBDA_PREFIX_UNARY_ACTION
-#undef BOOST_LAMBDA_BINARY_ACTION
-
-} // namespace lambda
-} // namespace boost
-
-#endif
-
-
-
-
-
-
-
-
-
-

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

@@ -1,917 +0,0 @@
-//  operator_return_type_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_OPERATOR_RETURN_TYPE_TRAITS_HPP
-#define BOOST_LAMBDA_OPERATOR_RETURN_TYPE_TRAITS_HPP
-
-#include "boost/lambda/detail/is_instance_of.hpp"
-#include "boost/type_traits/same_traits.hpp"
-
-#include "boost/indirect_reference.hpp"
-#include "boost/detail/container_fwd.hpp"
-
-#include <cstddef> // needed for the ptrdiff_t
-#include <iosfwd>  // for istream and ostream
-
-#include <iterator> // needed for operator&
-
-namespace boost { 
-namespace lambda {
-namespace detail {
-
-// -- general helper templates for type deduction ------------------
-
-// Much of the type deduction code for standard arithmetic types from Gary Powell
-
-template <class A> struct promote_code { static const int value = -1; };
-// this means that a code is not defined for A
-
-// -- the next 5 types are needed in if_then_else_return 
-// the promotion order is not important, but they must have distinct values.
-template <> struct promote_code<bool> { static const int value = 10; };
-template <> struct promote_code<char> { static const int value = 20; };
-template <> struct promote_code<unsigned char> { static const int value = 30; };
-template <> struct promote_code<signed char> { static const int value = 40; };
-template <> struct promote_code<short int> { static const int value = 50; };
-// ----------
-
-template <> struct promote_code<int> { static const int value = 100; };
-template <> struct promote_code<unsigned int> { static const int value = 200; };
-template <> struct promote_code<long> { static const int value = 300; };
-template <> struct promote_code<unsigned long> { static const int value = 400; };
-
-template <> struct promote_code<float> { static const int value = 500; };
-template <> struct promote_code<double> { static const int value = 600; };
-template <> struct promote_code<long double> { static const int value = 700; };
-
-// TODO: wchar_t
-
-// forward delcaration of complex.
-
-} // namespace detail
-} // namespace lambda 
-} // namespace boost
-
-namespace boost { 
-namespace lambda {
-namespace detail {
-
-template <> struct promote_code< std::complex<float> > { static const int value = 800; };
-template <> struct promote_code< std::complex<double> > { static const int value = 900; };
-template <> struct promote_code< std::complex<long double> > { static const int value = 1000; };
-
-// -- int promotion -------------------------------------------
-template <class T> struct promote_to_int { typedef T type; };
-
-template <> struct promote_to_int<bool> { typedef int type; };
-template <> struct promote_to_int<char> { typedef int type; };
-template <> struct promote_to_int<unsigned char> { typedef int type; };
-template <> struct promote_to_int<signed char> { typedef int type; };
-template <> struct promote_to_int<short int> { typedef int type; };
-
-// The unsigned short int promotion rule is this:
-// unsigned short int to signed int if a signed int can hold all values 
-// of unsigned short int, otherwise go to unsigned int.
-template <> struct promote_to_int<unsigned short int>
-{ 
-        typedef
-                detail::IF<sizeof(int) <= sizeof(unsigned short int),        
-// I had the logic reversed but ">" messes up the parsing.
-                unsigned int,
-                int>::RET type; 
-};
-
-
-// TODO: think, should there be default behaviour for non-standard types?
-
-} // namespace detail
-
-// ------------------------------------------ 
-// Unary actions ----------------------------
-// ------------------------------------------ 
-
-template<class Act, class A>
-struct plain_return_type_1 {
-  typedef detail::unspecified type;
-};
-
-
-
-template<class Act, class A>
-struct plain_return_type_1<unary_arithmetic_action<Act>, A> {
-  typedef A type;
-};
-
-template<class Act, class A> 
-struct return_type_1<unary_arithmetic_action<Act>, A> { 
-  typedef 
-    typename plain_return_type_1<
-      unary_arithmetic_action<Act>,
-      typename detail::remove_reference_and_cv<A>::type
-    >::type type;
-};
-
-
-template<class A>
-struct plain_return_type_1<bitwise_action<not_action>, A> {
-  typedef A type;
-};
-
-// bitwise not, operator~()
-template<class A> struct return_type_1<bitwise_action<not_action>, A> {
-  typedef 
-    typename plain_return_type_1<
-      bitwise_action<not_action>,
-      typename detail::remove_reference_and_cv<A>::type
-    >::type type;
-};
-
-
-// prefix increment and decrement operators return 
-// their argument by default as a non-const reference
-template<class Act, class A> 
-struct plain_return_type_1<pre_increment_decrement_action<Act>, A> {
-  typedef A& type;
-};
-
-template<class Act, class A> 
-struct return_type_1<pre_increment_decrement_action<Act>, A> {
-  typedef 
-    typename plain_return_type_1<
-      pre_increment_decrement_action<Act>,
-      typename detail::remove_reference_and_cv<A>::type
-    >::type type;
-};
-
-// post decrement just returns the same plain type.
-template<class Act, class A>
-struct plain_return_type_1<post_increment_decrement_action<Act>, A> {
-  typedef A type;
-};
-
-template<class Act, class A> 
-struct return_type_1<post_increment_decrement_action<Act>, A> 
-{ 
-  typedef 
-    typename plain_return_type_1<
-      post_increment_decrement_action<Act>,
-      typename detail::remove_reference_and_cv<A>::type
-    >::type type;
-};
-
-// logical not, operator!()
-template<class A> 
-struct plain_return_type_1<logical_action<not_action>, A> {
-  typedef bool type;
-};
-
-template<class A>
-struct return_type_1<logical_action<not_action>, A> {
-  typedef 
-    typename plain_return_type_1<
-      logical_action<not_action>,
-      typename detail::remove_reference_and_cv<A>::type
-    >::type type;
-};
-
-// address of action ---------------------------------------
-
-
-template<class A> 
-struct return_type_1<other_action<addressof_action>, A> { 
-  typedef 
-    typename plain_return_type_1<
-      other_action<addressof_action>, 
-      typename detail::remove_reference_and_cv<A>::type
-    >::type type1;
-
-  // If no user defined specialization for A, then return the
-  // cv qualified pointer to A
-  typedef typename detail::IF<
-    boost::is_same<type1, detail::unspecified>::value, 
-    typename boost::remove_reference<A>::type*,
-    type1
-  >::RET type;
-};
-
-// contentsof action ------------------------------------
-
-// TODO: this deduction may lead to fail directly, 
-// (if A has no specialization for iterator_traits and has no
-// typedef A::reference.
-// There is no easy way around this, cause there doesn't seem to be a way
-// to test whether a class is an iterator or not.
- 
-// The default works with std::iterators.
-
-namespace detail {
-
-  // A is a nonreference type
-template <class A> struct contentsof_type {
-  typedef typename boost::indirect_reference<A>::type type; 
-};
-
-  // this is since the nullary () in lambda_functor is always instantiated
-template <> struct contentsof_type<null_type> {
-  typedef detail::unspecified type;
-};
-
-
-template <class A> struct contentsof_type<const A> {
-  typedef typename contentsof_type<A>::type type;
-};
-
-template <class A> struct contentsof_type<volatile A> {
-  typedef typename contentsof_type<A>::type type;
-};
-
-template <class A> struct contentsof_type<const volatile A> {
-  typedef typename contentsof_type<A>::type type;
-};
-
-  // standard iterator traits should take care of the pointer types 
-  // but just to be on the safe side, we have the specializations here:
-  // these work even if A is cv-qualified.
-template <class A> struct contentsof_type<A*> {
-  typedef A& type;
-};
-template <class A> struct contentsof_type<A* const> {
-  typedef A& type;
-};
-template <class A> struct contentsof_type<A* volatile> {
-  typedef A& type;
-};
-template <class A> struct contentsof_type<A* const volatile> {
-  typedef A& type;
-};
-
-template<class A, int N> struct contentsof_type<A[N]> { 
-  typedef A& type; 
-};
-template<class A, int N> struct contentsof_type<const A[N]> { 
-  typedef const A& type; 
-};
-template<class A, int N> struct contentsof_type<volatile A[N]> { 
-  typedef volatile A& type; 
-};
-template<class A, int N> struct contentsof_type<const volatile A[N]> { 
-  typedef const volatile A& type; 
-};
-
-
-
-
-
-} // end detail
-
-template<class A> 
-struct return_type_1<other_action<contentsof_action>, A> { 
-
-  typedef 
-    typename plain_return_type_1<
-      other_action<contentsof_action>, 
-      typename detail::remove_reference_and_cv<A>::type
-    >::type type1;
-
-  // If no user defined specialization for A, then return the
-  // cv qualified pointer to A
-  typedef typename 
-  detail::IF_type<
-    boost::is_same<type1, detail::unspecified>::value, 
-    detail::contentsof_type<
-      typename boost::remove_reference<A>::type
-    >,
-    detail::identity_mapping<type1>
-  >::type type;
-};
-
-
-// ------------------------------------------------------------------
-// binary actions ---------------------------------------------------
-// ------------------------------------------------------------------
-
-// here the default case is: no user defined versions:
-template <class Act, class A, class B>
-struct plain_return_type_2 {
-  typedef detail::unspecified type; 
-};
-
-namespace detail {
-
-// error classes
-class illegal_pointer_arithmetic{};
-
-// pointer arithmetic type deductions ----------------------
-// value = false means that this is not a pointer arithmetic case
-// value = true means, that this can be a pointer arithmetic case, but not necessarily is
-// This means, that for user defined operators for pointer types, say for some operator+(X, *Y),
-// the deductions must be coded at an earliel level (return_type_2).
-
-template<class Act, class A, class B> 
-struct pointer_arithmetic_traits { static const bool value = false; };
-
-template<class A, class B> 
-struct pointer_arithmetic_traits<plus_action, A, B> { 
-
-  typedef typename 
-    array_to_pointer<typename boost::remove_reference<A>::type>::type AP;
-  typedef typename 
-    array_to_pointer<typename boost::remove_reference<B>::type>::type BP;
-
-  static const bool is_pointer_A = boost::is_pointer<AP>::value;
-  static const bool is_pointer_B = boost::is_pointer<BP>::value;  
-
-  static const bool value = is_pointer_A || is_pointer_B;
-
-  // can't add two pointers.
-  // note, that we do not check wether the other type is valid for 
-  // addition with a pointer.
-  // the compiler will catch it in the apply function
-
-  typedef typename 
-  detail::IF<
-    is_pointer_A && is_pointer_B, 
-      detail::return_type_deduction_failure<
-        detail::illegal_pointer_arithmetic
-      >,
-      typename detail::IF<is_pointer_A, AP, BP>::RET
-  >::RET type; 
-
-};
-
-template<class A, class B> 
-struct pointer_arithmetic_traits<minus_action, A, B> { 
-  typedef typename 
-    array_to_pointer<typename boost::remove_reference<A>::type>::type AP;
-  typedef typename 
-    array_to_pointer<typename boost::remove_reference<B>::type>::type BP;
-
-  static const bool is_pointer_A = boost::is_pointer<AP>::value;
-  static const bool is_pointer_B = boost::is_pointer<BP>::value;  
-
-  static const bool value = is_pointer_A || is_pointer_B;
-
-  static const bool same_pointer_type =
-    is_pointer_A && is_pointer_B && 
-    boost::is_same<
-      typename boost::remove_const<
-        typename boost::remove_pointer<
-          typename boost::remove_const<AP>::type
-        >::type
-      >::type,
-      typename boost::remove_const<
-        typename boost::remove_pointer<
-          typename boost::remove_const<BP>::type
-        >::type
-      >::type
-    >::value;
-
-  // ptr - ptr has type ptrdiff_t
-  // note, that we do not check if, in ptr - B, B is 
-  // valid for subtraction with a pointer.
-  // the compiler will catch it in the apply function
-
-  typedef typename 
-  detail::IF<
-    same_pointer_type, const std::ptrdiff_t,
-    typename detail::IF<
-      is_pointer_A, 
-      AP, 
-      detail::return_type_deduction_failure<detail::illegal_pointer_arithmetic>
-    >::RET
-  >::RET type; 
-};
-
-} // namespace detail
-   
-// -- arithmetic actions ---------------------------------------------
-
-namespace detail {
-   
-template<bool is_pointer_arithmetic, class Act, class A, class B> 
-struct return_type_2_arithmetic_phase_1;
-
-template<class A, class B> struct return_type_2_arithmetic_phase_2;
-template<class A, class B> struct return_type_2_arithmetic_phase_3;
-
-} // namespace detail
-  
-
-// drop any qualifiers from the argument types within arithmetic_action
-template<class A, class B, class Act> 
-struct return_type_2<arithmetic_action<Act>, A, B>
-{
-  typedef typename detail::remove_reference_and_cv<A>::type plain_A;
-  typedef typename detail::remove_reference_and_cv<B>::type plain_B;
-
-  typedef typename 
-    plain_return_type_2<arithmetic_action<Act>, plain_A, plain_B>::type type1;
-  
-  // if user defined return type, do not enter the whole arithmetic deductions
-  typedef typename 
-    detail::IF_type<
-      boost::is_same<type1, detail::unspecified>::value, 
-      detail::return_type_2_arithmetic_phase_1<
-         detail::pointer_arithmetic_traits<Act, A, B>::value, Act, A, B
-      >,
-      plain_return_type_2<arithmetic_action<Act>, plain_A, plain_B>
-    >::type type;
-};
-
-namespace detail {
-   
-// perform integral promotion, no pointer arithmetic
-template<bool is_pointer_arithmetic, class Act, class A, class B> 
-struct return_type_2_arithmetic_phase_1
-{
-  typedef typename 
-    return_type_2_arithmetic_phase_2<
-      typename remove_reference_and_cv<A>::type,
-      typename remove_reference_and_cv<B>::type
-    >::type type;
-};
-
-// pointer_arithmetic
-template<class Act, class A, class B> 
-struct return_type_2_arithmetic_phase_1<true, Act, A, B>
-{
-  typedef typename 
-    pointer_arithmetic_traits<Act, A, B>::type type;
-};
-
-template<class A, class B>
-struct return_type_2_arithmetic_phase_2 {
-  typedef typename
-    return_type_2_arithmetic_phase_3<
-      typename promote_to_int<A>::type, 
-      typename promote_to_int<B>::type
-    >::type type;
-};
-
-// specialization for unsigned int.
-// We only have to do these two specialization because the value promotion will
-// take care of the other cases.
-// The unsigned int promotion rule is this:
-// unsigned int to long if a long can hold all values of unsigned int,
-// otherwise go to unsigned long.
-
-// struct so I don't have to type this twice.
-struct promotion_of_unsigned_int
-{
-        typedef
-        detail::IF<sizeof(long) <= sizeof(unsigned int),        
-                unsigned long,
-                long>::RET type; 
-};
-
-template<>
-struct return_type_2_arithmetic_phase_2<unsigned int, long>
-{
-        typedef promotion_of_unsigned_int::type type;
-};
-template<>
-struct return_type_2_arithmetic_phase_2<long, unsigned int>
-{
-        typedef promotion_of_unsigned_int::type type;
-};
-
-
-template<class A, class B> struct return_type_2_arithmetic_phase_3 { 
-   enum { promote_code_A_value = promote_code<A>::value,
-         promote_code_B_value = promote_code<B>::value }; // enums for KCC
-  typedef typename
-    detail::IF<
-      promote_code_A_value == -1 || promote_code_B_value == -1,
-      detail::return_type_deduction_failure<return_type_2_arithmetic_phase_3>,
-      typename detail::IF<
-        ((int)promote_code_A_value > (int)promote_code_B_value), 
-        A, 
-        B
-      >::RET
-    >::RET type;                    
-};
-
-} // namespace detail
-
-// --  bitwise actions -------------------------------------------
-// note: for integral types deuduction is similar to arithmetic actions. 
-
-// drop any qualifiers from the argument types within arithmetic action
-template<class A, class B, class Act> 
-struct return_type_2<bitwise_action<Act>, A, B>
-{
-
-  typedef typename detail::remove_reference_and_cv<A>::type plain_A;
-  typedef typename detail::remove_reference_and_cv<B>::type plain_B;
-
-  typedef typename 
-    plain_return_type_2<bitwise_action<Act>, plain_A, plain_B>::type type1;
-  
-  // if user defined return type, do not enter type deductions
-  typedef typename 
-    detail::IF_type<
-      boost::is_same<type1, detail::unspecified>::value, 
-      return_type_2<arithmetic_action<plus_action>, A, B>,
-      plain_return_type_2<bitwise_action<Act>, plain_A, plain_B>
-    >::type type;
-
-  // plus_action is just a random pick, has to be a concrete instance
-
-  // TODO: This check is only valid for built-in types, overloaded types might
-  // accept floating point operators
-
-  // bitwise operators not defined for floating point types
-  // these test are not strictly needed here, since the error will be caught in
-  // the apply function
-  BOOST_STATIC_ASSERT(!(boost::is_float<plain_A>::value && boost::is_float<plain_B>::value));
-
-};
-
-namespace detail {
-
-#ifdef BOOST_NO_TEMPLATED_STREAMS
-
-template<class A, class B>
-struct leftshift_type {
-
-  typedef typename detail::IF<
-    boost::is_convertible<
-      typename boost::remove_reference<A>::type*,
-      std::ostream*
-    >::value,
-    std::ostream&, 
-    typename detail::remove_reference_and_cv<A>::type
-  >::RET type;
-};
-
-template<class A, class B>
-struct rightshift_type {
-
-  typedef typename detail::IF<
-
-    boost::is_convertible<
-      typename boost::remove_reference<A>::type*,
-      std::istream*
-    >::value, 
-    std::istream&,
-    typename detail::remove_reference_and_cv<A>::type
-  >::RET type;
-};
-
-#else
-
-template <class T> struct get_ostream_type {
-  typedef std::basic_ostream<typename T::char_type, 
-                             typename T::traits_type>& type;
-};
-
-template <class T> struct get_istream_type {
-  typedef std::basic_istream<typename T::char_type, 
-                             typename T::traits_type>& type;
-};
-
-template<class A, class B>
-struct leftshift_type {
-private:
-  typedef typename boost::remove_reference<A>::type plainA;
-public:
-  typedef typename detail::IF_type<
-    is_instance_of_2<plainA, std::basic_ostream>::value, 
-    get_ostream_type<plainA>, //reference to the stream 
-    detail::remove_reference_and_cv<A>
-  >::type type;
-};
-
-template<class A, class B>
-struct rightshift_type {
-private:
-  typedef typename boost::remove_reference<A>::type plainA;
-public:
-  typedef typename detail::IF_type<
-    is_instance_of_2<plainA, std::basic_istream>::value, 
-    get_istream_type<plainA>, //reference to the stream 
-    detail::remove_reference_and_cv<A>
-  >::type type;
-};
-
-
-#endif
-
-} // end detail
-
-// ostream
-template<class A, class B> 
-struct return_type_2<bitwise_action<leftshift_action>, A, B>
-{
-  typedef typename detail::remove_reference_and_cv<A>::type plain_A;
-  typedef typename detail::remove_reference_and_cv<B>::type plain_B;
-
-  typedef typename 
-    plain_return_type_2<bitwise_action<leftshift_action>, plain_A, plain_B>::type type1;
-  
-  // if user defined return type, do not enter type deductions
-  typedef typename 
-    detail::IF_type<
-      boost::is_same<type1, detail::unspecified>::value, 
-      detail::leftshift_type<A, B>,
-      plain_return_type_2<bitwise_action<leftshift_action>, plain_A, plain_B>
-    >::type type;
-};
-
-// istream
-template<class A, class B> 
-struct return_type_2<bitwise_action<rightshift_action>, A, B>
-{
-  typedef typename detail::remove_reference_and_cv<A>::type plain_A;
-  typedef typename detail::remove_reference_and_cv<B>::type plain_B;
-
-  typedef typename 
-    plain_return_type_2<bitwise_action<rightshift_action>, plain_A, plain_B>::type type1;
-  
-  // if user defined return type, do not enter type deductions
-  typedef typename 
-    detail::IF_type<
-      boost::is_same<type1, detail::unspecified>::value, 
-      detail::rightshift_type<A, B>,
-      plain_return_type_2<bitwise_action<rightshift_action>, plain_A, plain_B>
-    >::type type;
-};
-
-// -- logical actions ----------------------------------------
-// always bool
-// NOTE: this may not be true for some weird user-defined types,
-template<class A, class B, class Act> 
-struct plain_return_type_2<logical_action<Act>, A, B> { 
-  typedef bool type; 
-};
-
-template<class A, class B, class Act> 
-struct return_type_2<logical_action<Act>, A, B> { 
-
-  typedef typename detail::remove_reference_and_cv<A>::type plain_A;
-  typedef typename detail::remove_reference_and_cv<B>::type plain_B;
-
-  typedef typename 
-    plain_return_type_2<logical_action<Act>, plain_A, plain_B>::type type;
-  
-};
-
-
-// -- relational actions ----------------------------------------
-// always bool
-// NOTE: this may not be true for some weird user-defined types,
-template<class A, class B, class Act> 
-struct plain_return_type_2<relational_action<Act>, A, B> { 
-  typedef bool type; 
-};
-
-template<class A, class B, class Act> 
-struct return_type_2<relational_action<Act>, A, B> { 
-
-  typedef typename detail::remove_reference_and_cv<A>::type plain_A;
-  typedef typename detail::remove_reference_and_cv<B>::type plain_B;
-
-  typedef typename 
-    plain_return_type_2<relational_action<Act>, plain_A, plain_B>::type type; 
-};
-
-// Assingment actions -----------------------------------------------
-// return type is the type of the first argument as reference
-
-// note that cv-qualifiers are preserved.
-// Yes, assignment operator can be const!
-
-// NOTE: this may not be true for some weird user-defined types,
-
-template<class A, class B, class Act> 
-struct return_type_2<arithmetic_assignment_action<Act>, A, B> { 
-
-  typedef typename detail::remove_reference_and_cv<A>::type plain_A;
-  typedef typename detail::remove_reference_and_cv<B>::type plain_B;
-
-  typedef typename 
-    plain_return_type_2<
-      arithmetic_assignment_action<Act>, plain_A, plain_B
-    >::type type1;
-  
-  typedef typename 
-    detail::IF<
-      boost::is_same<type1, detail::unspecified>::value, 
-      typename boost::add_reference<A>::type,
-      type1
-    >::RET type;
-};
-
-template<class A, class B, class Act> 
-struct return_type_2<bitwise_assignment_action<Act>, A, B> { 
-
-  typedef typename detail::remove_reference_and_cv<A>::type plain_A;
-  typedef typename detail::remove_reference_and_cv<B>::type plain_B;
-
-  typedef typename 
-    plain_return_type_2<
-      bitwise_assignment_action<Act>, plain_A, plain_B
-    >::type type1;
-  
-  typedef typename 
-    detail::IF<
-      boost::is_same<type1, detail::unspecified>::value, 
-      typename boost::add_reference<A>::type,
-      type1
-    >::RET type;
-};
-
-template<class A, class B> 
-struct return_type_2<other_action<assignment_action>, A, B> { 
-  typedef typename detail::remove_reference_and_cv<A>::type plain_A;
-  typedef typename detail::remove_reference_and_cv<B>::type plain_B;
-
-  typedef typename 
-    plain_return_type_2<
-      other_action<assignment_action>, plain_A, plain_B
-    >::type type1;
-  
-  typedef typename 
-    detail::IF<
-      boost::is_same<type1, detail::unspecified>::value, 
-      typename boost::add_reference<A>::type,
-      type1
-    >::RET type;
-};
-
-// -- other actions ----------------------------------------
-
-// comma action ----------------------------------
-// Note: this may not be true for some weird user-defined types,
-
-// NOTE! This only tries the plain_return_type_2 layer and gives
-// detail::unspecified as default. If no such specialization is found, the 
-// type rule in the spcecialization of the return_type_2_prot is used
-// to give the type of the right argument (which can be a reference too)
-// (The built in operator, can return a l- or rvalue).
-template<class A, class B> 
-struct return_type_2<other_action<comma_action>, A, B> { 
-
-  typedef typename detail::remove_reference_and_cv<A>::type plain_A;
-  typedef typename detail::remove_reference_and_cv<B>::type plain_B;
-
-  typedef typename 
-    plain_return_type_2<
-      other_action<comma_action>, plain_A, plain_B
-    >::type type;
-  };
-
-// subscript action -----------------------------------------------
-
-
-namespace detail {
-  // A and B are nonreference types
-template <class A, class B> struct subscript_type {
-  typedef detail::unspecified type; 
-};
-
-template <class A, class B> struct subscript_type<A*, B> {
-  typedef A& type;
-};
-template <class A, class B> struct subscript_type<A* const, B> {
-  typedef A& type;
-};
-template <class A, class B> struct subscript_type<A* volatile, B> {
-  typedef A& type;
-};
-template <class A, class B> struct subscript_type<A* const volatile, B> {
-  typedef A& type;
-};
-
-
-template<class A, class B, int N> struct subscript_type<A[N], B> { 
-  typedef A& type; 
-};
-
-  // these 3 specializations are needed to make gcc <3 happy
-template<class A, class B, int N> struct subscript_type<const A[N], B> { 
-  typedef const A& type; 
-};
-template<class A, class B, int N> struct subscript_type<volatile A[N], B> { 
-  typedef volatile A& type; 
-};
-template<class A, class B, int N> struct subscript_type<const volatile A[N], B> { 
-  typedef const volatile A& type; 
-};
-
-} // end detail
-
-template<class A, class B>
-struct return_type_2<other_action<subscript_action>, A, B> {
-
-  typedef typename detail::remove_reference_and_cv<A>::type plain_A;
-  typedef typename detail::remove_reference_and_cv<B>::type plain_B;
-
-  typedef typename boost::remove_reference<A>::type nonref_A;
-  typedef typename boost::remove_reference<B>::type nonref_B;
-
-  typedef typename 
-    plain_return_type_2<
-      other_action<subscript_action>, plain_A, plain_B
-    >::type type1;
-  
-  typedef typename 
-    detail::IF_type<
-      boost::is_same<type1, detail::unspecified>::value, 
-      detail::subscript_type<nonref_A, nonref_B>,
-      plain_return_type_2<other_action<subscript_action>, plain_A, plain_B>
-    >::type type;
-
-};
-
-template<class Key, class T, class Cmp, class Allocator, class B> 
-struct plain_return_type_2<other_action<subscript_action>, std::map<Key, T, Cmp, Allocator>, B> { 
-  typedef T& type;
-  // T == std::map<Key, T, Cmp, Allocator>::mapped_type; 
-};
-
-template<class Key, class T, class Cmp, class Allocator, class B> 
-struct plain_return_type_2<other_action<subscript_action>, std::multimap<Key, T, Cmp, Allocator>, B> { 
-  typedef T& type;
-  // T == std::map<Key, T, Cmp, Allocator>::mapped_type; 
-};
-
-  // deque
-template<class T, class Allocator, class B> 
-struct plain_return_type_2<other_action<subscript_action>, std::deque<T, Allocator>, B> { 
-  typedef typename std::deque<T, Allocator>::reference type;
-};
-template<class T, class Allocator, class B> 
-struct plain_return_type_2<other_action<subscript_action>, const std::deque<T, Allocator>, B> { 
-  typedef typename std::deque<T, Allocator>::const_reference type;
-};
-
-  // vector
-template<class T, class Allocator, class B> 
-struct plain_return_type_2<other_action<subscript_action>, std::vector<T, Allocator>, B> { 
-  typedef typename std::vector<T, Allocator>::reference type;
-};
-template<class T, class Allocator, class B> 
-struct plain_return_type_2<other_action<subscript_action>, const std::vector<T, Allocator>, B> { 
-  typedef typename std::vector<T, Allocator>::const_reference type;
-};
-
-  // basic_string
-template<class Char, class Traits, class Allocator, class B> 
-struct plain_return_type_2<other_action<subscript_action>, std::basic_string<Char, Traits, Allocator>, B> { 
-  typedef typename std::basic_string<Char, Traits, Allocator>::reference type;
-};
-template<class Char, class Traits, class Allocator, class B> 
-struct plain_return_type_2<other_action<subscript_action>, const std::basic_string<Char, Traits, Allocator>, B> { 
-  typedef typename std::basic_string<Char, Traits, Allocator>::const_reference type;
-};
-
-template<class Char, class Traits, class Allocator> 
-struct plain_return_type_2<arithmetic_action<plus_action>,
-                           std::basic_string<Char, Traits, Allocator>,
-                           std::basic_string<Char, Traits, Allocator> > { 
-  typedef std::basic_string<Char, Traits, Allocator> type;
-};
-
-template<class Char, class Traits, class Allocator> 
-struct plain_return_type_2<arithmetic_action<plus_action>,
-                           const Char*,
-                           std::basic_string<Char, Traits, Allocator> > { 
-  typedef std::basic_string<Char, Traits, Allocator> type;
-};
-
-template<class Char, class Traits, class Allocator> 
-struct plain_return_type_2<arithmetic_action<plus_action>,
-                           std::basic_string<Char, Traits, Allocator>,
-                           const Char*> { 
-  typedef std::basic_string<Char, Traits, Allocator> type;
-};
-
-template<class Char, class Traits, class Allocator, std::size_t N> 
-struct plain_return_type_2<arithmetic_action<plus_action>,
-                           Char[N],
-                           std::basic_string<Char, Traits, Allocator> > { 
-  typedef std::basic_string<Char, Traits, Allocator> type;
-};
-
-template<class Char, class Traits, class Allocator, std::size_t N> 
-struct plain_return_type_2<arithmetic_action<plus_action>,
-                           std::basic_string<Char, Traits, Allocator>,
-                           Char[N]> { 
-  typedef std::basic_string<Char, Traits, Allocator> type;
-};
-
-
-} // namespace lambda
-} // namespace boost
-
-#endif
-
-