diff options
author | Remko Tronçon <git@el-tramo.be> | 2012-12-23 13:16:26 (GMT) |
---|---|---|
committer | Remko Tronçon <git@el-tramo.be> | 2012-12-23 14:43:26 (GMT) |
commit | 491ddd570a752cf9bda85933bed0c6942e39b1f9 (patch) | |
tree | 10c25c1be8cc08d0497df1dccd56a10fbb30beee /3rdParty/Boost/src/boost/lambda/detail/function_adaptors.hpp | |
parent | da7d7a0ca71b80281aa9ff2526290b61ccb0cc60 (diff) | |
download | swift-491ddd570a752cf9bda85933bed0c6942e39b1f9.zip swift-491ddd570a752cf9bda85933bed0c6942e39b1f9.tar.bz2 |
Update Boost to 1.52.0.
Change-Id: I1e56bea2600bf2ed9c5b3aba8c4f9d2a0f350e77
Diffstat (limited to '3rdParty/Boost/src/boost/lambda/detail/function_adaptors.hpp')
-rw-r--r-- | 3rdParty/Boost/src/boost/lambda/detail/function_adaptors.hpp | 789 |
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 + + + + + + + + + + + + + |