source: NonGTP/Boost/boost/spirit/phoenix/binders.hpp @ 857

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