binders.hpp source code [boost/libs/spirit/include/boost/spirit/home/classic/phoenix/binders.hpp]

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

source code of boost/libs/spirit/include/boost/spirit/home/classic/phoenix/binders.hpp