passenger 4.0.20 → 4.0.21

data/ext/boost/functional/hash/detail/container_fwd_0x.hpp

@@ -1,29 +0,0 @@
-
-// Copyright 2012 Daniel James.
-// 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)
-
-#if !defined(BOOST_DETAIL_CONTAINER_FWD_0X_HPP)
-#define BOOST_DETAIL_CONTAINER_FWD_0X_HPP
-
-#include <boost/detail/container_fwd.hpp>
-
-// std::array
-
-#if !defined(BOOST_NO_CXX11_HDR_ARRAY)
-#   include <array>
-#endif
-
-// std::tuple
-
-#if !defined(BOOST_NO_CXX11_HDR_TUPLE)
-#   include <tuple>
-#endif
-
-// std::shared_ptr/std::unique_ptr
-
-#if !defined(BOOST_NO_CXX11_HDR_MEMORY)
-#   include <memory>
-#endif
-
-#endif

data/ext/boost/lambda/core.hpp

@@ -1,79 +0,0 @@
-// -- core.hpp -- Boost Lambda Library -------------------------------------
-//
-// Copyright (C) 2000 Gary Powell (powellg@amazon.com)
-// 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
-// 
-// Includes the core of LL, without any real features for client:
-// 
-// tuples, lambda functors, return type deduction templates,
-// argument substitution mechanism (select functions)
-// 
-// Some functionality comes as well:
-// Assignment and subscript operators, as well as function
-// call operator for placeholder variables.
-// -------------------------------------------------------------------------
-
-#ifndef BOOST_LAMBDA_CORE_HPP
-#define BOOST_LAMBDA_CORE_HPP
-
-#include "boost/type_traits/transform_traits.hpp"
-#include "boost/type_traits/cv_traits.hpp"
-
-#include "boost/tuple/tuple.hpp"
-
-// inject some of the tuple names into lambda 
-namespace boost {
-namespace lambda {
-
-using ::boost::tuples::tuple;
-using ::boost::tuples::null_type;
-
-} // lambda
-} // boost
-
-#include "boost/lambda/detail/lambda_config.hpp"
-#include "boost/lambda/detail/lambda_fwd.hpp"
-
-#include "boost/lambda/detail/arity_code.hpp"
-#include "boost/lambda/detail/actions.hpp"
-
-#include "boost/lambda/detail/lambda_traits.hpp"
-
-#include "boost/lambda/detail/function_adaptors.hpp"
-#include "boost/lambda/detail/return_type_traits.hpp"
-
-#include "boost/lambda/detail/select_functions.hpp"
-
-#include "boost/lambda/detail/lambda_functor_base.hpp"
-
-#include "boost/lambda/detail/lambda_functors.hpp"
-
-#include "boost/lambda/detail/ret.hpp"
-
-namespace boost {
-namespace lambda {
-
-namespace {
-
-  // These are constants types and need to be initialised
-  boost::lambda::placeholder1_type free1 = boost::lambda::placeholder1_type();
-  boost::lambda::placeholder2_type free2 = boost::lambda::placeholder2_type();
-  boost::lambda::placeholder3_type free3 = boost::lambda::placeholder3_type();
-
-  boost::lambda::placeholder1_type& _1 = free1;
-  boost::lambda::placeholder2_type& _2 = free2;
-  boost::lambda::placeholder3_type& _3 = free3;
-  // _1, _2, ... naming scheme by Peter Dimov
-} // unnamed
-   
-} // lambda
-} // boost
-   
-   
-#endif //BOOST_LAMBDA_CORE_HPP

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

@@ -1,174 +0,0 @@
-// -- Boost Lambda Library - actions.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_ACTIONS_HPP
-#define BOOST_LAMBDA_ACTIONS_HPP
-
-namespace boost { 
-namespace lambda {
-
-
-
-template<int Arity, class Act> class action;
-
-// these need to be defined here, since the corresponding lambda 
-// functions are members of lambda_functor classes
-
-class assignment_action {};
-class subscript_action {};
-
-template <class Action> class other_action;
-
-// action for specifying the explicit return type
-template <class RET> class explicit_return_type_action {};
-
-// action for preventing the expansion of a lambda expression
-struct protect_action {};
-
-  // must be defined here, comma is a special case
-struct comma_action {};
-
-
-  // actions, for which the existence of protect is checked in return type 
-  // deduction.
-
-template <class Action> struct is_protectable {
-  BOOST_STATIC_CONSTANT(bool, value = false);
-};
-
-// NOTE: comma action is protectable. Other protectable actions
-// are listed in operator_actions.hpp
-
-template<> struct is_protectable<other_action<comma_action> > {
-  BOOST_STATIC_CONSTANT(bool, value = true);
-};
-
-
-namespace detail {
-
-  // this type is used in return type deductions to signal that deduction 
-  // did not find a result. It does not necessarily mean an error, it commonly
-  // means that something else should be tried.
-  class unspecified {};
-}
-
-  // function action is a special case: bind functions can be called with 
-  // the return type specialized explicitly e.g. bind<int>(foo);
-  // If this call syntax is used, the return type is stored in the latter
-  // argument of function_action template. Otherwise the argument gets the type
-  // 'unspecified'.
-  // This argument is only relevant in the return type deduction code
-template <int I, class Result_type = detail::unspecified> 
-class function_action {};
-   
-template<class T> class function_action<1, T> {
-public:
-  template<class RET, class A1>
-  static RET apply(A1& a1) {
-    return function_adaptor<typename boost::remove_cv<A1>::type>::
-      template apply<RET>(a1);
-  }
-};
-
-template<class T> class function_action<2, T> {
-public:
-  template<class RET, class A1, class A2>
-  static RET apply(A1& a1, A2& a2) {
-    return function_adaptor<typename boost::remove_cv<A1>::type>::
-      template apply<RET>(a1, a2);
-  }
-};
-
-template<class T> class function_action<3, T> {
-public:
-  template<class RET, class A1, class A2, class A3>
-  static RET apply(A1& a1, A2& a2, A3& a3) {
-    return function_adaptor<typename boost::remove_cv<A1>::type>::
-      template apply<RET>(a1, a2, a3);
-  }
-};
-
-template<class T> class function_action<4, T> {
-public:
-  template<class RET, class A1, class A2, class A3, class A4>
-  static RET apply(A1& a1, A2& a2, A3& a3, A4& a4) {
-    return function_adaptor<typename boost::remove_cv<A1>::type>::
-      template apply<RET>(a1, a2, a3, a4);
-  }
-};
-
-template<class T> class function_action<5, T> {
-public:
-  template<class RET, class A1, class A2, class A3, class A4, class A5>
-  static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) {
-    return function_adaptor<typename boost::remove_cv<A1>::type>::
-      template apply<RET>(a1, a2, a3, a4, a5);
-  }
-};
-
-template<class T> class function_action<6, T> {
-public:
-  template<class RET, class A1, class A2, class A3, class A4, class A5, 
-           class A6>
-  static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6) {
-    return function_adaptor<typename boost::remove_cv<A1>::type>::
-      template apply<RET>(a1, a2, a3, a4, a5, a6);
-  }
-};
-
-template<class T> class function_action<7, T> {
-public:
-  template<class RET, class A1, class A2, class A3, class A4, class A5,  
-           class A6, class A7>
-  static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7) {
-    return function_adaptor<typename boost::remove_cv<A1>::type>::
-      template apply<RET>(a1, a2, a3, a4, a5, a6, a7);
-  }
-};
-
-template<class T> class function_action<8, T> {
-public:
-  template<class RET, class A1, class A2, class A3, class A4, class A5, 
-           class A6, class A7, class A8>
-  static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, 
-                   A8& a8) {
-    return function_adaptor<typename boost::remove_cv<A1>::type>::
-      template apply<RET>(a1, a2, a3, a4, a5, a6, a7, a8);
-  }
-};
-
-template<class T> class function_action<9, T> {
-public:
-  template<class RET, class A1, class A2, class A3, class A4, class A5, 
-           class A6, class A7, class A8, class A9>
-  static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, 
-                   A8& a8, A9& a9) {
-    return function_adaptor<typename boost::remove_cv<A1>::type>::
-      template apply<RET>(a1, a2, a3, a4, a5, a6, a7, a8, a9);
-  }
-};
-
-template<class T> class function_action<10, T> {
-public:
-  template<class RET, class A1, class A2, class A3, class A4, class A5, 
-           class A6, class A7, class A8, class A9, class A10>
-  static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, 
-                   A8& a8, A9& a9, A10& a10) {
-    return function_adaptor<typename boost::remove_cv<A1>::type>::
-      template apply<RET>(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
-  }
-};
-
-} // namespace lambda
-} // namespace boost
-
-#endif

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

@@ -1,110 +0,0 @@
-// -- 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_ARITY_CODE_HPP
-#define BOOST_LAMBDA_ARITY_CODE_HPP
-
-#include "boost/type_traits/cv_traits.hpp"
-#include "boost/type_traits/transform_traits.hpp"
-
-namespace boost { 
-namespace lambda {
-
-// These constants state, whether a lambda_functor instantiation results from 
-// an expression which contains no placeholders (NONE), 
-// only free1 placeholders (FIRST), 
-// free2 placeholders and maybe free1 placeholders (SECOND),
-// free3 and maybe free1 and free2 placeholders (THIRD),
-// freeE placeholders and maybe free1 and free2  (EXCEPTION).
-// RETHROW means, that a rethrow expression is used somewhere in the lambda_functor.
-
-enum { NONE             = 0x00, // Notice we are using bits as flags here.
-       FIRST            = 0x01, 
-       SECOND           = 0x02, 
-       THIRD            = 0x04, 
-       EXCEPTION        = 0x08, 
-       RETHROW          = 0x10};
-
-
-template<class T>
-struct get_tuple_arity;
-
-namespace detail {
-
-template <class T> struct get_arity_;
-
-} // end detail;
-
-template <class T> struct get_arity {
-
-  BOOST_STATIC_CONSTANT(int, value = detail::get_arity_<typename boost::remove_cv<typename boost::remove_reference<T>::type>::type>::value);
-
-};
-
-namespace detail {
-
-template<class T>
-struct get_arity_ {
-  BOOST_STATIC_CONSTANT(int, value = 0);
-};
-
-template<class T>
-struct get_arity_<lambda_functor<T> > {
-  BOOST_STATIC_CONSTANT(int, value = get_arity<T>::value);
-};
-
-template<class Action, class Args>
-struct get_arity_<lambda_functor_base<Action, Args> > {
-  BOOST_STATIC_CONSTANT(int, value = get_tuple_arity<Args>::value);
-};
-
-template<int I>
-struct get_arity_<placeholder<I> > {
-  BOOST_STATIC_CONSTANT(int, value = I);
-};
-
-} // detail 
-
-template<class T>
-struct get_tuple_arity {
-  BOOST_STATIC_CONSTANT(int, value = get_arity<typename T::head_type>::value | get_tuple_arity<typename T::tail_type>::value);
-};
-
-
-template<>
-struct get_tuple_arity<null_type> {
-  BOOST_STATIC_CONSTANT(int, value = 0);
-};
-
-
-  // Does T have placeholder<I> as it's subexpression?
-
-template<class T, int I>
-struct has_placeholder {
-  BOOST_STATIC_CONSTANT(bool, value = (get_arity<T>::value & I) != 0);
-}; 
-
-template<int I, int J>
-struct includes_placeholder {
-  BOOST_STATIC_CONSTANT(bool, value = (J & I) != 0);
-};
-
-template<int I, int J>
-struct lacks_placeholder {
-  BOOST_STATIC_CONSTANT(bool, value = ((J & I) == 0));
-};
-
-
-} // namespace lambda
-} // namespace boost
-
-#endif

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

@@ -1,789 +0,0 @@
-// Boost Lambda Library -  function_adaptors.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_FUNCTION_ADAPTORS_HPP
-#define BOOST_LAMBDA_FUNCTION_ADAPTORS_HPP
-
-#include "boost/mpl/has_xxx.hpp"
-#include "boost/tuple/tuple.hpp"
-#include "boost/type_traits/same_traits.hpp"
-#include "boost/type_traits/remove_reference.hpp"
-#include "boost/type_traits/remove_cv.hpp"
-#include "boost/type_traits/add_const.hpp"
-#include "boost/type_traits/add_volatile.hpp"
-#include "boost/utility/result_of.hpp"
-
-namespace boost { 
-namespace lambda {
-
-namespace detail {
-
-BOOST_MPL_HAS_XXX_TEMPLATE_DEF(sig)
-
-template<class Tuple>
-struct remove_references_from_elements {
-  typedef typename boost::tuples::cons<
-    typename boost::remove_reference<typename Tuple::head_type>::type,
-    typename remove_references_from_elements<typename Tuple::tail_type>::type
-  > type;
-};
-
-template<>
-struct remove_references_from_elements<boost::tuples::null_type> {
-  typedef boost::tuples::null_type type;
-};
-
-}
-
-template <class Func> struct function_adaptor {
-
-  typedef typename detail::remove_reference_and_cv<Func>::type plainF;
-
-#if !defined(BOOST_NO_RESULT_OF)
-  // Support functors that use the boost::result_of return type convention.
-  template<class Tuple, int Length, bool HasSig>
-  struct result_converter;
-  template<class Tuple, int Length>
-  struct result_converter<Tuple, Length, true>
-    : plainF::template sig<
-        typename detail::remove_references_from_elements<Tuple>::type
-      >
-  {};
-  template<class Tuple>
-  struct result_converter<Tuple, 0, false>
-    : result_of<plainF()>
-  {};
-  template<class Tuple>
-  struct result_converter<Tuple, 1, false>
-    : result_of<plainF(
-        typename tuples::element<1, Tuple>::type)
-      >
-  {};
-  template<class Tuple>
-  struct result_converter<Tuple, 2, false>
-    : result_of<plainF(
-        typename tuples::element<1, Tuple>::type,
-        typename tuples::element<2, Tuple>::type)
-      >
-  {};
-  template<class Tuple>
-  struct result_converter<Tuple, 3, false>
-    : result_of<plainF(
-        typename tuples::element<1, Tuple>::type,
-        typename tuples::element<2, Tuple>::type,
-        typename tuples::element<3, Tuple>::type)
-      >
-  {};
-  template<class Tuple>
-  struct result_converter<Tuple, 4, false>
-    : result_of<plainF(
-        typename tuples::element<1, Tuple>::type,
-        typename tuples::element<2, Tuple>::type,
-        typename tuples::element<3, Tuple>::type,
-        typename tuples::element<4, Tuple>::type)
-      >
-  {};
-  template<class Tuple>
-  struct result_converter<Tuple, 5, false>
-    : result_of<plainF(
-        typename tuples::element<1, Tuple>::type,
-        typename tuples::element<2, Tuple>::type,
-        typename tuples::element<3, Tuple>::type,
-        typename tuples::element<4, Tuple>::type,
-        typename tuples::element<5, Tuple>::type)
-      >
-  {};
-  template<class Tuple>
-  struct result_converter<Tuple, 6, false>
-    : result_of<plainF(
-        typename tuples::element<1, Tuple>::type,
-        typename tuples::element<2, Tuple>::type,
-        typename tuples::element<3, Tuple>::type,
-        typename tuples::element<4, Tuple>::type,
-        typename tuples::element<5, Tuple>::type,
-        typename tuples::element<6, Tuple>::type)
-      >
-  {};
-  template<class Tuple>
-  struct result_converter<Tuple, 7, false>
-    : result_of<plainF(
-        typename tuples::element<1, Tuple>::type,
-        typename tuples::element<2, Tuple>::type,
-        typename tuples::element<3, Tuple>::type,
-        typename tuples::element<4, Tuple>::type,
-        typename tuples::element<5, Tuple>::type,
-        typename tuples::element<6, Tuple>::type,
-        typename tuples::element<7, Tuple>::type)
-      >
-  {};
-  template<class Tuple>
-  struct result_converter<Tuple, 8, false>
-    : result_of<plainF(
-        typename tuples::element<1, Tuple>::type,
-        typename tuples::element<2, Tuple>::type,
-        typename tuples::element<3, Tuple>::type,
-        typename tuples::element<4, Tuple>::type,
-        typename tuples::element<5, Tuple>::type,
-        typename tuples::element<6, Tuple>::type,
-        typename tuples::element<7, Tuple>::type,
-        typename tuples::element<8, Tuple>::type)
-      >
-  {};
-  template<class Tuple>
-  struct result_converter<Tuple, 9, false>
-    : result_of<plainF(
-        typename tuples::element<1, Tuple>::type,
-        typename tuples::element<2, Tuple>::type,
-        typename tuples::element<3, Tuple>::type,
-        typename tuples::element<4, Tuple>::type,
-        typename tuples::element<5, Tuple>::type,
-        typename tuples::element<6, Tuple>::type,
-        typename tuples::element<7, Tuple>::type,
-        typename tuples::element<8, Tuple>::type,
-        typename tuples::element<9, Tuple>::type)
-      >
-  {};
-
-  // we do not know the return type off-hand, we must ask it from Func
-  // To sig we pass a cons list, where the head is the function object type
-  // itself (potentially cv-qualified)
-  // and the tail contains the types of the actual arguments to be passed
-  // to the function object. The arguments can be cv qualified
-  // as well.
-  template <class Args>
-  struct sig
-    : result_converter<
-        Args
-      , tuples::length<typename Args::tail_type>::value
-      , detail::has_sig<plainF>::value
-      >
-  {};
-#else // BOOST_NO_RESULT_OF
-
-  template <class Args> class sig {
-    typedef typename detail::remove_reference_and_cv<Func>::type plainF;
-  public:
-    typedef typename plainF::template sig<
-      typename detail::remove_references_from_elements<Args>::type
-    >::type type;
-  };
-#endif
-
-  template<class RET, class A1>
-  static RET apply(A1& a1) {
-    return a1();
-  }
-  template<class RET, class A1, class A2>
-  static RET apply(A1& a1, A2& a2) {
-    return a1(a2);
-  }
-  template<class RET, class A1, class A2, class A3>
-  static RET apply(A1& a1, A2& a2, A3& a3) {
-    return a1(a2, a3);
-  }
-  template<class RET, class A1, class A2, class A3, class A4>
-  static RET apply(A1& a1, A2& a2, A3& a3, A4& a4) {
-    return a1(a2, a3, a4);
-  }
-  template<class RET, class A1, class A2, class A3, class A4, class A5>
-  static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) {
-    return a1(a2, a3, a4, a5);
-  }
-  template<class RET, class A1, class A2, class A3, class A4, class A5, class A6>
-  static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6) {
-    return a1(a2, a3, a4, a5, a6);
-  }
-  template<class RET, class A1, class A2, class A3, class A4, class A5, class A6, 
-           class A7>
-  static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, 
-                           A7& a7) {
-    return a1(a2, a3, a4, a5, a6, a7);
-  }
-  template<class RET, class A1, class A2, class A3, class A4, class A5, class A6, 
-           class A7, class A8>
-  static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, 
-                           A7& a7, A8& a8) {
-    return a1(a2, a3, a4, a5, a6, a7, a8);
-  }
-  template<class RET, class A1, class A2, class A3, class A4, class A5, class A6, 
-           class A7, class A8, class A9>
-  static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, 
-                           A7& a7, A8& a8, A9& a9) {
-    return a1(a2, a3, a4, a5, a6, a7, a8, a9);
-  }
-  template<class RET, class A1, class A2, class A3, class A4, class A5, class A6, 
-           class A7, class A8, class A9, class A10>
-  static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, 
-                           A7& a7, A8& a8, A9& a9, A10& a10) {
-    return a1(a2, a3, a4, a5, a6, a7, a8, a9, a10);
-  }
-};
-
-template <class Func> struct function_adaptor<const Func>; // error 
-
-// -- function adaptors with data member access
-template <class Object, class T>
-struct function_adaptor<T Object::*> {
-
-  //  typedef detail::unspecified type;
-
-  // T can have qualifiers and can be a reference type
-  // We get the return type by adding const, if the object through which
-  // the data member is accessed is const, and finally adding a reference
-  template<class Args> class sig { 
-    typedef typename boost::tuples::element<1, Args>::type argument_type;
-    typedef typename boost::remove_reference<
-      argument_type
-    >::type unref_type;
-
-    typedef typename detail::IF<boost::is_const<unref_type>::value,
-      typename boost::add_const<T>::type,
-      T
-    >::RET properly_consted_return_type;
-
-    typedef typename detail::IF<boost::is_volatile<unref_type>::value,
-      typename boost::add_volatile<properly_consted_return_type>::type,
-      properly_consted_return_type
-    >::RET properly_cvd_return_type;
-
-
-  public:
-    typedef typename detail::IF<boost::is_reference<argument_type>::value,
-      typename boost::add_reference<properly_cvd_return_type>::type,
-      typename boost::remove_cv<T>::type
-    >::RET type;
-  };
-
-  template <class RET>
-  static RET apply( T Object::*data, Object& o) {
-    return o.*data;
-  }
-  template <class RET>
-  static RET apply( T Object::*data, const Object& o) {
-    return o.*data;
-  }
-  template <class RET>
-  static RET apply( T Object::*data, volatile Object& o) {
-    return o.*data;
-  }
-  template <class RET>
-  static RET apply( T Object::*data, const volatile Object& o) {
-    return o.*data;
-  }
-  template <class RET>
-  static RET apply( T Object::*data, Object* o) {
-    return o->*data;
-  }
-  template <class RET>
-  static RET apply( T Object::*data, const Object* o) {
-    return o->*data;
-  }
-  template <class RET>
-  static RET apply( T Object::*data, volatile Object* o) {
-    return o->*data;
-  }
-  template <class RET>
-  static RET apply( T Object::*data, const volatile Object* o) {
-    return o->*data;
-  }
-};
-
-// -- function adaptors with 1 argument apply
-   
-template <class Result>
-struct function_adaptor<Result (void)> {
-  
-  template<class T> struct sig { typedef Result type; };
-  template <class RET>
-  static Result apply(Result (*func)()) {
-    return func();
-  }
-};
-
-template <class Result>
-struct function_adaptor<Result (*)(void)> {
-
-  template<class T> struct sig { typedef Result type; };
-  template <class RET>
-  static Result apply(Result (*func)()) {
-    return func();
-  }
-};
-
-
-// -- function adaptors with 2 argument apply
-template <class Object, class Result>
-struct function_adaptor<Result (Object::*)() const> {
-
-  template<class T> struct sig { typedef Result type; };
-  template <class RET>
-  static Result apply( Result (Object::*func)() const, const Object* o) {
-    return (o->*func)();
-  }
-  template <class RET>
-  static Result apply( Result (Object::*func)() const, const Object& o) {
-    return (o.*func)();
-  }
-};
-
-template <class Object, class Result>
-struct function_adaptor<Result (Object::*)()> {
-
-  template<class T> struct sig { typedef Result type; };
-  template <class RET>
-  static Result apply( Result (Object::*func)(), Object* o) {
-    return (o->*func)();
-  }
-  template <class RET>
-  static Result apply( Result (Object::*func)(), Object& o) {
-    return (o.*func)();
-  }
-};
-
-template <class Arg1, class Result>
-struct function_adaptor<Result (Arg1)> {
-
-  template<class T> struct sig { typedef Result type; };
-  template <class RET, class A1>
-  static Result apply(Result (*func)(Arg1), A1& a1) {
-    return func(a1);
-  }
-};
-
-template <class Arg1, class Result>
-struct function_adaptor<Result (*)(Arg1)> {
-
-  template<class T> struct sig { typedef Result type; };
-  template <class RET, class A1>
-  static Result apply(Result (*func)(Arg1), A1& a1) {
-    return func(a1);
-  }
-};
-
-
-// -- function adaptors with 3 argument apply
-template <class Object, class Arg1, class Result>
-struct function_adaptor<Result (Object::*)(Arg1) const> {
-
-  template<class T> struct sig { typedef Result type; };
-  template <class RET, class A1>
-  static Result apply( Result (Object::*func)(Arg1) const, const Object* o, 
-    A1& a1) {
-    return (o->*func)(a1);
-  }
-  template <class RET, class A1>
-  static Result apply( Result (Object::*func)(Arg1) const, const Object& o, 
-    A1& a1) {
-    return (o.*func)(a1);
-  }
-};
-
-template <class Object, class Arg1, class Result>
-struct function_adaptor<Result (Object::*)(Arg1)> {
-
-  template<class T> struct sig { typedef Result type; };
-  template <class RET, class A1>
-  static Result apply( Result (Object::*func)(Arg1), Object* o, A1& a1) {
-    return (o->*func)(a1);
-  }
-  template <class RET, class A1>
-  static Result apply( Result (Object::*func)(Arg1), Object& o, A1& a1) {
-    return (o.*func)(a1);
-  }
-};
-
-template <class Arg1, class Arg2, class Result>
-struct function_adaptor<Result (Arg1, Arg2)> {
-
-  template<class T> struct sig { typedef Result type; };
-  template <class RET, class A1, class A2>
-  static Result apply(Result (*func)(Arg1, Arg2), A1& a1, A2& a2) {
-    return func(a1, a2);
-  }
-};
-
-template <class Arg1, class Arg2, class Result>
-struct function_adaptor<Result (*)(Arg1, Arg2)> {
-
-  template<class T> struct sig { typedef Result type; };
-  template <class RET, class A1, class A2>
-  static Result apply(Result (*func)(Arg1, Arg2), A1& a1, A2& a2) {
-    return func(a1, a2);
-  }
-};
-
-
-// -- function adaptors with 4 argument apply
-template <class Object, class Arg1, class Arg2, class Result>
-struct function_adaptor<Result (Object::*)(Arg1, Arg2) const> {
-
-  template<class T> struct sig { typedef Result type; };
-  template <class RET, class A1, class A2>
-  static Result apply( Result (Object::*func)(Arg1, Arg2) const, const Object* o, A1& a1, A2& a2) {
-    return (o->*func)(a1, a2);
-  }
-  template <class RET, class A1, class A2>
-  static Result apply( Result (Object::*func)(Arg1, Arg2) const, const Object& o, A1& a1, A2& a2) {
-    return (o.*func)(a1, a2);
-  }
-};
-
-template <class Object, class Arg1, class Arg2, class Result>
-struct function_adaptor<Result (Object::*)(Arg1, Arg2)> {
-
-  template<class T> struct sig { typedef Result type; };
-  template <class RET, class A1, class A2>
-  static Result apply( Result (Object::*func)(Arg1, Arg2), Object* o, A1& a1, A2& a2) {
-    return (o->*func)(a1, a2);
-  }
-  template <class RET, class A1, class A2>
-  static Result apply( Result (Object::*func)(Arg1, Arg2), Object& o, A1& a1, A2& a2) {
-    return (o.*func)(a1, a2);
-  }
-};
-
-template <class Arg1, class Arg2, class Arg3, class Result>
-struct function_adaptor<Result (Arg1, Arg2, Arg3)> {
-
-  template<class T> struct sig { typedef Result type; };
-  template <class RET, class A1, class A2, class A3>
-  static Result apply(Result (*func)(Arg1, Arg2, Arg3), A1& a1, A2& a2, A3& a3) {
-    return func(a1, a2, a3);
-  }
-};
-
-template <class Arg1, class Arg2, class Arg3, class Result>
-struct function_adaptor<Result (*)(Arg1, Arg2, Arg3)> {
-
-  template<class T> struct sig { typedef Result type; };
-  template <class RET, class A1, class A2, class A3>
-  static Result apply(Result (*func)(Arg1, Arg2, Arg3), A1& a1, A2& a2, A3& a3) {
-    return func(a1, a2, a3);
-  }
-};
-
-
-// -- function adaptors with 5 argument apply
-template <class Object, class Arg1, class Arg2, class Arg3, class Result>
-struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3) const> {
-
-  template<class T> struct sig { typedef Result type; };
-  template <class RET, class A1, class A2, class A3>
-  static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3) const, const Object* o, A1& a1, A2& a2, A3& a3) {
-    return (o->*func)(a1, a2, a3);
-  }
-  template <class RET, class A1, class A2, class A3>
-  static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3) const, const Object& o, A1& a1, A2& a2, A3& a3) {
-    return (o.*func)(a1, a2, a3);
-  }
-};
-
-template <class Object, class Arg1, class Arg2, class Arg3, class Result>
-struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3)> {
-
-  template<class T> struct sig { typedef Result type; };
-  template <class RET, class A1, class A2, class A3>
-  static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3), Object* o, A1& a1, A2& a2, A3& a3) {
-    return (o->*func)(a1, a2, a3);
-  }
-  template <class RET, class A1, class A2, class A3>
-  static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3), Object& o, A1& a1, A2& a2, A3& a3) {
-    return (o.*func)(a1, a2, a3);
-  }
-};
-
-template <class Arg1, class Arg2, class Arg3, class Arg4, class Result>
-struct function_adaptor<Result (Arg1, Arg2, Arg3, Arg4)> {
-
-  template<class T> struct sig { typedef Result type; };
-  template <class RET, class A1, class A2, class A3, class A4>
-  static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4), A1& a1, A2& a2, A3& a3, A4& a4) {
-    return func(a1, a2, a3, a4);
-  }
-};
-
-template <class Arg1, class Arg2, class Arg3, class Arg4, class Result>
-struct function_adaptor<Result (*)(Arg1, Arg2, Arg3, Arg4)> {
-
-  template<class T> struct sig { typedef Result type; };
-  template <class RET, class A1, class A2, class A3, class A4>
-  static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4), A1& a1, A2& a2, A3& a3, A4& a4) {
-    return func(a1, a2, a3, a4);
-  }
-};
-
-
-// -- function adaptors with 6 argument apply
-template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Result>
-struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4) const> {
-
-  template<class T> struct sig { typedef Result type; };
-  template <class RET, class A1, class A2, class A3, class A4>
-  static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4) const, const Object* o, A1& a1, A2& a2, A3& a3, A4& a4) {
-    return (o->*func)(a1, a2, a3, a4);
-  }
-  template <class RET, class A1, class A2, class A3, class A4>
-  static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4) const, const Object& o, A1& a1, A2& a2, A3& a3, A4& a4) {
-    return (o.*func)(a1, a2, a3, a4);
-  }
-};
-
-template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Result>
-struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4)> {
-
-  template<class T> struct sig { typedef Result type; };
-  template <class RET, class A1, class A2, class A3, class A4>
-  static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4), Object* o, A1& a1, A2& a2, A3& a3, A4& a4) {
-    return (o->*func)(a1, a2, a3, a4);
-  }
-  template <class RET, class A1, class A2, class A3, class A4>
-  static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4), Object& o, A1& a1, A2& a2, A3& a3, A4& a4) {
-    return (o.*func)(a1, a2, a3, a4);
-  }
-};
-
-template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Result>
-struct function_adaptor<Result (Arg1, Arg2, Arg3, Arg4, Arg5)> {
-
-  template<class T> struct sig { typedef Result type; };
-  template <class RET, class A1, class A2, class A3, class A4, class A5>
-  static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4, Arg5), A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) {
-    return func(a1, a2, a3, a4, a5);
-  }
-};
-
-template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Result>
-struct function_adaptor<Result (*)(Arg1, Arg2, Arg3, Arg4, Arg5)> {
-
-  template<class T> struct sig { typedef Result type; };
-  template <class RET, class A1, class A2, class A3, class A4, class A5>
-  static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4, Arg5), A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) {
-    return func(a1, a2, a3, a4, a5);
-  }
-};
-
-
-// -- function adaptors with 7 argument apply
-template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Result>
-struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5) const> {
-
-  template<class T> struct sig { typedef Result type; };
-  template <class RET, class A1, class A2, class A3, class A4, class A5>
-  static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5) const, const Object* o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) {
-    return (o->*func)(a1, a2, a3, a4, a5);
-  }
-  template <class RET, class A1, class A2, class A3, class A4, class A5>
-  static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5) const, const Object& o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) {
-    return (o.*func)(a1, a2, a3, a4, a5);
-  }
-};
-
-template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Result>
-struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5)> {
-
-  template<class T> struct sig { typedef Result type; };
-  template <class RET, class A1, class A2, class A3, class A4, class A5>
-  static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5), Object* o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) {
-    return (o->*func)(a1, a2, a3, a4, a5);
-  }
-  template <class RET, class A1, class A2, class A3, class A4, class A5>
-  static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5), Object& o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) {
-    return (o.*func)(a1, a2, a3, a4, a5);
-  }
-};
-
-template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Result>
-struct function_adaptor<Result (Arg1, Arg2, Arg3, Arg4, Arg5, Arg6)> {
-
-  template<class T> struct sig { typedef Result type; };
-  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6>
-  static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6), A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6) {
-    return func(a1, a2, a3, a4, a5, a6);
-  }
-};
-
-template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Result>
-struct function_adaptor<Result (*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6)> {
-
-  template<class T> struct sig { typedef Result type; };
-  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6>
-  static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6), A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6) {
-    return func(a1, a2, a3, a4, a5, a6);
-  }
-};
-
-
-// -- function adaptors with 8 argument apply
-template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Result>
-struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6) const> {
-
-  template<class T> struct sig { typedef Result type; };
-  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6>
-  static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6) const, const Object* o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6) {
-    return (o->*func)(a1, a2, a3, a4, a5, a6);
-  }
-  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6>
-  static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6) const, const Object& o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6) {
-    return (o.*func)(a1, a2, a3, a4, a5, a6);
-  }
-};
-
-template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Result>
-struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6)> {
-
-  template<class T> struct sig { typedef Result type; };
-  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6>
-  static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6), Object* o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6) {
-    return (o->*func)(a1, a2, a3, a4, a5, a6);
-  }
-  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6>
-  static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6), Object& o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6) {
-    return (o.*func)(a1, a2, a3, a4, a5, a6);
-  }
-};
-
-template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Result>
-struct function_adaptor<Result (Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7)> {
-
-  template<class T> struct sig { typedef Result type; };
-  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-  static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7), A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7) {
-    return func(a1, a2, a3, a4, a5, a6, a7);
-  }
-};
-
-template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Result>
-struct function_adaptor<Result (*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7)> {
-
-  template<class T> struct sig { typedef Result type; };
-  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-  static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7), A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7) {
-    return func(a1, a2, a3, a4, a5, a6, a7);
-  }
-};
-
-
-// -- function adaptors with 9 argument apply
-template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Result>
-struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7) const> {
-
-  template<class T> struct sig { typedef Result type; };
-  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-  static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7) const, const Object* o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7) {
-    return (o->*func)(a1, a2, a3, a4, a5, a6, a7);
-  }
-  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-  static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7) const, const Object& o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7) {
-    return (o.*func)(a1, a2, a3, a4, a5, a6, a7);
-  }
-};
-
-template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Result>
-struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7)> {
-
-  template<class T> struct sig { typedef Result type; };
-  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-  static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7), Object* o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7) {
-    return (o->*func)(a1, a2, a3, a4, a5, a6, a7);
-  }
-  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-  static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7), Object& o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7) {
-    return (o.*func)(a1, a2, a3, a4, a5, a6, a7);
-  }
-};
-
-template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Arg8, class Result>
-struct function_adaptor<Result (Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8)> {
-
-  template<class T> struct sig { typedef Result type; };
-  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-  static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8), A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8) {
-    return func(a1, a2, a3, a4, a5, a6, a7, a8);
-  }
-};
-
-template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Arg8, class Result>
-struct function_adaptor<Result (*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8)> {
-
-  template<class T> struct sig { typedef Result type; };
-  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-  static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8), A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8) {
-    return func(a1, a2, a3, a4, a5, a6, a7, a8);
-  }
-};
-
-
-// -- function adaptors with 10 argument apply
-template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Arg8, class Result>
-struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8) const> {
-
-  template<class T> struct sig { typedef Result type; };
-  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-  static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8) const, const Object* o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8) {
-    return (o->*func)(a1, a2, a3, a4, a5, a6, a7, a8);
-  }
-  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-  static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8) const, const Object& o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8) {
-    return (o.*func)(a1, a2, a3, a4, a5, a6, a7, a8);
-  }
-};
-
-template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Arg8, class Result>
-struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8)> {
-
-  template<class T> struct sig { typedef Result type; };
-  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-  static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8), Object* o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8) {
-    return (o->*func)(a1, a2, a3, a4, a5, a6, a7, a8);
-  }
-  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-  static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8), Object& o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8) {
-    return (o.*func)(a1, a2, a3, a4, a5, a6, a7, a8);
-  }
-};
-
-template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Arg8, class Arg9, class Result>
-struct function_adaptor<Result (Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8, Arg9)> {
-
-  template<class T> struct sig { typedef Result type; };
-  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-  static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8, Arg9), A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9) {
-    return func(a1, a2, a3, a4, a5, a6, a7, a8, a9);
-  }
-};
-
-template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Arg8, class Arg9, class Result>
-struct function_adaptor<Result (*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8, Arg9)> {
-
-  template<class T> struct sig { typedef Result type; };
-  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-  static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8, Arg9), A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9) {
-    return func(a1, a2, a3, a4, a5, a6, a7, a8, a9);
-  }
-};
-
-} // namespace lambda
-} // namespace boost
-
-#endif
-
-
-
-
-
-
-
-
-
-
-
-
-