function_callback.h

   1 #ifndef ___HGL___FUNCTION_CALLBACK___
   2 #define ___HGL___FUNCTION_CALLBACK___
   3
   4 namespace fc {
   5
   6     /**
   7        function_callback
   8        関数コールバック基底クラス
   9        全てのコールバック関数クラスは、このクラスから派生する。
  10        smart_ptrの使用が前提である。
  11     */
  12     class function_callback {
  13     public:
  14
  15         virtual ~function_callback() {}
  16
  17         //これを必ずオーバーロードすること。
  18         virtual void run() = 0;
  19     };
  20
  21     /*
  22       準備するコールバック関数クラスの種類は、
  23       返り値あり、返り値無し --- 2種
  24       メンバ関数、非メンバ関数 --- 2種
  25       引数0〜5個               --- 6種
  26       の24個定義する
  27     */
  28     template<class T> class function_callback_vg0;
  29     class function_callback_v0;
  30     template<class T> class function_callback_v1;
  31     template<class T1,class T2> class function_callback_v2;
  32     template<class T1,class T2,class T3> class function_callback_v3;
  33     template<class T1,class T2,class T3,class T4> class function_callback_v4;
  34     template<class T1,class T2,class T3,class T4,class T5> class function_callback_v5;
  35     template<class Obj> class function_callback_vm0;
  36     template<class Obj,class T> class function_callback_vm1;
  37     template<class Obj,class T1,class T2> class function_callback_vm2;
  38     template<class Obj,class T1,class T2,class T3> class function_callback_vm3;
  39     template<class Obj,class T1,class T2,class T3,class T4> class function_callback_vm4;
  40     template<class Obj,class T1,class T2,class T3,class T4,class T5> class function_callback_vm5;
  41
  42     /**
  43        function_callback_v
  44        返り値無しのコールバック関数クラス。
  45        staticなcreate関数によって、それぞれを作成する。
  46        また、これから作成されるクラスも、全てfunction_callback派生クラスである。
  47     */
  48     class function_callback_v : public function_callback {
  49     public:
  50
  51         virtual ~function_callback_v() {}
  52
  53         //--------------------------------------------------------------------------------
  54         // 各関数コールバッククラス生成関数群。
  55         // ここでの関数群は、全て同じ名前のオーバーロードによって行われる。
  56         //--------------------------------------------------------------------------------
  57
  58         //引数無し、返り値無しの静的関数のみのコールバック関数クラス作成
  59         template<class T>
  60         static function_callback_v* create(void (T::*f)()) {
  61             return new function_callback_vg0<T>(f);
  62         }
  63
  64         //引数あり、静的関数のみ
  65         template<class Arg1>
  66         static function_callback_v* create(void (*f)(Arg1),Arg1 a1) {
  67             return new function_callback_v1<Arg1>(f,a1);
  68         }
  69
  70         template<class Arg1,class Arg2>
  71         static function_callback_v* create(void (*f)(Arg1,Arg2),Arg1 a1,Arg2 a2) {
  72             return new function_callback_v2<Arg1,Arg2>(f,a1,a2);
  73         }
  74
  75         template<class Arg1,class Arg2,class Arg3>
  76         static function_callback_v* create(void (*f)(Arg1,Arg2,Arg3),Arg1 a1,Arg2 a2,Arg3 a3) {
  77             return new function_callback_v3<Arg1,Arg2,Arg3>(f,a1,a2,a3);
  78         }
  79
  80         template<class Arg1,class Arg2,class Arg3,class Arg4>
  81         static function_callback_v* create(void (*f)(Arg1,Arg2,Arg3,Arg4),Arg1 a1,Arg2 a2,Arg3 a3,Arg4 a4) {
  82             return new function_callback_v4<Arg1,Arg2,Arg3,Arg4>(f,a1,a2,a3,a4);
  83         }
  84
  85         template<class Arg1,class Arg2,class Arg3,class Arg4,class Arg5>
  86         static function_callback_v* create(void (*f)(Arg1,Arg2,Arg3,Arg4,Arg5),
  87                                     Arg1 a1,Arg2 a2,Arg3 a3,Arg4 a4,Arg5 a5) {
  88             return new function_callback_v5<Arg1,Arg2,Arg3,Arg4,Arg5>(f,a1,a2,a3,a4,a5);
  89         }
  90
  91         //引数無し、メンバ関数
  92         template<class obj>
  93         static function_callback_v* create(void (obj::*f)(),obj* p) {
  94             return new function_callback_vm0<obj>(f,p);
  95         }
  96
  97         template<class obj,class Arg1>
  98         static function_callback_v* create(void (obj::*f)(Arg1),obj* p,Arg1 a1) {
  99             return new function_callback_vm1<obj,Arg1>(f,p,a1);
 100         }
 101
 102         template<class obj,class Arg1,class Arg2>
 103         static function_callback_v* create(void (obj::*f)(Arg1,Arg2),obj* p,Arg1 a1,Arg2 a2) {
 104             return new function_callback_vm2<obj,Arg1,Arg2>(f,p,a1,a2);
 105         }
 106
 107         template<class obj,class Arg1,class Arg2,class Arg3>
 108         static function_callback_v* create(void (obj::*f)(Arg1,Arg2,Arg3),obj* p,Arg1 a1,Arg2 a2,Arg3 a3) {
 109             return new function_callback_vm3<obj,Arg1,Arg2,Arg3>(f,p,a1,a2,a3);
 110         }
 111
 112         template<class obj,class Arg1,class Arg2,class Arg3,class Arg4>
 113         static function_callback_v* create(void (obj::*f)(Arg1,Arg2,Arg3,Arg4),obj* p,
 114                                     Arg1 a1,Arg2 a2,Arg3 a3,Arg4 a4) {
 115             return new function_callback_vm4<obj,Arg1,Arg2,Arg3,Arg4>(f,p,a1,a2,a3,a4);
 116         }
 117
 118         template<class obj,class Arg1,class Arg2,class Arg3,class Arg4,class Arg5>
 119         static function_callback_v* create(void (obj::*f)(Arg1,Arg2,Arg3,Arg4,Arg5),obj* p,
 120                                     Arg1 a1,Arg2 a2,Arg3 a3,Arg4 a4,Arg5 a5) {
 121             return new function_callback_vm5<obj,Arg1,Arg2,Arg3,Arg4,Arg5>(f,p,a1,a2,a3,a4,a5);
 122         }
 123
 124         virtual void run() {}
 125
 126     };
 127
 128     //================================================================================
 129     // 返り値ありの関数コールバッククラス
 130     //================================================================================
 131
 132     template<class Result,class T> class function_callback_rg0;
 133     template<class Result>class function_callback_r0;
 134     template<class Result, class T> class function_callback_r1;
 135     template<class Result, class T1,class T2> class function_callback_r2;
 136     template<class Result, class T1,class T2,class T3> class function_callback_r3;
 137     template<class Result, class T1,class T2,class T3,class T4> class function_callback_r4;
 138     template<class Result, class T1,class T2,class T3,class T4,class T5> class function_callback_r5;
 139     template<class Result, class OBJ> class function_callback_rm0;
 140     template<class Result, class OBJ,class T> class function_callback_rm1;
 141     template<class Result, class OBJ,class T1,class T2> class function_callback_rm2;
 142     template<class Result, class OBJ,class T1,class T2,class T3> class function_callback_rm3;
 143     template<class Result, class OBJ,class T1,class T2,class T3,class T4> class function_callback_rm4;
 144     template<class Result, class OBJ,class T1,class T2,class T3,class T4,class T5> class function_callback_rm5;
 145
 146     /**
 147        function_callback_r
 148        返り値ありのコールバック関数クラスの元締め
 149        getResultで引数を取得する
 150     */
 151     template<class Result>
 152     class function_callback_r : public function_callback {
 153     public:
 154
 155         function_callback_r() : m_Result() {}
 156         virtual ~function_callback_r() {}
 157
 158
 159         //--------------------------------------------------------------------------------
 160         // 返り値有りの関数コールバックの定義
 161         // 返り値はそれぞれ自由に設定することができる。
 162         //--------------------------------------------------------------------------------
 163         inline function_callback_r<Result>* create(Result (*f)(void)) {
 164             return new function_callback_r0<Result>(f);
 165         }
 166
 167
 168         template<class T>
 169         static function_callback_r<Result>* create(Result (T::*f)()) {
 170             return new function_callback_rg0<Result,T>(f);
 171         }
 172
 173         //非メンバ関数
 174         template<class Arg1>
 175         static function_callback_r<Result>* create(Result (*f)(Arg1),Arg1 a1) {
 176             return new function_callback_r1<Result,Arg1>(f,a1);
 177         }
 178
 179         template<class Arg1,class Arg2>
 180         static function_callback_r<Result>* create(Result (*f)(Arg1,Arg2),Arg1 a1,Arg2 a2) {
 181             return new function_callback_r2<Result,Arg1,Arg2>(f,a1,a2);
 182         }
 183
 184         template<class Arg1,class Arg2,class Arg3>
 185         static function_callback_r<Result>*
 186         create(Result (*f)(Arg1,Arg2,Arg3),Arg1 a1,Arg2 a2,Arg3 a3) {
 187             return new function_callback_r3<Result,Arg1,Arg2,Arg3>(f,a1,a2,a3);
 188         }
 189
 190         template<class Arg1,class Arg2,class Arg3,class Arg4>
 191         static function_callback_r<Result>* create(Result (*f)(Arg1,Arg2,Arg3,Arg4),Arg1 a1,Arg2 a2,Arg3 a3,Arg4 a4) {
 192             return new function_callback_r4<Result,Arg1,Arg2,Arg3,Arg4>(f,a1,a2,a3,a4);
 193         }
 194
 195         template<class Arg1,class Arg2,class Arg3,class Arg4,class Arg5>
 196         static function_callback_r<Result>* create(Result (*f)(Arg1,Arg2,Arg3,Arg4),
 197                                             Arg1 a1,Arg2 a2,Arg3 a3,Arg4 a4,Arg5 a5) {
 198             return new function_callback_r5<Result,Arg1,Arg2,Arg3,Arg4,Arg5>(f,a1,a2,a3,a4,a5);
 199         }
 200
 201         //メンバ関数
 202         template<class T>
 203         static function_callback_r<Result>* create(Result (T::*f)(),T* p) {
 204             return new function_callback_rm0<Result,T>(f,p);
 205         }
 206
 207         template<class T,class Arg1>
 208         static function_callback_r<Result>* create(Result (T::*f)(Arg1),T* p,Arg1 a1) {
 209             return new function_callback_rm1<Result,T,Arg1>(f,p,a1);
 210         }
 211
 212         template<class T,class Arg1,class Arg2>
 213         static function_callback_r<Result>* create(Result (T::*f)(Arg1,Arg2),T* p,Arg1 a1,Arg2 a2) {
 214             return new function_callback_rm2<Result,T,Arg1,Arg2>(f,p,a1,a2);
 215         }
 216
 217         template<class T,class Arg1,class Arg2,class Arg3>
 218         static function_callback_r<Result>* create(Result (T::*f)(Arg1,Arg2,Arg3),T* p,Arg1 a1,Arg2 a2,Arg3 a3) {
 219             return new function_callback_rm3<Result,T,Arg1,Arg2,Arg3>(f,p,a1,a2,a3);
 220         }
 221
 222         template<class T,class Arg1,class Arg2,class Arg3,class Arg4>
 223         static function_callback_r<Result>* create(Result (T::*f)(Arg1,Arg2,Arg3,Arg4),T* p,
 224                                             Arg1 a1,Arg2 a2,Arg3 a3,Arg4 a4) {
 225             return new function_callback_rm4<Result,T,Arg1,Arg2,Arg3,Arg4>(f,p,a1,a2,a3,a4);
 226         }
 227
 228         template<class T,class Arg1,class Arg2,class Arg3,class Arg4,class Arg5>
 229         static function_callback_r<Result>* create(Result (T::*f)(Arg1,Arg2,Arg3,Arg4,Arg5),T* p,
 230                                             Arg1 a1,Arg2 a2,Arg3 a3,Arg4 a4,Arg5 a5) {
 231             return new function_callback_rm5<Result,T,Arg1,Arg2,Arg3,Arg4,Arg5>(f,p,a1,a2,a3,a4,a5);
 232         }
 233
 234         Result getResult() {
 235             return m_Result;
 236         }
 237
 238         void setResult(Result r) {this->m_Result = r;}
 239
 240     private:
 241
 242         Result m_Result;
 243
 244     };
 245
 246     //================================================================================
 247     // 各コールバックテンプレートの実装
 248     //================================================================================
 249
 250     class function_callback_v0 : public function_callback_v {
 251     public:
 252         typedef void (*CallBack)(void);
 253
 254         function_callback_v0(CallBack c) : m_lpFunc(c) {}
 255
 256         virtual void run() {
 257             m_lpFunc();
 258         }
 259
 260     private:
 261
 262         CallBack m_lpFunc;
 263
 264     };
 265
 266     template<class T>
 267     class function_callback_vg0 : public function_callback_v {
 268     public:
 269         typedef void (T::*CallBack)();
 270
 271         function_callback_vg0(CallBack c) : m_lpFunc(c) {}
 272
 273         virtual void run() {
 274             m_lpFunc();
 275         }
 276
 277     private:
 278
 279         CallBack m_lpFunc;
 280
 281     };
 282
 283     template<class Arg1>
 284     class function_callback_v1 : public function_callback_v {
 285     public:
 286         typedef void (*CallBack)(Arg1);
 287
 288         function_callback_v1(CallBack c,Arg1 a1) : m_lpFunc(c),m_Arg1(a1) {}
 289
 290         virtual void run() {
 291             m_lpFunc(m_Arg1);
 292         }
 293
 294     private:
 295
 296         CallBack m_lpFunc;
 297         Arg1 m_Arg1;
 298
 299     };
 300
 301     template<class Arg1,class Arg2>
 302     class function_callback_v2 : public function_callback_v {
 303     public:
 304         typedef void (*CallBack)(Arg1,Arg2);
 305
 306         function_callback_v2(CallBack c,Arg1 a1,Arg2 a2) :
 307             m_lpFunc(c),m_Arg1(a1),m_Arg2(a2) {}
 308
 309         virtual void run() {
 310             m_lpFunc(m_Arg1,m_Arg2);
 311         }
 312
 313     private:
 314
 315         CallBack m_lpFunc;
 316         Arg1 m_Arg1;
 317         Arg2 m_Arg2;
 318
 319     };
 320
 321     template<class Arg1,class Arg2,class Arg3>
 322     class function_callback_v3 : public function_callback_v {
 323     public:
 324         typedef void (*CallBack)(Arg1,Arg2,Arg3);
 325
 326         function_callback_v3(CallBack c,Arg1 a1,Arg2 a2,Arg3 a3) :
 327             m_lpFunc(c),m_Arg1(a1),m_Arg2(a2),m_Arg3(a3) {}
 328
 329         virtual void run() {
 330             m_lpFunc(m_Arg1,m_Arg2,m_Arg3);
 331         }
 332
 333     private:
 334
 335         CallBack m_lpFunc;
 336         Arg1 m_Arg1;
 337         Arg2 m_Arg2;
 338         Arg3 m_Arg3;
 339
 340     };
 341
 342     template<class Arg1,class Arg2,class Arg3,class Arg4>
 343     class function_callback_v4 : public function_callback_v {
 344     public:
 345         typedef void (*CallBack)(Arg1,Arg2,Arg3,Arg4);
 346
 347         function_callback_v4(CallBack c,Arg1 a1,Arg2 a2,Arg3 a3,Arg4 a4) :
 348             m_lpFunc(c),m_Arg1(a1),m_Arg2(a2),m_Arg3(a3),m_Arg4(a4) {}
 349
 350         virtual void run() {
 351             m_lpFunc(m_Arg1,m_Arg2,m_Arg3,m_Arg4);
 352         }
 353
 354     private:
 355
 356         CallBack m_lpFunc;
 357         Arg1 m_Arg1;
 358         Arg2 m_Arg2;
 359         Arg3 m_Arg3;
 360         Arg4 m_Arg4;
 361
 362     };
 363
 364     template<class Arg1,class Arg2,class Arg3,class Arg4,class Arg5>
 365     class function_callback_v5 : public function_callback_v {
 366     public:
 367         typedef void (*CallBack)(Arg1,Arg2,Arg3,Arg4,Arg5);
 368
 369         function_callback_v5(CallBack c,Arg1 a1,Arg2 a2,Arg3 a3,Arg4 a4,Arg5 a5) :
 370             m_lpFunc(c),m_Arg1(a1),m_Arg2(a2),m_Arg3(a3),m_Arg4(a4),m_Arg5(a5) {}
 371
 372         virtual void run() {
 373             m_lpFunc(m_Arg1,m_Arg2,m_Arg3,m_Arg4,m_Arg5);
 374         }
 375
 376     private:
 377
 378         CallBack m_lpFunc;
 379         Arg1 m_Arg1;
 380         Arg2 m_Arg2;
 381         Arg3 m_Arg3;
 382         Arg4 m_Arg4;
 383         Arg5 m_Arg5;
 384
 385     };
 386
 387     //------------------------------------------------------------------
 388
 389     template<class obj>
 390     class function_callback_vm0 : public function_callback_v {
 391     public:
 392         typedef void (obj::*CallBack)();
 393
 394         function_callback_vm0(CallBack c,obj* p) : m_lpFunc(c),m_lpObj(p) {}
 395
 396         virtual void run() {
 397             (m_lpObj->*m_lpFunc)();
 398         }
 399
 400     private:
 401
 402         CallBack m_lpFunc;
 403         obj* m_lpObj;
 404
 405     };
 406
 407     template<class obj,class Arg1>
 408     class function_callback_vm1 : public function_callback_v {
 409     public:
 410         typedef void (obj::*CallBack)(Arg1);
 411
 412         function_callback_vm1(CallBack c,obj* p,Arg1 a1) :
 413             m_lpFunc(c),m_lpObj(p),m_Arg1(a1) {}
 414
 415         virtual void run() {
 416             (m_lpObj->*m_lpFunc)(m_Arg1);
 417         }
 418
 419     private:
 420
 421         CallBack m_lpFunc;
 422         obj* m_lpObj;
 423         Arg1 m_Arg1;
 424
 425     };
 426
 427     template<class obj,class Arg1,class Arg2>
 428     class function_callback_vm2 : public function_callback_v {
 429     public:
 430         typedef void (obj::*CallBack)(Arg1,Arg2);
 431
 432         function_callback_vm2(CallBack c,obj* p,Arg1 a1,Arg2 a2) :
 433             m_lpFunc(c),m_lpObj(p),m_Arg1(a1),m_Arg2(a2) {}
 434
 435         virtual void run() {
 436             (m_lpObj->*m_lpFunc)(m_Arg1,m_Arg2);
 437         }
 438
 439     private:
 440
 441         CallBack m_lpFunc;
 442         obj* m_lpObj;
 443         Arg1 m_Arg1;
 444         Arg2 m_Arg2;
 445
 446     };
 447
 448     template<class obj,class Arg1,class Arg2,class Arg3>
 449     class function_callback_vm3 : public function_callback_v {
 450     public:
 451         typedef void (obj::*CallBack)(Arg1,Arg2,Arg3);
 452
 453         function_callback_vm3(CallBack c,obj* p,Arg1 a1,Arg2 a2,Arg3 a3) :
 454             m_lpFunc(c),m_lpObj(p),m_Arg1(a1),m_Arg2(a2),m_Arg3(a3) {}
 455
 456         virtual void run() {
 457             (m_lpObj->*m_lpFunc)(m_Arg1,m_Arg2,m_Arg3);
 458         }
 459
 460     private:
 461
 462         CallBack m_lpFunc;
 463         obj* m_lpObj;
 464         Arg1 m_Arg1;
 465         Arg2 m_Arg2;
 466         Arg3 m_Arg3;
 467
 468     };
 469
 470     template<class obj,class Arg1,class Arg2,class Arg3,class Arg4>
 471     class function_callback_vm4 : public function_callback_v {
 472     public:
 473         typedef void (obj::*CallBack)(Arg1,Arg2,Arg3,Arg4);
 474
 475         function_callback_vm4(CallBack c,obj* p,Arg1 a1,Arg2 a2,Arg3 a3,Arg4 a4) :
 476             m_lpFunc(c),m_lpObj(p),m_Arg1(a1),m_Arg2(a2),m_Arg3(a3),m_Arg4(a4) {}
 477
 478         virtual void run() {
 479             (m_lpObj->*m_lpFunc)(m_Arg1,m_Arg2,m_Arg3,m_Arg4);
 480         }
 481
 482     private:
 483
 484         CallBack m_lpFunc;
 485         obj* m_lpObj;
 486         Arg1 m_Arg1;
 487         Arg2 m_Arg2;
 488         Arg3 m_Arg3;
 489         Arg4 m_Arg4;
 490
 491     };
 492
 493     template<class obj,class Arg1,class Arg2,class Arg3,class Arg4,class Arg5>
 494     class function_callback_vm5 : public function_callback_v {
 495     public:
 496         typedef void (obj::*CallBack)(Arg1,Arg2,Arg3,Arg4,Arg5);
 497
 498         function_callback_vm5(CallBack c,obj* p,Arg1 a1,Arg2 a2,Arg3 a3,Arg4 a4,Arg5 a5) :
 499             m_lpFunc(c),m_lpObj(p),m_Arg1(a1),m_Arg2(a2),m_Arg3(a3),m_Arg4(a4),m_Arg5(a5) {}
 500
 501         virtual void run() {
 502             (m_lpObj->*m_lpFunc)(m_Arg1,m_Arg2,m_Arg3,m_Arg4,m_Arg5);
 503         }
 504
 505     private:
 506
 507         CallBack m_lpFunc;
 508         obj* m_lpObj;
 509         Arg1 m_Arg1;
 510         Arg2 m_Arg2;
 511         Arg3 m_Arg3;
 512         Arg4 m_Arg4;
 513         Arg5 m_Arg5;
 514
 515     };
 516
 517     //-----------------------------------------------------------------------
 518
 519     template<class Result>
 520     class function_callback_r0 : public function_callback_r<Result> {
 521     public:
 522         typedef Result (*CallBack)();
 523
 524         function_callback_r0(CallBack c) : m_lpFunc(c) {}
 525
 526         virtual void run() {
 527             Result r = m_lpFunc();
 528             setResult(r);
 529         }
 530
 531     private:
 532
 533         CallBack m_lpFunc;
 534
 535     };
 536
 537     template<class Result,class T>
 538     class function_callback_rg0 : public function_callback_r<Result> {
 539     public:
 540         typedef Result (T::*CallBack)();
 541
 542         function_callback_rg0(CallBack c) : m_lpFunc(c) {}
 543
 544         virtual void run() {
 545             Result r = m_lpFunc();
 546             setResult(r);
 547         }
 548
 549     private:
 550
 551         CallBack m_lpFunc;
 552
 553     };
 554
 555     template<class Result,class Arg1>
 556     class function_callback_r1 : public function_callback_r<Result> {
 557     public:
 558         typedef Result (*CallBack)(Arg1);
 559
 560         function_callback_r1(CallBack c,Arg1 a1) : m_lpFunc(c),m_Arg1(a1) {}
 561
 562         virtual void run() {
 563             Result r = m_lpFunc(m_Arg1);
 564             setResult(r);
 565         }
 566
 567     private:
 568
 569         CallBack m_lpFunc;
 570         Arg1 m_Arg1;
 571
 572     };
 573
 574     template<class Result,class Arg1,class Arg2>
 575     class function_callback_r2 : public function_callback_r<Result> {
 576     public:
 577         typedef Result (*CallBack)(Arg1,Arg2);
 578
 579         function_callback_r2(CallBack c,Arg1 a1,Arg2 a2) : m_lpFunc(c),m_Arg1(a1),m_Arg2(a2) {}
 580
 581         virtual void run() {
 582             Result r = m_lpFunc(m_Arg1,m_Arg2);
 583             setResult(r);
 584         }
 585
 586     private:
 587
 588         CallBack m_lpFunc;
 589         Arg1 m_Arg1;
 590         Arg2 m_Arg2;
 591
 592     };
 593
 594     template<class Result,class Arg1,class Arg2,class Arg3>
 595     class function_callback_r3 : public function_callback_r<Result> {
 596     public:
 597         typedef Result (*CallBack)(Arg1,Arg2,Arg3);
 598
 599         function_callback_r3(CallBack c,Arg1 a1,Arg2 a2,Arg3 a3) :
 600             m_lpFunc(c),m_Arg1(a1),m_Arg2(a2),m_Arg3(a3) {}
 601
 602         virtual void run() {
 603             Result r = m_lpFunc(m_Arg1,m_Arg2,m_Arg3);
 604             setResult(r);
 605         }
 606
 607     private:
 608
 609         CallBack m_lpFunc;
 610         Arg1 m_Arg1;
 611         Arg2 m_Arg2;
 612         Arg3 m_Arg3;
 613
 614     };
 615
 616     template<class Result,class Arg1,class Arg2,class Arg3,class Arg4>
 617     class function_callback_r4 : public function_callback_r<Result> {
 618     public:
 619         typedef Result (*CallBack)(Arg1,Arg2,Arg3,Arg4);
 620
 621         function_callback_r4(CallBack c,Arg1 a1,Arg2 a2,Arg3 a3,Arg4 a4) :
 622             m_lpFunc(c),m_Arg1(a1),m_Arg2(a2),m_Arg3(a3),m_Arg4(a4) {}
 623
 624         virtual void run() {
 625             Result r = m_lpFunc(m_Arg1,m_Arg2,m_Arg3,m_Arg4);
 626             setResult(r);
 627         }
 628
 629     private:
 630
 631         CallBack m_lpFunc;
 632         Arg1 m_Arg1;
 633         Arg2 m_Arg2;
 634         Arg3 m_Arg3;
 635         Arg4 m_Arg4;
 636
 637     };
 638
 639     template<class Result,class Arg1,class Arg2,class Arg3,class Arg4,class Arg5>
 640     class function_callback_r5 : public function_callback_r<Result> {
 641     public:
 642         typedef Result (*CallBack)(Arg1,Arg2,Arg3,Arg4);
 643
 644         function_callback_r5(CallBack c,Arg1 a1,Arg2 a2,Arg3 a3,Arg4 a4,Arg5 a5) :
 645             m_lpFunc(c),m_Arg1(a1),m_Arg2(a2),m_Arg3(a3),m_Arg4(a4),m_Arg5(a5) {}
 646
 647         virtual void run() {
 648             Result r = m_lpFunc(m_Arg1,m_Arg2,m_Arg3,m_Arg4,m_Arg5);
 649             setResult(r);
 650         }
 651
 652     private:
 653
 654         CallBack m_lpFunc;
 655         Arg1 m_Arg1;
 656         Arg2 m_Arg2;
 657         Arg3 m_Arg3;
 658         Arg4 m_Arg4;
 659         Arg5 m_Arg5;
 660
 661     };
 662
 663     template<class Result,class T>
 664     class function_callback_rm0 : public function_callback_r<Result> {
 665     public:
 666         typedef Result (T::*CallBack)();
 667
 668         function_callback_rm0(CallBack c,T* p) : m_lpFunc(c),m_lpObj(p) {}
 669
 670         virtual void run() {
 671             Result r = (m_lpObj->*m_lpFunc)();
 672             setResult(r);
 673         }
 674
 675     private:
 676
 677         CallBack m_lpFunc;
 678         T* m_lpObj;
 679
 680     };
 681
 682     template<class Result,class T,class Arg1>
 683     class function_callback_rm1 : public function_callback_r<Result> {
 684     public:
 685         typedef Result (T::*CallBack)(Arg1);
 686
 687         function_callback_rm1(CallBack c,T* p,Arg1 a1) :
 688             m_lpFunc(c),m_lpObj(p),m_Arg1(a1) {}
 689
 690         virtual void run() {
 691             Result r = (m_lpObj->*m_lpFunc)(m_Arg1);
 692             setResult(r);
 693         }
 694
 695     private:
 696
 697         CallBack m_lpFunc;
 698         T* m_lpObj;
 699         Arg1 m_Arg1;
 700
 701     };
 702
 703     template<class Result,class T,class Arg1,class Arg2>
 704     class function_callback_rm2 : public function_callback_r<Result> {
 705     public:
 706         typedef Result (T::*CallBack)(Arg1,Arg2);
 707
 708         function_callback_rm2(CallBack c,T* p,Arg1 a1,Arg2 a2) :
 709             m_lpFunc(c),m_lpObj(p),m_Arg1(a1),m_Arg2(a2) {}
 710
 711         virtual void run() {
 712             Result r = (m_lpObj->*m_lpFunc)(m_Arg1,m_Arg2);
 713             setResult(r);
 714         }
 715
 716     private:
 717
 718         CallBack m_lpFunc;
 719         T* m_lpObj;
 720         Arg1 m_Arg1;
 721         Arg2 m_Arg2;
 722
 723     };
 724
 725     template<class Result,class T,class Arg1,class Arg2,class Arg3>
 726     class function_callback_rm3 : public function_callback_r<Result> {
 727     public:
 728         typedef Result (T::*CallBack)(Arg1,Arg2,Arg3);
 729
 730         function_callback_rm3(CallBack c,T* p,Arg1 a1,Arg2 a2,Arg3 a3) :
 731             m_lpFunc(c),m_lpObj(p),m_Arg1(a1),m_Arg2(a2),m_Arg3(a3) {}
 732
 733         virtual void run() {
 734             Result r = (m_lpObj->*m_lpFunc)(m_Arg1,m_Arg2,m_Arg3);
 735             setResult(r);
 736         }
 737
 738     private:
 739
 740         CallBack m_lpFunc;
 741         T* m_lpObj;
 742         Arg1 m_Arg1;
 743         Arg2 m_Arg2;
 744         Arg3 m_Arg3;
 745
 746     };
 747
 748     template<class Result,class T,class Arg1,class Arg2,class Arg3,class Arg4>
 749     class function_callback_rm4 : public function_callback_r<Result> {
 750     public:
 751         typedef Result (T::*CallBack)(Arg1,Arg2,Arg3,Arg4);
 752
 753         function_callback_rm4(CallBack c,T* p,Arg1 a1,Arg2 a2,Arg3 a3,Arg4 a4) :
 754             m_lpFunc(c),m_lpObj(p),m_Arg1(a1),m_Arg2(a2),m_Arg3(a3),m_Arg4(a4) {}
 755
 756         virtual void run() {
 757             Result r = (m_lpObj->*m_lpFunc)(m_Arg1,m_Arg2,m_Arg3,m_Arg4);
 758             setResult(r);
 759         }
 760
 761     private:
 762
 763         CallBack m_lpFunc;
 764         T* m_lpObj;
 765         Arg1 m_Arg1;
 766         Arg2 m_Arg2;
 767         Arg3 m_Arg3;
 768         Arg4 m_Arg4;
 769
 770     };
 771
 772     template<class Result,class T,class Arg1,class Arg2,class Arg3,class Arg4,class Arg5>
 773     class function_callback_rm5 : public function_callback_r<Result> {
 774     public:
 775         typedef Result (T::*CallBack)(Arg1,Arg2,Arg3,Arg4,Arg5);
 776
 777         function_callback_rm5(CallBack c,T* p,Arg1 a1,Arg2 a2,Arg3 a3,Arg4 a4,Arg5 a5) :
 778             m_lpFunc(c),m_lpObj(p),m_Arg1(a1),m_Arg2(a2),m_Arg3(a3),m_Arg4(a4),m_Arg5(a5) {}
 779
 780         virtual void run() {
 781             Result r = (m_lpObj->*m_lpFunc)(m_Arg1,m_Arg2,m_Arg3,m_Arg4,m_Arg5);
 782             setResult(r);
 783         }
 784
 785     private:
 786
 787         CallBack m_lpFunc;
 788         T* m_lpObj;
 789         Arg1 m_Arg1;
 790         Arg2 m_Arg2;
 791         Arg3 m_Arg3;
 792         Arg4 m_Arg4;
 793         Arg5 m_Arg5;
 794
 795     };
 796
 797
 798     // この関数のみ、実体が必要であるため、ここで定義する。
 799     inline function_callback_v* create(void (*f)(void))
 800     {
 801         return new function_callback_v0(f);
 802     }
 803
 804
 805 };
 806
 807 #endif