include/caller.h

   1 /*       +------------------------------------+
   2  *       | Inspire Internet Relay Chat Daemon |
   3  *       +------------------------------------+
   4  *
   5  *  InspIRCd: (C) 2002-2007 InspIRCd Development Team
   6  * See: http://www.inspircd.org/wiki/index.php/Credits
   7  *
   8  * This program is free but copyrighted software; see
   9  *            the file COPYING for details.
  10  *
  11  * ---------------------------------------------------
  12  */
  13
  14 #ifndef __CALLER__H__
  15 #define __CALLER__H__
  16
  17 /* The templates below can be auto generated by tools/create_templates.pl.
  18  * They are used to represent a functor with a given number of parameters and
  19  * a specific return type. To prevent passing the wrong number of parameters
  20  * and have the compiler detect this error at build-time, each class is numbered
  21  * according to the number of parameters it takes, e.g. caller0, caller1, caller2.
  22  * These have been generated from zero parameters to eight.
  23  *
  24  * If you want to declare a functor which takes two parameters, a userrec and a chanrec,
  25  * and returns bool, simply create it like this:
  26  *
  27  * caller2<bool, userrec*, chanrec*> MyFunction;
  28  *
  29  * and initialize it correctly, when placed into a class you will be able to call it:
  30  *
  31  * bool n = someclass->MyFunction(someuser, somechan);
  32  *
  33  * These functor templates work this way so that you can simply and easily allow
  34  * for these class methods to be overridden from within a module, e.g. have a module
  35  * which completely replaces the code for IsNick, etc. This is a very powerful feature
  36  * which should be considered 'advanced' and not for beginners. If you do not
  37  * understand these templates, STAY AWAY from playing with this until you do, as if
  38  * you get this wrong, this can generate some pretty long winded and confusing error
  39  * messages at compile time.
  40  */
  41
  42 template <typename ReturnType> class CoreExport HandlerBase0
  43 {
  44  public:
  45         virtual ReturnType Call() = 0;
  46         virtual ~HandlerBase0() { }
  47 };
  48
  49 template <typename ReturnType, typename Param1> class CoreExport HandlerBase1
  50 {
  51  public:
  52         virtual ReturnType Call(Param1) = 0;
  53         virtual ~HandlerBase1() { }
  54 };
  55
  56 template <typename ReturnType, typename Param1, typename Param2> class CoreExport HandlerBase2
  57 {
  58  public:
  59         virtual ReturnType Call(Param1, Param2) = 0;
  60         virtual ~HandlerBase2() { }
  61 };
  62
  63 template <typename ReturnType, typename Param1, typename Param2, typename Param3> class CoreExport HandlerBase3
  64 {
  65  public:
  66         virtual ReturnType Call(Param1, Param2, Param3) = 0;
  67         virtual ~HandlerBase3() { }
  68 };
  69
  70 template <typename ReturnType, typename Param1, typename Param2, typename Param3, typename Param4> class CoreExport HandlerBase4
  71 {
  72  public:
  73         virtual ReturnType Call(Param1, Param2, Param3, Param4) = 0;
  74         virtual ~HandlerBase4() { }
  75 };
  76
  77 template <typename ReturnType, typename Param1, typename Param2, typename Param3, typename Param4, typename Param5> class CoreExport HandlerBase5
  78 {
  79  public:
  80         virtual ReturnType Call(Param1, Param2, Param3, Param4, Param5) = 0;
  81         virtual ~HandlerBase5() { }
  82 };
  83
  84 template <typename ReturnType, typename Param1, typename Param2, typename Param3, typename Param4, typename Param5, typename Param6> class CoreExport HandlerBase6
  85 {
  86  public:
  87         virtual ReturnType Call(Param1, Param2, Param3, Param4, Param5, Param6) = 0;
  88         virtual ~HandlerBase6() { }
  89 };
  90
  91 template <typename ReturnType, typename Param1, typename Param2, typename Param3, typename Param4, typename Param5, typename Param6, typename Param7> class CoreExport HandlerBase7
  92 {
  93  public:
  94         virtual ReturnType Call(Param1, Param2, Param3, Param4, Param5, Param6, Param7) = 0;
  95         virtual ~HandlerBase7() { }
  96 };
  97
  98 template <typename ReturnType, typename Param1, typename Param2, typename Param3, typename Param4, typename Param5, typename Param6, typename Param7, typename Param8> class CoreExport HandlerBase8
  99 {
 100  public:
 101         virtual ReturnType Call(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8) = 0;
 102         virtual ~HandlerBase8() { }
 103 };
 104
 105 template <typename HandlerType> class CoreExport caller
 106 {
 107  public:
 108         HandlerType* target;
 109
 110         caller(HandlerType* initial)
 111         : target(initial)
 112         { }
 113
 114         virtual ~caller() { }
 115
 116         caller& operator=(HandlerType* newtarget)
 117         {
 118                 target = newtarget;
 119                 return *this;
 120         }
 121 };
 122
 123 template <typename ReturnType> class CoreExport caller0 : public caller< HandlerBase0<ReturnType> >
 124 {
 125  public:
 126         caller0(HandlerBase0<ReturnType>* initial)
 127         : caller< HandlerBase0<ReturnType> >::caller(initial)
 128         { }
 129
 130         virtual ReturnType operator() ()
 131         {
 132                 return this->target->Call();
 133         }
 134 };
 135
 136 template <typename ReturnType, typename Param1> class CoreExport caller1 : public caller< HandlerBase1<ReturnType, Param1> >
 137 {
 138  public:
 139         caller1(HandlerBase1<ReturnType, Param1>* initial)
 140         : caller< HandlerBase1<ReturnType, Param1> >::caller(initial)
 141         { }
 142
 143         virtual ReturnType operator() (Param1 param1)
 144         {
 145                 return this->target->Call(param1);
 146         }
 147 };
 148
 149 template <typename ReturnType, typename Param1, typename Param2> class CoreExport caller2 : public caller< HandlerBase2<ReturnType, Param1, Param2> >
 150 {
 151  public:
 152         caller2(HandlerBase2<ReturnType, Param1, Param2>* initial)
 153         : caller< HandlerBase2<ReturnType, Param1, Param2> >::caller(initial)
 154         { }
 155
 156         virtual ReturnType operator() (Param1 param1, Param2 param2)
 157         {
 158                 return this->target->Call(param1, param2);
 159         }
 160 };
 161
 162 template <typename ReturnType, typename Param1, typename Param2, typename Param3> class CoreExport caller3 : public caller< HandlerBase3<ReturnType, Param1, Param2, Param3> >
 163 {
 164  public:
 165         caller3(HandlerBase3<ReturnType, Param1, Param2, Param3>* initial)
 166         : caller< HandlerBase3<ReturnType, Param1, Param2, Param3> >::caller(initial)
 167         { }
 168
 169         virtual ReturnType operator() (Param1 param1, Param2 param2, Param3 param3)
 170         {
 171                 return this->target->Call(param1, param2, param3);
 172         }
 173 };
 174
 175 template <typename ReturnType, typename Param1, typename Param2, typename Param3, typename Param4> class CoreExport caller4 : public caller< HandlerBase4<ReturnType, Param1, Param2, Param3, Param4> >
 176 {
 177  public:
 178         caller4(HandlerBase4<ReturnType, Param1, Param2, Param3, Param4>* initial)
 179         : caller< HandlerBase4<ReturnType, Param1, Param2, Param3, Param4> >::caller(initial)
 180         { }
 181
 182         virtual ReturnType operator() (Param1 param1, Param2 param2, Param3 param3, Param4 param4)
 183         {
 184                 return this->target->Call(param1, param2, param3, param4);
 185         }
 186 };
 187
 188 template <typename ReturnType, typename Param1, typename Param2, typename Param3, typename Param4, typename Param5> class CoreExport caller5 : public caller< HandlerBase5<ReturnType, Param1, Param2, Param3, Param4, Param5> >
 189 {
 190  public:
 191         caller5(HandlerBase5<ReturnType, Param1, Param2, Param3, Param4, Param5>* initial)
 192         : caller< HandlerBase5<ReturnType, Param1, Param2, Param3, Param4, Param5> >::caller(initial)
 193         { }
 194
 195         virtual ReturnType operator() (Param1 param1, Param2 param2, Param3 param3, Param4 param4, Param5 param5)
 196         {
 197                 return this->target->Call(param1, param2, param3, param4, param5);
 198         }
 199 };
 200
 201 template <typename ReturnType, typename Param1, typename Param2, typename Param3, typename Param4, typename Param5, typename Param6> class CoreExport caller6 : public caller< HandlerBase6<ReturnType, Param1, Param2, Param3, Param4, Param5, Param6> >
 202 {
 203  public:
 204         caller6(HandlerBase6<ReturnType, Param1, Param2, Param3, Param4, Param5, Param6>* initial)
 205         : caller< HandlerBase6<ReturnType, Param1, Param2, Param3, Param4, Param5, Param6> >::caller(initial)
 206         { }
 207
 208         virtual ReturnType operator() (Param1 param1, Param2 param2, Param3 param3, Param4 param4, Param5 param5, Param6 param6)
 209         {
 210                 return this->target->Call(param1, param2, param3, param4, param5, param6);
 211         }
 212 };
 213
 214 template <typename ReturnType, typename Param1, typename Param2, typename Param3, typename Param4, typename Param5, typename Param6, typename Param7> class CoreExport caller7 : public caller< HandlerBase7<ReturnType, Param1, Param2, Param3, Param4, Param5, Param6, Param7> >
 215 {
 216  public:
 217         caller7(HandlerBase7<ReturnType, Param1, Param2, Param3, Param4, Param5, Param6, Param7>* initial)
 218         : caller< HandlerBase7<ReturnType, Param1, Param2, Param3, Param4, Param5, Param6, Param7> >::caller(initial)
 219         { }
 220
 221         virtual ReturnType operator() (Param1 param1, Param2 param2, Param3 param3, Param4 param4, Param5 param5, Param6 param6, Param7 param7)
 222         {
 223                 return this->target->Call(param1, param2, param3, param4, param5, param6, param7);
 224         }
 225 };
 226
 227 template <typename ReturnType, typename Param1, typename Param2, typename Param3, typename Param4, typename Param5, typename Param6, typename Param7, typename Param8> class CoreExport caller8 : public caller< HandlerBase8<ReturnType, Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8> >
 228 {
 229  public:
 230         caller8(HandlerBase8<ReturnType, Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8>* initial)
 231         : caller< HandlerBase8<ReturnType, Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8> >::caller(initial)
 232         { }
 233
 234         virtual ReturnType operator() (Param1 param1, Param2 param2, Param3 param3, Param4 param4, Param5 param5, Param6 param6, Param7 param7, Param8 param8)
 235         {
 236                 return this->target->Call(param1, param2, param3, param4, param5, param6, param7, param8);
 237         }
 238 };
 239
 240 #endif
 241