Symaptic: os/ossrv/ossrv_pub/boost_apis/boost/spirit/phoenix/binders.hpp@260cb5ec6c19 (annotated)

sl@0	1	/*=============================================================================
sl@0	2	Phoenix v1.2
sl@0	3	Copyright (c) 2001-2002 Joel de Guzman
sl@0	4
sl@0	5	Use, modification and distribution is subject to the Boost Software
sl@0	6	License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
sl@0	7	http://www.boost.org/LICENSE_1_0.txt)
sl@0	8	==============================================================================*/
sl@0	9	#ifndef PHOENIX_BINDERS_HPP
sl@0	10	#define PHOENIX_BINDERS_HPP
sl@0	11
sl@0	12	///////////////////////////////////////////////////////////////////////////////
sl@0	13	#include <boost/spirit/phoenix/functions.hpp>
sl@0	14	#include <boost/type_traits/is_const.hpp>
sl@0	15	#include <boost/mpl/if.hpp>
sl@0	16
sl@0	17	///////////////////////////////////////////////////////////////////////////////
sl@0	18	namespace phoenix {
sl@0	19
sl@0	20	///////////////////////////////////////////////////////////////////////////////
sl@0	21	//
sl@0	22	// Binders
sl@0	23	//
sl@0	24	// There are times when it is desireable to bind a simple functor,
sl@0	25	// function, member function or member variable for deferred
sl@0	26	// evaluation. This can be done through the binding facilities
sl@0	27	// provided below. There are template classes:
sl@0	28	//
sl@0	29	// 1) function_ptr ( function pointer binder )
sl@0	30	// 2) functor ( functor pointer binder )
sl@0	31	// 3) member_function_ptr ( member function pointer binder )
sl@0	32	// 4) member_var_ptr ( member variable pointer binder )
sl@0	33	//
sl@0	34	// These template classes are specialized lazy function classes for
sl@0	35	// functors, function pointers, member function pointers and member
sl@0	36	// variable pointers, respectively. These are subclasses of the
sl@0	37	// lazy-function class (see functions.hpp). Each of these has a
sl@0	38	// corresponding overloaded bind(x) function. Each bind(x) function
sl@0	39	// generates a suitable binder object.
sl@0	40	//
sl@0	41	// Example, given a function foo:
sl@0	42	//
sl@0	43	// void foo_(int n) { std::cout << n << std::endl; }
sl@0	44	//
sl@0	45	// Here's how the function foo is bound:
sl@0	46	//
sl@0	47	// bind(&foo_)
sl@0	48	//
sl@0	49	// This bind expression results to a lazy-function (see
sl@0	50	// functions.hpp) that is lazily evaluated. This bind expression is
sl@0	51	// also equivalent to:
sl@0	52	//
sl@0	53	// function_ptr<void, int> foo = &foo_;
sl@0	54	//
sl@0	55	// The template parameter of the function_ptr is the return and
sl@0	56	// argument types of actual signature of the function to be bound
sl@0	57	// read from left to right:
sl@0	58	//
sl@0	59	// void foo_(int); ---> function_ptr<void, int>
sl@0	60	//
sl@0	61	// Either bind(&foo_) and its equivalent foo can now be used in the
sl@0	62	// same way a lazy function (see functions.hpp) is used:
sl@0	63	//
sl@0	64	// bind(&foo_)(arg1)
sl@0	65	//
sl@0	66	// or
sl@0	67	//
sl@0	68	// foo(arg1)
sl@0	69	//
sl@0	70	// The latter, of course, being much easier to understand. This is
sl@0	71	// now a full-fledged lazy function that can finally be evaluated
sl@0	72	// by another function call invocation. A second function call will
sl@0	73	// invoke the actual foo function:
sl@0	74	//
sl@0	75	// int i = 4;
sl@0	76	// foo(arg1)(i);
sl@0	77	//
sl@0	78	// will print out "4".
sl@0	79	//
sl@0	80	// Binding functors and member functions can be done similarly.
sl@0	81	// Here's how to bind a functor (e.g. std::plus<int>):
sl@0	82	//
sl@0	83	// bind(std::plus<int>())
sl@0	84	//
sl@0	85	// or
sl@0	86	//
sl@0	87	// functor<std::plus<int> > plus;
sl@0	88	//
sl@0	89	// Again, these are full-fledged lazy functions. In this case,
sl@0	90	// unlike the first example, expect 2 arguments (std::plus<int>
sl@0	91	// needs two arguments lhs and rhs). Either or both of which can be
sl@0	92	// lazily bound:
sl@0	93	//
sl@0	94	// plus(arg1, arg2) // arg1 + arg2
sl@0	95	// plus(100, arg1) // 100 + arg1
sl@0	96	// plus(100, 200) // 300
sl@0	97	//
sl@0	98	// A bound member function takes in a pointer or reference to an
sl@0	99	// object as the first argument. For instance, given:
sl@0	100	//
sl@0	101	// struct xyz { void foo(int) const; };
sl@0	102	//
sl@0	103	// xyz's foo member function can be bound as:
sl@0	104	//
sl@0	105	// bind(&xyz::foo)
sl@0	106	//
sl@0	107	// or
sl@0	108	//
sl@0	109	// member_function_ptr<void, xyz, int> xyz_foo = &xyz::foo;
sl@0	110	//
sl@0	111	// The template parameter of the member_function_ptr is the return,
sl@0	112	// class and argument types of actual signature of the function to
sl@0	113	// be bound read from left to right:
sl@0	114	//
sl@0	115	// void xyz::foo_(int); ---> member_function_ptr<void, xyz, int>
sl@0	116	//
sl@0	117	// Take note that a member_function_ptr lazy-function expects the
sl@0	118	// first argument to be a pointer or reference to an object. Both
sl@0	119	// the object (reference or pointer) and the arguments can be
sl@0	120	// lazily bound. Examples:
sl@0	121	//
sl@0	122	// xyz obj;
sl@0	123	// xyz_foo(arg1, arg2) // arg1.foo(arg2)
sl@0	124	// xyz_foo(obj, arg1) // obj.foo(arg1)
sl@0	125	// xyz_foo(obj, 100) // obj.foo(100)
sl@0	126	//
sl@0	127	// Be reminded that var(obj) must be used to call non-const member
sl@0	128	// functions. For example, if xyz was declared as:
sl@0	129	//
sl@0	130	// struct xyz { void foo(int); };
sl@0	131	//
sl@0	132	// the pointer or reference to the object must also be non-const.
sl@0	133	// Lazily bound arguments are stored as const value by default (see
sl@0	134	// variable class in primitives.hpp).
sl@0	135	//
sl@0	136	// xyz_foo(var(obj), 100) // obj.foo(100)
sl@0	137	//
sl@0	138	// Finally, member variables can be bound much like member
sl@0	139	// functions. For instance, given:
sl@0	140	//
sl@0	141	// struct xyz { int v; };
sl@0	142	//
sl@0	143	// xyz::v can be bound as:
sl@0	144	//
sl@0	145	// bind(&xyz::v)
sl@0	146	// or
sl@0	147	//
sl@0	148	// member_var_ptr<int, xyz> xyz_v = &xyz::v;
sl@0	149	//
sl@0	150	// The template parameter of the member_var_ptr is the type of the
sl@0	151	// variable followed by the class:
sl@0	152	//
sl@0	153	// int xyz::v; ---> member_var_ptr<int, xyz>
sl@0	154	//
sl@0	155	// Just like the member_function_ptr, member_var_ptr also expects
sl@0	156	// the first argument to be a pointer or reference to an object.
sl@0	157	// Both the object (reference or pointer) and the arguments can be
sl@0	158	// lazily bound. Examples:
sl@0	159	//
sl@0	160	// xyz obj;
sl@0	161	// xyz_v(arg1) // arg1.v
sl@0	162	// xyz_v(obj) // obj.v
sl@0	163	//
sl@0	164	///////////////////////////////////////////////////////////////////////////////
sl@0	165
sl@0	166	///////////////////////////////////////////////////////////////////////////////
sl@0	167	//
sl@0	168	// Functor binder
sl@0	169	//
sl@0	170	///////////////////////////////////////////////////////////////////////////////
sl@0	171	template <typename FuncT>
sl@0	172	struct functor_action : public FuncT {
sl@0	173
sl@0	174	#if !defined(__BORLANDC__) && (!defined(__MWERKS__) \|\| (__MWERKS__ > 0x3002))
sl@0	175
sl@0	176	template <
sl@0	177	typename A = nil_t
sl@0	178	, typename B = nil_t
sl@0	179	, typename C = nil_t
sl@0	180
sl@0	181	#if PHOENIX_LIMIT > 3
sl@0	182	, typename D = nil_t
sl@0	183	, typename E = nil_t
sl@0	184	, typename F = nil_t
sl@0	185
sl@0	186	#if PHOENIX_LIMIT > 6
sl@0	187	, typename G = nil_t
sl@0	188	, typename H = nil_t
sl@0	189	, typename I = nil_t
sl@0	190
sl@0	191	#if PHOENIX_LIMIT > 9
sl@0	192	, typename J = nil_t
sl@0	193	, typename K = nil_t
sl@0	194	, typename L = nil_t
sl@0	195
sl@0	196	#if PHOENIX_LIMIT > 12
sl@0	197	, typename M = nil_t
sl@0	198	, typename N = nil_t
sl@0	199	, typename O = nil_t
sl@0	200
sl@0	201	#endif
sl@0	202	#endif
sl@0	203	#endif
sl@0	204	#endif
sl@0	205	>
sl@0	206	struct result { typedef typename FuncT::result_type type; };
sl@0	207	#endif
sl@0	208
sl@0	209	functor_action(FuncT fptr_ = FuncT())
sl@0	210	: FuncT(fptr_) {}
sl@0	211	};
sl@0	212
sl@0	213	#if defined(__BORLANDC__) \|\| (defined(__MWERKS__) && (__MWERKS__ <= 0x3002))
sl@0	214
sl@0	215	///////////////////////////////////////////////////////////////////////////////
sl@0	216	//
sl@0	217	// The following specializations are needed because Borland and CodeWarrior
sl@0	218	// does not accept default template arguments in nested template classes in
sl@0	219	// classes (i.e functor_action::result)
sl@0	220	//
sl@0	221	///////////////////////////////////////////////////////////////////////////////
sl@0	222	template <typename FuncT, typename TupleT>
sl@0	223	struct composite0_result<functor_action<FuncT>, TupleT> {
sl@0	224
sl@0	225	typedef typename FuncT::result_type type;
sl@0	226	};
sl@0	227
sl@0	228	//////////////////////////////////
sl@0	229	template <typename FuncT, typename TupleT,
sl@0	230	typename A>
sl@0	231	struct composite1_result<functor_action<FuncT>, TupleT, A> {
sl@0	232
sl@0	233	typedef typename FuncT::result_type type;
sl@0	234	};
sl@0	235
sl@0	236	//////////////////////////////////
sl@0	237	template <typename FuncT, typename TupleT,
sl@0	238	typename A, typename B>
sl@0	239	struct composite2_result<functor_action<FuncT>, TupleT, A, B> {
sl@0	240
sl@0	241	typedef typename FuncT::result_type type;
sl@0	242	};
sl@0	243
sl@0	244	//////////////////////////////////
sl@0	245	template <typename FuncT, typename TupleT,
sl@0	246	typename A, typename B, typename C>
sl@0	247	struct composite3_result<functor_action<FuncT>, TupleT, A, B, C> {
sl@0	248
sl@0	249	typedef typename FuncT::result_type type;
sl@0	250	};
sl@0	251
sl@0	252	#if PHOENIX_LIMIT > 3
sl@0	253	//////////////////////////////////
sl@0	254	template <typename FuncT, typename TupleT,
sl@0	255	typename A, typename B, typename C, typename D>
sl@0	256	struct composite4_result<functor_action<FuncT>, TupleT,
sl@0	257	A, B, C, D> {
sl@0	258
sl@0	259	typedef typename FuncT::result_type type;
sl@0	260	};
sl@0	261
sl@0	262	//////////////////////////////////
sl@0	263	template <typename FuncT, typename TupleT,
sl@0	264	typename A, typename B, typename C, typename D, typename E>
sl@0	265	struct composite5_result<functor_action<FuncT>, TupleT,
sl@0	266	A, B, C, D, E> {
sl@0	267
sl@0	268	typedef typename FuncT::result_type type;
sl@0	269	};
sl@0	270
sl@0	271	//////////////////////////////////
sl@0	272	template <typename FuncT, typename TupleT,
sl@0	273	typename A, typename B, typename C, typename D, typename E,
sl@0	274	typename F>
sl@0	275	struct composite6_result<functor_action<FuncT>, TupleT,
sl@0	276	A, B, C, D, E, F> {
sl@0	277
sl@0	278	typedef typename FuncT::result_type type;
sl@0	279	};
sl@0	280
sl@0	281	#if PHOENIX_LIMIT > 6
sl@0	282	//////////////////////////////////
sl@0	283	template <typename FuncT, typename TupleT,
sl@0	284	typename A, typename B, typename C, typename D, typename E,
sl@0	285	typename F, typename G>
sl@0	286	struct composite7_result<functor_action<FuncT>, TupleT,
sl@0	287	A, B, C, D, E, F, G> {
sl@0	288
sl@0	289	typedef typename FuncT::result_type type;
sl@0	290	};
sl@0	291
sl@0	292	//////////////////////////////////
sl@0	293	template <typename FuncT, typename TupleT,
sl@0	294	typename A, typename B, typename C, typename D, typename E,
sl@0	295	typename F, typename G, typename H>
sl@0	296	struct composite8_result<functor_action<FuncT>, TupleT,
sl@0	297	A, B, C, D, E, F, G, H> {
sl@0	298
sl@0	299	typedef typename FuncT::result_type type;
sl@0	300	};
sl@0	301
sl@0	302	//////////////////////////////////
sl@0	303	template <typename FuncT, typename TupleT,
sl@0	304	typename A, typename B, typename C, typename D, typename E,
sl@0	305	typename F, typename G, typename H, typename I>
sl@0	306	struct composite9_result<functor_action<FuncT>, TupleT,
sl@0	307	A, B, C, D, E, F, G, H, I> {
sl@0	308
sl@0	309	typedef typename FuncT::result_type type;
sl@0	310	};
sl@0	311
sl@0	312	#if PHOENIX_LIMIT > 9
sl@0	313	//////////////////////////////////
sl@0	314	template <typename FuncT, typename TupleT,
sl@0	315	typename A, typename B, typename C, typename D, typename E,
sl@0	316	typename F, typename G, typename H, typename I, typename J>
sl@0	317	struct composite10_result<functor_action<FuncT>, TupleT,
sl@0	318	A, B, C, D, E, F, G, H, I, J> {
sl@0	319
sl@0	320	typedef typename FuncT::result_type type;
sl@0	321	};
sl@0	322
sl@0	323	//////////////////////////////////
sl@0	324	template <typename FuncT, typename TupleT,
sl@0	325	typename A, typename B, typename C, typename D, typename E,
sl@0	326	typename F, typename G, typename H, typename I, typename J,
sl@0	327	typename K>
sl@0	328	struct composite11_result<functor_action<FuncT>, TupleT,
sl@0	329	A, B, C, D, E, F, G, H, I, J, K> {
sl@0	330
sl@0	331	typedef typename FuncT::result_type type;
sl@0	332	};
sl@0	333
sl@0	334	//////////////////////////////////
sl@0	335	template <typename FuncT, typename TupleT,
sl@0	336	typename A, typename B, typename C, typename D, typename E,
sl@0	337	typename F, typename G, typename H, typename I, typename J,
sl@0	338	typename K, typename L>
sl@0	339	struct composite12_result<functor_action<FuncT>, TupleT,
sl@0	340	A, B, C, D, E, F, G, H, I, J, K, L> {
sl@0	341
sl@0	342	typedef typename FuncT::result_type type;
sl@0	343	};
sl@0	344
sl@0	345	#if PHOENIX_LIMIT > 12
sl@0	346	//////////////////////////////////
sl@0	347	template <typename FuncT, typename TupleT,
sl@0	348	typename A, typename B, typename C, typename D, typename E,
sl@0	349	typename F, typename G, typename H, typename I, typename J,
sl@0	350	typename K, typename L, typename M>
sl@0	351	struct composite13_result<functor_action<FuncT>, TupleT,
sl@0	352	A, B, C, D, E, F, G, H, I, J, K, L, M> {
sl@0	353
sl@0	354	typedef typename FuncT::result_type type;
sl@0	355	};
sl@0	356
sl@0	357	//////////////////////////////////
sl@0	358	template <typename FuncT, typename TupleT,
sl@0	359	typename A, typename B, typename C, typename D, typename E,
sl@0	360	typename F, typename G, typename H, typename I, typename J,
sl@0	361	typename K, typename L, typename M, typename N>
sl@0	362	struct composite14_result<functor_action<FuncT>, TupleT,
sl@0	363	A, B, C, D, E, F, G, H, I, J, K, L, M, N> {
sl@0	364
sl@0	365	typedef typename FuncT::result_type type;
sl@0	366	};
sl@0	367
sl@0	368	//////////////////////////////////
sl@0	369	template <typename FuncT, typename TupleT,
sl@0	370	typename A, typename B, typename C, typename D, typename E,
sl@0	371	typename F, typename G, typename H, typename I, typename J,
sl@0	372	typename K, typename L, typename M, typename N, typename O>
sl@0	373	struct composite15_result<functor_action<FuncT>, TupleT,
sl@0	374	A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> {
sl@0	375
sl@0	376	typedef typename FuncT::result_type type;
sl@0	377	};
sl@0	378
sl@0	379	#endif
sl@0	380	#endif
sl@0	381	#endif
sl@0	382	#endif
sl@0	383	#endif
sl@0	384
sl@0	385	//////////////////////////////////
sl@0	386	template <typename FuncT>
sl@0	387	struct functor : public function<functor_action<FuncT> > {
sl@0	388
sl@0	389	functor(FuncT func)
sl@0	390	: function<functor_action<FuncT> >(functor_action<FuncT>(func)) {};
sl@0	391	};
sl@0	392
sl@0	393	//////////////////////////////////
sl@0	394	template <typename FuncT>
sl@0	395	inline functor<FuncT>
sl@0	396	bind(FuncT func)
sl@0	397	{
sl@0	398	return functor<FuncT>(func);
sl@0	399	}
sl@0	400
sl@0	401	///////////////////////////////////////////////////////////////////////////////
sl@0	402	//
sl@0	403	// Member variable pointer binder
sl@0	404	//
sl@0	405	///////////////////////////////////////////////////////////////////////////////
sl@0	406	namespace impl {
sl@0	407
sl@0	408	//////////////////////////////////
sl@0	409	template <typename T>
sl@0	410	struct as_ptr {
sl@0	411
sl@0	412	typedef T* pointer_type;
sl@0	413
sl@0	414	static T* get(T& ref)
sl@0	415	{ return &ref; }
sl@0	416	};
sl@0	417
sl@0	418	//////////////////////////////////
sl@0	419	template <typename T>
sl@0	420	struct as_ptr<T*> {
sl@0	421
sl@0	422	typedef T* pointer_type;
sl@0	423
sl@0	424	static T* get(T* ptr)
sl@0	425	{ return ptr; }
sl@0	426	};
sl@0	427	}
sl@0	428
sl@0	429	//////////////////////////////////
sl@0	430	template <typename ActionT, typename ClassT>
sl@0	431	struct member_var_ptr_action_result {
sl@0	432
sl@0	433	typedef typename ActionT::template result<ClassT>::type type;
sl@0	434	};
sl@0	435
sl@0	436	//////////////////////////////////
sl@0	437	template <typename T, typename ClassT>
sl@0	438	struct member_var_ptr_action {
sl@0	439
sl@0	440	typedef member_var_ptr_action<T, ClassT> self_t;
sl@0	441
sl@0	442	template <typename CT>
sl@0	443	struct result {
sl@0	444	typedef typename boost::mpl::if_<boost::is_const<CT>, T const&, T&
sl@0	445	>::type type;
sl@0	446	};
sl@0	447
sl@0	448	typedef T ClassT::*mem_var_ptr_t;
sl@0	449
sl@0	450	member_var_ptr_action(mem_var_ptr_t ptr_)
sl@0	451	: ptr(ptr_) {}
sl@0	452
sl@0	453	template <typename CT>
sl@0	454	typename member_var_ptr_action_result<self_t, CT>::type
sl@0	455	operator()(CT& obj) const
sl@0	456	{ return impl::as_ptr<CT>::get(obj)->*ptr; }
sl@0	457
sl@0	458	mem_var_ptr_t ptr;
sl@0	459	};
sl@0	460
sl@0	461	//////////////////////////////////
sl@0	462	template <typename T, typename ClassT>
sl@0	463	struct member_var_ptr
sl@0	464	: public function<member_var_ptr_action<T, ClassT> > {
sl@0	465
sl@0	466	member_var_ptr(T ClassT::*mp)
sl@0	467	: function<member_var_ptr_action<T, ClassT> >
sl@0	468	(member_var_ptr_action<T, ClassT>(mp)) {}
sl@0	469	};
sl@0	470
sl@0	471	//////////////////////////////////
sl@0	472	template <typename T, typename ClassT>
sl@0	473	inline member_var_ptr<T, ClassT>
sl@0	474	bind(T ClassT::*mp)
sl@0	475	{
sl@0	476	return member_var_ptr<T, ClassT>(mp);
sl@0	477	}
sl@0	478
sl@0	479	///////////////////////////////////////////////////////////////////////////////
sl@0	480	//
sl@0	481	// Function pointer binder (main class)
sl@0	482	//
sl@0	483	///////////////////////////////////////////////////////////////////////////////
sl@0	484	template <
sl@0	485	typename RT
sl@0	486	, typename A = nil_t
sl@0	487	, typename B = nil_t
sl@0	488	, typename C = nil_t
sl@0	489
sl@0	490	#if PHOENIX_LIMIT > 3
sl@0	491	, typename D = nil_t
sl@0	492	, typename E = nil_t
sl@0	493	, typename F = nil_t
sl@0	494
sl@0	495	#if PHOENIX_LIMIT > 6
sl@0	496	, typename G = nil_t
sl@0	497	, typename H = nil_t
sl@0	498	, typename I = nil_t
sl@0	499
sl@0	500	#if PHOENIX_LIMIT > 9
sl@0	501	, typename J = nil_t
sl@0	502	, typename K = nil_t
sl@0	503	, typename L = nil_t
sl@0	504
sl@0	505	#if PHOENIX_LIMIT > 12
sl@0	506	, typename M = nil_t
sl@0	507	, typename N = nil_t
sl@0	508	, typename O = nil_t
sl@0	509
sl@0	510	#endif
sl@0	511	#endif
sl@0	512	#endif
sl@0	513	#endif
sl@0	514
sl@0	515	, typename NU = nil_t // Not used
sl@0	516	>
sl@0	517	struct function_ptr_action;
sl@0	518
sl@0	519	//////////////////////////////////
sl@0	520	template <
sl@0	521	typename RT
sl@0	522	, typename A = nil_t
sl@0	523	, typename B = nil_t
sl@0	524	, typename C = nil_t
sl@0	525
sl@0	526	#if PHOENIX_LIMIT > 3
sl@0	527	, typename D = nil_t
sl@0	528	, typename E = nil_t
sl@0	529	, typename F = nil_t
sl@0	530
sl@0	531	#if PHOENIX_LIMIT > 6
sl@0	532	, typename G = nil_t
sl@0	533	, typename H = nil_t
sl@0	534	, typename I = nil_t
sl@0	535
sl@0	536	#if PHOENIX_LIMIT > 9
sl@0	537	, typename J = nil_t
sl@0	538	, typename K = nil_t
sl@0	539	, typename L = nil_t
sl@0	540
sl@0	541	#if PHOENIX_LIMIT > 12
sl@0	542	, typename M = nil_t
sl@0	543	, typename N = nil_t
sl@0	544	, typename O = nil_t
sl@0	545
sl@0	546	#endif
sl@0	547	#endif
sl@0	548	#endif
sl@0	549	#endif
sl@0	550	>
sl@0	551	struct function_ptr
sl@0	552	: public function<function_ptr_action<RT
sl@0	553	, A, B, C
sl@0	554	#if PHOENIX_LIMIT > 3
sl@0	555	, D, E, F
sl@0	556	#if PHOENIX_LIMIT > 6
sl@0	557	, G, H, I
sl@0	558	#if PHOENIX_LIMIT > 9
sl@0	559	, J, K, L
sl@0	560	#if PHOENIX_LIMIT > 12
sl@0	561	, M, N, O
sl@0	562	#endif
sl@0	563	#endif
sl@0	564	#endif
sl@0	565	#endif
sl@0	566	> > {
sl@0	567
sl@0	568	typedef function_ptr_action<RT
sl@0	569	, A, B, C
sl@0	570	#if PHOENIX_LIMIT > 3
sl@0	571	, D, E, F
sl@0	572	#if PHOENIX_LIMIT > 6
sl@0	573	, G, H, I
sl@0	574	#if PHOENIX_LIMIT > 9
sl@0	575	, J, K, L
sl@0	576	#if PHOENIX_LIMIT > 12
sl@0	577	, M, N, O
sl@0	578	#endif
sl@0	579	#endif
sl@0	580	#endif
sl@0	581	#endif
sl@0	582	> action_t;
sl@0	583
sl@0	584	template <typename FPT>
sl@0	585	function_ptr(FPT fp)
sl@0	586	: function<action_t>(action_t(fp)) {}
sl@0	587	};
sl@0	588
sl@0	589	///////////////////////////////////////////////////////////////////////////////
sl@0	590	//
sl@0	591	// Function pointer binder (specialization for 0 arg)
sl@0	592	//
sl@0	593	///////////////////////////////////////////////////////////////////////////////
sl@0	594	template <typename RT>
sl@0	595	struct function_ptr_action<RT,
sl@0	596	nil_t, nil_t, nil_t,
sl@0	597	#if PHOENIX_LIMIT > 3
sl@0	598	nil_t, nil_t, nil_t,
sl@0	599	#if PHOENIX_LIMIT > 6
sl@0	600	nil_t, nil_t, nil_t,
sl@0	601	#if PHOENIX_LIMIT > 9
sl@0	602	nil_t, nil_t, nil_t,
sl@0	603	#if PHOENIX_LIMIT > 12
sl@0	604	nil_t, nil_t, nil_t,
sl@0	605	#endif
sl@0	606	#endif
sl@0	607	#endif
sl@0	608	#endif
sl@0	609	nil_t // Unused
sl@0	610	> {
sl@0	611
sl@0	612	typedef RT result_type;
sl@0	613	typedef RT(*func_ptr_t)();
sl@0	614
sl@0	615	function_ptr_action(func_ptr_t fptr_)
sl@0	616	: fptr(fptr_) {}
sl@0	617
sl@0	618	result_type operator()() const
sl@0	619	{ return fptr(); }
sl@0	620
sl@0	621	func_ptr_t fptr;
sl@0	622	};
sl@0	623
sl@0	624	//////////////////////////////////
sl@0	625	template <typename RT>
sl@0	626	inline function_ptr<RT>
sl@0	627	bind(RT(*fptr)())
sl@0	628	{
sl@0	629	return function_ptr<RT>(fptr);
sl@0	630	}
sl@0	631
sl@0	632	///////////////////////////////////////////////////////////////////////////////
sl@0	633	//
sl@0	634	// Function pointer binder (specialization for 1 arg)
sl@0	635	//
sl@0	636	///////////////////////////////////////////////////////////////////////////////
sl@0	637	template <typename RT, typename A>
sl@0	638	struct function_ptr_action<RT,
sl@0	639	A, nil_t, nil_t,
sl@0	640	#if PHOENIX_LIMIT > 3
sl@0	641	nil_t, nil_t, nil_t,
sl@0	642	#if PHOENIX_LIMIT > 6
sl@0	643	nil_t, nil_t, nil_t,
sl@0	644	#if PHOENIX_LIMIT > 9
sl@0	645	nil_t, nil_t, nil_t,
sl@0	646	#if PHOENIX_LIMIT > 12
sl@0	647	nil_t, nil_t, nil_t,
sl@0	648	#endif
sl@0	649	#endif
sl@0	650	#endif
sl@0	651	#endif
sl@0	652	nil_t // Unused
sl@0	653	> {
sl@0	654
sl@0	655	typedef RT result_type;
sl@0	656	typedef RT(*func_ptr_t)(A);
sl@0	657
sl@0	658	template <typename A_>
sl@0	659	struct result { typedef result_type type; };
sl@0	660
sl@0	661	function_ptr_action(func_ptr_t fptr_)
sl@0	662	: fptr(fptr_) {}
sl@0	663
sl@0	664	result_type operator()(A a) const
sl@0	665	{ return fptr(a); }
sl@0	666
sl@0	667	func_ptr_t fptr;
sl@0	668	};
sl@0	669
sl@0	670	//////////////////////////////////
sl@0	671	template <typename RT, typename A>
sl@0	672	inline function_ptr<RT, A>
sl@0	673	bind(RT(*fptr)(A))
sl@0	674	{
sl@0	675	return function_ptr<RT, A>(fptr);
sl@0	676	}
sl@0	677
sl@0	678	///////////////////////////////////////////////////////////////////////////////
sl@0	679	//
sl@0	680	// Function pointer binder (specialization for 2 args)
sl@0	681	//
sl@0	682	///////////////////////////////////////////////////////////////////////////////
sl@0	683	template <typename RT, typename A, typename B>
sl@0	684	struct function_ptr_action<RT,
sl@0	685	A, B, nil_t,
sl@0	686	#if PHOENIX_LIMIT > 3
sl@0	687	nil_t, nil_t, nil_t,
sl@0	688	#if PHOENIX_LIMIT > 6
sl@0	689	nil_t, nil_t, nil_t,
sl@0	690	#if PHOENIX_LIMIT > 9
sl@0	691	nil_t, nil_t, nil_t,
sl@0	692	#if PHOENIX_LIMIT > 12
sl@0	693	nil_t, nil_t, nil_t,
sl@0	694	#endif
sl@0	695	#endif
sl@0	696	#endif
sl@0	697	#endif
sl@0	698	nil_t // Unused
sl@0	699	> {
sl@0	700
sl@0	701	typedef RT result_type;
sl@0	702	typedef RT(*func_ptr_t)(A, B);
sl@0	703
sl@0	704	template <typename A_, typename B_>
sl@0	705	struct result { typedef result_type type; };
sl@0	706
sl@0	707	function_ptr_action(func_ptr_t fptr_)
sl@0	708	: fptr(fptr_) {}
sl@0	709
sl@0	710	result_type operator()(A a, B b) const
sl@0	711	{ return fptr(a, b); }
sl@0	712
sl@0	713	func_ptr_t fptr;
sl@0	714	};
sl@0	715
sl@0	716	//////////////////////////////////
sl@0	717	template <typename RT, typename A, typename B>
sl@0	718	inline function_ptr<RT, A, B>
sl@0	719	bind(RT(*fptr)(A, B))
sl@0	720	{
sl@0	721	return function_ptr<RT, A, B>(fptr);
sl@0	722	}
sl@0	723
sl@0	724	///////////////////////////////////////////////////////////////////////////////
sl@0	725	//
sl@0	726	// Function pointer binder (specialization for 3 args)
sl@0	727	//
sl@0	728	///////////////////////////////////////////////////////////////////////////////
sl@0	729	template <typename RT, typename A, typename B, typename C>
sl@0	730	struct function_ptr_action<RT,
sl@0	731	A, B, C,
sl@0	732	#if PHOENIX_LIMIT > 3
sl@0	733	nil_t, nil_t, nil_t,
sl@0	734	#if PHOENIX_LIMIT > 6
sl@0	735	nil_t, nil_t, nil_t,
sl@0	736	#if PHOENIX_LIMIT > 9
sl@0	737	nil_t, nil_t, nil_t,
sl@0	738	#if PHOENIX_LIMIT > 12
sl@0	739	nil_t, nil_t, nil_t,
sl@0	740	#endif
sl@0	741	#endif
sl@0	742	#endif
sl@0	743	#endif
sl@0	744	nil_t // Unused
sl@0	745	> {
sl@0	746
sl@0	747	typedef RT result_type;
sl@0	748	typedef RT(*func_ptr_t)(A, B, C);
sl@0	749
sl@0	750	template <typename A_, typename B_, typename C_>
sl@0	751	struct result { typedef result_type type; };
sl@0	752
sl@0	753	function_ptr_action(func_ptr_t fptr_)
sl@0	754	: fptr(fptr_) {}
sl@0	755
sl@0	756	result_type operator()(A a, B b, C c) const
sl@0	757	{ return fptr(a, b, c); }
sl@0	758
sl@0	759	func_ptr_t fptr;
sl@0	760	};
sl@0	761
sl@0	762	//////////////////////////////////
sl@0	763	template <typename RT, typename A, typename B, typename C>
sl@0	764	inline function_ptr<RT, A, B, C>
sl@0	765	bind(RT(*fptr)(A, B, C))
sl@0	766	{
sl@0	767	return function_ptr<RT, A, B, C>(fptr);
sl@0	768	}
sl@0	769
sl@0	770	#if PHOENIX_LIMIT > 3
sl@0	771	///////////////////////////////////////////////////////////////////////////////
sl@0	772	//
sl@0	773	// Function pointer binder (specialization for 4 args)
sl@0	774	//
sl@0	775	///////////////////////////////////////////////////////////////////////////////
sl@0	776	template <typename RT, typename A, typename B, typename C, typename D>
sl@0	777	struct function_ptr_action<RT,
sl@0	778	A, B, C, D, nil_t, nil_t,
sl@0	779	#if PHOENIX_LIMIT > 6
sl@0	780	nil_t, nil_t, nil_t,
sl@0	781	#if PHOENIX_LIMIT > 9
sl@0	782	nil_t, nil_t, nil_t,
sl@0	783	#if PHOENIX_LIMIT > 12
sl@0	784	nil_t, nil_t, nil_t,
sl@0	785	#endif
sl@0	786	#endif
sl@0	787	#endif
sl@0	788	nil_t // Unused
sl@0	789	> {
sl@0	790
sl@0	791	typedef RT result_type;
sl@0	792	typedef RT(*func_ptr_t)(A, B, C, D);
sl@0	793
sl@0	794	template <typename A_, typename B_, typename C_, typename D_>
sl@0	795	struct result { typedef result_type type; };
sl@0	796
sl@0	797	function_ptr_action(func_ptr_t fptr_)
sl@0	798	: fptr(fptr_) {}
sl@0	799
sl@0	800	result_type operator()(A a, B b, C c, D d) const
sl@0	801	{ return fptr(a, b, c, d); }
sl@0	802
sl@0	803	func_ptr_t fptr;
sl@0	804	};
sl@0	805
sl@0	806	//////////////////////////////////
sl@0	807	template <typename RT, typename A, typename B, typename C, typename D>
sl@0	808	inline function_ptr<RT, A, B, C, D>
sl@0	809	bind(RT(*fptr)(A, B, C, D))
sl@0	810	{
sl@0	811	return function_ptr<RT, A, B, C, D>(fptr);
sl@0	812	}
sl@0	813
sl@0	814	///////////////////////////////////////////////////////////////////////////////
sl@0	815	//
sl@0	816	// Function pointer binder (specialization for 5 args)
sl@0	817	//
sl@0	818	///////////////////////////////////////////////////////////////////////////////
sl@0	819	template <typename RT,
sl@0	820	typename A, typename B, typename C, typename D, typename E
sl@0	821	>
sl@0	822	struct function_ptr_action<RT,
sl@0	823	A, B, C, D, E, nil_t,
sl@0	824	#if PHOENIX_LIMIT > 6
sl@0	825	nil_t, nil_t, nil_t,
sl@0	826	#if PHOENIX_LIMIT > 9
sl@0	827	nil_t, nil_t, nil_t,
sl@0	828	#if PHOENIX_LIMIT > 12
sl@0	829	nil_t, nil_t, nil_t,
sl@0	830	#endif
sl@0	831	#endif
sl@0	832	#endif
sl@0	833	nil_t // Unused
sl@0	834	> {
sl@0	835
sl@0	836	typedef RT result_type;
sl@0	837	typedef RT(*func_ptr_t)(A, B, C, D, E);
sl@0	838
sl@0	839	template <
sl@0	840	typename A_, typename B_, typename C_, typename D_, typename E_
sl@0	841	>
sl@0	842	struct result { typedef result_type type; };
sl@0	843
sl@0	844	function_ptr_action(func_ptr_t fptr_)
sl@0	845	: fptr(fptr_) {}
sl@0	846
sl@0	847	result_type operator()(
sl@0	848	A a, B b, C c, D d, E e
sl@0	849	) const
sl@0	850	{ return fptr(a, b, c, d, e); }
sl@0	851
sl@0	852	func_ptr_t fptr;
sl@0	853	};
sl@0	854
sl@0	855	//////////////////////////////////
sl@0	856	template <typename RT,
sl@0	857	typename A, typename B, typename C, typename D, typename E
sl@0	858	>
sl@0	859	inline function_ptr<RT, A, B, C, D, E>
sl@0	860	bind(RT(*fptr)(A, B, C, D, E))
sl@0	861	{
sl@0	862	return function_ptr<RT, A, B, C, D, E>(fptr);
sl@0	863	}
sl@0	864
sl@0	865	///////////////////////////////////////////////////////////////////////////////
sl@0	866	//
sl@0	867	// Function pointer binder (specialization for 6 args)
sl@0	868	//
sl@0	869	///////////////////////////////////////////////////////////////////////////////
sl@0	870	template <typename RT,
sl@0	871	typename A, typename B, typename C, typename D, typename E,
sl@0	872	typename F
sl@0	873	>
sl@0	874	struct function_ptr_action<RT,
sl@0	875	A, B, C, D, E, F,
sl@0	876	#if PHOENIX_LIMIT > 6
sl@0	877	nil_t, nil_t, nil_t,
sl@0	878	#if PHOENIX_LIMIT > 9
sl@0	879	nil_t, nil_t, nil_t,
sl@0	880	#if PHOENIX_LIMIT > 12
sl@0	881	nil_t, nil_t, nil_t,
sl@0	882	#endif
sl@0	883	#endif
sl@0	884	#endif
sl@0	885	nil_t // Unused
sl@0	886	> {
sl@0	887
sl@0	888	typedef RT result_type;
sl@0	889	typedef RT(*func_ptr_t)(A, B, C, D, E, F);
sl@0	890
sl@0	891	template <
sl@0	892	typename A_, typename B_, typename C_, typename D_, typename E_,
sl@0	893	typename F_
sl@0	894	>
sl@0	895	struct result { typedef result_type type; };
sl@0	896
sl@0	897	function_ptr_action(func_ptr_t fptr_)
sl@0	898	: fptr(fptr_) {}
sl@0	899
sl@0	900	result_type operator()(
sl@0	901	A a, B b, C c, D d, E e,
sl@0	902	F f
sl@0	903	) const
sl@0	904	{ return fptr(a, b, c, d, e, f); }
sl@0	905
sl@0	906	func_ptr_t fptr;
sl@0	907	};
sl@0	908
sl@0	909	//////////////////////////////////
sl@0	910	template <typename RT,
sl@0	911	typename A, typename B, typename C, typename D, typename E,
sl@0	912	typename F
sl@0	913	>
sl@0	914	inline function_ptr<RT, A, B, C, D, E, F>
sl@0	915	bind(RT(*fptr)(A, B, C, D, E, F))
sl@0	916	{
sl@0	917	return function_ptr<RT, A, B, C, D, E, F>(fptr);
sl@0	918	}
sl@0	919
sl@0	920	#if PHOENIX_LIMIT > 6
sl@0	921	///////////////////////////////////////////////////////////////////////////////
sl@0	922	//
sl@0	923	// Function pointer binder (specialization for 7 args)
sl@0	924	//
sl@0	925	///////////////////////////////////////////////////////////////////////////////
sl@0	926	template <typename RT,
sl@0	927	typename A, typename B, typename C, typename D, typename E,
sl@0	928	typename F, typename G
sl@0	929	>
sl@0	930	struct function_ptr_action<RT,
sl@0	931	A, B, C, D, E, F, G, nil_t, nil_t,
sl@0	932	#if PHOENIX_LIMIT > 9
sl@0	933	nil_t, nil_t, nil_t,
sl@0	934	#if PHOENIX_LIMIT > 12
sl@0	935	nil_t, nil_t, nil_t,
sl@0	936	#endif
sl@0	937	#endif
sl@0	938	nil_t // Unused
sl@0	939	> {
sl@0	940
sl@0	941	typedef RT result_type;
sl@0	942	typedef RT(*func_ptr_t)(A, B, C, D, E, F, G);
sl@0	943
sl@0	944	template <
sl@0	945	typename A_, typename B_, typename C_, typename D_, typename E_,
sl@0	946	typename F_, typename G_
sl@0	947	>
sl@0	948	struct result { typedef result_type type; };
sl@0	949
sl@0	950	function_ptr_action(func_ptr_t fptr_)
sl@0	951	: fptr(fptr_) {}
sl@0	952
sl@0	953	result_type operator()(
sl@0	954	A a, B b, C c, D d, E e,
sl@0	955	F f, G g
sl@0	956	) const
sl@0	957	{ return fptr(a, b, c, d, e, f, g); }
sl@0	958
sl@0	959	func_ptr_t fptr;
sl@0	960	};
sl@0	961
sl@0	962	//////////////////////////////////
sl@0	963	template <typename RT,
sl@0	964	typename A, typename B, typename C, typename D, typename E,
sl@0	965	typename F, typename G
sl@0	966	>
sl@0	967	inline function_ptr<RT, A, B, C, D, E, F, G>
sl@0	968	bind(RT(*fptr)(A, B, C, D, E, F, G))
sl@0	969	{
sl@0	970	return function_ptr<RT, A, B, C, D, E, F, G>(fptr);
sl@0	971	}
sl@0	972
sl@0	973	///////////////////////////////////////////////////////////////////////////////
sl@0	974	//
sl@0	975	// Function pointer binder (specialization for 8 args)
sl@0	976	//
sl@0	977	///////////////////////////////////////////////////////////////////////////////
sl@0	978	template <typename RT,
sl@0	979	typename A, typename B, typename C, typename D, typename E,
sl@0	980	typename F, typename G, typename H
sl@0	981	>
sl@0	982	struct function_ptr_action<RT,
sl@0	983	A, B, C, D, E, F, G, H, nil_t,
sl@0	984	#if PHOENIX_LIMIT > 9
sl@0	985	nil_t, nil_t, nil_t,
sl@0	986	#if PHOENIX_LIMIT > 12
sl@0	987	nil_t, nil_t, nil_t,
sl@0	988	#endif
sl@0	989	#endif
sl@0	990	nil_t // Unused
sl@0	991	> {
sl@0	992
sl@0	993	typedef RT result_type;
sl@0	994	typedef RT(*func_ptr_t)(A, B, C, D, E, F, G, H);
sl@0	995
sl@0	996	template <
sl@0	997	typename A_, typename B_, typename C_, typename D_, typename E_,
sl@0	998	typename F_, typename G_, typename H_
sl@0	999	>
sl@0	1000	struct result { typedef result_type type; };
sl@0	1001
sl@0	1002	function_ptr_action(func_ptr_t fptr_)
sl@0	1003	: fptr(fptr_) {}
sl@0	1004
sl@0	1005	result_type operator()(
sl@0	1006	A a, B b, C c, D d, E e,
sl@0	1007	F f, G g, H h
sl@0	1008	) const
sl@0	1009	{ return fptr(a, b, c, d, e, f, g, h); }
sl@0	1010
sl@0	1011	func_ptr_t fptr;
sl@0	1012	};
sl@0	1013
sl@0	1014	//////////////////////////////////
sl@0	1015	template <typename RT,
sl@0	1016	typename A, typename B, typename C, typename D, typename E,
sl@0	1017	typename F, typename G, typename H
sl@0	1018	>
sl@0	1019	inline function_ptr<RT, A, B, C, D, E, F, G, H>
sl@0	1020	bind(RT(*fptr)(A, B, C, D, E, F, G, H))
sl@0	1021	{
sl@0	1022	return function_ptr<RT, A, B, C, D, E, F, G, H>(fptr);
sl@0	1023	}
sl@0	1024
sl@0	1025	///////////////////////////////////////////////////////////////////////////////
sl@0	1026	//
sl@0	1027	// Function pointer binder (specialization for 9 args)
sl@0	1028	//
sl@0	1029	///////////////////////////////////////////////////////////////////////////////
sl@0	1030	template <typename RT,
sl@0	1031	typename A, typename B, typename C, typename D, typename E,
sl@0	1032	typename F, typename G, typename H, typename I
sl@0	1033	>
sl@0	1034	struct function_ptr_action<RT,
sl@0	1035	A, B, C, D, E, F, G, H, I,
sl@0	1036	#if PHOENIX_LIMIT > 9
sl@0	1037	nil_t, nil_t, nil_t,
sl@0	1038	#if PHOENIX_LIMIT > 12
sl@0	1039	nil_t, nil_t, nil_t,
sl@0	1040	#endif
sl@0	1041	#endif
sl@0	1042	nil_t // Unused
sl@0	1043	> {
sl@0	1044
sl@0	1045	typedef RT result_type;
sl@0	1046	typedef RT(*func_ptr_t)(A, B, C, D, E, F, G, H, I);
sl@0	1047
sl@0	1048	template <
sl@0	1049	typename A_, typename B_, typename C_, typename D_, typename E_,
sl@0	1050	typename F_, typename G_, typename H_, typename I_
sl@0	1051	>
sl@0	1052	struct result { typedef result_type type; };
sl@0	1053
sl@0	1054	function_ptr_action(func_ptr_t fptr_)
sl@0	1055	: fptr(fptr_) {}
sl@0	1056
sl@0	1057	result_type operator()(
sl@0	1058	A a, B b, C c, D d, E e,
sl@0	1059	F f, G g, H h, I i
sl@0	1060	) const
sl@0	1061	{ return fptr(a, b, c, d, e, f, g, h, i); }
sl@0	1062
sl@0	1063	func_ptr_t fptr;
sl@0	1064	};
sl@0	1065
sl@0	1066	//////////////////////////////////
sl@0	1067	template <typename RT,
sl@0	1068	typename A, typename B, typename C, typename D, typename E,
sl@0	1069	typename F, typename G, typename H, typename I
sl@0	1070	>
sl@0	1071	inline function_ptr<RT, A, B, C, D, E, F, G, H, I>
sl@0	1072	bind(RT(*fptr)(A, B, C, D, E, F, G, H, I))
sl@0	1073	{
sl@0	1074	return function_ptr<RT, A, B, C, D, E, F, G, H, I>(fptr);
sl@0	1075	}
sl@0	1076
sl@0	1077	#if PHOENIX_LIMIT > 9
sl@0	1078	///////////////////////////////////////////////////////////////////////////////
sl@0	1079	//
sl@0	1080	// Function pointer binder (specialization for 10 args)
sl@0	1081	//
sl@0	1082	///////////////////////////////////////////////////////////////////////////////
sl@0	1083	template <typename RT,
sl@0	1084	typename A, typename B, typename C, typename D, typename E,
sl@0	1085	typename F, typename G, typename H, typename I, typename J
sl@0	1086	>
sl@0	1087	struct function_ptr_action<RT,
sl@0	1088	A, B, C, D, E, F, G, H, I, J, nil_t, nil_t,
sl@0	1089	#if PHOENIX_LIMIT > 12
sl@0	1090	nil_t, nil_t, nil_t,
sl@0	1091	#endif
sl@0	1092	nil_t // Unused
sl@0	1093	> {
sl@0	1094
sl@0	1095	typedef RT result_type;
sl@0	1096	typedef RT(*func_ptr_t)(A, B, C, D, E, F, G, H, I, J);
sl@0	1097
sl@0	1098	template <
sl@0	1099	typename A_, typename B_, typename C_, typename D_, typename E_,
sl@0	1100	typename F_, typename G_, typename H_, typename I_, typename J_
sl@0	1101	>
sl@0	1102	struct result { typedef result_type type; };
sl@0	1103
sl@0	1104	function_ptr_action(func_ptr_t fptr_)
sl@0	1105	: fptr(fptr_) {}
sl@0	1106
sl@0	1107	result_type operator()(
sl@0	1108	A a, B b, C c, D d, E e,
sl@0	1109	F f, G g, H h, I i, J j
sl@0	1110	) const
sl@0	1111	{ return fptr(a, b, c, d, e, f, g, h, i, j); }
sl@0	1112
sl@0	1113	func_ptr_t fptr;
sl@0	1114	};
sl@0	1115
sl@0	1116	//////////////////////////////////
sl@0	1117	template <typename RT,
sl@0	1118	typename A, typename B, typename C, typename D, typename E,
sl@0	1119	typename F, typename G, typename H, typename I, typename J
sl@0	1120	>
sl@0	1121	inline function_ptr<RT, A, B, C, D, E, F, G, H, I, J>
sl@0	1122	bind(RT(*fptr)(A, B, C, D, E, F, G, H, I, J))
sl@0	1123	{
sl@0	1124	return function_ptr<RT, A, B, C, D, E, F, G, H, I, J>(fptr);
sl@0	1125	}
sl@0	1126
sl@0	1127	///////////////////////////////////////////////////////////////////////////////
sl@0	1128	//
sl@0	1129	// Function pointer binder (specialization for 11 args)
sl@0	1130	//
sl@0	1131	///////////////////////////////////////////////////////////////////////////////
sl@0	1132	template <typename RT,
sl@0	1133	typename A, typename B, typename C, typename D, typename E,
sl@0	1134	typename F, typename G, typename H, typename I, typename J,
sl@0	1135	typename K
sl@0	1136	>
sl@0	1137	struct function_ptr_action<RT,
sl@0	1138	A, B, C, D, E, F, G, H, I, J, K, nil_t,
sl@0	1139	#if PHOENIX_LIMIT > 12
sl@0	1140	nil_t, nil_t, nil_t,
sl@0	1141	#endif
sl@0	1142	nil_t // Unused
sl@0	1143	> {
sl@0	1144
sl@0	1145	typedef RT result_type;
sl@0	1146	typedef RT(*func_ptr_t)(A, B, C, D, E, F, G, H, I, J, K);
sl@0	1147
sl@0	1148	template <
sl@0	1149	typename A_, typename B_, typename C_, typename D_, typename E_,
sl@0	1150	typename F_, typename G_, typename H_, typename I_, typename J_,
sl@0	1151	typename K_
sl@0	1152	>
sl@0	1153	struct result { typedef result_type type; };
sl@0	1154
sl@0	1155	function_ptr_action(func_ptr_t fptr_)
sl@0	1156	: fptr(fptr_) {}
sl@0	1157
sl@0	1158	result_type operator()(
sl@0	1159	A a, B b, C c, D d, E e,
sl@0	1160	F f, G g, H h, I i, J j,
sl@0	1161	K k
sl@0	1162	) const
sl@0	1163	{ return fptr(a, b, c, d, e, f, g, h, i, j, k); }
sl@0	1164
sl@0	1165	func_ptr_t fptr;
sl@0	1166	};
sl@0	1167
sl@0	1168	//////////////////////////////////
sl@0	1169	template <typename RT,
sl@0	1170	typename A, typename B, typename C, typename D, typename E,
sl@0	1171	typename F, typename G, typename H, typename I, typename J,
sl@0	1172	typename K
sl@0	1173	>
sl@0	1174	inline function_ptr<RT, A, B, C, D, E, F, G, H, I, J, K>
sl@0	1175	bind(RT(*fptr)(A, B, C, D, E, F, G, H, I, J, K))
sl@0	1176	{
sl@0	1177	return function_ptr<RT, A, B, C, D, E, F, G, H, I, J, K>(fptr);
sl@0	1178	}
sl@0	1179
sl@0	1180	///////////////////////////////////////////////////////////////////////////////
sl@0	1181	//
sl@0	1182	// Function pointer binder (specialization for 12 args)
sl@0	1183	//
sl@0	1184	///////////////////////////////////////////////////////////////////////////////
sl@0	1185	template <typename RT,
sl@0	1186	typename A, typename B, typename C, typename D, typename E,
sl@0	1187	typename F, typename G, typename H, typename I, typename J,
sl@0	1188	typename K, typename L
sl@0	1189	>
sl@0	1190	struct function_ptr_action<RT,
sl@0	1191	A, B, C, D, E, F, G, H, I, J, K, L,
sl@0	1192	#if PHOENIX_LIMIT > 12
sl@0	1193	nil_t, nil_t, nil_t,
sl@0	1194	#endif
sl@0	1195	nil_t // Unused
sl@0	1196	> {
sl@0	1197
sl@0	1198	typedef RT result_type;
sl@0	1199	typedef RT(*func_ptr_t)(A, B, C, D, E, F, G, H, I, J, K, L);
sl@0	1200
sl@0	1201	template <
sl@0	1202	typename A_, typename B_, typename C_, typename D_, typename E_,
sl@0	1203	typename F_, typename G_, typename H_, typename I_, typename J_,
sl@0	1204	typename K_, typename L_
sl@0	1205	>
sl@0	1206	struct result { typedef result_type type; };
sl@0	1207
sl@0	1208	function_ptr_action(func_ptr_t fptr_)
sl@0	1209	: fptr(fptr_) {}
sl@0	1210
sl@0	1211	result_type operator()(
sl@0	1212	A a, B b, C c, D d, E e,
sl@0	1213	F f, G g, H h, I i, J j,
sl@0	1214	K k, L l
sl@0	1215	) const
sl@0	1216	{ return fptr(a, b, c, d, e, f, g, h, i, j, k, l); }
sl@0	1217
sl@0	1218	func_ptr_t fptr;
sl@0	1219	};
sl@0	1220
sl@0	1221	//////////////////////////////////
sl@0	1222	template <typename RT,
sl@0	1223	typename A, typename B, typename C, typename D, typename E,
sl@0	1224	typename F, typename G, typename H, typename I, typename J,
sl@0	1225	typename K, typename L
sl@0	1226	>
sl@0	1227	inline function_ptr<RT, A, B, C, D, E, F, G, H, I, J, K, L>
sl@0	1228	bind(RT(*fptr)(A, B, C, D, E, F, G, H, I, J, K, L))
sl@0	1229	{
sl@0	1230	return function_ptr<RT, A, B, C, D, E, F, G, H, I, J, K, L>(fptr);
sl@0	1231	}
sl@0	1232
sl@0	1233	#if PHOENIX_LIMIT > 12
sl@0	1234	///////////////////////////////////////////////////////////////////////////////
sl@0	1235	//
sl@0	1236	// Function pointer binder (specialization for 13 args)
sl@0	1237	//
sl@0	1238	///////////////////////////////////////////////////////////////////////////////
sl@0	1239	template <typename RT,
sl@0	1240	typename A, typename B, typename C, typename D, typename E,
sl@0	1241	typename F, typename G, typename H, typename I, typename J,
sl@0	1242	typename K, typename L, typename M
sl@0	1243	>
sl@0	1244	struct function_ptr_action<RT,
sl@0	1245	A, B, C, D, E, F, G, H, I, J, K, L, M, nil_t, nil_t, nil_t> {
sl@0	1246
sl@0	1247	typedef RT result_type;
sl@0	1248	typedef RT(*func_ptr_t)(A, B, C, D, E, F, G, H, I, J, K, L, M);
sl@0	1249
sl@0	1250	template <
sl@0	1251	typename A_, typename B_, typename C_, typename D_, typename E_,
sl@0	1252	typename F_, typename G_, typename H_, typename I_, typename J_,
sl@0	1253	typename K_, typename L_, typename M_
sl@0	1254	>
sl@0	1255	struct result { typedef result_type type; };
sl@0	1256
sl@0	1257	function_ptr_action(func_ptr_t fptr_)
sl@0	1258	: fptr(fptr_) {}
sl@0	1259
sl@0	1260	result_type operator()(
sl@0	1261	A a, B b, C c, D d, E e,
sl@0	1262	F f, G g, H h, I i, J j,
sl@0	1263	K k, L l, M m
sl@0	1264	) const
sl@0	1265	{ return fptr(a, b, c, d, e, f, g, h, i, j, k, l, m); }
sl@0	1266
sl@0	1267	func_ptr_t fptr;
sl@0	1268	};
sl@0	1269
sl@0	1270	//////////////////////////////////
sl@0	1271	template <typename RT,
sl@0	1272	typename A, typename B, typename C, typename D, typename E,
sl@0	1273	typename F, typename G, typename H, typename I, typename J,
sl@0	1274	typename K, typename L, typename M
sl@0	1275	>
sl@0	1276	inline function_ptr<RT, A, B, C, D, E, F, G, H, I, J, K, L, M>
sl@0	1277	bind(RT(*fptr)(A, B, C, D, E, F, G, H, I, J, K, L, M))
sl@0	1278	{
sl@0	1279	return function_ptr<RT, A, B, C, D, E, F, G, H, I, J, K, L, M>(fptr);
sl@0	1280	}
sl@0	1281
sl@0	1282	///////////////////////////////////////////////////////////////////////////////
sl@0	1283	//
sl@0	1284	// Function pointer binder (specialization for 14 args)
sl@0	1285	//
sl@0	1286	///////////////////////////////////////////////////////////////////////////////
sl@0	1287	template <typename RT,
sl@0	1288	typename A, typename B, typename C, typename D, typename E,
sl@0	1289	typename F, typename G, typename H, typename I, typename J,
sl@0	1290	typename K, typename L, typename M, typename N
sl@0	1291	>
sl@0	1292	struct function_ptr_action<RT,
sl@0	1293	A, B, C, D, E, F, G, H, I, J, K, L, M, N, nil_t, nil_t> {
sl@0	1294
sl@0	1295	typedef RT result_type;
sl@0	1296	typedef RT(*func_ptr_t)(A, B, C, D, E, F, G, H, I, J, K, L, M, N);
sl@0	1297
sl@0	1298	template <
sl@0	1299	typename A_, typename B_, typename C_, typename D_, typename E_,
sl@0	1300	typename F_, typename G_, typename H_, typename I_, typename J_,
sl@0	1301	typename K_, typename L_, typename M_, typename N_
sl@0	1302	>
sl@0	1303	struct result { typedef result_type type; };
sl@0	1304
sl@0	1305	function_ptr_action(func_ptr_t fptr_)
sl@0	1306	: fptr(fptr_) {}
sl@0	1307
sl@0	1308	result_type operator()(
sl@0	1309	A a, B b, C c, D d, E e,
sl@0	1310	F f, G g, H h, I i, J j,
sl@0	1311	K k, L l, M m, N n
sl@0	1312	) const
sl@0	1313	{ return fptr(a, b, c, d, e, f, g, h, i, j, k, l, m, n); }
sl@0	1314
sl@0	1315	func_ptr_t fptr;
sl@0	1316	};
sl@0	1317
sl@0	1318	//////////////////////////////////
sl@0	1319	template <typename RT,
sl@0	1320	typename A, typename B, typename C, typename D, typename E,
sl@0	1321	typename F, typename G, typename H, typename I, typename J,
sl@0	1322	typename K, typename L, typename M, typename N
sl@0	1323	>
sl@0	1324	inline function_ptr<RT, A, B, C, D, E, F, G, H, I, J, K, L, M, N>
sl@0	1325	bind(RT(*fptr)(A, B, C, D, E, F, G, H, I, J, K, L, M, N))
sl@0	1326	{
sl@0	1327	return function_ptr<RT, A, B, C, D, E, F, G, H, I, J, K, L, M, N>(fptr);
sl@0	1328	}
sl@0	1329
sl@0	1330	///////////////////////////////////////////////////////////////////////////////
sl@0	1331	//
sl@0	1332	// Function pointer binder (specialization for 15 args)
sl@0	1333	//
sl@0	1334	///////////////////////////////////////////////////////////////////////////////
sl@0	1335	template <typename RT,
sl@0	1336	typename A, typename B, typename C, typename D, typename E,
sl@0	1337	typename F, typename G, typename H, typename I, typename J,
sl@0	1338	typename K, typename L, typename M, typename N, typename O
sl@0	1339	>
sl@0	1340	struct function_ptr_action<RT,
sl@0	1341	A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, nil_t> {
sl@0	1342
sl@0	1343	typedef RT result_type;
sl@0	1344	typedef RT(*func_ptr_t)(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O);
sl@0	1345
sl@0	1346	template <
sl@0	1347	typename A_, typename B_, typename C_, typename D_, typename E_,
sl@0	1348	typename F_, typename G_, typename H_, typename I_, typename J_,
sl@0	1349	typename K_, typename L_, typename M_, typename N_, typename O_
sl@0	1350	>
sl@0	1351	struct result { typedef result_type type; };
sl@0	1352
sl@0	1353	function_ptr_action(func_ptr_t fptr_)
sl@0	1354	: fptr(fptr_) {}
sl@0	1355
sl@0	1356	result_type operator()(
sl@0	1357	A a, B b, C c, D d, E e,
sl@0	1358	F f, G g, H h, I i, J j,
sl@0	1359	K k, L l, M m, N n, O o
sl@0	1360	) const
sl@0	1361	{ return fptr(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o); }
sl@0	1362
sl@0	1363	func_ptr_t fptr;
sl@0	1364	};
sl@0	1365
sl@0	1366	//////////////////////////////////
sl@0	1367	template <typename RT,
sl@0	1368	typename A, typename B, typename C, typename D, typename E,
sl@0	1369	typename F, typename G, typename H, typename I, typename J,
sl@0	1370	typename K, typename L, typename M, typename N, typename O
sl@0	1371	>
sl@0	1372	inline function_ptr<RT, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>
sl@0	1373	bind(RT(*fptr)(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O))
sl@0	1374	{
sl@0	1375	return function_ptr<RT, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(fptr);
sl@0	1376	}
sl@0	1377
sl@0	1378	#endif
sl@0	1379	#endif
sl@0	1380	#endif
sl@0	1381	#endif
sl@0	1382	///////////////////////////////////////////////////////////////////////////////
sl@0	1383	//
sl@0	1384	// Member function pointer binder (main class)
sl@0	1385	//
sl@0	1386	///////////////////////////////////////////////////////////////////////////////
sl@0	1387	template <
sl@0	1388	typename RT,
sl@0	1389	typename ClassT
sl@0	1390	, typename A = nil_t
sl@0	1391	, typename B = nil_t
sl@0	1392	, typename C = nil_t
sl@0	1393
sl@0	1394	#if PHOENIX_LIMIT > 3
sl@0	1395	, typename D = nil_t
sl@0	1396	, typename E = nil_t
sl@0	1397	, typename F = nil_t
sl@0	1398
sl@0	1399	#if PHOENIX_LIMIT > 6
sl@0	1400	, typename G = nil_t
sl@0	1401	, typename H = nil_t
sl@0	1402	, typename I = nil_t
sl@0	1403
sl@0	1404	#if PHOENIX_LIMIT > 9
sl@0	1405	, typename J = nil_t
sl@0	1406	, typename K = nil_t
sl@0	1407	, typename L = nil_t
sl@0	1408
sl@0	1409	#if PHOENIX_LIMIT > 12
sl@0	1410	, typename M = nil_t
sl@0	1411	, typename N = nil_t
sl@0	1412	, typename O = nil_t
sl@0	1413
sl@0	1414	#endif
sl@0	1415	#endif
sl@0	1416	#endif
sl@0	1417	#endif
sl@0	1418
sl@0	1419	, typename NU = nil_t // Not used
sl@0	1420	>
sl@0	1421	struct member_function_ptr_action;
sl@0	1422
sl@0	1423	//////////////////////////////////
sl@0	1424	template <
sl@0	1425	typename RT,
sl@0	1426	typename ClassT
sl@0	1427	, typename A = nil_t
sl@0	1428	, typename B = nil_t
sl@0	1429	, typename C = nil_t
sl@0	1430
sl@0	1431	#if PHOENIX_LIMIT > 3
sl@0	1432	, typename D = nil_t
sl@0	1433	, typename E = nil_t
sl@0	1434	, typename F = nil_t
sl@0	1435
sl@0	1436	#if PHOENIX_LIMIT > 6
sl@0	1437	, typename G = nil_t
sl@0	1438	, typename H = nil_t
sl@0	1439	, typename I = nil_t
sl@0	1440
sl@0	1441	#if PHOENIX_LIMIT > 9
sl@0	1442	, typename J = nil_t
sl@0	1443	, typename K = nil_t
sl@0	1444	, typename L = nil_t
sl@0	1445
sl@0	1446	#if PHOENIX_LIMIT > 12
sl@0	1447	, typename M = nil_t
sl@0	1448	, typename N = nil_t
sl@0	1449	, typename O = nil_t
sl@0	1450
sl@0	1451	#endif
sl@0	1452	#endif
sl@0	1453	#endif
sl@0	1454	#endif
sl@0	1455	>
sl@0	1456	struct member_function_ptr
sl@0	1457	: public function<member_function_ptr_action<RT, ClassT
sl@0	1458	, A, B, C
sl@0	1459	#if PHOENIX_LIMIT > 3
sl@0	1460	, D, E, F
sl@0	1461	#if PHOENIX_LIMIT > 6
sl@0	1462	, G, H, I
sl@0	1463	#if PHOENIX_LIMIT > 9
sl@0	1464	, J, K, L
sl@0	1465	#if PHOENIX_LIMIT > 12
sl@0	1466	, M, N, O
sl@0	1467	#endif
sl@0	1468	#endif
sl@0	1469	#endif
sl@0	1470	#endif
sl@0	1471	> > {
sl@0	1472
sl@0	1473	typedef member_function_ptr_action<RT, ClassT
sl@0	1474	, A, B, C
sl@0	1475	#if PHOENIX_LIMIT > 3
sl@0	1476	, D, E, F
sl@0	1477	#if PHOENIX_LIMIT > 6
sl@0	1478	, G, H, I
sl@0	1479	#if PHOENIX_LIMIT > 9
sl@0	1480	, J, K, L
sl@0	1481	#if PHOENIX_LIMIT > 12
sl@0	1482	, M, N, O
sl@0	1483	#endif
sl@0	1484	#endif
sl@0	1485	#endif
sl@0	1486	#endif
sl@0	1487	> action_t;
sl@0	1488
sl@0	1489	template <typename FPT>
sl@0	1490	member_function_ptr(FPT fp)
sl@0	1491	: function<action_t>(action_t(fp)) {}
sl@0	1492	};
sl@0	1493
sl@0	1494	///////////////////////////////////////////////////////////////////////////////
sl@0	1495	//
sl@0	1496	// Member function pointer binder (specialization for 0 arg)
sl@0	1497	//
sl@0	1498	///////////////////////////////////////////////////////////////////////////////
sl@0	1499	template <typename RT, typename ClassT>
sl@0	1500	struct member_function_ptr_action<RT, ClassT,
sl@0	1501	nil_t, nil_t, nil_t,
sl@0	1502	#if PHOENIX_LIMIT > 3
sl@0	1503	nil_t, nil_t, nil_t,
sl@0	1504	#if PHOENIX_LIMIT > 6
sl@0	1505	nil_t, nil_t, nil_t,
sl@0	1506	#if PHOENIX_LIMIT > 9
sl@0	1507	nil_t, nil_t, nil_t,
sl@0	1508	#if PHOENIX_LIMIT > 12
sl@0	1509	nil_t, nil_t, nil_t,
sl@0	1510	#endif
sl@0	1511	#endif
sl@0	1512	#endif
sl@0	1513	#endif
sl@0	1514	nil_t // Unused
sl@0	1515	> {
sl@0	1516
sl@0	1517	typedef RT result_type;
sl@0	1518	typedef RT(ClassT::*mf)();
sl@0	1519	typedef RT(ClassT::*cmf)() const;
sl@0	1520	typedef typename boost::mpl::if_<boost::is_const<ClassT>, cmf, mf>::type
sl@0	1521	mem_func_ptr_t;
sl@0	1522
sl@0	1523	template <typename CT>
sl@0	1524	struct result { typedef result_type type; };
sl@0	1525
sl@0	1526	member_function_ptr_action(mem_func_ptr_t fptr_)
sl@0	1527	: fptr(fptr_) {}
sl@0	1528
sl@0	1529	template <typename CT>
sl@0	1530	result_type operator()(CT& obj) const
sl@0	1531	{ return (impl::as_ptr<CT>::get(obj)->*fptr)(); }
sl@0	1532
sl@0	1533	mem_func_ptr_t fptr;
sl@0	1534	};
sl@0	1535
sl@0	1536	//////////////////////////////////
sl@0	1537	template <typename RT, typename ClassT>
sl@0	1538	inline member_function_ptr<RT, ClassT>
sl@0	1539	bind(RT(ClassT::*fptr)())
sl@0	1540	{
sl@0	1541	return member_function_ptr<RT, ClassT>(fptr);
sl@0	1542	}
sl@0	1543
sl@0	1544	template <typename RT, typename ClassT>
sl@0	1545	inline member_function_ptr<RT, ClassT const>
sl@0	1546	bind(RT(ClassT::*fptr)() const)
sl@0	1547	{
sl@0	1548	return member_function_ptr<RT, ClassT const>(fptr);
sl@0	1549	}
sl@0	1550
sl@0	1551	///////////////////////////////////////////////////////////////////////////////
sl@0	1552	//
sl@0	1553	// Member function pointer binder (specialization for 1 arg)
sl@0	1554	//
sl@0	1555	///////////////////////////////////////////////////////////////////////////////
sl@0	1556	template <typename RT, typename ClassT, typename A>
sl@0	1557	struct member_function_ptr_action<RT, ClassT,
sl@0	1558	A, nil_t, nil_t,
sl@0	1559	#if PHOENIX_LIMIT > 3
sl@0	1560	nil_t, nil_t, nil_t,
sl@0	1561	#if PHOENIX_LIMIT > 6
sl@0	1562	nil_t, nil_t, nil_t,
sl@0	1563	#if PHOENIX_LIMIT > 9
sl@0	1564	nil_t, nil_t, nil_t,
sl@0	1565	#if PHOENIX_LIMIT > 12
sl@0	1566	nil_t, nil_t, nil_t,
sl@0	1567	#endif
sl@0	1568	#endif
sl@0	1569	#endif
sl@0	1570	#endif
sl@0	1571	nil_t // Unused
sl@0	1572	> {
sl@0	1573
sl@0	1574	typedef RT result_type;
sl@0	1575	typedef RT(ClassT::*mf)(A);
sl@0	1576	typedef RT(ClassT::*cmf)(A) const;
sl@0	1577	typedef typename boost::mpl::if_<boost::is_const<ClassT>, cmf, mf>::type
sl@0	1578	mem_func_ptr_t;
sl@0	1579
sl@0	1580	template <typename CT, typename A_>
sl@0	1581	struct result { typedef result_type type; };
sl@0	1582
sl@0	1583	member_function_ptr_action(mem_func_ptr_t fptr_)
sl@0	1584	: fptr(fptr_) {}
sl@0	1585
sl@0	1586	template <typename CT>
sl@0	1587	result_type operator()(CT& obj, A a) const
sl@0	1588	{ return (impl::as_ptr<CT>::get(obj)->*fptr)(a); }
sl@0	1589
sl@0	1590	mem_func_ptr_t fptr;
sl@0	1591	};
sl@0	1592
sl@0	1593	//////////////////////////////////
sl@0	1594	template <typename RT, typename ClassT, typename A>
sl@0	1595	inline member_function_ptr<RT, ClassT, A>
sl@0	1596	bind(RT(ClassT::*fptr)(A))
sl@0	1597	{
sl@0	1598	return member_function_ptr<RT, ClassT, A>(fptr);
sl@0	1599	}
sl@0	1600
sl@0	1601	//////////////////////////////////
sl@0	1602	template <typename RT, typename ClassT, typename A>
sl@0	1603	inline member_function_ptr<RT, ClassT const, A>
sl@0	1604	bind(RT(ClassT::*fptr)(A) const)
sl@0	1605	{
sl@0	1606	return member_function_ptr<RT, ClassT const, A>(fptr);
sl@0	1607	}
sl@0	1608
sl@0	1609	///////////////////////////////////////////////////////////////////////////////
sl@0	1610	//
sl@0	1611	// Member function pointer binder (specialization for 2 args)
sl@0	1612	//
sl@0	1613	///////////////////////////////////////////////////////////////////////////////
sl@0	1614	template <typename RT, typename ClassT, typename A, typename B>
sl@0	1615	struct member_function_ptr_action<RT, ClassT,
sl@0	1616	A, B, nil_t,
sl@0	1617	#if PHOENIX_LIMIT > 3
sl@0	1618	nil_t, nil_t, nil_t,
sl@0	1619	#if PHOENIX_LIMIT > 6
sl@0	1620	nil_t, nil_t, nil_t,
sl@0	1621	#if PHOENIX_LIMIT > 9
sl@0	1622	nil_t, nil_t, nil_t,
sl@0	1623	#if PHOENIX_LIMIT > 12
sl@0	1624	nil_t, nil_t, nil_t,
sl@0	1625	#endif
sl@0	1626	#endif
sl@0	1627	#endif
sl@0	1628	#endif
sl@0	1629	nil_t // Unused
sl@0	1630	> {
sl@0	1631
sl@0	1632	typedef RT result_type;
sl@0	1633	typedef RT(ClassT::*mf)(A, B);
sl@0	1634	typedef RT(ClassT::*cmf)(A, B) const;
sl@0	1635	typedef typename boost::mpl::if_<boost::is_const<ClassT>, cmf, mf>::type
sl@0	1636	mem_func_ptr_t;
sl@0	1637
sl@0	1638	template <typename CT, typename A_, typename B_>
sl@0	1639	struct result { typedef result_type type; };
sl@0	1640
sl@0	1641	member_function_ptr_action(mem_func_ptr_t fptr_)
sl@0	1642	: fptr(fptr_) {}
sl@0	1643
sl@0	1644	template <typename CT>
sl@0	1645	result_type operator()(CT& obj, A a, B b) const
sl@0	1646	{ return (impl::as_ptr<CT>::get(obj)->*fptr)(a, b); }
sl@0	1647
sl@0	1648	mem_func_ptr_t fptr;
sl@0	1649	};
sl@0	1650
sl@0	1651	//////////////////////////////////
sl@0	1652	template <typename RT, typename ClassT, typename A, typename B>
sl@0	1653	inline member_function_ptr<RT, ClassT, A, B>
sl@0	1654	bind(RT(ClassT::*fptr)(A, B))
sl@0	1655	{
sl@0	1656	return member_function_ptr<RT, ClassT, A, B>(fptr);
sl@0	1657	}
sl@0	1658
sl@0	1659	//////////////////////////////////
sl@0	1660	template <typename RT, typename ClassT, typename A, typename B>
sl@0	1661	inline member_function_ptr<RT, ClassT const, A, B>
sl@0	1662	bind(RT(ClassT::*fptr)(A, B) const)
sl@0	1663	{
sl@0	1664	return member_function_ptr<RT, ClassT const, A, B>(fptr);
sl@0	1665	}
sl@0	1666
sl@0	1667	#if PHOENIX_LIMIT > 3
sl@0	1668	///////////////////////////////////////////////////////////////////////////////
sl@0	1669	//
sl@0	1670	// Member function pointer binder (specialization for 3 args)
sl@0	1671	//
sl@0	1672	///////////////////////////////////////////////////////////////////////////////
sl@0	1673	template <typename RT, typename ClassT, typename A, typename B, typename C>
sl@0	1674	struct member_function_ptr_action<RT, ClassT,
sl@0	1675	A, B, C, nil_t, nil_t, nil_t,
sl@0	1676	#if PHOENIX_LIMIT > 6
sl@0	1677	nil_t, nil_t, nil_t,
sl@0	1678	#if PHOENIX_LIMIT > 9
sl@0	1679	nil_t, nil_t, nil_t,
sl@0	1680	#if PHOENIX_LIMIT > 12
sl@0	1681	nil_t, nil_t, nil_t,
sl@0	1682	#endif
sl@0	1683	#endif
sl@0	1684	#endif
sl@0	1685	nil_t // Unused
sl@0	1686	> {
sl@0	1687
sl@0	1688	typedef RT result_type;
sl@0	1689	typedef RT(ClassT::*mf)(A, B, C);
sl@0	1690	typedef RT(ClassT::*cmf)(A, B, C) const;
sl@0	1691	typedef typename boost::mpl::if_<boost::is_const<ClassT>, cmf, mf>::type
sl@0	1692	mem_func_ptr_t;
sl@0	1693
sl@0	1694	template <typename CT, typename A_, typename B_, typename C_>
sl@0	1695	struct result { typedef result_type type; };
sl@0	1696
sl@0	1697	member_function_ptr_action(mem_func_ptr_t fptr_)
sl@0	1698	: fptr(fptr_) {}
sl@0	1699
sl@0	1700	template <typename CT>
sl@0	1701	result_type operator()(CT& obj, A a, B b, C c) const
sl@0	1702	{ return (impl::as_ptr<CT>::get(obj)->*fptr)(a, b, c); }
sl@0	1703
sl@0	1704	mem_func_ptr_t fptr;
sl@0	1705	};
sl@0	1706
sl@0	1707	//////////////////////////////////
sl@0	1708	template <typename RT, typename ClassT, typename A, typename B, typename C>
sl@0	1709	inline member_function_ptr<RT, ClassT, A, B, C>
sl@0	1710	bind(RT(ClassT::*fptr)(A, B, C))
sl@0	1711	{
sl@0	1712	return member_function_ptr<RT, ClassT, A, B, C>(fptr);
sl@0	1713	}
sl@0	1714
sl@0	1715	//////////////////////////////////
sl@0	1716	template <typename RT, typename ClassT, typename A, typename B, typename C>
sl@0	1717	inline member_function_ptr<RT, ClassT const, A, B, C>
sl@0	1718	bind(RT(ClassT::*fptr)(A, B, C) const)
sl@0	1719	{
sl@0	1720	return member_function_ptr<RT, ClassT const, A, B, C>(fptr);
sl@0	1721	}
sl@0	1722
sl@0	1723	///////////////////////////////////////////////////////////////////////////////
sl@0	1724	//
sl@0	1725	// Member function pointer binder (specialization for 4 args)
sl@0	1726	//
sl@0	1727	///////////////////////////////////////////////////////////////////////////////
sl@0	1728	template <typename RT, typename ClassT,
sl@0	1729	typename A, typename B, typename C, typename D
sl@0	1730	>
sl@0	1731	struct member_function_ptr_action<RT, ClassT,
sl@0	1732	A, B, C, D, nil_t, nil_t,
sl@0	1733	#if PHOENIX_LIMIT > 6
sl@0	1734	nil_t, nil_t, nil_t,
sl@0	1735	#if PHOENIX_LIMIT > 9
sl@0	1736	nil_t, nil_t, nil_t,
sl@0	1737	#if PHOENIX_LIMIT > 12
sl@0	1738	nil_t, nil_t, nil_t,
sl@0	1739	#endif
sl@0	1740	#endif
sl@0	1741	#endif
sl@0	1742	nil_t // Unused
sl@0	1743	> {
sl@0	1744
sl@0	1745	typedef RT result_type;
sl@0	1746	typedef RT(ClassT::*mf)(A, B, C, D);
sl@0	1747	typedef RT(ClassT::*cmf)(A, B, C, D) const;
sl@0	1748	typedef typename boost::mpl::if_<boost::is_const<ClassT>, cmf, mf>::type
sl@0	1749	mem_func_ptr_t;
sl@0	1750
sl@0	1751	template <typename CT,
sl@0	1752	typename A_, typename B_, typename C_, typename D_
sl@0	1753	>
sl@0	1754	struct result { typedef result_type type; };
sl@0	1755
sl@0	1756	member_function_ptr_action(mem_func_ptr_t fptr_)
sl@0	1757	: fptr(fptr_) {}
sl@0	1758
sl@0	1759	template <typename CT>
sl@0	1760	result_type operator()(CT& obj,
sl@0	1761	A a, B b, C c, D d
sl@0	1762	) const
sl@0	1763	{ return (impl::as_ptr<CT>::get(obj)->*fptr)(a, b, c, d); }
sl@0	1764
sl@0	1765	mem_func_ptr_t fptr;
sl@0	1766	};
sl@0	1767
sl@0	1768	//////////////////////////////////
sl@0	1769	template <typename RT, typename ClassT,
sl@0	1770	typename A, typename B, typename C, typename D
sl@0	1771	>
sl@0	1772	inline member_function_ptr<RT, ClassT, A, B, C, D>
sl@0	1773	bind(RT(ClassT::*fptr)(A, B, C, D))
sl@0	1774	{
sl@0	1775	return member_function_ptr<
sl@0	1776	RT, ClassT, A, B, C, D>(fptr);
sl@0	1777	}
sl@0	1778
sl@0	1779	//////////////////////////////////
sl@0	1780	template <typename RT, typename ClassT,
sl@0	1781	typename A, typename B, typename C, typename D
sl@0	1782	>
sl@0	1783	inline member_function_ptr<RT, ClassT const, A, B, C, D>
sl@0	1784	bind(RT(ClassT::*fptr)(A, B, C, D) const)
sl@0	1785	{
sl@0	1786	return member_function_ptr<
sl@0	1787	RT, ClassT const, A, B, C, D>(fptr);
sl@0	1788	}
sl@0	1789
sl@0	1790	///////////////////////////////////////////////////////////////////////////////
sl@0	1791	//
sl@0	1792	// Member function pointer binder (specialization for 5 args)
sl@0	1793	//
sl@0	1794	///////////////////////////////////////////////////////////////////////////////
sl@0	1795	template <typename RT, typename ClassT,
sl@0	1796	typename A, typename B, typename C, typename D,
sl@0	1797	typename E
sl@0	1798	>
sl@0	1799	struct member_function_ptr_action<RT, ClassT,
sl@0	1800	A, B, C, D, E, nil_t,
sl@0	1801	#if PHOENIX_LIMIT > 6
sl@0	1802	nil_t, nil_t, nil_t,
sl@0	1803	#if PHOENIX_LIMIT > 9
sl@0	1804	nil_t, nil_t, nil_t,
sl@0	1805	#if PHOENIX_LIMIT > 12
sl@0	1806	nil_t, nil_t, nil_t,
sl@0	1807	#endif
sl@0	1808	#endif
sl@0	1809	#endif
sl@0	1810	nil_t // Unused
sl@0	1811	> {
sl@0	1812
sl@0	1813	typedef RT result_type;
sl@0	1814	typedef RT(ClassT::*mf)(A, B, C, D, E);
sl@0	1815	typedef RT(ClassT::*cmf)(A, B, C, D, E) const;
sl@0	1816	typedef typename boost::mpl::if_<boost::is_const<ClassT>, cmf, mf>::type
sl@0	1817	mem_func_ptr_t;
sl@0	1818
sl@0	1819	template <typename CT,
sl@0	1820	typename A_, typename B_, typename C_, typename D_,
sl@0	1821	typename E_
sl@0	1822	>
sl@0	1823	struct result { typedef result_type type; };
sl@0	1824
sl@0	1825	member_function_ptr_action(mem_func_ptr_t fptr_)
sl@0	1826	: fptr(fptr_) {}
sl@0	1827
sl@0	1828	template <typename CT>
sl@0	1829	result_type operator()(CT& obj,
sl@0	1830	A a, B b, C c, D d, E e
sl@0	1831	) const
sl@0	1832	{ return (impl::as_ptr<CT>::get(obj)->*fptr)(a, b, c, d, e); }
sl@0	1833
sl@0	1834	mem_func_ptr_t fptr;
sl@0	1835	};
sl@0	1836
sl@0	1837	//////////////////////////////////
sl@0	1838	template <typename RT, typename ClassT,
sl@0	1839	typename A, typename B, typename C, typename D,
sl@0	1840	typename E
sl@0	1841	>
sl@0	1842	inline member_function_ptr<RT, ClassT, A, B, C, D, E>
sl@0	1843	bind(RT(ClassT::*fptr)(A, B, C, D, E))
sl@0	1844	{
sl@0	1845	return member_function_ptr<
sl@0	1846	RT, ClassT, A, B, C, D, E>(fptr);
sl@0	1847	}
sl@0	1848
sl@0	1849	//////////////////////////////////
sl@0	1850	template <typename RT, typename ClassT,
sl@0	1851	typename A, typename B, typename C, typename D,
sl@0	1852	typename E
sl@0	1853	>
sl@0	1854	inline member_function_ptr<RT, ClassT const, A, B, C, D, E>
sl@0	1855	bind(RT(ClassT::*fptr)(A, B, C, D, E) const)
sl@0	1856	{
sl@0	1857	return member_function_ptr<
sl@0	1858	RT, ClassT const, A, B, C, D, E>(fptr);
sl@0	1859	}
sl@0	1860
sl@0	1861	#if PHOENIX_LIMIT > 6
sl@0	1862	///////////////////////////////////////////////////////////////////////////////
sl@0	1863	//
sl@0	1864	// Member function pointer binder (specialization for 6 args)
sl@0	1865	//
sl@0	1866	///////////////////////////////////////////////////////////////////////////////
sl@0	1867	template <typename RT, typename ClassT,
sl@0	1868	typename A, typename B, typename C, typename D,
sl@0	1869	typename E, typename F
sl@0	1870	>
sl@0	1871	struct member_function_ptr_action<RT, ClassT,
sl@0	1872	A, B, C, D, E, F, nil_t, nil_t, nil_t,
sl@0	1873	#if PHOENIX_LIMIT > 9
sl@0	1874	nil_t, nil_t, nil_t,
sl@0	1875	#if PHOENIX_LIMIT > 12
sl@0	1876	nil_t, nil_t, nil_t,
sl@0	1877	#endif
sl@0	1878	#endif
sl@0	1879	nil_t // Unused
sl@0	1880	> {
sl@0	1881
sl@0	1882	typedef RT result_type;
sl@0	1883	typedef RT(ClassT::*mf)(A, B, C, D, E, F);
sl@0	1884	typedef RT(ClassT::*cmf)(A, B, C, D, E, F) const;
sl@0	1885	typedef typename boost::mpl::if_<boost::is_const<ClassT>, cmf, mf>::type
sl@0	1886	mem_func_ptr_t;
sl@0	1887
sl@0	1888	template <typename CT,
sl@0	1889	typename A_, typename B_, typename C_, typename D_,
sl@0	1890	typename E_, typename F_
sl@0	1891	>
sl@0	1892	struct result { typedef result_type type; };
sl@0	1893
sl@0	1894	member_function_ptr_action(mem_func_ptr_t fptr_)
sl@0	1895	: fptr(fptr_) {}
sl@0	1896
sl@0	1897	template <typename CT>
sl@0	1898	result_type operator()(CT& obj,
sl@0	1899	A a, B b, C c, D d, E e, F f
sl@0	1900	) const
sl@0	1901	{ return (impl::as_ptr<CT>::get(obj)->*fptr)(a, b, c, d, e, f); }
sl@0	1902
sl@0	1903	mem_func_ptr_t fptr;
sl@0	1904	};
sl@0	1905
sl@0	1906	//////////////////////////////////
sl@0	1907	template <typename RT, typename ClassT,
sl@0	1908	typename A, typename B, typename C, typename D,
sl@0	1909	typename E, typename F
sl@0	1910	>
sl@0	1911	inline member_function_ptr<RT, ClassT, A, B, C, D, E, F>
sl@0	1912	bind(RT(ClassT::*fptr)(A, B, C, D, E, F))
sl@0	1913	{
sl@0	1914	return member_function_ptr<
sl@0	1915	RT, ClassT, A, B, C, D, E, F>(fptr);
sl@0	1916	}
sl@0	1917
sl@0	1918	//////////////////////////////////
sl@0	1919	template <typename RT, typename ClassT,
sl@0	1920	typename A, typename B, typename C, typename D,
sl@0	1921	typename E, typename F
sl@0	1922	>
sl@0	1923	inline member_function_ptr<RT, ClassT const, A, B, C, D, E, F>
sl@0	1924	bind(RT(ClassT::*fptr)(A, B, C, D, E, F) const)
sl@0	1925	{
sl@0	1926	return member_function_ptr<
sl@0	1927	RT, ClassT const, A, B, C, D, E, F>(fptr);
sl@0	1928	}
sl@0	1929
sl@0	1930	///////////////////////////////////////////////////////////////////////////////
sl@0	1931	//
sl@0	1932	// Member function pointer binder (specialization for 7 args)
sl@0	1933	//
sl@0	1934	///////////////////////////////////////////////////////////////////////////////
sl@0	1935	template <typename RT, typename ClassT,
sl@0	1936	typename A, typename B, typename C, typename D,
sl@0	1937	typename E, typename F, typename G
sl@0	1938	>
sl@0	1939	struct member_function_ptr_action<RT, ClassT,
sl@0	1940	A, B, C, D, E, F, G, nil_t, nil_t,
sl@0	1941	#if PHOENIX_LIMIT > 9
sl@0	1942	nil_t, nil_t, nil_t,
sl@0	1943	#if PHOENIX_LIMIT > 12
sl@0	1944	nil_t, nil_t, nil_t,
sl@0	1945	#endif
sl@0	1946	#endif
sl@0	1947	nil_t // Unused
sl@0	1948	> {
sl@0	1949
sl@0	1950	typedef RT result_type;
sl@0	1951	typedef RT(ClassT::*mf)(A, B, C, D, E, F, G);
sl@0	1952	typedef RT(ClassT::*cmf)(A, B, C, D, E, F, G) const;
sl@0	1953	typedef typename boost::mpl::if_<boost::is_const<ClassT>, cmf, mf>::type
sl@0	1954	mem_func_ptr_t;
sl@0	1955
sl@0	1956	template <typename CT,
sl@0	1957	typename A_, typename B_, typename C_, typename D_,
sl@0	1958	typename E_, typename F_, typename G_
sl@0	1959	>
sl@0	1960	struct result { typedef result_type type; };
sl@0	1961
sl@0	1962	member_function_ptr_action(mem_func_ptr_t fptr_)
sl@0	1963	: fptr(fptr_) {}
sl@0	1964
sl@0	1965	template <typename CT>
sl@0	1966	result_type operator()(CT& obj,
sl@0	1967	A a, B b, C c, D d, E e, F f, G g
sl@0	1968	) const
sl@0	1969	{ return (impl::as_ptr<CT>::get(obj)->*fptr)(a, b, c, d, e, f, g); }
sl@0	1970
sl@0	1971	mem_func_ptr_t fptr;
sl@0	1972	};
sl@0	1973
sl@0	1974	//////////////////////////////////
sl@0	1975	template <typename RT, typename ClassT,
sl@0	1976	typename A, typename B, typename C, typename D,
sl@0	1977	typename E, typename F, typename G
sl@0	1978	>
sl@0	1979	inline member_function_ptr<RT, ClassT, A, B, C, D, E, F, G>
sl@0	1980	bind(RT(ClassT::*fptr)(A, B, C, D, E, F, G))
sl@0	1981	{
sl@0	1982	return member_function_ptr<
sl@0	1983	RT, ClassT, A, B, C, D, E, F, G>(fptr);
sl@0	1984	}
sl@0	1985
sl@0	1986	//////////////////////////////////
sl@0	1987	template <typename RT, typename ClassT,
sl@0	1988	typename A, typename B, typename C, typename D,
sl@0	1989	typename E, typename F, typename G
sl@0	1990	>
sl@0	1991	inline member_function_ptr<RT, ClassT const, A, B, C, D, E, F, G>
sl@0	1992	bind(RT(ClassT::*fptr)(A, B, C, D, E, F, G) const)
sl@0	1993	{
sl@0	1994	return member_function_ptr<
sl@0	1995	RT, ClassT const, A, B, C, D, E, F, G>(fptr);
sl@0	1996	}
sl@0	1997
sl@0	1998	///////////////////////////////////////////////////////////////////////////////
sl@0	1999	//
sl@0	2000	// Member function pointer binder (specialization for 8 args)
sl@0	2001	//
sl@0	2002	///////////////////////////////////////////////////////////////////////////////
sl@0	2003	template <typename RT, typename ClassT,
sl@0	2004	typename A, typename B, typename C, typename D,
sl@0	2005	typename E, typename F, typename G, typename H
sl@0	2006	>
sl@0	2007	struct member_function_ptr_action<RT, ClassT,
sl@0	2008	A, B, C, D, E, F, G, H, nil_t,
sl@0	2009	#if PHOENIX_LIMIT > 9
sl@0	2010	nil_t, nil_t, nil_t,
sl@0	2011	#if PHOENIX_LIMIT > 12
sl@0	2012	nil_t, nil_t, nil_t,
sl@0	2013	#endif
sl@0	2014	#endif
sl@0	2015	nil_t // Unused
sl@0	2016	> {
sl@0	2017
sl@0	2018	typedef RT result_type;
sl@0	2019	typedef RT(ClassT::*mf)(A, B, C, D, E, F, G, H);
sl@0	2020	typedef RT(ClassT::*cmf)(A, B, C, D, E, F, G, H) const;
sl@0	2021	typedef typename boost::mpl::if_<boost::is_const<ClassT>, cmf, mf>::type
sl@0	2022	mem_func_ptr_t;
sl@0	2023
sl@0	2024	template <typename CT,
sl@0	2025	typename A_, typename B_, typename C_, typename D_,
sl@0	2026	typename E_, typename F_, typename G_, typename H_
sl@0	2027	>
sl@0	2028	struct result { typedef result_type type; };
sl@0	2029
sl@0	2030	member_function_ptr_action(mem_func_ptr_t fptr_)
sl@0	2031	: fptr(fptr_) {}
sl@0	2032
sl@0	2033	template <typename CT>
sl@0	2034	result_type operator()(CT& obj,
sl@0	2035	A a, B b, C c, D d, E e, F f, G g, H h
sl@0	2036	) const
sl@0	2037	{ return (impl::as_ptr<CT>::get(obj)->*fptr)(a, b, c, d, e, f, g, h); }
sl@0	2038
sl@0	2039	mem_func_ptr_t fptr;
sl@0	2040	};
sl@0	2041
sl@0	2042	//////////////////////////////////
sl@0	2043	template <typename RT, typename ClassT,
sl@0	2044	typename A, typename B, typename C, typename D,
sl@0	2045	typename E, typename F, typename G, typename H
sl@0	2046	>
sl@0	2047	inline member_function_ptr<RT, ClassT, A, B, C, D, E, F, G, H>
sl@0	2048	bind(RT(ClassT::*fptr)(A, B, C, D, E, F, G, H))
sl@0	2049	{
sl@0	2050	return member_function_ptr<
sl@0	2051	RT, ClassT, A, B, C, D, E, F, G, H>(fptr);
sl@0	2052	}
sl@0	2053
sl@0	2054	//////////////////////////////////
sl@0	2055	template <typename RT, typename ClassT,
sl@0	2056	typename A, typename B, typename C, typename D,
sl@0	2057	typename E, typename F, typename G, typename H
sl@0	2058	>
sl@0	2059	inline member_function_ptr<RT, ClassT const, A, B, C, D, E, F, G, H>
sl@0	2060	bind(RT(ClassT::*fptr)(A, B, C, D, E, F, G, H) const)
sl@0	2061	{
sl@0	2062	return member_function_ptr<
sl@0	2063	RT, ClassT const, A, B, C, D, E, F, G, H>(fptr);
sl@0	2064	}
sl@0	2065
sl@0	2066	#if PHOENIX_LIMIT > 9
sl@0	2067	///////////////////////////////////////////////////////////////////////////////
sl@0	2068	//
sl@0	2069	// Member function pointer binder (specialization for 9 args)
sl@0	2070	//
sl@0	2071	///////////////////////////////////////////////////////////////////////////////
sl@0	2072	template <typename RT, typename ClassT,
sl@0	2073	typename A, typename B, typename C, typename D,
sl@0	2074	typename E, typename F, typename G, typename H, typename I
sl@0	2075	>
sl@0	2076	struct member_function_ptr_action<RT, ClassT,
sl@0	2077	A, B, C, D, E, F, G, H, I, nil_t, nil_t, nil_t,
sl@0	2078	#if PHOENIX_LIMIT > 12
sl@0	2079	nil_t, nil_t, nil_t,
sl@0	2080	#endif
sl@0	2081	nil_t // Unused
sl@0	2082	> {
sl@0	2083
sl@0	2084	typedef RT result_type;
sl@0	2085	typedef RT(ClassT::*mf)(A, B, C, D, E, F, G, H, I);
sl@0	2086	typedef RT(ClassT::*cmf)(A, B, C, D, E, F, G, H, I) const;
sl@0	2087	typedef typename boost::mpl::if_<boost::is_const<ClassT>, cmf, mf>::type
sl@0	2088	mem_func_ptr_t;
sl@0	2089
sl@0	2090	template <typename CT,
sl@0	2091	typename A_, typename B_, typename C_, typename D_,
sl@0	2092	typename E_, typename F_, typename G_, typename H_, typename I_
sl@0	2093	>
sl@0	2094	struct result { typedef result_type type; };
sl@0	2095
sl@0	2096	member_function_ptr_action(mem_func_ptr_t fptr_)
sl@0	2097	: fptr(fptr_) {}
sl@0	2098
sl@0	2099	template <typename CT>
sl@0	2100	result_type operator()(CT& obj,
sl@0	2101	A a, B b, C c, D d, E e, F f, G g, H h, I i
sl@0	2102	) const
sl@0	2103	{ return (impl::as_ptr<CT>::get(obj)->*fptr)(a, b, c, d, e, f, g, h, i); }
sl@0	2104
sl@0	2105	mem_func_ptr_t fptr;
sl@0	2106	};
sl@0	2107
sl@0	2108	//////////////////////////////////
sl@0	2109	template <typename RT, typename ClassT,
sl@0	2110	typename A, typename B, typename C, typename D,
sl@0	2111	typename E, typename F, typename G, typename H, typename I
sl@0	2112	>
sl@0	2113	inline member_function_ptr<RT, ClassT, A, B, C, D, E, F, G, H, I>
sl@0	2114	bind(RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I))
sl@0	2115	{
sl@0	2116	return member_function_ptr<
sl@0	2117	RT, ClassT, A, B, C, D, E, F, G, H, I>(fptr);
sl@0	2118	}
sl@0	2119
sl@0	2120	//////////////////////////////////
sl@0	2121	template <typename RT, typename ClassT,
sl@0	2122	typename A, typename B, typename C, typename D,
sl@0	2123	typename E, typename F, typename G, typename H, typename I
sl@0	2124	>
sl@0	2125	inline member_function_ptr<RT, ClassT const, A, B, C, D, E, F, G, H, I>
sl@0	2126	bind(RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I) const)
sl@0	2127	{
sl@0	2128	return member_function_ptr<
sl@0	2129	RT, ClassT const, A, B, C, D, E, F, G, H, I>(fptr);
sl@0	2130	}
sl@0	2131
sl@0	2132	///////////////////////////////////////////////////////////////////////////////
sl@0	2133	//
sl@0	2134	// Member function pointer binder (specialization for 10 args)
sl@0	2135	//
sl@0	2136	///////////////////////////////////////////////////////////////////////////////
sl@0	2137	template <typename RT, typename ClassT,
sl@0	2138	typename A, typename B, typename C, typename D,
sl@0	2139	typename E, typename F, typename G, typename H, typename I,
sl@0	2140	typename J
sl@0	2141	>
sl@0	2142	struct member_function_ptr_action<RT, ClassT,
sl@0	2143	A, B, C, D, E, F, G, H, I, J, nil_t, nil_t,
sl@0	2144	#if PHOENIX_LIMIT > 12
sl@0	2145	nil_t, nil_t, nil_t,
sl@0	2146	#endif
sl@0	2147	nil_t // Unused
sl@0	2148	> {
sl@0	2149
sl@0	2150	typedef RT result_type;
sl@0	2151	typedef RT(ClassT::*mf)(A, B, C, D, E, F, G, H, I, J);
sl@0	2152	typedef RT(ClassT::*cmf)(A, B, C, D, E, F, G, H, I, J) const;
sl@0	2153	typedef typename boost::mpl::if_<boost::is_const<ClassT>, cmf, mf>::type
sl@0	2154	mem_func_ptr_t;
sl@0	2155
sl@0	2156	template <typename CT,
sl@0	2157	typename A_, typename B_, typename C_, typename D_,
sl@0	2158	typename E_, typename F_, typename G_, typename H_, typename I_,
sl@0	2159	typename J_
sl@0	2160	>
sl@0	2161	struct result { typedef result_type type; };
sl@0	2162
sl@0	2163	member_function_ptr_action(mem_func_ptr_t fptr_)
sl@0	2164	: fptr(fptr_) {}
sl@0	2165
sl@0	2166	template <typename CT>
sl@0	2167	result_type operator()(CT& obj,
sl@0	2168	A a, B b, C c, D d, E e, F f, G g, H h, I i, J j
sl@0	2169	) const
sl@0	2170	{
sl@0	2171	return (impl::as_ptr<CT>::get(obj)->*fptr)
sl@0	2172	(a, b, c, d, e, f, g, h, i, j);
sl@0	2173	}
sl@0	2174
sl@0	2175	mem_func_ptr_t fptr;
sl@0	2176	};
sl@0	2177
sl@0	2178	//////////////////////////////////
sl@0	2179	template <typename RT, typename ClassT,
sl@0	2180	typename A, typename B, typename C, typename D,
sl@0	2181	typename E, typename F, typename G, typename H, typename I,
sl@0	2182	typename J
sl@0	2183	>
sl@0	2184	inline member_function_ptr<RT, ClassT, A, B, C, D, E, F, G, H, I, J>
sl@0	2185	bind(RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J))
sl@0	2186	{
sl@0	2187	return member_function_ptr<
sl@0	2188	RT, ClassT, A, B, C, D, E, F, G, H, I, J>(fptr);
sl@0	2189	}
sl@0	2190
sl@0	2191	//////////////////////////////////
sl@0	2192	template <typename RT, typename ClassT,
sl@0	2193	typename A, typename B, typename C, typename D,
sl@0	2194	typename E, typename F, typename G, typename H, typename I,
sl@0	2195	typename J
sl@0	2196	>
sl@0	2197	inline member_function_ptr<RT, ClassT const, A, B, C, D, E, F, G, H, I, J>
sl@0	2198	bind(RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J) const)
sl@0	2199	{
sl@0	2200	return member_function_ptr<
sl@0	2201	RT, ClassT const, A, B, C, D, E, F, G, H, I, J>(fptr);
sl@0	2202	}
sl@0	2203
sl@0	2204	///////////////////////////////////////////////////////////////////////////////
sl@0	2205	//
sl@0	2206	// Member function pointer binder (specialization for 11 args)
sl@0	2207	//
sl@0	2208	///////////////////////////////////////////////////////////////////////////////
sl@0	2209	template <typename RT, typename ClassT,
sl@0	2210	typename A, typename B, typename C, typename D,
sl@0	2211	typename E, typename F, typename G, typename H, typename I,
sl@0	2212	typename J, typename K
sl@0	2213	>
sl@0	2214	struct member_function_ptr_action<RT, ClassT,
sl@0	2215	A, B, C, D, E, F, G, H, I, J, K, nil_t,
sl@0	2216	#if PHOENIX_LIMIT > 12
sl@0	2217	nil_t, nil_t, nil_t,
sl@0	2218	#endif
sl@0	2219	nil_t // Unused
sl@0	2220	> {
sl@0	2221
sl@0	2222	typedef RT result_type;
sl@0	2223	typedef RT(ClassT::*mf)(A, B, C, D, E, F, G, H, I, J, K);
sl@0	2224	typedef RT(ClassT::*cmf)(A, B, C, D, E, F, G, H, I, J, K) const;
sl@0	2225	typedef typename boost::mpl::if_<boost::is_const<ClassT>, cmf, mf>::type
sl@0	2226	mem_func_ptr_t;
sl@0	2227
sl@0	2228	template <typename CT,
sl@0	2229	typename A_, typename B_, typename C_, typename D_,
sl@0	2230	typename E_, typename F_, typename G_, typename H_, typename I_,
sl@0	2231	typename J_, typename K_
sl@0	2232	>
sl@0	2233	struct result { typedef result_type type; };
sl@0	2234
sl@0	2235	member_function_ptr_action(mem_func_ptr_t fptr_)
sl@0	2236	: fptr(fptr_) {}
sl@0	2237
sl@0	2238	template <typename CT>
sl@0	2239	result_type operator()(CT& obj,
sl@0	2240	A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k
sl@0	2241	) const
sl@0	2242	{
sl@0	2243	return (impl::as_ptr<CT>::get(obj)->*fptr)
sl@0	2244	(a, b, c, d, e, f, g, h, i, j, k);
sl@0	2245	}
sl@0	2246
sl@0	2247	mem_func_ptr_t fptr;
sl@0	2248	};
sl@0	2249
sl@0	2250	//////////////////////////////////
sl@0	2251	template <typename RT, typename ClassT,
sl@0	2252	typename A, typename B, typename C, typename D,
sl@0	2253	typename E, typename F, typename G, typename H, typename I,
sl@0	2254	typename J, typename K
sl@0	2255	>
sl@0	2256	inline member_function_ptr<RT, ClassT, A, B, C, D, E, F, G, H, I, J, K>
sl@0	2257	bind(RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K))
sl@0	2258	{
sl@0	2259	return member_function_ptr<
sl@0	2260	RT, ClassT, A, B, C, D, E, F, G, H, I, J, K>(fptr);
sl@0	2261	}
sl@0	2262
sl@0	2263	//////////////////////////////////
sl@0	2264	template <typename RT, typename ClassT,
sl@0	2265	typename A, typename B, typename C, typename D,
sl@0	2266	typename E, typename F, typename G, typename H, typename I,
sl@0	2267	typename J, typename K
sl@0	2268	>
sl@0	2269	inline member_function_ptr<RT, ClassT const, A, B, C, D, E, F, G, H, I, J, K>
sl@0	2270	bind(RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K) const)
sl@0	2271	{
sl@0	2272	return member_function_ptr<
sl@0	2273	RT, ClassT const, A, B, C, D, E, F, G, H, I, J, K>(fptr);
sl@0	2274	}
sl@0	2275
sl@0	2276	#if PHOENIX_LIMIT > 12
sl@0	2277	///////////////////////////////////////////////////////////////////////////////
sl@0	2278	//
sl@0	2279	// Member function pointer binder (specialization for 12 args)
sl@0	2280	//
sl@0	2281	///////////////////////////////////////////////////////////////////////////////
sl@0	2282	template <typename RT, typename ClassT,
sl@0	2283	typename A, typename B, typename C, typename D,
sl@0	2284	typename E, typename F, typename G, typename H, typename I,
sl@0	2285	typename J, typename K, typename L
sl@0	2286	>
sl@0	2287	struct member_function_ptr_action<RT, ClassT,
sl@0	2288	A, B, C, D, E, F, G, H, I, J, K, L, nil_t, nil_t, nil_t, nil_t> {
sl@0	2289
sl@0	2290	typedef RT result_type;
sl@0	2291	typedef RT(ClassT::*mf)(A, B, C, D, E, F, G, H, I, J, K, L);
sl@0	2292	typedef RT(ClassT::*cmf)(A, B, C, D, E, F, G, H, I, J, K, L) const;
sl@0	2293	typedef typename boost::mpl::if_<boost::is_const<ClassT>, cmf, mf>::type
sl@0	2294	mem_func_ptr_t;
sl@0	2295
sl@0	2296	template <typename CT,
sl@0	2297	typename A_, typename B_, typename C_, typename D_,
sl@0	2298	typename E_, typename F_, typename G_, typename H_, typename I_,
sl@0	2299	typename J_, typename K_, typename L_
sl@0	2300	>
sl@0	2301	struct result { typedef result_type type; };
sl@0	2302
sl@0	2303	member_function_ptr_action(mem_func_ptr_t fptr_)
sl@0	2304	: fptr(fptr_) {}
sl@0	2305
sl@0	2306	template <typename CT>
sl@0	2307	result_type operator()(CT& obj,
sl@0	2308	A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k, L l
sl@0	2309	) const
sl@0	2310	{
sl@0	2311	return (impl::as_ptr<CT>::get(obj)->*fptr)
sl@0	2312	(a, b, c, d, e, f, g, h, i, j, k, l);
sl@0	2313	}
sl@0	2314
sl@0	2315	mem_func_ptr_t fptr;
sl@0	2316	};
sl@0	2317
sl@0	2318	//////////////////////////////////
sl@0	2319	template <typename RT, typename ClassT,
sl@0	2320	typename A, typename B, typename C, typename D,
sl@0	2321	typename E, typename F, typename G, typename H, typename I,
sl@0	2322	typename J, typename K, typename L
sl@0	2323	>
sl@0	2324	inline member_function_ptr<RT, ClassT, A, B, C, D, E, F, G, H, I, J, K, L>
sl@0	2325	bind(RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K, L))
sl@0	2326	{
sl@0	2327	return member_function_ptr<
sl@0	2328	RT, ClassT, A, B, C, D, E, F, G, H, I, J, K, L>(fptr);
sl@0	2329	}
sl@0	2330
sl@0	2331	//////////////////////////////////
sl@0	2332	template <typename RT, typename ClassT,
sl@0	2333	typename A, typename B, typename C, typename D,
sl@0	2334	typename E, typename F, typename G, typename H, typename I,
sl@0	2335	typename J, typename K, typename L
sl@0	2336	>
sl@0	2337	inline member_function_ptr<RT, ClassT const, A, B, C, D, E, F, G, H, I, J, K, L>
sl@0	2338	bind(RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K, L) const)
sl@0	2339	{
sl@0	2340	return member_function_ptr<
sl@0	2341	RT, ClassT const, A, B, C, D, E, F, G, H, I, J, K, L>(fptr);
sl@0	2342	}
sl@0	2343
sl@0	2344	///////////////////////////////////////////////////////////////////////////////
sl@0	2345	//
sl@0	2346	// Member function pointer binder (specialization for 13 args)
sl@0	2347	//
sl@0	2348	///////////////////////////////////////////////////////////////////////////////
sl@0	2349	template <typename RT, typename ClassT,
sl@0	2350	typename A, typename B, typename C, typename D,
sl@0	2351	typename E, typename F, typename G, typename H, typename I,
sl@0	2352	typename J, typename K, typename L, typename M
sl@0	2353	>
sl@0	2354	struct member_function_ptr_action<RT, ClassT,
sl@0	2355	A, B, C, D, E, F, G, H, I, J, K, L, M, nil_t, nil_t, nil_t> {
sl@0	2356
sl@0	2357	typedef RT result_type;
sl@0	2358	typedef RT(ClassT::*mf)(A, B, C, D, E, F, G, H, I, J, K, L, M);
sl@0	2359	typedef RT(ClassT::*cmf)(A, B, C, D, E, F, G, H, I, J, K, L, M) const;
sl@0	2360	typedef typename boost::mpl::if_<boost::is_const<ClassT>, cmf, mf>::type
sl@0	2361	mem_func_ptr_t;
sl@0	2362
sl@0	2363	template <typename CT,
sl@0	2364	typename A_, typename B_, typename C_, typename D_,
sl@0	2365	typename E_, typename F_, typename G_, typename H_, typename I_,
sl@0	2366	typename J_, typename K_, typename L_, typename M_
sl@0	2367	>
sl@0	2368	struct result { typedef result_type type; };
sl@0	2369
sl@0	2370	member_function_ptr_action(mem_func_ptr_t fptr_)
sl@0	2371	: fptr(fptr_) {}
sl@0	2372
sl@0	2373	template <typename CT>
sl@0	2374	result_type operator()(CT& obj,
sl@0	2375	A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k, L l, M m
sl@0	2376	) const
sl@0	2377	{
sl@0	2378	return (impl::as_ptr<CT>::get(obj)->*fptr)
sl@0	2379	(a, b, c, d, e, f, g, h, i, j, k, l, m);
sl@0	2380	}
sl@0	2381
sl@0	2382	mem_func_ptr_t fptr;
sl@0	2383	};
sl@0	2384
sl@0	2385	//////////////////////////////////
sl@0	2386	template <typename RT, typename ClassT,
sl@0	2387	typename A, typename B, typename C, typename D,
sl@0	2388	typename E, typename F, typename G, typename H, typename I,
sl@0	2389	typename J, typename K, typename L, typename M
sl@0	2390	>
sl@0	2391	inline member_function_ptr<RT, ClassT, A, B, C, D, E, F, G, H, I, J, K, L, M>
sl@0	2392	bind(RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K, L, M))
sl@0	2393	{
sl@0	2394	return member_function_ptr<
sl@0	2395	RT, ClassT, A, B, C, D, E, F, G, H, I, J, K, L, M>(fptr);
sl@0	2396	}
sl@0	2397
sl@0	2398	//////////////////////////////////
sl@0	2399	template <typename RT, typename ClassT,
sl@0	2400	typename A, typename B, typename C, typename D,
sl@0	2401	typename E, typename F, typename G, typename H, typename I,
sl@0	2402	typename J, typename K, typename L, typename M
sl@0	2403	>
sl@0	2404	inline member_function_ptr<RT, ClassT const, A, B, C, D, E, F, G, H, I, J, K, L, M>
sl@0	2405	bind(RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K, L, M) const)
sl@0	2406	{
sl@0	2407	return member_function_ptr<
sl@0	2408	RT, ClassT const, A, B, C, D, E, F, G, H, I, J, K, L, M>(fptr);
sl@0	2409	}
sl@0	2410
sl@0	2411	///////////////////////////////////////////////////////////////////////////////
sl@0	2412	//
sl@0	2413	// Member function pointer binder (specialization for 14 args)
sl@0	2414	//
sl@0	2415	///////////////////////////////////////////////////////////////////////////////
sl@0	2416	template <typename RT, typename ClassT,
sl@0	2417	typename A, typename B, typename C, typename D,
sl@0	2418	typename E, typename F, typename G, typename H, typename I,
sl@0	2419	typename J, typename K, typename L, typename M, typename N
sl@0	2420	>
sl@0	2421	struct member_function_ptr_action<RT, ClassT,
sl@0	2422	A, B, C, D, E, F, G, H, I, J, K, L, M, N, nil_t, nil_t> {
sl@0	2423
sl@0	2424	typedef RT result_type;
sl@0	2425	typedef RT(ClassT::*mf)(A, B, C, D, E, F, G, H, I, J, K, L, M, N);
sl@0	2426	typedef RT(ClassT::*cmf)(A, B, C, D, E, F, G, H, I, J, K, L, M, N) const;
sl@0	2427	typedef typename boost::mpl::if_<boost::is_const<ClassT>, cmf, mf>::type
sl@0	2428	mem_func_ptr_t;
sl@0	2429
sl@0	2430	template <typename CT,
sl@0	2431	typename A_, typename B_, typename C_, typename D_,
sl@0	2432	typename E_, typename F_, typename G_, typename H_, typename I_,
sl@0	2433	typename J_, typename K_, typename L_, typename M_, typename N_
sl@0	2434	>
sl@0	2435	struct result { typedef result_type type; };
sl@0	2436
sl@0	2437	member_function_ptr_action(mem_func_ptr_t fptr_)
sl@0	2438	: fptr(fptr_) {}
sl@0	2439
sl@0	2440	template <typename CT>
sl@0	2441	result_type operator()(CT& obj,
sl@0	2442	A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k, L l, M m, N n
sl@0	2443	) const
sl@0	2444	{
sl@0	2445	return (impl::as_ptr<CT>::get(obj)->*fptr)
sl@0	2446	(a, b, c, d, e, f, g, h, i, j, k, l, m, n);
sl@0	2447	}
sl@0	2448
sl@0	2449	mem_func_ptr_t fptr;
sl@0	2450	};
sl@0	2451
sl@0	2452	//////////////////////////////////
sl@0	2453	template <typename RT, typename ClassT,
sl@0	2454	typename A, typename B, typename C, typename D,
sl@0	2455	typename E, typename F, typename G, typename H, typename I,
sl@0	2456	typename J, typename K, typename L, typename M, typename N
sl@0	2457	>
sl@0	2458	inline member_function_ptr<RT, ClassT, A, B, C, D, E, F, G, H, I, J, K, L, M, N>
sl@0	2459	bind(RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K, L, M, N))
sl@0	2460	{
sl@0	2461	return member_function_ptr<
sl@0	2462	RT, ClassT, A, B, C, D, E, F, G, H, I, J, K, L, M, N>(fptr);
sl@0	2463	}
sl@0	2464
sl@0	2465	//////////////////////////////////
sl@0	2466	template <typename RT, typename ClassT,
sl@0	2467	typename A, typename B, typename C, typename D,
sl@0	2468	typename E, typename F, typename G, typename H, typename I,
sl@0	2469	typename J, typename K, typename L, typename M, typename N
sl@0	2470	>
sl@0	2471	inline member_function_ptr<RT, ClassT const, A, B, C, D, E, F, G, H, I, J, K, L, M, N>
sl@0	2472	bind(RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K, L, M, N) const)
sl@0	2473	{
sl@0	2474	return member_function_ptr<
sl@0	2475	RT, ClassT const, A, B, C, D, E, F, G, H, I, J, K, L, M, N>(fptr);
sl@0	2476	}
sl@0	2477
sl@0	2478	///////////////////////////////////////////////////////////////////////////////
sl@0	2479	//
sl@0	2480	// Member function pointer binder (specialization for 15 args)
sl@0	2481	//
sl@0	2482	///////////////////////////////////////////////////////////////////////////////
sl@0	2483	template <typename RT, typename ClassT,
sl@0	2484	typename A, typename B, typename C, typename D,
sl@0	2485	typename E, typename F, typename G, typename H, typename I,
sl@0	2486	typename J, typename K, typename L, typename M, typename N,
sl@0	2487	typename O
sl@0	2488	>
sl@0	2489	struct member_function_ptr_action<RT, ClassT,
sl@0	2490	A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, nil_t> {
sl@0	2491
sl@0	2492	typedef RT result_type;
sl@0	2493	typedef RT(ClassT::*mf)(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O);
sl@0	2494	typedef RT(ClassT::*cmf)(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) const;
sl@0	2495	typedef typename boost::mpl::if_<boost::is_const<ClassT>, cmf, mf>::type
sl@0	2496	mem_func_ptr_t;
sl@0	2497
sl@0	2498	template <typename CT,
sl@0	2499	typename A_, typename B_, typename C_, typename D_,
sl@0	2500	typename E_, typename F_, typename G_, typename H_, typename I_,
sl@0	2501	typename J_, typename K_, typename L_, typename M_, typename N_,
sl@0	2502	typename O_
sl@0	2503	>
sl@0	2504	struct result { typedef result_type type; };
sl@0	2505
sl@0	2506	member_function_ptr_action(mem_func_ptr_t fptr_)
sl@0	2507	: fptr(fptr_) {}
sl@0	2508
sl@0	2509	template <typename CT>
sl@0	2510	result_type operator()(CT& obj,
sl@0	2511	A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k, L l, M m, N n, O o
sl@0	2512	) const
sl@0	2513	{
sl@0	2514	return (impl::as_ptr<CT>::get(obj)->*fptr)
sl@0	2515	(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o);
sl@0	2516	}
sl@0	2517
sl@0	2518	mem_func_ptr_t fptr;
sl@0	2519	};
sl@0	2520
sl@0	2521	//////////////////////////////////
sl@0	2522	template <typename RT, typename ClassT,
sl@0	2523	typename A, typename B, typename C, typename D,
sl@0	2524	typename E, typename F, typename G, typename H, typename I,
sl@0	2525	typename J, typename K, typename L, typename M, typename N,
sl@0	2526	typename O
sl@0	2527	>
sl@0	2528	inline member_function_ptr<RT, ClassT, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>
sl@0	2529	bind(RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O))
sl@0	2530	{
sl@0	2531	return member_function_ptr<
sl@0	2532	RT, ClassT, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(fptr);
sl@0	2533	}
sl@0	2534
sl@0	2535	//////////////////////////////////
sl@0	2536	template <typename RT, typename ClassT,
sl@0	2537	typename A, typename B, typename C, typename D,
sl@0	2538	typename E, typename F, typename G, typename H, typename I,
sl@0	2539	typename J, typename K, typename L, typename M, typename N,
sl@0	2540	typename O
sl@0	2541	>
sl@0	2542	inline member_function_ptr<RT, ClassT const, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>
sl@0	2543	bind(RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) const)
sl@0	2544	{
sl@0	2545	return member_function_ptr<
sl@0	2546	RT, ClassT const, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(fptr);
sl@0	2547	}
sl@0	2548
sl@0	2549	#endif
sl@0	2550	#endif
sl@0	2551	#endif
sl@0	2552	#endif
sl@0	2553
sl@0	2554	///////////////////////////////////////////////////////////////////////////////
sl@0	2555	//
sl@0	2556	// Bound member function binder (main class)
sl@0	2557	//
sl@0	2558	///////////////////////////////////////////////////////////////////////////////
sl@0	2559	template <
sl@0	2560	typename RT,
sl@0	2561	typename ClassT
sl@0	2562	, typename A = nil_t
sl@0	2563	, typename B = nil_t
sl@0	2564	, typename C = nil_t
sl@0	2565
sl@0	2566	#if PHOENIX_LIMIT > 3
sl@0	2567	, typename D = nil_t
sl@0	2568	, typename E = nil_t
sl@0	2569	, typename F = nil_t
sl@0	2570
sl@0	2571	#if PHOENIX_LIMIT > 6
sl@0	2572	, typename G = nil_t
sl@0	2573	, typename H = nil_t
sl@0	2574	, typename I = nil_t
sl@0	2575
sl@0	2576	#if PHOENIX_LIMIT > 9
sl@0	2577	, typename J = nil_t
sl@0	2578	, typename K = nil_t
sl@0	2579	, typename L = nil_t
sl@0	2580
sl@0	2581	#if PHOENIX_LIMIT > 12
sl@0	2582	, typename M = nil_t
sl@0	2583	, typename N = nil_t
sl@0	2584	, typename O = nil_t
sl@0	2585
sl@0	2586	#endif
sl@0	2587	#endif
sl@0	2588	#endif
sl@0	2589	#endif
sl@0	2590
sl@0	2591	, typename NU = nil_t // Not used
sl@0	2592	>
sl@0	2593	struct bound_member_action;
sl@0	2594
sl@0	2595	//////////////////////////////////
sl@0	2596	template <
sl@0	2597	typename RT,
sl@0	2598	typename ClassT
sl@0	2599	, typename A = nil_t
sl@0	2600	, typename B = nil_t
sl@0	2601	, typename C = nil_t
sl@0	2602
sl@0	2603	#if PHOENIX_LIMIT > 3
sl@0	2604	, typename D = nil_t
sl@0	2605	, typename E = nil_t
sl@0	2606	, typename F = nil_t
sl@0	2607
sl@0	2608	#if PHOENIX_LIMIT > 6
sl@0	2609	, typename G = nil_t
sl@0	2610	, typename H = nil_t
sl@0	2611	, typename I = nil_t
sl@0	2612
sl@0	2613	#if PHOENIX_LIMIT > 9
sl@0	2614	, typename J = nil_t
sl@0	2615	, typename K = nil_t
sl@0	2616	, typename L = nil_t
sl@0	2617
sl@0	2618	#if PHOENIX_LIMIT > 12
sl@0	2619	, typename M = nil_t
sl@0	2620	, typename N = nil_t
sl@0	2621	, typename O = nil_t
sl@0	2622
sl@0	2623	#endif
sl@0	2624	#endif
sl@0	2625	#endif
sl@0	2626	#endif
sl@0	2627	>
sl@0	2628	struct bound_member
sl@0	2629	: public function<bound_member_action<RT, ClassT
sl@0	2630	, A, B, C
sl@0	2631	#if PHOENIX_LIMIT > 3
sl@0	2632	, D, E, F
sl@0	2633	#if PHOENIX_LIMIT > 6
sl@0	2634	, G, H, I
sl@0	2635	#if PHOENIX_LIMIT > 9
sl@0	2636	, J, K, L
sl@0	2637	#if PHOENIX_LIMIT > 12
sl@0	2638	, M, N, O
sl@0	2639	#endif
sl@0	2640	#endif
sl@0	2641	#endif
sl@0	2642	#endif
sl@0	2643	> > {
sl@0	2644
sl@0	2645	typedef bound_member_action<RT, ClassT
sl@0	2646	, A, B, C
sl@0	2647	#if PHOENIX_LIMIT > 3
sl@0	2648	, D, E, F
sl@0	2649	#if PHOENIX_LIMIT > 6
sl@0	2650	, G, H, I
sl@0	2651	#if PHOENIX_LIMIT > 9
sl@0	2652	, J, K, L
sl@0	2653	#if PHOENIX_LIMIT > 12
sl@0	2654	, M, N, O
sl@0	2655	#endif
sl@0	2656	#endif
sl@0	2657	#endif
sl@0	2658	#endif
sl@0	2659	> action_t;
sl@0	2660
sl@0	2661	template <typename CT, typename FPT>
sl@0	2662	bound_member(CT & c, FPT fp)
sl@0	2663	: function<action_t>(action_t(c,fp)) {}
sl@0	2664
sl@0	2665	#if !defined(__BORLANDC__)
sl@0	2666	template <typename CT, typename FPT>
sl@0	2667	bound_member(CT * c, FPT fp)
sl@0	2668	: function<action_t>(action_t(c,fp)) {}
sl@0	2669	#endif
sl@0	2670	};
sl@0	2671
sl@0	2672	///////////////////////////////////////////////////////////////////////////////
sl@0	2673	//
sl@0	2674	// Bound member function binder (specialization for 0 arg)
sl@0	2675	//
sl@0	2676	///////////////////////////////////////////////////////////////////////////////
sl@0	2677
sl@0	2678	template <typename RT, typename ClassT>
sl@0	2679	struct bound_member_action<RT, ClassT,
sl@0	2680	nil_t, nil_t, nil_t,
sl@0	2681	#if PHOENIX_LIMIT > 3
sl@0	2682	nil_t, nil_t, nil_t,
sl@0	2683	#if PHOENIX_LIMIT > 6
sl@0	2684	nil_t, nil_t, nil_t,
sl@0	2685	#if PHOENIX_LIMIT > 9
sl@0	2686	nil_t, nil_t, nil_t,
sl@0	2687	#if PHOENIX_LIMIT > 12
sl@0	2688	nil_t, nil_t, nil_t,
sl@0	2689	#endif
sl@0	2690	#endif
sl@0	2691	#endif
sl@0	2692	#endif
sl@0	2693	nil_t // Unused
sl@0	2694	> {
sl@0	2695
sl@0	2696	typedef RT result_type;
sl@0	2697	typedef RT(ClassT::*mf)();
sl@0	2698	typedef RT(ClassT::*cmf)() const;
sl@0	2699	typedef typename boost::mpl::if_<boost::is_const<ClassT>, cmf, mf>::type
sl@0	2700	mem_func_ptr_t;
sl@0	2701
sl@0	2702	template <typename CT>
sl@0	2703	struct result { typedef result_type type; };
sl@0	2704
sl@0	2705	template <typename CT>
sl@0	2706	bound_member_action(CT & obj_, mem_func_ptr_t fptr_)
sl@0	2707	: obj(impl::as_ptr<CT>::get(obj_)), fptr(fptr_) {}
sl@0	2708
sl@0	2709	result_type operator()() const
sl@0	2710	{ return (obj->*fptr)(); }
sl@0	2711
sl@0	2712	typename impl::as_ptr<ClassT>::pointer_type obj;
sl@0	2713	mem_func_ptr_t fptr;
sl@0	2714	};
sl@0	2715
sl@0	2716	//////////////////////////////////
sl@0	2717
sl@0	2718	template <typename RT, typename ClassT>
sl@0	2719	inline bound_member<RT,ClassT>
sl@0	2720	bind(ClassT & obj, RT(ClassT::*fptr)())
sl@0	2721	{
sl@0	2722	return bound_member<RT,ClassT>(obj, fptr);
sl@0	2723	}
sl@0	2724
sl@0	2725	template <typename RT, typename ClassT>
sl@0	2726	inline bound_member<RT,ClassT>
sl@0	2727	bind(ClassT * obj, RT(ClassT::*fptr)())
sl@0	2728	{
sl@0	2729	#if defined(__MWERKS__) && (__MWERKS__ < 0x3003)
sl@0	2730	return bound_member<RT,ClassT>(*obj, fptr);
sl@0	2731	#else
sl@0	2732	return bound_member<RT,ClassT>(obj, fptr);
sl@0	2733	#endif
sl@0	2734	}
sl@0	2735
sl@0	2736	template <typename RT, typename ClassT>
sl@0	2737	inline bound_member<RT,ClassT const>
sl@0	2738	bind(ClassT const& obj, RT(ClassT::*fptr)())
sl@0	2739	{
sl@0	2740	return bound_member<RT,ClassT const>(obj, fptr);
sl@0	2741	}
sl@0	2742
sl@0	2743	template <typename RT, typename ClassT>
sl@0	2744	inline bound_member<RT,ClassT const>
sl@0	2745	bind(ClassT const* obj, RT(ClassT::*fptr)() const)
sl@0	2746	{
sl@0	2747	#if defined(__MWERKS__) && (__MWERKS__ < 0x3003)
sl@0	2748	return bound_member<RT,ClassT const>(*obj, fptr);
sl@0	2749	#else
sl@0	2750	return bound_member<RT,ClassT const>(obj, fptr);
sl@0	2751	#endif
sl@0	2752	}
sl@0	2753
sl@0	2754	///////////////////////////////////////////////////////////////////////////////
sl@0	2755	//
sl@0	2756	// Bound member function binder (specialization for 1 arg)
sl@0	2757	//
sl@0	2758	///////////////////////////////////////////////////////////////////////////////
sl@0	2759	template <typename RT, typename ClassT, typename A>
sl@0	2760	struct bound_member_action<RT, ClassT,
sl@0	2761	A, nil_t, nil_t,
sl@0	2762	#if PHOENIX_LIMIT > 3
sl@0	2763	nil_t, nil_t, nil_t,
sl@0	2764	#if PHOENIX_LIMIT > 6
sl@0	2765	nil_t, nil_t, nil_t,
sl@0	2766	#if PHOENIX_LIMIT > 9
sl@0	2767	nil_t, nil_t, nil_t,
sl@0	2768	#if PHOENIX_LIMIT > 12
sl@0	2769	nil_t, nil_t, nil_t,
sl@0	2770	#endif
sl@0	2771	#endif
sl@0	2772	#endif
sl@0	2773	#endif
sl@0	2774	nil_t // Unused
sl@0	2775	> {
sl@0	2776
sl@0	2777	typedef RT result_type;
sl@0	2778	typedef RT(ClassT::*mf)(A);
sl@0	2779	typedef RT(ClassT::*cmf)(A) const;
sl@0	2780	typedef typename boost::mpl::if_<boost::is_const<ClassT>, cmf, mf>::type
sl@0	2781	mem_func_ptr_t;
sl@0	2782
sl@0	2783	template <typename A_>
sl@0	2784	struct result { typedef result_type type; };
sl@0	2785
sl@0	2786	template <typename CT>
sl@0	2787	bound_member_action(CT & obj_, mem_func_ptr_t fptr_)
sl@0	2788	: obj(impl::as_ptr<CT>::get(obj_)), fptr(fptr_) {}
sl@0	2789
sl@0	2790	result_type operator()(A a) const
sl@0	2791	{ return (obj->*fptr)(a); }
sl@0	2792
sl@0	2793	typename impl::as_ptr<ClassT>::pointer_type obj;
sl@0	2794	mem_func_ptr_t fptr;
sl@0	2795	};
sl@0	2796
sl@0	2797	//////////////////////////////////
sl@0	2798	template <typename RT, typename ClassT, typename A>
sl@0	2799	inline bound_member<RT, ClassT, A>
sl@0	2800	bind(ClassT & obj, RT(ClassT::*fptr)(A))
sl@0	2801	{
sl@0	2802	return bound_member<RT, ClassT, A>(obj,fptr);
sl@0	2803	}
sl@0	2804
sl@0	2805	template <typename RT, typename ClassT, typename A>
sl@0	2806	inline bound_member<RT, ClassT, A>
sl@0	2807	bind(ClassT * obj, RT(ClassT::*fptr)(A))
sl@0	2808	{
sl@0	2809	return bound_member<RT, ClassT, A>(obj,fptr);
sl@0	2810	}
sl@0	2811
sl@0	2812	//////////////////////////////////
sl@0	2813	template <typename RT, typename ClassT, typename A>
sl@0	2814	inline bound_member<RT, ClassT const, A>
sl@0	2815	bind(ClassT const& obj, RT(ClassT::*fptr)(A) const)
sl@0	2816	{
sl@0	2817	return bound_member<RT, ClassT const, A>(obj,fptr);
sl@0	2818	}
sl@0	2819
sl@0	2820	template <typename RT, typename ClassT, typename A>
sl@0	2821	inline bound_member<RT, ClassT const, A>
sl@0	2822	bind(ClassT const* obj, RT(ClassT::*fptr)(A) const)
sl@0	2823	{
sl@0	2824	return bound_member<RT, ClassT const, A>(obj,fptr);
sl@0	2825	}
sl@0	2826
sl@0	2827	///////////////////////////////////////////////////////////////////////////////
sl@0	2828	//
sl@0	2829	// Bound member function binder (specialization for 2 args)
sl@0	2830	//
sl@0	2831	///////////////////////////////////////////////////////////////////////////////
sl@0	2832	template <typename RT, typename ClassT, typename A, typename B>
sl@0	2833	struct bound_member_action<RT, ClassT,
sl@0	2834	A, B, nil_t,
sl@0	2835	#if PHOENIX_LIMIT > 3
sl@0	2836	nil_t, nil_t, nil_t,
sl@0	2837	#if PHOENIX_LIMIT > 6
sl@0	2838	nil_t, nil_t, nil_t,
sl@0	2839	#if PHOENIX_LIMIT > 9
sl@0	2840	nil_t, nil_t, nil_t,
sl@0	2841	#if PHOENIX_LIMIT > 12
sl@0	2842	nil_t, nil_t, nil_t,
sl@0	2843	#endif
sl@0	2844	#endif
sl@0	2845	#endif
sl@0	2846	#endif
sl@0	2847	nil_t // Unused
sl@0	2848	> {
sl@0	2849
sl@0	2850	typedef RT result_type;
sl@0	2851	typedef RT(ClassT::*mf)(A, B);
sl@0	2852	typedef RT(ClassT::*cmf)(A, B) const;
sl@0	2853	typedef typename boost::mpl::if_<boost::is_const<ClassT>, cmf, mf>::type
sl@0	2854	mem_func_ptr_t;
sl@0	2855
sl@0	2856	template <typename A_, typename B_>
sl@0	2857	struct result { typedef result_type type; };
sl@0	2858
sl@0	2859	template <typename CT>
sl@0	2860	bound_member_action(CT & obj_, mem_func_ptr_t fptr_)
sl@0	2861	: obj(impl::as_ptr<CT>::get(obj_)), fptr(fptr_) {}
sl@0	2862
sl@0	2863	result_type operator()(A a, B b) const
sl@0	2864	{ return (obj->*fptr)(a, b); }
sl@0	2865
sl@0	2866	typename impl::as_ptr<ClassT>::pointer_type obj;
sl@0	2867	mem_func_ptr_t fptr;
sl@0	2868	};
sl@0	2869
sl@0	2870	//////////////////////////////////
sl@0	2871	template <typename RT, typename ClassT, typename A, typename B>
sl@0	2872	inline bound_member<RT, ClassT, A, B>
sl@0	2873	bind(ClassT & obj,RT(ClassT::*fptr)(A, B))
sl@0	2874	{
sl@0	2875	return bound_member<RT, ClassT, A, B>(obj,fptr);
sl@0	2876	}
sl@0	2877
sl@0	2878	template <typename RT, typename ClassT, typename A, typename B>
sl@0	2879	inline bound_member<RT, ClassT, A, B>
sl@0	2880	bind(ClassT * obj,RT(ClassT::*fptr)(A, B))
sl@0	2881	{
sl@0	2882	return bound_member<RT, ClassT, A, B>(obj,fptr);
sl@0	2883	}
sl@0	2884
sl@0	2885	template <typename RT, typename ClassT, typename A, typename B>
sl@0	2886	inline bound_member<RT, ClassT const, A, B>
sl@0	2887	bind(ClassT const& obj,RT(ClassT::*fptr)(A, B) const)
sl@0	2888	{
sl@0	2889	return bound_member<RT, ClassT const, A, B>(obj,fptr);
sl@0	2890	}
sl@0	2891
sl@0	2892	template <typename RT, typename ClassT, typename A, typename B>
sl@0	2893	inline bound_member<RT, ClassT const, A, B>
sl@0	2894	bind(ClassT const* obj,RT(ClassT::*fptr)(A, B) const)
sl@0	2895	{
sl@0	2896	return bound_member<RT, ClassT const, A, B>(obj,fptr);
sl@0	2897	}
sl@0	2898
sl@0	2899	#if PHOENIX_LIMIT > 3
sl@0	2900	///////////////////////////////////////////////////////////////////////////////
sl@0	2901	//
sl@0	2902	// Bound member function binder (specialization for 3 args)
sl@0	2903	//
sl@0	2904	///////////////////////////////////////////////////////////////////////////////
sl@0	2905	template <typename RT, typename ClassT, typename A, typename B, typename C>
sl@0	2906	struct bound_member_action<RT, ClassT,
sl@0	2907	A, B, C, nil_t, nil_t, nil_t,
sl@0	2908	#if PHOENIX_LIMIT > 6
sl@0	2909	nil_t, nil_t, nil_t,
sl@0	2910	#if PHOENIX_LIMIT > 9
sl@0	2911	nil_t, nil_t, nil_t,
sl@0	2912	#if PHOENIX_LIMIT > 12
sl@0	2913	nil_t, nil_t, nil_t,
sl@0	2914	#endif
sl@0	2915	#endif
sl@0	2916	#endif
sl@0	2917	nil_t // Unused
sl@0	2918	> {
sl@0	2919
sl@0	2920	typedef RT result_type;
sl@0	2921	typedef RT(ClassT::*mf)(A, B, C);
sl@0	2922	typedef RT(ClassT::*cmf)(A, B, C) const;
sl@0	2923	typedef typename boost::mpl::if_<boost::is_const<ClassT>, cmf, mf>::type
sl@0	2924	mem_func_ptr_t;
sl@0	2925
sl@0	2926	template <typename A_, typename B_, typename C_>
sl@0	2927	struct result { typedef result_type type; };
sl@0	2928
sl@0	2929	template <typename CT>
sl@0	2930	bound_member_action(CT & obj_, mem_func_ptr_t fptr_)
sl@0	2931	: obj(impl::as_ptr<CT>::get(obj_)), fptr(fptr_) {}
sl@0	2932
sl@0	2933	result_type operator()(A a, B b, C c) const
sl@0	2934	{ return (obj->*fptr)(a, b, c); }
sl@0	2935
sl@0	2936	typename impl::as_ptr<ClassT>::pointer_type obj;
sl@0	2937	mem_func_ptr_t fptr;
sl@0	2938	};
sl@0	2939
sl@0	2940	//////////////////////////////////
sl@0	2941	template <typename RT, typename ClassT, typename A, typename B, typename C>
sl@0	2942	inline bound_member<RT, ClassT, A, B, C>
sl@0	2943	bind(ClassT & obj,RT(ClassT::*fptr)(A, B, C))
sl@0	2944	{
sl@0	2945	return bound_member<RT, ClassT, A, B, C>(obj,fptr);
sl@0	2946	}
sl@0	2947
sl@0	2948	template <typename RT, typename ClassT, typename A, typename B, typename C>
sl@0	2949	inline bound_member<RT, ClassT, A, B, C>
sl@0	2950	bind(ClassT * obj,RT(ClassT::*fptr)(A, B, C))
sl@0	2951	{
sl@0	2952	return bound_member<RT, ClassT, A, B, C>(obj,fptr);
sl@0	2953	}
sl@0	2954
sl@0	2955	template <typename RT, typename ClassT, typename A, typename B, typename C>
sl@0	2956	inline bound_member<RT, ClassT const, A, B, C>
sl@0	2957	bind(ClassT const& obj,RT(ClassT::*fptr)(A, B, C) const)
sl@0	2958	{
sl@0	2959	return bound_member<RT, ClassT const, A, B, C>(obj,fptr);
sl@0	2960	}
sl@0	2961
sl@0	2962	template <typename RT, typename ClassT, typename A, typename B, typename C>
sl@0	2963	inline bound_member<RT, ClassT const, A, B, C>
sl@0	2964	bind(ClassT const* obj,RT(ClassT::*fptr)(A, B, C) const)
sl@0	2965	{
sl@0	2966	return bound_member<RT, ClassT const, A, B, C>(obj,fptr);
sl@0	2967	}
sl@0	2968
sl@0	2969	///////////////////////////////////////////////////////////////////////////////
sl@0	2970	//
sl@0	2971	// Bound member function binder (specialization for 4 args)
sl@0	2972	//
sl@0	2973	///////////////////////////////////////////////////////////////////////////////
sl@0	2974	template <typename RT, typename ClassT,
sl@0	2975	typename A, typename B, typename C, typename D
sl@0	2976	>
sl@0	2977	struct bound_member_action<RT, ClassT,
sl@0	2978	A, B, C, D, nil_t, nil_t,
sl@0	2979	#if PHOENIX_LIMIT > 6
sl@0	2980	nil_t, nil_t, nil_t,
sl@0	2981	#if PHOENIX_LIMIT > 9
sl@0	2982	nil_t, nil_t, nil_t,
sl@0	2983	#if PHOENIX_LIMIT > 12
sl@0	2984	nil_t, nil_t, nil_t,
sl@0	2985	#endif
sl@0	2986	#endif
sl@0	2987	#endif
sl@0	2988	nil_t // Unused
sl@0	2989	> {
sl@0	2990
sl@0	2991	typedef RT result_type;
sl@0	2992	typedef RT(ClassT::*mf)(A, B, C, D);
sl@0	2993	typedef RT(ClassT::*cmf)(A, B, C, D) const;
sl@0	2994	typedef typename boost::mpl::if_<boost::is_const<ClassT>, cmf, mf>::type
sl@0	2995	mem_func_ptr_t;
sl@0	2996
sl@0	2997	template <typename A_, typename B_, typename C_, typename D_>
sl@0	2998	struct result { typedef result_type type; };
sl@0	2999
sl@0	3000	template <typename CT>
sl@0	3001	bound_member_action(CT & obj_, mem_func_ptr_t fptr_)
sl@0	3002	: obj(impl::as_ptr<CT>::get(obj_)), fptr(fptr_) {}
sl@0	3003
sl@0	3004	result_type operator()(A a, B b, C c, D d) const
sl@0	3005	{ return (obj->*fptr)(a, b, c, d); }
sl@0	3006
sl@0	3007	typename impl::as_ptr<ClassT>::pointer_type obj;
sl@0	3008	mem_func_ptr_t fptr;
sl@0	3009	};
sl@0	3010
sl@0	3011	//////////////////////////////////
sl@0	3012	template <typename RT, typename ClassT,
sl@0	3013	typename A, typename B, typename C, typename D
sl@0	3014	>
sl@0	3015	inline bound_member<RT, ClassT, A, B, C, D>
sl@0	3016	bind(ClassT & obj,RT(ClassT::*fptr)(A, B, C, D))
sl@0	3017	{
sl@0	3018	return bound_member<
sl@0	3019	RT, ClassT, A, B, C, D>(obj,fptr);
sl@0	3020	}
sl@0	3021
sl@0	3022	template <typename RT, typename ClassT,
sl@0	3023	typename A, typename B, typename C, typename D
sl@0	3024	>
sl@0	3025	inline bound_member<RT, ClassT, A, B, C, D>
sl@0	3026	bind(ClassT * obj,RT(ClassT::*fptr)(A, B, C, D))
sl@0	3027	{
sl@0	3028	return bound_member<
sl@0	3029	RT, ClassT, A, B, C, D>(obj,fptr);
sl@0	3030	}
sl@0	3031
sl@0	3032	template <typename RT, typename ClassT,
sl@0	3033	typename A, typename B, typename C, typename D
sl@0	3034	>
sl@0	3035	inline bound_member<RT, ClassT const, A, B, C, D>
sl@0	3036	bind(ClassT const& obj,RT(ClassT::*fptr)(A, B, C, D) const)
sl@0	3037	{
sl@0	3038	return bound_member<
sl@0	3039	RT, ClassT const, A, B, C, D>(obj,fptr);
sl@0	3040	}
sl@0	3041
sl@0	3042	template <typename RT, typename ClassT,
sl@0	3043	typename A, typename B, typename C, typename D
sl@0	3044	>
sl@0	3045	inline bound_member<RT, ClassT const, A, B, C, D>
sl@0	3046	bind(ClassT const* obj,RT(ClassT::*fptr)(A, B, C, D) const)
sl@0	3047	{
sl@0	3048	return bound_member<
sl@0	3049	RT, ClassT const, A, B, C, D>(obj,fptr);
sl@0	3050	}
sl@0	3051
sl@0	3052	///////////////////////////////////////////////////////////////////////////////
sl@0	3053	//
sl@0	3054	// Bound member function binder (specialization for 5 args)
sl@0	3055	//
sl@0	3056	///////////////////////////////////////////////////////////////////////////////
sl@0	3057	template <typename RT, typename ClassT,
sl@0	3058	typename A, typename B, typename C, typename D,
sl@0	3059	typename E
sl@0	3060	>
sl@0	3061	struct bound_member_action<RT, ClassT,
sl@0	3062	A, B, C, D, E, nil_t,
sl@0	3063	#if PHOENIX_LIMIT > 6
sl@0	3064	nil_t, nil_t, nil_t,
sl@0	3065	#if PHOENIX_LIMIT > 9
sl@0	3066	nil_t, nil_t, nil_t,
sl@0	3067	#if PHOENIX_LIMIT > 12
sl@0	3068	nil_t, nil_t, nil_t,
sl@0	3069	#endif
sl@0	3070	#endif
sl@0	3071	#endif
sl@0	3072	nil_t // Unused
sl@0	3073	> {
sl@0	3074
sl@0	3075	typedef RT result_type;
sl@0	3076	typedef RT(ClassT::*mf)(A, B, C, D, E);
sl@0	3077	typedef RT(ClassT::*cmf)(A, B, C, D, E) const;
sl@0	3078	typedef typename boost::mpl::if_<boost::is_const<ClassT>, cmf, mf>::type
sl@0	3079	mem_func_ptr_t;
sl@0	3080
sl@0	3081	template <typename A_, typename B_, typename C_, typename D_,
sl@0	3082	typename E_
sl@0	3083	>
sl@0	3084	struct result { typedef result_type type; };
sl@0	3085
sl@0	3086	template <typename CT>
sl@0	3087	bound_member_action(CT & obj_, mem_func_ptr_t fptr_)
sl@0	3088	: obj(impl::as_ptr<CT>::get(obj_)), fptr(fptr_) {}
sl@0	3089
sl@0	3090	result_type operator()(
sl@0	3091	A a, B b, C c, D d, E e
sl@0	3092	) const
sl@0	3093	{ return (obj->*fptr)(a, b, c, d, e); }
sl@0	3094
sl@0	3095	typename impl::as_ptr<ClassT>::pointer_type obj;
sl@0	3096	mem_func_ptr_t fptr;
sl@0	3097	};
sl@0	3098
sl@0	3099	//////////////////////////////////
sl@0	3100	template <typename RT, typename ClassT,
sl@0	3101	typename A, typename B, typename C, typename D,
sl@0	3102	typename E
sl@0	3103	>
sl@0	3104	inline bound_member<RT, ClassT, A, B, C, D, E>
sl@0	3105	bind(ClassT & obj,RT(ClassT::*fptr)(A, B, C, D, E))
sl@0	3106	{
sl@0	3107	return bound_member<
sl@0	3108	RT, ClassT, A, B, C, D, E>(obj,fptr);
sl@0	3109	}
sl@0	3110
sl@0	3111	template <typename RT, typename ClassT,
sl@0	3112	typename A, typename B, typename C, typename D,
sl@0	3113	typename E
sl@0	3114	>
sl@0	3115	inline bound_member<RT, ClassT, A, B, C, D, E>
sl@0	3116	bind(ClassT * obj,RT(ClassT::*fptr)(A, B, C, D, E))
sl@0	3117	{
sl@0	3118	return bound_member<
sl@0	3119	RT, ClassT, A, B, C, D, E>(obj,fptr);
sl@0	3120	}
sl@0	3121
sl@0	3122	template <typename RT, typename ClassT,
sl@0	3123	typename A, typename B, typename C, typename D,
sl@0	3124	typename E
sl@0	3125	>
sl@0	3126	inline bound_member<RT, ClassT const, A, B, C, D, E>
sl@0	3127	bind(ClassT const& obj,RT(ClassT::*fptr)(A, B, C, D, E) const)
sl@0	3128	{
sl@0	3129	return bound_member<
sl@0	3130	RT, ClassT const, A, B, C, D, E>(obj,fptr);
sl@0	3131	}
sl@0	3132
sl@0	3133	template <typename RT, typename ClassT,
sl@0	3134	typename A, typename B, typename C, typename D,
sl@0	3135	typename E
sl@0	3136	>
sl@0	3137	inline bound_member<RT, ClassT const, A, B, C, D, E>
sl@0	3138	bind(ClassT const* obj,RT(ClassT::*fptr)(A, B, C, D, E) const)
sl@0	3139	{
sl@0	3140	return bound_member<
sl@0	3141	RT, ClassT const, A, B, C, D, E>(obj,fptr);
sl@0	3142	}
sl@0	3143
sl@0	3144	#if PHOENIX_LIMIT > 6
sl@0	3145	///////////////////////////////////////////////////////////////////////////////
sl@0	3146	//
sl@0	3147	// Bound member function binder (specialization for 6 args)
sl@0	3148	//
sl@0	3149	///////////////////////////////////////////////////////////////////////////////
sl@0	3150	template <typename RT, typename ClassT,
sl@0	3151	typename A, typename B, typename C, typename D,
sl@0	3152	typename E, typename F
sl@0	3153	>
sl@0	3154	struct bound_member_action<RT, ClassT,
sl@0	3155	A, B, C, D, E, F, nil_t, nil_t, nil_t,
sl@0	3156	#if PHOENIX_LIMIT > 9
sl@0	3157	nil_t, nil_t, nil_t,
sl@0	3158	#if PHOENIX_LIMIT > 12
sl@0	3159	nil_t, nil_t, nil_t,
sl@0	3160	#endif
sl@0	3161	#endif
sl@0	3162	nil_t // Unused
sl@0	3163	> {
sl@0	3164
sl@0	3165	typedef RT result_type;
sl@0	3166	typedef RT(ClassT::*mf)(A, B, C, D, E, F);
sl@0	3167	typedef RT(ClassT::*cmf)(A, B, C, D, E, F) const;
sl@0	3168	typedef typename boost::mpl::if_<boost::is_const<ClassT>, cmf, mf>::type
sl@0	3169	mem_func_ptr_t;
sl@0	3170
sl@0	3171	template <
sl@0	3172	typename A_, typename B_, typename C_, typename D_,
sl@0	3173	typename E_, typename F_
sl@0	3174	>
sl@0	3175	struct result { typedef result_type type; };
sl@0	3176
sl@0	3177	template <typename CT>
sl@0	3178	bound_member_action(CT & obj_, mem_func_ptr_t fptr_)
sl@0	3179	: obj(impl::as_ptr<CT>::get(obj_)), fptr(fptr_) {}
sl@0	3180
sl@0	3181	result_type operator()(
sl@0	3182	A a, B b, C c, D d, E e, F f
sl@0	3183	) const
sl@0	3184	{ return (obj->*fptr)(a, b, c, d, e, f); }
sl@0	3185
sl@0	3186	typename impl::as_ptr<ClassT>::pointer_type obj;
sl@0	3187	mem_func_ptr_t fptr;
sl@0	3188	};
sl@0	3189
sl@0	3190	//////////////////////////////////
sl@0	3191	template <typename RT, typename ClassT,
sl@0	3192	typename A, typename B, typename C, typename D,
sl@0	3193	typename E, typename F
sl@0	3194	>
sl@0	3195	inline bound_member<RT, ClassT, A, B, C, D, E, F>
sl@0	3196	bind(ClassT & obj,RT(ClassT::*fptr)(A, B, C, D, E, F))
sl@0	3197	{
sl@0	3198	return bound_member<
sl@0	3199	RT, ClassT, A, B, C, D, E, F>(obj,fptr);
sl@0	3200	}
sl@0	3201
sl@0	3202	template <typename RT, typename ClassT,
sl@0	3203	typename A, typename B, typename C, typename D,
sl@0	3204	typename E, typename F
sl@0	3205	>
sl@0	3206	inline bound_member<RT, ClassT, A, B, C, D, E, F>
sl@0	3207	bind(ClassT * obj,RT(ClassT::*fptr)(A, B, C, D, E, F))
sl@0	3208	{
sl@0	3209	return bound_member<
sl@0	3210	RT, ClassT, A, B, C, D, E, F>(obj,fptr);
sl@0	3211	}
sl@0	3212
sl@0	3213	template <typename RT, typename ClassT,
sl@0	3214	typename A, typename B, typename C, typename D,
sl@0	3215	typename E, typename F
sl@0	3216	>
sl@0	3217	inline bound_member<RT, ClassT const, A, B, C, D, E, F>
sl@0	3218	bind(ClassT const& obj,RT(ClassT::*fptr)(A, B, C, D, E, F) const)
sl@0	3219	{
sl@0	3220	return bound_member<
sl@0	3221	RT, ClassT const, A, B, C, D, E, F>(obj,fptr);
sl@0	3222	}
sl@0	3223
sl@0	3224	template <typename RT, typename ClassT,
sl@0	3225	typename A, typename B, typename C, typename D,
sl@0	3226	typename E, typename F
sl@0	3227	>
sl@0	3228	inline bound_member<RT, ClassT const, A, B, C, D, E, F>
sl@0	3229	bind(ClassT const* obj,RT(ClassT::*fptr)(A, B, C, D, E, F) const)
sl@0	3230	{
sl@0	3231	return bound_member<
sl@0	3232	RT, ClassT const, A, B, C, D, E, F>(obj,fptr);
sl@0	3233	}
sl@0	3234
sl@0	3235	///////////////////////////////////////////////////////////////////////////////
sl@0	3236	//
sl@0	3237	// Bound member function binder (specialization for 7 args)
sl@0	3238	//
sl@0	3239	///////////////////////////////////////////////////////////////////////////////
sl@0	3240	template <typename RT, typename ClassT,
sl@0	3241	typename A, typename B, typename C, typename D,
sl@0	3242	typename E, typename F, typename G
sl@0	3243	>
sl@0	3244	struct bound_member_action<RT, ClassT,
sl@0	3245	A, B, C, D, E, F, G, nil_t, nil_t,
sl@0	3246	#if PHOENIX_LIMIT > 9
sl@0	3247	nil_t, nil_t, nil_t,
sl@0	3248	#if PHOENIX_LIMIT > 12
sl@0	3249	nil_t, nil_t, nil_t,
sl@0	3250	#endif
sl@0	3251	#endif
sl@0	3252	nil_t // Unused
sl@0	3253	> {
sl@0	3254
sl@0	3255	typedef RT result_type;
sl@0	3256	typedef RT(ClassT::*mf)(A, B, C, D, E, F, G);
sl@0	3257	typedef RT(ClassT::*cmf)(A, B, C, D, E, F, G) const;
sl@0	3258	typedef typename boost::mpl::if_<boost::is_const<ClassT>, cmf, mf>::type
sl@0	3259	mem_func_ptr_t;
sl@0	3260
sl@0	3261	template <
sl@0	3262	typename A_, typename B_, typename C_, typename D_,
sl@0	3263	typename E_, typename F_, typename G_
sl@0	3264	>
sl@0	3265	struct result { typedef result_type type; };
sl@0	3266
sl@0	3267	template <typename CT>
sl@0	3268	bound_member_action(CT & obj_, mem_func_ptr_t fptr_)
sl@0	3269	: obj(impl::as_ptr<CT>::get(obj_)), fptr(fptr_) {}
sl@0	3270
sl@0	3271	result_type operator()(
sl@0	3272	A a, B b, C c, D d, E e, F f, G g
sl@0	3273	) const
sl@0	3274	{ return (obj->*fptr)(a, b, c, d, e, f, g); }
sl@0	3275
sl@0	3276	typename impl::as_ptr<ClassT>::pointer_type obj;
sl@0	3277	mem_func_ptr_t fptr;
sl@0	3278	};
sl@0	3279
sl@0	3280	//////////////////////////////////
sl@0	3281	template <typename RT, typename ClassT,
sl@0	3282	typename A, typename B, typename C, typename D,
sl@0	3283	typename E, typename F, typename G
sl@0	3284	>
sl@0	3285	inline bound_member<RT, ClassT, A, B, C, D, E, F, G>
sl@0	3286	bind(ClassT & obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G))
sl@0	3287	{
sl@0	3288	return bound_member<
sl@0	3289	RT, ClassT, A, B, C, D, E, F, G>(obj,fptr);
sl@0	3290	}
sl@0	3291
sl@0	3292	template <typename RT, typename ClassT,
sl@0	3293	typename A, typename B, typename C, typename D,
sl@0	3294	typename E, typename F, typename G
sl@0	3295	>
sl@0	3296	inline bound_member<RT, ClassT, A, B, C, D, E, F, G>
sl@0	3297	bind(ClassT * obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G))
sl@0	3298	{
sl@0	3299	return bound_member<
sl@0	3300	RT, ClassT, A, B, C, D, E, F, G>(obj,fptr);
sl@0	3301	}
sl@0	3302
sl@0	3303	template <typename RT, typename ClassT,
sl@0	3304	typename A, typename B, typename C, typename D,
sl@0	3305	typename E, typename F, typename G
sl@0	3306	>
sl@0	3307	inline bound_member<RT, ClassT const, A, B, C, D, E, F, G>
sl@0	3308	bind(ClassT const& obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G) const)
sl@0	3309	{
sl@0	3310	return bound_member<
sl@0	3311	RT, ClassT const, A, B, C, D, E, F, G>(obj,fptr);
sl@0	3312	}
sl@0	3313
sl@0	3314	template <typename RT, typename ClassT,
sl@0	3315	typename A, typename B, typename C, typename D,
sl@0	3316	typename E, typename F, typename G
sl@0	3317	>
sl@0	3318	inline bound_member<RT, ClassT const, A, B, C, D, E, F, G>
sl@0	3319	bind(ClassT const* obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G) const)
sl@0	3320	{
sl@0	3321	return bound_member<
sl@0	3322	RT, ClassT const, A, B, C, D, E, F, G>(obj,fptr);
sl@0	3323	}
sl@0	3324
sl@0	3325	///////////////////////////////////////////////////////////////////////////////
sl@0	3326	//
sl@0	3327	// Bound member function binder (specialization for 8 args)
sl@0	3328	//
sl@0	3329	///////////////////////////////////////////////////////////////////////////////
sl@0	3330	template <typename RT, typename ClassT,
sl@0	3331	typename A, typename B, typename C, typename D,
sl@0	3332	typename E, typename F, typename G, typename H
sl@0	3333	>
sl@0	3334	struct bound_member_action<RT, ClassT,
sl@0	3335	A, B, C, D, E, F, G, H, nil_t,
sl@0	3336	#if PHOENIX_LIMIT > 9
sl@0	3337	nil_t, nil_t, nil_t,
sl@0	3338	#if PHOENIX_LIMIT > 12
sl@0	3339	nil_t, nil_t, nil_t,
sl@0	3340	#endif
sl@0	3341	#endif
sl@0	3342	nil_t // Unused
sl@0	3343	> {
sl@0	3344
sl@0	3345	typedef RT result_type;
sl@0	3346	typedef RT(ClassT::*mf)(A, B, C, D, E, F, G, H);
sl@0	3347	typedef RT(ClassT::*cmf)(A, B, C, D, E, F, G, H) const;
sl@0	3348	typedef typename boost::mpl::if_<boost::is_const<ClassT>, cmf, mf>::type
sl@0	3349	mem_func_ptr_t;
sl@0	3350
sl@0	3351	template <
sl@0	3352	typename A_, typename B_, typename C_, typename D_,
sl@0	3353	typename E_, typename F_, typename G_, typename H_
sl@0	3354	>
sl@0	3355	struct result { typedef result_type type; };
sl@0	3356
sl@0	3357	template <typename CT>
sl@0	3358	bound_member_action(CT & obj_, mem_func_ptr_t fptr_)
sl@0	3359	: obj(impl::as_ptr<CT>::get(obj_)), fptr(fptr_) {}
sl@0	3360
sl@0	3361	result_type operator()(
sl@0	3362	A a, B b, C c, D d, E e, F f, G g, H h
sl@0	3363	) const
sl@0	3364	{ return (obj->*fptr)(a, b, c, d, e, f, g, h); }
sl@0	3365
sl@0	3366	typename impl::as_ptr<ClassT>::pointer_type obj;
sl@0	3367	mem_func_ptr_t fptr;
sl@0	3368	};
sl@0	3369
sl@0	3370	//////////////////////////////////
sl@0	3371	template <typename RT, typename ClassT,
sl@0	3372	typename A, typename B, typename C, typename D,
sl@0	3373	typename E, typename F, typename G, typename H
sl@0	3374	>
sl@0	3375	inline bound_member<RT, ClassT, A, B, C, D, E, F, G, H>
sl@0	3376	bind(ClassT & obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H))
sl@0	3377	{
sl@0	3378	return bound_member<
sl@0	3379	RT, ClassT, A, B, C, D, E, F, G, H>(obj,fptr);
sl@0	3380	}
sl@0	3381
sl@0	3382	template <typename RT, typename ClassT,
sl@0	3383	typename A, typename B, typename C, typename D,
sl@0	3384	typename E, typename F, typename G, typename H
sl@0	3385	>
sl@0	3386	inline bound_member<RT, ClassT, A, B, C, D, E, F, G, H>
sl@0	3387	bind(ClassT * obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H))
sl@0	3388	{
sl@0	3389	return bound_member<
sl@0	3390	RT, ClassT, A, B, C, D, E, F, G, H>(obj,fptr);
sl@0	3391	}
sl@0	3392
sl@0	3393	template <typename RT, typename ClassT,
sl@0	3394	typename A, typename B, typename C, typename D,
sl@0	3395	typename E, typename F, typename G, typename H
sl@0	3396	>
sl@0	3397	inline bound_member<RT, ClassT const, A, B, C, D, E, F, G, H>
sl@0	3398	bind(ClassT const& obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H) const)
sl@0	3399	{
sl@0	3400	return bound_member<
sl@0	3401	RT, ClassT const, A, B, C, D, E, F, G, H>(obj,fptr);
sl@0	3402	}
sl@0	3403
sl@0	3404	template <typename RT, typename ClassT,
sl@0	3405	typename A, typename B, typename C, typename D,
sl@0	3406	typename E, typename F, typename G, typename H
sl@0	3407	>
sl@0	3408	inline bound_member<RT, ClassT const, A, B, C, D, E, F, G, H>
sl@0	3409	bind(ClassT const* obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H) const)
sl@0	3410	{
sl@0	3411	return bound_member<
sl@0	3412	RT, ClassT const, A, B, C, D, E, F, G, H>(obj,fptr);
sl@0	3413	}
sl@0	3414
sl@0	3415	#if PHOENIX_LIMIT > 9
sl@0	3416	///////////////////////////////////////////////////////////////////////////////
sl@0	3417	//
sl@0	3418	// Bound member function binder (specialization for 9 args)
sl@0	3419	//
sl@0	3420	///////////////////////////////////////////////////////////////////////////////
sl@0	3421	template <typename RT, typename ClassT,
sl@0	3422	typename A, typename B, typename C, typename D,
sl@0	3423	typename E, typename F, typename G, typename H, typename I
sl@0	3424	>
sl@0	3425	struct bound_member_action<RT, ClassT,
sl@0	3426	A, B, C, D, E, F, G, H, I, nil_t, nil_t, nil_t,
sl@0	3427	#if PHOENIX_LIMIT > 12
sl@0	3428	nil_t, nil_t, nil_t,
sl@0	3429	#endif
sl@0	3430	nil_t // Unused
sl@0	3431	> {
sl@0	3432
sl@0	3433	typedef RT result_type;
sl@0	3434	typedef RT(ClassT::*mf)(A, B, C, D, E, F, G, H, I);
sl@0	3435	typedef RT(ClassT::*cmf)(A, B, C, D, E, F, G, H, I) const;
sl@0	3436	typedef typename boost::mpl::if_<boost::is_const<ClassT>, cmf, mf>::type
sl@0	3437	mem_func_ptr_t;
sl@0	3438
sl@0	3439	template <
sl@0	3440	typename A_, typename B_, typename C_, typename D_,
sl@0	3441	typename E_, typename F_, typename G_, typename H_, typename I_
sl@0	3442	>
sl@0	3443	struct result { typedef result_type type; };
sl@0	3444
sl@0	3445	template <typename CT>
sl@0	3446	bound_member_action(CT & obj_, mem_func_ptr_t fptr_)
sl@0	3447	: obj(impl::as_ptr<CT>::get(obj_)), fptr(fptr_) {}
sl@0	3448
sl@0	3449	result_type operator()(
sl@0	3450	A a, B b, C c, D d, E e, F f, G g, H h, I i
sl@0	3451	) const
sl@0	3452	{ return (obj->*fptr)(a, b, c, d, e, f, g, h, i); }
sl@0	3453
sl@0	3454	typename impl::as_ptr<ClassT>::pointer_type obj;
sl@0	3455	mem_func_ptr_t fptr;
sl@0	3456	};
sl@0	3457
sl@0	3458	//////////////////////////////////
sl@0	3459	template <typename RT, typename ClassT,
sl@0	3460	typename A, typename B, typename C, typename D,
sl@0	3461	typename E, typename F, typename G, typename H, typename I
sl@0	3462	>
sl@0	3463	inline bound_member<RT, ClassT, A, B, C, D, E, F, G, H, I>
sl@0	3464	bind(ClassT & obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I))
sl@0	3465	{
sl@0	3466	return bound_member<
sl@0	3467	RT, ClassT, A, B, C, D, E, F, G, H, I>(obj,fptr);
sl@0	3468	}
sl@0	3469
sl@0	3470	template <typename RT, typename ClassT,
sl@0	3471	typename A, typename B, typename C, typename D,
sl@0	3472	typename E, typename F, typename G, typename H, typename I
sl@0	3473	>
sl@0	3474	inline bound_member<RT, ClassT, A, B, C, D, E, F, G, H, I>
sl@0	3475	bind(ClassT * obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I))
sl@0	3476	{
sl@0	3477	return bound_member<
sl@0	3478	RT, ClassT, A, B, C, D, E, F, G, H, I>(obj,fptr);
sl@0	3479	}
sl@0	3480
sl@0	3481	template <typename RT, typename ClassT,
sl@0	3482	typename A, typename B, typename C, typename D,
sl@0	3483	typename E, typename F, typename G, typename H, typename I
sl@0	3484	>
sl@0	3485	inline bound_member<RT, ClassT const, A, B, C, D, E, F, G, H, I>
sl@0	3486	bind(ClassT const& obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I) const)
sl@0	3487	{
sl@0	3488	return bound_member<
sl@0	3489	RT, ClassT const, A, B, C, D, E, F, G, H, I>(obj,fptr);
sl@0	3490	}
sl@0	3491
sl@0	3492	template <typename RT, typename ClassT,
sl@0	3493	typename A, typename B, typename C, typename D,
sl@0	3494	typename E, typename F, typename G, typename H, typename I
sl@0	3495	>
sl@0	3496	inline bound_member<RT, ClassT const, A, B, C, D, E, F, G, H, I>
sl@0	3497	bind(ClassT const* obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I) const)
sl@0	3498	{
sl@0	3499	return bound_member<
sl@0	3500	RT, ClassT const, A, B, C, D, E, F, G, H, I>(obj,fptr);
sl@0	3501	}
sl@0	3502
sl@0	3503	///////////////////////////////////////////////////////////////////////////////
sl@0	3504	//
sl@0	3505	// Bound member function binder (specialization for 10 args)
sl@0	3506	//
sl@0	3507	///////////////////////////////////////////////////////////////////////////////
sl@0	3508	template <typename RT, typename ClassT,
sl@0	3509	typename A, typename B, typename C, typename D,
sl@0	3510	typename E, typename F, typename G, typename H, typename I,
sl@0	3511	typename J
sl@0	3512	>
sl@0	3513	struct bound_member_action<RT, ClassT,
sl@0	3514	A, B, C, D, E, F, G, H, I, J, nil_t, nil_t,
sl@0	3515	#if PHOENIX_LIMIT > 12
sl@0	3516	nil_t, nil_t, nil_t,
sl@0	3517	#endif
sl@0	3518	nil_t // Unused
sl@0	3519	> {
sl@0	3520
sl@0	3521	typedef RT result_type;
sl@0	3522	typedef RT(ClassT::*mf)(A, B, C, D, E, F, G, H, I, J);
sl@0	3523	typedef RT(ClassT::*cmf)(A, B, C, D, E, F, G, H, I, J) const;
sl@0	3524	typedef typename boost::mpl::if_<boost::is_const<ClassT>, cmf, mf>::type
sl@0	3525	mem_func_ptr_t;
sl@0	3526
sl@0	3527	template <
sl@0	3528	typename A_, typename B_, typename C_, typename D_,
sl@0	3529	typename E_, typename F_, typename G_, typename H_, typename I_,
sl@0	3530	typename J_
sl@0	3531	>
sl@0	3532	struct result { typedef result_type type; };
sl@0	3533
sl@0	3534	template <typename CT>
sl@0	3535	bound_member_action(CT & obj_, mem_func_ptr_t fptr_)
sl@0	3536	: obj(impl::as_ptr<CT>::get(obj_)), fptr(fptr_) {}
sl@0	3537
sl@0	3538	result_type operator()(
sl@0	3539	A a, B b, C c, D d, E e, F f, G g, H h, I i, J j
sl@0	3540	) const
sl@0	3541	{
sl@0	3542	return (obj->*fptr)(a, b, c, d, e, f, g, h, i, j);
sl@0	3543	}
sl@0	3544
sl@0	3545	typename impl::as_ptr<ClassT>::pointer_type obj;
sl@0	3546	mem_func_ptr_t fptr;
sl@0	3547	};
sl@0	3548
sl@0	3549	//////////////////////////////////
sl@0	3550	template <typename RT, typename ClassT,
sl@0	3551	typename A, typename B, typename C, typename D,
sl@0	3552	typename E, typename F, typename G, typename H, typename I,
sl@0	3553	typename J
sl@0	3554	>
sl@0	3555	inline bound_member<RT, ClassT, A, B, C, D, E, F, G, H, I, J>
sl@0	3556	bind(ClassT & obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J))
sl@0	3557	{
sl@0	3558	return bound_member<
sl@0	3559	RT, ClassT, A, B, C, D, E, F, G, H, I, J>(obj,fptr);
sl@0	3560	}
sl@0	3561
sl@0	3562	template <typename RT, typename ClassT,
sl@0	3563	typename A, typename B, typename C, typename D,
sl@0	3564	typename E, typename F, typename G, typename H, typename I,
sl@0	3565	typename J
sl@0	3566	>
sl@0	3567	inline bound_member<RT, ClassT, A, B, C, D, E, F, G, H, I, J>
sl@0	3568	bind(ClassT * obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J))
sl@0	3569	{
sl@0	3570	return bound_member<
sl@0	3571	RT, ClassT, A, B, C, D, E, F, G, H, I, J>(obj,fptr);
sl@0	3572	}
sl@0	3573
sl@0	3574	template <typename RT, typename ClassT,
sl@0	3575	typename A, typename B, typename C, typename D,
sl@0	3576	typename E, typename F, typename G, typename H, typename I,
sl@0	3577	typename J
sl@0	3578	>
sl@0	3579	inline bound_member<RT, ClassT const, A, B, C, D, E, F, G, H, I, J>
sl@0	3580	bind(ClassT const& obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J) const)
sl@0	3581	{
sl@0	3582	return bound_member<
sl@0	3583	RT, ClassT const, A, B, C, D, E, F, G, H, I, J>(obj,fptr);
sl@0	3584	}
sl@0	3585
sl@0	3586	template <typename RT, typename ClassT,
sl@0	3587	typename A, typename B, typename C, typename D,
sl@0	3588	typename E, typename F, typename G, typename H, typename I,
sl@0	3589	typename J
sl@0	3590	>
sl@0	3591	inline bound_member<RT, ClassT const, A, B, C, D, E, F, G, H, I, J>
sl@0	3592	bind(ClassT const* obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J) const)
sl@0	3593	{
sl@0	3594	return bound_member<
sl@0	3595	RT, ClassT const, A, B, C, D, E, F, G, H, I, J>(obj,fptr);
sl@0	3596	}
sl@0	3597
sl@0	3598	///////////////////////////////////////////////////////////////////////////////
sl@0	3599	//
sl@0	3600	// Bound member function binder (specialization for 11 args)
sl@0	3601	//
sl@0	3602	///////////////////////////////////////////////////////////////////////////////
sl@0	3603	template <typename RT, typename ClassT,
sl@0	3604	typename A, typename B, typename C, typename D,
sl@0	3605	typename E, typename F, typename G, typename H, typename I,
sl@0	3606	typename J, typename K
sl@0	3607	>
sl@0	3608	struct bound_member_action<RT, ClassT,
sl@0	3609	A, B, C, D, E, F, G, H, I, J, K, nil_t,
sl@0	3610	#if PHOENIX_LIMIT > 12
sl@0	3611	nil_t, nil_t, nil_t,
sl@0	3612	#endif
sl@0	3613	nil_t // Unused
sl@0	3614	> {
sl@0	3615
sl@0	3616	typedef RT result_type;
sl@0	3617	typedef RT(ClassT::*mf)(A, B, C, D, E, F, G, H, I, J, K);
sl@0	3618	typedef RT(ClassT::*cmf)(A, B, C, D, E, F, G, H, I, J, K) const;
sl@0	3619	typedef typename boost::mpl::if_<boost::is_const<ClassT>, cmf, mf>::type
sl@0	3620	mem_func_ptr_t;
sl@0	3621
sl@0	3622	template <
sl@0	3623	typename A_, typename B_, typename C_, typename D_,
sl@0	3624	typename E_, typename F_, typename G_, typename H_, typename I_,
sl@0	3625	typename J_, typename K_
sl@0	3626	>
sl@0	3627	struct result { typedef result_type type; };
sl@0	3628
sl@0	3629	template <typename CT>
sl@0	3630	bound_member_action(CT & obj_, mem_func_ptr_t fptr_)
sl@0	3631	: obj(impl::as_ptr<CT>::get(obj_)), fptr(fptr_) {}
sl@0	3632
sl@0	3633	result_type operator()(
sl@0	3634	A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k
sl@0	3635	) const
sl@0	3636	{
sl@0	3637	return (obj->*fptr)(a, b, c, d, e, f, g, h, i, j, k);
sl@0	3638	}
sl@0	3639
sl@0	3640	typename impl::as_ptr<ClassT>::pointer_type obj;
sl@0	3641	mem_func_ptr_t fptr;
sl@0	3642	};
sl@0	3643
sl@0	3644	//////////////////////////////////
sl@0	3645	template <typename RT, typename ClassT,
sl@0	3646	typename A, typename B, typename C, typename D,
sl@0	3647	typename E, typename F, typename G, typename H, typename I,
sl@0	3648	typename J, typename K
sl@0	3649	>
sl@0	3650	inline bound_member<RT, ClassT, A, B, C, D, E, F, G, H, I, J, K>
sl@0	3651	bind(ClassT & obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K))
sl@0	3652	{
sl@0	3653	return bound_member<
sl@0	3654	RT, ClassT, A, B, C, D, E, F, G, H, I, J, K>(obj,fptr);
sl@0	3655	}
sl@0	3656
sl@0	3657	template <typename RT, typename ClassT,
sl@0	3658	typename A, typename B, typename C, typename D,
sl@0	3659	typename E, typename F, typename G, typename H, typename I,
sl@0	3660	typename J, typename K
sl@0	3661	>
sl@0	3662	inline bound_member<RT, ClassT, A, B, C, D, E, F, G, H, I, J, K>
sl@0	3663	bind(ClassT * obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K))
sl@0	3664	{
sl@0	3665	return bound_member<
sl@0	3666	RT, ClassT, A, B, C, D, E, F, G, H, I, J, K>(obj,fptr);
sl@0	3667	}
sl@0	3668
sl@0	3669	template <typename RT, typename ClassT,
sl@0	3670	typename A, typename B, typename C, typename D,
sl@0	3671	typename E, typename F, typename G, typename H, typename I,
sl@0	3672	typename J, typename K
sl@0	3673	>
sl@0	3674	inline bound_member<RT, ClassT const, A, B, C, D, E, F, G, H, I, J, K>
sl@0	3675	bind(ClassT const& obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K) const)
sl@0	3676	{
sl@0	3677	return bound_member<
sl@0	3678	RT, ClassT const, A, B, C, D, E, F, G, H, I, J, K>(obj,fptr);
sl@0	3679	}
sl@0	3680
sl@0	3681	template <typename RT, typename ClassT,
sl@0	3682	typename A, typename B, typename C, typename D,
sl@0	3683	typename E, typename F, typename G, typename H, typename I,
sl@0	3684	typename J, typename K
sl@0	3685	>
sl@0	3686	inline bound_member<RT, ClassT const, A, B, C, D, E, F, G, H, I, J, K>
sl@0	3687	bind(ClassT const* obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K) const)
sl@0	3688	{
sl@0	3689	return bound_member<
sl@0	3690	RT, ClassT const, A, B, C, D, E, F, G, H, I, J, K>(obj,fptr);
sl@0	3691	}
sl@0	3692
sl@0	3693	#if PHOENIX_LIMIT > 12
sl@0	3694	///////////////////////////////////////////////////////////////////////////////
sl@0	3695	//
sl@0	3696	// Bound member function binder (specialization for 12 args)
sl@0	3697	//
sl@0	3698	///////////////////////////////////////////////////////////////////////////////
sl@0	3699	template <typename RT, typename ClassT,
sl@0	3700	typename A, typename B, typename C, typename D,
sl@0	3701	typename E, typename F, typename G, typename H, typename I,
sl@0	3702	typename J, typename K, typename L
sl@0	3703	>
sl@0	3704	struct bound_member_action<RT, ClassT,
sl@0	3705	A, B, C, D, E, F, G, H, I, J, K, L, nil_t, nil_t, nil_t, nil_t> {
sl@0	3706
sl@0	3707	typedef RT result_type;
sl@0	3708	typedef RT(ClassT::*mf)(A, B, C, D, E, F, G, H, I, J, K, L);
sl@0	3709	typedef RT(ClassT::*cmf)(A, B, C, D, E, F, G, H, I, J, K, L) const;
sl@0	3710	typedef typename boost::mpl::if_<boost::is_const<ClassT>, cmf, mf>::type
sl@0	3711	mem_func_ptr_t;
sl@0	3712
sl@0	3713	template <
sl@0	3714	typename A_, typename B_, typename C_, typename D_,
sl@0	3715	typename E_, typename F_, typename G_, typename H_, typename I_,
sl@0	3716	typename J_, typename K_, typename L_
sl@0	3717	>
sl@0	3718	struct result { typedef result_type type; };
sl@0	3719
sl@0	3720	template <typename CT>
sl@0	3721	bound_member_action(CT & obj_, mem_func_ptr_t fptr_)
sl@0	3722	: obj(impl::as_ptr<CT>::get(obj_)), fptr(fptr_) {}
sl@0	3723
sl@0	3724	result_type operator()(
sl@0	3725	A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k, L l
sl@0	3726	) const
sl@0	3727	{
sl@0	3728	return (obj->*fptr)(a, b, c, d, e, f, g, h, i, j, k, l);
sl@0	3729	}
sl@0	3730
sl@0	3731	typename impl::as_ptr<ClassT>::pointer_type obj;
sl@0	3732	mem_func_ptr_t fptr;
sl@0	3733	};
sl@0	3734
sl@0	3735	//////////////////////////////////
sl@0	3736	template <typename RT, typename ClassT,
sl@0	3737	typename A, typename B, typename C, typename D,
sl@0	3738	typename E, typename F, typename G, typename H, typename I,
sl@0	3739	typename J, typename K, typename L
sl@0	3740	>
sl@0	3741	inline bound_member<RT, ClassT, A, B, C, D, E, F, G, H, I, J, K, L>
sl@0	3742	bind(ClassT & obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K, L))
sl@0	3743	{
sl@0	3744	return bound_member<
sl@0	3745	RT, ClassT, A, B, C, D, E, F, G, H, I, J, K, L>(obj,fptr);
sl@0	3746	}
sl@0	3747
sl@0	3748	template <typename RT, typename ClassT,
sl@0	3749	typename A, typename B, typename C, typename D,
sl@0	3750	typename E, typename F, typename G, typename H, typename I,
sl@0	3751	typename J, typename K, typename L
sl@0	3752	>
sl@0	3753	inline bound_member<RT, ClassT, A, B, C, D, E, F, G, H, I, J, K, L>
sl@0	3754	bind(ClassT * obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K, L))
sl@0	3755	{
sl@0	3756	return bound_member<
sl@0	3757	RT, ClassT, A, B, C, D, E, F, G, H, I, J, K, L>(obj,fptr);
sl@0	3758	}
sl@0	3759
sl@0	3760	template <typename RT, typename ClassT,
sl@0	3761	typename A, typename B, typename C, typename D,
sl@0	3762	typename E, typename F, typename G, typename H, typename I,
sl@0	3763	typename J, typename K, typename L
sl@0	3764	>
sl@0	3765	inline bound_member<RT, ClassT const, A, B, C, D, E, F, G, H, I, J, K, L>
sl@0	3766	bind(ClassT const& obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K, L) const)
sl@0	3767	{
sl@0	3768	return bound_member<
sl@0	3769	RT, ClassT const, A, B, C, D, E, F, G, H, I, J, K, L>(obj,fptr);
sl@0	3770	}
sl@0	3771
sl@0	3772	template <typename RT, typename ClassT,
sl@0	3773	typename A, typename B, typename C, typename D,
sl@0	3774	typename E, typename F, typename G, typename H, typename I,
sl@0	3775	typename J, typename K, typename L
sl@0	3776	>
sl@0	3777	inline bound_member<RT, ClassT const, A, B, C, D, E, F, G, H, I, J, K, L>
sl@0	3778	bind(ClassT const* obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K, L) const)
sl@0	3779	{
sl@0	3780	return bound_member<
sl@0	3781	RT, ClassT const, A, B, C, D, E, F, G, H, I, J, K, L>(obj,fptr);
sl@0	3782	}
sl@0	3783
sl@0	3784	///////////////////////////////////////////////////////////////////////////////
sl@0	3785	//
sl@0	3786	// Bound member function binder (specialization for 13 args)
sl@0	3787	//
sl@0	3788	///////////////////////////////////////////////////////////////////////////////
sl@0	3789	template <typename RT, typename ClassT,
sl@0	3790	typename A, typename B, typename C, typename D,
sl@0	3791	typename E, typename F, typename G, typename H, typename I,
sl@0	3792	typename J, typename K, typename L, typename M
sl@0	3793	>
sl@0	3794	struct bound_member_action<RT, ClassT,
sl@0	3795	A, B, C, D, E, F, G, H, I, J, K, L, M, nil_t, nil_t, nil_t> {
sl@0	3796
sl@0	3797	typedef RT result_type;
sl@0	3798	typedef RT(ClassT::*mf)(A, B, C, D, E, F, G, H, I, J, K, L, M);
sl@0	3799	typedef RT(ClassT::*cmf)(A, B, C, D, E, F, G, H, I, J, K, L, M) const;
sl@0	3800	typedef typename boost::mpl::if_<boost::is_const<ClassT>, cmf, mf>::type
sl@0	3801	mem_func_ptr_t;
sl@0	3802
sl@0	3803	template <
sl@0	3804	typename A_, typename B_, typename C_, typename D_,
sl@0	3805	typename E_, typename F_, typename G_, typename H_, typename I_,
sl@0	3806	typename J_, typename K_, typename L_, typename M_
sl@0	3807	>
sl@0	3808	struct result { typedef result_type type; };
sl@0	3809
sl@0	3810	template <typename CT>
sl@0	3811	bound_member_action(CT & obj_, mem_func_ptr_t fptr_)
sl@0	3812	: obj(impl::as_ptr<CT>::get(obj_)), fptr(fptr_) {}
sl@0	3813
sl@0	3814	result_type operator()(
sl@0	3815	A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k, L l, M m
sl@0	3816	) const
sl@0	3817	{
sl@0	3818	return (obj->*fptr)(a, b, c, d, e, f, g, h, i, j, k, l, m);
sl@0	3819	}
sl@0	3820
sl@0	3821	typename impl::as_ptr<ClassT>::pointer_type obj;
sl@0	3822	mem_func_ptr_t fptr;
sl@0	3823	};
sl@0	3824
sl@0	3825	//////////////////////////////////
sl@0	3826	template <typename RT, typename ClassT,
sl@0	3827	typename A, typename B, typename C, typename D,
sl@0	3828	typename E, typename F, typename G, typename H, typename I,
sl@0	3829	typename J, typename K, typename L, typename M
sl@0	3830	>
sl@0	3831	inline bound_member<RT, ClassT, A, B, C, D, E, F, G, H, I, J, K, L, M>
sl@0	3832	bind(ClassT & obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K, L, M))
sl@0	3833	{
sl@0	3834	return bound_member<
sl@0	3835	RT, ClassT, A, B, C, D, E, F, G, H, I, J, K, L, M>(obj,fptr);
sl@0	3836	}
sl@0	3837
sl@0	3838	template <typename RT, typename ClassT,
sl@0	3839	typename A, typename B, typename C, typename D,
sl@0	3840	typename E, typename F, typename G, typename H, typename I,
sl@0	3841	typename J, typename K, typename L, typename M
sl@0	3842	>
sl@0	3843	inline bound_member<RT, ClassT, A, B, C, D, E, F, G, H, I, J, K, L, M>
sl@0	3844	bind(ClassT * obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K, L, M))
sl@0	3845	{
sl@0	3846	return bound_member<
sl@0	3847	RT, ClassT, A, B, C, D, E, F, G, H, I, J, K, L, M>(obj,fptr);
sl@0	3848	}
sl@0	3849
sl@0	3850	template <typename RT, typename ClassT,
sl@0	3851	typename A, typename B, typename C, typename D,
sl@0	3852	typename E, typename F, typename G, typename H, typename I,
sl@0	3853	typename J, typename K, typename L, typename M
sl@0	3854	>
sl@0	3855	inline bound_member<RT, ClassT const, A, B, C, D, E, F, G, H, I, J, K, L, M>
sl@0	3856	bind(ClassT const& obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K, L, M) const)
sl@0	3857	{
sl@0	3858	return bound_member<
sl@0	3859	RT, ClassT const, A, B, C, D, E, F, G, H, I, J, K, L, M>(obj,fptr);
sl@0	3860	}
sl@0	3861
sl@0	3862	template <typename RT, typename ClassT,
sl@0	3863	typename A, typename B, typename C, typename D,
sl@0	3864	typename E, typename F, typename G, typename H, typename I,
sl@0	3865	typename J, typename K, typename L, typename M
sl@0	3866	>
sl@0	3867	inline bound_member<RT, ClassT const, A, B, C, D, E, F, G, H, I, J, K, L, M>
sl@0	3868	bind(ClassT const* obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K, L, M) const)
sl@0	3869	{
sl@0	3870	return bound_member<
sl@0	3871	RT, ClassT const, A, B, C, D, E, F, G, H, I, J, K, L, M>(obj,fptr);
sl@0	3872	}
sl@0	3873
sl@0	3874	///////////////////////////////////////////////////////////////////////////////
sl@0	3875	//
sl@0	3876	// Bound member function binder (specialization for 14 args)
sl@0	3877	//
sl@0	3878	///////////////////////////////////////////////////////////////////////////////
sl@0	3879	template <typename RT, typename ClassT,
sl@0	3880	typename A, typename B, typename C, typename D,
sl@0	3881	typename E, typename F, typename G, typename H, typename I,
sl@0	3882	typename J, typename K, typename L, typename M, typename N
sl@0	3883	>
sl@0	3884	struct bound_member_action<RT, ClassT,
sl@0	3885	A, B, C, D, E, F, G, H, I, J, K, L, M, N, nil_t, nil_t> {
sl@0	3886
sl@0	3887	typedef RT result_type;
sl@0	3888	typedef RT(ClassT::*mf)(A, B, C, D, E, F, G, H, I, J, K, L, M, N);
sl@0	3889	typedef RT(ClassT::*cmf)(A, B, C, D, E, F, G, H, I, J, K, L, M, N) const;
sl@0	3890	typedef typename boost::mpl::if_<boost::is_const<ClassT>, cmf, mf>::type
sl@0	3891	mem_func_ptr_t;
sl@0	3892
sl@0	3893	template <
sl@0	3894	typename A_, typename B_, typename C_, typename D_,
sl@0	3895	typename E_, typename F_, typename G_, typename H_, typename I_,
sl@0	3896	typename J_, typename K_, typename L_, typename M_, typename N_
sl@0	3897	>
sl@0	3898	struct result { typedef result_type type; };
sl@0	3899
sl@0	3900	template <typename CT>
sl@0	3901	bound_member_action(CT & obj_, mem_func_ptr_t fptr_)
sl@0	3902	: obj(impl::as_ptr<CT>::get(obj_)), fptr(fptr_) {}
sl@0	3903
sl@0	3904	result_type operator()(
sl@0	3905	A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k, L l, M m, N n
sl@0	3906	) const
sl@0	3907	{
sl@0	3908	return (obj->*fptr)(a, b, c, d, e, f, g, h, i, j, k, l, m, n);
sl@0	3909	}
sl@0	3910
sl@0	3911	typename impl::as_ptr<ClassT>::pointer_type obj;
sl@0	3912	mem_func_ptr_t fptr;
sl@0	3913	};
sl@0	3914
sl@0	3915	//////////////////////////////////
sl@0	3916	template <typename RT, typename ClassT,
sl@0	3917	typename A, typename B, typename C, typename D,
sl@0	3918	typename E, typename F, typename G, typename H, typename I,
sl@0	3919	typename J, typename K, typename L, typename M, typename N
sl@0	3920	>
sl@0	3921	inline bound_member<RT, ClassT, A, B, C, D, E, F, G, H, I, J, K, L, M, N>
sl@0	3922	bind(ClassT & obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K, L, M, N))
sl@0	3923	{
sl@0	3924	return bound_member<
sl@0	3925	RT, ClassT, A, B, C, D, E, F, G, H, I, J, K, L, M, N>(obj,fptr);
sl@0	3926	}
sl@0	3927
sl@0	3928	template <typename RT, typename ClassT,
sl@0	3929	typename A, typename B, typename C, typename D,
sl@0	3930	typename E, typename F, typename G, typename H, typename I,
sl@0	3931	typename J, typename K, typename L, typename M, typename N
sl@0	3932	>
sl@0	3933	inline bound_member<RT, ClassT, A, B, C, D, E, F, G, H, I, J, K, L, M, N>
sl@0	3934	bind(ClassT * obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K, L, M, N))
sl@0	3935	{
sl@0	3936	return bound_member<
sl@0	3937	RT, ClassT, A, B, C, D, E, F, G, H, I, J, K, L, M, N>(obj,fptr);
sl@0	3938	}
sl@0	3939
sl@0	3940	template <typename RT, typename ClassT,
sl@0	3941	typename A, typename B, typename C, typename D,
sl@0	3942	typename E, typename F, typename G, typename H, typename I,
sl@0	3943	typename J, typename K, typename L, typename M, typename N
sl@0	3944	>
sl@0	3945	inline bound_member<RT, ClassT const, A, B, C, D, E, F, G, H, I, J, K, L, M, N>
sl@0	3946	bind(ClassT const& obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K, L, M, N) const)
sl@0	3947	{
sl@0	3948	return bound_member<
sl@0	3949	RT, ClassT const, A, B, C, D, E, F, G, H, I, J, K, L, M, N>(obj,fptr);
sl@0	3950	}
sl@0	3951
sl@0	3952	template <typename RT, typename ClassT,
sl@0	3953	typename A, typename B, typename C, typename D,
sl@0	3954	typename E, typename F, typename G, typename H, typename I,
sl@0	3955	typename J, typename K, typename L, typename M, typename N
sl@0	3956	>
sl@0	3957	inline bound_member<RT, ClassT const, A, B, C, D, E, F, G, H, I, J, K, L, M, N>
sl@0	3958	bind(ClassT const* obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K, L, M, N) const)
sl@0	3959	{
sl@0	3960	return bound_member<
sl@0	3961	RT, ClassT const, A, B, C, D, E, F, G, H, I, J, K, L, M, N>(obj,fptr);
sl@0	3962	}
sl@0	3963
sl@0	3964	///////////////////////////////////////////////////////////////////////////////
sl@0	3965	//
sl@0	3966	// Bound member function binder (specialization for 15 args)
sl@0	3967	//
sl@0	3968	///////////////////////////////////////////////////////////////////////////////
sl@0	3969	template <typename RT, typename ClassT,
sl@0	3970	typename A, typename B, typename C, typename D,
sl@0	3971	typename E, typename F, typename G, typename H, typename I,
sl@0	3972	typename J, typename K, typename L, typename M, typename N,
sl@0	3973	typename O
sl@0	3974	>
sl@0	3975	struct bound_member_action<RT, ClassT,
sl@0	3976	A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, nil_t> {
sl@0	3977
sl@0	3978	typedef RT result_type;
sl@0	3979	typedef RT(ClassT::*mf)(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O);
sl@0	3980	typedef RT(ClassT::*cmf)(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) const;
sl@0	3981	typedef typename boost::mpl::if_<boost::is_const<ClassT>, cmf, mf>::type
sl@0	3982	mem_func_ptr_t;
sl@0	3983
sl@0	3984	template <
sl@0	3985	typename A_, typename B_, typename C_, typename D_,
sl@0	3986	typename E_, typename F_, typename G_, typename H_, typename I_,
sl@0	3987	typename J_, typename K_, typename L_, typename M_, typename N_,
sl@0	3988	typename O_
sl@0	3989	>
sl@0	3990	struct result { typedef result_type type; };
sl@0	3991
sl@0	3992	template <typename CT>
sl@0	3993	bound_member_action(CT & obj_, mem_func_ptr_t fptr_)
sl@0	3994	: obj(impl::as_ptr<CT>::get(obj_)), fptr(fptr_) {}
sl@0	3995
sl@0	3996	result_type operator()(
sl@0	3997	A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k, L l, M m, N n, O o
sl@0	3998	) const
sl@0	3999	{
sl@0	4000	return (obj->*fptr)(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o);
sl@0	4001	}
sl@0	4002
sl@0	4003	typename impl::as_ptr<ClassT>::pointer_type obj;
sl@0	4004	mem_func_ptr_t fptr;
sl@0	4005	};
sl@0	4006
sl@0	4007	//////////////////////////////////
sl@0	4008	template <typename RT, typename ClassT,
sl@0	4009	typename A, typename B, typename C, typename D,
sl@0	4010	typename E, typename F, typename G, typename H, typename I,
sl@0	4011	typename J, typename K, typename L, typename M, typename N,
sl@0	4012	typename O
sl@0	4013	>
sl@0	4014	inline bound_member<RT, ClassT, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>
sl@0	4015	bind(ClassT & obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O))
sl@0	4016	{
sl@0	4017	return bound_member<
sl@0	4018	RT, ClassT, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(obj,fptr);
sl@0	4019	}
sl@0	4020
sl@0	4021	template <typename RT, typename ClassT,
sl@0	4022	typename A, typename B, typename C, typename D,
sl@0	4023	typename E, typename F, typename G, typename H, typename I,
sl@0	4024	typename J, typename K, typename L, typename M, typename N,
sl@0	4025	typename O
sl@0	4026	>
sl@0	4027	inline bound_member<RT, ClassT, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>
sl@0	4028	bind(ClassT * obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O))
sl@0	4029	{
sl@0	4030	return bound_member<
sl@0	4031	RT, ClassT, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(obj,fptr);
sl@0	4032	}
sl@0	4033
sl@0	4034	template <typename RT, typename ClassT,
sl@0	4035	typename A, typename B, typename C, typename D,
sl@0	4036	typename E, typename F, typename G, typename H, typename I,
sl@0	4037	typename J, typename K, typename L, typename M, typename N,
sl@0	4038	typename O
sl@0	4039	>
sl@0	4040	inline bound_member<RT, ClassT const, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>
sl@0	4041	bind(ClassT const& obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) const)
sl@0	4042	{
sl@0	4043	return bound_member<
sl@0	4044	RT, ClassT const, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(obj,fptr);
sl@0	4045	}
sl@0	4046
sl@0	4047	template <typename RT, typename ClassT,
sl@0	4048	typename A, typename B, typename C, typename D,
sl@0	4049	typename E, typename F, typename G, typename H, typename I,
sl@0	4050	typename J, typename K, typename L, typename M, typename N,
sl@0	4051	typename O
sl@0	4052	>
sl@0	4053	inline bound_member<RT, ClassT const, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>
sl@0	4054	bind(ClassT const* obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) const)
sl@0	4055	{
sl@0	4056	return bound_member<
sl@0	4057	RT, ClassT const, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(obj,fptr);
sl@0	4058	}
sl@0	4059
sl@0	4060	#endif
sl@0	4061	#endif
sl@0	4062	#endif
sl@0	4063	#endif
sl@0	4064
sl@0	4065	} // namespace phoenix
sl@0	4066
sl@0	4067	#endif

author	sl
	Tue, 10 Jun 2014 14:32:02 +0200
changeset 1	260cb5ec6c19
permissions	-rw-r--r--