vamp-build-and-test: DEPENDENCIES/generic/include/boost/spirit/home/classic/phoenix/binders.hpp annotate

annotate DEPENDENCIES/generic/include/boost/spirit/home/classic/phoenix/binders.hpp @ 118:770eb830ec19 emscripten

Typo fix

author	Chris Cannam
date	Wed, 18 May 2016 16:14:08 +0100
parents	2665513ce2d3
children

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

Mercurial > hg > vamp-build-and-test

annotate DEPENDENCIES/generic/include/boost/spirit/home/classic/phoenix/binders.hpp @ 118:770eb830ec19 emscripten