Home · Modules · All Classes · All Namespaces
callbacks.h
1 
23 #ifndef _TelepathyQt_callbacks_h_HEADER_GUARD_
24 #define _TelepathyQt_callbacks_h_HEADER_GUARD_
25 
26 #ifndef IN_TP_QT_HEADER
27 #error IN_TP_QT_HEADER
28 #endif
29 
30 #include <TelepathyQt/Functors>
31 #include <TelepathyQt/Global>
32 
33 namespace Tp
34 {
35 
36 struct TP_QT_EXPORT AbstractFunctorCaller
37 {
38  typedef void *(*HookType)(void*);
39 
40  AbstractFunctorCaller(HookType invokeMethodHook) : invokeMethodHook(invokeMethodHook) {}
42 
43  virtual AbstractFunctorCaller *clone() const = 0;
44 
45  HookType invokeMethodHook;
46 
47 private:
49  AbstractFunctorCaller &operator=(const AbstractFunctorCaller &other);
50 };
51 
52 template <class T, class Functor>
54 {
57  functor(functor) {}
58  virtual ~BaseFunctorCaller() {}
59 
60  virtual AbstractFunctorCaller *clone() const { return new T(functor); }
61 
62  Functor functor;
63 };
64 
65 struct TP_QT_EXPORT BaseCallback
66 {
67  BaseCallback() : caller(0) {}
68  /* takes ownership of caller */
69  BaseCallback(AbstractFunctorCaller *caller) : caller(caller) {}
70  BaseCallback(const BaseCallback &other) : caller(other.caller->clone()) {}
71  virtual ~BaseCallback() { delete caller; }
72 
73  bool isValid() const { return caller != 0; }
74 
76  {
77  if (caller == other.caller) return *this;
78  delete caller;
79  caller = other.caller->clone();
80  return *this;
81  }
82 
83 protected:
84  /* may be null */
86 };
87 
88 template <class Functor, class R >
89 struct FunctorCaller0 : public BaseFunctorCaller<FunctorCaller0<Functor, R >, Functor>
90 {
91  typedef R ResultType;
93 
94  explicit FunctorCaller0(const Functor &functor) : BaseFunctorCaller<FunctorCaller0, Functor>(functor, reinterpret_cast<AbstractFunctorCaller::HookType>(&FunctorCaller0<Functor, R >::invoke)) {}
95 
97  {
98  typedef FunctorCaller0<Functor, R > Type;
99  Type *typed = static_cast<Type*>(call);
100  return (typed->functor)();
101  }
102 };
103 
104 template <class R >
105 struct Callback0 : public BaseCallback
106 {
107  typedef R (*FunctionType)();
108  typedef R ResultType;
109 
111  template <class Functor>
112  Callback0(const Functor &functor) : BaseCallback(new FunctorCaller0<Functor, R >(functor)) {}
113 
115  {
116  if (caller) {
117  typedef R (*InvokeType)(AbstractFunctorCaller* );
118  InvokeType invokeMethod = reinterpret_cast<InvokeType>(caller->invokeMethodHook);
119  return invokeMethod(caller );
120  }
121  return ResultType();
122  }
123 };
124 
125 template <class Functor, class R , class Arg1>
126 struct FunctorCaller1 : public BaseFunctorCaller<FunctorCaller1<Functor, R , Arg1>, Functor>
127 {
128  typedef R ResultType;
129  typedef R (*InvokeType)(AbstractFunctorCaller* , Arg1);
130 
131  explicit FunctorCaller1(const Functor &functor) : BaseFunctorCaller<FunctorCaller1, Functor>(functor, reinterpret_cast<AbstractFunctorCaller::HookType>(&FunctorCaller1<Functor, R , Arg1>::invoke)) {}
132 
133  static ResultType invoke(AbstractFunctorCaller *call , Arg1 a1)
134  {
136  Type *typed = static_cast<Type*>(call);
137  return (typed->functor)(a1);
138  }
139 };
140 
141 template <class R , class Arg1>
142 struct Callback1 : public BaseCallback
143 {
144  typedef R (*FunctionType)(Arg1);
145  typedef R ResultType;
146 
148  template <class Functor>
149  Callback1(const Functor &functor) : BaseCallback(new FunctorCaller1<Functor, R , Arg1>(functor)) {}
150 
151  ResultType operator()(Arg1 a1) const
152  {
153  if (caller) {
154  typedef R (*InvokeType)(AbstractFunctorCaller* , Arg1);
155  InvokeType invokeMethod = reinterpret_cast<InvokeType>(caller->invokeMethodHook);
156  return invokeMethod(caller , a1);
157  }
158  return ResultType();
159  }
160 };
161 
162 template <class Functor, class R , class Arg1, class Arg2>
163 struct FunctorCaller2 : public BaseFunctorCaller<FunctorCaller2<Functor, R , Arg1, Arg2>, Functor>
164 {
165  typedef R ResultType;
166  typedef R (*InvokeType)(AbstractFunctorCaller* , Arg1, Arg2);
167 
168  explicit FunctorCaller2(const Functor &functor) : BaseFunctorCaller<FunctorCaller2, Functor>(functor, reinterpret_cast<AbstractFunctorCaller::HookType>(&FunctorCaller2<Functor, R , Arg1, Arg2>::invoke)) {}
169 
170  static ResultType invoke(AbstractFunctorCaller *call , Arg1 a1, Arg2 a2)
171  {
173  Type *typed = static_cast<Type*>(call);
174  return (typed->functor)(a1, a2);
175  }
176 };
177 
178 template <class R , class Arg1, class Arg2>
179 struct Callback2 : public BaseCallback
180 {
181  typedef R (*FunctionType)(Arg1, Arg2);
182  typedef R ResultType;
183 
185  template <class Functor>
186  Callback2(const Functor &functor) : BaseCallback(new FunctorCaller2<Functor, R , Arg1, Arg2>(functor)) {}
187 
188  ResultType operator()(Arg1 a1, Arg2 a2) const
189  {
190  if (caller) {
191  typedef R (*InvokeType)(AbstractFunctorCaller* , Arg1, Arg2);
192  InvokeType invokeMethod = reinterpret_cast<InvokeType>(caller->invokeMethodHook);
193  return invokeMethod(caller , a1, a2);
194  }
195  return ResultType();
196  }
197 };
198 
199 template <class Functor, class R , class Arg1, class Arg2, class Arg3>
200 struct FunctorCaller3 : public BaseFunctorCaller<FunctorCaller3<Functor, R , Arg1, Arg2, Arg3>, Functor>
201 {
202  typedef R ResultType;
203  typedef R (*InvokeType)(AbstractFunctorCaller* , Arg1, Arg2, Arg3);
204 
205  explicit FunctorCaller3(const Functor &functor) : BaseFunctorCaller<FunctorCaller3, Functor>(functor, reinterpret_cast<AbstractFunctorCaller::HookType>(&FunctorCaller3<Functor, R , Arg1, Arg2, Arg3>::invoke)) {}
206 
207  static ResultType invoke(AbstractFunctorCaller *call , Arg1 a1, Arg2 a2, Arg3 a3)
208  {
210  Type *typed = static_cast<Type*>(call);
211  return (typed->functor)(a1, a2, a3);
212  }
213 };
214 
215 template <class R , class Arg1, class Arg2, class Arg3>
216 struct Callback3 : public BaseCallback
217 {
218  typedef R (*FunctionType)(Arg1, Arg2, Arg3);
219  typedef R ResultType;
220 
222  template <class Functor>
223  Callback3(const Functor &functor) : BaseCallback(new FunctorCaller3<Functor, R , Arg1, Arg2, Arg3>(functor)) {}
224 
225  ResultType operator()(Arg1 a1, Arg2 a2, Arg3 a3) const
226  {
227  if (caller) {
228  typedef R (*InvokeType)(AbstractFunctorCaller* , Arg1, Arg2, Arg3);
229  InvokeType invokeMethod = reinterpret_cast<InvokeType>(caller->invokeMethodHook);
230  return invokeMethod(caller , a1, a2, a3);
231  }
232  return ResultType();
233  }
234 };
235 
236 template <class Functor, class R , class Arg1, class Arg2, class Arg3, class Arg4>
237 struct FunctorCaller4 : public BaseFunctorCaller<FunctorCaller4<Functor, R , Arg1, Arg2, Arg3, Arg4>, Functor>
238 {
239  typedef R ResultType;
240  typedef R (*InvokeType)(AbstractFunctorCaller* , Arg1, Arg2, Arg3, Arg4);
241 
242  explicit FunctorCaller4(const Functor &functor) : BaseFunctorCaller<FunctorCaller4, Functor>(functor, reinterpret_cast<AbstractFunctorCaller::HookType>(&FunctorCaller4<Functor, R , Arg1, Arg2, Arg3, Arg4>::invoke)) {}
243 
244  static ResultType invoke(AbstractFunctorCaller *call , Arg1 a1, Arg2 a2, Arg3 a3, Arg4 a4)
245  {
247  Type *typed = static_cast<Type*>(call);
248  return (typed->functor)(a1, a2, a3, a4);
249  }
250 };
251 
252 template <class R , class Arg1, class Arg2, class Arg3, class Arg4>
253 struct Callback4 : public BaseCallback
254 {
255  typedef R (*FunctionType)(Arg1, Arg2, Arg3, Arg4);
256  typedef R ResultType;
257 
259  template <class Functor>
260  Callback4(const Functor &functor) : BaseCallback(new FunctorCaller4<Functor, R , Arg1, Arg2, Arg3, Arg4>(functor)) {}
261 
262  ResultType operator()(Arg1 a1, Arg2 a2, Arg3 a3, Arg4 a4) const
263  {
264  if (caller) {
265  typedef R (*InvokeType)(AbstractFunctorCaller* , Arg1, Arg2, Arg3, Arg4);
266  InvokeType invokeMethod = reinterpret_cast<InvokeType>(caller->invokeMethodHook);
267  return invokeMethod(caller , a1, a2, a3, a4);
268  }
269  return ResultType();
270  }
271 };
272 
273 template <class Functor, class R , class Arg1, class Arg2, class Arg3, class Arg4, class Arg5>
274 struct FunctorCaller5 : public BaseFunctorCaller<FunctorCaller5<Functor, R , Arg1, Arg2, Arg3, Arg4, Arg5>, Functor>
275 {
276  typedef R ResultType;
277  typedef R (*InvokeType)(AbstractFunctorCaller* , Arg1, Arg2, Arg3, Arg4, Arg5);
278 
279  explicit FunctorCaller5(const Functor &functor) : BaseFunctorCaller<FunctorCaller5, Functor>(functor, reinterpret_cast<AbstractFunctorCaller::HookType>(&FunctorCaller5<Functor, R , Arg1, Arg2, Arg3, Arg4, Arg5>::invoke)) {}
280 
281  static ResultType invoke(AbstractFunctorCaller *call , Arg1 a1, Arg2 a2, Arg3 a3, Arg4 a4, Arg5 a5)
282  {
284  Type *typed = static_cast<Type*>(call);
285  return (typed->functor)(a1, a2, a3, a4, a5);
286  }
287 };
288 
289 template <class R , class Arg1, class Arg2, class Arg3, class Arg4, class Arg5>
290 struct Callback5 : public BaseCallback
291 {
292  typedef R (*FunctionType)(Arg1, Arg2, Arg3, Arg4, Arg5);
293  typedef R ResultType;
294 
296  template <class Functor>
297  Callback5(const Functor &functor) : BaseCallback(new FunctorCaller5<Functor, R , Arg1, Arg2, Arg3, Arg4, Arg5>(functor)) {}
298 
299  ResultType operator()(Arg1 a1, Arg2 a2, Arg3 a3, Arg4 a4, Arg5 a5) const
300  {
301  if (caller) {
302  typedef R (*InvokeType)(AbstractFunctorCaller* , Arg1, Arg2, Arg3, Arg4, Arg5);
303  InvokeType invokeMethod = reinterpret_cast<InvokeType>(caller->invokeMethodHook);
304  return invokeMethod(caller , a1, a2, a3, a4, a5);
305  }
306  return ResultType();
307  }
308 };
309 
310 template <class Functor, class R , class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6>
311 struct FunctorCaller6 : public BaseFunctorCaller<FunctorCaller6<Functor, R , Arg1, Arg2, Arg3, Arg4, Arg5, Arg6>, Functor>
312 {
313  typedef R ResultType;
314  typedef R (*InvokeType)(AbstractFunctorCaller* , Arg1, Arg2, Arg3, Arg4, Arg5, Arg6);
315 
316  explicit FunctorCaller6(const Functor &functor) : BaseFunctorCaller<FunctorCaller6, Functor>(functor, reinterpret_cast<AbstractFunctorCaller::HookType>(&FunctorCaller6<Functor, R , Arg1, Arg2, Arg3, Arg4, Arg5, Arg6>::invoke)) {}
317 
318  static ResultType invoke(AbstractFunctorCaller *call , Arg1 a1, Arg2 a2, Arg3 a3, Arg4 a4, Arg5 a5, Arg6 a6)
319  {
321  Type *typed = static_cast<Type*>(call);
322  return (typed->functor)(a1, a2, a3, a4, a5, a6);
323  }
324 };
325 
326 template <class R , class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6>
327 struct Callback6 : public BaseCallback
328 {
329  typedef R (*FunctionType)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6);
330  typedef R ResultType;
331 
333  template <class Functor>
334  Callback6(const Functor &functor) : BaseCallback(new FunctorCaller6<Functor, R , Arg1, Arg2, Arg3, Arg4, Arg5, Arg6>(functor)) {}
335 
336  ResultType operator()(Arg1 a1, Arg2 a2, Arg3 a3, Arg4 a4, Arg5 a5, Arg6 a6) const
337  {
338  if (caller) {
339  typedef R (*InvokeType)(AbstractFunctorCaller* , Arg1, Arg2, Arg3, Arg4, Arg5, Arg6);
340  InvokeType invokeMethod = reinterpret_cast<InvokeType>(caller->invokeMethodHook);
341  return invokeMethod(caller , a1, a2, a3, a4, a5, a6);
342  }
343  return ResultType();
344  }
345 };
346 
347 template <class Functor, class R , class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7>
348 struct FunctorCaller7 : public BaseFunctorCaller<FunctorCaller7<Functor, R , Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7>, Functor>
349 {
350  typedef R ResultType;
351  typedef R (*InvokeType)(AbstractFunctorCaller* , Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7);
352 
353  explicit FunctorCaller7(const Functor &functor) : BaseFunctorCaller<FunctorCaller7, Functor>(functor, reinterpret_cast<AbstractFunctorCaller::HookType>(&FunctorCaller7<Functor, R , Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7>::invoke)) {}
354 
355  static ResultType invoke(AbstractFunctorCaller *call , Arg1 a1, Arg2 a2, Arg3 a3, Arg4 a4, Arg5 a5, Arg6 a6, Arg7 a7)
356  {
358  Type *typed = static_cast<Type*>(call);
359  return (typed->functor)(a1, a2, a3, a4, a5, a6, a7);
360  }
361 };
362 
363 template <class R , class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7>
364 struct Callback7 : public BaseCallback
365 {
366  typedef R (*FunctionType)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7);
367  typedef R ResultType;
368 
370  template <class Functor>
371  Callback7(const Functor &functor) : BaseCallback(new FunctorCaller7<Functor, R , Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7>(functor)) {}
372 
373  ResultType operator()(Arg1 a1, Arg2 a2, Arg3 a3, Arg4 a4, Arg5 a5, Arg6 a6, Arg7 a7) const
374  {
375  if (caller) {
376  typedef R (*InvokeType)(AbstractFunctorCaller* , Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7);
377  InvokeType invokeMethod = reinterpret_cast<InvokeType>(caller->invokeMethodHook);
378  return invokeMethod(caller , a1, a2, a3, a4, a5, a6, a7);
379  }
380  return ResultType();
381  }
382 };
383 
384 }
385 
386 #endif
BaseCallback & operator=(const BaseCallback &other)
Definition: callbacks.h:75
R(* InvokeType)(AbstractFunctorCaller *, Arg1, Arg2, Arg3, Arg4)
Definition: callbacks.h:240
FunctorCaller0(const Functor &functor)
Definition: callbacks.h:94
Callback with 3 arguments.
Definition: callbacks.h:216
Definition: callbacks.h:163
Callback5(const Functor &functor)
Definition: callbacks.h:297
R ResultType
Definition: callbacks.h:108
virtual AbstractFunctorCaller * clone() const
Definition: callbacks.h:60
Callback1()
Definition: callbacks.h:147
Callback4()
Definition: callbacks.h:258
virtual ~AbstractFunctorCaller()
Definition: callbacks.h:41
R ResultType
Definition: callbacks.h:276
R ResultType
Definition: callbacks.h:256
R(* FunctionType)(Arg1, Arg2, Arg3, Arg4)
Definition: callbacks.h:255
R(* FunctionType)(Arg1)
Definition: callbacks.h:144
FunctorCaller5(const Functor &functor)
Definition: callbacks.h:279
static ResultType invoke(AbstractFunctorCaller *call, Arg1 a1, Arg2 a2)
Definition: callbacks.h:170
R(* InvokeType)(AbstractFunctorCaller *, Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7)
Definition: callbacks.h:351
R ResultType
Definition: callbacks.h:91
R(* InvokeType)(AbstractFunctorCaller *, Arg1, Arg2, Arg3)
Definition: callbacks.h:203
ResultType operator()(Arg1 a1, Arg2 a2, Arg3 a3, Arg4 a4) const
Definition: callbacks.h:262
HookType invokeMethodHook
Definition: callbacks.h:45
R ResultType
Definition: callbacks.h:202
R ResultType
Definition: callbacks.h:182
FunctorCaller1(const Functor &functor)
Definition: callbacks.h:131
R(* FunctionType)(Arg1, Arg2, Arg3, Arg4, Arg5)
Definition: callbacks.h:292
Callback6()
Definition: callbacks.h:332
Callback with 5 arguments.
Definition: callbacks.h:290
BaseCallback(AbstractFunctorCaller *caller)
Definition: callbacks.h:69
R(* FunctionType)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7)
Definition: callbacks.h:366
Definition: callbacks.h:237
Callback3(const Functor &functor)
Definition: callbacks.h:223
AbstractFunctorCaller * caller
Definition: callbacks.h:85
R ResultType
Definition: callbacks.h:313
FunctorCaller6(const Functor &functor)
Definition: callbacks.h:316
Callback0(const Functor &functor)
Definition: callbacks.h:112
Callback2(const Functor &functor)
Definition: callbacks.h:186
R ResultType
Definition: callbacks.h:367
ResultType operator()(Arg1 a1, Arg2 a2, Arg3 a3, Arg4 a4, Arg5 a5, Arg6 a6) const
Definition: callbacks.h:336
Callback with 6 arguments.
Definition: callbacks.h:327
Callback6(const Functor &functor)
Definition: callbacks.h:334
R ResultType
Definition: callbacks.h:145
FunctorCaller2(const Functor &functor)
Definition: callbacks.h:168
R(* FunctionType)()
Definition: callbacks.h:107
Functor functor
Definition: callbacks.h:62
Callback3()
Definition: callbacks.h:221
static ResultType invoke(AbstractFunctorCaller *call, Arg1 a1, Arg2 a2, Arg3 a3)
Definition: callbacks.h:207
FunctorCaller3(const Functor &functor)
Definition: callbacks.h:205
R ResultType
Definition: callbacks.h:350
Callback2()
Definition: callbacks.h:184
virtual AbstractFunctorCaller * clone() const =0
bool isValid() const
Definition: callbacks.h:73
R(* FunctionType)(Arg1, Arg2)
Definition: callbacks.h:181
R ResultType
Definition: callbacks.h:293
Callback with 0 arguments.
Definition: callbacks.h:105
Definition: callbacks.h:274
R(* FunctionType)(Arg1, Arg2, Arg3)
Definition: callbacks.h:218
Definition: callbacks.h:53
Callback1(const Functor &functor)
Definition: callbacks.h:149
static ResultType invoke(AbstractFunctorCaller *call, Arg1 a1, Arg2 a2, Arg3 a3, Arg4 a4, Arg5 a5)
Definition: callbacks.h:281
static ResultType invoke(AbstractFunctorCaller *call)
Definition: callbacks.h:96
void *(* HookType)(void *)
Definition: callbacks.h:38
ResultType operator()(Arg1 a1, Arg2 a2, Arg3 a3, Arg4 a4, Arg5 a5, Arg6 a6, Arg7 a7) const
Definition: callbacks.h:373
R ResultType
Definition: callbacks.h:219
Definition: callbacks.h:200
FunctorCaller7(const Functor &functor)
Definition: callbacks.h:353
R(* FunctionType)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6)
Definition: callbacks.h:329
Callback with 7 arguments.
Definition: callbacks.h:364
ResultType operator()(Arg1 a1, Arg2 a2, Arg3 a3) const
Definition: callbacks.h:225
Callback with 1 argument.
Definition: callbacks.h:142
Definition: callbacks.h:311
R ResultType
Definition: callbacks.h:165
static ResultType invoke(AbstractFunctorCaller *call, Arg1 a1)
Definition: callbacks.h:133
static ResultType invoke(AbstractFunctorCaller *call, Arg1 a1, Arg2 a2, Arg3 a3, Arg4 a4, Arg5 a5, Arg6 a6, Arg7 a7)
Definition: callbacks.h:355
Callback with 4 arguments.
Definition: callbacks.h:253
R ResultType
Definition: callbacks.h:239
R(* InvokeType)(AbstractFunctorCaller *)
Definition: callbacks.h:92
virtual ~BaseFunctorCaller()
Definition: callbacks.h:58
ResultType operator()() const
Definition: callbacks.h:114
static ResultType invoke(AbstractFunctorCaller *call, Arg1 a1, Arg2 a2, Arg3 a3, Arg4 a4)
Definition: callbacks.h:244
static ResultType invoke(AbstractFunctorCaller *call, Arg1 a1, Arg2 a2, Arg3 a3, Arg4 a4, Arg5 a5, Arg6 a6)
Definition: callbacks.h:318
Callback5()
Definition: callbacks.h:295
BaseCallback(const BaseCallback &other)
Definition: callbacks.h:70
virtual ~BaseCallback()
Definition: callbacks.h:71
Callback7()
Definition: callbacks.h:369
Definition: callbacks.h:348
R ResultType
Definition: callbacks.h:330
R(* InvokeType)(AbstractFunctorCaller *, Arg1, Arg2, Arg3, Arg4, Arg5)
Definition: callbacks.h:277
ResultType operator()(Arg1 a1) const
Definition: callbacks.h:151
R ResultType
Definition: callbacks.h:128
BaseFunctorCaller(const Functor &functor, AbstractFunctorCaller::HookType invokeMethodHook)
Definition: callbacks.h:55
ResultType operator()(Arg1 a1, Arg2 a2) const
Definition: callbacks.h:188
R(* InvokeType)(AbstractFunctorCaller *, Arg1)
Definition: callbacks.h:129
Definition: callbacks.h:89
Definition: callbacks.h:36
FunctorCaller4(const Functor &functor)
Definition: callbacks.h:242
Callback0()
Definition: callbacks.h:110
Callback7(const Functor &functor)
Definition: callbacks.h:371
AbstractFunctorCaller(HookType invokeMethodHook)
Definition: callbacks.h:40
Definition: abstract-adaptor.cpp:31
R(* InvokeType)(AbstractFunctorCaller *, Arg1, Arg2)
Definition: callbacks.h:166
BaseCallback()
Definition: callbacks.h:67
R(* InvokeType)(AbstractFunctorCaller *, Arg1, Arg2, Arg3, Arg4, Arg5, Arg6)
Definition: callbacks.h:314
Callback with 2 arguments.
Definition: callbacks.h:179
Definition: callbacks.h:126
ResultType operator()(Arg1 a1, Arg2 a2, Arg3 a3, Arg4 a4, Arg5 a5) const
Definition: callbacks.h:299
Base class for all the callback classes.
Definition: callbacks.h:65
Callback4(const Functor &functor)
Definition: callbacks.h:260