src/callback.h

   1 // THIS IS A GENERATED FILE, RUN callback.pl to regenerate it
   2 // THIS IS A GENERATED FILE, RUN callback.pl to regenerate it
   3 // THIS IS A GENERATED FILE, RUN callback.pl to regenerate it
   4 // THIS IS A GENERATED FILE, RUN callback.pl to regenerate it
   5 // THIS IS A GENERATED FILE, RUN callback.pl to regenerate it
   6 // THIS IS A GENERATED FILE, RUN callback.pl to regenerate it
   7
   8 /*
   9     callback.h -- C++ callback mechanism
  10     Copyright (C) 2003 Marc Lehmann <pcg@goof.com>
  11
  12     This program is free software; you can redistribute it and/or modify
  13     it under the terms of the GNU General Public License as published by
  14     the Free Software Foundation; either version 2 of the License, or
  15     (at your option) any later version.
  16
  17     This program is distributed in the hope that it will be useful,
  18     but WITHOUT ANY WARRANTY; without even the implied warranty of
  19     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20     GNU General Public License for more details.
  21
  22     You should have received a copy of the GNU General Public License
  23     along with this program; if not, write to the Free Software
  24     Foundation, Inc. 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  25 */
  26
  27 #ifndef CALLBACK_H__
  28 #define CALLBACK_H__
  29
  30 template<class R>
  31 class callback0 {
  32   struct object { };
  33
  34   void *obj;
  35   R (object::*meth)();
  36
  37   /* a proxy is a kind of recipe on how to call a specific class method */
  38   struct proxy_base {
  39     virtual R call (void *obj, R (object::*meth)()) = 0;
  40   };
  41   template<class O1, class O2>
  42   struct proxy : proxy_base {
  43     virtual R call (void *obj, R (object::*meth)())
  44       {
  45         ((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)()>(meth)))
  46           ();
  47       }
  48   };
  49
  50   proxy_base *prxy;
  51
  52 public:
  53   template<class O1, class O2>
  54   callback0 (O1 *object, R (O2::*method)())
  55     {
  56       static proxy<O1,O2> p;
  57       obj  = reinterpret_cast<void *>(object);
  58       meth = reinterpret_cast<R (object::*)()>(method);
  59       prxy = &p;
  60     }
  61
  62   R call() const
  63     {
  64       return prxy->call (obj, meth);
  65     }
  66
  67   R operator ()() const
  68     {
  69       return call ();
  70     }
  71 };
  72
  73 template<class R, class A1>
  74 class callback1 {
  75   struct object { };
  76
  77   void *obj;
  78   R (object::*meth)(A1);
  79
  80   /* a proxy is a kind of recipe on how to call a specific class method */
  81   struct proxy_base {
  82     virtual R call (void *obj, R (object::*meth)(A1), A1 a1) = 0;
  83   };
  84   template<class O1, class O2>
  85   struct proxy : proxy_base {
  86     virtual R call (void *obj, R (object::*meth)(A1), A1 a1)
  87       {
  88         ((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1)>(meth)))
  89           (a1);
  90       }
  91   };
  92
  93   proxy_base *prxy;
  94
  95 public:
  96   template<class O1, class O2>
  97   callback1 (O1 *object, R (O2::*method)(A1))
  98     {
  99       static proxy<O1,O2> p;
 100       obj  = reinterpret_cast<void *>(object);
 101       meth = reinterpret_cast<R (object::*)(A1)>(method);
 102       prxy = &p;
 103     }
 104
 105   R call(A1 a1) const
 106     {
 107       return prxy->call (obj, meth, a1);
 108     }
 109
 110   R operator ()(A1 a1) const
 111     {
 112       return call (a1);
 113     }
 114 };
 115
 116 template<class R, class A1, class A2>
 117 class callback2 {
 118   struct object { };
 119
 120   void *obj;
 121   R (object::*meth)(A1, A2);
 122
 123   /* a proxy is a kind of recipe on how to call a specific class method */
 124   struct proxy_base {
 125     virtual R call (void *obj, R (object::*meth)(A1, A2), A1 a1, A2 a2) = 0;
 126   };
 127   template<class O1, class O2>
 128   struct proxy : proxy_base {
 129     virtual R call (void *obj, R (object::*meth)(A1, A2), A1 a1, A2 a2)
 130       {
 131         ((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1, A2)>(meth)))
 132           (a1, a2);
 133       }
 134   };
 135
 136   proxy_base *prxy;
 137
 138 public:
 139   template<class O1, class O2>
 140   callback2 (O1 *object, R (O2::*method)(A1, A2))
 141     {
 142       static proxy<O1,O2> p;
 143       obj  = reinterpret_cast<void *>(object);
 144       meth = reinterpret_cast<R (object::*)(A1, A2)>(method);
 145       prxy = &p;
 146     }
 147
 148   R call(A1 a1, A2 a2) const
 149     {
 150       return prxy->call (obj, meth, a1, a2);
 151     }
 152
 153   R operator ()(A1 a1, A2 a2) const
 154     {
 155       return call (a1, a2);
 156     }
 157 };
 158
 159 template<class R, class A1, class A2, class A3>
 160 class callback3 {
 161   struct object { };
 162
 163   void *obj;
 164   R (object::*meth)(A1, A2, A3);
 165
 166   /* a proxy is a kind of recipe on how to call a specific class method */
 167   struct proxy_base {
 168     virtual R call (void *obj, R (object::*meth)(A1, A2, A3), A1 a1, A2 a2, A3 a3) = 0;
 169   };
 170   template<class O1, class O2>
 171   struct proxy : proxy_base {
 172     virtual R call (void *obj, R (object::*meth)(A1, A2, A3), A1 a1, A2 a2, A3 a3)
 173       {
 174         ((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1, A2, A3)>(meth)))
 175           (a1, a2, a3);
 176       }
 177   };
 178
 179   proxy_base *prxy;
 180
 181 public:
 182   template<class O1, class O2>
 183   callback3 (O1 *object, R (O2::*method)(A1, A2, A3))
 184     {
 185       static proxy<O1,O2> p;
 186       obj  = reinterpret_cast<void *>(object);
 187       meth = reinterpret_cast<R (object::*)(A1, A2, A3)>(method);
 188       prxy = &p;
 189     }
 190
 191   R call(A1 a1, A2 a2, A3 a3) const
 192     {
 193       return prxy->call (obj, meth, a1, a2, a3);
 194     }
 195
 196   R operator ()(A1 a1, A2 a2, A3 a3) const
 197     {
 198       return call (a1, a2, a3);
 199     }
 200 };
 201
 202 template<class R, class A1, class A2, class A3, class A4>
 203 class callback4 {
 204   struct object { };
 205
 206   void *obj;
 207   R (object::*meth)(A1, A2, A3, A4);
 208
 209   /* a proxy is a kind of recipe on how to call a specific class method */
 210   struct proxy_base {
 211     virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4), A1 a1, A2 a2, A3 a3, A4 a4) = 0;
 212   };
 213   template<class O1, class O2>
 214   struct proxy : proxy_base {
 215     virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4), A1 a1, A2 a2, A3 a3, A4 a4)
 216       {
 217         ((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1, A2, A3, A4)>(meth)))
 218           (a1, a2, a3, a4);
 219       }
 220   };
 221
 222   proxy_base *prxy;
 223
 224 public:
 225   template<class O1, class O2>
 226   callback4 (O1 *object, R (O2::*method)(A1, A2, A3, A4))
 227     {
 228       static proxy<O1,O2> p;
 229       obj  = reinterpret_cast<void *>(object);
 230       meth = reinterpret_cast<R (object::*)(A1, A2, A3, A4)>(method);
 231       prxy = &p;
 232     }
 233
 234   R call(A1 a1, A2 a2, A3 a3, A4 a4) const
 235     {
 236       return prxy->call (obj, meth, a1, a2, a3, a4);
 237     }
 238
 239   R operator ()(A1 a1, A2 a2, A3 a3, A4 a4) const
 240     {
 241       return call (a1, a2, a3, a4);
 242     }
 243 };
 244
 245 template<class R, class A1, class A2, class A3, class A4, class A5>
 246 class callback5 {
 247   struct object { };
 248
 249   void *obj;
 250   R (object::*meth)(A1, A2, A3, A4, A5);
 251
 252   /* a proxy is a kind of recipe on how to call a specific class method */
 253   struct proxy_base {
 254     virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4, A5), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) = 0;
 255   };
 256   template<class O1, class O2>
 257   struct proxy : proxy_base {
 258     virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4, A5), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
 259       {
 260         ((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1, A2, A3, A4, A5)>(meth)))
 261           (a1, a2, a3, a4, a5);
 262       }
 263   };
 264
 265   proxy_base *prxy;
 266
 267 public:
 268   template<class O1, class O2>
 269   callback5 (O1 *object, R (O2::*method)(A1, A2, A3, A4, A5))
 270     {
 271       static proxy<O1,O2> p;
 272       obj  = reinterpret_cast<void *>(object);
 273       meth = reinterpret_cast<R (object::*)(A1, A2, A3, A4, A5)>(method);
 274       prxy = &p;
 275     }
 276
 277   R call(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
 278     {
 279       return prxy->call (obj, meth, a1, a2, a3, a4, a5);
 280     }
 281
 282   R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
 283     {
 284       return call (a1, a2, a3, a4, a5);
 285     }
 286 };
 287
 288 template<class R, class A1, class A2, class A3, class A4, class A5, class A6>
 289 class callback6 {
 290   struct object { };
 291
 292   void *obj;
 293   R (object::*meth)(A1, A2, A3, A4, A5, A6);
 294
 295   /* a proxy is a kind of recipe on how to call a specific class method */
 296   struct proxy_base {
 297     virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4, A5, A6), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) = 0;
 298   };
 299   template<class O1, class O2>
 300   struct proxy : proxy_base {
 301     virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4, A5, A6), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
 302       {
 303         ((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1, A2, A3, A4, A5, A6)>(meth)))
 304           (a1, a2, a3, a4, a5, a6);
 305       }
 306   };
 307
 308   proxy_base *prxy;
 309
 310 public:
 311   template<class O1, class O2>
 312   callback6 (O1 *object, R (O2::*method)(A1, A2, A3, A4, A5, A6))
 313     {
 314       static proxy<O1,O2> p;
 315       obj  = reinterpret_cast<void *>(object);
 316       meth = reinterpret_cast<R (object::*)(A1, A2, A3, A4, A5, A6)>(method);
 317       prxy = &p;
 318     }
 319
 320   R call(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
 321     {
 322       return prxy->call (obj, meth, a1, a2, a3, a4, a5, a6);
 323     }
 324
 325   R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
 326     {
 327       return call (a1, a2, a3, a4, a5, a6);
 328     }
 329 };
 330
 331 template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
 332 class callback7 {
 333   struct object { };
 334
 335   void *obj;
 336   R (object::*meth)(A1, A2, A3, A4, A5, A6, A7);
 337
 338   /* a proxy is a kind of recipe on how to call a specific class method */
 339   struct proxy_base {
 340     virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4, A5, A6, A7), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) = 0;
 341   };
 342   template<class O1, class O2>
 343   struct proxy : proxy_base {
 344     virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4, A5, A6, A7), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
 345       {
 346         ((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1, A2, A3, A4, A5, A6, A7)>(meth)))
 347           (a1, a2, a3, a4, a5, a6, a7);
 348       }
 349   };
 350
 351   proxy_base *prxy;
 352
 353 public:
 354   template<class O1, class O2>
 355   callback7 (O1 *object, R (O2::*method)(A1, A2, A3, A4, A5, A6, A7))
 356     {
 357       static proxy<O1,O2> p;
 358       obj  = reinterpret_cast<void *>(object);
 359       meth = reinterpret_cast<R (object::*)(A1, A2, A3, A4, A5, A6, A7)>(method);
 360       prxy = &p;
 361     }
 362
 363   R call(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
 364     {
 365       return prxy->call (obj, meth, a1, a2, a3, a4, a5, a6, a7);
 366     }
 367
 368   R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
 369     {
 370       return call (a1, a2, a3, a4, a5, a6, a7);
 371     }
 372 };
 373
 374 #endif