1// BEGIN_Callable 10 2 /** 3 Callable represents a "callable" type, which is fundamentally 4 similar to an Invokable but is semantically richer. 5 */ 6 template <typename R, class A1 = Void, class A2 = Void, class A3 = Void, class A4 = Void, class A5 = Void, class A6 = Void, class A7 = Void, class A8 = Void, class A9 = Void, class A10 = Void> 7 class Callable : public Invokable<A1,A2,A3,A4,A5,A6,A7,A8,A9,A10> { 8 public: 9 typedef R ReturnT; 10 enum { NumArgs = 10 }; 11 12 public: 13 /** 14 Creates a copy of this object and returns it. Caller owns 15 the returned object. 16 */ 17 virtual Callable* clone() const = 0; 18 19 /** Exact behaviour is defined by subclass implementations. */ 20 virtual ReturnT operator()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) const = 0; 21 22 /** Same as calling this->operator()(...). */ 23 ReturnT call(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) const 24 { return this->operator()(a1,a2,a3,a4,a5,a6,a7,a8,a9,a10); } 25 26 /** Same as calling this->operator()(...), except that the return value 27 of that method is ignored. */ 28 void invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) const 29 { this->operator()(a1,a2,a3,a4,a5,a6,a7,a8,a9,a10); } 30 }; 31 32// END_Callable 10 33// BEGIN_Callable 9 34 // specialization 35 template <typename R,class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> 36 class Callable<R, A1,A2,A3,A4,A5,A6,A7,A8,A9,Void> : public Invokable<A1,A2,A3,A4,A5,A6,A7,A8,A9> { 37 public: 38 typedef R ReturnT; 39 enum { NumArgs = 9 }; 40 41 public: 42 /** 43 Creates a copy of this object and returns it. Caller owns 44 the returned object. 45 */ 46 virtual Callable* clone() const = 0; 47 48 /** Exact behaviour is defined by subclass implementations. */ 49 virtual ReturnT operator()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) const = 0; 50 51 /** Same as calling this->operator()(...). */ 52 ReturnT call(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) const 53 { return this->operator()(a1,a2,a3,a4,a5,a6,a7,a8,a9); } 54 55 /** Same as calling this->operator()(...), except that the return value 56 of that method is ignored. */ 57 void invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) const 58 { this->operator()(a1,a2,a3,a4,a5,a6,a7,a8,a9); } 59 }; 60 61// END_Callable 9 62// BEGIN_Callable 8 63 // specialization 64 template <typename R,class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> 65 class Callable<R, A1,A2,A3,A4,A5,A6,A7,A8,Void,Void> : public Invokable<A1,A2,A3,A4,A5,A6,A7,A8> { 66 public: 67 typedef R ReturnT; 68 enum { NumArgs = 8 }; 69 70 public: 71 /** 72 Creates a copy of this object and returns it. Caller owns 73 the returned object. 74 */ 75 virtual Callable* clone() const = 0; 76 77 /** Exact behaviour is defined by subclass implementations. */ 78 virtual ReturnT operator()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const = 0; 79 80 /** Same as calling this->operator()(...). */ 81 ReturnT call(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const 82 { return this->operator()(a1,a2,a3,a4,a5,a6,a7,a8); } 83 84 /** Same as calling this->operator()(...), except that the return value 85 of that method is ignored. */ 86 void invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const 87 { this->operator()(a1,a2,a3,a4,a5,a6,a7,a8); } 88 }; 89 90// END_Callable 8 91// BEGIN_Callable 7 92 // specialization 93 template <typename R,class A1, class A2, class A3, class A4, class A5, class A6, class A7> 94 class Callable<R, A1,A2,A3,A4,A5,A6,A7,Void,Void,Void> : public Invokable<A1,A2,A3,A4,A5,A6,A7> { 95 public: 96 typedef R ReturnT; 97 enum { NumArgs = 7 }; 98 99 public: 100 /** 101 Creates a copy of this object and returns it. Caller owns 102 the returned object. 103 */ 104 virtual Callable* clone() const = 0; 105 106 /** Exact behaviour is defined by subclass implementations. */ 107 virtual ReturnT operator()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const = 0; 108 109 /** Same as calling this->operator()(...). */ 110 ReturnT call(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const 111 { return this->operator()(a1,a2,a3,a4,a5,a6,a7); } 112 113 /** Same as calling this->operator()(...), except that the return value 114 of that method is ignored. */ 115 void invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const 116 { this->operator()(a1,a2,a3,a4,a5,a6,a7); } 117 }; 118 119// END_Callable 7 120// BEGIN_Callable 6 121 // specialization 122 template <typename R,class A1, class A2, class A3, class A4, class A5, class A6> 123 class Callable<R, A1,A2,A3,A4,A5,A6,Void,Void,Void,Void> : public Invokable<A1,A2,A3,A4,A5,A6> { 124 public: 125 typedef R ReturnT; 126 enum { NumArgs = 6 }; 127 128 public: 129 /** 130 Creates a copy of this object and returns it. Caller owns 131 the returned object. 132 */ 133 virtual Callable* clone() const = 0; 134 135 /** Exact behaviour is defined by subclass implementations. */ 136 virtual ReturnT operator()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const = 0; 137 138 /** Same as calling this->operator()(...). */ 139 ReturnT call(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const 140 { return this->operator()(a1,a2,a3,a4,a5,a6); } 141 142 /** Same as calling this->operator()(...), except that the return value 143 of that method is ignored. */ 144 void invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const 145 { this->operator()(a1,a2,a3,a4,a5,a6); } 146 }; 147 148// END_Callable 6 149// BEGIN_Callable 5 150 // specialization 151 template <typename R,class A1, class A2, class A3, class A4, class A5> 152 class Callable<R, A1,A2,A3,A4,A5,Void,Void,Void,Void,Void> : public Invokable<A1,A2,A3,A4,A5> { 153 public: 154 typedef R ReturnT; 155 enum { NumArgs = 5 }; 156 157 public: 158 /** 159 Creates a copy of this object and returns it. Caller owns 160 the returned object. 161 */ 162 virtual Callable* clone() const = 0; 163 164 /** Exact behaviour is defined by subclass implementations. */ 165 virtual ReturnT operator()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const = 0; 166 167 /** Same as calling this->operator()(...). */ 168 ReturnT call(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const 169 { return this->operator()(a1,a2,a3,a4,a5); } 170 171 /** Same as calling this->operator()(...), except that the return value 172 of that method is ignored. */ 173 void invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const 174 { this->operator()(a1,a2,a3,a4,a5); } 175 }; 176 177// END_Callable 5 178// BEGIN_Callable 4 179 // specialization 180 template <typename R,class A1, class A2, class A3, class A4> 181 class Callable<R, A1,A2,A3,A4,Void,Void,Void,Void,Void,Void> : public Invokable<A1,A2,A3,A4> { 182 public: 183 typedef R ReturnT; 184 enum { NumArgs = 4 }; 185 186 public: 187 /** 188 Creates a copy of this object and returns it. Caller owns 189 the returned object. 190 */ 191 virtual Callable* clone() const = 0; 192 193 /** Exact behaviour is defined by subclass implementations. */ 194 virtual ReturnT operator()(A1 a1, A2 a2, A3 a3, A4 a4) const = 0; 195 196 /** Same as calling this->operator()(...). */ 197 ReturnT call(A1 a1, A2 a2, A3 a3, A4 a4) const 198 { return this->operator()(a1,a2,a3,a4); } 199 200 /** Same as calling this->operator()(...), except that the return value 201 of that method is ignored. */ 202 void invoke(A1 a1, A2 a2, A3 a3, A4 a4) const 203 { this->operator()(a1,a2,a3,a4); } 204 }; 205 206// END_Callable 4 207// BEGIN_Callable 3 208 // specialization 209 template <typename R,class A1, class A2, class A3> 210 class Callable<R, A1,A2,A3,Void,Void,Void,Void,Void,Void,Void> : public Invokable<A1,A2,A3> { 211 public: 212 typedef R ReturnT; 213 enum { NumArgs = 3 }; 214 215 public: 216 /** 217 Creates a copy of this object and returns it. Caller owns 218 the returned object. 219 */ 220 virtual Callable* clone() const = 0; 221 222 /** Exact behaviour is defined by subclass implementations. */ 223 virtual ReturnT operator()(A1 a1, A2 a2, A3 a3) const = 0; 224 225 /** Same as calling this->operator()(...). */ 226 ReturnT call(A1 a1, A2 a2, A3 a3) const 227 { return this->operator()(a1,a2,a3); } 228 229 /** Same as calling this->operator()(...), except that the return value 230 of that method is ignored. */ 231 void invoke(A1 a1, A2 a2, A3 a3) const 232 { this->operator()(a1,a2,a3); } 233 }; 234 235// END_Callable 3 236// BEGIN_Callable 2 237 // specialization 238 template <typename R,class A1, class A2> 239 class Callable<R, A1,A2,Void,Void,Void,Void,Void,Void,Void,Void> : public Invokable<A1,A2> { 240 public: 241 typedef R ReturnT; 242 enum { NumArgs = 2 }; 243 244 public: 245 /** 246 Creates a copy of this object and returns it. Caller owns 247 the returned object. 248 */ 249 virtual Callable* clone() const = 0; 250 251 /** Exact behaviour is defined by subclass implementations. */ 252 virtual ReturnT operator()(A1 a1, A2 a2) const = 0; 253 254 /** Same as calling this->operator()(...). */ 255 ReturnT call(A1 a1, A2 a2) const 256 { return this->operator()(a1,a2); } 257 258 /** Same as calling this->operator()(...), except that the return value 259 of that method is ignored. */ 260 void invoke(A1 a1, A2 a2) const 261 { this->operator()(a1,a2); } 262 }; 263 264// END_Callable 2 265// BEGIN_Callable 1 266 // specialization 267 template <typename R,class A1> 268 class Callable<R, A1,Void,Void,Void,Void,Void,Void,Void,Void,Void> : public Invokable<A1> { 269 public: 270 typedef R ReturnT; 271 enum { NumArgs = 1 }; 272 273 public: 274 /** 275 Creates a copy of this object and returns it. Caller owns 276 the returned object. 277 */ 278 virtual Callable* clone() const = 0; 279 280 /** Exact behaviour is defined by subclass implementations. */ 281 virtual ReturnT operator()(A1 a1) const = 0; 282 283 /** Same as calling this->operator()(...). */ 284 ReturnT call(A1 a1) const 285 { return this->operator()(a1); } 286 287 /** Same as calling this->operator()(...), except that the return value 288 of that method is ignored. */ 289 void invoke(A1 a1) const 290 { this->operator()(a1); } 291 }; 292 293// END_Callable 1 294// BEGIN_Callable 0 295 // specialization 296 template <typename R> 297 class Callable<R, Void,Void,Void,Void,Void,Void,Void,Void,Void,Void> : public Invokable<> { 298 public: 299 typedef R ReturnT; 300 enum { NumArgs = 0 }; 301 302 public: 303 /** 304 Creates a copy of this object and returns it. Caller owns 305 the returned object. 306 */ 307 virtual Callable* clone() const = 0; 308 309 /** Exact behaviour is defined by subclass implementations. */ 310 virtual ReturnT operator()() const = 0; 311 312 /** Same as calling this->operator()(...). */ 313 ReturnT call() const 314 { return this->operator()(); } 315 316 /** Same as calling this->operator()(...), except that the return value 317 of that method is ignored. */ 318 void invoke() const 319 { this->operator()(); } 320 }; 321 322// END_Callable 0 323