|
1 /******************************************************************************* |
|
2 * Copyright (c) 2005, 2010 Nokia Corporation and/or its subsidiary(-ies). |
|
3 * All rights reserved. This program and the accompanying materials |
|
4 * are made available under the terms of the Eclipse Public License v1.0 |
|
5 * which accompanies this distribution, and is available at |
|
6 * http://www.eclipse.org/legal/epl-v10.html |
|
7 * |
|
8 * Contributors: |
|
9 * Nokia Corporation - S60 implementation |
|
10 *******************************************************************************/ |
|
11 |
|
12 |
|
13 #ifndef METHODCALL_H |
|
14 #define METHODCALL_H |
|
15 |
|
16 |
|
17 #include "methodwrappers.h" |
|
18 |
|
19 |
|
20 // Disable bothersome warning |
|
21 //#pragma warning(disable: 4786) // 'identifier' : identifier was truncated to 'number' characters in the debug information |
|
22 |
|
23 |
|
24 /* |
|
25 * Note: Call() used for calling const methods cause errors in Lint and are |
|
26 * thus wrapped in a #ifndef / #endif clause to prevent Lint from seeing them. |
|
27 */ |
|
28 |
|
29 |
|
30 class CSwtDisplay; |
|
31 |
|
32 |
|
33 /** |
|
34 * A functor executing object |
|
35 * |
|
36 * An executor is a function that takes a functor as argument and executes it |
|
37 * in the UI thread. |
|
38 */ |
|
39 typedef void (*TExecutor)(const MSwtFunctor& aFunctor, CSwtDisplay* aDisplay); |
|
40 |
|
41 |
|
42 void ExecuteRegularFunctor(const MSwtFunctor& aFunctor, CSwtDisplay* aDisplay); |
|
43 void ExecuteLeavingFunctorL(const MSwtFunctor& aFunctor, CSwtDisplay* aDisplay); |
|
44 |
|
45 |
|
46 |
|
47 |
|
48 /** |
|
49 * Utility class that constructs a method call wrapping object and |
|
50 * passes it on to an executor. |
|
51 * |
|
52 * <b>Known limitations</b>: |
|
53 * - methods that return references are not handled. |
|
54 */ |
|
55 template<TExecutor Execute> |
|
56 class TMethodCall |
|
57 { |
|
58 public: |
|
59 /** |
|
60 * Calls a method with no argument and a return value |
|
61 */ |
|
62 template<class S, class R, class C> |
|
63 static inline void Call(S& aResult, C* aObject, R(C::*aMethod)(), CSwtDisplay* aDisplay = 0) |
|
64 { |
|
65 Execute(TMethodWrapperR0<S,R,C>(aResult, *aObject, aMethod), aDisplay); |
|
66 } |
|
67 |
|
68 |
|
69 #ifndef _lint |
|
70 /** |
|
71 * Calls a const method with no argument and a return value |
|
72 */ |
|
73 template<class S, class R, class C> |
|
74 static inline void Call(S& aResult, const C* aObject, R(C::*aMethod)() const, CSwtDisplay* aDisplay = 0) |
|
75 { |
|
76 Call(aResult, const_cast<C*>(aObject), reinterpret_cast<R(C::*)()>(aMethod), aDisplay); |
|
77 } |
|
78 #endif // _lint |
|
79 |
|
80 |
|
81 /** |
|
82 * Calls a method with no argument and no return value |
|
83 */ |
|
84 template<class C> |
|
85 static inline void Call(C* aObject, void (C::*aMethod)(), CSwtDisplay* aDisplay = 0) |
|
86 { |
|
87 Execute(TMethodWrapper0<C>(*aObject, aMethod), aDisplay); |
|
88 } |
|
89 |
|
90 #ifndef _lint |
|
91 /** |
|
92 * Calls a const method with no argument and no return value |
|
93 */ |
|
94 template<class C> |
|
95 static inline void Call(const C* aObject, void (C::*aMethod)() const, CSwtDisplay* aDisplay = 0) |
|
96 { |
|
97 Call(const_cast<C*>(aObject), reinterpret_cast<void (C::*)()>(aMethod), aDisplay); |
|
98 } |
|
99 #endif // _lint |
|
100 |
|
101 |
|
102 /** |
|
103 * Calls a method with 1 argument and a return value |
|
104 */ |
|
105 template<class S, class R, class C, class A1, class B1> |
|
106 static inline void Call(S& aResult, C* aObject, R(C::*aMethod)(A1), B1& aArg1, CSwtDisplay* aDisplay = 0) |
|
107 { |
|
108 Execute(TMethodWrapperR1<S,R,C,A1>(aResult, *aObject, aMethod, aArg1), aDisplay); |
|
109 } |
|
110 |
|
111 |
|
112 #ifndef _lint |
|
113 /** |
|
114 * Calls a const method with 1 argument and a return value |
|
115 */ |
|
116 template<class S, class R, class C, class A1, class B1> |
|
117 static inline void Call(S& aResult, const C* aObject, R(C::*aMethod)(A1) const, B1& aArg1, CSwtDisplay* aDisplay = 0) |
|
118 { |
|
119 Call(aResult, const_cast<C*>(aObject), reinterpret_cast<R(C::*)(A1)>(aMethod), aArg1, aDisplay); |
|
120 } |
|
121 #endif // _lint |
|
122 |
|
123 |
|
124 /** |
|
125 * Calls a method with 1 argument and no return value |
|
126 */ |
|
127 template<class C, class A1, class B1> |
|
128 static inline void Call(C* aObject, void (C::*aMethod)(A1), B1& aArg1, CSwtDisplay* aDisplay = 0) |
|
129 { |
|
130 Execute(TMethodWrapper1<C,A1>(*aObject, aMethod, aArg1), aDisplay); |
|
131 } |
|
132 |
|
133 |
|
134 #ifndef _lint |
|
135 /** |
|
136 * Calls a const method with 1 argument and no return value |
|
137 */ |
|
138 template<class C, class A1, class B1> |
|
139 static inline void Call(const C* aObject, void (C::*aMethod)(A1) const, B1& aArg1, CSwtDisplay* aDisplay = 0) |
|
140 { |
|
141 Call(const_cast<C*>(aObject), reinterpret_cast<void (C::*)(A1)>(aMethod), aArg1, aDisplay); |
|
142 } |
|
143 #endif // _lint |
|
144 |
|
145 |
|
146 /** |
|
147 * Calls a method with 2 arguments and no return value |
|
148 */ |
|
149 template<class C, class A1, class A2, class B1, class B2> |
|
150 static inline void Call(C* aObject, void (C::*aMethod)(A1,A2), B1& aArg1, B2& aArg2, CSwtDisplay* aDisplay = 0) |
|
151 { |
|
152 Execute(TMethodWrapper2<C,A1,A2>(*aObject, aMethod, aArg1, aArg2), aDisplay); |
|
153 } |
|
154 |
|
155 |
|
156 #ifndef _lint |
|
157 /** |
|
158 * Calls a const method with 2 arguments and no return value |
|
159 */ |
|
160 template<class C, class A1, class A2, class B1, class B2> |
|
161 static inline void Call(const C* aObject, void (C::*aMethod)(A1,A2) const, B1& aArg1, B2& aArg2, CSwtDisplay* aDisplay = 0) |
|
162 { |
|
163 Call(const_cast<C*>(aObject), reinterpret_cast<void (C::*)(A1,A2)>(aMethod), aArg1, aArg2, aDisplay); |
|
164 } |
|
165 #endif // _lint |
|
166 |
|
167 |
|
168 /** |
|
169 * Calls a method with 2 arguments and a return value |
|
170 */ |
|
171 template<class S, class R, class C, class A1, class A2, class B1, class B2> |
|
172 static inline void Call(S& aResult, C* aObject, R(C::*aMethod)(A1,A2), B1& aArg1, B2& aArg2, CSwtDisplay* aDisplay = 0) |
|
173 { |
|
174 Execute(TMethodWrapperR2<S,R,C,A1,A2>(aResult, *aObject, aMethod, aArg1, aArg2), aDisplay); |
|
175 } |
|
176 |
|
177 |
|
178 #ifndef _lint |
|
179 /** |
|
180 * Calls a const method with 2 arguments and a return value |
|
181 */ |
|
182 template<class S, class R, class C, class A1, class A2, class B1, class B2> |
|
183 static inline void Call(S& aResult, const C* aObject, R(C::*aMethod)(A1,A2) const, B1& aArg1, B2& aArg2, CSwtDisplay* aDisplay = 0) |
|
184 { |
|
185 Call(aResult, const_cast<C*>(aObject), reinterpret_cast<R(C::*)(A1,A2)>(aMethod), aArg1, aArg2, aDisplay); |
|
186 } |
|
187 #endif // _lint |
|
188 |
|
189 |
|
190 /** |
|
191 * Calls a method with 3 arguments and no return value |
|
192 */ |
|
193 template<class C, class A1, class A2, class A3, class B1, class B2, class B3> |
|
194 static inline void Call(C* aObject, void (C::*aMethod)(A1,A2,A3), B1& aArg1, B2& aArg2, B3& aArg3, CSwtDisplay* aDisplay = 0) |
|
195 { |
|
196 Execute(TMethodWrapper3<C,A1,A2,A3>(*aObject, aMethod, aArg1, aArg2, aArg3), aDisplay); |
|
197 } |
|
198 |
|
199 |
|
200 #ifndef _lint |
|
201 /** |
|
202 * Calls a const method with 3 arguments and no return value |
|
203 */ |
|
204 template<class C, class A1, class A2, class A3, class B1, class B2, class B3> |
|
205 static inline void Call(const C* aObject, void (C::*aMethod)(A1,A2,A3) const, B1& aArg1, B2& aArg2, B3& aArg3, CSwtDisplay* aDisplay = 0) |
|
206 { |
|
207 Call(const_cast<C*>(aObject), reinterpret_cast<void (C::*)(A1,A2,A3)>(aMethod), aArg1, aArg2, aArg3, aDisplay); |
|
208 } |
|
209 #endif // _lint |
|
210 |
|
211 |
|
212 /** |
|
213 * Calls a method with 3 arguments and a return value |
|
214 */ |
|
215 template<class S, class R, class C, class A1, class A2, class A3, class B1, class B2, class B3> |
|
216 static inline void Call(S& aResult, C* aObject, R(C::*aMethod)(A1,A2,A3), B1& aArg1, B2& aArg2, B3& aArg3, CSwtDisplay* aDisplay = 0) |
|
217 { |
|
218 Execute(TMethodWrapperR3<S,R,C,A1,A2,A3>(aResult, *aObject, aMethod, aArg1, aArg2, aArg3), aDisplay); |
|
219 } |
|
220 |
|
221 |
|
222 #ifndef _lint |
|
223 /** |
|
224 * Calls a const method with 3 arguments and a return value |
|
225 */ |
|
226 template<class S, class R, class C, class A1, class A2, class A3, class B1, class B2, class B3> |
|
227 static inline void Call(S& aResult, const C* aObject, R(C::*aMethod)(A1,A2,A3) const, B1& aArg1, B2& aArg2, B3& aArg3, CSwtDisplay* aDisplay = 0) |
|
228 { |
|
229 Call(aResult, const_cast<C*>(aObject), reinterpret_cast<R(C::*)(A1,A2,A3)>(aMethod), aArg1, aArg2, aArg3, aDisplay); |
|
230 } |
|
231 #endif // _lint |
|
232 |
|
233 |
|
234 /** |
|
235 * Calls a method with 4 arguments and no return value |
|
236 */ |
|
237 template<class C, class A1, class A2, class A3, class A4, class B1, class B2, class B3, class B4> |
|
238 static inline void Call(C* aObject, void (C::*aMethod)(A1,A2,A3,A4), B1& aArg1, B2& aArg2, B3& aArg3, B4& aArg4, CSwtDisplay* aDisplay = 0) |
|
239 { |
|
240 Execute(TMethodWrapper4<C,A1,A2,A3,A4>(*aObject, aMethod, aArg1, aArg2, aArg3, aArg4), aDisplay); |
|
241 } |
|
242 |
|
243 |
|
244 #ifndef _lint |
|
245 /** |
|
246 * Calls a const method with 4 arguments and no return value |
|
247 */ |
|
248 template<class C, class A1, class A2, class A3, class A4, class B1, class B2, class B3, class B4> |
|
249 static inline void Call(const C* aObject, void (C::*aMethod)(A1,A2,A3,A4) const, B1& aArg1, B2& aArg2, B3& aArg3, B4& aArg4, CSwtDisplay* aDisplay = 0) |
|
250 { |
|
251 Call(const_cast<C*>(aObject), reinterpret_cast<void (C::*)(A1, A2, A3, A4)>(aMethod), aArg1, aArg2, aArg3, aArg4, aDisplay); |
|
252 } |
|
253 #endif // _lint |
|
254 |
|
255 |
|
256 /** |
|
257 * Calls a method with 4 arguments and a return value |
|
258 */ |
|
259 template<class S, class R, class C, class A1, class A2, class A3, class A4, class B1, class B2, class B3, class B4> |
|
260 static inline void Call(S& aResult, C* aObject, R(C::*aMethod)(A1,A2,A3,A4), B1& aArg1, B2& aArg2, B3& aArg3, B4& aArg4, CSwtDisplay* aDisplay = 0) |
|
261 { |
|
262 Execute(TMethodWrapperR4<S,R,C,A1,A2,A3,A4>(aResult, *aObject, aMethod, aArg1, aArg2, aArg3, aArg4), aDisplay); |
|
263 } |
|
264 |
|
265 |
|
266 #ifndef _lint |
|
267 /** |
|
268 * Calls a const method with 4 arguments and a return value |
|
269 */ |
|
270 template<class S, class R, class C, class A1, class A2, class A3, class A4, class B1, class B2, class B3, class B4> |
|
271 static inline void Call(S& aResult, const C* aObject, R(C::*aMethod)(A1,A2,A3,A4) const, B1& aArg1, B2& aArg2, B3& aArg3, B4& aArg4, CSwtDisplay* aDisplay = 0) |
|
272 { |
|
273 Call(aResult, const_cast<C*>(aObject), reinterpret_cast<R(C::*)(A1,A2,A3,A4)>(aMethod), aArg1, aArg2, aArg3, aArg4, aDisplay); |
|
274 } |
|
275 #endif // _lint |
|
276 |
|
277 |
|
278 /** |
|
279 * Calls a method with 5 arguments and no return value |
|
280 */ |
|
281 template<class C, class A1, class A2, class A3, class A4, class A5, class B1, class B2, class B3, class B4, class B5> |
|
282 static inline void Call(C* aObject, void (C::*aMethod)(A1,A2,A3,A4,A5), B1& aArg1, B2& aArg2, B3& aArg3, B4& aArg4, B5& aArg5, CSwtDisplay* aDisplay = 0) |
|
283 { |
|
284 Execute(TMethodWrapper5<C,A1,A2,A3,A4,A5>(*aObject, aMethod, aArg1, aArg2, aArg3, aArg4, aArg5), aDisplay); |
|
285 } |
|
286 |
|
287 |
|
288 /** |
|
289 * Calls a method with 5 arguments and a return value |
|
290 */ |
|
291 template<class S, class R, class C, class A1, class A2, class A3, class A4, class A5, class B1, class B2, class B3, class B4, class B5> |
|
292 static inline void Call(S& aResult, C* aObject, R(C::*aMethod)(A1,A2,A3,A4,A5), B1& aArg1, B2& aArg2, B3& aArg3, B4& aArg4, B5& aArg5, CSwtDisplay* aDisplay = 0) |
|
293 { |
|
294 Execute(TMethodWrapperR5<S,R,C,A1,A2,A3,A4,A5>(aResult, *aObject, aMethod, aArg1, aArg2, aArg3, aArg4, aArg5), aDisplay); |
|
295 } |
|
296 |
|
297 |
|
298 #ifndef _lint |
|
299 /** |
|
300 * Calls a const method with 5 arguments and no return value |
|
301 */ |
|
302 template<class C, class A1, class A2, class A3, class A4, class A5, class B1, class B2, class B3, class B4, class B5> |
|
303 static inline void Call(const C* aObject, void (C::*aMethod)(A1,A2,A3,A4,A5) const, B1& aArg1, B2& aArg2, B3& aArg3, B4& aArg4, B5& aArg5, CSwtDisplay* aDisplay = 0) |
|
304 { |
|
305 Call(const_cast<C*>(aObject), reinterpret_cast<void (C::*)(A1, A2, A3, A4, A5)>(aMethod), aArg1, aArg2, aArg3, aArg4, aArg5, aDisplay); |
|
306 } |
|
307 #endif // _lint |
|
308 |
|
309 |
|
310 #ifndef _lint |
|
311 /** |
|
312 * Calls a const method with 5 arguments and a return value |
|
313 */ |
|
314 template<class S, class R, class C, class A1, class A2, class A3, class A4, class A5, class B1, class B2, class B3, class B4, class B5> |
|
315 static inline void Call(S& aResult, const C* aObject, R(C::*aMethod)(A1,A2,A3,A4,A5) const, B1& aArg1, B2& aArg2, B3& aArg3, B4& aArg4, B5& aArg5, CSwtDisplay* aDisplay = 0) |
|
316 { |
|
317 Call(aResult, const_cast<C*>(aObject), reinterpret_cast<R(C::*)(A1,A2,A3,A4,A5)>(aMethod), aArg1, aArg2, aArg3, aArg4, aArg5, aDisplay); |
|
318 } |
|
319 #endif // _lint |
|
320 |
|
321 |
|
322 /** |
|
323 * Calls a method with 6 arguments and no return value |
|
324 */ |
|
325 template<class C, class A1, class A2, class A3, class A4, class A5, class A6, class B1, class B2, class B3, class B4, class B5, class B6> |
|
326 static inline void Call(C* aObject, void (C::*aMethod)(A1,A2,A3,A4,A5,A6), B1& aArg1, B2& aArg2, B3& aArg3, B4& aArg4, B5& aArg5, B6& aArg6, CSwtDisplay* aDisplay = 0) |
|
327 { |
|
328 Execute(TMethodWrapper6<C,A1,A2,A3,A4,A5,A6>(*aObject, aMethod, aArg1, aArg2, aArg3, aArg4, aArg5, aArg6), aDisplay); |
|
329 } |
|
330 |
|
331 |
|
332 /** |
|
333 * Calls a method with 6 arguments and a return value |
|
334 */ |
|
335 template<class S, class R, class C, class A1, class A2, class A3, class A4, class A5, class A6, class B1, class B2, class B3, class B4, class B5, class B6> |
|
336 static inline void Call(S& aResult, C* aObject, R(C::*aMethod)(A1,A2,A3,A4,A5,A6), B1& aArg1, B2& aArg2, B3& aArg3, B4& aArg4, B5& aArg5, B6& aArg6, CSwtDisplay* aDisplay = 0) |
|
337 { |
|
338 Execute(TMethodWrapperR6<S,R,C,A1,A2,A3,A4,A5,A6>(aResult, *aObject, aMethod, aArg1, aArg2, aArg3, aArg4, aArg5, aArg6), aDisplay); |
|
339 } |
|
340 |
|
341 |
|
342 #ifndef _lint |
|
343 /** |
|
344 * Calls a const method with 6 arguments and a return value |
|
345 */ |
|
346 template<class S, class R, class C, class A1, class A2, class A3, class A4, class A5, class A6, class B1, class B2, class B3, class B4, class B5, class B6> |
|
347 static inline void Call(S& aResult, const C* aObject, R(C::*aMethod)(A1,A2,A3,A4,A5,A6) const, B1& aArg1, B2& aArg2, B3& aArg3, B4& aArg4, B5& aArg5, B6& aArg6, CSwtDisplay* aDisplay = 0) |
|
348 { |
|
349 Call(aResult, const_cast<C*>(aObject), reinterpret_cast<R(C::*)(A1,A2,A3,A4,A5,A6)>(aMethod), aArg1, aArg2, aArg3, aArg4, aArg5, aArg6, aDisplay); |
|
350 } |
|
351 #endif // _lint |
|
352 |
|
353 |
|
354 #ifndef _lint |
|
355 /** |
|
356 * Calls a const method with 6 arguments and no return value |
|
357 */ |
|
358 template<class C, class A1, class A2, class A3, class A4, class A5, class A6, class B1, class B2, class B3, class B4, class B5, class B6> |
|
359 static inline void Call(const C* aObject, void (C::*aMethod)(A1,A2,A3,A4,A5,A6) const, B1& aArg1, B2& aArg2, B3& aArg3, B4& aArg4, B5& aArg5, B6& aArg6, CSwtDisplay* aDisplay = 0) |
|
360 { |
|
361 Call(const_cast<C*>(aObject), reinterpret_cast<void (C::*)(A1, A2, A3, A4, A5, A6)>(aMethod), aArg1, aArg2, aArg3, aArg4, aArg5, aArg6, aDisplay); |
|
362 } |
|
363 #endif // _lint |
|
364 |
|
365 |
|
366 /** |
|
367 * Calls a method with 7 arguments and no return value |
|
368 */ |
|
369 template<class C, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class B1, class B2, class B3, class B4, class B5, class B6, class B7> |
|
370 static inline void Call(C* aObject, void (C::*aMethod)(A1,A2,A3,A4,A5,A6,A7), B1& aArg1, B2& aArg2, B3& aArg3, B4& aArg4, B5& aArg5, B6& aArg6, B7& aArg7, CSwtDisplay* aDisplay = 0) |
|
371 { |
|
372 Execute(TMethodWrapper7<C,A1,A2,A3,A4,A5,A6,A7>(*aObject, aMethod, aArg1, aArg2, aArg3, aArg4, aArg5, aArg6, aArg7), aDisplay); |
|
373 } |
|
374 |
|
375 |
|
376 /** |
|
377 * Calls a method with 7 arguments and a return value |
|
378 */ |
|
379 template<class S, class R, class C, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class B1, class B2, class B3, class B4, class B5, class B6, class B7> |
|
380 static inline void Call(S& aResult, C* aObject, R(C::*aMethod)(A1,A2,A3,A4,A5,A6,A7), B1& aArg1, B2& aArg2, B3& aArg3, B4& aArg4, B5& aArg5, B6& aArg6, B7& aArg7, CSwtDisplay* aDisplay = 0) |
|
381 { |
|
382 Execute(TMethodWrapperR7<S,R,C,A1,A2,A3,A4,A5,A6,A7>(aResult, *aObject, aMethod, aArg1, aArg2, aArg3, aArg4, aArg5, aArg6, aArg7), aDisplay); |
|
383 } |
|
384 |
|
385 |
|
386 #ifndef _lint |
|
387 /** |
|
388 * Calls a const method with 7 arguments and a return value |
|
389 */ |
|
390 template<class S, class R, class C, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class B1, class B2, class B3, class B4, class B5, class B6, class B7> |
|
391 static inline void Call(S& aResult, const C* aObject, R(C::*aMethod)(A1,A2,A3,A4,A5,A6,A7) const, B1& aArg1, B2& aArg2, B3& aArg3, B4& aArg4, B5& aArg5, B6& aArg6, B7& aArg7, CSwtDisplay* aDisplay = 0) |
|
392 { |
|
393 Call(aResult, const_cast<C*>(aObject), reinterpret_cast<R(C::*)(A1,A2,A3,A4,A5,A6,A7)>(aMethod), aArg1, aArg2, aArg3, aArg4, aArg5, aArg6, aArg7, aDisplay); |
|
394 } |
|
395 #endif // _lint |
|
396 |
|
397 |
|
398 /** |
|
399 * Calls a method with 8 arguments and no return value |
|
400 */ |
|
401 template<class C, class A1, class A2, class A3, class A4, class A5, class A6, class A7,class A8, class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8> |
|
402 static inline void Call(C* aObject, void (C::*aMethod)(A1,A2,A3,A4,A5,A6,A7,A8), B1& aArg1, B2& aArg2, B3& aArg3, B4& aArg4, B5& aArg5, B6& aArg6, B7& aArg7, B8& aArg8, CSwtDisplay* aDisplay = 0) |
|
403 { |
|
404 Execute(TMethodWrapper8<C,A1,A2,A3,A4,A5,A6,A7,A8>(*aObject, aMethod, aArg1, aArg2, aArg3, aArg4, aArg5, aArg6, aArg7, aArg8), aDisplay); |
|
405 } |
|
406 |
|
407 |
|
408 }; |
|
409 |
|
410 |
|
411 |
|
412 |
|
413 /** |
|
414 * Specialisation of TMethodCall for non-leaving methods |
|
415 */ |
|
416 typedef TMethodCall<ExecuteRegularFunctor> TRegularMethodCall; |
|
417 |
|
418 |
|
419 /** |
|
420 * Specialisation of TMethodCall for leaving methods |
|
421 */ |
|
422 typedef TMethodCall<ExecuteLeavingFunctorL> TLeavingMethodCall; |
|
423 |
|
424 |
|
425 /** |
|
426 * Helper macro to ease calling a regular method |
|
427 */ |
|
428 #define CallMethod TRegularMethodCall::Call |
|
429 |
|
430 |
|
431 /** |
|
432 * Helper macro to ease calling a leaving method |
|
433 */ |
|
434 #define CallMethodL TLeavingMethodCall::Call |
|
435 |
|
436 |
|
437 #endif // METHODCALL_H |
|
438 |
|
439 |
|
440 |