Main Page | Class Hierarchy | Alphabetical List | Class List | File List | Class Members

ucall.hpp

00001 /* ==================================================== ======== ======= *
00002  *
00003  *  ucall.hpp: callback objects
00004  *  Ubit Project  [Elc][2003]
00005  *  Author: Eric Lecolinet
00006  *
00007  *  Part of the Ubit Toolkit: A Brick Construction Game Model for Creating GUIs
00008  *
00009  *  (C) 1999-2003 Eric Lecolinet @ ENST Paris
00010  *  WWW: http://www.enst.fr/~elc/ubit   Email: elc@enst.fr (subject: ubit)
00011  *
00012  * ***********************************************************************
00013  * COPYRIGHT NOTICE : 
00014  * THIS PROGRAM IS DISTRIBUTED WITHOUT ANY WARRANTY AND WITHOUT EVEN THE 
00015  * IMPLIED WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. 
00016  * YOU CAN REDISTRIBUTE IT AND/OR MODIFY IT UNDER THE TERMS OF THE GNU 
00017  * GENERAL PUBLIC LICENSE AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
00018  * EITHER VERSION 2 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
00019  * SEE FILES 'COPYRIGHT' AND 'COPYING' FOR MORE DETAILS.
00020  * ***********************************************************************
00021  *
00022  * ==================================================== [Elc:03] ======= *
00023  * ==================================================== ======== ======= */
00024 
00025 #ifndef _ucall_hpp_
00026 #define _ucall_hpp_
00027 //pragma ident  "@(#)ucall.hpp  ubit:03.06.04"
00028 #include <ubit/ucond.hpp>
00029 
00133 class UGenCallImpl: public UBrick {
00134   virtual void addingTo(class ULink *selflink, UGroup *parent);
00135   virtual void removingFrom(class ULink *selflink, UGroup *parent);
00136   // NOTE that removingFrom() requires a destructor to be defined.
00137 public:
00138   UGenCallImpl() {}
00139   virtual ~UGenCallImpl() {destructs();}
00140 };
00141 
00142 template <class EE> 
00143 class UGenCall: public UGenCallImpl {
00144 public:
00145   virtual void call(EE&) = 0;
00146 };
00147 
00148 typedef UGenCall<class UEvent> UCall;
00149 typedef UGenCall<class UBrick> UListCall;
00150 
00151 /* ==================================================== [Elc:03] ======= */
00152 /* ==================================================== ======== ======= */
00153 
00154 template <class CC, class VAL, class EE>
00155 class UCall_show : public UGenCall<EE>{
00156   CC  obj;
00157   VAL val;
00158 public:
00159   UCall_show(CC _obj, VAL _val) : UCall(), obj(_obj), val(_val) {}
00160   void call(EE&) {obj->show(val);}
00161 };
00162 
00163 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00164 // ushow(a,b) will call 'a->show(b)'
00165 // 'a' must have a show() method that can take 'b' as an argument
00166 
00167 template <class CC, class VAL> 
00168 UCall& ushow(CC* obj, VAL val) 
00169 {return *(new UCall_show<CC*,VAL,UEvent>(obj, val));}
00170 
00171 template <class CC, class VAL> 
00172 UCall& ushowref(CC* obj, VAL& val) 
00173 {return *(new UCall_show<CC*,VAL&,UEvent>(obj, val));}
00174 
00175 /* ==================================================== ======== ======= */
00176 
00177 template <class CC, class VAL, class EE>
00178 class UCall_set : public UGenCall<EE>{
00179   CC  obj;
00180   VAL val;
00181 public:
00182   UCall_set(CC _obj, VAL _val) : UCall(), obj(_obj), val(_val) {}
00183   void call(EE&) {obj->set(val);}
00184 };
00185 
00186 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00187 // uset(a,b) will call 'a->set(b)'
00188 // 'a' must have a set() method that can take 'b' as an argument
00189 
00190 template <class CC, class VAL> 
00191 UCall& uset(CC* obj, VAL val) 
00192 {return *(new UCall_set<CC*,VAL,UEvent>(obj, val));}
00193 
00194 template <class CC, class VAL> 
00195 UCall& usetref(CC* obj, VAL& val) 
00196 {return *(new UCall_set<CC*,VAL&,UEvent>(obj, val));}
00197 
00198 /* ==================================================== ======== ======= */
00199 
00200 template <class CC, class VAL, class EE>
00201 class UCall_assign : public UGenCall<EE>{
00202   CC  obj;
00203   VAL val;
00204 public:
00205   UCall_assign(CC _obj, VAL _val) : UCall(), obj(_obj), val(_val) {}
00206   void call(EE&) {*obj = val;}
00207 };
00208 
00209 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00210 // uassign(a,b) will call 'a = b'
00211 
00212 template <class CC, class VAL> 
00213 UCall& uassign(CC* obj, VAL val) 
00214 {return *(new UCall_assign<CC*,VAL,UEvent>(obj, val));}
00215 
00216 template <class CC, class VAL> 
00217 UCall& uassignref(CC* obj, VAL& val) 
00218 {return *(new UCall_assign<CC*,VAL&,UEvent>(obj, val));}
00219 
00220 // ==================================================== [Elc:03] ======= 
00221 // ==================================================== ======== =======
00222 // Callback methods with NO argument:
00223 
00224 template <class CC, class RR, class MM, class EE> 
00225 class UCall_M_0a : public UGenCall<EE>{
00226   CC obj;
00227   RR (MM::*member)();
00228 public:
00229   UCall_M_0a(CC _obj, RR(MM::*mm)()) : obj(_obj), member(mm) {}
00230   void call(EE&) {(obj->*member)();}
00231 };
00232 
00233 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00234 
00235 template <class CC, class RR,  class MM, class EE> 
00236 class UCall_M_e0a : public UGenCall<EE> {
00237   CC obj;
00238   RR (MM::*member)(EE&);
00239 public:
00240   UCall_M_e0a(CC _obj, RR(MM::*mm)(EE&)) : obj(_obj), member(mm) {}
00241   void call(EE& e) {(obj->*member)(e);}
00242 };
00243 
00244 // ==================================================== ======== ======= 
00245 
00246 template <class CC, class RR, class MM> 
00247 UCall& ucall(CC* obj, RR(MM::*mm)()) 
00248 {return *(new UCall_M_0a<CC*,RR,MM,UEvent>(obj, mm));}
00249 
00250 template <class CC, class RR, class MM> 
00251 UCall& ucall(CC* obj, RR(MM::*mm)(UEvent&)) 
00252 {return *(new UCall_M_e0a<CC*,RR,MM,UEvent>(obj, mm));}
00253 
00254 template <class CC, class RR, class MM> 
00255 UListCall& ucall(CC* obj, RR(MM::*mm)(UBrick&)) 
00256 {return *(new UCall_M_e0a<CC*,RR,MM,UBrick>(obj, mm));}
00257 
00258 
00259 // ==================================================== [Elc:03] =======
00260 // ==================================================== ======== =======
00261 // Callback methods with ONE argument:
00262 
00263 template <class CC, class A1, class RR, class MM, class EE> 
00264 class UCall_M_1a : public UGenCall<EE> {
00265   CC obj;
00266   RR (MM::*member)(A1);
00267   A1 a1;
00268 public:
00269   UCall_M_1a(CC _obj, RR(MM::*mm)(A1), A1 _a1) : obj(_obj), member(mm), a1(_a1) {}
00270   void call(EE&) {(obj->*member)(a1);}
00271 };
00272 
00273 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00274 
00275 template <class CC, class A1, class RR, class MM, class EE> 
00276 class UCall_M_e1a : public UGenCall<EE> {
00277   CC obj;
00278   RR (MM::*member)(EE&, A1);
00279   A1 a1;
00280 public:
00281   UCall_M_e1a(CC _obj, RR(MM::*mm)(EE&,A1), A1 _a1) : obj(_obj), member(mm), a1(_a1) {}
00282   void call(EE& e) {(obj->*member)(e, a1);}
00283 };
00284 
00285 // ==================================================== ======== ======= 
00286 // passage par VALEUR:
00287 // NNN nouvelle version qui evite les ambiguites NNN :
00288 // methode a la fin / type retour RR / passage UEvent& ou UBrick& 
00289 
00290 template <class CC, class A1, class RR, class MM> 
00291 UCall& ucall(CC* obj, A1 a1, RR(MM::*mm)(A1)) 
00292 {return *(new UCall_M_1a<CC*,A1,RR,MM,UEvent>(obj, mm, a1));}
00293 
00294 template <class CC, class A1, class RR, class MM> 
00295 UCall& ucall(CC* obj, A1 a1, RR(MM::*mm)(UEvent&, A1)) 
00296 {return *(new UCall_M_e1a<CC*,A1,RR,MM,UEvent>(obj, mm, a1));}
00297 
00298 template <class CC, class A1, class RR, class MM> 
00299 UListCall& ucall(CC* obj, A1 a1, RR(MM::*mm)(UBrick&, A1)) 
00300 {return *(new UCall_M_e1a<CC*,A1,RR,MM,UBrick>(obj, mm, a1));}
00301 
00302 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00303 // passage par REFERENCE:
00304 
00305 template <class CC, class A1, class RR, class MM> 
00306 UCall& ucallref(CC* obj, A1& a1, RR(MM::*mm)(A1&))
00307 {return *(new UCall_M_1a<CC*,A1&,RR,MM,UEvent>(obj, mm, a1));}
00308 
00309 template <class CC, class A1, class RR, class MM> 
00310 UCall& ucallref(CC* obj, A1& a1, RR(MM::*mm)(UEvent&, A1&)) 
00311 {return *(new UCall_M_e1a<CC*,A1&,RR,MM,UEvent>(obj, mm, a1));}
00312 
00313 template <class CC, class A1, class RR, class MM> 
00314 UListCall& ucallref(CC* obj, A1& a1, RR(MM::*mm)(UBrick&, A1&)) 
00315 {return *(new UCall_M_e1a<CC*,A1&,RR,MM,UBrick>(obj, mm, a1));}
00316 
00317 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00318 // passage par CONST REFERENCE:
00319 
00320 template <class CC, class A1, class RR, class MM> 
00321 UCall& ucallref(CC* obj, const A1& a1, RR(MM::*mm)(const A1&))
00322 {return *(new UCall_M_1a<CC*,const A1&,RR,MM,UEvent>(obj, mm, a1));}
00323 
00324 template <class CC, class A1, class RR, class MM> 
00325 UCall& ucallref(CC* obj, const A1& a1, RR(MM::*mm)(UEvent&, const A1&)) 
00326 {return *(new UCall_M_e1a<CC*,const A1&,RR,MM,UEvent>(obj, mm, a1));}
00327 
00328 template <class CC, class A1, class RR, class MM> 
00329 UListCall& ucallref(CC* obj, const A1& a1, RR(MM::*mm)(UBrick&, const A1&)) 
00330 {return *(new UCall_M_e1a<CC*,const A1&,RR,MM,UBrick>(obj, mm, a1));}
00331 
00332 
00333 // ==================================================== [Elc:03] ======= 
00334 // ==================================================== ======== ======= 
00335 // Callback Methods with TWO arguments
00336 
00337 template <class CC, class A1, class A2, class RR, class MM, class EE> 
00338 class UCall_M_2a : public UGenCall<EE> {
00339   CC obj;
00340   RR (MM::*member)(A1, A2);
00341   A1 a1; A2 a2;
00342 public:
00343   UCall_M_2a(CC _obj, RR(MM::*mm)(A1,A2), A1 _a1, A2 _a2)
00344     : obj(_obj), member(mm), a1(_a1), a2(_a2) {} 
00345   void call(EE&) {(obj->*member)(a1, a2);}
00346 };
00347 
00348 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00349 
00350 template <class CC, class A1, class A2, class RR, class MM, class EE> 
00351 class UCall_M_e2a : public UGenCall<EE> {
00352   CC obj;
00353   RR (MM::*member)(EE&, A1, A2);
00354   A1 a1; A2 a2;
00355 public:
00356   UCall_M_e2a(CC _obj, RR(MM::*mm)(EE&,A1,A2), A1 _a1, A2 _a2)
00357     : obj(_obj), member(mm), a1(_a1), a2(_a2) {} 
00358   void call(EE& e) {(obj->*member)(e, a1, a2);}
00359 };
00360 
00361 // ==================================================== ======== ======= 
00362 // passage par VALEUR:
00363 
00364 template <class CC, class A1, class A2, class RR, class MM> 
00365 UCall& ucall(CC* obj, A1 a1, A2 a2, RR(MM::*mm)(A1,A2)) 
00366 {return *(new UCall_M_2a<CC*,A1,A2,RR,MM,UEvent>(obj, mm, a1, a2));}
00367 
00368 template <class CC, class A1, class A2, class RR, class MM> 
00369 UCall& ucall(CC* obj, A1 a1, A2 a2, RR(MM::*mm)(UEvent&,A1,A2)) 
00370 {return *(new UCall_M_e2a<CC*,A1,A2,RR,MM,UEvent>(obj, mm, a1, a2));}
00371 
00372 template <class CC, class A1, class A2, class RR, class MM> 
00373 UListCall& ucall(CC* obj, A1 a1, A2 a2, RR(MM::*mm)(UBrick&,A1,A2)) 
00374 {return *(new UCall_M_e2a<CC*,A1,A2,RR,MM,UBrick>(obj, mm, a1, a2));}
00375 
00376 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00377 // passage par REFERENCE:
00378 
00379 template <class CC, class A1, class A2, class RR, class MM> 
00380 UCall& ucallref(CC* obj, A1& a1, A2& a2, RR(MM::*mm)(A1&,A2&)) 
00381 {return *(new UCall_M_2a<CC*,A1&,A2&,RR,MM,UEvent>(obj, mm, a1, a2));}
00382 
00383 template <class CC, class A1, class A2, class RR, class MM> 
00384 UCall& ucallref(CC* obj, A1& a1, A2& a2, RR(MM::*mm)(UEvent&,A1&,A2&)) 
00385 {return *(new UCall_M_e2a<CC*,A1&,A2&,RR,MM,UEvent>(obj, mm, a1, a2));}
00386 
00387 template <class CC, class A1, class A2, class RR, class MM> 
00388 UListCall& ucallref(CC* obj, A1& a1, A2& a2, RR(MM::*mm)(UBrick&,A1&,A2&)) 
00389 {return *(new UCall_M_e2a<CC*,A1&,A2&,RR,MM,UBrick>(obj, mm, a1, a2));}
00390 
00391 
00392 /* ==================================================== [Elc:03] ======= */
00393 /* ==================================================== ======== ======= */
00394 // Callback Function with ONE argument
00395 
00396 template <class A1, class RR, class EE> 
00397 class UCall_F_1a : public UGenCall<EE> {
00398   RR (*fun)(A1);
00399   A1 a1;
00400 public:
00401   UCall_F_1a( RR(*f)(A1), A1 _a1) : fun(f), a1(_a1) {}
00402   void call(EE&) {(*fun)(a1);}
00403 };
00404 
00405 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00406 
00407 template <class A1, class RR, class EE> 
00408 class UCall_F_e1a : public UGenCall<EE> {
00409   RR (*fun)(EE&, A1);
00410   A1 a1;
00411 public:
00412   UCall_F_e1a( RR(*f)(EE&,A1), A1 _a1) : fun(f), a1(_a1) {}
00413   void call(EE& e) {(*fun)(e, a1);}
00414 };
00415 
00416 /* ==================================================== ======== ======= */
00417 // passage par VALEUR:
00418 
00419 template <class A1, class RR> 
00420 UCall& ucall(A1 a1, RR(*f)(A1)) 
00421 {return *(new UCall_F_1a<A1,RR,UEvent>(f, a1));}
00422 
00423 template <class A1, class RR> 
00424 UCall& ucall(A1 a1, RR(*f)(UEvent&,A1)) 
00425 {return *(new UCall_F_e1a<A1,RR,UEvent>(f, a1));}
00426 
00427 template <class A1, class RR> 
00428 UListCall& ucall(A1 a1, RR(*f)(UBrick&,A1)) 
00429 {return *(new UCall_F_e1a<A1,RR,UBrick>(f, a1));}
00430 
00431 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00432 // passage par REFERENCE:
00433 
00434 template <class A1, class RR> 
00435 UCall& ucallref(A1& a1, RR(*f)(A1&)) 
00436 {return *(new UCall_F_1a<A1&,RR,UEvent>(f, a1));}
00437 
00438 template <class A1, class RR> 
00439 UCall& ucallref(A1& a1, RR(*f)(UEvent&,A1&)) 
00440 {return *(new UCall_F_e1a<A1&,RR,UEvent>(f, a1));}
00441 
00442 template <class A1, class RR> 
00443 UListCall& ucallref(A1& a1, RR(*f)(UBrick&,A1&)) 
00444 {return *(new UCall_F_e1a<A1&,RR,UBrick>(f, a1));}
00445 
00446 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00447 // passage par CONST REFERENCE:
00448 
00449 template <class A1, class RR> 
00450 UCall& ucallref(const A1& a1, RR(*f)(const A1&)) 
00451 {return *(new UCall_F_1a<const A1&,RR,UEvent> (f, a1));}
00452 
00453 template <class A1, class RR> 
00454 UCall& ucallref(const A1& a1, RR(*f)(UEvent&,const A1&)) 
00455 {return *(new UCall_F_e1a<const A1&,RR,UEvent> (f, a1));}
00456 
00457 
00458 /* ==================================================== [Elc:03] ======= */
00459 /* ==================================================== ======== ======= */
00460 // Callback Function with TWO arguments
00461 
00462 template <class A1, class A2, class RR, class EE> 
00463 class UCall_F_2a : public UGenCall<EE>{
00464   RR (*fun)(A1, A2);
00465   A1 a1; A2 a2;
00466 public:
00467   UCall_F_2a( RR(*f)(A1,A2), A1 _a1, A2 _a2) : fun(f), a1(_a1), a2(_a2) {}
00468   void call(EE&) {(*fun)(a1, a2);}
00469 };
00470 
00471 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00472 
00473 template <class A1, class A2, class RR, class EE> 
00474 class UCall_F_e2a : public UGenCall<EE>{
00475   RR (*fun)(EE&, A1, A2);
00476   A1 a1; A2 a2;
00477 public:
00478   UCall_F_e2a( RR(*f)(EE&,A1,A2), A1 _a1, A2 _a2) : fun(f), a1(_a1), a2(_a2) {}
00479   void call(EE& e) {(*fun)(e, a1, a2);}
00480 };
00481 
00482 /* ==================================================== ======== ======= */
00483 // passage par VALEUR:
00484 
00485 template <class A1, class A2, class RR> 
00486 UCall& ucall(A1 a1, A2 a2, RR(*f)(A1,A2)) 
00487 {return *(new UCall_F_2a<A1,A2,RR,UEvent>(f, a1, a2));}
00488 
00489 template <class A1, class A2, class RR> 
00490 UCall& ucall(A1 a1, A2 a2, RR(*f)(UEvent&,A1,A2)) 
00491 {return *(new UCall_F_e2a<A1,A2,RR,UEvent>(f, a1, a2));}
00492 
00493 template <class A1, class A2, class RR> 
00494 UListCall& ucall(A1 a1, A2 a2, RR(*f)(UBrick&,A1,A2)) 
00495 {return *(new UCall_F_e2a<A1,A2,RR,UBrick>(f, a1, a2));}
00496 
00497 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00498 // passage par REFERENCE:
00499 
00500 template <class A1, class A2, class RR> 
00501 UCall& ucallref(A1& a1, A2& a2, RR(*f)(A1&,A2&))
00502 {return *(new UCall_F_2a<A1&,A2&,RR,UEvent>(f, a1, a2));}
00503 
00504 template <class A1, class A2, class RR> 
00505 UCall& ucallref(A1& a1, A2& a2, RR(*f)(UEvent&,A1&,A2&))
00506 {return *(new UCall_F_e2a<A1&,A2&,RR,UEvent>(f, a1, a2));}
00507 
00508 template <class A1, class A2, class RR> 
00509 UListCall& ucallref(A1& a1, A2& a2, RR(*f)(UBrick&,A1&,A2&))
00510 {return *(new UCall_F_e2a<A1&,A2&,RR,UBrick>(f, a1, a2));}
00511 
00512 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00513 // passage par CONST REFERENCE:
00514 
00515 template <class A1, class A2, class RR> 
00516 UCall& ucallref(const A1& a1, const A2& a2, RR(*f)(const A1&,const A2&))
00517 {return *(new UCall_F_2a<const A1&, const A2&,RR,UEvent>(f, a1, a2));}
00518 
00519 template <class A1, class A2, class RR> 
00520 UCall& ucallref(const A1& a1, const A2& a2, RR(*f)(UEvent&,const A1&,const A2&))
00521 {return *(new UCall_F_e2a<const A1&, const A2&,RR,UEvent>(f, a1, a2));}
00522 
00523 
00524 #endif
00525 /* ==================================================== [TheEnd] ======= */
00526 /* ==================================================== [Elc:03] ======= */

Generated on Thu Mar 3 06:40:10 2005 for Ubit[Eric.Lecolinet@enst.fr] by  doxygen 1.4.1