00001
00006
00007
00008
00009
00010
00011
00012
00013
00022
00024
00025 inline void CTBcallbackSource0::operator()()
00026 {
00027 if (m_shead) {
00028 Execute(0);
00029 }
00030 return;
00031 }
00032
00033
00042
00044
00045 template <class T>
00046 inline CTBcallbackTarget0<T>::CTBcallbackTarget0()
00047 : mp_this(0),
00048 mo_func(0)
00049 {}
00050
00051
00053
00054 template <class T>
00055 inline CTBcallbackTarget0<T>::CTBcallbackTarget0(
00056 const CTBcallbackTarget0<T>& rhs)
00057 : CTBcallbackTargetBase(rhs),
00058 mp_this(0),
00059 mo_func(0)
00060 {}
00061
00062
00064
00065 template <class T>
00066 inline CTBcallbackTarget0<T>::CTBcallbackTarget0(T* p_this,
00067 void (T::* o_func)())
00068 : mp_this(p_this),
00069 mo_func(o_func)
00070 {}
00071
00072
00074
00075 template <class T>
00076 inline CTBcallbackTarget0<T>::CTBcallbackTarget0(
00077 const CTBcallbackTarget0<T>& rhs,
00078 T* p_this, void (T::* o_func)())
00079 : CTBcallbackTargetBase(rhs),
00080 mp_this(p_this),
00081 mo_func(o_func)
00082 {}
00083
00084
00086
00087 template <class T>
00088 inline void CTBcallbackTarget0<T>::Configure(T* p_this,
00089 void (T::* o_func)())
00090 {
00091 mp_this = p_this;
00092 mo_func = o_func;
00093 return;
00094 }
00095
00096
00098
00099 template <class T>
00100 inline void CTBcallbackTarget0<T>::Connect(CTBcallbackSource0& source)
00101 {
00102 CTBcallbackTargetBase::Connect(source);
00103 return;
00104 }
00105
00106
00108
00109 template <class T>
00110 inline void CTBcallbackTarget0<T>::Disconnect(CTBcallbackSource0& source)
00111 {
00112 CTBcallbackTargetBase::Disconnect(source);
00113 return;
00114 }
00115
00116
00118
00119 template <class T>
00120 inline void CTBcallbackTarget0<T>::Execute(void* p_arg) const
00121 {
00122 if (mp_this) (mp_this->*mo_func)();
00123 return;
00124 }
00125
00126
00127
00136
00138
00139 template <class T1>
00140 inline void CTBcallbackSource1<T1>::operator()(T1 p1)
00141 {
00142 if (m_shead) {
00143 CTBcallbackArg1<T1> arg(p1);
00144 Execute(&arg);
00145 }
00146 return;
00147 }
00148
00149
00158
00160
00161 template <class T, class T1>
00162 inline CTBcallbackTarget1<T,T1>::CTBcallbackTarget1()
00163 : mp_this(0),
00164 mo_func(0)
00165 {}
00166
00167
00169
00170 template <class T, class T1>
00171 inline CTBcallbackTarget1<T,T1>::CTBcallbackTarget1(
00172 const CTBcallbackTarget1<T,T1>& rhs)
00173 : CTBcallbackTargetBase(rhs),
00174 mp_this(0),
00175 mo_func(0)
00176 {}
00177
00178
00180
00181 template <class T, class T1>
00182 inline CTBcallbackTarget1<T,T1>::CTBcallbackTarget1(T* p_this,
00183 void (T::* o_func)(T1))
00184 : mp_this(p_this),
00185 mo_func(o_func)
00186 {}
00187
00188
00190
00191 template <class T, class T1>
00192 inline CTBcallbackTarget1<T,T1>::CTBcallbackTarget1(
00193 const CTBcallbackTarget1<T,T1>& rhs,
00194 T* p_this, void (T::* o_func)(T1))
00195 : CTBcallbackTargetBase(rhs),
00196 mp_this(p_this),
00197 mo_func(o_func)
00198 {}
00199
00200
00202
00203 template <class T, class T1>
00204 inline void CTBcallbackTarget1<T,T1>::Configure(T* p_this,
00205 void (T::* o_func)(T1))
00206 {
00207 mp_this = p_this;
00208 mo_func = o_func;
00209 return;
00210 }
00211
00212
00214
00215 template <class T, class T1>
00216 inline void CTBcallbackTarget1<T,T1>::Connect(CTBcallbackSource1<T1>& source)
00217 {
00218 CTBcallbackTargetBase::Connect(source);
00219 return;
00220 }
00221
00222
00224
00225 template <class T, class T1>
00226 inline void CTBcallbackTarget1<T,T1>::Disconnect(CTBcallbackSource1<T1>& source)
00227 {
00228 CTBcallbackTargetBase::Disconnect(source);
00229 return;
00230 }
00231
00232
00234
00235 template <class T, class T1>
00236 inline void CTBcallbackTarget1<T,T1>::Execute(void* p_arg) const
00237 {
00238 CTBcallbackArg1<T1>* p = (CTBcallbackArg1<T1>*) p_arg;
00239 if (mp_this) (mp_this->*mo_func)(p->m_p1);
00240 return;
00241 }
00242
00243
00244 #ifdef DEV_DOCS
00245
00252 #endif
00253
00254
00256
00257 template <class T1>
00258 inline CTBcallbackArg1<T1>::CTBcallbackArg1(T1 p1)
00259 : m_p1(p1)
00260 {}
00261
00262
00263
00272
00274
00275 template <class T1, class T2>
00276 inline void CTBcallbackSource2<T1,T2>::operator()(T1 p1, T2 p2)
00277 {
00278 if (m_shead) {
00279 CTBcallbackArg2<T1,T2> arg(p1,p2);
00280 Execute(&arg);
00281 }
00282 return;
00283 }
00284
00285
00294
00296
00297 template <class T, class T1, class T2>
00298 inline CTBcallbackTarget2<T,T1,T2>::CTBcallbackTarget2()
00299 : mp_this(0),
00300 mo_func(0)
00301 {}
00302
00303
00305
00306 template <class T, class T1, class T2>
00307 inline CTBcallbackTarget2<T,T1,T2>::CTBcallbackTarget2(
00308 const CTBcallbackTarget2<T,T1,T2>& rhs)
00309 : CTBcallbackTargetBase(rhs),
00310 mp_this(0),
00311 mo_func(0)
00312 {}
00313
00314
00316
00317 template <class T, class T1, class T2>
00318 inline CTBcallbackTarget2<T,T1,T2>::CTBcallbackTarget2(T* p_this,
00319 void (T::* o_func)(T1,T2))
00320 : mp_this(p_this),
00321 mo_func(o_func)
00322 {}
00323
00324
00326
00327 template <class T, class T1, class T2>
00328 inline CTBcallbackTarget2<T,T1,T2>::CTBcallbackTarget2(
00329 const CTBcallbackTarget2<T,T1,T2>& rhs,
00330 T* p_this, void (T::* o_func)(T1,T2))
00331 : CTBcallbackTargetBase(rhs),
00332 mp_this(p_this),
00333 mo_func(o_func)
00334 {}
00335
00336
00338
00339 template <class T, class T1, class T2>
00340 inline void CTBcallbackTarget2<T,T1,T2>::Configure(T* p_this,
00341 void (T::* o_func)(T1,T2))
00342 {
00343 mp_this = p_this;
00344 mo_func = o_func;
00345 return;
00346 }
00347
00348
00350
00351 template <class T, class T1, class T2>
00352 inline void CTBcallbackTarget2<T,T1,T2>::Connect(
00353 CTBcallbackSource2<T1,T2>& source)
00354 {
00355 CTBcallbackTargetBase::Connect(source);
00356 return;
00357 }
00358
00359
00361
00362 template <class T, class T1, class T2>
00363 inline void CTBcallbackTarget2<T,T1,T2>::Disconnect(
00364 CTBcallbackSource2<T1,T2>& source)
00365 {
00366 CTBcallbackTargetBase::Disconnect(source);
00367 return;
00368 }
00369
00370
00372
00373 template <class T, class T1, class T2>
00374 inline void CTBcallbackTarget2<T,T1,T2>::Execute(void* p_arg) const
00375 {
00376 CTBcallbackArg2<T1,T2>* p = (CTBcallbackArg2<T1,T2>*) p_arg;
00377 if (mp_this) (mp_this->*mo_func)(p->m_p1, p->m_p2);
00378 return;
00379 }
00380
00381
00382 #ifdef DEV_DOCS
00383
00390 #endif
00391
00392
00394
00395 template <class T1, class T2>
00396 inline CTBcallbackArg2<T1,T2>::CTBcallbackArg2(T1 p1, T2 p2)
00397 : m_p1(p1),
00398 m_p2(p2)
00399 {}
00400
00401
00402
00411
00413
00414 template <class T1, class T2, class T3>
00415 inline void CTBcallbackSource3<T1,T2,T3>::operator()(T1 p1, T2 p2, T3 p3)
00416 {
00417 if (m_shead) {
00418 CTBcallbackArg3<T1,T2,T3> arg(p1,p2,p3);
00419 Execute(&arg);
00420 }
00421 return;
00422 }
00423
00424
00433
00435
00436 template <class T, class T1, class T2, class T3>
00437 inline CTBcallbackTarget3<T,T1,T2,T3>::CTBcallbackTarget3()
00438 : mp_this(0),
00439 mo_func(0)
00440 {}
00441
00442
00444
00445 template <class T, class T1, class T2, class T3>
00446 inline CTBcallbackTarget3<T,T1,T2,T3>::CTBcallbackTarget3(
00447 const CTBcallbackTarget3<T,T1,T2,T3>& rhs)
00448 : CTBcallbackTargetBase(rhs),
00449 mp_this(0),
00450 mo_func(0)
00451 {}
00452
00453
00455
00456 template <class T, class T1, class T2, class T3>
00457 inline CTBcallbackTarget3<T,T1,T2,T3>::CTBcallbackTarget3(T* p_this,
00458 void (T::* o_func)(T1,T2,T3))
00459 : mp_this(p_this),
00460 mo_func(o_func)
00461 {}
00462
00463
00465
00466 template <class T, class T1, class T2, class T3>
00467 inline CTBcallbackTarget3<T,T1,T2,T3>::CTBcallbackTarget3(
00468 const CTBcallbackTarget3<T,T1,T2,T3>& rhs,
00469 T* p_this, void (T::* o_func)(T1,T2,T3))
00470 : CTBcallbackTargetBase(rhs),
00471 mp_this(p_this),
00472 mo_func(o_func)
00473 {}
00474
00475
00477
00478 template <class T, class T1, class T2, class T3>
00479 inline void CTBcallbackTarget3<T,T1,T2,T3>::Configure(T* p_this,
00480 void (T::* o_func)(T1,T2,T3))
00481 {
00482 mp_this = p_this;
00483 mo_func = o_func;
00484 return;
00485 }
00486
00487
00489
00490 template <class T, class T1, class T2, class T3>
00491 inline void CTBcallbackTarget3<T,T1,T2,T3>::Connect(
00492 CTBcallbackSource3<T1,T2,T3>& source)
00493 {
00494 CTBcallbackTargetBase::Connect(source);
00495 return;
00496 }
00497
00498
00500
00501 template <class T, class T1, class T2, class T3>
00502 inline void CTBcallbackTarget3<T,T1,T2,T3>::Disconnect(
00503 CTBcallbackSource3<T1,T2,T3>& source)
00504 {
00505 CTBcallbackTargetBase::Disconnect(source);
00506 return;
00507 }
00508
00509
00511
00512 template <class T, class T1, class T2, class T3>
00513 inline void CTBcallbackTarget3<T,T1,T2,T3>::Execute(void* p_arg) const
00514 {
00515 CTBcallbackArg3<T1,T2,T3>* p = (CTBcallbackArg3<T1,T2,T3>*) p_arg;
00516 if (mp_this) (mp_this->*mo_func)(p->m_p1, p->m_p2, p->m_p3);
00517 return;
00518 }
00519
00520
00521 #ifdef DEV_DOCS
00522
00529 #endif
00530
00531
00533
00534 template <class T1, class T2, class T3>
00535 inline CTBcallbackArg3<T1,T2,T3>::CTBcallbackArg3(T1 p1, T2 p2, T3 p3)
00536 : m_p1(p1),
00537 m_p2(p2),
00538 m_p3(p3)
00539 {}
00540
00541
00542
00551
00553
00554 template <class T1, class T2, class T3, class T4>
00555 inline void CTBcallbackSource4<T1,T2,T3,T4>::operator()(T1 p1, T2 p2,
00556 T3 p3, T4 p4)
00557 {
00558 if (m_shead) {
00559 CTBcallbackArg4<T1,T2,T3,T4> arg(p1,p2,p3,p4);
00560 Execute(&arg);
00561 }
00562 return;
00563 }
00564
00565
00574
00576
00577 template <class T, class T1, class T2, class T3, class T4>
00578 inline CTBcallbackTarget4<T,T1,T2,T3,T4>::CTBcallbackTarget4()
00579 : mp_this(0),
00580 mo_func(0)
00581 {}
00582
00583
00585
00586 template <class T, class T1, class T2, class T3, class T4>
00587 inline CTBcallbackTarget4<T,T1,T2,T3,T4>::CTBcallbackTarget4(
00588 const CTBcallbackTarget4<T,T1,T2,T3,T4>& rhs)
00589 : CTBcallbackTargetBase(rhs),
00590 mp_this(0),
00591 mo_func(0)
00592 {}
00593
00594
00596
00597 template <class T, class T1, class T2, class T3, class T4>
00598 inline CTBcallbackTarget4<T,T1,T2,T3,T4>::CTBcallbackTarget4(T* p_this,
00599 void (T::* o_func)(T1,T2,T3,T4))
00600 : mp_this(p_this),
00601 mo_func(o_func)
00602 {}
00603
00604
00606
00607 template <class T, class T1, class T2, class T3, class T4>
00608 inline CTBcallbackTarget4<T,T1,T2,T3,T4>::CTBcallbackTarget4(
00609 const CTBcallbackTarget4<T,T1,T2,T3,T4>& rhs,
00610 T* p_this, void (T::* o_func)(T1,T2,T3,T4))
00611 : CTBcallbackTargetBase(rhs),
00612 mp_this(p_this),
00613 mo_func(o_func)
00614 {}
00615
00616
00618
00619 template <class T, class T1, class T2, class T3, class T4>
00620 inline void CTBcallbackTarget4<T,T1,T2,T3,T4>::Configure(T* p_this,
00621 void (T::* o_func)(T1,T2,T3,T4))
00622 {
00623 mp_this = p_this;
00624 mo_func = o_func;
00625 return;
00626 }
00627
00628
00630
00631 template <class T, class T1, class T2, class T3, class T4>
00632 inline void CTBcallbackTarget4<T,T1,T2,T3,T4>::Connect(
00633 CTBcallbackSource4<T1,T2,T3,T4>& source)
00634 {
00635 CTBcallbackTargetBase::Connect(source);
00636 return;
00637 }
00638
00639
00641
00642 template <class T, class T1, class T2, class T3, class T4>
00643 inline void CTBcallbackTarget4<T,T1,T2,T3,T4>::Disconnect(
00644 CTBcallbackSource4<T1,T2,T3,T4>& source)
00645 {
00646 CTBcallbackTargetBase::Disconnect(source);
00647 return;
00648 }
00649
00650
00652
00653 template <class T, class T1, class T2, class T3, class T4>
00654 inline void CTBcallbackTarget4<T,T1,T2,T3,T4>::Execute(void* p_arg) const
00655 {
00656 CTBcallbackArg4<T1,T2,T3,T4>* p = (CTBcallbackArg4<T1,T2,T3,T4>*) p_arg;
00657 if (mp_this) (mp_this->*mo_func)(p->m_p1, p->m_p2, p->m_p3, p->m_p4);
00658 return;
00659 }
00660
00661
00662 #ifdef DEV_DOCS
00663
00670 #endif
00671
00672
00674
00675 template <class T1, class T2, class T3, class T4>
00676 inline CTBcallbackArg4<T1,T2,T3,T4>::CTBcallbackArg4(T1 p1, T2 p2, T3 p3, T4 p4)
00677 : m_p1(p1),
00678 m_p2(p2),
00679 m_p3(p3),
00680 m_p4(p4)
00681 {}
00682
