lib/function_callback.h

   1 #ifndef ___HGL___FUNCTION_CALLBACK___
   2 #define ___HGL___FUNCTION_CALLBACK___
   3
   4 #include "lib/uncopyable.h"
   5
   6 namespace utility {
   7
   8 /**
   9    function_callback
  10    関数コールバック基底クラス
  11    全てのコールバック関数クラスは、このクラスから派生する。
  12    smart_ptrの使用が前提である。
  13 */
  14 class FunctionCallback : private utility::UncopyableInterface {
  15  public:
  16
  17   virtual ~FunctionCallback() {}
  18
  19   //  これを必ずオーバーロードすること。
  20   virtual void Run() = 0;
  21 };
  22
  23 /*
  24   準備するコールバック関数クラスの種類は、
  25   返り値あり、返り値無し --- 2種
  26   メンバ関数、非メンバ関数 --- 2種
  27   引数0〜5個               --- 6種
  28   の24個定義する。
  29   それぞれ、FunctionCallback[返り値有無][Global/Member][引数の個数]
  30   というフォーマットのクラス名となっている。
  31 */
  32 template<class T> class FunctionCallbackVoidGlobal0;
  33 class FunctionCallbackVoid0;
  34 template<class T> class FunctionCallbackVoidGlobal1;
  35 template<class T1, class T2> class FunctionCallbackVoid2;
  36 template<class T1, class T2, class T3> class FunctionCallbackVoid3;
  37 template<class T1, class T2, class T3, class T4> class FunctionCallbackVoid4;
  38 template<class T1, class T2, class T3, class T4, class T5>
  39 class FunctionCallbackVoid5;
  40
  41 template<class Obj> class FunctionCallbackVoidMember0;
  42 template<class Obj, class T> class FunctionCallbackVoidMember1;
  43 template<class Obj, class T1, class T2> class FunctionCallbackVoidMember2;
  44 template<class Obj, class T1, class T2, class T3>
  45 class FunctionCallbackVoidMember3;
  46 template<class Obj, class T1, class T2, class T3, class T4>
  47 class FunctionCallbackVoidMember4;
  48 template<class Obj, class T1, class T2, class T3, class T4, class T5>
  49 class FunctionCallbackVoidMember5;
  50
  51 /**
  52    FunctionCallback_v
  53    返り値無しのコールバック関数クラス。
  54    staticなcreate関数によって、それぞれを作成する。
  55    また、これから作成されるクラスも、全てFunctionCallback派生クラスである。
  56 */
  57 class FunctionCallbackVoid : public FunctionCallback {
  58  public:
  59
  60   virtual ~FunctionCallbackVoid() {}
  61
  62   //----------------------------------------------------------------------
  63   // 各関数コールバッククラス生成関数群。
  64   // ここでの関数群は、全て同じ名前のオーバーロードによって行われる。
  65   //----------------------------------------------------------------------
  66
  67   //  引数無し、返り値無しの静的関数のみのコールバック関数クラス作成
  68   template<class T>
  69   static FunctionCallbackVoid* create(void (T::*f)()) {
  70     return new FunctionCallbackVoidg0<T>(f);
  71   }
  72
  73   //  引数あり、静的関数のみ
  74   template<class Arg1>
  75   static FunctionCallbackVoid* create(void (*f)(Arg1), Arg1 a1) {
  76     return new FunctionCallbackVoid1<Arg1>(f, a1);
  77   }
  78
  79   template<class Arg1, class Arg2>
  80   static FunctionCallbackVoid* create(void (*f)(Arg1, Arg2),
  81                                      Arg1 a1, Arg2 a2) {
  82     return new FunctionCallbackVoid2<Arg1, Arg2>(f, a1, a2);
  83   }
  84
  85   template<class Arg1, class Arg2, class Arg3>
  86   static FunctionCallbackVoid* create(void (*f)(Arg1, Arg2, Arg3),
  87                                      Arg1 a1, Arg2 a2, Arg3 a3) {
  88     return new FunctionCallbackVoid3<Arg1, Arg2, Arg3>(f, a1, a2, a3);
  89   }
  90
  91   template<class Arg1, class Arg2, class Arg3, class Arg4>
  92   static FunctionCallbackVoid* create(void (*f)(Arg1, Arg2, Arg3, Arg4),
  93                                      Arg1 a1, Arg2 a2, Arg3 a3, Arg4 a4) {
  94     return new FunctionCallbackVoid4<Arg1, Arg2, Arg3, Arg4>
  95         (f, a1, a2, a3, a4);
  96   }
  97
  98   template<class Arg1, class Arg2, class Arg3, class Arg4, class Arg5>
  99   static FunctionCallbackVoid*
 100   create(void (*f)(Arg1, Arg2, Arg3, Arg4, Arg5), Arg1 a1, Arg2 a2,
 101          Arg3 a3, Arg4 a4, Arg5 a5) {
 102     return new FunctionCallbackVoid5<Arg1, Arg2, Arg3, Arg4, Arg5>
 103         (f, a1, a2, a3, a4, a5);
 104   }
 105
 106   //  引数無し、メンバ関数
 107   template<class obj>
 108   static FunctionCallbackVoid* create(void (obj::*f)(), obj* p) {
 109     return new FunctionCallbackVoidMember0<obj>(f, p);
 110   }
 111
 112   template<class obj, class Arg1>
 113   static FunctionCallbackVoid* create(void (obj::*f)(Arg1), obj* p,
 114                                      Arg1 a1) {
 115     return new FunctionCallbackVoidMember1<obj, Arg1>(f, p, a1);
 116   }
 117
 118   template<class obj, class Arg1, class Arg2>
 119   static FunctionCallbackVoid* create(void (obj::*f)(Arg1, Arg2), obj* p,
 120                                      Arg1 a1, Arg2 a2) {
 121     return new FunctionCallbackVoidMember2<obj, Arg1, Arg2>(f, p, a1, a2);
 122   }
 123
 124   template<class obj, class Arg1, class Arg2, class Arg3>
 125   static FunctionCallbackVoid* create(void (obj::*f)(Arg1, Arg2, Arg3),
 126                                      obj* p, Arg1 a1, Arg2 a2, Arg3 a3) {
 127     return new FunctionCallbackVoidMember3<obj, Arg1, Arg2, Arg3>
 128         (f, p, a1, a2, a3);
 129   }
 130
 131   template<class obj, class Arg1, class Arg2, class Arg3, class Arg4>
 132   static FunctionCallbackVoid*
 133   create(void (obj::*f)(Arg1, Arg2, Arg3, Arg4), obj* p,
 134          Arg1 a1, Arg2 a2, Arg3 a3, Arg4 a4) {
 135     return new FunctionCallbackVoidMember4<obj, Arg1, Arg2, Arg3, Arg4>
 136         (f, p, a1, a2, a3, a4);
 137   }
 138
 139   template<class obj, class Arg1, class Arg2, class Arg3,
 140            class Arg4, class Arg5>
 141   static FunctionCallbackVoid*
 142   create(void (obj::*f)(Arg1, Arg2, Arg3, Arg4, Arg5), obj* p,
 143          Arg1 a1, Arg2 a2, Arg3 a3, Arg4 a4, Arg5 a5) {
 144     return new FunctionCallbackVoidMember5<obj, Arg1, Arg2, Arg3, Arg4, Arg5>
 145         (f, p, a1, a2, a3, a4, a5);
 146   }
 147
 148   virtual void Run() {}
 149 };
 150
 151 //==============================================================================
 152 //  返り値ありの関数コールバッククラス
 153 //==============================================================================
 154
 155 template<class Result, class T> class FunctionCallbackResultGlobal0;
 156
 157 template<class Result>class FunctionCallbackResult0;
 158
 159 template<class Result, class T> class FunctionCallbackResult1;
 160
 161 template<class Result, class T1, class T2> class FunctionCallbackResult2;
 162
 163 template<class Result, class T1, class T2, class T3> class FunctionCallbackResult3;
 164
 165 template<class Result, class T1, class T2, class T3, class T4>
 166 class FunctionCallbackResult4;
 167
 168 template<class Result, class T1, class T2, class T3, class T4, class T5>
 169 class FunctionCallbackResult5;
 170
 171 template<class Result, class OBJ> class FunctionCallbackResultMember0;
 172
 173 template<class Result, class OBJ, class T> class FunctionCallbackResultMember1;
 174
 175 template<class Result, class OBJ, class T1, class T2>
 176 class FunctionCallbackResultMember2;
 177
 178 template<class Result, class OBJ, class T1, class T2, class T3>
 179 class FunctionCallbackResultMember3;
 180
 181 template<class Result, class OBJ, class T1, class T2, class T3, class T4>
 182 class FunctionCallbackResultMember4;
 183
 184 template<class Result, class OBJ, class T1, class T2,
 185          class T3, class T4, class T5>
 186 class FunctionCallbackResultMember5;
 187
 188 /**
 189    FunctionCallback_r
 190    返り値ありのコールバック関数クラスの元締め
 191    getResultで引数を取得する
 192 */
 193 template<class Result>
 194 class FunctionCallbackResult : public FunctionCallback {
 195  public:
 196
 197   FunctionCallbackResult() : mResultesult() {}
 198   virtual ~FunctionCallbackResult() {}
 199
 200   //----------------------------------------------------------------------------
 201   //  返り値有りの関数コールバックの定義
 202   //  返り値はそれぞれ自由に設定することができる。
 203   //----------------------------------------------------------------------------
 204   inline FunctionCallbackResult<Result>* create(Result (*f)(void)) {
 205     return new FunctionCallbackResult0<Result>(f);
 206   }
 207
 208
 209   template<class T>
 210   static FunctionCallbackResult<Result>* create(Result (T::*f)()) {
 211     return new FunctionCallbackResultGlobal0<Result, T>(f);
 212   }
 213
 214   //  非メンバ関数
 215   template<class Arg1>
 216   static FunctionCallbackResult<Result>* create(Result (*f)(Arg1), Arg1 a1) {
 217     return new FunctionCallbackResult1<Result, Arg1>(f, a1);
 218   }
 219
 220   template<class Arg1, class Arg2>
 221   static FunctionCallbackResult<Result>* create(Result (*f)(Arg1, Arg2),
 222                                              Arg1 a1, Arg2 a2) {
 223     return new FunctionCallbackResult2<Result, Arg1, Arg2>(f, a1, a2);
 224   }
 225
 226   template<class Arg1, class Arg2, class Arg3>
 227   static FunctionCallbackResult<Result>*
 228   create(Result (*f)(Arg1, Arg2, Arg3), Arg1 a1, Arg2 a2, Arg3 a3) {
 229     return new FunctionCallbackResult3<Result, Arg1, Arg2, Arg3>(f, a1, a2, a3);
 230   }
 231
 232   template<class Arg1, class Arg2, class Arg3, class Arg4>
 233   static FunctionCallbackResult<Result>*
 234   create(Result (*f)(Arg1, Arg2, Arg3, Arg4),
 235          Arg1 a1, Arg2 a2, Arg3 a3, Arg4 a4) {
 236     return new FunctionCallbackResult4<Result, Arg1, Arg2, Arg3, Arg4>
 237         (f, a1, a2, a3, a4);
 238   }
 239
 240   template<class Arg1, class Arg2, class Arg3, class Arg4, class Arg5>
 241   static FunctionCallbackResult<Result>*
 242   create(Result (*f)(Arg1, Arg2, Arg3, Arg4),
 243          Arg1 a1, Arg2 a2, Arg3 a3, Arg4 a4, Arg5 a5) {
 244     return new FunctionCallbackResult5<Result, Arg1, Arg2, Arg3, Arg4, Arg5>
 245         (f, a1, a2, a3, a4, a5);
 246   }
 247
 248   //  メンバ関数
 249   template<class T>
 250   static FunctionCallbackResult<Result>* create(Result (T::*f)(), T* p) {
 251     return new FunctionCallbackResultMember0<Result, T>(f, p);
 252   }
 253
 254   template<class T, class Arg1>
 255   static FunctionCallbackResult<Result>* create(Result (T::*f)(Arg1), T* p,
 256                                              Arg1 a1) {
 257     return new FunctionCallbackResultMember1<Result, T, Arg1>(f, p, a1);
 258   }
 259
 260   template<class T, class Arg1, class Arg2>
 261   static FunctionCallbackResult<Result>* create(Result (T::*f)(Arg1, Arg2), T* p,
 262                                              Arg1 a1, Arg2 a2) {
 263     return new FunctionCallbackResultMember2<Result, T, Arg1, Arg2>(f, p, a1, a2);
 264   }
 265
 266   template<class T, class Arg1, class Arg2, class Arg3>
 267   static FunctionCallbackResult<Result>* create(Result (T::*f)(Arg1, Arg2, Arg3),
 268                                              T* p, Arg1 a1, Arg2 a2, Arg3 a3) {
 269     return new FunctionCallbackResultMember3<Result, T, Arg1, Arg2, Arg3>
 270         (f, p, a1, a2, a3);
 271   }
 272
 273   template<class T, class Arg1, class Arg2, class Arg3, class Arg4>
 274   static FunctionCallbackResult<Result>*
 275   create(Result (T::*f)(Arg1, Arg2, Arg3, Arg4), T* p,
 276          Arg1 a1, Arg2 a2, Arg3 a3, Arg4 a4) {
 277     return new FunctionCallbackResultMember4<Result, T, Arg1, Arg2, Arg3, Arg4>
 278         (f, p, a1, a2, a3, a4);
 279   }
 280
 281   template<class T, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5>
 282   static FunctionCallbackResult<Result>*
 283   create(Result (T::*f)(Arg1, Arg2, Arg3, Arg4, Arg5), T* p,
 284          Arg1 a1, Arg2 a2, Arg3 a3, Arg4 a4, Arg5 a5) {
 285     return new FunctionCallbackResultMember5<Result, T, Arg1, Arg2, Arg3, Arg4, Arg5>
 286         (f, p, a1, a2, a3, a4, a5);
 287   }
 288
 289   Result result_() {
 290     return result_;
 291   }
 292
 293   void SetResult(Result r) {this->result_ = r;}
 294
 295  private:
 296
 297   Result result_;
 298 };
 299
 300 //==============================================================================
 301 //  各コールバックテンプレートの実装
 302 //  各コールバックテンプレートは、原則として全てコピー不可能とする。
 303 //==============================================================================
 304
 305 class FunctionCallbackVoid0 : public FunctionCallbackVoid {
 306  public:
 307   typedef void (*CallBack)(void);
 308
 309   explicit FunctionCallbackVoid0(CallBack c) : function_(c) {}
 310
 311   virtual void Run() {
 312     function_();
 313   }
 314
 315  private:
 316
 317   CallBack function_;
 318
 319 };
 320
 321 template<class T>
 322 class FunctionCallbackVoidGlobal0 : public FunctionCallbackVoid {
 323  public:
 324   typedef void (T::*CallBack)();
 325
 326   FunctionCallbackVoidGlobal0(CallBack c) : function_(c) {}
 327   FunctionCallbackVoidGlobal0(const FunctionCallbackVoidGlobal0& v) : function_(NULL) {
 328     function_ = v.function_;
 329   }
 330
 331   virtual void Run() {
 332     function_();
 333   }
 334
 335  private:
 336
 337   CallBack function_;
 338
 339 };
 340
 341 template<class Arg1>
 342 class FunctionCallbackVoid1 : public FunctionCallbackVoid {
 343  public:
 344   typedef void (*CallBack)(Arg1);
 345
 346   FunctionCallbackVoid1(CallBack c,Arg1 a1) : function_(c),arg1_(a1) {}
 347   FunctionCallbackVoid1(const FunctionCallbackVoid1<Arg1>& v) : function_(NULL),arg1_(NULL) {
 348     function_ = v.function_;
 349     arg1_ = v.arg1_;
 350   }
 351
 352   virtual void Run() {
 353     function_(arg1_);
 354   }
 355
 356  private:
 357
 358   CallBack function_;
 359   Arg1 arg1_;
 360
 361 };
 362
 363 template<class Arg1,class Arg2>
 364 class FunctionCallbackVoid2 : public FunctionCallbackVoid {
 365  public:
 366   typedef void (*CallBack)(Arg1,Arg2);
 367
 368   FunctionCallbackVoid2(CallBack c,Arg1 a1,Arg2 a2) :
 369       function_(c),arg1_(a1),arg2_(a2) {}
 370   FunctionCallbackVoid2(const FunctionCallbackVoid2<Arg1,Arg2>& v) :
 371       function_(NULL),arg1_(NULL),arg2_(NULL) {
 372     function_ = v.function_;
 373     arg1_ = v.arg1_;
 374     arg2_ = v.arg2_;
 375   }
 376
 377   virtual void Run() {
 378     function_(arg1_,arg2_);
 379   }
 380
 381  private:
 382
 383   CallBack function_;
 384   Arg1 arg1_;
 385   Arg2 arg2_;
 386
 387 };
 388
 389 template<class Arg1,class Arg2,class Arg3>
 390 class FunctionCallbackVoid3 : public FunctionCallbackVoid {
 391  public:
 392   typedef void (*CallBack)(Arg1,Arg2,Arg3);
 393
 394   FunctionCallbackVoid3(CallBack c,Arg1 a1,Arg2 a2,Arg3 a3) :
 395       function_(c),arg1_(a1),arg2_(a2),arg3_(a3) {}
 396   FunctionCallbackVoid3(const FunctionCallbackVoid3<Arg1,Arg2,Arg3>& v) :
 397       function_(NULL),arg1_(NULL),arg2_(NULL),arg3_(NULL) {
 398     function_ = v.function_;
 399     arg1_ = v.arg1_;
 400     arg2_ = v.arg2_;
 401     arg3_ = v.arg3_;
 402   }
 403
 404   virtual void Run() {
 405     function_(arg1_,arg2_,arg3_);
 406   }
 407
 408  private:
 409
 410   CallBack function_;
 411   Arg1 arg1_;
 412   Arg2 arg2_;
 413   Arg3 arg3_;
 414
 415 };
 416
 417 template<class Arg1,class Arg2,class Arg3,class Arg4>
 418 class FunctionCallbackVoid4 : public FunctionCallbackVoid {
 419  public:
 420   typedef void (*CallBack)(Arg1,Arg2,Arg3,Arg4);
 421
 422   FunctionCallbackVoid4(CallBack c,Arg1 a1,Arg2 a2,Arg3 a3,Arg4 a4) :
 423       function_(c),arg1_(a1),arg2_(a2),arg3_(a3),arg4_(a4) {}
 424   FunctionCallbackVoid4(const FunctionCallbackVoid4
 425                        <Arg1,Arg2,Arg3,Arg4>& v) :
 426       function_(NULL),arg1_(NULL),arg2_(NULL),arg3_(NULL),arg4_(NULL) {
 427     function_ = v.function_;
 428     arg1_ = v.arg1_;
 429     arg2_ = v.arg2_;
 430     arg3_ = v.arg3_;
 431     arg4_ = v.arg4_;
 432   }
 433
 434   virtual void Run() {
 435     function_(arg1_,arg2_,arg3_,arg4_);
 436   }
 437
 438  private:
 439
 440   CallBack function_;
 441   Arg1 arg1_;
 442   Arg2 arg2_;
 443   Arg3 arg3_;
 444   Arg4 arg4_;
 445
 446 };
 447
 448 template<class Arg1,class Arg2,class Arg3,class Arg4,class Arg5>
 449 class FunctionCallbackVoid5 : public FunctionCallbackVoid {
 450  public:
 451   typedef void (*CallBack)(Arg1,Arg2,Arg3,Arg4,Arg5);
 452
 453   FunctionCallbackVoid5(CallBack c,Arg1 a1,Arg2 a2,Arg3 a3,Arg4 a4,Arg5 a5) :
 454       function_(c),arg1_(a1),arg2_(a2),arg3_(a3),arg4_(a4),arg5_(a5) {}
 455   FunctionCallbackVoid5(const FunctionCallbackVoid5<Arg1,Arg2,Arg3,
 456                        Arg4, Arg5>& v) :
 457       function_(NULL),arg1_(NULL),arg2_(NULL),arg3_(NULL),
 458       arg4_(NULL), arg5_(NULL)
 459   {
 460     function_ = v.function_;
 461     arg1_ = v.arg1_;
 462     arg2_ = v.arg2_;
 463     arg3_ = v.arg3_;
 464     arg4_ = v.arg4_;
 465     arg5_ = v.arg5_;
 466   }
 467
 468   virtual void Run() {
 469     function_(arg1_,arg2_,arg3_,arg4_,arg5_);
 470   }
 471
 472  private:
 473
 474   CallBack function_;
 475   Arg1 arg1_;
 476   Arg2 arg2_;
 477   Arg3 arg3_;
 478   Arg4 arg4_;
 479   Arg5 arg5_;
 480
 481 };
 482
 483 //------------------------------------------------------------------
 484
 485 template<class obj>
 486 class FunctionCallbackVoidMember0 : public FunctionCallbackVoid {
 487  public:
 488   typedef void (obj::*CallBack)();
 489
 490   FunctionCallbackVoidMember0(CallBack c,obj* p) : function_(c),obj_(p) {}
 491   FunctionCallbackVoidMember0(const FunctionCallbackVoidMember0<obj>& o) : function_(NULL),obj_(NULL)
 492   {
 493     function_ = o.function_;
 494     obj_ = o.obj_;
 495   }
 496
 497   virtual void Run() {
 498     (obj_->*function_)();
 499   }
 500
 501  private:
 502
 503   CallBack function_;
 504   obj* obj_;
 505
 506 };
 507
 508 template<class obj,class Arg1>
 509 class FunctionCallbackVoidMember1 : public FunctionCallbackVoid {
 510  public:
 511   typedef void (obj::*CallBack)(Arg1);
 512
 513   FunctionCallbackVoidMember1(CallBack c,obj* p,Arg1 a1) :
 514       function_(c),obj_(p),arg1_(a1) {}
 515   FunctionCallbackVoidMember1(const FunctionCallbackVoidMember1<obj,Arg1>& o) :
 516       function_(NULL),obj_(NULL),arg1_(NULL)
 517   {
 518     function_ = o.function_;
 519     obj_ = o.obj_;
 520     arg1_ = o.arg1_;
 521   }
 522
 523   virtual void Run() {
 524     (obj_->*function_)(arg1_);
 525   }
 526
 527  private:
 528
 529   CallBack function_;
 530   obj* obj_;
 531   Arg1 arg1_;
 532
 533 };
 534
 535 template<class obj,class Arg1,class Arg2>
 536 class FunctionCallbackVoidMember2 : public FunctionCallbackVoid {
 537  public:
 538   typedef void (obj::*CallBack)(Arg1,Arg2);
 539
 540   FunctionCallbackVoidMember2(CallBack c,obj* p,Arg1 a1,Arg2 a2) :
 541       function_(c),obj_(p),arg1_(a1),arg2_(a2) {}
 542   FunctionCallbackVoidMember2(const FunctionCallbackVoidMember2<obj,Arg1,Arg2>& o) :
 543       function_(NULL),obj_(NULL),arg1_(NULL),arg2_(NULL)
 544   {
 545     function_ = o.function_;
 546     obj_ = o.obj_;
 547     arg1_ = o.arg1_;
 548     arg2_ = o.arg2_;
 549   }
 550
 551   virtual void Run() {
 552     (obj_->*function_)(arg1_,arg2_);
 553   }
 554
 555  private:
 556
 557   CallBack function_;
 558   obj* obj_;
 559   Arg1 arg1_;
 560   Arg2 arg2_;
 561
 562 };
 563
 564 template<class obj,class Arg1,class Arg2,class Arg3>
 565 class FunctionCallbackVoidMember3 : public FunctionCallbackVoid {
 566  public:
 567   typedef void (obj::*CallBack)(Arg1,Arg2,Arg3);
 568
 569   FunctionCallbackVoidMember3(CallBack c,obj* p,Arg1 a1,Arg2 a2,Arg3 a3) :
 570       function_(c),obj_(p),arg1_(a1),arg2_(a2),arg3_(a3) {}
 571   FunctionCallbackVoidMember3(const FunctionCallbackVoidMember3<obj,Arg1,Arg2,Arg3>& o) :
 572       function_(NULL),obj_(NULL),arg1_(NULL),arg2_(NULL),arg3_(NULL)
 573   {
 574     function_ = o.function_;
 575     obj_ = o.obj_;
 576     arg1_ = o.arg1_;
 577     arg2_ = o.arg2_;
 578     arg3_ = o.arg3_;
 579   }
 580
 581   virtual void Run() {
 582     (obj_->*function_)(arg1_,arg2_,arg3_);
 583   }
 584
 585  private:
 586
 587   CallBack function_;
 588   obj* obj_;
 589   Arg1 arg1_;
 590   Arg2 arg2_;
 591   Arg3 arg3_;
 592
 593 };
 594
 595 template<class obj,class Arg1,class Arg2,class Arg3,class Arg4>
 596 class FunctionCallbackVoidMember4 : public FunctionCallbackVoid {
 597  public:
 598   typedef void (obj::*CallBack)(Arg1,Arg2,Arg3,Arg4);
 599
 600   FunctionCallbackVoidMember4(CallBack c,obj* p,Arg1 a1,Arg2 a2,Arg3 a3,Arg4 a4) :
 601       function_(c),obj_(p),arg1_(a1),arg2_(a2),arg3_(a3),arg4_(a4) {}
 602   FunctionCallbackVoidMember4(const FunctionCallbackVoidMember4<obj,Arg1,Arg2,Arg3,Arg4>& o) :
 603       function_(NULL),obj_(NULL),arg1_(NULL),arg2_(NULL),
 604       arg3_(NULL),arg4_(NULL)
 605   {
 606     function_ = o.function_;
 607     obj_ = o.obj_;
 608     arg1_ = o.arg1_;
 609     arg2_ = o.arg2_;
 610     arg3_ = o.arg3_;
 611     arg4_ = o.arg4_;
 612   }
 613
 614   virtual void Run() {
 615     (obj_->*function_)(arg1_,arg2_,arg3_,arg4_);
 616   }
 617
 618  private:
 619
 620   CallBack function_;
 621   obj* obj_;
 622   Arg1 arg1_;
 623   Arg2 arg2_;
 624   Arg3 arg3_;
 625   Arg4 arg4_;
 626
 627 };
 628
 629 template<class obj,class Arg1,class Arg2,class Arg3,class Arg4,class Arg5>
 630 class FunctionCallbackVoidMember5 : public FunctionCallbackVoid {
 631  public:
 632   typedef void (obj::*CallBack)(Arg1,Arg2,Arg3,Arg4,Arg5);
 633
 634   FunctionCallbackVoidMember5(CallBack c,obj* p,Arg1 a1,Arg2 a2,Arg3 a3,Arg4 a4,Arg5 a5) :
 635       function_(c),obj_(p),arg1_(a1),arg2_(a2),arg3_(a3),arg4_(a4),arg5_(a5) {}
 636   FunctionCallbackVoidMember5(const FunctionCallbackVoidMember5<obj,Arg1,Arg2,Arg3,Arg4,Arg5>& o) :
 637       function_(NULL),obj_(NULL),arg1_(NULL),arg2_(NULL),
 638       arg3_(NULL),arg4_(NULL),arg5_(NULL)
 639   {
 640     function_ = o.function_;
 641     obj_ = o.obj_;
 642     arg1_ = o.arg1_;
 643     arg2_ = o.arg2_;
 644     arg3_ = o.arg3_;
 645     arg4_ = o.arg4_;
 646     arg5_ = o.arg5_;
 647   }
 648
 649   virtual void Run() {
 650     (obj_->*function_)(arg1_,arg2_,arg3_,arg4_,arg5_);
 651   }
 652
 653  private:
 654
 655   CallBack function_;
 656   obj* obj_;
 657   Arg1 arg1_;
 658   Arg2 arg2_;
 659   Arg3 arg3_;
 660   Arg4 arg4_;
 661   Arg5 arg5_;
 662
 663 };
 664
 665 //-----------------------------------------------------------------------
 666
 667 template<class Result>
 668 class FunctionCallbackResult0 : public FunctionCallbackResult<Result> {
 669  public:
 670   typedef Result (*CallBack)();
 671
 672   FunctionCallbackResult0(CallBack c) : function_(c) {}
 673   FunctionCallbackResult0(const FunctionCallbackResult0<Result>& r) :
 674       function_(NULL)
 675   {
 676     function_ = r.function_;
 677   }
 678
 679   virtual void Run() {
 680     Result r = function_();
 681     SetResult(r);
 682   }
 683
 684  private:
 685
 686   CallBack function_;
 687
 688 };
 689
 690 template<class Result,class T>
 691 class FunctionCallbackResultGlobal0 : public FunctionCallbackResult<Result> {
 692  public:
 693   typedef Result (T::*CallBack)();
 694
 695   FunctionCallbackResultGlobal0(CallBack c) : function_(c) {}
 696   FunctionCallbackResultGlobal0(const FunctionCallbackResultGlobal0<Result,T>& r) :
 697       function_(NULL)
 698   {
 699     function_ = r.function_;
 700   }
 701   FunctionCallbackResult1<Result,T>& operator=(
 702       const FunctionCallbackResult1<Result, T>& r)
 703   {
 704     function_ = r.function_;
 705   }
 706
 707   virtual void Run() {
 708     Result r = function_();
 709     SetResult(r);
 710   }
 711
 712  private:
 713
 714   CallBack function_;
 715
 716 };
 717
 718 template<class Result,class Arg1>
 719 class FunctionCallbackResult1 : public FunctionCallbackResult<Result> {
 720  public:
 721   typedef Result (*CallBack)(Arg1);
 722
 723   FunctionCallbackResult1(CallBack c,Arg1 a1) : function_(c),arg1_(a1) {}
 724   FunctionCallbackResult1(const FunctionCallbackResult1<Result,Arg1>& r) :
 725       function_(NULL), arg1_(NULL)
 726   {
 727     function_ = r.function_;
 728     arg1_ = r.arg1_;
 729   }
 730   FunctionCallbackResult1<Result, Arg1>& operator=(
 731       const FunctionCallbackResult1<Result,Arg1>& r)
 732   {
 733     function_ = r.function_;
 734     arg1_ = r.arg1_;
 735   }
 736
 737   virtual void Run() {
 738     Result r = function_(arg1_);
 739     SetResult(r);
 740   }
 741
 742  private:
 743
 744   CallBack function_;
 745   Arg1 arg1_;
 746
 747 };
 748
 749 template<class Result,class Arg1,class Arg2>
 750 class FunctionCallbackResult2 : public FunctionCallbackResult<Result> {
 751  public:
 752   typedef Result (*CallBack)(Arg1,Arg2);
 753
 754   FunctionCallbackResult2(CallBack c,Arg1 a1,Arg2 a2) : function_(c),arg1_(a1),arg2_(a2) {}
 755   FunctionCallbackResult2(const FunctionCallbackResult2<Result,Arg1,Arg2>& r) :
 756       function_(NULL), arg1_(NULL), arg2_(NULL)
 757   {
 758     function_ = r.function_;
 759     arg1_ = r.arg1_;
 760     arg2_ = r.arg2_;
 761   }
 762   FunctionCallbackResult2<Result, Arg1, Arg2>& operator=(
 763       const FunctionCallbackResult2<Result,Arg1,Arg2>& r)
 764   {
 765     function_ = r.function_;
 766     arg1_ = r.arg1_;
 767     arg2_ = r.arg2_;
 768   }
 769
 770   virtual void Run() {
 771     Result r = function_(arg1_,arg2_);
 772     SetResult(r);
 773   }
 774
 775  private:
 776
 777   CallBack function_;
 778   Arg1 arg1_;
 779   Arg2 arg2_;
 780
 781 };
 782
 783 template<class Result,class Arg1,class Arg2,class Arg3>
 784 class FunctionCallbackResult3 : public FunctionCallbackResult<Result> {
 785  public:
 786   typedef Result (*CallBack)(Arg1,Arg2,Arg3);
 787
 788   FunctionCallbackResult3(CallBack c,Arg1 a1,Arg2 a2,Arg3 a3) :
 789       function_(c),arg1_(a1),arg2_(a2),arg3_(a3) {}
 790   FunctionCallbackResult3(const FunctionCallbackResult3<Result,Arg1,Arg2,Arg3>& r) :
 791       function_(NULL), arg1_(NULL), arg2_(NULL), arg3_(NULL)
 792   {
 793     function_ = r.function_;
 794     arg1_ = r.arg1_;
 795     arg2_ = r.arg2_;
 796     arg3_ = r.arg3_;
 797   }
 798   FunctionCallbackResult3<Result, Arg1, Arg2, Arg3>& operator=(
 799       const FunctionCallbackResult3<Result,Arg1,Arg2, Arg3>& r)
 800   {
 801     function_ = r.function_;
 802     arg1_ = r.arg1_;
 803     arg2_ = r.arg2_;
 804     arg3_ = r.arg3_;
 805   }
 806
 807   virtual void Run() {
 808     Result r = function_(arg1_,arg2_,arg3_);
 809     SetResult(r);
 810   }
 811
 812  private:
 813
 814   CallBack function_;
 815   Arg1 arg1_;
 816   Arg2 arg2_;
 817   Arg3 arg3_;
 818
 819 };
 820
 821 template<class Result,class Arg1,class Arg2,class Arg3,class Arg4>
 822 class FunctionCallbackResult4 : public FunctionCallbackResult<Result> {
 823  public:
 824   typedef Result (*CallBack)(Arg1,Arg2,Arg3,Arg4);
 825
 826   FunctionCallbackResult4(CallBack c,Arg1 a1,Arg2 a2,Arg3 a3,Arg4 a4) :
 827       function_(c),arg1_(a1),arg2_(a2),arg3_(a3),arg4_(a4) {}
 828   FunctionCallbackResult4(const FunctionCallbackResult4<Result,Arg1,Arg2,Arg3,Arg4>& r) :
 829       function_(NULL), arg1_(NULL), arg2_(NULL),arg3_(NULL), arg4_(NULL)
 830   {
 831     function_ = r.function_;
 832     arg1_ = r.arg1_;
 833     arg2_ = r.arg2_;
 834     arg3_ = r.arg3_;
 835     arg4_ = r.arg4_;
 836   }
 837
 838   virtual void Run() {
 839     Result r = function_(arg1_,arg2_,arg3_,arg4_);
 840     SetResult(r);
 841   }
 842
 843  private:
 844
 845   CallBack function_;
 846   Arg1 arg1_;
 847   Arg2 arg2_;
 848   Arg3 arg3_;
 849   Arg4 arg4_;
 850
 851 };
 852
 853 template<class Result,class Arg1,class Arg2,class Arg3,class Arg4,class Arg5>
 854 class FunctionCallbackResult5 : public FunctionCallbackResult<Result> {
 855  public:
 856   typedef Result (*CallBack)(Arg1,Arg2,Arg3,Arg4);
 857
 858   FunctionCallbackResult5(CallBack c,Arg1 a1,Arg2 a2,Arg3 a3,Arg4 a4,Arg5 a5) :
 859       function_(c),arg1_(a1),arg2_(a2),arg3_(a3),arg4_(a4),arg5_(a5) {}
 860   FunctionCallbackResult5(const FunctionCallbackResult5<Result,Arg1,Arg2,Arg3,Arg4,Arg5>& r) :
 861       function_(NULL), arg1_(NULL), arg2_(NULL),arg3_(NULL), arg4_(NULL),
 862       arg5_(NULL)
 863   {
 864     function_ = r.function_;
 865     arg1_ = r.arg1_;
 866     arg2_ = r.arg2_;
 867     arg3_ = r.arg3_;
 868     arg4_ = r.arg4_;
 869     arg5_ = r.arg5_;
 870   }
 871
 872
 873   virtual void Run() {
 874     Result r = function_(arg1_,arg2_,arg3_,arg4_,arg5_);
 875     SetResult(r);
 876   }
 877
 878  private:
 879
 880   CallBack function_;
 881   Arg1 arg1_;
 882   Arg2 arg2_;
 883   Arg3 arg3_;
 884   Arg4 arg4_;
 885   Arg5 arg5_;
 886
 887 };
 888
 889 template<class Result,class T>
 890 class FunctionCallbackResultMember0 : public FunctionCallbackResult<Result> {
 891  public:
 892   typedef Result (T::*CallBack)();
 893
 894   FunctionCallbackResultMember0(CallBack c,T* p) : function_(c),obj_(p) {}
 895   FunctionCallbackResultMember0(const FunctionCallbackResultMember0<Result, T>& r) :
 896       function_(NULL),obj_(NULL)
 897   {
 898     function_ = r.function_;
 899     obj_ = r.obj_;
 900   }
 901
 902   virtual void Run() {
 903     Result r = (obj_->*function_)();
 904     SetResult(r);
 905   }
 906
 907  private:
 908
 909   CallBack function_;
 910   T* obj_;
 911
 912 };
 913
 914 template<class Result,class T,class Arg1>
 915 class FunctionCallbackResultMember1 : public FunctionCallbackResult<Result> {
 916  public:
 917   typedef Result (T::*CallBack)(Arg1);
 918
 919   FunctionCallbackResultMember1(CallBack c,T* p,Arg1 a1) :
 920       function_(c),obj_(p),arg1_(a1) {}
 921   FunctionCallbackResultMember1(const FunctionCallbackResultMember1<Result, T,Arg1>& r) :
 922       function_(NULL),obj_(NULL), arg1_(NULL)
 923   {
 924     function_ = r.function_;
 925     obj_ = r.obj_;
 926     arg1_ = r.arg1_;
 927   }
 928
 929   virtual void Run() {
 930     Result r = (obj_->*function_)(arg1_);
 931     SetResult(r);
 932   }
 933
 934  private:
 935
 936   CallBack function_;
 937   T* obj_;
 938   Arg1 arg1_;
 939
 940 };
 941
 942 template<class Result,class T,class Arg1,class Arg2>
 943 class FunctionCallbackResultMember2 : public FunctionCallbackResult<Result> {
 944  public:
 945   typedef Result (T::*CallBack)(Arg1,Arg2);
 946
 947   FunctionCallbackResultMember2(CallBack c,T* p,Arg1 a1,Arg2 a2) :
 948       function_(c),obj_(p),arg1_(a1),arg2_(a2) {}
 949   FunctionCallbackResultMember2(const FunctionCallbackResultMember2<Result,T,Arg1,Arg2>& r) :
 950       function_(NULL),obj_(NULL), arg1_(NULL), arg2_(NULL)
 951   {
 952     function_ = r.function_;
 953     obj_ = r.obj_;
 954     arg1_ = r.arg1_;
 955     arg2_ = r.arg2_;
 956   }
 957
 958   virtual void Run() {
 959     Result r = (obj_->*function_)(arg1_,arg2_);
 960     SetResult(r);
 961   }
 962
 963  private:
 964
 965   CallBack function_;
 966   T* obj_;
 967   Arg1 arg1_;
 968   Arg2 arg2_;
 969
 970 };
 971
 972 template<class Result,class T,class Arg1,class Arg2,class Arg3>
 973 class FunctionCallbackResultMember3 : public FunctionCallbackResult<Result> {
 974  public:
 975   typedef Result (T::*CallBack)(Arg1,Arg2,Arg3);
 976
 977   FunctionCallbackResultMember3(CallBack c,T* p,Arg1 a1,Arg2 a2,Arg3 a3) :
 978       function_(c),obj_(p),arg1_(a1),arg2_(a2),arg3_(a3) {}
 979   FunctionCallbackResultMember3(const FunctionCallbackResultMember3<Result, T,
 980                         Arg1,Arg2,Arg3>& r) :
 981       function_(NULL),obj_(NULL), arg1_(NULL), arg2_(NULL),
 982       arg3_(NULL)
 983   {
 984     function_ = r.function_;
 985     obj_ = r.obj_;
 986     arg1_ = r.arg1_;
 987     arg2_ = r.arg2_;
 988     arg3_ = r.arg3_;
 989   }
 990
 991   virtual void Run() {
 992     Result r = (obj_->*function_)(arg1_,arg2_,arg3_);
 993     SetResult(r);
 994   }
 995
 996  private:
 997
 998   CallBack function_;
 999   T* obj_;
1000   Arg1 arg1_;
1001   Arg2 arg2_;
1002   Arg3 arg3_;
1003
1004 };
1005
1006 template<class Result,class T,class Arg1,class Arg2,class Arg3,class Arg4>
1007 class FunctionCallbackResultMember4 : public FunctionCallbackResult<Result> {
1008  public:
1009   typedef Result (T::*CallBack)(Arg1,Arg2,Arg3,Arg4);
1010
1011   FunctionCallbackResultMember4(CallBack c,T* p,Arg1 a1,Arg2 a2,Arg3 a3,Arg4 a4) :
1012       function_(c),obj_(p),arg1_(a1),arg2_(a2),arg3_(a3),arg4_(a4) {}
1013   FunctionCallbackResultMember4(const FunctionCallbackResultMember4<Result, T,
1014                         Arg1,Arg2,Arg3,Arg4>& r) :
1015       function_(NULL),obj_(NULL), arg1_(NULL), arg2_(NULL),
1016       arg3_(NULL), arg4_(NULL)
1017   {
1018     function_ = r.function_;
1019     obj_ = r.obj_;
1020     arg1_ = r.arg1_;
1021     arg2_ = r.arg2_;
1022     arg3_ = r.arg3_;
1023     arg4_ = r.arg4_;
1024   }
1025
1026   virtual void Run() {
1027     Result r = (obj_->*function_)(arg1_,arg2_,arg3_,arg4_);
1028     SetResult(r);
1029   }
1030
1031  private:
1032
1033   CallBack function_;
1034   T* obj_;
1035   Arg1 arg1_;
1036   Arg2 arg2_;
1037   Arg3 arg3_;
1038   Arg4 arg4_;
1039
1040 };
1041
1042 template<class Result,class T,class Arg1,class Arg2,class Arg3,class Arg4,class Arg5>
1043 class FunctionCallbackResultMember5 : public FunctionCallbackResult<Result> {
1044  public:
1045   typedef Result (T::*CallBack)(Arg1,Arg2,Arg3,Arg4,Arg5);
1046
1047   FunctionCallbackResultMember5(CallBack c,T* p,Arg1 a1,Arg2 a2,Arg3 a3,Arg4 a4,Arg5 a5) :
1048       function_(c),obj_(p),arg1_(a1),arg2_(a2),arg3_(a3),arg4_(a4),arg5_(a5) {}
1049   FunctionCallbackResultMember5(const FunctionCallbackResultMember5<Result, T,
1050                         Arg1,Arg2,Arg3,Arg4, Arg5>& r) :
1051       function_(NULL),obj_(NULL), arg1_(NULL), arg2_(NULL),
1052       arg3_(NULL), arg4_(NULL), arg5_(NULL)
1053   {
1054     function_ = r.function_;
1055     obj_ = r.obj_;
1056     arg1_ = r.arg1_;
1057     arg2_ = r.arg2_;
1058     arg3_ = r.arg3_;
1059     arg4_ = r.arg4_;
1060     arg5_ = r.arg5_;
1061   }
1062
1063   virtual void Run() {
1064     Result r = (obj_->*function_)(arg1_,arg2_,arg3_,arg4_,arg5_);
1065     SetResult(r);
1066   }
1067
1068  private:
1069
1070   CallBack function_;
1071   T* obj_;
1072   Arg1 arg1_;
1073   Arg2 arg2_;
1074   Arg3 arg3_;
1075   Arg4 arg4_;
1076   Arg5 arg5_;
1077
1078 };
1079
1080
1081 // この関数のみ、実体が必要であるため、ここで定義する。
1082 inline FunctionCallbackVoid* create(void (*f)(void))
1083 {
1084   return new FunctionCallbackVoid0(f);
1085 }
1086
1087
1088 };
1089
1090 #endif