00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00018
00019 #ifndef _CALLBACK_SPECIALIZATIONS_H
00020 #define _CALLBACK_SPECIALIZATIONS_H
00021
00022 struct CallbackUtils_ {
00023 static void FailIsRepeatable(const char* name);
00024 };
00025
00026
00027 class Closure {
00028 public:
00029 virtual ~Closure() { }
00030 virtual void Run() = 0;
00031 };
00032
00033 template <class R>
00034 class ResultCallback {
00035 public:
00036 virtual ~ResultCallback() { }
00037 virtual R Run() = 0;
00038 };
00039
00040 template <bool del, class R, class T>
00041 class _ConstMemberResultCallback_0_0 : public ResultCallback<R> {
00042 public:
00043 typedef ResultCallback<R> base;
00044 typedef R (T::*MemberSignature)() const;
00045
00046 private:
00047 const T* object_;
00048 MemberSignature member_;
00049
00050 public:
00051 inline _ConstMemberResultCallback_0_0(
00052 const T* object, MemberSignature member)
00053 : object_(object),
00054 member_(member) {
00055 }
00056
00057 virtual R Run() {
00058 if (!del) {
00059 R result = (object_->*member_)();
00060 return result;
00061 } else {
00062 R result = (object_->*member_)();
00063
00064 member_ = NULL;
00065 delete this;
00066 return result;
00067 }
00068 }
00069 };
00070
00071 template <bool del, class T>
00072 class _ConstMemberResultCallback_0_0<del, void, T>
00073 : public Closure {
00074 public:
00075 typedef Closure base;
00076 typedef void (T::*MemberSignature)() const;
00077
00078 private:
00079 const T* object_;
00080 MemberSignature member_;
00081
00082 public:
00083 inline _ConstMemberResultCallback_0_0(
00084 const T* object, MemberSignature member)
00085 : object_(object),
00086 member_(member) {
00087 }
00088
00089 virtual void Run() {
00090 if (!del) {
00091 (object_->*member_)();
00092 } else {
00093 (object_->*member_)();
00094
00095 member_ = NULL;
00096 delete this;
00097 }
00098 }
00099 };
00100
00101 #ifndef SWIG
00102 template <class T1, class T2, class R>
00103 inline typename _ConstMemberResultCallback_0_0<true,R,T1>::base*
00104 NewCallback(
00105 const T1* obj, R (T2::*member)() const) {
00106 return new _ConstMemberResultCallback_0_0<true,R,T1>(
00107 obj, member);
00108 }
00109 #endif
00110
00111 #ifndef SWIG
00112 template <class T1, class T2, class R>
00113 inline typename _ConstMemberResultCallback_0_0<false,R,T1>::base*
00114 NewPermanentCallback(
00115 const T1* obj, R (T2::*member)() const) {
00116 return new _ConstMemberResultCallback_0_0<false,R,T1>(
00117 obj, member);
00118 }
00119 #endif
00120
00121 template <bool del, class R, class T>
00122 class _MemberResultCallback_0_0 : public ResultCallback<R> {
00123 public:
00124 typedef ResultCallback<R> base;
00125 typedef R (T::*MemberSignature)() ;
00126
00127 private:
00128 T* object_;
00129 MemberSignature member_;
00130
00131 public:
00132 inline _MemberResultCallback_0_0(
00133 T* object, MemberSignature member)
00134 : object_(object),
00135 member_(member) {
00136 }
00137
00138 virtual R Run() {
00139 if (!del) {
00140 R result = (object_->*member_)();
00141 return result;
00142 } else {
00143 R result = (object_->*member_)();
00144
00145 member_ = NULL;
00146 delete this;
00147 return result;
00148 }
00149 }
00150 };
00151
00152 template <bool del, class T>
00153 class _MemberResultCallback_0_0<del, void, T>
00154 : public Closure {
00155 public:
00156 typedef Closure base;
00157 typedef void (T::*MemberSignature)() ;
00158
00159 private:
00160 T* object_;
00161 MemberSignature member_;
00162
00163 public:
00164 inline _MemberResultCallback_0_0(
00165 T* object, MemberSignature member)
00166 : object_(object),
00167 member_(member) {
00168 }
00169
00170 virtual void Run() {
00171 if (!del) {
00172 (object_->*member_)();
00173 } else {
00174 (object_->*member_)();
00175
00176 member_ = NULL;
00177 delete this;
00178 }
00179 }
00180 };
00181
00182 #ifndef SWIG
00183 template <class T1, class T2, class R>
00184 inline typename _MemberResultCallback_0_0<true,R,T1>::base*
00185 NewCallback(
00186 T1* obj, R (T2::*member)() ) {
00187 return new _MemberResultCallback_0_0<true,R,T1>(
00188 obj, member);
00189 }
00190 #endif
00191
00192 #ifndef SWIG
00193 template <class T1, class T2, class R>
00194 inline typename _MemberResultCallback_0_0<false,R,T1>::base*
00195 NewPermanentCallback(
00196 T1* obj, R (T2::*member)() ) {
00197 return new _MemberResultCallback_0_0<false,R,T1>(
00198 obj, member);
00199 }
00200 #endif
00201
00202 template <bool del, class R>
00203 class _FunctionResultCallback_0_0 : public ResultCallback<R> {
00204 public:
00205 typedef ResultCallback<R> base;
00206 typedef R (*FunctionSignature)();
00207
00208 private:
00209 FunctionSignature function_;
00210
00211 public:
00212 inline _FunctionResultCallback_0_0(
00213 FunctionSignature function)
00214 : function_(function) {
00215 }
00216
00217 virtual R Run() {
00218 if (!del) {
00219 R result = (*function_)();
00220 return result;
00221 } else {
00222 R result = (*function_)();
00223
00224 function_ = NULL;
00225 delete this;
00226 return result;
00227 }
00228 }
00229 };
00230
00231 template <bool del>
00232 class _FunctionResultCallback_0_0<del, void>
00233 : public Closure {
00234 public:
00235 typedef Closure base;
00236 typedef void (*FunctionSignature)();
00237
00238 private:
00239 FunctionSignature function_;
00240
00241 public:
00242 inline _FunctionResultCallback_0_0(
00243 FunctionSignature function)
00244 : function_(function) {
00245 }
00246
00247 virtual void Run() {
00248 if (!del) {
00249 (*function_)();
00250 } else {
00251 (*function_)();
00252
00253 function_ = NULL;
00254 delete this;
00255 }
00256 }
00257 };
00258
00259 template <class R>
00260 inline typename _FunctionResultCallback_0_0<true,R>::base*
00261 NewCallback(R (*function)()) {
00262 return new _FunctionResultCallback_0_0<true,R>(function);
00263 }
00264
00265 template <class R>
00266 inline typename _FunctionResultCallback_0_0<false,R>::base*
00267 NewPermanentCallback(R (*function)()) {
00268 return new _FunctionResultCallback_0_0<false,R>(function);
00269 }
00270
00271 template <class A1>
00272 class Callback1 {
00273 public:
00274 virtual ~Callback1() { }
00275 virtual void Run(A1) = 0;
00276 };
00277
00278 template <class R, class A1>
00279 class ResultCallback1 {
00280 public:
00281 virtual ~ResultCallback1() { }
00282 virtual R Run(A1) = 0;
00283 };
00284
00285 template <bool del, class R, class T, class A1>
00286 class _ConstMemberResultCallback_0_1 : public ResultCallback1<R,A1> {
00287 public:
00288 typedef ResultCallback1<R,A1> base;
00289 typedef R (T::*MemberSignature)(A1) const;
00290
00291 private:
00292 const T* object_;
00293 MemberSignature member_;
00294
00295 public:
00296 inline _ConstMemberResultCallback_0_1(
00297 const T* object, MemberSignature member)
00298 : object_(object),
00299 member_(member) {
00300 }
00301
00302 virtual R Run(A1 a1) {
00303 if (!del) {
00304 R result = (object_->*member_)(a1);
00305 return result;
00306 } else {
00307 R result = (object_->*member_)(a1);
00308
00309 member_ = NULL;
00310 delete this;
00311 return result;
00312 }
00313 }
00314 };
00315
00316 template <bool del, class T, class A1>
00317 class _ConstMemberResultCallback_0_1<del, void, T, A1>
00318 : public Callback1<A1> {
00319 public:
00320 typedef Callback1<A1> base;
00321 typedef void (T::*MemberSignature)(A1) const;
00322
00323 private:
00324 const T* object_;
00325 MemberSignature member_;
00326
00327 public:
00328 inline _ConstMemberResultCallback_0_1(
00329 const T* object, MemberSignature member)
00330 : object_(object),
00331 member_(member) {
00332 }
00333
00334 virtual void Run(A1 a1) {
00335 if (!del) {
00336 (object_->*member_)(a1);
00337 } else {
00338 (object_->*member_)(a1);
00339
00340 member_ = NULL;
00341 delete this;
00342 }
00343 }
00344 };
00345
00346 #ifndef SWIG
00347 template <class T1, class T2, class R, class A1>
00348 inline typename _ConstMemberResultCallback_0_1<true,R,T1,A1>::base*
00349 NewCallback(
00350 const T1* obj, R (T2::*member)(A1) const) {
00351 return new _ConstMemberResultCallback_0_1<true,R,T1,A1>(
00352 obj, member);
00353 }
00354 #endif
00355
00356 #ifndef SWIG
00357 template <class T1, class T2, class R, class A1>
00358 inline typename _ConstMemberResultCallback_0_1<false,R,T1,A1>::base*
00359 NewPermanentCallback(
00360 const T1* obj, R (T2::*member)(A1) const) {
00361 return new _ConstMemberResultCallback_0_1<false,R,T1,A1>(
00362 obj, member);
00363 }
00364 #endif
00365
00366 template <bool del, class R, class T, class A1>
00367 class _MemberResultCallback_0_1 : public ResultCallback1<R,A1> {
00368 public:
00369 typedef ResultCallback1<R,A1> base;
00370 typedef R (T::*MemberSignature)(A1) ;
00371
00372 private:
00373 T* object_;
00374 MemberSignature member_;
00375
00376 public:
00377 inline _MemberResultCallback_0_1(
00378 T* object, MemberSignature member)
00379 : object_(object),
00380 member_(member) {
00381 }
00382
00383 virtual R Run(A1 a1) {
00384 if (!del) {
00385 R result = (object_->*member_)(a1);
00386 return result;
00387 } else {
00388 R result = (object_->*member_)(a1);
00389
00390 member_ = NULL;
00391 delete this;
00392 return result;
00393 }
00394 }
00395 };
00396
00397 template <bool del, class T, class A1>
00398 class _MemberResultCallback_0_1<del, void, T, A1>
00399 : public Callback1<A1> {
00400 public:
00401 typedef Callback1<A1> base;
00402 typedef void (T::*MemberSignature)(A1) ;
00403
00404 private:
00405 T* object_;
00406 MemberSignature member_;
00407
00408 public:
00409 inline _MemberResultCallback_0_1(
00410 T* object, MemberSignature member)
00411 : object_(object),
00412 member_(member) {
00413 }
00414
00415 virtual void Run(A1 a1) {
00416 if (!del) {
00417 (object_->*member_)(a1);
00418 } else {
00419 (object_->*member_)(a1);
00420
00421 member_ = NULL;
00422 delete this;
00423 }
00424 }
00425 };
00426
00427 #ifndef SWIG
00428 template <class T1, class T2, class R, class A1>
00429 inline typename _MemberResultCallback_0_1<true,R,T1,A1>::base*
00430 NewCallback(
00431 T1* obj, R (T2::*member)(A1) ) {
00432 return new _MemberResultCallback_0_1<true,R,T1,A1>(
00433 obj, member);
00434 }
00435 #endif
00436
00437 #ifndef SWIG
00438 template <class T1, class T2, class R, class A1>
00439 inline typename _MemberResultCallback_0_1<false,R,T1,A1>::base*
00440 NewPermanentCallback(
00441 T1* obj, R (T2::*member)(A1) ) {
00442 return new _MemberResultCallback_0_1<false,R,T1,A1>(
00443 obj, member);
00444 }
00445 #endif
00446
00447 template <bool del, class R, class A1>
00448 class _FunctionResultCallback_0_1 : public ResultCallback1<R,A1> {
00449 public:
00450 typedef ResultCallback1<R,A1> base;
00451 typedef R (*FunctionSignature)(A1);
00452
00453 private:
00454 FunctionSignature function_;
00455
00456 public:
00457 inline _FunctionResultCallback_0_1(
00458 FunctionSignature function)
00459 : function_(function) {
00460 }
00461
00462 virtual R Run(A1 a1) {
00463 if (!del) {
00464 R result = (*function_)(a1);
00465 return result;
00466 } else {
00467 R result = (*function_)(a1);
00468
00469 function_ = NULL;
00470 delete this;
00471 return result;
00472 }
00473 }
00474 };
00475
00476 template <bool del, class A1>
00477 class _FunctionResultCallback_0_1<del, void, A1>
00478 : public Callback1<A1> {
00479 public:
00480 typedef Callback1<A1> base;
00481 typedef void (*FunctionSignature)(A1);
00482
00483 private:
00484 FunctionSignature function_;
00485
00486 public:
00487 inline _FunctionResultCallback_0_1(
00488 FunctionSignature function)
00489 : function_(function) {
00490 }
00491
00492 virtual void Run(A1 a1) {
00493 if (!del) {
00494 (*function_)(a1);
00495 } else {
00496 (*function_)(a1);
00497
00498 function_ = NULL;
00499 delete this;
00500 }
00501 }
00502 };
00503
00504 template <class R, class A1>
00505 inline typename _FunctionResultCallback_0_1<true,R,A1>::base*
00506 NewCallback(R (*function)(A1)) {
00507 return new _FunctionResultCallback_0_1<true,R,A1>(function);
00508 }
00509
00510 template <class R, class A1>
00511 inline typename _FunctionResultCallback_0_1<false,R,A1>::base*
00512 NewPermanentCallback(R (*function)(A1)) {
00513 return new _FunctionResultCallback_0_1<false,R,A1>(function);
00514 }
00515
00516 template <class A1,class A2>
00517 class Callback2 {
00518 public:
00519 virtual ~Callback2() { }
00520 virtual void Run(A1,A2) = 0;
00521 };
00522
00523 template <class R, class A1,class A2>
00524 class ResultCallback2 {
00525 public:
00526 virtual ~ResultCallback2() { }
00527 virtual R Run(A1,A2) = 0;
00528 };
00529
00530 template <bool del, class R, class T, class A1, class A2>
00531 class _ConstMemberResultCallback_0_2 : public ResultCallback2<R,A1,A2> {
00532 public:
00533 typedef ResultCallback2<R,A1,A2> base;
00534 typedef R (T::*MemberSignature)(A1,A2) const;
00535
00536 private:
00537 const T* object_;
00538 MemberSignature member_;
00539
00540 public:
00541 inline _ConstMemberResultCallback_0_2(
00542 const T* object, MemberSignature member)
00543 : object_(object),
00544 member_(member) {
00545 }
00546
00547 virtual R Run(A1 a1,A2 a2) {
00548 if (!del) {
00549 R result = (object_->*member_)(a1,a2);
00550 return result;
00551 } else {
00552 R result = (object_->*member_)(a1,a2);
00553
00554 member_ = NULL;
00555 delete this;
00556 return result;
00557 }
00558 }
00559 };
00560
00561 template <bool del, class T, class A1, class A2>
00562 class _ConstMemberResultCallback_0_2<del, void, T, A1, A2>
00563 : public Callback2<A1,A2> {
00564 public:
00565 typedef Callback2<A1,A2> base;
00566 typedef void (T::*MemberSignature)(A1,A2) const;
00567
00568 private:
00569 const T* object_;
00570 MemberSignature member_;
00571
00572 public:
00573 inline _ConstMemberResultCallback_0_2(
00574 const T* object, MemberSignature member)
00575 : object_(object),
00576 member_(member) {
00577 }
00578
00579 virtual void Run(A1 a1,A2 a2) {
00580 if (!del) {
00581 (object_->*member_)(a1,a2);
00582 } else {
00583 (object_->*member_)(a1,a2);
00584
00585 member_ = NULL;
00586 delete this;
00587 }
00588 }
00589 };
00590
00591 #ifndef SWIG
00592 template <class T1, class T2, class R, class A1, class A2>
00593 inline typename _ConstMemberResultCallback_0_2<true,R,T1,A1,A2>::base*
00594 NewCallback(
00595 const T1* obj, R (T2::*member)(A1,A2) const) {
00596 return new _ConstMemberResultCallback_0_2<true,R,T1,A1,A2>(
00597 obj, member);
00598 }
00599 #endif
00600
00601 #ifndef SWIG
00602 template <class T1, class T2, class R, class A1, class A2>
00603 inline typename _ConstMemberResultCallback_0_2<false,R,T1,A1,A2>::base*
00604 NewPermanentCallback(
00605 const T1* obj, R (T2::*member)(A1,A2) const) {
00606 return new _ConstMemberResultCallback_0_2<false,R,T1,A1,A2>(
00607 obj, member);
00608 }
00609 #endif
00610
00611 template <bool del, class R, class T, class A1, class A2>
00612 class _MemberResultCallback_0_2 : public ResultCallback2<R,A1,A2> {
00613 public:
00614 typedef ResultCallback2<R,A1,A2> base;
00615 typedef R (T::*MemberSignature)(A1,A2) ;
00616
00617 private:
00618 T* object_;
00619 MemberSignature member_;
00620
00621 public:
00622 inline _MemberResultCallback_0_2(
00623 T* object, MemberSignature member)
00624 : object_(object),
00625 member_(member) {
00626 }
00627
00628 virtual R Run(A1 a1,A2 a2) {
00629 if (!del) {
00630 R result = (object_->*member_)(a1,a2);
00631 return result;
00632 } else {
00633 R result = (object_->*member_)(a1,a2);
00634
00635 member_ = NULL;
00636 delete this;
00637 return result;
00638 }
00639 }
00640 };
00641
00642 template <bool del, class T, class A1, class A2>
00643 class _MemberResultCallback_0_2<del, void, T, A1, A2>
00644 : public Callback2<A1,A2> {
00645 public:
00646 typedef Callback2<A1,A2> base;
00647 typedef void (T::*MemberSignature)(A1,A2) ;
00648
00649 private:
00650 T* object_;
00651 MemberSignature member_;
00652
00653 public:
00654 inline _MemberResultCallback_0_2(
00655 T* object, MemberSignature member)
00656 : object_(object),
00657 member_(member) {
00658 }
00659
00660 virtual void Run(A1 a1,A2 a2) {
00661 if (!del) {
00662 (object_->*member_)(a1,a2);
00663 } else {
00664 (object_->*member_)(a1,a2);
00665
00666 member_ = NULL;
00667 delete this;
00668 }
00669 }
00670 };
00671
00672 #ifndef SWIG
00673 template <class T1, class T2, class R, class A1, class A2>
00674 inline typename _MemberResultCallback_0_2<true,R,T1,A1,A2>::base*
00675 NewCallback(
00676 T1* obj, R (T2::*member)(A1,A2) ) {
00677 return new _MemberResultCallback_0_2<true,R,T1,A1,A2>(
00678 obj, member);
00679 }
00680 #endif
00681
00682 #ifndef SWIG
00683 template <class T1, class T2, class R, class A1, class A2>
00684 inline typename _MemberResultCallback_0_2<false,R,T1,A1,A2>::base*
00685 NewPermanentCallback(
00686 T1* obj, R (T2::*member)(A1,A2) ) {
00687 return new _MemberResultCallback_0_2<false,R,T1,A1,A2>(
00688 obj, member);
00689 }
00690 #endif
00691
00692 template <bool del, class R, class A1, class A2>
00693 class _FunctionResultCallback_0_2 : public ResultCallback2<R,A1,A2> {
00694 public:
00695 typedef ResultCallback2<R,A1,A2> base;
00696 typedef R (*FunctionSignature)(A1,A2);
00697
00698 private:
00699 FunctionSignature function_;
00700
00701 public:
00702 inline _FunctionResultCallback_0_2(
00703 FunctionSignature function)
00704 : function_(function) {
00705 }
00706
00707 virtual R Run(A1 a1,A2 a2) {
00708 if (!del) {
00709 R result = (*function_)(a1,a2);
00710 return result;
00711 } else {
00712 R result = (*function_)(a1,a2);
00713
00714 function_ = NULL;
00715 delete this;
00716 return result;
00717 }
00718 }
00719 };
00720
00721 template <bool del, class A1, class A2>
00722 class _FunctionResultCallback_0_2<del, void, A1, A2>
00723 : public Callback2<A1,A2> {
00724 public:
00725 typedef Callback2<A1,A2> base;
00726 typedef void (*FunctionSignature)(A1,A2);
00727
00728 private:
00729 FunctionSignature function_;
00730
00731 public:
00732 inline _FunctionResultCallback_0_2(
00733 FunctionSignature function)
00734 : function_(function) {
00735 }
00736
00737 virtual void Run(A1 a1,A2 a2) {
00738 if (!del) {
00739 (*function_)(a1,a2);
00740 } else {
00741 (*function_)(a1,a2);
00742
00743 function_ = NULL;
00744 delete this;
00745 }
00746 }
00747 };
00748
00749 template <class R, class A1, class A2>
00750 inline typename _FunctionResultCallback_0_2<true,R,A1,A2>::base*
00751 NewCallback(R (*function)(A1,A2)) {
00752 return new _FunctionResultCallback_0_2<true,R,A1,A2>(function);
00753 }
00754
00755 template <class R, class A1, class A2>
00756 inline typename _FunctionResultCallback_0_2<false,R,A1,A2>::base*
00757 NewPermanentCallback(R (*function)(A1,A2)) {
00758 return new _FunctionResultCallback_0_2<false,R,A1,A2>(function);
00759 }
00760
00761 template <class A1,class A2,class A3>
00762 class Callback3 {
00763 public:
00764 virtual ~Callback3() { }
00765 virtual void Run(A1,A2,A3) = 0;
00766 };
00767
00768 template <class R, class A1,class A2,class A3>
00769 class ResultCallback3 {
00770 public:
00771 virtual ~ResultCallback3() { }
00772 virtual R Run(A1,A2,A3) = 0;
00773 };
00774
00775 template <bool del, class R, class T, class A1, class A2, class A3>
00776 class _ConstMemberResultCallback_0_3 : public ResultCallback3<R,A1,A2,A3> {
00777 public:
00778 typedef ResultCallback3<R,A1,A2,A3> base;
00779 typedef R (T::*MemberSignature)(A1,A2,A3) const;
00780
00781 private:
00782 const T* object_;
00783 MemberSignature member_;
00784
00785 public:
00786 inline _ConstMemberResultCallback_0_3(
00787 const T* object, MemberSignature member)
00788 : object_(object),
00789 member_(member) {
00790 }
00791
00792 virtual R Run(A1 a1,A2 a2,A3 a3) {
00793 if (!del) {
00794 R result = (object_->*member_)(a1,a2,a3);
00795 return result;
00796 } else {
00797 R result = (object_->*member_)(a1,a2,a3);
00798
00799 member_ = NULL;
00800 delete this;
00801 return result;
00802 }
00803 }
00804 };
00805
00806 template <bool del, class T, class A1, class A2, class A3>
00807 class _ConstMemberResultCallback_0_3<del, void, T, A1, A2, A3>
00808 : public Callback3<A1,A2,A3> {
00809 public:
00810 typedef Callback3<A1,A2,A3> base;
00811 typedef void (T::*MemberSignature)(A1,A2,A3) const;
00812
00813 private:
00814 const T* object_;
00815 MemberSignature member_;
00816
00817 public:
00818 inline _ConstMemberResultCallback_0_3(
00819 const T* object, MemberSignature member)
00820 : object_(object),
00821 member_(member) {
00822 }
00823
00824 virtual void Run(A1 a1,A2 a2,A3 a3) {
00825 if (!del) {
00826 (object_->*member_)(a1,a2,a3);
00827 } else {
00828 (object_->*member_)(a1,a2,a3);
00829
00830 member_ = NULL;
00831 delete this;
00832 }
00833 }
00834 };
00835
00836 #ifndef SWIG
00837 template <class T1, class T2, class R, class A1, class A2, class A3>
00838 inline typename _ConstMemberResultCallback_0_3<true,R,T1,A1,A2,A3>::base*
00839 NewCallback(
00840 const T1* obj, R (T2::*member)(A1,A2,A3) const) {
00841 return new _ConstMemberResultCallback_0_3<true,R,T1,A1,A2,A3>(
00842 obj, member);
00843 }
00844 #endif
00845
00846 #ifndef SWIG
00847 template <class T1, class T2, class R, class A1, class A2, class A3>
00848 inline typename _ConstMemberResultCallback_0_3<false,R,T1,A1,A2,A3>::base*
00849 NewPermanentCallback(
00850 const T1* obj, R (T2::*member)(A1,A2,A3) const) {
00851 return new _ConstMemberResultCallback_0_3<false,R,T1,A1,A2,A3>(
00852 obj, member);
00853 }
00854 #endif
00855
00856 template <bool del, class R, class T, class A1, class A2, class A3>
00857 class _MemberResultCallback_0_3 : public ResultCallback3<R,A1,A2,A3> {
00858 public:
00859 typedef ResultCallback3<R,A1,A2,A3> base;
00860 typedef R (T::*MemberSignature)(A1,A2,A3) ;
00861
00862 private:
00863 T* object_;
00864 MemberSignature member_;
00865
00866 public:
00867 inline _MemberResultCallback_0_3(
00868 T* object, MemberSignature member)
00869 : object_(object),
00870 member_(member) {
00871 }
00872
00873 virtual R Run(A1 a1,A2 a2,A3 a3) {
00874 if (!del) {
00875 R result = (object_->*member_)(a1,a2,a3);
00876 return result;
00877 } else {
00878 R result = (object_->*member_)(a1,a2,a3);
00879
00880 member_ = NULL;
00881 delete this;
00882 return result;
00883 }
00884 }
00885 };
00886
00887 template <bool del, class T, class A1, class A2, class A3>
00888 class _MemberResultCallback_0_3<del, void, T, A1, A2, A3>
00889 : public Callback3<A1,A2,A3> {
00890 public:
00891 typedef Callback3<A1,A2,A3> base;
00892 typedef void (T::*MemberSignature)(A1,A2,A3) ;
00893
00894 private:
00895 T* object_;
00896 MemberSignature member_;
00897
00898 public:
00899 inline _MemberResultCallback_0_3(
00900 T* object, MemberSignature member)
00901 : object_(object),
00902 member_(member) {
00903 }
00904
00905 virtual void Run(A1 a1,A2 a2,A3 a3) {
00906 if (!del) {
00907 (object_->*member_)(a1,a2,a3);
00908 } else {
00909 (object_->*member_)(a1,a2,a3);
00910
00911 member_ = NULL;
00912 delete this;
00913 }
00914 }
00915 };
00916
00917 #ifndef SWIG
00918 template <class T1, class T2, class R, class A1, class A2, class A3>
00919 inline typename _MemberResultCallback_0_3<true,R,T1,A1,A2,A3>::base*
00920 NewCallback(
00921 T1* obj, R (T2::*member)(A1,A2,A3) ) {
00922 return new _MemberResultCallback_0_3<true,R,T1,A1,A2,A3>(
00923 obj, member);
00924 }
00925 #endif
00926
00927 #ifndef SWIG
00928 template <class T1, class T2, class R, class A1, class A2, class A3>
00929 inline typename _MemberResultCallback_0_3<false,R,T1,A1,A2,A3>::base*
00930 NewPermanentCallback(
00931 T1* obj, R (T2::*member)(A1,A2,A3) ) {
00932 return new _MemberResultCallback_0_3<false,R,T1,A1,A2,A3>(
00933 obj, member);
00934 }
00935 #endif
00936
00937 template <bool del, class R, class A1, class A2, class A3>
00938 class _FunctionResultCallback_0_3 : public ResultCallback3<R,A1,A2,A3> {
00939 public:
00940 typedef ResultCallback3<R,A1,A2,A3> base;
00941 typedef R (*FunctionSignature)(A1,A2,A3);
00942
00943 private:
00944 FunctionSignature function_;
00945
00946 public:
00947 inline _FunctionResultCallback_0_3(
00948 FunctionSignature function)
00949 : function_(function) {
00950 }
00951
00952 virtual R Run(A1 a1,A2 a2,A3 a3) {
00953 if (!del) {
00954 R result = (*function_)(a1,a2,a3);
00955 return result;
00956 } else {
00957 R result = (*function_)(a1,a2,a3);
00958
00959 function_ = NULL;
00960 delete this;
00961 return result;
00962 }
00963 }
00964 };
00965
00966 template <bool del, class A1, class A2, class A3>
00967 class _FunctionResultCallback_0_3<del, void, A1, A2, A3>
00968 : public Callback3<A1,A2,A3> {
00969 public:
00970 typedef Callback3<A1,A2,A3> base;
00971 typedef void (*FunctionSignature)(A1,A2,A3);
00972
00973 private:
00974 FunctionSignature function_;
00975
00976 public:
00977 inline _FunctionResultCallback_0_3(
00978 FunctionSignature function)
00979 : function_(function) {
00980 }
00981
00982 virtual void Run(A1 a1,A2 a2,A3 a3) {
00983 if (!del) {
00984 (*function_)(a1,a2,a3);
00985 } else {
00986 (*function_)(a1,a2,a3);
00987
00988 function_ = NULL;
00989 delete this;
00990 }
00991 }
00992 };
00993
00994 template <class R, class A1, class A2, class A3>
00995 inline typename _FunctionResultCallback_0_3<true,R,A1,A2,A3>::base*
00996 NewCallback(R (*function)(A1,A2,A3)) {
00997 return new _FunctionResultCallback_0_3<true,R,A1,A2,A3>(function);
00998 }
00999
01000 template <class R, class A1, class A2, class A3>
01001 inline typename _FunctionResultCallback_0_3<false,R,A1,A2,A3>::base*
01002 NewPermanentCallback(R (*function)(A1,A2,A3)) {
01003 return new _FunctionResultCallback_0_3<false,R,A1,A2,A3>(function);
01004 }
01005
01006 #endif