summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat (limited to '3rdParty/Boost/src/boost/lambda/detail/function_adaptors.hpp')
-rw-r--r--3rdParty/Boost/src/boost/lambda/detail/function_adaptors.hpp789
1 files changed, 789 insertions, 0 deletions
diff --git a/3rdParty/Boost/src/boost/lambda/detail/function_adaptors.hpp b/3rdParty/Boost/src/boost/lambda/detail/function_adaptors.hpp
new file mode 100644
index 0000000..35db8b4
--- /dev/null
+++ b/3rdParty/Boost/src/boost/lambda/detail/function_adaptors.hpp
@@ -0,0 +1,789 @@
+// 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
+
+
+
+
+
+
+
+
+
+
+
+
+