RCFProto

- Main Page
- Classes
- Files

- File List

All Classes Functions Typedefs
RcfMethodGen.hpp
1
2 //******************************************************************************
3 // RCF - Remote Call Framework
4 //
5 // Copyright (c) 2005 - 2013, Delta V Software. All rights reserved.
6 // http://www.deltavsoft.com
7 //
8 // RCF is distributed under dual licenses - closed source or GPL.
9 // Consult your particular license for conditions of use.
10 //
11 // If you have not purchased a commercial license, you are using RCF
12 // under GPL terms.
13 //
14 // Version: 2.0
15 // Contact: support <at> deltavsoft.com
16 //
17 //******************************************************************************
18
19 #ifndef INCLUDE_RCF_RCFMETHODGEN_HPP
20 #define INCLUDE_RCF_RCFMETHODGEN_HPP
21
22
23
24
25 //------------------------------------------------------------------------------
26 // Parameters - R0
27 //------------------------------------------------------------------------------
28
29 // RCF_METHOD_R0
30 #define RCF_METHOD_R0_INLINE(R,func ) \
31 RCF_METHOD_R0_INLINE_(R,func , RCF_MAKE_UNIQUE_ID(func, R0))
32
33 #define RCF_METHOD_R0_INLINE_(R,func , id) \
34 public: \
35 RCF_MAKE_NEXT_DISPATCH_ID(id) \
36 ::RCF::FutureImpl<R > func( \
37 ) \
38 { \
39 return func( \
40 ::RCF::CallOptions() \
41 ); \
42 } \
43 ::RCF::FutureImpl<R > func( \
44 const ::RCF::CallOptions &callOptions \
45 ) \
46 { \
47 getClientStub().setAsync(false); \
48 return RCF::FutureImpl<R >( \
49 ::RCF::AllocateClientParameters< \
50 R \
51 , \
52 V,V,V,V,V,V,V,V,V,V,V,V,V,V,V >()( \
53 getClientStub() \
54 , \
55 V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V()).r.get(),\
56 getClientStub(), \
57 mInterfaceName, \
58 id::value, \
59 callOptions.apply(getClientStub()), \
60 #func, \
61 "R0"); \
62 } \
63 const char * getFunctionName(const id &) \
64 { \
65 return #func; \
66 } \
67 const char * getArity(const id &) \
68 { \
69 return "R0"; \
70 } \
71 \
72 private: \
73 template<typename T> \
74 void invoke( \
75 const id &, \
76 ::RCF::RcfSession &session, \
77 T &t) \
78 { \
79 if (session.isInProcess()) \
80 { \
81 ::RCF::ClientParameters< \
82 R \
83 , V,V,V,V,V,V,V,V,V,V,V,V,V,V,V > &p = static_cast< \
84 ::RCF::ClientParameters< \
85 R \
86 , V,V,V,V,V,V,V,V,V,V,V,V,V,V,V > &>(* session.getInProcessParameters());\
87 p.r.set( t.func( ) ); \
88 } \
89 else \
90 { \
91 ::RCF::ServerParameters< \
92 R \
93 > &p = \
94 ::RCF::AllocateServerParameters< \
95 R \
96 >()(session); \
97 p.r.set( \
98 session.getAutoSend(), \
99 t.func( \
100 )); \
101 } \
102 }
103
104 // RCF_METHOD_R0_DECL
105 #define RCF_METHOD_R0_DECL(R,func ) \
106 RCF_METHOD_R0_DECL_(R,func , RCF_MAKE_UNIQUE_ID(func, R0))
107
108 #define RCF_METHOD_R0_DECL_(R,func , id) \
109 public: \
110 RCF_MAKE_NEXT_DISPATCH_ID(id) \
111 ::RCF::FutureImpl<R > func( \
112 ) \
113 { \
114 return func( \
115 ::RCF::CallOptions() \
116 ); \
117 } \
118 \
119 ::RCF::FutureImpl<R > func( \
120 const ::RCF::CallOptions &callOptions \
121 ); \
122 \
123 void error__method_defined_out_of_order__##func( \
124 id * \
125 ); \
126 \
127 const char * getFunctionName(const id &) \
128 { \
129 return #func; \
130 } \
131 const char * getArity(const id &) \
132 { \
133 return "R0"; \
134 } \
135 \
136 private: \
137 template<typename T> \
138 void invoke( \
139 const id &, \
140 ::RCF::RcfSession &session, \
141 T &t) \
142 { \
143 if (session.isInProcess()) \
144 { \
145 ::RCF::ClientParameters< \
146 R \
147 , V,V,V,V,V,V,V,V,V,V,V,V,V,V,V > &p = static_cast< \
148 ::RCF::ClientParameters< \
149 R \
150 , V,V,V,V,V,V,V,V,V,V,V,V,V,V,V > &>(* session.getInProcessParameters());\
151 p.r.set( t.func( ) ); \
152 } \
153 else \
154 { \
155 ::RCF::ServerParameters< \
156 R \
157 > &p = \
158 ::RCF::AllocateServerParameters< \
159 R \
160 >()(session); \
161 p.r.set( \
162 session.getAutoSend(), \
163 t.func( \
164 )); \
165 } \
166 }
167
168 // RCF_METHOD_R0_DEF
169 #define RCF_METHOD_R0_DEF(R,func ) \
170 RCF_METHOD_R0_DEF_(R,func , RCF_PP_CAT(rcf_interface_id_1_, func, R0, __LINE__), RCF_MAKE_UNIQUE_ID(func, R0), RCF_PP_CAT(rcf_interface_id_2_, func, R0, __LINE__))
171
172 #define RCF_METHOD_R0_DEF_(R,func , interfaceId, funcId, genParms) \
173 RCF_CURRENT_STATIC_ID(interfaceId, RCF_interface_id_helper, int, int) \
174 typedef GeneratorParms<interfaceId> genParms; \
175 RCF_ADVANCE_STATIC_ID(funcId, RCF_def_dispatch_id_helper, ::RCF::Dummy<genParms::RcfClientT>, genParms::RcfClientT, static)\
176 RCF_EXPORT_INTERFACE ::RCF::FutureImpl<R > genParms::RcfClientT::func( \
177 const ::RCF::CallOptions &callOptions \
178 ) \
179 { \
180 getClientStub().setAsync(false); \
181 return RCF::FutureImpl<R >( \
182 ::RCF::AllocateClientParameters< \
183 R \
184 , \
185 V,V,V,V,V,V,V,V,V,V,V,V,V,V,V >()( \
186 getClientStub() \
187 , \
188 V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V()).r.get(),\
189 getClientStub(), \
190 mInterfaceName, \
191 funcId::value, \
192 callOptions.apply(getClientStub()), \
193 #func, \
194 "R0"); \
195 } \
196 void genParms::RcfClientT::error__method_defined_out_of_order__##func( \
197 funcId * \
198 ) \
199 { \
200 }
201
202
203
204 //------------------------------------------------------------------------------
205 // Parameters - V0
206 //------------------------------------------------------------------------------
207
208 // RCF_METHOD_V0
209 #define RCF_METHOD_V0_INLINE(R,func ) \
210 RCF_METHOD_V0_INLINE_(R,func , RCF_MAKE_UNIQUE_ID(func, V0))
211
212 #define RCF_METHOD_V0_INLINE_(R,func , id) \
213 public: \
214 BOOST_STATIC_ASSERT(( boost::is_same<R, void>::value )); \
215 RCF_MAKE_NEXT_DISPATCH_ID(id) \
216 ::RCF::FutureImpl<V> func( \
217 ) \
218 { \
219 return func( \
220 ::RCF::CallOptions() \
221 ); \
222 } \
223 ::RCF::FutureImpl<V> func( \
224 const ::RCF::CallOptions &callOptions \
225 ) \
226 { \
227 getClientStub().setAsync(false); \
228 return RCF::FutureImpl<V>( \
229 ::RCF::AllocateClientParameters< \
230 V \
231 , \
232 V,V,V,V,V,V,V,V,V,V,V,V,V,V,V >()( \
233 getClientStub() \
234 , \
235 V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V()).r.get(),\
236 getClientStub(), \
237 mInterfaceName, \
238 id::value, \
239 callOptions.apply(getClientStub()), \
240 #func, \
241 "V0"); \
242 } \
243 const char * getFunctionName(const id &) \
244 { \
245 return #func; \
246 } \
247 const char * getArity(const id &) \
248 { \
249 return "V0"; \
250 } \
251 \
252 private: \
253 template<typename T> \
254 void invoke( \
255 const id &, \
256 ::RCF::RcfSession &session, \
257 T &t) \
258 { \
259 if (session.isInProcess()) \
260 { \
261 ::RCF::ClientParameters< \
262 V \
263 , V,V,V,V,V,V,V,V,V,V,V,V,V,V,V > &p = static_cast< \
264 ::RCF::ClientParameters< \
265 V \
266 , V,V,V,V,V,V,V,V,V,V,V,V,V,V,V > &>(* session.getInProcessParameters());\
267 RCF_UNUSED_VARIABLE(p); \
268 t.func( \
269 ); \
270 } \
271 else \
272 { \
273 ::RCF::ServerParameters< \
274 V \
275 > &p = \
276 ::RCF::AllocateServerParameters< \
277 V \
278 >()(session); \
279 RCF_UNUSED_VARIABLE(p); \
280 t.func( \
281 ); \
282 } \
283 }
284
285 // RCF_METHOD_V0_DECL
286 #define RCF_METHOD_V0_DECL(R,func ) \
287 RCF_METHOD_V0_DECL_(R,func , RCF_MAKE_UNIQUE_ID(func, V0))
288
289 #define RCF_METHOD_V0_DECL_(R,func , id) \
290 public: \
291 BOOST_STATIC_ASSERT(( boost::is_same<R, void>::value )); \
292 RCF_MAKE_NEXT_DISPATCH_ID(id) \
293 ::RCF::FutureImpl<V> func( \
294 ) \
295 { \
296 return func( \
297 ::RCF::CallOptions() \
298 ); \
299 } \
300 \
301 ::RCF::FutureImpl<V> func( \
302 const ::RCF::CallOptions &callOptions \
303 ); \
304 \
305 void error__method_defined_out_of_order__##func( \
306 id * \
307 ); \
308 \
309 const char * getFunctionName(const id &) \
310 { \
311 return #func; \
312 } \
313 const char * getArity(const id &) \
314 { \
315 return "V0"; \
316 } \
317 \
318 private: \
319 template<typename T> \
320 void invoke( \
321 const id &, \
322 ::RCF::RcfSession &session, \
323 T &t) \
324 { \
325 if (session.isInProcess()) \
326 { \
327 ::RCF::ClientParameters< \
328 V \
329 , V,V,V,V,V,V,V,V,V,V,V,V,V,V,V > &p = static_cast< \
330 ::RCF::ClientParameters< \
331 V \
332 , V,V,V,V,V,V,V,V,V,V,V,V,V,V,V > &>(* session.getInProcessParameters());\
333 RCF_UNUSED_VARIABLE(p); \
334 t.func( \
335 ); \
336 } \
337 else \
338 { \
339 ::RCF::ServerParameters< \
340 V \
341 > &p = \
342 ::RCF::AllocateServerParameters< \
343 V \
344 >()(session); \
345 RCF_UNUSED_VARIABLE(p); \
346 t.func( \
347 ); \
348 } \
349 }
350
351 // RCF_METHOD_V0_DEF
352 #define RCF_METHOD_V0_DEF(R,func ) \
353 RCF_METHOD_V0_DEF_(R,func , RCF_PP_CAT(rcf_interface_id_1_, func, R0, __LINE__), RCF_MAKE_UNIQUE_ID(func, R0), RCF_PP_CAT(rcf_interface_id_2_, func, R0, __LINE__))
354
355 #define RCF_METHOD_V0_DEF_(R,func , interfaceId, funcId, genParms) \
356 RCF_CURRENT_STATIC_ID(interfaceId, RCF_interface_id_helper, int, int) \
357 typedef GeneratorParms<interfaceId> genParms; \
358 RCF_ADVANCE_STATIC_ID(funcId, RCF_def_dispatch_id_helper, ::RCF::Dummy<genParms::RcfClientT>, genParms::RcfClientT, static)\
359 RCF_EXPORT_INTERFACE ::RCF::FutureImpl<::RCF::Void> genParms::RcfClientT::func(\
360 const ::RCF::CallOptions &callOptions \
361 ) \
362 { \
363 typedef ::RCF::Void V; \
364 getClientStub().setAsync(false); \
365 return RCF::FutureImpl<V >( \
366 ::RCF::AllocateClientParameters< \
367 V \
368 , \
369 V,V,V,V,V,V,V,V,V,V,V,V,V,V,V >()( \
370 getClientStub() \
371 , \
372 V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V()).r.get(),\
373 getClientStub(), \
374 mInterfaceName, \
375 funcId::value, \
376 callOptions.apply(getClientStub()), \
377 #func, \
378 "V0"); \
379 } \
380 void genParms::RcfClientT::error__method_defined_out_of_order__##func( \
381 funcId * \
382 ) \
383 { \
384 }
385
386
387
388
389 //------------------------------------------------------------------------------
390 // Parameters - R1
391 //------------------------------------------------------------------------------
392
393 // RCF_METHOD_R1
394 #define RCF_METHOD_R1_INLINE(R,func , A1) \
395 RCF_METHOD_R1_INLINE_(R,func , A1, RCF_MAKE_UNIQUE_ID(func, R1))
396
397 #define RCF_METHOD_R1_INLINE_(R,func , A1, id) \
398 public: \
399 RCF_MAKE_NEXT_DISPATCH_ID(id) \
400 ::RCF::FutureImpl<R > func( \
401 ::RCF::RemoveOut<A1 >::type a1) \
402 { \
403 return func( \
404 ::RCF::CallOptions() , \
405 a1); \
406 } \
407 ::RCF::FutureImpl<R > func( \
408 const ::RCF::CallOptions &callOptions , \
409 ::RCF::RemoveOut<A1 >::type a1) \
410 { \
411 getClientStub().setAsync(false); \
412 return RCF::FutureImpl<R >( \
413 ::RCF::AllocateClientParameters< \
414 R , \
415 A1 , \
416 V,V,V,V,V,V,V,V,V,V,V,V,V,V >()( \
417 getClientStub() , \
418 a1 , \
419 V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V()).r.get(),\
420 getClientStub(), \
421 mInterfaceName, \
422 id::value, \
423 callOptions.apply(getClientStub()), \
424 #func, \
425 "R1"); \
426 } \
427 const char * getFunctionName(const id &) \
428 { \
429 return #func; \
430 } \
431 const char * getArity(const id &) \
432 { \
433 return "R1"; \
434 } \
435 \
436 private: \
437 template<typename T> \
438 void invoke( \
439 const id &, \
440 ::RCF::RcfSession &session, \
441 T &t) \
442 { \
443 if (session.isInProcess()) \
444 { \
445 ::RCF::ClientParameters< \
446 R , \
447 A1 , V,V,V,V,V,V,V,V,V,V,V,V,V,V > &p = static_cast< \
448 ::RCF::ClientParameters< \
449 R , \
450 A1 , V,V,V,V,V,V,V,V,V,V,V,V,V,V > &>(* session.getInProcessParameters());\
451 p.r.set( t.func( p.a1.get() ) ); \
452 } \
453 else \
454 { \
455 ::RCF::ServerParameters< \
456 R , \
457 A1 > &p = \
458 ::RCF::AllocateServerParameters< \
459 R , \
460 A1 >()(session); \
461 p.r.set( \
462 session.getAutoSend(), \
463 t.func( \
464 p.a1.get())); \
465 } \
466 }
467
468 // RCF_METHOD_R1_DECL
469 #define RCF_METHOD_R1_DECL(R,func , A1) \
470 RCF_METHOD_R1_DECL_(R,func , A1, RCF_MAKE_UNIQUE_ID(func, R1))
471
472 #define RCF_METHOD_R1_DECL_(R,func , A1, id) \
473 public: \
474 RCF_MAKE_NEXT_DISPATCH_ID(id) \
475 ::RCF::FutureImpl<R > func( \
476 ::RCF::RemoveOut<A1 >::type a1) \
477 { \
478 return func( \
479 ::RCF::CallOptions() , \
480 a1); \
481 } \
482 \
483 ::RCF::FutureImpl<R > func( \
484 const ::RCF::CallOptions &callOptions , \
485 ::RCF::RemoveOut<A1 >::type a1); \
486 \
487 void error__method_defined_out_of_order__##func( \
488 id * , \
489 ::RCF::RemoveOut<A1 >::type a1); \
490 \
491 const char * getFunctionName(const id &) \
492 { \
493 return #func; \
494 } \
495 const char * getArity(const id &) \
496 { \
497 return "R1"; \
498 } \
499 \
500 private: \
501 template<typename T> \
502 void invoke( \
503 const id &, \
504 ::RCF::RcfSession &session, \
505 T &t) \
506 { \
507 if (session.isInProcess()) \
508 { \
509 ::RCF::ClientParameters< \
510 R , \
511 A1 , V,V,V,V,V,V,V,V,V,V,V,V,V,V > &p = static_cast< \
512 ::RCF::ClientParameters< \
513 R , \
514 A1 , V,V,V,V,V,V,V,V,V,V,V,V,V,V > &>(* session.getInProcessParameters());\
515 p.r.set( t.func( p.a1.get() ) ); \
516 } \
517 else \
518 { \
519 ::RCF::ServerParameters< \
520 R , \
521 A1 > &p = \
522 ::RCF::AllocateServerParameters< \
523 R , \
524 A1 >()(session); \
525 p.r.set( \
526 session.getAutoSend(), \
527 t.func( \
528 p.a1.get())); \
529 } \
530 }
531
532 // RCF_METHOD_R1_DEF
533 #define RCF_METHOD_R1_DEF(R,func , A1) \
534 RCF_METHOD_R1_DEF_(R,func , A1, RCF_PP_CAT(rcf_interface_id_1_, func, R1, __LINE__), RCF_MAKE_UNIQUE_ID(func, R1), RCF_PP_CAT(rcf_interface_id_2_, func, R1, __LINE__))
535
536 #define RCF_METHOD_R1_DEF_(R,func , A1, interfaceId, funcId, genParms) \
537 RCF_CURRENT_STATIC_ID(interfaceId, RCF_interface_id_helper, int, int) \
538 typedef GeneratorParms<interfaceId> genParms; \
539 RCF_ADVANCE_STATIC_ID(funcId, RCF_def_dispatch_id_helper, ::RCF::Dummy<genParms::RcfClientT>, genParms::RcfClientT, static)\
540 RCF_EXPORT_INTERFACE ::RCF::FutureImpl<R > genParms::RcfClientT::func( \
541 const ::RCF::CallOptions &callOptions , \
542 ::RCF::RemoveOut<A1 >::type a1) \
543 { \
544 getClientStub().setAsync(false); \
545 return RCF::FutureImpl<R >( \
546 ::RCF::AllocateClientParameters< \
547 R , \
548 A1 , \
549 V,V,V,V,V,V,V,V,V,V,V,V,V,V >()( \
550 getClientStub() , \
551 a1 , \
552 V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V()).r.get(),\
553 getClientStub(), \
554 mInterfaceName, \
555 funcId::value, \
556 callOptions.apply(getClientStub()), \
557 #func, \
558 "R1"); \
559 } \
560 void genParms::RcfClientT::error__method_defined_out_of_order__##func( \
561 funcId * , \
562 ::RCF::RemoveOut<A1 >::type a1) \
563 { \
564 }
565
566
567
568 //------------------------------------------------------------------------------
569 // Parameters - V1
570 //------------------------------------------------------------------------------
571
572 // RCF_METHOD_V1
573 #define RCF_METHOD_V1_INLINE(R,func , A1) \
574 RCF_METHOD_V1_INLINE_(R,func , A1, RCF_MAKE_UNIQUE_ID(func, V1))
575
576 #define RCF_METHOD_V1_INLINE_(R,func , A1, id) \
577 public: \
578 BOOST_STATIC_ASSERT(( boost::is_same<R, void>::value )); \
579 RCF_MAKE_NEXT_DISPATCH_ID(id) \
580 ::RCF::FutureImpl<V> func( \
581 ::RCF::RemoveOut<A1 >::type a1) \
582 { \
583 return func( \
584 ::RCF::CallOptions() , \
585 a1); \
586 } \
587 ::RCF::FutureImpl<V> func( \
588 const ::RCF::CallOptions &callOptions , \
589 ::RCF::RemoveOut<A1 >::type a1) \
590 { \
591 getClientStub().setAsync(false); \
592 return RCF::FutureImpl<V>( \
593 ::RCF::AllocateClientParameters< \
594 V , \
595 A1 , \
596 V,V,V,V,V,V,V,V,V,V,V,V,V,V >()( \
597 getClientStub() , \
598 a1 , \
599 V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V()).r.get(),\
600 getClientStub(), \
601 mInterfaceName, \
602 id::value, \
603 callOptions.apply(getClientStub()), \
604 #func, \
605 "V1"); \
606 } \
607 const char * getFunctionName(const id &) \
608 { \
609 return #func; \
610 } \
611 const char * getArity(const id &) \
612 { \
613 return "V1"; \
614 } \
615 \
616 private: \
617 template<typename T> \
618 void invoke( \
619 const id &, \
620 ::RCF::RcfSession &session, \
621 T &t) \
622 { \
623 if (session.isInProcess()) \
624 { \
625 ::RCF::ClientParameters< \
626 V , \
627 A1 , V,V,V,V,V,V,V,V,V,V,V,V,V,V > &p = static_cast< \
628 ::RCF::ClientParameters< \
629 V , \
630 A1 , V,V,V,V,V,V,V,V,V,V,V,V,V,V > &>(* session.getInProcessParameters());\
631 RCF_UNUSED_VARIABLE(p); \
632 t.func( \
633 p.a1.get() ); \
634 } \
635 else \
636 { \
637 ::RCF::ServerParameters< \
638 V , \
639 A1 > &p = \
640 ::RCF::AllocateServerParameters< \
641 V , \
642 A1 >()(session); \
643 RCF_UNUSED_VARIABLE(p); \
644 t.func( \
645 p.a1.get()); \
646 } \
647 }
648
649 // RCF_METHOD_V1_DECL
650 #define RCF_METHOD_V1_DECL(R,func , A1) \
651 RCF_METHOD_V1_DECL_(R,func , A1, RCF_MAKE_UNIQUE_ID(func, V1))
652
653 #define RCF_METHOD_V1_DECL_(R,func , A1, id) \
654 public: \
655 BOOST_STATIC_ASSERT(( boost::is_same<R, void>::value )); \
656 RCF_MAKE_NEXT_DISPATCH_ID(id) \
657 ::RCF::FutureImpl<V> func( \
658 ::RCF::RemoveOut<A1 >::type a1) \
659 { \
660 return func( \
661 ::RCF::CallOptions() , \
662 a1); \
663 } \
664 \
665 ::RCF::FutureImpl<V> func( \
666 const ::RCF::CallOptions &callOptions , \
667 ::RCF::RemoveOut<A1 >::type a1); \
668 \
669 void error__method_defined_out_of_order__##func( \
670 id * , \
671 ::RCF::RemoveOut<A1 >::type a1); \
672 \
673 const char * getFunctionName(const id &) \
674 { \
675 return #func; \
676 } \
677 const char * getArity(const id &) \
678 { \
679 return "V1"; \
680 } \
681 \
682 private: \
683 template<typename T> \
684 void invoke( \
685 const id &, \
686 ::RCF::RcfSession &session, \
687 T &t) \
688 { \
689 if (session.isInProcess()) \
690 { \
691 ::RCF::ClientParameters< \
692 V , \
693 A1 , V,V,V,V,V,V,V,V,V,V,V,V,V,V > &p = static_cast< \
694 ::RCF::ClientParameters< \
695 V , \
696 A1 , V,V,V,V,V,V,V,V,V,V,V,V,V,V > &>(* session.getInProcessParameters());\
697 RCF_UNUSED_VARIABLE(p); \
698 t.func( \
699 p.a1.get() ); \
700 } \
701 else \
702 { \
703 ::RCF::ServerParameters< \
704 V , \
705 A1 > &p = \
706 ::RCF::AllocateServerParameters< \
707 V , \
708 A1 >()(session); \
709 RCF_UNUSED_VARIABLE(p); \
710 t.func( \
711 p.a1.get()); \
712 } \
713 }
714
715 // RCF_METHOD_V1_DEF
716 #define RCF_METHOD_V1_DEF(R,func , A1) \
717 RCF_METHOD_V1_DEF_(R,func , A1, RCF_PP_CAT(rcf_interface_id_1_, func, R1, __LINE__), RCF_MAKE_UNIQUE_ID(func, R1), RCF_PP_CAT(rcf_interface_id_2_, func, R1, __LINE__))
718
719 #define RCF_METHOD_V1_DEF_(R,func , A1, interfaceId, funcId, genParms) \
720 RCF_CURRENT_STATIC_ID(interfaceId, RCF_interface_id_helper, int, int) \
721 typedef GeneratorParms<interfaceId> genParms; \
722 RCF_ADVANCE_STATIC_ID(funcId, RCF_def_dispatch_id_helper, ::RCF::Dummy<genParms::RcfClientT>, genParms::RcfClientT, static)\
723 RCF_EXPORT_INTERFACE ::RCF::FutureImpl<::RCF::Void> genParms::RcfClientT::func(\
724 const ::RCF::CallOptions &callOptions , \
725 ::RCF::RemoveOut<A1 >::type a1) \
726 { \
727 typedef ::RCF::Void V; \
728 getClientStub().setAsync(false); \
729 return RCF::FutureImpl<V >( \
730 ::RCF::AllocateClientParameters< \
731 V , \
732 A1 , \
733 V,V,V,V,V,V,V,V,V,V,V,V,V,V >()( \
734 getClientStub() , \
735 a1 , \
736 V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V()).r.get(),\
737 getClientStub(), \
738 mInterfaceName, \
739 funcId::value, \
740 callOptions.apply(getClientStub()), \
741 #func, \
742 "V1"); \
743 } \
744 void genParms::RcfClientT::error__method_defined_out_of_order__##func( \
745 funcId * , \
746 ::RCF::RemoveOut<A1 >::type a1) \
747 { \
748 }
749
750
751
752
753 //------------------------------------------------------------------------------
754 // Parameters - R2
755 //------------------------------------------------------------------------------
756
757 // RCF_METHOD_R2
758 #define RCF_METHOD_R2_INLINE(R,func , A1,A2) \
759 RCF_METHOD_R2_INLINE_(R,func , A1,A2, RCF_MAKE_UNIQUE_ID(func, R2))
760
761 #define RCF_METHOD_R2_INLINE_(R,func , A1,A2, id) \
762 public: \
763 RCF_MAKE_NEXT_DISPATCH_ID(id) \
764 ::RCF::FutureImpl<R > func( \
765 ::RCF::RemoveOut<A1 >::type a1, \
766 ::RCF::RemoveOut<A2 >::type a2) \
767 { \
768 return func( \
769 ::RCF::CallOptions() , \
770 a1,a2); \
771 } \
772 ::RCF::FutureImpl<R > func( \
773 const ::RCF::CallOptions &callOptions , \
774 ::RCF::RemoveOut<A1 >::type a1, \
775 ::RCF::RemoveOut<A2 >::type a2) \
776 { \
777 getClientStub().setAsync(false); \
778 return RCF::FutureImpl<R >( \
779 ::RCF::AllocateClientParameters< \
780 R , \
781 A1,A2 , \
782 V,V,V,V,V,V,V,V,V,V,V,V,V >()( \
783 getClientStub() , \
784 a1,a2 , \
785 V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V()).r.get(),\
786 getClientStub(), \
787 mInterfaceName, \
788 id::value, \
789 callOptions.apply(getClientStub()), \
790 #func, \
791 "R2"); \
792 } \
793 const char * getFunctionName(const id &) \
794 { \
795 return #func; \
796 } \
797 const char * getArity(const id &) \
798 { \
799 return "R2"; \
800 } \
801 \
802 private: \
803 template<typename T> \
804 void invoke( \
805 const id &, \
806 ::RCF::RcfSession &session, \
807 T &t) \
808 { \
809 if (session.isInProcess()) \
810 { \
811 ::RCF::ClientParameters< \
812 R , \
813 A1,A2 , V,V,V,V,V,V,V,V,V,V,V,V,V > &p = static_cast< \
814 ::RCF::ClientParameters< \
815 R , \
816 A1,A2 , V,V,V,V,V,V,V,V,V,V,V,V,V > &>(* session.getInProcessParameters());\
817 p.r.set( t.func( p.a1.get(), \
818 p.a2.get() ) ); \
819 } \
820 else \
821 { \
822 ::RCF::ServerParameters< \
823 R , \
824 A1,A2 > &p = \
825 ::RCF::AllocateServerParameters< \
826 R , \
827 A1,A2 >()(session); \
828 p.r.set( \
829 session.getAutoSend(), \
830 t.func( \
831 p.a1.get(), \
832 p.a2.get())); \
833 } \
834 }
835
836 // RCF_METHOD_R2_DECL
837 #define RCF_METHOD_R2_DECL(R,func , A1,A2) \
838 RCF_METHOD_R2_DECL_(R,func , A1,A2, RCF_MAKE_UNIQUE_ID(func, R2))
839
840 #define RCF_METHOD_R2_DECL_(R,func , A1,A2, id) \
841 public: \
842 RCF_MAKE_NEXT_DISPATCH_ID(id) \
843 ::RCF::FutureImpl<R > func( \
844 ::RCF::RemoveOut<A1 >::type a1, \
845 ::RCF::RemoveOut<A2 >::type a2) \
846 { \
847 return func( \
848 ::RCF::CallOptions() , \
849 a1,a2); \
850 } \
851 \
852 ::RCF::FutureImpl<R > func( \
853 const ::RCF::CallOptions &callOptions , \
854 ::RCF::RemoveOut<A1 >::type a1, \
855 ::RCF::RemoveOut<A2 >::type a2); \
856 \
857 void error__method_defined_out_of_order__##func( \
858 id * , \
859 ::RCF::RemoveOut<A1 >::type a1, \
860 ::RCF::RemoveOut<A2 >::type a2); \
861 \
862 const char * getFunctionName(const id &) \
863 { \
864 return #func; \
865 } \
866 const char * getArity(const id &) \
867 { \
868 return "R2"; \
869 } \
870 \
871 private: \
872 template<typename T> \
873 void invoke( \
874 const id &, \
875 ::RCF::RcfSession &session, \
876 T &t) \
877 { \
878 if (session.isInProcess()) \
879 { \
880 ::RCF::ClientParameters< \
881 R , \
882 A1,A2 , V,V,V,V,V,V,V,V,V,V,V,V,V > &p = static_cast< \
883 ::RCF::ClientParameters< \
884 R , \
885 A1,A2 , V,V,V,V,V,V,V,V,V,V,V,V,V > &>(* session.getInProcessParameters());\
886 p.r.set( t.func( p.a1.get(), \
887 p.a2.get() ) ); \
888 } \
889 else \
890 { \
891 ::RCF::ServerParameters< \
892 R , \
893 A1,A2 > &p = \
894 ::RCF::AllocateServerParameters< \
895 R , \
896 A1,A2 >()(session); \
897 p.r.set( \
898 session.getAutoSend(), \
899 t.func( \
900 p.a1.get(), \
901 p.a2.get())); \
902 } \
903 }
904
905 // RCF_METHOD_R2_DEF
906 #define RCF_METHOD_R2_DEF(R,func , A1,A2) \
907 RCF_METHOD_R2_DEF_(R,func , A1,A2, RCF_PP_CAT(rcf_interface_id_1_, func, R2, __LINE__), RCF_MAKE_UNIQUE_ID(func, R2), RCF_PP_CAT(rcf_interface_id_2_, func, R2, __LINE__))
908
909 #define RCF_METHOD_R2_DEF_(R,func , A1,A2, interfaceId, funcId, genParms) \
910 RCF_CURRENT_STATIC_ID(interfaceId, RCF_interface_id_helper, int, int) \
911 typedef GeneratorParms<interfaceId> genParms; \
912 RCF_ADVANCE_STATIC_ID(funcId, RCF_def_dispatch_id_helper, ::RCF::Dummy<genParms::RcfClientT>, genParms::RcfClientT, static)\
913 RCF_EXPORT_INTERFACE ::RCF::FutureImpl<R > genParms::RcfClientT::func( \
914 const ::RCF::CallOptions &callOptions , \
915 ::RCF::RemoveOut<A1 >::type a1, \
916 ::RCF::RemoveOut<A2 >::type a2) \
917 { \
918 getClientStub().setAsync(false); \
919 return RCF::FutureImpl<R >( \
920 ::RCF::AllocateClientParameters< \
921 R , \
922 A1,A2 , \
923 V,V,V,V,V,V,V,V,V,V,V,V,V >()( \
924 getClientStub() , \
925 a1,a2 , \
926 V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V()).r.get(),\
927 getClientStub(), \
928 mInterfaceName, \
929 funcId::value, \
930 callOptions.apply(getClientStub()), \
931 #func, \
932 "R2"); \
933 } \
934 void genParms::RcfClientT::error__method_defined_out_of_order__##func( \
935 funcId * , \
936 ::RCF::RemoveOut<A1 >::type a1, \
937 ::RCF::RemoveOut<A2 >::type a2) \
938 { \
939 }
940
941
942
943 //------------------------------------------------------------------------------
944 // Parameters - V2
945 //------------------------------------------------------------------------------
946
947 // RCF_METHOD_V2
948 #define RCF_METHOD_V2_INLINE(R,func , A1,A2) \
949 RCF_METHOD_V2_INLINE_(R,func , A1,A2, RCF_MAKE_UNIQUE_ID(func, V2))
950
951 #define RCF_METHOD_V2_INLINE_(R,func , A1,A2, id) \
952 public: \
953 BOOST_STATIC_ASSERT(( boost::is_same<R, void>::value )); \
954 RCF_MAKE_NEXT_DISPATCH_ID(id) \
955 ::RCF::FutureImpl<V> func( \
956 ::RCF::RemoveOut<A1 >::type a1, \
957 ::RCF::RemoveOut<A2 >::type a2) \
958 { \
959 return func( \
960 ::RCF::CallOptions() , \
961 a1,a2); \
962 } \
963 ::RCF::FutureImpl<V> func( \
964 const ::RCF::CallOptions &callOptions , \
965 ::RCF::RemoveOut<A1 >::type a1, \
966 ::RCF::RemoveOut<A2 >::type a2) \
967 { \
968 getClientStub().setAsync(false); \
969 return RCF::FutureImpl<V>( \
970 ::RCF::AllocateClientParameters< \
971 V , \
972 A1,A2 , \
973 V,V,V,V,V,V,V,V,V,V,V,V,V >()( \
974 getClientStub() , \
975 a1,a2 , \
976 V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V()).r.get(),\
977 getClientStub(), \
978 mInterfaceName, \
979 id::value, \
980 callOptions.apply(getClientStub()), \
981 #func, \
982 "V2"); \
983 } \
984 const char * getFunctionName(const id &) \
985 { \
986 return #func; \
987 } \
988 const char * getArity(const id &) \
989 { \
990 return "V2"; \
991 } \
992 \
993 private: \
994 template<typename T> \
995 void invoke( \
996 const id &, \
997 ::RCF::RcfSession &session, \
998 T &t) \
999 { \
1000 if (session.isInProcess()) \
1001 { \
1002 ::RCF::ClientParameters< \
1003 V , \
1004 A1,A2 , V,V,V,V,V,V,V,V,V,V,V,V,V > &p = static_cast< \
1005 ::RCF::ClientParameters< \
1006 V , \
1007 A1,A2 , V,V,V,V,V,V,V,V,V,V,V,V,V > &>(* session.getInProcessParameters());\
1008 RCF_UNUSED_VARIABLE(p); \
1009 t.func( \
1010 p.a1.get(), \
1011 p.a2.get() ); \
1012 } \
1013 else \
1014 { \
1015 ::RCF::ServerParameters< \
1016 V , \
1017 A1,A2 > &p = \
1018 ::RCF::AllocateServerParameters< \
1019 V , \
1020 A1,A2 >()(session); \
1021 RCF_UNUSED_VARIABLE(p); \
1022 t.func( \
1023 p.a1.get(), \
1024 p.a2.get()); \
1025 } \
1026 }
1027
1028 // RCF_METHOD_V2_DECL
1029 #define RCF_METHOD_V2_DECL(R,func , A1,A2) \
1030 RCF_METHOD_V2_DECL_(R,func , A1,A2, RCF_MAKE_UNIQUE_ID(func, V2))
1031
1032 #define RCF_METHOD_V2_DECL_(R,func , A1,A2, id) \
1033 public: \
1034 BOOST_STATIC_ASSERT(( boost::is_same<R, void>::value )); \
1035 RCF_MAKE_NEXT_DISPATCH_ID(id) \
1036 ::RCF::FutureImpl<V> func( \
1037 ::RCF::RemoveOut<A1 >::type a1, \
1038 ::RCF::RemoveOut<A2 >::type a2) \
1039 { \
1040 return func( \
1041 ::RCF::CallOptions() , \
1042 a1,a2); \
1043 } \
1044 \
1045 ::RCF::FutureImpl<V> func( \
1046 const ::RCF::CallOptions &callOptions , \
1047 ::RCF::RemoveOut<A1 >::type a1, \
1048 ::RCF::RemoveOut<A2 >::type a2); \
1049 \
1050 void error__method_defined_out_of_order__##func( \
1051 id * , \
1052 ::RCF::RemoveOut<A1 >::type a1, \
1053 ::RCF::RemoveOut<A2 >::type a2); \
1054 \
1055 const char * getFunctionName(const id &) \
1056 { \
1057 return #func; \
1058 } \
1059 const char * getArity(const id &) \
1060 { \
1061 return "V2"; \
1062 } \
1063 \
1064 private: \
1065 template<typename T> \
1066 void invoke( \
1067 const id &, \
1068 ::RCF::RcfSession &session, \
1069 T &t) \
1070 { \
1071 if (session.isInProcess()) \
1072 { \
1073 ::RCF::ClientParameters< \
1074 V , \
1075 A1,A2 , V,V,V,V,V,V,V,V,V,V,V,V,V > &p = static_cast< \
1076 ::RCF::ClientParameters< \
1077 V , \
1078 A1,A2 , V,V,V,V,V,V,V,V,V,V,V,V,V > &>(* session.getInProcessParameters());\
1079 RCF_UNUSED_VARIABLE(p); \
1080 t.func( \
1081 p.a1.get(), \
1082 p.a2.get() ); \
1083 } \
1084 else \
1085 { \
1086 ::RCF::ServerParameters< \
1087 V , \
1088 A1,A2 > &p = \
1089 ::RCF::AllocateServerParameters< \
1090 V , \
1091 A1,A2 >()(session); \
1092 RCF_UNUSED_VARIABLE(p); \
1093 t.func( \
1094 p.a1.get(), \
1095 p.a2.get()); \
1096 } \
1097 }
1098
1099 // RCF_METHOD_V2_DEF
1100 #define RCF_METHOD_V2_DEF(R,func , A1,A2) \
1101 RCF_METHOD_V2_DEF_(R,func , A1,A2, RCF_PP_CAT(rcf_interface_id_1_, func, R2, __LINE__), RCF_MAKE_UNIQUE_ID(func, R2), RCF_PP_CAT(rcf_interface_id_2_, func, R2, __LINE__))
1102
1103 #define RCF_METHOD_V2_DEF_(R,func , A1,A2, interfaceId, funcId, genParms) \
1104 RCF_CURRENT_STATIC_ID(interfaceId, RCF_interface_id_helper, int, int) \
1105 typedef GeneratorParms<interfaceId> genParms; \
1106 RCF_ADVANCE_STATIC_ID(funcId, RCF_def_dispatch_id_helper, ::RCF::Dummy<genParms::RcfClientT>, genParms::RcfClientT, static)\
1107 RCF_EXPORT_INTERFACE ::RCF::FutureImpl<::RCF::Void> genParms::RcfClientT::func(\
1108 const ::RCF::CallOptions &callOptions , \
1109 ::RCF::RemoveOut<A1 >::type a1, \
1110 ::RCF::RemoveOut<A2 >::type a2) \
1111 { \
1112 typedef ::RCF::Void V; \
1113 getClientStub().setAsync(false); \
1114 return RCF::FutureImpl<V >( \
1115 ::RCF::AllocateClientParameters< \
1116 V , \
1117 A1,A2 , \
1118 V,V,V,V,V,V,V,V,V,V,V,V,V >()( \
1119 getClientStub() , \
1120 a1,a2 , \
1121 V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V()).r.get(),\
1122 getClientStub(), \
1123 mInterfaceName, \
1124 funcId::value, \
1125 callOptions.apply(getClientStub()), \
1126 #func, \
1127 "V2"); \
1128 } \
1129 void genParms::RcfClientT::error__method_defined_out_of_order__##func( \
1130 funcId * , \
1131 ::RCF::RemoveOut<A1 >::type a1, \
1132 ::RCF::RemoveOut<A2 >::type a2) \
1133 { \
1134 }
1135
1136
1137
1138
1139 //------------------------------------------------------------------------------
1140 // Parameters - R3
1141 //------------------------------------------------------------------------------
1142
1143 // RCF_METHOD_R3
1144 #define RCF_METHOD_R3_INLINE(R,func , A1,A2,A3) \
1145 RCF_METHOD_R3_INLINE_(R,func , A1,A2,A3, RCF_MAKE_UNIQUE_ID(func, R3))
1146
1147 #define RCF_METHOD_R3_INLINE_(R,func , A1,A2,A3, id) \
1148 public: \
1149 RCF_MAKE_NEXT_DISPATCH_ID(id) \
1150 ::RCF::FutureImpl<R > func( \
1151 ::RCF::RemoveOut<A1 >::type a1, \
1152 ::RCF::RemoveOut<A2 >::type a2, \
1153 ::RCF::RemoveOut<A3 >::type a3) \
1154 { \
1155 return func( \
1156 ::RCF::CallOptions() , \
1157 a1,a2,a3); \
1158 } \
1159 ::RCF::FutureImpl<R > func( \
1160 const ::RCF::CallOptions &callOptions , \
1161 ::RCF::RemoveOut<A1 >::type a1, \
1162 ::RCF::RemoveOut<A2 >::type a2, \
1163 ::RCF::RemoveOut<A3 >::type a3) \
1164 { \
1165 getClientStub().setAsync(false); \
1166 return RCF::FutureImpl<R >( \
1167 ::RCF::AllocateClientParameters< \
1168 R , \
1169 A1,A2,A3 , \
1170 V,V,V,V,V,V,V,V,V,V,V,V >()( \
1171 getClientStub() , \
1172 a1,a2,a3 , \
1173 V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V()).r.get(),\
1174 getClientStub(), \
1175 mInterfaceName, \
1176 id::value, \
1177 callOptions.apply(getClientStub()), \
1178 #func, \
1179 "R3"); \
1180 } \
1181 const char * getFunctionName(const id &) \
1182 { \
1183 return #func; \
1184 } \
1185 const char * getArity(const id &) \
1186 { \
1187 return "R3"; \
1188 } \
1189 \
1190 private: \
1191 template<typename T> \
1192 void invoke( \
1193 const id &, \
1194 ::RCF::RcfSession &session, \
1195 T &t) \
1196 { \
1197 if (session.isInProcess()) \
1198 { \
1199 ::RCF::ClientParameters< \
1200 R , \
1201 A1,A2,A3 , V,V,V,V,V,V,V,V,V,V,V,V > &p = static_cast<\
1202 ::RCF::ClientParameters< \
1203 R , \
1204 A1,A2,A3 , V,V,V,V,V,V,V,V,V,V,V,V > &>(* session.getInProcessParameters());\
1205 p.r.set( t.func( p.a1.get(), \
1206 p.a2.get(), \
1207 p.a3.get() ) ); \
1208 } \
1209 else \
1210 { \
1211 ::RCF::ServerParameters< \
1212 R , \
1213 A1,A2,A3 > &p = \
1214 ::RCF::AllocateServerParameters< \
1215 R , \
1216 A1,A2,A3 >()(session); \
1217 p.r.set( \
1218 session.getAutoSend(), \
1219 t.func( \
1220 p.a1.get(), \
1221 p.a2.get(), \
1222 p.a3.get())); \
1223 } \
1224 }
1225
1226 // RCF_METHOD_R3_DECL
1227 #define RCF_METHOD_R3_DECL(R,func , A1,A2,A3) \
1228 RCF_METHOD_R3_DECL_(R,func , A1,A2,A3, RCF_MAKE_UNIQUE_ID(func, R3))
1229
1230 #define RCF_METHOD_R3_DECL_(R,func , A1,A2,A3, id) \
1231 public: \
1232 RCF_MAKE_NEXT_DISPATCH_ID(id) \
1233 ::RCF::FutureImpl<R > func( \
1234 ::RCF::RemoveOut<A1 >::type a1, \
1235 ::RCF::RemoveOut<A2 >::type a2, \
1236 ::RCF::RemoveOut<A3 >::type a3) \
1237 { \
1238 return func( \
1239 ::RCF::CallOptions() , \
1240 a1,a2,a3); \
1241 } \
1242 \
1243 ::RCF::FutureImpl<R > func( \
1244 const ::RCF::CallOptions &callOptions , \
1245 ::RCF::RemoveOut<A1 >::type a1, \
1246 ::RCF::RemoveOut<A2 >::type a2, \
1247 ::RCF::RemoveOut<A3 >::type a3); \
1248 \
1249 void error__method_defined_out_of_order__##func( \
1250 id * , \
1251 ::RCF::RemoveOut<A1 >::type a1, \
1252 ::RCF::RemoveOut<A2 >::type a2, \
1253 ::RCF::RemoveOut<A3 >::type a3); \
1254 \
1255 const char * getFunctionName(const id &) \
1256 { \
1257 return #func; \
1258 } \
1259 const char * getArity(const id &) \
1260 { \
1261 return "R3"; \
1262 } \
1263 \
1264 private: \
1265 template<typename T> \
1266 void invoke( \
1267 const id &, \
1268 ::RCF::RcfSession &session, \
1269 T &t) \
1270 { \
1271 if (session.isInProcess()) \
1272 { \
1273 ::RCF::ClientParameters< \
1274 R , \
1275 A1,A2,A3 , V,V,V,V,V,V,V,V,V,V,V,V > &p = static_cast<\
1276 ::RCF::ClientParameters< \
1277 R , \
1278 A1,A2,A3 , V,V,V,V,V,V,V,V,V,V,V,V > &>(* session.getInProcessParameters());\
1279 p.r.set( t.func( p.a1.get(), \
1280 p.a2.get(), \
1281 p.a3.get() ) ); \
1282 } \
1283 else \
1284 { \
1285 ::RCF::ServerParameters< \
1286 R , \
1287 A1,A2,A3 > &p = \
1288 ::RCF::AllocateServerParameters< \
1289 R , \
1290 A1,A2,A3 >()(session); \
1291 p.r.set( \
1292 session.getAutoSend(), \
1293 t.func( \
1294 p.a1.get(), \
1295 p.a2.get(), \
1296 p.a3.get())); \
1297 } \
1298 }
1299
1300 // RCF_METHOD_R3_DEF
1301 #define RCF_METHOD_R3_DEF(R,func , A1,A2,A3) \
1302 RCF_METHOD_R3_DEF_(R,func , A1,A2,A3, RCF_PP_CAT(rcf_interface_id_1_, func, R3, __LINE__), RCF_MAKE_UNIQUE_ID(func, R3), RCF_PP_CAT(rcf_interface_id_2_, func, R3, __LINE__))
1303
1304 #define RCF_METHOD_R3_DEF_(R,func , A1,A2,A3, interfaceId, funcId, genParms) \
1305 RCF_CURRENT_STATIC_ID(interfaceId, RCF_interface_id_helper, int, int) \
1306 typedef GeneratorParms<interfaceId> genParms; \
1307 RCF_ADVANCE_STATIC_ID(funcId, RCF_def_dispatch_id_helper, ::RCF::Dummy<genParms::RcfClientT>, genParms::RcfClientT, static)\
1308 RCF_EXPORT_INTERFACE ::RCF::FutureImpl<R > genParms::RcfClientT::func( \
1309 const ::RCF::CallOptions &callOptions , \
1310 ::RCF::RemoveOut<A1 >::type a1, \
1311 ::RCF::RemoveOut<A2 >::type a2, \
1312 ::RCF::RemoveOut<A3 >::type a3) \
1313 { \
1314 getClientStub().setAsync(false); \
1315 return RCF::FutureImpl<R >( \
1316 ::RCF::AllocateClientParameters< \
1317 R , \
1318 A1,A2,A3 , \
1319 V,V,V,V,V,V,V,V,V,V,V,V >()( \
1320 getClientStub() , \
1321 a1,a2,a3 , \
1322 V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V()).r.get(), \
1323 getClientStub(), \
1324 mInterfaceName, \
1325 funcId::value, \
1326 callOptions.apply(getClientStub()), \
1327 #func, \
1328 "R3"); \
1329 } \
1330 void genParms::RcfClientT::error__method_defined_out_of_order__##func( \
1331 funcId * , \
1332 ::RCF::RemoveOut<A1 >::type a1, \
1333 ::RCF::RemoveOut<A2 >::type a2, \
1334 ::RCF::RemoveOut<A3 >::type a3) \
1335 { \
1336 }
1337
1338
1339
1340 //------------------------------------------------------------------------------
1341 // Parameters - V3
1342 //------------------------------------------------------------------------------
1343
1344 // RCF_METHOD_V3
1345 #define RCF_METHOD_V3_INLINE(R,func , A1,A2,A3) \
1346 RCF_METHOD_V3_INLINE_(R,func , A1,A2,A3, RCF_MAKE_UNIQUE_ID(func, V3))
1347
1348 #define RCF_METHOD_V3_INLINE_(R,func , A1,A2,A3, id) \
1349 public: \
1350 BOOST_STATIC_ASSERT(( boost::is_same<R, void>::value )); \
1351 RCF_MAKE_NEXT_DISPATCH_ID(id) \
1352 ::RCF::FutureImpl<V> func( \
1353 ::RCF::RemoveOut<A1 >::type a1, \
1354 ::RCF::RemoveOut<A2 >::type a2, \
1355 ::RCF::RemoveOut<A3 >::type a3) \
1356 { \
1357 return func( \
1358 ::RCF::CallOptions() , \
1359 a1,a2,a3); \
1360 } \
1361 ::RCF::FutureImpl<V> func( \
1362 const ::RCF::CallOptions &callOptions , \
1363 ::RCF::RemoveOut<A1 >::type a1, \
1364 ::RCF::RemoveOut<A2 >::type a2, \
1365 ::RCF::RemoveOut<A3 >::type a3) \
1366 { \
1367 getClientStub().setAsync(false); \
1368 return RCF::FutureImpl<V>( \
1369 ::RCF::AllocateClientParameters< \
1370 V , \
1371 A1,A2,A3 , \
1372 V,V,V,V,V,V,V,V,V,V,V,V >()( \
1373 getClientStub() , \
1374 a1,a2,a3 , \
1375 V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V()).r.get(),\
1376 getClientStub(), \
1377 mInterfaceName, \
1378 id::value, \
1379 callOptions.apply(getClientStub()), \
1380 #func, \
1381 "V3"); \
1382 } \
1383 const char * getFunctionName(const id &) \
1384 { \
1385 return #func; \
1386 } \
1387 const char * getArity(const id &) \
1388 { \
1389 return "V3"; \
1390 } \
1391 \
1392 private: \
1393 template<typename T> \
1394 void invoke( \
1395 const id &, \
1396 ::RCF::RcfSession &session, \
1397 T &t) \
1398 { \
1399 if (session.isInProcess()) \
1400 { \
1401 ::RCF::ClientParameters< \
1402 V , \
1403 A1,A2,A3 , V,V,V,V,V,V,V,V,V,V,V,V > &p = static_cast<\
1404 ::RCF::ClientParameters< \
1405 V , \
1406 A1,A2,A3 , V,V,V,V,V,V,V,V,V,V,V,V > &>(* session.getInProcessParameters());\
1407 RCF_UNUSED_VARIABLE(p); \
1408 t.func( \
1409 p.a1.get(), \
1410 p.a2.get(), \
1411 p.a3.get() ); \
1412 } \
1413 else \
1414 { \
1415 ::RCF::ServerParameters< \
1416 V , \
1417 A1,A2,A3 > &p = \
1418 ::RCF::AllocateServerParameters< \
1419 V , \
1420 A1,A2,A3 >()(session); \
1421 RCF_UNUSED_VARIABLE(p); \
1422 t.func( \
1423 p.a1.get(), \
1424 p.a2.get(), \
1425 p.a3.get()); \
1426 } \
1427 }
1428
1429 // RCF_METHOD_V3_DECL
1430 #define RCF_METHOD_V3_DECL(R,func , A1,A2,A3) \
1431 RCF_METHOD_V3_DECL_(R,func , A1,A2,A3, RCF_MAKE_UNIQUE_ID(func, V3))
1432
1433 #define RCF_METHOD_V3_DECL_(R,func , A1,A2,A3, id) \
1434 public: \
1435 BOOST_STATIC_ASSERT(( boost::is_same<R, void>::value )); \
1436 RCF_MAKE_NEXT_DISPATCH_ID(id) \
1437 ::RCF::FutureImpl<V> func( \
1438 ::RCF::RemoveOut<A1 >::type a1, \
1439 ::RCF::RemoveOut<A2 >::type a2, \
1440 ::RCF::RemoveOut<A3 >::type a3) \
1441 { \
1442 return func( \
1443 ::RCF::CallOptions() , \
1444 a1,a2,a3); \
1445 } \
1446 \
1447 ::RCF::FutureImpl<V> func( \
1448 const ::RCF::CallOptions &callOptions , \
1449 ::RCF::RemoveOut<A1 >::type a1, \
1450 ::RCF::RemoveOut<A2 >::type a2, \
1451 ::RCF::RemoveOut<A3 >::type a3); \
1452 \
1453 void error__method_defined_out_of_order__##func( \
1454 id * , \
1455 ::RCF::RemoveOut<A1 >::type a1, \
1456 ::RCF::RemoveOut<A2 >::type a2, \
1457 ::RCF::RemoveOut<A3 >::type a3); \
1458 \
1459 const char * getFunctionName(const id &) \
1460 { \
1461 return #func; \
1462 } \
1463 const char * getArity(const id &) \
1464 { \
1465 return "V3"; \
1466 } \
1467 \
1468 private: \
1469 template<typename T> \
1470 void invoke( \
1471 const id &, \
1472 ::RCF::RcfSession &session, \
1473 T &t) \
1474 { \
1475 if (session.isInProcess()) \
1476 { \
1477 ::RCF::ClientParameters< \
1478 V , \
1479 A1,A2,A3 , V,V,V,V,V,V,V,V,V,V,V,V > &p = static_cast<\
1480 ::RCF::ClientParameters< \
1481 V , \
1482 A1,A2,A3 , V,V,V,V,V,V,V,V,V,V,V,V > &>(* session.getInProcessParameters());\
1483 RCF_UNUSED_VARIABLE(p); \
1484 t.func( \
1485 p.a1.get(), \
1486 p.a2.get(), \
1487 p.a3.get() ); \
1488 } \
1489 else \
1490 { \
1491 ::RCF::ServerParameters< \
1492 V , \
1493 A1,A2,A3 > &p = \
1494 ::RCF::AllocateServerParameters< \
1495 V , \
1496 A1,A2,A3 >()(session); \
1497 RCF_UNUSED_VARIABLE(p); \
1498 t.func( \
1499 p.a1.get(), \
1500 p.a2.get(), \
1501 p.a3.get()); \
1502 } \
1503 }
1504
1505 // RCF_METHOD_V3_DEF
1506 #define RCF_METHOD_V3_DEF(R,func , A1,A2,A3) \
1507 RCF_METHOD_V3_DEF_(R,func , A1,A2,A3, RCF_PP_CAT(rcf_interface_id_1_, func, R3, __LINE__), RCF_MAKE_UNIQUE_ID(func, R3), RCF_PP_CAT(rcf_interface_id_2_, func, R3, __LINE__))
1508
1509 #define RCF_METHOD_V3_DEF_(R,func , A1,A2,A3, interfaceId, funcId, genParms) \
1510 RCF_CURRENT_STATIC_ID(interfaceId, RCF_interface_id_helper, int, int) \
1511 typedef GeneratorParms<interfaceId> genParms; \
1512 RCF_ADVANCE_STATIC_ID(funcId, RCF_def_dispatch_id_helper, ::RCF::Dummy<genParms::RcfClientT>, genParms::RcfClientT, static)\
1513 RCF_EXPORT_INTERFACE ::RCF::FutureImpl<::RCF::Void> genParms::RcfClientT::func(\
1514 const ::RCF::CallOptions &callOptions , \
1515 ::RCF::RemoveOut<A1 >::type a1, \
1516 ::RCF::RemoveOut<A2 >::type a2, \
1517 ::RCF::RemoveOut<A3 >::type a3) \
1518 { \
1519 typedef ::RCF::Void V; \
1520 getClientStub().setAsync(false); \
1521 return RCF::FutureImpl<V >( \
1522 ::RCF::AllocateClientParameters< \
1523 V , \
1524 A1,A2,A3 , \
1525 V,V,V,V,V,V,V,V,V,V,V,V >()( \
1526 getClientStub() , \
1527 a1,a2,a3 , \
1528 V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V()).r.get(), \
1529 getClientStub(), \
1530 mInterfaceName, \
1531 funcId::value, \
1532 callOptions.apply(getClientStub()), \
1533 #func, \
1534 "V3"); \
1535 } \
1536 void genParms::RcfClientT::error__method_defined_out_of_order__##func( \
1537 funcId * , \
1538 ::RCF::RemoveOut<A1 >::type a1, \
1539 ::RCF::RemoveOut<A2 >::type a2, \
1540 ::RCF::RemoveOut<A3 >::type a3) \
1541 { \
1542 }
1543
1544
1545
1546
1547 //------------------------------------------------------------------------------
1548 // Parameters - R4
1549 //------------------------------------------------------------------------------
1550
1551 // RCF_METHOD_R4
1552 #define RCF_METHOD_R4_INLINE(R,func , A1,A2,A3,A4) \
1553 RCF_METHOD_R4_INLINE_(R,func , A1,A2,A3,A4, RCF_MAKE_UNIQUE_ID(func, R4))
1554
1555 #define RCF_METHOD_R4_INLINE_(R,func , A1,A2,A3,A4, id) \
1556 public: \
1557 RCF_MAKE_NEXT_DISPATCH_ID(id) \
1558 ::RCF::FutureImpl<R > func( \
1559 ::RCF::RemoveOut<A1 >::type a1, \
1560 ::RCF::RemoveOut<A2 >::type a2, \
1561 ::RCF::RemoveOut<A3 >::type a3, \
1562 ::RCF::RemoveOut<A4 >::type a4) \
1563 { \
1564 return func( \
1565 ::RCF::CallOptions() , \
1566 a1,a2,a3,a4); \
1567 } \
1568 ::RCF::FutureImpl<R > func( \
1569 const ::RCF::CallOptions &callOptions , \
1570 ::RCF::RemoveOut<A1 >::type a1, \
1571 ::RCF::RemoveOut<A2 >::type a2, \
1572 ::RCF::RemoveOut<A3 >::type a3, \
1573 ::RCF::RemoveOut<A4 >::type a4) \
1574 { \
1575 getClientStub().setAsync(false); \
1576 return RCF::FutureImpl<R >( \
1577 ::RCF::AllocateClientParameters< \
1578 R , \
1579 A1,A2,A3,A4 , \
1580 V,V,V,V,V,V,V,V,V,V,V >()( \
1581 getClientStub() , \
1582 a1,a2,a3,a4 , \
1583 V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V()).r.get(),\
1584 getClientStub(), \
1585 mInterfaceName, \
1586 id::value, \
1587 callOptions.apply(getClientStub()), \
1588 #func, \
1589 "R4"); \
1590 } \
1591 const char * getFunctionName(const id &) \
1592 { \
1593 return #func; \
1594 } \
1595 const char * getArity(const id &) \
1596 { \
1597 return "R4"; \
1598 } \
1599 \
1600 private: \
1601 template<typename T> \
1602 void invoke( \
1603 const id &, \
1604 ::RCF::RcfSession &session, \
1605 T &t) \
1606 { \
1607 if (session.isInProcess()) \
1608 { \
1609 ::RCF::ClientParameters< \
1610 R , \
1611 A1,A2,A3,A4 , V,V,V,V,V,V,V,V,V,V,V > &p = static_cast<\
1612 ::RCF::ClientParameters< \
1613 R , \
1614 A1,A2,A3,A4 , V,V,V,V,V,V,V,V,V,V,V > &>(* session.getInProcessParameters());\
1615 p.r.set( t.func( p.a1.get(), \
1616 p.a2.get(), \
1617 p.a3.get(), \
1618 p.a4.get() ) ); \
1619 } \
1620 else \
1621 { \
1622 ::RCF::ServerParameters< \
1623 R , \
1624 A1,A2,A3,A4 > &p = \
1625 ::RCF::AllocateServerParameters< \
1626 R , \
1627 A1,A2,A3,A4 >()(session); \
1628 p.r.set( \
1629 session.getAutoSend(), \
1630 t.func( \
1631 p.a1.get(), \
1632 p.a2.get(), \
1633 p.a3.get(), \
1634 p.a4.get())); \
1635 } \
1636 }
1637
1638 // RCF_METHOD_R4_DECL
1639 #define RCF_METHOD_R4_DECL(R,func , A1,A2,A3,A4) \
1640 RCF_METHOD_R4_DECL_(R,func , A1,A2,A3,A4, RCF_MAKE_UNIQUE_ID(func, R4))
1641
1642 #define RCF_METHOD_R4_DECL_(R,func , A1,A2,A3,A4, id) \
1643 public: \
1644 RCF_MAKE_NEXT_DISPATCH_ID(id) \
1645 ::RCF::FutureImpl<R > func( \
1646 ::RCF::RemoveOut<A1 >::type a1, \
1647 ::RCF::RemoveOut<A2 >::type a2, \
1648 ::RCF::RemoveOut<A3 >::type a3, \
1649 ::RCF::RemoveOut<A4 >::type a4) \
1650 { \
1651 return func( \
1652 ::RCF::CallOptions() , \
1653 a1,a2,a3,a4); \
1654 } \
1655 \
1656 ::RCF::FutureImpl<R > func( \
1657 const ::RCF::CallOptions &callOptions , \
1658 ::RCF::RemoveOut<A1 >::type a1, \
1659 ::RCF::RemoveOut<A2 >::type a2, \
1660 ::RCF::RemoveOut<A3 >::type a3, \
1661 ::RCF::RemoveOut<A4 >::type a4); \
1662 \
1663 void error__method_defined_out_of_order__##func( \
1664 id * , \
1665 ::RCF::RemoveOut<A1 >::type a1, \
1666 ::RCF::RemoveOut<A2 >::type a2, \
1667 ::RCF::RemoveOut<A3 >::type a3, \
1668 ::RCF::RemoveOut<A4 >::type a4); \
1669 \
1670 const char * getFunctionName(const id &) \
1671 { \
1672 return #func; \
1673 } \
1674 const char * getArity(const id &) \
1675 { \
1676 return "R4"; \
1677 } \
1678 \
1679 private: \
1680 template<typename T> \
1681 void invoke( \
1682 const id &, \
1683 ::RCF::RcfSession &session, \
1684 T &t) \
1685 { \
1686 if (session.isInProcess()) \
1687 { \
1688 ::RCF::ClientParameters< \
1689 R , \
1690 A1,A2,A3,A4 , V,V,V,V,V,V,V,V,V,V,V > &p = static_cast<\
1691 ::RCF::ClientParameters< \
1692 R , \
1693 A1,A2,A3,A4 , V,V,V,V,V,V,V,V,V,V,V > &>(* session.getInProcessParameters());\
1694 p.r.set( t.func( p.a1.get(), \
1695 p.a2.get(), \
1696 p.a3.get(), \
1697 p.a4.get() ) ); \
1698 } \
1699 else \
1700 { \
1701 ::RCF::ServerParameters< \
1702 R , \
1703 A1,A2,A3,A4 > &p = \
1704 ::RCF::AllocateServerParameters< \
1705 R , \
1706 A1,A2,A3,A4 >()(session); \
1707 p.r.set( \
1708 session.getAutoSend(), \
1709 t.func( \
1710 p.a1.get(), \
1711 p.a2.get(), \
1712 p.a3.get(), \
1713 p.a4.get())); \
1714 } \
1715 }
1716
1717 // RCF_METHOD_R4_DEF
1718 #define RCF_METHOD_R4_DEF(R,func , A1,A2,A3,A4) \
1719 RCF_METHOD_R4_DEF_(R,func , A1,A2,A3,A4, RCF_PP_CAT(rcf_interface_id_1_, func, R4, __LINE__), RCF_MAKE_UNIQUE_ID(func, R4), RCF_PP_CAT(rcf_interface_id_2_, func, R4, __LINE__))
1720
1721 #define RCF_METHOD_R4_DEF_(R,func , A1,A2,A3,A4, interfaceId, funcId, genParms)\
1722 RCF_CURRENT_STATIC_ID(interfaceId, RCF_interface_id_helper, int, int) \
1723 typedef GeneratorParms<interfaceId> genParms; \
1724 RCF_ADVANCE_STATIC_ID(funcId, RCF_def_dispatch_id_helper, ::RCF::Dummy<genParms::RcfClientT>, genParms::RcfClientT, static)\
1725 RCF_EXPORT_INTERFACE ::RCF::FutureImpl<R > genParms::RcfClientT::func( \
1726 const ::RCF::CallOptions &callOptions , \
1727 ::RCF::RemoveOut<A1 >::type a1, \
1728 ::RCF::RemoveOut<A2 >::type a2, \
1729 ::RCF::RemoveOut<A3 >::type a3, \
1730 ::RCF::RemoveOut<A4 >::type a4) \
1731 { \
1732 getClientStub().setAsync(false); \
1733 return RCF::FutureImpl<R >( \
1734 ::RCF::AllocateClientParameters< \
1735 R , \
1736 A1,A2,A3,A4 , \
1737 V,V,V,V,V,V,V,V,V,V,V >()( \
1738 getClientStub() , \
1739 a1,a2,a3,a4 , \
1740 V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V()).r.get(), \
1741 getClientStub(), \
1742 mInterfaceName, \
1743 funcId::value, \
1744 callOptions.apply(getClientStub()), \
1745 #func, \
1746 "R4"); \
1747 } \
1748 void genParms::RcfClientT::error__method_defined_out_of_order__##func( \
1749 funcId * , \
1750 ::RCF::RemoveOut<A1 >::type a1, \
1751 ::RCF::RemoveOut<A2 >::type a2, \
1752 ::RCF::RemoveOut<A3 >::type a3, \
1753 ::RCF::RemoveOut<A4 >::type a4) \
1754 { \
1755 }
1756
1757
1758
1759 //------------------------------------------------------------------------------
1760 // Parameters - V4
1761 //------------------------------------------------------------------------------
1762
1763 // RCF_METHOD_V4
1764 #define RCF_METHOD_V4_INLINE(R,func , A1,A2,A3,A4) \
1765 RCF_METHOD_V4_INLINE_(R,func , A1,A2,A3,A4, RCF_MAKE_UNIQUE_ID(func, V4))
1766
1767 #define RCF_METHOD_V4_INLINE_(R,func , A1,A2,A3,A4, id) \
1768 public: \
1769 BOOST_STATIC_ASSERT(( boost::is_same<R, void>::value )); \
1770 RCF_MAKE_NEXT_DISPATCH_ID(id) \
1771 ::RCF::FutureImpl<V> func( \
1772 ::RCF::RemoveOut<A1 >::type a1, \
1773 ::RCF::RemoveOut<A2 >::type a2, \
1774 ::RCF::RemoveOut<A3 >::type a3, \
1775 ::RCF::RemoveOut<A4 >::type a4) \
1776 { \
1777 return func( \
1778 ::RCF::CallOptions() , \
1779 a1,a2,a3,a4); \
1780 } \
1781 ::RCF::FutureImpl<V> func( \
1782 const ::RCF::CallOptions &callOptions , \
1783 ::RCF::RemoveOut<A1 >::type a1, \
1784 ::RCF::RemoveOut<A2 >::type a2, \
1785 ::RCF::RemoveOut<A3 >::type a3, \
1786 ::RCF::RemoveOut<A4 >::type a4) \
1787 { \
1788 getClientStub().setAsync(false); \
1789 return RCF::FutureImpl<V>( \
1790 ::RCF::AllocateClientParameters< \
1791 V , \
1792 A1,A2,A3,A4 , \
1793 V,V,V,V,V,V,V,V,V,V,V >()( \
1794 getClientStub() , \
1795 a1,a2,a3,a4 , \
1796 V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V()).r.get(),\
1797 getClientStub(), \
1798 mInterfaceName, \
1799 id::value, \
1800 callOptions.apply(getClientStub()), \
1801 #func, \
1802 "V4"); \
1803 } \
1804 const char * getFunctionName(const id &) \
1805 { \
1806 return #func; \
1807 } \
1808 const char * getArity(const id &) \
1809 { \
1810 return "V4"; \
1811 } \
1812 \
1813 private: \
1814 template<typename T> \
1815 void invoke( \
1816 const id &, \
1817 ::RCF::RcfSession &session, \
1818 T &t) \
1819 { \
1820 if (session.isInProcess()) \
1821 { \
1822 ::RCF::ClientParameters< \
1823 V , \
1824 A1,A2,A3,A4 , V,V,V,V,V,V,V,V,V,V,V > &p = static_cast<\
1825 ::RCF::ClientParameters< \
1826 V , \
1827 A1,A2,A3,A4 , V,V,V,V,V,V,V,V,V,V,V > &>(* session.getInProcessParameters());\
1828 RCF_UNUSED_VARIABLE(p); \
1829 t.func( \
1830 p.a1.get(), \
1831 p.a2.get(), \
1832 p.a3.get(), \
1833 p.a4.get() ); \
1834 } \
1835 else \
1836 { \
1837 ::RCF::ServerParameters< \
1838 V , \
1839 A1,A2,A3,A4 > &p = \
1840 ::RCF::AllocateServerParameters< \
1841 V , \
1842 A1,A2,A3,A4 >()(session); \
1843 RCF_UNUSED_VARIABLE(p); \
1844 t.func( \
1845 p.a1.get(), \
1846 p.a2.get(), \
1847 p.a3.get(), \
1848 p.a4.get()); \
1849 } \
1850 }
1851
1852 // RCF_METHOD_V4_DECL
1853 #define RCF_METHOD_V4_DECL(R,func , A1,A2,A3,A4) \
1854 RCF_METHOD_V4_DECL_(R,func , A1,A2,A3,A4, RCF_MAKE_UNIQUE_ID(func, V4))
1855
1856 #define RCF_METHOD_V4_DECL_(R,func , A1,A2,A3,A4, id) \
1857 public: \
1858 BOOST_STATIC_ASSERT(( boost::is_same<R, void>::value )); \
1859 RCF_MAKE_NEXT_DISPATCH_ID(id) \
1860 ::RCF::FutureImpl<V> func( \
1861 ::RCF::RemoveOut<A1 >::type a1, \
1862 ::RCF::RemoveOut<A2 >::type a2, \
1863 ::RCF::RemoveOut<A3 >::type a3, \
1864 ::RCF::RemoveOut<A4 >::type a4) \
1865 { \
1866 return func( \
1867 ::RCF::CallOptions() , \
1868 a1,a2,a3,a4); \
1869 } \
1870 \
1871 ::RCF::FutureImpl<V> func( \
1872 const ::RCF::CallOptions &callOptions , \
1873 ::RCF::RemoveOut<A1 >::type a1, \
1874 ::RCF::RemoveOut<A2 >::type a2, \
1875 ::RCF::RemoveOut<A3 >::type a3, \
1876 ::RCF::RemoveOut<A4 >::type a4); \
1877 \
1878 void error__method_defined_out_of_order__##func( \
1879 id * , \
1880 ::RCF::RemoveOut<A1 >::type a1, \
1881 ::RCF::RemoveOut<A2 >::type a2, \
1882 ::RCF::RemoveOut<A3 >::type a3, \
1883 ::RCF::RemoveOut<A4 >::type a4); \
1884 \
1885 const char * getFunctionName(const id &) \
1886 { \
1887 return #func; \
1888 } \
1889 const char * getArity(const id &) \
1890 { \
1891 return "V4"; \
1892 } \
1893 \
1894 private: \
1895 template<typename T> \
1896 void invoke( \
1897 const id &, \
1898 ::RCF::RcfSession &session, \
1899 T &t) \
1900 { \
1901 if (session.isInProcess()) \
1902 { \
1903 ::RCF::ClientParameters< \
1904 V , \
1905 A1,A2,A3,A4 , V,V,V,V,V,V,V,V,V,V,V > &p = static_cast<\
1906 ::RCF::ClientParameters< \
1907 V , \
1908 A1,A2,A3,A4 , V,V,V,V,V,V,V,V,V,V,V > &>(* session.getInProcessParameters());\
1909 RCF_UNUSED_VARIABLE(p); \
1910 t.func( \
1911 p.a1.get(), \
1912 p.a2.get(), \
1913 p.a3.get(), \
1914 p.a4.get() ); \
1915 } \
1916 else \
1917 { \
1918 ::RCF::ServerParameters< \
1919 V , \
1920 A1,A2,A3,A4 > &p = \
1921 ::RCF::AllocateServerParameters< \
1922 V , \
1923 A1,A2,A3,A4 >()(session); \
1924 RCF_UNUSED_VARIABLE(p); \
1925 t.func( \
1926 p.a1.get(), \
1927 p.a2.get(), \
1928 p.a3.get(), \
1929 p.a4.get()); \
1930 } \
1931 }
1932
1933 // RCF_METHOD_V4_DEF
1934 #define RCF_METHOD_V4_DEF(R,func , A1,A2,A3,A4) \
1935 RCF_METHOD_V4_DEF_(R,func , A1,A2,A3,A4, RCF_PP_CAT(rcf_interface_id_1_, func, R4, __LINE__), RCF_MAKE_UNIQUE_ID(func, R4), RCF_PP_CAT(rcf_interface_id_2_, func, R4, __LINE__))
1936
1937 #define RCF_METHOD_V4_DEF_(R,func , A1,A2,A3,A4, interfaceId, funcId, genParms)\
1938 RCF_CURRENT_STATIC_ID(interfaceId, RCF_interface_id_helper, int, int) \
1939 typedef GeneratorParms<interfaceId> genParms; \
1940 RCF_ADVANCE_STATIC_ID(funcId, RCF_def_dispatch_id_helper, ::RCF::Dummy<genParms::RcfClientT>, genParms::RcfClientT, static)\
1941 RCF_EXPORT_INTERFACE ::RCF::FutureImpl<::RCF::Void> genParms::RcfClientT::func(\
1942 const ::RCF::CallOptions &callOptions , \
1943 ::RCF::RemoveOut<A1 >::type a1, \
1944 ::RCF::RemoveOut<A2 >::type a2, \
1945 ::RCF::RemoveOut<A3 >::type a3, \
1946 ::RCF::RemoveOut<A4 >::type a4) \
1947 { \
1948 typedef ::RCF::Void V; \
1949 getClientStub().setAsync(false); \
1950 return RCF::FutureImpl<V >( \
1951 ::RCF::AllocateClientParameters< \
1952 V , \
1953 A1,A2,A3,A4 , \
1954 V,V,V,V,V,V,V,V,V,V,V >()( \
1955 getClientStub() , \
1956 a1,a2,a3,a4 , \
1957 V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V()).r.get(), \
1958 getClientStub(), \
1959 mInterfaceName, \
1960 funcId::value, \
1961 callOptions.apply(getClientStub()), \
1962 #func, \
1963 "V4"); \
1964 } \
1965 void genParms::RcfClientT::error__method_defined_out_of_order__##func( \
1966 funcId * , \
1967 ::RCF::RemoveOut<A1 >::type a1, \
1968 ::RCF::RemoveOut<A2 >::type a2, \
1969 ::RCF::RemoveOut<A3 >::type a3, \
1970 ::RCF::RemoveOut<A4 >::type a4) \
1971 { \
1972 }
1973
1974
1975
1976
1977 //------------------------------------------------------------------------------
1978 // Parameters - R5
1979 //------------------------------------------------------------------------------
1980
1981 // RCF_METHOD_R5
1982 #define RCF_METHOD_R5_INLINE(R,func , A1,A2,A3,A4,A5) \
1983 RCF_METHOD_R5_INLINE_(R,func , A1,A2,A3,A4,A5, RCF_MAKE_UNIQUE_ID(func, R5))
1984
1985 #define RCF_METHOD_R5_INLINE_(R,func , A1,A2,A3,A4,A5, id) \
1986 public: \
1987 RCF_MAKE_NEXT_DISPATCH_ID(id) \
1988 ::RCF::FutureImpl<R > func( \
1989 ::RCF::RemoveOut<A1 >::type a1, \
1990 ::RCF::RemoveOut<A2 >::type a2, \
1991 ::RCF::RemoveOut<A3 >::type a3, \
1992 ::RCF::RemoveOut<A4 >::type a4, \
1993 ::RCF::RemoveOut<A5 >::type a5) \
1994 { \
1995 return func( \
1996 ::RCF::CallOptions() , \
1997 a1,a2,a3,a4,a5); \
1998 } \
1999 ::RCF::FutureImpl<R > func( \
2000 const ::RCF::CallOptions &callOptions , \
2001 ::RCF::RemoveOut<A1 >::type a1, \
2002 ::RCF::RemoveOut<A2 >::type a2, \
2003 ::RCF::RemoveOut<A3 >::type a3, \
2004 ::RCF::RemoveOut<A4 >::type a4, \
2005 ::RCF::RemoveOut<A5 >::type a5) \
2006 { \
2007 getClientStub().setAsync(false); \
2008 return RCF::FutureImpl<R >( \
2009 ::RCF::AllocateClientParameters< \
2010 R , \
2011 A1,A2,A3,A4,A5 , \
2012 V,V,V,V,V,V,V,V,V,V >()( \
2013 getClientStub() , \
2014 a1,a2,a3,a4,a5 , \
2015 V(),V(),V(),V(),V(),V(),V(),V(),V(),V()).r.get(), \
2016 getClientStub(), \
2017 mInterfaceName, \
2018 id::value, \
2019 callOptions.apply(getClientStub()), \
2020 #func, \
2021 "R5"); \
2022 } \
2023 const char * getFunctionName(const id &) \
2024 { \
2025 return #func; \
2026 } \
2027 const char * getArity(const id &) \
2028 { \
2029 return "R5"; \
2030 } \
2031 \
2032 private: \
2033 template<typename T> \
2034 void invoke( \
2035 const id &, \
2036 ::RCF::RcfSession &session, \
2037 T &t) \
2038 { \
2039 if (session.isInProcess()) \
2040 { \
2041 ::RCF::ClientParameters< \
2042 R , \
2043 A1,A2,A3,A4,A5 , V,V,V,V,V,V,V,V,V,V > &p = static_cast<\
2044 ::RCF::ClientParameters< \
2045 R , \
2046 A1,A2,A3,A4,A5 , V,V,V,V,V,V,V,V,V,V > &>(* session.getInProcessParameters());\
2047 p.r.set( t.func( p.a1.get(), \
2048 p.a2.get(), \
2049 p.a3.get(), \
2050 p.a4.get(), \
2051 p.a5.get() ) ); \
2052 } \
2053 else \
2054 { \
2055 ::RCF::ServerParameters< \
2056 R , \
2057 A1,A2,A3,A4,A5 > &p = \
2058 ::RCF::AllocateServerParameters< \
2059 R , \
2060 A1,A2,A3,A4,A5 >()(session); \
2061 p.r.set( \
2062 session.getAutoSend(), \
2063 t.func( \
2064 p.a1.get(), \
2065 p.a2.get(), \
2066 p.a3.get(), \
2067 p.a4.get(), \
2068 p.a5.get())); \
2069 } \
2070 }
2071
2072 // RCF_METHOD_R5_DECL
2073 #define RCF_METHOD_R5_DECL(R,func , A1,A2,A3,A4,A5) \
2074 RCF_METHOD_R5_DECL_(R,func , A1,A2,A3,A4,A5, RCF_MAKE_UNIQUE_ID(func, R5))
2075
2076 #define RCF_METHOD_R5_DECL_(R,func , A1,A2,A3,A4,A5, id) \
2077 public: \
2078 RCF_MAKE_NEXT_DISPATCH_ID(id) \
2079 ::RCF::FutureImpl<R > func( \
2080 ::RCF::RemoveOut<A1 >::type a1, \
2081 ::RCF::RemoveOut<A2 >::type a2, \
2082 ::RCF::RemoveOut<A3 >::type a3, \
2083 ::RCF::RemoveOut<A4 >::type a4, \
2084 ::RCF::RemoveOut<A5 >::type a5) \
2085 { \
2086 return func( \
2087 ::RCF::CallOptions() , \
2088 a1,a2,a3,a4,a5); \
2089 } \
2090 \
2091 ::RCF::FutureImpl<R > func( \
2092 const ::RCF::CallOptions &callOptions , \
2093 ::RCF::RemoveOut<A1 >::type a1, \
2094 ::RCF::RemoveOut<A2 >::type a2, \
2095 ::RCF::RemoveOut<A3 >::type a3, \
2096 ::RCF::RemoveOut<A4 >::type a4, \
2097 ::RCF::RemoveOut<A5 >::type a5); \
2098 \
2099 void error__method_defined_out_of_order__##func( \
2100 id * , \
2101 ::RCF::RemoveOut<A1 >::type a1, \
2102 ::RCF::RemoveOut<A2 >::type a2, \
2103 ::RCF::RemoveOut<A3 >::type a3, \
2104 ::RCF::RemoveOut<A4 >::type a4, \
2105 ::RCF::RemoveOut<A5 >::type a5); \
2106 \
2107 const char * getFunctionName(const id &) \
2108 { \
2109 return #func; \
2110 } \
2111 const char * getArity(const id &) \
2112 { \
2113 return "R5"; \
2114 } \
2115 \
2116 private: \
2117 template<typename T> \
2118 void invoke( \
2119 const id &, \
2120 ::RCF::RcfSession &session, \
2121 T &t) \
2122 { \
2123 if (session.isInProcess()) \
2124 { \
2125 ::RCF::ClientParameters< \
2126 R , \
2127 A1,A2,A3,A4,A5 , V,V,V,V,V,V,V,V,V,V > &p = static_cast<\
2128 ::RCF::ClientParameters< \
2129 R , \
2130 A1,A2,A3,A4,A5 , V,V,V,V,V,V,V,V,V,V > &>(* session.getInProcessParameters());\
2131 p.r.set( t.func( p.a1.get(), \
2132 p.a2.get(), \
2133 p.a3.get(), \
2134 p.a4.get(), \
2135 p.a5.get() ) ); \
2136 } \
2137 else \
2138 { \
2139 ::RCF::ServerParameters< \
2140 R , \
2141 A1,A2,A3,A4,A5 > &p = \
2142 ::RCF::AllocateServerParameters< \
2143 R , \
2144 A1,A2,A3,A4,A5 >()(session); \
2145 p.r.set( \
2146 session.getAutoSend(), \
2147 t.func( \
2148 p.a1.get(), \
2149 p.a2.get(), \
2150 p.a3.get(), \
2151 p.a4.get(), \
2152 p.a5.get())); \
2153 } \
2154 }
2155
2156 // RCF_METHOD_R5_DEF
2157 #define RCF_METHOD_R5_DEF(R,func , A1,A2,A3,A4,A5) \
2158 RCF_METHOD_R5_DEF_(R,func , A1,A2,A3,A4,A5, RCF_PP_CAT(rcf_interface_id_1_, func, R5, __LINE__), RCF_MAKE_UNIQUE_ID(func, R5), RCF_PP_CAT(rcf_interface_id_2_, func, R5, __LINE__))
2159
2160 #define RCF_METHOD_R5_DEF_(R,func , A1,A2,A3,A4,A5, interfaceId, funcId, genParms)\
2161 RCF_CURRENT_STATIC_ID(interfaceId, RCF_interface_id_helper, int, int) \
2162 typedef GeneratorParms<interfaceId> genParms; \
2163 RCF_ADVANCE_STATIC_ID(funcId, RCF_def_dispatch_id_helper, ::RCF::Dummy<genParms::RcfClientT>, genParms::RcfClientT, static)\
2164 RCF_EXPORT_INTERFACE ::RCF::FutureImpl<R > genParms::RcfClientT::func( \
2165 const ::RCF::CallOptions &callOptions , \
2166 ::RCF::RemoveOut<A1 >::type a1, \
2167 ::RCF::RemoveOut<A2 >::type a2, \
2168 ::RCF::RemoveOut<A3 >::type a3, \
2169 ::RCF::RemoveOut<A4 >::type a4, \
2170 ::RCF::RemoveOut<A5 >::type a5) \
2171 { \
2172 getClientStub().setAsync(false); \
2173 return RCF::FutureImpl<R >( \
2174 ::RCF::AllocateClientParameters< \
2175 R , \
2176 A1,A2,A3,A4,A5 , \
2177 V,V,V,V,V,V,V,V,V,V >()( \
2178 getClientStub() , \
2179 a1,a2,a3,a4,a5 , \
2180 V(),V(),V(),V(),V(),V(),V(),V(),V(),V()).r.get(), \
2181 getClientStub(), \
2182 mInterfaceName, \
2183 funcId::value, \
2184 callOptions.apply(getClientStub()), \
2185 #func, \
2186 "R5"); \
2187 } \
2188 void genParms::RcfClientT::error__method_defined_out_of_order__##func( \
2189 funcId * , \
2190 ::RCF::RemoveOut<A1 >::type a1, \
2191 ::RCF::RemoveOut<A2 >::type a2, \
2192 ::RCF::RemoveOut<A3 >::type a3, \
2193 ::RCF::RemoveOut<A4 >::type a4, \
2194 ::RCF::RemoveOut<A5 >::type a5) \
2195 { \
2196 }
2197
2198
2199
2200 //------------------------------------------------------------------------------
2201 // Parameters - V5
2202 //------------------------------------------------------------------------------
2203
2204 // RCF_METHOD_V5
2205 #define RCF_METHOD_V5_INLINE(R,func , A1,A2,A3,A4,A5) \
2206 RCF_METHOD_V5_INLINE_(R,func , A1,A2,A3,A4,A5, RCF_MAKE_UNIQUE_ID(func, V5))
2207
2208 #define RCF_METHOD_V5_INLINE_(R,func , A1,A2,A3,A4,A5, id) \
2209 public: \
2210 BOOST_STATIC_ASSERT(( boost::is_same<R, void>::value )); \
2211 RCF_MAKE_NEXT_DISPATCH_ID(id) \
2212 ::RCF::FutureImpl<V> func( \
2213 ::RCF::RemoveOut<A1 >::type a1, \
2214 ::RCF::RemoveOut<A2 >::type a2, \
2215 ::RCF::RemoveOut<A3 >::type a3, \
2216 ::RCF::RemoveOut<A4 >::type a4, \
2217 ::RCF::RemoveOut<A5 >::type a5) \
2218 { \
2219 return func( \
2220 ::RCF::CallOptions() , \
2221 a1,a2,a3,a4,a5); \
2222 } \
2223 ::RCF::FutureImpl<V> func( \
2224 const ::RCF::CallOptions &callOptions , \
2225 ::RCF::RemoveOut<A1 >::type a1, \
2226 ::RCF::RemoveOut<A2 >::type a2, \
2227 ::RCF::RemoveOut<A3 >::type a3, \
2228 ::RCF::RemoveOut<A4 >::type a4, \
2229 ::RCF::RemoveOut<A5 >::type a5) \
2230 { \
2231 getClientStub().setAsync(false); \
2232 return RCF::FutureImpl<V>( \
2233 ::RCF::AllocateClientParameters< \
2234 V , \
2235 A1,A2,A3,A4,A5 , \
2236 V,V,V,V,V,V,V,V,V,V >()( \
2237 getClientStub() , \
2238 a1,a2,a3,a4,a5 , \
2239 V(),V(),V(),V(),V(),V(),V(),V(),V(),V()).r.get(), \
2240 getClientStub(), \
2241 mInterfaceName, \
2242 id::value, \
2243 callOptions.apply(getClientStub()), \
2244 #func, \
2245 "V5"); \
2246 } \
2247 const char * getFunctionName(const id &) \
2248 { \
2249 return #func; \
2250 } \
2251 const char * getArity(const id &) \
2252 { \
2253 return "V5"; \
2254 } \
2255 \
2256 private: \
2257 template<typename T> \
2258 void invoke( \
2259 const id &, \
2260 ::RCF::RcfSession &session, \
2261 T &t) \
2262 { \
2263 if (session.isInProcess()) \
2264 { \
2265 ::RCF::ClientParameters< \
2266 V , \
2267 A1,A2,A3,A4,A5 , V,V,V,V,V,V,V,V,V,V > &p = static_cast<\
2268 ::RCF::ClientParameters< \
2269 V , \
2270 A1,A2,A3,A4,A5 , V,V,V,V,V,V,V,V,V,V > &>(* session.getInProcessParameters());\
2271 RCF_UNUSED_VARIABLE(p); \
2272 t.func( \
2273 p.a1.get(), \
2274 p.a2.get(), \
2275 p.a3.get(), \
2276 p.a4.get(), \
2277 p.a5.get() ); \
2278 } \
2279 else \
2280 { \
2281 ::RCF::ServerParameters< \
2282 V , \
2283 A1,A2,A3,A4,A5 > &p = \
2284 ::RCF::AllocateServerParameters< \
2285 V , \
2286 A1,A2,A3,A4,A5 >()(session); \
2287 RCF_UNUSED_VARIABLE(p); \
2288 t.func( \
2289 p.a1.get(), \
2290 p.a2.get(), \
2291 p.a3.get(), \
2292 p.a4.get(), \
2293 p.a5.get()); \
2294 } \
2295 }
2296
2297 // RCF_METHOD_V5_DECL
2298 #define RCF_METHOD_V5_DECL(R,func , A1,A2,A3,A4,A5) \
2299 RCF_METHOD_V5_DECL_(R,func , A1,A2,A3,A4,A5, RCF_MAKE_UNIQUE_ID(func, V5))
2300
2301 #define RCF_METHOD_V5_DECL_(R,func , A1,A2,A3,A4,A5, id) \
2302 public: \
2303 BOOST_STATIC_ASSERT(( boost::is_same<R, void>::value )); \
2304 RCF_MAKE_NEXT_DISPATCH_ID(id) \
2305 ::RCF::FutureImpl<V> func( \
2306 ::RCF::RemoveOut<A1 >::type a1, \
2307 ::RCF::RemoveOut<A2 >::type a2, \
2308 ::RCF::RemoveOut<A3 >::type a3, \
2309 ::RCF::RemoveOut<A4 >::type a4, \
2310 ::RCF::RemoveOut<A5 >::type a5) \
2311 { \
2312 return func( \
2313 ::RCF::CallOptions() , \
2314 a1,a2,a3,a4,a5); \
2315 } \
2316 \
2317 ::RCF::FutureImpl<V> func( \
2318 const ::RCF::CallOptions &callOptions , \
2319 ::RCF::RemoveOut<A1 >::type a1, \
2320 ::RCF::RemoveOut<A2 >::type a2, \
2321 ::RCF::RemoveOut<A3 >::type a3, \
2322 ::RCF::RemoveOut<A4 >::type a4, \
2323 ::RCF::RemoveOut<A5 >::type a5); \
2324 \
2325 void error__method_defined_out_of_order__##func( \
2326 id * , \
2327 ::RCF::RemoveOut<A1 >::type a1, \
2328 ::RCF::RemoveOut<A2 >::type a2, \
2329 ::RCF::RemoveOut<A3 >::type a3, \
2330 ::RCF::RemoveOut<A4 >::type a4, \
2331 ::RCF::RemoveOut<A5 >::type a5); \
2332 \
2333 const char * getFunctionName(const id &) \
2334 { \
2335 return #func; \
2336 } \
2337 const char * getArity(const id &) \
2338 { \
2339 return "V5"; \
2340 } \
2341 \
2342 private: \
2343 template<typename T> \
2344 void invoke( \
2345 const id &, \
2346 ::RCF::RcfSession &session, \
2347 T &t) \
2348 { \
2349 if (session.isInProcess()) \
2350 { \
2351 ::RCF::ClientParameters< \
2352 V , \
2353 A1,A2,A3,A4,A5 , V,V,V,V,V,V,V,V,V,V > &p = static_cast<\
2354 ::RCF::ClientParameters< \
2355 V , \
2356 A1,A2,A3,A4,A5 , V,V,V,V,V,V,V,V,V,V > &>(* session.getInProcessParameters());\
2357 RCF_UNUSED_VARIABLE(p); \
2358 t.func( \
2359 p.a1.get(), \
2360 p.a2.get(), \
2361 p.a3.get(), \
2362 p.a4.get(), \
2363 p.a5.get() ); \
2364 } \
2365 else \
2366 { \
2367 ::RCF::ServerParameters< \
2368 V , \
2369 A1,A2,A3,A4,A5 > &p = \
2370 ::RCF::AllocateServerParameters< \
2371 V , \
2372 A1,A2,A3,A4,A5 >()(session); \
2373 RCF_UNUSED_VARIABLE(p); \
2374 t.func( \
2375 p.a1.get(), \
2376 p.a2.get(), \
2377 p.a3.get(), \
2378 p.a4.get(), \
2379 p.a5.get()); \
2380 } \
2381 }
2382
2383 // RCF_METHOD_V5_DEF
2384 #define RCF_METHOD_V5_DEF(R,func , A1,A2,A3,A4,A5) \
2385 RCF_METHOD_V5_DEF_(R,func , A1,A2,A3,A4,A5, RCF_PP_CAT(rcf_interface_id_1_, func, R5, __LINE__), RCF_MAKE_UNIQUE_ID(func, R5), RCF_PP_CAT(rcf_interface_id_2_, func, R5, __LINE__))
2386
2387 #define RCF_METHOD_V5_DEF_(R,func , A1,A2,A3,A4,A5, interfaceId, funcId, genParms)\
2388 RCF_CURRENT_STATIC_ID(interfaceId, RCF_interface_id_helper, int, int) \
2389 typedef GeneratorParms<interfaceId> genParms; \
2390 RCF_ADVANCE_STATIC_ID(funcId, RCF_def_dispatch_id_helper, ::RCF::Dummy<genParms::RcfClientT>, genParms::RcfClientT, static)\
2391 RCF_EXPORT_INTERFACE ::RCF::FutureImpl<::RCF::Void> genParms::RcfClientT::func(\
2392 const ::RCF::CallOptions &callOptions , \
2393 ::RCF::RemoveOut<A1 >::type a1, \
2394 ::RCF::RemoveOut<A2 >::type a2, \
2395 ::RCF::RemoveOut<A3 >::type a3, \
2396 ::RCF::RemoveOut<A4 >::type a4, \
2397 ::RCF::RemoveOut<A5 >::type a5) \
2398 { \
2399 typedef ::RCF::Void V; \
2400 getClientStub().setAsync(false); \
2401 return RCF::FutureImpl<V >( \
2402 ::RCF::AllocateClientParameters< \
2403 V , \
2404 A1,A2,A3,A4,A5 , \
2405 V,V,V,V,V,V,V,V,V,V >()( \
2406 getClientStub() , \
2407 a1,a2,a3,a4,a5 , \
2408 V(),V(),V(),V(),V(),V(),V(),V(),V(),V()).r.get(), \
2409 getClientStub(), \
2410 mInterfaceName, \
2411 funcId::value, \
2412 callOptions.apply(getClientStub()), \
2413 #func, \
2414 "V5"); \
2415 } \
2416 void genParms::RcfClientT::error__method_defined_out_of_order__##func( \
2417 funcId * , \
2418 ::RCF::RemoveOut<A1 >::type a1, \
2419 ::RCF::RemoveOut<A2 >::type a2, \
2420 ::RCF::RemoveOut<A3 >::type a3, \
2421 ::RCF::RemoveOut<A4 >::type a4, \
2422 ::RCF::RemoveOut<A5 >::type a5) \
2423 { \
2424 }
2425
2426
2427
2428
2429 //------------------------------------------------------------------------------
2430 // Parameters - R6
2431 //------------------------------------------------------------------------------
2432
2433 // RCF_METHOD_R6
2434 #define RCF_METHOD_R6_INLINE(R,func , A1,A2,A3,A4,A5,A6) \
2435 RCF_METHOD_R6_INLINE_(R,func , A1,A2,A3,A4,A5,A6, RCF_MAKE_UNIQUE_ID(func, R6))
2436
2437 #define RCF_METHOD_R6_INLINE_(R,func , A1,A2,A3,A4,A5,A6, id) \
2438 public: \
2439 RCF_MAKE_NEXT_DISPATCH_ID(id) \
2440 ::RCF::FutureImpl<R > func( \
2441 ::RCF::RemoveOut<A1 >::type a1, \
2442 ::RCF::RemoveOut<A2 >::type a2, \
2443 ::RCF::RemoveOut<A3 >::type a3, \
2444 ::RCF::RemoveOut<A4 >::type a4, \
2445 ::RCF::RemoveOut<A5 >::type a5, \
2446 ::RCF::RemoveOut<A6 >::type a6) \
2447 { \
2448 return func( \
2449 ::RCF::CallOptions() , \
2450 a1,a2,a3,a4,a5,a6); \
2451 } \
2452 ::RCF::FutureImpl<R > func( \
2453 const ::RCF::CallOptions &callOptions , \
2454 ::RCF::RemoveOut<A1 >::type a1, \
2455 ::RCF::RemoveOut<A2 >::type a2, \
2456 ::RCF::RemoveOut<A3 >::type a3, \
2457 ::RCF::RemoveOut<A4 >::type a4, \
2458 ::RCF::RemoveOut<A5 >::type a5, \
2459 ::RCF::RemoveOut<A6 >::type a6) \
2460 { \
2461 getClientStub().setAsync(false); \
2462 return RCF::FutureImpl<R >( \
2463 ::RCF::AllocateClientParameters< \
2464 R , \
2465 A1,A2,A3,A4,A5,A6 , \
2466 V,V,V,V,V,V,V,V,V >()( \
2467 getClientStub() , \
2468 a1,a2,a3,a4,a5,a6 , \
2469 V(),V(),V(),V(),V(),V(),V(),V(),V()).r.get(), \
2470 getClientStub(), \
2471 mInterfaceName, \
2472 id::value, \
2473 callOptions.apply(getClientStub()), \
2474 #func, \
2475 "R6"); \
2476 } \
2477 const char * getFunctionName(const id &) \
2478 { \
2479 return #func; \
2480 } \
2481 const char * getArity(const id &) \
2482 { \
2483 return "R6"; \
2484 } \
2485 \
2486 private: \
2487 template<typename T> \
2488 void invoke( \
2489 const id &, \
2490 ::RCF::RcfSession &session, \
2491 T &t) \
2492 { \
2493 if (session.isInProcess()) \
2494 { \
2495 ::RCF::ClientParameters< \
2496 R , \
2497 A1,A2,A3,A4,A5,A6 , V,V,V,V,V,V,V,V,V > &p = static_cast<\
2498 ::RCF::ClientParameters< \
2499 R , \
2500 A1,A2,A3,A4,A5,A6 , V,V,V,V,V,V,V,V,V > &>(* session.getInProcessParameters());\
2501 p.r.set( t.func( p.a1.get(), \
2502 p.a2.get(), \
2503 p.a3.get(), \
2504 p.a4.get(), \
2505 p.a5.get(), \
2506 p.a6.get() ) ); \
2507 } \
2508 else \
2509 { \
2510 ::RCF::ServerParameters< \
2511 R , \
2512 A1,A2,A3,A4,A5,A6 > &p = \
2513 ::RCF::AllocateServerParameters< \
2514 R , \
2515 A1,A2,A3,A4,A5,A6 >()(session); \
2516 p.r.set( \
2517 session.getAutoSend(), \
2518 t.func( \
2519 p.a1.get(), \
2520 p.a2.get(), \
2521 p.a3.get(), \
2522 p.a4.get(), \
2523 p.a5.get(), \
2524 p.a6.get())); \
2525 } \
2526 }
2527
2528 // RCF_METHOD_R6_DECL
2529 #define RCF_METHOD_R6_DECL(R,func , A1,A2,A3,A4,A5,A6) \
2530 RCF_METHOD_R6_DECL_(R,func , A1,A2,A3,A4,A5,A6, RCF_MAKE_UNIQUE_ID(func, R6))
2531
2532 #define RCF_METHOD_R6_DECL_(R,func , A1,A2,A3,A4,A5,A6, id) \
2533 public: \
2534 RCF_MAKE_NEXT_DISPATCH_ID(id) \
2535 ::RCF::FutureImpl<R > func( \
2536 ::RCF::RemoveOut<A1 >::type a1, \
2537 ::RCF::RemoveOut<A2 >::type a2, \
2538 ::RCF::RemoveOut<A3 >::type a3, \
2539 ::RCF::RemoveOut<A4 >::type a4, \
2540 ::RCF::RemoveOut<A5 >::type a5, \
2541 ::RCF::RemoveOut<A6 >::type a6) \
2542 { \
2543 return func( \
2544 ::RCF::CallOptions() , \
2545 a1,a2,a3,a4,a5,a6); \
2546 } \
2547 \
2548 ::RCF::FutureImpl<R > func( \
2549 const ::RCF::CallOptions &callOptions , \
2550 ::RCF::RemoveOut<A1 >::type a1, \
2551 ::RCF::RemoveOut<A2 >::type a2, \
2552 ::RCF::RemoveOut<A3 >::type a3, \
2553 ::RCF::RemoveOut<A4 >::type a4, \
2554 ::RCF::RemoveOut<A5 >::type a5, \
2555 ::RCF::RemoveOut<A6 >::type a6); \
2556 \
2557 void error__method_defined_out_of_order__##func( \
2558 id * , \
2559 ::RCF::RemoveOut<A1 >::type a1, \
2560 ::RCF::RemoveOut<A2 >::type a2, \
2561 ::RCF::RemoveOut<A3 >::type a3, \
2562 ::RCF::RemoveOut<A4 >::type a4, \
2563 ::RCF::RemoveOut<A5 >::type a5, \
2564 ::RCF::RemoveOut<A6 >::type a6); \
2565 \
2566 const char * getFunctionName(const id &) \
2567 { \
2568 return #func; \
2569 } \
2570 const char * getArity(const id &) \
2571 { \
2572 return "R6"; \
2573 } \
2574 \
2575 private: \
2576 template<typename T> \
2577 void invoke( \
2578 const id &, \
2579 ::RCF::RcfSession &session, \
2580 T &t) \
2581 { \
2582 if (session.isInProcess()) \
2583 { \
2584 ::RCF::ClientParameters< \
2585 R , \
2586 A1,A2,A3,A4,A5,A6 , V,V,V,V,V,V,V,V,V > &p = static_cast<\
2587 ::RCF::ClientParameters< \
2588 R , \
2589 A1,A2,A3,A4,A5,A6 , V,V,V,V,V,V,V,V,V > &>(* session.getInProcessParameters());\
2590 p.r.set( t.func( p.a1.get(), \
2591 p.a2.get(), \
2592 p.a3.get(), \
2593 p.a4.get(), \
2594 p.a5.get(), \
2595 p.a6.get() ) ); \
2596 } \
2597 else \
2598 { \
2599 ::RCF::ServerParameters< \
2600 R , \
2601 A1,A2,A3,A4,A5,A6 > &p = \
2602 ::RCF::AllocateServerParameters< \
2603 R , \
2604 A1,A2,A3,A4,A5,A6 >()(session); \
2605 p.r.set( \
2606 session.getAutoSend(), \
2607 t.func( \
2608 p.a1.get(), \
2609 p.a2.get(), \
2610 p.a3.get(), \
2611 p.a4.get(), \
2612 p.a5.get(), \
2613 p.a6.get())); \
2614 } \
2615 }
2616
2617 // RCF_METHOD_R6_DEF
2618 #define RCF_METHOD_R6_DEF(R,func , A1,A2,A3,A4,A5,A6) \
2619 RCF_METHOD_R6_DEF_(R,func , A1,A2,A3,A4,A5,A6, RCF_PP_CAT(rcf_interface_id_1_, func, R6, __LINE__), RCF_MAKE_UNIQUE_ID(func, R6), RCF_PP_CAT(rcf_interface_id_2_, func, R6, __LINE__))
2620
2621 #define RCF_METHOD_R6_DEF_(R,func , A1,A2,A3,A4,A5,A6, interfaceId, funcId, genParms)\
2622 RCF_CURRENT_STATIC_ID(interfaceId, RCF_interface_id_helper, int, int) \
2623 typedef GeneratorParms<interfaceId> genParms; \
2624 RCF_ADVANCE_STATIC_ID(funcId, RCF_def_dispatch_id_helper, ::RCF::Dummy<genParms::RcfClientT>, genParms::RcfClientT, static)\
2625 RCF_EXPORT_INTERFACE ::RCF::FutureImpl<R > genParms::RcfClientT::func( \
2626 const ::RCF::CallOptions &callOptions , \
2627 ::RCF::RemoveOut<A1 >::type a1, \
2628 ::RCF::RemoveOut<A2 >::type a2, \
2629 ::RCF::RemoveOut<A3 >::type a3, \
2630 ::RCF::RemoveOut<A4 >::type a4, \
2631 ::RCF::RemoveOut<A5 >::type a5, \
2632 ::RCF::RemoveOut<A6 >::type a6) \
2633 { \
2634 getClientStub().setAsync(false); \
2635 return RCF::FutureImpl<R >( \
2636 ::RCF::AllocateClientParameters< \
2637 R , \
2638 A1,A2,A3,A4,A5,A6 , \
2639 V,V,V,V,V,V,V,V,V >()( \
2640 getClientStub() , \
2641 a1,a2,a3,a4,a5,a6 , \
2642 V(),V(),V(),V(),V(),V(),V(),V(),V()).r.get(), \
2643 getClientStub(), \
2644 mInterfaceName, \
2645 funcId::value, \
2646 callOptions.apply(getClientStub()), \
2647 #func, \
2648 "R6"); \
2649 } \
2650 void genParms::RcfClientT::error__method_defined_out_of_order__##func( \
2651 funcId * , \
2652 ::RCF::RemoveOut<A1 >::type a1, \
2653 ::RCF::RemoveOut<A2 >::type a2, \
2654 ::RCF::RemoveOut<A3 >::type a3, \
2655 ::RCF::RemoveOut<A4 >::type a4, \
2656 ::RCF::RemoveOut<A5 >::type a5, \
2657 ::RCF::RemoveOut<A6 >::type a6) \
2658 { \
2659 }
2660
2661
2662
2663 //------------------------------------------------------------------------------
2664 // Parameters - V6
2665 //------------------------------------------------------------------------------
2666
2667 // RCF_METHOD_V6
2668 #define RCF_METHOD_V6_INLINE(R,func , A1,A2,A3,A4,A5,A6) \
2669 RCF_METHOD_V6_INLINE_(R,func , A1,A2,A3,A4,A5,A6, RCF_MAKE_UNIQUE_ID(func, V6))
2670
2671 #define RCF_METHOD_V6_INLINE_(R,func , A1,A2,A3,A4,A5,A6, id) \
2672 public: \
2673 BOOST_STATIC_ASSERT(( boost::is_same<R, void>::value )); \
2674 RCF_MAKE_NEXT_DISPATCH_ID(id) \
2675 ::RCF::FutureImpl<V> func( \
2676 ::RCF::RemoveOut<A1 >::type a1, \
2677 ::RCF::RemoveOut<A2 >::type a2, \
2678 ::RCF::RemoveOut<A3 >::type a3, \
2679 ::RCF::RemoveOut<A4 >::type a4, \
2680 ::RCF::RemoveOut<A5 >::type a5, \
2681 ::RCF::RemoveOut<A6 >::type a6) \
2682 { \
2683 return func( \
2684 ::RCF::CallOptions() , \
2685 a1,a2,a3,a4,a5,a6); \
2686 } \
2687 ::RCF::FutureImpl<V> func( \
2688 const ::RCF::CallOptions &callOptions , \
2689 ::RCF::RemoveOut<A1 >::type a1, \
2690 ::RCF::RemoveOut<A2 >::type a2, \
2691 ::RCF::RemoveOut<A3 >::type a3, \
2692 ::RCF::RemoveOut<A4 >::type a4, \
2693 ::RCF::RemoveOut<A5 >::type a5, \
2694 ::RCF::RemoveOut<A6 >::type a6) \
2695 { \
2696 getClientStub().setAsync(false); \
2697 return RCF::FutureImpl<V>( \
2698 ::RCF::AllocateClientParameters< \
2699 V , \
2700 A1,A2,A3,A4,A5,A6 , \
2701 V,V,V,V,V,V,V,V,V >()( \
2702 getClientStub() , \
2703 a1,a2,a3,a4,a5,a6 , \
2704 V(),V(),V(),V(),V(),V(),V(),V(),V()).r.get(), \
2705 getClientStub(), \
2706 mInterfaceName, \
2707 id::value, \
2708 callOptions.apply(getClientStub()), \
2709 #func, \
2710 "V6"); \
2711 } \
2712 const char * getFunctionName(const id &) \
2713 { \
2714 return #func; \
2715 } \
2716 const char * getArity(const id &) \
2717 { \
2718 return "V6"; \
2719 } \
2720 \
2721 private: \
2722 template<typename T> \
2723 void invoke( \
2724 const id &, \
2725 ::RCF::RcfSession &session, \
2726 T &t) \
2727 { \
2728 if (session.isInProcess()) \
2729 { \
2730 ::RCF::ClientParameters< \
2731 V , \
2732 A1,A2,A3,A4,A5,A6 , V,V,V,V,V,V,V,V,V > &p = static_cast<\
2733 ::RCF::ClientParameters< \
2734 V , \
2735 A1,A2,A3,A4,A5,A6 , V,V,V,V,V,V,V,V,V > &>(* session.getInProcessParameters());\
2736 RCF_UNUSED_VARIABLE(p); \
2737 t.func( \
2738 p.a1.get(), \
2739 p.a2.get(), \
2740 p.a3.get(), \
2741 p.a4.get(), \
2742 p.a5.get(), \
2743 p.a6.get() ); \
2744 } \
2745 else \
2746 { \
2747 ::RCF::ServerParameters< \
2748 V , \
2749 A1,A2,A3,A4,A5,A6 > &p = \
2750 ::RCF::AllocateServerParameters< \
2751 V , \
2752 A1,A2,A3,A4,A5,A6 >()(session); \
2753 RCF_UNUSED_VARIABLE(p); \
2754 t.func( \
2755 p.a1.get(), \
2756 p.a2.get(), \
2757 p.a3.get(), \
2758 p.a4.get(), \
2759 p.a5.get(), \
2760 p.a6.get()); \
2761 } \
2762 }
2763
2764 // RCF_METHOD_V6_DECL
2765 #define RCF_METHOD_V6_DECL(R,func , A1,A2,A3,A4,A5,A6) \
2766 RCF_METHOD_V6_DECL_(R,func , A1,A2,A3,A4,A5,A6, RCF_MAKE_UNIQUE_ID(func, V6))
2767
2768 #define RCF_METHOD_V6_DECL_(R,func , A1,A2,A3,A4,A5,A6, id) \
2769 public: \
2770 BOOST_STATIC_ASSERT(( boost::is_same<R, void>::value )); \
2771 RCF_MAKE_NEXT_DISPATCH_ID(id) \
2772 ::RCF::FutureImpl<V> func( \
2773 ::RCF::RemoveOut<A1 >::type a1, \
2774 ::RCF::RemoveOut<A2 >::type a2, \
2775 ::RCF::RemoveOut<A3 >::type a3, \
2776 ::RCF::RemoveOut<A4 >::type a4, \
2777 ::RCF::RemoveOut<A5 >::type a5, \
2778 ::RCF::RemoveOut<A6 >::type a6) \
2779 { \
2780 return func( \
2781 ::RCF::CallOptions() , \
2782 a1,a2,a3,a4,a5,a6); \
2783 } \
2784 \
2785 ::RCF::FutureImpl<V> func( \
2786 const ::RCF::CallOptions &callOptions , \
2787 ::RCF::RemoveOut<A1 >::type a1, \
2788 ::RCF::RemoveOut<A2 >::type a2, \
2789 ::RCF::RemoveOut<A3 >::type a3, \
2790 ::RCF::RemoveOut<A4 >::type a4, \
2791 ::RCF::RemoveOut<A5 >::type a5, \
2792 ::RCF::RemoveOut<A6 >::type a6); \
2793 \
2794 void error__method_defined_out_of_order__##func( \
2795 id * , \
2796 ::RCF::RemoveOut<A1 >::type a1, \
2797 ::RCF::RemoveOut<A2 >::type a2, \
2798 ::RCF::RemoveOut<A3 >::type a3, \
2799 ::RCF::RemoveOut<A4 >::type a4, \
2800 ::RCF::RemoveOut<A5 >::type a5, \
2801 ::RCF::RemoveOut<A6 >::type a6); \
2802 \
2803 const char * getFunctionName(const id &) \
2804 { \
2805 return #func; \
2806 } \
2807 const char * getArity(const id &) \
2808 { \
2809 return "V6"; \
2810 } \
2811 \
2812 private: \
2813 template<typename T> \
2814 void invoke( \
2815 const id &, \
2816 ::RCF::RcfSession &session, \
2817 T &t) \
2818 { \
2819 if (session.isInProcess()) \
2820 { \
2821 ::RCF::ClientParameters< \
2822 V , \
2823 A1,A2,A3,A4,A5,A6 , V,V,V,V,V,V,V,V,V > &p = static_cast<\
2824 ::RCF::ClientParameters< \
2825 V , \
2826 A1,A2,A3,A4,A5,A6 , V,V,V,V,V,V,V,V,V > &>(* session.getInProcessParameters());\
2827 RCF_UNUSED_VARIABLE(p); \
2828 t.func( \
2829 p.a1.get(), \
2830 p.a2.get(), \
2831 p.a3.get(), \
2832 p.a4.get(), \
2833 p.a5.get(), \
2834 p.a6.get() ); \
2835 } \
2836 else \
2837 { \
2838 ::RCF::ServerParameters< \
2839 V , \
2840 A1,A2,A3,A4,A5,A6 > &p = \
2841 ::RCF::AllocateServerParameters< \
2842 V , \
2843 A1,A2,A3,A4,A5,A6 >()(session); \
2844 RCF_UNUSED_VARIABLE(p); \
2845 t.func( \
2846 p.a1.get(), \
2847 p.a2.get(), \
2848 p.a3.get(), \
2849 p.a4.get(), \
2850 p.a5.get(), \
2851 p.a6.get()); \
2852 } \
2853 }
2854
2855 // RCF_METHOD_V6_DEF
2856 #define RCF_METHOD_V6_DEF(R,func , A1,A2,A3,A4,A5,A6) \
2857 RCF_METHOD_V6_DEF_(R,func , A1,A2,A3,A4,A5,A6, RCF_PP_CAT(rcf_interface_id_1_, func, R6, __LINE__), RCF_MAKE_UNIQUE_ID(func, R6), RCF_PP_CAT(rcf_interface_id_2_, func, R6, __LINE__))
2858
2859 #define RCF_METHOD_V6_DEF_(R,func , A1,A2,A3,A4,A5,A6, interfaceId, funcId, genParms)\
2860 RCF_CURRENT_STATIC_ID(interfaceId, RCF_interface_id_helper, int, int) \
2861 typedef GeneratorParms<interfaceId> genParms; \
2862 RCF_ADVANCE_STATIC_ID(funcId, RCF_def_dispatch_id_helper, ::RCF::Dummy<genParms::RcfClientT>, genParms::RcfClientT, static)\
2863 RCF_EXPORT_INTERFACE ::RCF::FutureImpl<::RCF::Void> genParms::RcfClientT::func(\
2864 const ::RCF::CallOptions &callOptions , \
2865 ::RCF::RemoveOut<A1 >::type a1, \
2866 ::RCF::RemoveOut<A2 >::type a2, \
2867 ::RCF::RemoveOut<A3 >::type a3, \
2868 ::RCF::RemoveOut<A4 >::type a4, \
2869 ::RCF::RemoveOut<A5 >::type a5, \
2870 ::RCF::RemoveOut<A6 >::type a6) \
2871 { \
2872 typedef ::RCF::Void V; \
2873 getClientStub().setAsync(false); \
2874 return RCF::FutureImpl<V >( \
2875 ::RCF::AllocateClientParameters< \
2876 V , \
2877 A1,A2,A3,A4,A5,A6 , \
2878 V,V,V,V,V,V,V,V,V >()( \
2879 getClientStub() , \
2880 a1,a2,a3,a4,a5,a6 , \
2881 V(),V(),V(),V(),V(),V(),V(),V(),V()).r.get(), \
2882 getClientStub(), \
2883 mInterfaceName, \
2884 funcId::value, \
2885 callOptions.apply(getClientStub()), \
2886 #func, \
2887 "V6"); \
2888 } \
2889 void genParms::RcfClientT::error__method_defined_out_of_order__##func( \
2890 funcId * , \
2891 ::RCF::RemoveOut<A1 >::type a1, \
2892 ::RCF::RemoveOut<A2 >::type a2, \
2893 ::RCF::RemoveOut<A3 >::type a3, \
2894 ::RCF::RemoveOut<A4 >::type a4, \
2895 ::RCF::RemoveOut<A5 >::type a5, \
2896 ::RCF::RemoveOut<A6 >::type a6) \
2897 { \
2898 }
2899
2900
2901
2902
2903 //------------------------------------------------------------------------------
2904 // Parameters - R7
2905 //------------------------------------------------------------------------------
2906
2907 // RCF_METHOD_R7
2908 #define RCF_METHOD_R7_INLINE(R,func , A1,A2,A3,A4,A5,A6,A7) \
2909 RCF_METHOD_R7_INLINE_(R,func , A1,A2,A3,A4,A5,A6,A7, RCF_MAKE_UNIQUE_ID(func, R7))
2910
2911 #define RCF_METHOD_R7_INLINE_(R,func , A1,A2,A3,A4,A5,A6,A7, id) \
2912 public: \
2913 RCF_MAKE_NEXT_DISPATCH_ID(id) \
2914 ::RCF::FutureImpl<R > func( \
2915 ::RCF::RemoveOut<A1 >::type a1, \
2916 ::RCF::RemoveOut<A2 >::type a2, \
2917 ::RCF::RemoveOut<A3 >::type a3, \
2918 ::RCF::RemoveOut<A4 >::type a4, \
2919 ::RCF::RemoveOut<A5 >::type a5, \
2920 ::RCF::RemoveOut<A6 >::type a6, \
2921 ::RCF::RemoveOut<A7 >::type a7) \
2922 { \
2923 return func( \
2924 ::RCF::CallOptions() , \
2925 a1,a2,a3,a4,a5,a6,a7); \
2926 } \
2927 ::RCF::FutureImpl<R > func( \
2928 const ::RCF::CallOptions &callOptions , \
2929 ::RCF::RemoveOut<A1 >::type a1, \
2930 ::RCF::RemoveOut<A2 >::type a2, \
2931 ::RCF::RemoveOut<A3 >::type a3, \
2932 ::RCF::RemoveOut<A4 >::type a4, \
2933 ::RCF::RemoveOut<A5 >::type a5, \
2934 ::RCF::RemoveOut<A6 >::type a6, \
2935 ::RCF::RemoveOut<A7 >::type a7) \
2936 { \
2937 getClientStub().setAsync(false); \
2938 return RCF::FutureImpl<R >( \
2939 ::RCF::AllocateClientParameters< \
2940 R , \
2941 A1,A2,A3,A4,A5,A6,A7 , \
2942 V,V,V,V,V,V,V,V >()( \
2943 getClientStub() , \
2944 a1,a2,a3,a4,a5,a6,a7 , \
2945 V(),V(),V(),V(),V(),V(),V(),V()).r.get(), \
2946 getClientStub(), \
2947 mInterfaceName, \
2948 id::value, \
2949 callOptions.apply(getClientStub()), \
2950 #func, \
2951 "R7"); \
2952 } \
2953 const char * getFunctionName(const id &) \
2954 { \
2955 return #func; \
2956 } \
2957 const char * getArity(const id &) \
2958 { \
2959 return "R7"; \
2960 } \
2961 \
2962 private: \
2963 template<typename T> \
2964 void invoke( \
2965 const id &, \
2966 ::RCF::RcfSession &session, \
2967 T &t) \
2968 { \
2969 if (session.isInProcess()) \
2970 { \
2971 ::RCF::ClientParameters< \
2972 R , \
2973 A1,A2,A3,A4,A5,A6,A7 , V,V,V,V,V,V,V,V > &p = static_cast<\
2974 ::RCF::ClientParameters< \
2975 R , \
2976 A1,A2,A3,A4,A5,A6,A7 , V,V,V,V,V,V,V,V > &>(* session.getInProcessParameters());\
2977 p.r.set( t.func( p.a1.get(), \
2978 p.a2.get(), \
2979 p.a3.get(), \
2980 p.a4.get(), \
2981 p.a5.get(), \
2982 p.a6.get(), \
2983 p.a7.get() ) ); \
2984 } \
2985 else \
2986 { \
2987 ::RCF::ServerParameters< \
2988 R , \
2989 A1,A2,A3,A4,A5,A6,A7 > &p = \
2990 ::RCF::AllocateServerParameters< \
2991 R , \
2992 A1,A2,A3,A4,A5,A6,A7 >()(session); \
2993 p.r.set( \
2994 session.getAutoSend(), \
2995 t.func( \
2996 p.a1.get(), \
2997 p.a2.get(), \
2998 p.a3.get(), \
2999 p.a4.get(), \
3000 p.a5.get(), \
3001 p.a6.get(), \
3002 p.a7.get())); \
3003 } \
3004 }
3005
3006 // RCF_METHOD_R7_DECL
3007 #define RCF_METHOD_R7_DECL(R,func , A1,A2,A3,A4,A5,A6,A7) \
3008 RCF_METHOD_R7_DECL_(R,func , A1,A2,A3,A4,A5,A6,A7, RCF_MAKE_UNIQUE_ID(func, R7))
3009
3010 #define RCF_METHOD_R7_DECL_(R,func , A1,A2,A3,A4,A5,A6,A7, id) \
3011 public: \
3012 RCF_MAKE_NEXT_DISPATCH_ID(id) \
3013 ::RCF::FutureImpl<R > func( \
3014 ::RCF::RemoveOut<A1 >::type a1, \
3015 ::RCF::RemoveOut<A2 >::type a2, \
3016 ::RCF::RemoveOut<A3 >::type a3, \
3017 ::RCF::RemoveOut<A4 >::type a4, \
3018 ::RCF::RemoveOut<A5 >::type a5, \
3019 ::RCF::RemoveOut<A6 >::type a6, \
3020 ::RCF::RemoveOut<A7 >::type a7) \
3021 { \
3022 return func( \
3023 ::RCF::CallOptions() , \
3024 a1,a2,a3,a4,a5,a6,a7); \
3025 } \
3026 \
3027 ::RCF::FutureImpl<R > func( \
3028 const ::RCF::CallOptions &callOptions , \
3029 ::RCF::RemoveOut<A1 >::type a1, \
3030 ::RCF::RemoveOut<A2 >::type a2, \
3031 ::RCF::RemoveOut<A3 >::type a3, \
3032 ::RCF::RemoveOut<A4 >::type a4, \
3033 ::RCF::RemoveOut<A5 >::type a5, \
3034 ::RCF::RemoveOut<A6 >::type a6, \
3035 ::RCF::RemoveOut<A7 >::type a7); \
3036 \
3037 void error__method_defined_out_of_order__##func( \
3038 id * , \
3039 ::RCF::RemoveOut<A1 >::type a1, \
3040 ::RCF::RemoveOut<A2 >::type a2, \
3041 ::RCF::RemoveOut<A3 >::type a3, \
3042 ::RCF::RemoveOut<A4 >::type a4, \
3043 ::RCF::RemoveOut<A5 >::type a5, \
3044 ::RCF::RemoveOut<A6 >::type a6, \
3045 ::RCF::RemoveOut<A7 >::type a7); \
3046 \
3047 const char * getFunctionName(const id &) \
3048 { \
3049 return #func; \
3050 } \
3051 const char * getArity(const id &) \
3052 { \
3053 return "R7"; \
3054 } \
3055 \
3056 private: \
3057 template<typename T> \
3058 void invoke( \
3059 const id &, \
3060 ::RCF::RcfSession &session, \
3061 T &t) \
3062 { \
3063 if (session.isInProcess()) \
3064 { \
3065 ::RCF::ClientParameters< \
3066 R , \
3067 A1,A2,A3,A4,A5,A6,A7 , V,V,V,V,V,V,V,V > &p = static_cast<\
3068 ::RCF::ClientParameters< \
3069 R , \
3070 A1,A2,A3,A4,A5,A6,A7 , V,V,V,V,V,V,V,V > &>(* session.getInProcessParameters());\
3071 p.r.set( t.func( p.a1.get(), \
3072 p.a2.get(), \
3073 p.a3.get(), \
3074 p.a4.get(), \
3075 p.a5.get(), \
3076 p.a6.get(), \
3077 p.a7.get() ) ); \
3078 } \
3079 else \
3080 { \
3081 ::RCF::ServerParameters< \
3082 R , \
3083 A1,A2,A3,A4,A5,A6,A7 > &p = \
3084 ::RCF::AllocateServerParameters< \
3085 R , \
3086 A1,A2,A3,A4,A5,A6,A7 >()(session); \
3087 p.r.set( \
3088 session.getAutoSend(), \
3089 t.func( \
3090 p.a1.get(), \
3091 p.a2.get(), \
3092 p.a3.get(), \
3093 p.a4.get(), \
3094 p.a5.get(), \
3095 p.a6.get(), \
3096 p.a7.get())); \
3097 } \
3098 }
3099
3100 // RCF_METHOD_R7_DEF
3101 #define RCF_METHOD_R7_DEF(R,func , A1,A2,A3,A4,A5,A6,A7) \
3102 RCF_METHOD_R7_DEF_(R,func , A1,A2,A3,A4,A5,A6,A7, RCF_PP_CAT(rcf_interface_id_1_, func, R7, __LINE__), RCF_MAKE_UNIQUE_ID(func, R7), RCF_PP_CAT(rcf_interface_id_2_, func, R7, __LINE__))
3103
3104 #define RCF_METHOD_R7_DEF_(R,func , A1,A2,A3,A4,A5,A6,A7, interfaceId, funcId, genParms)\
3105 RCF_CURRENT_STATIC_ID(interfaceId, RCF_interface_id_helper, int, int) \
3106 typedef GeneratorParms<interfaceId> genParms; \
3107 RCF_ADVANCE_STATIC_ID(funcId, RCF_def_dispatch_id_helper, ::RCF::Dummy<genParms::RcfClientT>, genParms::RcfClientT, static)\
3108 RCF_EXPORT_INTERFACE ::RCF::FutureImpl<R > genParms::RcfClientT::func( \
3109 const ::RCF::CallOptions &callOptions , \
3110 ::RCF::RemoveOut<A1 >::type a1, \
3111 ::RCF::RemoveOut<A2 >::type a2, \
3112 ::RCF::RemoveOut<A3 >::type a3, \
3113 ::RCF::RemoveOut<A4 >::type a4, \
3114 ::RCF::RemoveOut<A5 >::type a5, \
3115 ::RCF::RemoveOut<A6 >::type a6, \
3116 ::RCF::RemoveOut<A7 >::type a7) \
3117 { \
3118 getClientStub().setAsync(false); \
3119 return RCF::FutureImpl<R >( \
3120 ::RCF::AllocateClientParameters< \
3121 R , \
3122 A1,A2,A3,A4,A5,A6,A7 , \
3123 V,V,V,V,V,V,V,V >()( \
3124 getClientStub() , \
3125 a1,a2,a3,a4,a5,a6,a7 , \
3126 V(),V(),V(),V(),V(),V(),V(),V()).r.get(), \
3127 getClientStub(), \
3128 mInterfaceName, \
3129 funcId::value, \
3130 callOptions.apply(getClientStub()), \
3131 #func, \
3132 "R7"); \
3133 } \
3134 void genParms::RcfClientT::error__method_defined_out_of_order__##func( \
3135 funcId * , \
3136 ::RCF::RemoveOut<A1 >::type a1, \
3137 ::RCF::RemoveOut<A2 >::type a2, \
3138 ::RCF::RemoveOut<A3 >::type a3, \
3139 ::RCF::RemoveOut<A4 >::type a4, \
3140 ::RCF::RemoveOut<A5 >::type a5, \
3141 ::RCF::RemoveOut<A6 >::type a6, \
3142 ::RCF::RemoveOut<A7 >::type a7) \
3143 { \
3144 }
3145
3146
3147
3148 //------------------------------------------------------------------------------
3149 // Parameters - V7
3150 //------------------------------------------------------------------------------
3151
3152 // RCF_METHOD_V7
3153 #define RCF_METHOD_V7_INLINE(R,func , A1,A2,A3,A4,A5,A6,A7) \
3154 RCF_METHOD_V7_INLINE_(R,func , A1,A2,A3,A4,A5,A6,A7, RCF_MAKE_UNIQUE_ID(func, V7))
3155
3156 #define RCF_METHOD_V7_INLINE_(R,func , A1,A2,A3,A4,A5,A6,A7, id) \
3157 public: \
3158 BOOST_STATIC_ASSERT(( boost::is_same<R, void>::value )); \
3159 RCF_MAKE_NEXT_DISPATCH_ID(id) \
3160 ::RCF::FutureImpl<V> func( \
3161 ::RCF::RemoveOut<A1 >::type a1, \
3162 ::RCF::RemoveOut<A2 >::type a2, \
3163 ::RCF::RemoveOut<A3 >::type a3, \
3164 ::RCF::RemoveOut<A4 >::type a4, \
3165 ::RCF::RemoveOut<A5 >::type a5, \
3166 ::RCF::RemoveOut<A6 >::type a6, \
3167 ::RCF::RemoveOut<A7 >::type a7) \
3168 { \
3169 return func( \
3170 ::RCF::CallOptions() , \
3171 a1,a2,a3,a4,a5,a6,a7); \
3172 } \
3173 ::RCF::FutureImpl<V> func( \
3174 const ::RCF::CallOptions &callOptions , \
3175 ::RCF::RemoveOut<A1 >::type a1, \
3176 ::RCF::RemoveOut<A2 >::type a2, \
3177 ::RCF::RemoveOut<A3 >::type a3, \
3178 ::RCF::RemoveOut<A4 >::type a4, \
3179 ::RCF::RemoveOut<A5 >::type a5, \
3180 ::RCF::RemoveOut<A6 >::type a6, \
3181 ::RCF::RemoveOut<A7 >::type a7) \
3182 { \
3183 getClientStub().setAsync(false); \
3184 return RCF::FutureImpl<V>( \
3185 ::RCF::AllocateClientParameters< \
3186 V , \
3187 A1,A2,A3,A4,A5,A6,A7 , \
3188 V,V,V,V,V,V,V,V >()( \
3189 getClientStub() , \
3190 a1,a2,a3,a4,a5,a6,a7 , \
3191 V(),V(),V(),V(),V(),V(),V(),V()).r.get(), \
3192 getClientStub(), \
3193 mInterfaceName, \
3194 id::value, \
3195 callOptions.apply(getClientStub()), \
3196 #func, \
3197 "V7"); \
3198 } \
3199 const char * getFunctionName(const id &) \
3200 { \
3201 return #func; \
3202 } \
3203 const char * getArity(const id &) \
3204 { \
3205 return "V7"; \
3206 } \
3207 \
3208 private: \
3209 template<typename T> \
3210 void invoke( \
3211 const id &, \
3212 ::RCF::RcfSession &session, \
3213 T &t) \
3214 { \
3215 if (session.isInProcess()) \
3216 { \
3217 ::RCF::ClientParameters< \
3218 V , \
3219 A1,A2,A3,A4,A5,A6,A7 , V,V,V,V,V,V,V,V > &p = static_cast<\
3220 ::RCF::ClientParameters< \
3221 V , \
3222 A1,A2,A3,A4,A5,A6,A7 , V,V,V,V,V,V,V,V > &>(* session.getInProcessParameters());\
3223 RCF_UNUSED_VARIABLE(p); \
3224 t.func( \
3225 p.a1.get(), \
3226 p.a2.get(), \
3227 p.a3.get(), \
3228 p.a4.get(), \
3229 p.a5.get(), \
3230 p.a6.get(), \
3231 p.a7.get() ); \
3232 } \
3233 else \
3234 { \
3235 ::RCF::ServerParameters< \
3236 V , \
3237 A1,A2,A3,A4,A5,A6,A7 > &p = \
3238 ::RCF::AllocateServerParameters< \
3239 V , \
3240 A1,A2,A3,A4,A5,A6,A7 >()(session); \
3241 RCF_UNUSED_VARIABLE(p); \
3242 t.func( \
3243 p.a1.get(), \
3244 p.a2.get(), \
3245 p.a3.get(), \
3246 p.a4.get(), \
3247 p.a5.get(), \
3248 p.a6.get(), \
3249 p.a7.get()); \
3250 } \
3251 }
3252
3253 // RCF_METHOD_V7_DECL
3254 #define RCF_METHOD_V7_DECL(R,func , A1,A2,A3,A4,A5,A6,A7) \
3255 RCF_METHOD_V7_DECL_(R,func , A1,A2,A3,A4,A5,A6,A7, RCF_MAKE_UNIQUE_ID(func, V7))
3256
3257 #define RCF_METHOD_V7_DECL_(R,func , A1,A2,A3,A4,A5,A6,A7, id) \
3258 public: \
3259 BOOST_STATIC_ASSERT(( boost::is_same<R, void>::value )); \
3260 RCF_MAKE_NEXT_DISPATCH_ID(id) \
3261 ::RCF::FutureImpl<V> func( \
3262 ::RCF::RemoveOut<A1 >::type a1, \
3263 ::RCF::RemoveOut<A2 >::type a2, \
3264 ::RCF::RemoveOut<A3 >::type a3, \
3265 ::RCF::RemoveOut<A4 >::type a4, \
3266 ::RCF::RemoveOut<A5 >::type a5, \
3267 ::RCF::RemoveOut<A6 >::type a6, \
3268 ::RCF::RemoveOut<A7 >::type a7) \
3269 { \
3270 return func( \
3271 ::RCF::CallOptions() , \
3272 a1,a2,a3,a4,a5,a6,a7); \
3273 } \
3274 \
3275 ::RCF::FutureImpl<V> func( \
3276 const ::RCF::CallOptions &callOptions , \
3277 ::RCF::RemoveOut<A1 >::type a1, \
3278 ::RCF::RemoveOut<A2 >::type a2, \
3279 ::RCF::RemoveOut<A3 >::type a3, \
3280 ::RCF::RemoveOut<A4 >::type a4, \
3281 ::RCF::RemoveOut<A5 >::type a5, \
3282 ::RCF::RemoveOut<A6 >::type a6, \
3283 ::RCF::RemoveOut<A7 >::type a7); \
3284 \
3285 void error__method_defined_out_of_order__##func( \
3286 id * , \
3287 ::RCF::RemoveOut<A1 >::type a1, \
3288 ::RCF::RemoveOut<A2 >::type a2, \
3289 ::RCF::RemoveOut<A3 >::type a3, \
3290 ::RCF::RemoveOut<A4 >::type a4, \
3291 ::RCF::RemoveOut<A5 >::type a5, \
3292 ::RCF::RemoveOut<A6 >::type a6, \
3293 ::RCF::RemoveOut<A7 >::type a7); \
3294 \
3295 const char * getFunctionName(const id &) \
3296 { \
3297 return #func; \
3298 } \
3299 const char * getArity(const id &) \
3300 { \
3301 return "V7"; \
3302 } \
3303 \
3304 private: \
3305 template<typename T> \
3306 void invoke( \
3307 const id &, \
3308 ::RCF::RcfSession &session, \
3309 T &t) \
3310 { \
3311 if (session.isInProcess()) \
3312 { \
3313 ::RCF::ClientParameters< \
3314 V , \
3315 A1,A2,A3,A4,A5,A6,A7 , V,V,V,V,V,V,V,V > &p = static_cast<\
3316 ::RCF::ClientParameters< \
3317 V , \
3318 A1,A2,A3,A4,A5,A6,A7 , V,V,V,V,V,V,V,V > &>(* session.getInProcessParameters());\
3319 RCF_UNUSED_VARIABLE(p); \
3320 t.func( \
3321 p.a1.get(), \
3322 p.a2.get(), \
3323 p.a3.get(), \
3324 p.a4.get(), \
3325 p.a5.get(), \
3326 p.a6.get(), \
3327 p.a7.get() ); \
3328 } \
3329 else \
3330 { \
3331 ::RCF::ServerParameters< \
3332 V , \
3333 A1,A2,A3,A4,A5,A6,A7 > &p = \
3334 ::RCF::AllocateServerParameters< \
3335 V , \
3336 A1,A2,A3,A4,A5,A6,A7 >()(session); \
3337 RCF_UNUSED_VARIABLE(p); \
3338 t.func( \
3339 p.a1.get(), \
3340 p.a2.get(), \
3341 p.a3.get(), \
3342 p.a4.get(), \
3343 p.a5.get(), \
3344 p.a6.get(), \
3345 p.a7.get()); \
3346 } \
3347 }
3348
3349 // RCF_METHOD_V7_DEF
3350 #define RCF_METHOD_V7_DEF(R,func , A1,A2,A3,A4,A5,A6,A7) \
3351 RCF_METHOD_V7_DEF_(R,func , A1,A2,A3,A4,A5,A6,A7, RCF_PP_CAT(rcf_interface_id_1_, func, R7, __LINE__), RCF_MAKE_UNIQUE_ID(func, R7), RCF_PP_CAT(rcf_interface_id_2_, func, R7, __LINE__))
3352
3353 #define RCF_METHOD_V7_DEF_(R,func , A1,A2,A3,A4,A5,A6,A7, interfaceId, funcId, genParms)\
3354 RCF_CURRENT_STATIC_ID(interfaceId, RCF_interface_id_helper, int, int) \
3355 typedef GeneratorParms<interfaceId> genParms; \
3356 RCF_ADVANCE_STATIC_ID(funcId, RCF_def_dispatch_id_helper, ::RCF::Dummy<genParms::RcfClientT>, genParms::RcfClientT, static)\
3357 RCF_EXPORT_INTERFACE ::RCF::FutureImpl<::RCF::Void> genParms::RcfClientT::func(\
3358 const ::RCF::CallOptions &callOptions , \
3359 ::RCF::RemoveOut<A1 >::type a1, \
3360 ::RCF::RemoveOut<A2 >::type a2, \
3361 ::RCF::RemoveOut<A3 >::type a3, \
3362 ::RCF::RemoveOut<A4 >::type a4, \
3363 ::RCF::RemoveOut<A5 >::type a5, \
3364 ::RCF::RemoveOut<A6 >::type a6, \
3365 ::RCF::RemoveOut<A7 >::type a7) \
3366 { \
3367 typedef ::RCF::Void V; \
3368 getClientStub().setAsync(false); \
3369 return RCF::FutureImpl<V >( \
3370 ::RCF::AllocateClientParameters< \
3371 V , \
3372 A1,A2,A3,A4,A5,A6,A7 , \
3373 V,V,V,V,V,V,V,V >()( \
3374 getClientStub() , \
3375 a1,a2,a3,a4,a5,a6,a7 , \
3376 V(),V(),V(),V(),V(),V(),V(),V()).r.get(), \
3377 getClientStub(), \
3378 mInterfaceName, \
3379 funcId::value, \
3380 callOptions.apply(getClientStub()), \
3381 #func, \
3382 "V7"); \
3383 } \
3384 void genParms::RcfClientT::error__method_defined_out_of_order__##func( \
3385 funcId * , \
3386 ::RCF::RemoveOut<A1 >::type a1, \
3387 ::RCF::RemoveOut<A2 >::type a2, \
3388 ::RCF::RemoveOut<A3 >::type a3, \
3389 ::RCF::RemoveOut<A4 >::type a4, \
3390 ::RCF::RemoveOut<A5 >::type a5, \
3391 ::RCF::RemoveOut<A6 >::type a6, \
3392 ::RCF::RemoveOut<A7 >::type a7) \
3393 { \
3394 }
3395
3396
3397
3398
3399 //------------------------------------------------------------------------------
3400 // Parameters - R8
3401 //------------------------------------------------------------------------------
3402
3403 // RCF_METHOD_R8
3404 #define RCF_METHOD_R8_INLINE(R,func , A1,A2,A3,A4,A5,A6,A7,A8) \
3405 RCF_METHOD_R8_INLINE_(R,func , A1,A2,A3,A4,A5,A6,A7,A8, RCF_MAKE_UNIQUE_ID(func, R8))
3406
3407 #define RCF_METHOD_R8_INLINE_(R,func , A1,A2,A3,A4,A5,A6,A7,A8, id) \
3408 public: \
3409 RCF_MAKE_NEXT_DISPATCH_ID(id) \
3410 ::RCF::FutureImpl<R > func( \
3411 ::RCF::RemoveOut<A1 >::type a1, \
3412 ::RCF::RemoveOut<A2 >::type a2, \
3413 ::RCF::RemoveOut<A3 >::type a3, \
3414 ::RCF::RemoveOut<A4 >::type a4, \
3415 ::RCF::RemoveOut<A5 >::type a5, \
3416 ::RCF::RemoveOut<A6 >::type a6, \
3417 ::RCF::RemoveOut<A7 >::type a7, \
3418 ::RCF::RemoveOut<A8 >::type a8) \
3419 { \
3420 return func( \
3421 ::RCF::CallOptions() , \
3422 a1,a2,a3,a4,a5,a6,a7,a8); \
3423 } \
3424 ::RCF::FutureImpl<R > func( \
3425 const ::RCF::CallOptions &callOptions , \
3426 ::RCF::RemoveOut<A1 >::type a1, \
3427 ::RCF::RemoveOut<A2 >::type a2, \
3428 ::RCF::RemoveOut<A3 >::type a3, \
3429 ::RCF::RemoveOut<A4 >::type a4, \
3430 ::RCF::RemoveOut<A5 >::type a5, \
3431 ::RCF::RemoveOut<A6 >::type a6, \
3432 ::RCF::RemoveOut<A7 >::type a7, \
3433 ::RCF::RemoveOut<A8 >::type a8) \
3434 { \
3435 getClientStub().setAsync(false); \
3436 return RCF::FutureImpl<R >( \
3437 ::RCF::AllocateClientParameters< \
3438 R , \
3439 A1,A2,A3,A4,A5,A6,A7,A8 , \
3440 V,V,V,V,V,V,V >()( \
3441 getClientStub() , \
3442 a1,a2,a3,a4,a5,a6,a7,a8 , \
3443 V(),V(),V(),V(),V(),V(),V()).r.get(), \
3444 getClientStub(), \
3445 mInterfaceName, \
3446 id::value, \
3447 callOptions.apply(getClientStub()), \
3448 #func, \
3449 "R8"); \
3450 } \
3451 const char * getFunctionName(const id &) \
3452 { \
3453 return #func; \
3454 } \
3455 const char * getArity(const id &) \
3456 { \
3457 return "R8"; \
3458 } \
3459 \
3460 private: \
3461 template<typename T> \
3462 void invoke( \
3463 const id &, \
3464 ::RCF::RcfSession &session, \
3465 T &t) \
3466 { \
3467 if (session.isInProcess()) \
3468 { \
3469 ::RCF::ClientParameters< \
3470 R , \
3471 A1,A2,A3,A4,A5,A6,A7,A8 , V,V,V,V,V,V,V > &p = static_cast<\
3472 ::RCF::ClientParameters< \
3473 R , \
3474 A1,A2,A3,A4,A5,A6,A7,A8 , V,V,V,V,V,V,V > &>(* session.getInProcessParameters());\
3475 p.r.set( t.func( p.a1.get(), \
3476 p.a2.get(), \
3477 p.a3.get(), \
3478 p.a4.get(), \
3479 p.a5.get(), \
3480 p.a6.get(), \
3481 p.a7.get(), \
3482 p.a8.get() ) ); \
3483 } \
3484 else \
3485 { \
3486 ::RCF::ServerParameters< \
3487 R , \
3488 A1,A2,A3,A4,A5,A6,A7,A8 > &p = \
3489 ::RCF::AllocateServerParameters< \
3490 R , \
3491 A1,A2,A3,A4,A5,A6,A7,A8 >()(session); \
3492 p.r.set( \
3493 session.getAutoSend(), \
3494 t.func( \
3495 p.a1.get(), \
3496 p.a2.get(), \
3497 p.a3.get(), \
3498 p.a4.get(), \
3499 p.a5.get(), \
3500 p.a6.get(), \
3501 p.a7.get(), \
3502 p.a8.get())); \
3503 } \
3504 }
3505
3506 // RCF_METHOD_R8_DECL
3507 #define RCF_METHOD_R8_DECL(R,func , A1,A2,A3,A4,A5,A6,A7,A8) \
3508 RCF_METHOD_R8_DECL_(R,func , A1,A2,A3,A4,A5,A6,A7,A8, RCF_MAKE_UNIQUE_ID(func, R8))
3509
3510 #define RCF_METHOD_R8_DECL_(R,func , A1,A2,A3,A4,A5,A6,A7,A8, id) \
3511 public: \
3512 RCF_MAKE_NEXT_DISPATCH_ID(id) \
3513 ::RCF::FutureImpl<R > func( \
3514 ::RCF::RemoveOut<A1 >::type a1, \
3515 ::RCF::RemoveOut<A2 >::type a2, \
3516 ::RCF::RemoveOut<A3 >::type a3, \
3517 ::RCF::RemoveOut<A4 >::type a4, \
3518 ::RCF::RemoveOut<A5 >::type a5, \
3519 ::RCF::RemoveOut<A6 >::type a6, \
3520 ::RCF::RemoveOut<A7 >::type a7, \
3521 ::RCF::RemoveOut<A8 >::type a8) \
3522 { \
3523 return func( \
3524 ::RCF::CallOptions() , \
3525 a1,a2,a3,a4,a5,a6,a7,a8); \
3526 } \
3527 \
3528 ::RCF::FutureImpl<R > func( \
3529 const ::RCF::CallOptions &callOptions , \
3530 ::RCF::RemoveOut<A1 >::type a1, \
3531 ::RCF::RemoveOut<A2 >::type a2, \
3532 ::RCF::RemoveOut<A3 >::type a3, \
3533 ::RCF::RemoveOut<A4 >::type a4, \
3534 ::RCF::RemoveOut<A5 >::type a5, \
3535 ::RCF::RemoveOut<A6 >::type a6, \
3536 ::RCF::RemoveOut<A7 >::type a7, \
3537 ::RCF::RemoveOut<A8 >::type a8); \
3538 \
3539 void error__method_defined_out_of_order__##func( \
3540 id * , \
3541 ::RCF::RemoveOut<A1 >::type a1, \
3542 ::RCF::RemoveOut<A2 >::type a2, \
3543 ::RCF::RemoveOut<A3 >::type a3, \
3544 ::RCF::RemoveOut<A4 >::type a4, \
3545 ::RCF::RemoveOut<A5 >::type a5, \
3546 ::RCF::RemoveOut<A6 >::type a6, \
3547 ::RCF::RemoveOut<A7 >::type a7, \
3548 ::RCF::RemoveOut<A8 >::type a8); \
3549 \
3550 const char * getFunctionName(const id &) \
3551 { \
3552 return #func; \
3553 } \
3554 const char * getArity(const id &) \
3555 { \
3556 return "R8"; \
3557 } \
3558 \
3559 private: \
3560 template<typename T> \
3561 void invoke( \
3562 const id &, \
3563 ::RCF::RcfSession &session, \
3564 T &t) \
3565 { \
3566 if (session.isInProcess()) \
3567 { \
3568 ::RCF::ClientParameters< \
3569 R , \
3570 A1,A2,A3,A4,A5,A6,A7,A8 , V,V,V,V,V,V,V > &p = static_cast<\
3571 ::RCF::ClientParameters< \
3572 R , \
3573 A1,A2,A3,A4,A5,A6,A7,A8 , V,V,V,V,V,V,V > &>(* session.getInProcessParameters());\
3574 p.r.set( t.func( p.a1.get(), \
3575 p.a2.get(), \
3576 p.a3.get(), \
3577 p.a4.get(), \
3578 p.a5.get(), \
3579 p.a6.get(), \
3580 p.a7.get(), \
3581 p.a8.get() ) ); \
3582 } \
3583 else \
3584 { \
3585 ::RCF::ServerParameters< \
3586 R , \
3587 A1,A2,A3,A4,A5,A6,A7,A8 > &p = \
3588 ::RCF::AllocateServerParameters< \
3589 R , \
3590 A1,A2,A3,A4,A5,A6,A7,A8 >()(session); \
3591 p.r.set( \
3592 session.getAutoSend(), \
3593 t.func( \
3594 p.a1.get(), \
3595 p.a2.get(), \
3596 p.a3.get(), \
3597 p.a4.get(), \
3598 p.a5.get(), \
3599 p.a6.get(), \
3600 p.a7.get(), \
3601 p.a8.get())); \
3602 } \
3603 }
3604
3605 // RCF_METHOD_R8_DEF
3606 #define RCF_METHOD_R8_DEF(R,func , A1,A2,A3,A4,A5,A6,A7,A8) \
3607 RCF_METHOD_R8_DEF_(R,func , A1,A2,A3,A4,A5,A6,A7,A8, RCF_PP_CAT(rcf_interface_id_1_, func, R8, __LINE__), RCF_MAKE_UNIQUE_ID(func, R8), RCF_PP_CAT(rcf_interface_id_2_, func, R8, __LINE__))
3608
3609 #define RCF_METHOD_R8_DEF_(R,func , A1,A2,A3,A4,A5,A6,A7,A8, interfaceId, funcId, genParms)\
3610 RCF_CURRENT_STATIC_ID(interfaceId, RCF_interface_id_helper, int, int) \
3611 typedef GeneratorParms<interfaceId> genParms; \
3612 RCF_ADVANCE_STATIC_ID(funcId, RCF_def_dispatch_id_helper, ::RCF::Dummy<genParms::RcfClientT>, genParms::RcfClientT, static)\
3613 RCF_EXPORT_INTERFACE ::RCF::FutureImpl<R > genParms::RcfClientT::func( \
3614 const ::RCF::CallOptions &callOptions , \
3615 ::RCF::RemoveOut<A1 >::type a1, \
3616 ::RCF::RemoveOut<A2 >::type a2, \
3617 ::RCF::RemoveOut<A3 >::type a3, \
3618 ::RCF::RemoveOut<A4 >::type a4, \
3619 ::RCF::RemoveOut<A5 >::type a5, \
3620 ::RCF::RemoveOut<A6 >::type a6, \
3621 ::RCF::RemoveOut<A7 >::type a7, \
3622 ::RCF::RemoveOut<A8 >::type a8) \
3623 { \
3624 getClientStub().setAsync(false); \
3625 return RCF::FutureImpl<R >( \
3626 ::RCF::AllocateClientParameters< \
3627 R , \
3628 A1,A2,A3,A4,A5,A6,A7,A8 , \
3629 V,V,V,V,V,V,V >()( \
3630 getClientStub() , \
3631 a1,a2,a3,a4,a5,a6,a7,a8 , \
3632 V(),V(),V(),V(),V(),V(),V()).r.get(), \
3633 getClientStub(), \
3634 mInterfaceName, \
3635 funcId::value, \
3636 callOptions.apply(getClientStub()), \
3637 #func, \
3638 "R8"); \
3639 } \
3640 void genParms::RcfClientT::error__method_defined_out_of_order__##func( \
3641 funcId * , \
3642 ::RCF::RemoveOut<A1 >::type a1, \
3643 ::RCF::RemoveOut<A2 >::type a2, \
3644 ::RCF::RemoveOut<A3 >::type a3, \
3645 ::RCF::RemoveOut<A4 >::type a4, \
3646 ::RCF::RemoveOut<A5 >::type a5, \
3647 ::RCF::RemoveOut<A6 >::type a6, \
3648 ::RCF::RemoveOut<A7 >::type a7, \
3649 ::RCF::RemoveOut<A8 >::type a8) \
3650 { \
3651 }
3652
3653
3654
3655 //------------------------------------------------------------------------------
3656 // Parameters - V8
3657 //------------------------------------------------------------------------------
3658
3659 // RCF_METHOD_V8
3660 #define RCF_METHOD_V8_INLINE(R,func , A1,A2,A3,A4,A5,A6,A7,A8) \
3661 RCF_METHOD_V8_INLINE_(R,func , A1,A2,A3,A4,A5,A6,A7,A8, RCF_MAKE_UNIQUE_ID(func, V8))
3662
3663 #define RCF_METHOD_V8_INLINE_(R,func , A1,A2,A3,A4,A5,A6,A7,A8, id) \
3664 public: \
3665 BOOST_STATIC_ASSERT(( boost::is_same<R, void>::value )); \
3666 RCF_MAKE_NEXT_DISPATCH_ID(id) \
3667 ::RCF::FutureImpl<V> func( \
3668 ::RCF::RemoveOut<A1 >::type a1, \
3669 ::RCF::RemoveOut<A2 >::type a2, \
3670 ::RCF::RemoveOut<A3 >::type a3, \
3671 ::RCF::RemoveOut<A4 >::type a4, \
3672 ::RCF::RemoveOut<A5 >::type a5, \
3673 ::RCF::RemoveOut<A6 >::type a6, \
3674 ::RCF::RemoveOut<A7 >::type a7, \
3675 ::RCF::RemoveOut<A8 >::type a8) \
3676 { \
3677 return func( \
3678 ::RCF::CallOptions() , \
3679 a1,a2,a3,a4,a5,a6,a7,a8); \
3680 } \
3681 ::RCF::FutureImpl<V> func( \
3682 const ::RCF::CallOptions &callOptions , \
3683 ::RCF::RemoveOut<A1 >::type a1, \
3684 ::RCF::RemoveOut<A2 >::type a2, \
3685 ::RCF::RemoveOut<A3 >::type a3, \
3686 ::RCF::RemoveOut<A4 >::type a4, \
3687 ::RCF::RemoveOut<A5 >::type a5, \
3688 ::RCF::RemoveOut<A6 >::type a6, \
3689 ::RCF::RemoveOut<A7 >::type a7, \
3690 ::RCF::RemoveOut<A8 >::type a8) \
3691 { \
3692 getClientStub().setAsync(false); \
3693 return RCF::FutureImpl<V>( \
3694 ::RCF::AllocateClientParameters< \
3695 V , \
3696 A1,A2,A3,A4,A5,A6,A7,A8 , \
3697 V,V,V,V,V,V,V >()( \
3698 getClientStub() , \
3699 a1,a2,a3,a4,a5,a6,a7,a8 , \
3700 V(),V(),V(),V(),V(),V(),V()).r.get(), \
3701 getClientStub(), \
3702 mInterfaceName, \
3703 id::value, \
3704 callOptions.apply(getClientStub()), \
3705 #func, \
3706 "V8"); \
3707 } \
3708 const char * getFunctionName(const id &) \
3709 { \
3710 return #func; \
3711 } \
3712 const char * getArity(const id &) \
3713 { \
3714 return "V8"; \
3715 } \
3716 \
3717 private: \
3718 template<typename T> \
3719 void invoke( \
3720 const id &, \
3721 ::RCF::RcfSession &session, \
3722 T &t) \
3723 { \
3724 if (session.isInProcess()) \
3725 { \
3726 ::RCF::ClientParameters< \
3727 V , \
3728 A1,A2,A3,A4,A5,A6,A7,A8 , V,V,V,V,V,V,V > &p = static_cast<\
3729 ::RCF::ClientParameters< \
3730 V , \
3731 A1,A2,A3,A4,A5,A6,A7,A8 , V,V,V,V,V,V,V > &>(* session.getInProcessParameters());\
3732 RCF_UNUSED_VARIABLE(p); \
3733 t.func( \
3734 p.a1.get(), \
3735 p.a2.get(), \
3736 p.a3.get(), \
3737 p.a4.get(), \
3738 p.a5.get(), \
3739 p.a6.get(), \
3740 p.a7.get(), \
3741 p.a8.get() ); \
3742 } \
3743 else \
3744 { \
3745 ::RCF::ServerParameters< \
3746 V , \
3747 A1,A2,A3,A4,A5,A6,A7,A8 > &p = \
3748 ::RCF::AllocateServerParameters< \
3749 V , \
3750 A1,A2,A3,A4,A5,A6,A7,A8 >()(session); \
3751 RCF_UNUSED_VARIABLE(p); \
3752 t.func( \
3753 p.a1.get(), \
3754 p.a2.get(), \
3755 p.a3.get(), \
3756 p.a4.get(), \
3757 p.a5.get(), \
3758 p.a6.get(), \
3759 p.a7.get(), \
3760 p.a8.get()); \
3761 } \
3762 }
3763
3764 // RCF_METHOD_V8_DECL
3765 #define RCF_METHOD_V8_DECL(R,func , A1,A2,A3,A4,A5,A6,A7,A8) \
3766 RCF_METHOD_V8_DECL_(R,func , A1,A2,A3,A4,A5,A6,A7,A8, RCF_MAKE_UNIQUE_ID(func, V8))
3767
3768 #define RCF_METHOD_V8_DECL_(R,func , A1,A2,A3,A4,A5,A6,A7,A8, id) \
3769 public: \
3770 BOOST_STATIC_ASSERT(( boost::is_same<R, void>::value )); \
3771 RCF_MAKE_NEXT_DISPATCH_ID(id) \
3772 ::RCF::FutureImpl<V> func( \
3773 ::RCF::RemoveOut<A1 >::type a1, \
3774 ::RCF::RemoveOut<A2 >::type a2, \
3775 ::RCF::RemoveOut<A3 >::type a3, \
3776 ::RCF::RemoveOut<A4 >::type a4, \
3777 ::RCF::RemoveOut<A5 >::type a5, \
3778 ::RCF::RemoveOut<A6 >::type a6, \
3779 ::RCF::RemoveOut<A7 >::type a7, \
3780 ::RCF::RemoveOut<A8 >::type a8) \
3781 { \
3782 return func( \
3783 ::RCF::CallOptions() , \
3784 a1,a2,a3,a4,a5,a6,a7,a8); \
3785 } \
3786 \
3787 ::RCF::FutureImpl<V> func( \
3788 const ::RCF::CallOptions &callOptions , \
3789 ::RCF::RemoveOut<A1 >::type a1, \
3790 ::RCF::RemoveOut<A2 >::type a2, \
3791 ::RCF::RemoveOut<A3 >::type a3, \
3792 ::RCF::RemoveOut<A4 >::type a4, \
3793 ::RCF::RemoveOut<A5 >::type a5, \
3794 ::RCF::RemoveOut<A6 >::type a6, \
3795 ::RCF::RemoveOut<A7 >::type a7, \
3796 ::RCF::RemoveOut<A8 >::type a8); \
3797 \
3798 void error__method_defined_out_of_order__##func( \
3799 id * , \
3800 ::RCF::RemoveOut<A1 >::type a1, \
3801 ::RCF::RemoveOut<A2 >::type a2, \
3802 ::RCF::RemoveOut<A3 >::type a3, \
3803 ::RCF::RemoveOut<A4 >::type a4, \
3804 ::RCF::RemoveOut<A5 >::type a5, \
3805 ::RCF::RemoveOut<A6 >::type a6, \
3806 ::RCF::RemoveOut<A7 >::type a7, \
3807 ::RCF::RemoveOut<A8 >::type a8); \
3808 \
3809 const char * getFunctionName(const id &) \
3810 { \
3811 return #func; \
3812 } \
3813 const char * getArity(const id &) \
3814 { \
3815 return "V8"; \
3816 } \
3817 \
3818 private: \
3819 template<typename T> \
3820 void invoke( \
3821 const id &, \
3822 ::RCF::RcfSession &session, \
3823 T &t) \
3824 { \
3825 if (session.isInProcess()) \
3826 { \
3827 ::RCF::ClientParameters< \
3828 V , \
3829 A1,A2,A3,A4,A5,A6,A7,A8 , V,V,V,V,V,V,V > &p = static_cast<\
3830 ::RCF::ClientParameters< \
3831 V , \
3832 A1,A2,A3,A4,A5,A6,A7,A8 , V,V,V,V,V,V,V > &>(* session.getInProcessParameters());\
3833 RCF_UNUSED_VARIABLE(p); \
3834 t.func( \
3835 p.a1.get(), \
3836 p.a2.get(), \
3837 p.a3.get(), \
3838 p.a4.get(), \
3839 p.a5.get(), \
3840 p.a6.get(), \
3841 p.a7.get(), \
3842 p.a8.get() ); \
3843 } \
3844 else \
3845 { \
3846 ::RCF::ServerParameters< \
3847 V , \
3848 A1,A2,A3,A4,A5,A6,A7,A8 > &p = \
3849 ::RCF::AllocateServerParameters< \
3850 V , \
3851 A1,A2,A3,A4,A5,A6,A7,A8 >()(session); \
3852 RCF_UNUSED_VARIABLE(p); \
3853 t.func( \
3854 p.a1.get(), \
3855 p.a2.get(), \
3856 p.a3.get(), \
3857 p.a4.get(), \
3858 p.a5.get(), \
3859 p.a6.get(), \
3860 p.a7.get(), \
3861 p.a8.get()); \
3862 } \
3863 }
3864
3865 // RCF_METHOD_V8_DEF
3866 #define RCF_METHOD_V8_DEF(R,func , A1,A2,A3,A4,A5,A6,A7,A8) \
3867 RCF_METHOD_V8_DEF_(R,func , A1,A2,A3,A4,A5,A6,A7,A8, RCF_PP_CAT(rcf_interface_id_1_, func, R8, __LINE__), RCF_MAKE_UNIQUE_ID(func, R8), RCF_PP_CAT(rcf_interface_id_2_, func, R8, __LINE__))
3868
3869 #define RCF_METHOD_V8_DEF_(R,func , A1,A2,A3,A4,A5,A6,A7,A8, interfaceId, funcId, genParms)\
3870 RCF_CURRENT_STATIC_ID(interfaceId, RCF_interface_id_helper, int, int) \
3871 typedef GeneratorParms<interfaceId> genParms; \
3872 RCF_ADVANCE_STATIC_ID(funcId, RCF_def_dispatch_id_helper, ::RCF::Dummy<genParms::RcfClientT>, genParms::RcfClientT, static)\
3873 RCF_EXPORT_INTERFACE ::RCF::FutureImpl<::RCF::Void> genParms::RcfClientT::func(\
3874 const ::RCF::CallOptions &callOptions , \
3875 ::RCF::RemoveOut<A1 >::type a1, \
3876 ::RCF::RemoveOut<A2 >::type a2, \
3877 ::RCF::RemoveOut<A3 >::type a3, \
3878 ::RCF::RemoveOut<A4 >::type a4, \
3879 ::RCF::RemoveOut<A5 >::type a5, \
3880 ::RCF::RemoveOut<A6 >::type a6, \
3881 ::RCF::RemoveOut<A7 >::type a7, \
3882 ::RCF::RemoveOut<A8 >::type a8) \
3883 { \
3884 typedef ::RCF::Void V; \
3885 getClientStub().setAsync(false); \
3886 return RCF::FutureImpl<V >( \
3887 ::RCF::AllocateClientParameters< \
3888 V , \
3889 A1,A2,A3,A4,A5,A6,A7,A8 , \
3890 V,V,V,V,V,V,V >()( \
3891 getClientStub() , \
3892 a1,a2,a3,a4,a5,a6,a7,a8 , \
3893 V(),V(),V(),V(),V(),V(),V()).r.get(), \
3894 getClientStub(), \
3895 mInterfaceName, \
3896 funcId::value, \
3897 callOptions.apply(getClientStub()), \
3898 #func, \
3899 "V8"); \
3900 } \
3901 void genParms::RcfClientT::error__method_defined_out_of_order__##func( \
3902 funcId * , \
3903 ::RCF::RemoveOut<A1 >::type a1, \
3904 ::RCF::RemoveOut<A2 >::type a2, \
3905 ::RCF::RemoveOut<A3 >::type a3, \
3906 ::RCF::RemoveOut<A4 >::type a4, \
3907 ::RCF::RemoveOut<A5 >::type a5, \
3908 ::RCF::RemoveOut<A6 >::type a6, \
3909 ::RCF::RemoveOut<A7 >::type a7, \
3910 ::RCF::RemoveOut<A8 >::type a8) \
3911 { \
3912 }
3913
3914
3915
3916
3917 //------------------------------------------------------------------------------
3918 // Parameters - R9
3919 //------------------------------------------------------------------------------
3920
3921 // RCF_METHOD_R9
3922 #define RCF_METHOD_R9_INLINE(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9) \
3923 RCF_METHOD_R9_INLINE_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9, RCF_MAKE_UNIQUE_ID(func, R9))
3924
3925 #define RCF_METHOD_R9_INLINE_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9, id) \
3926 public: \
3927 RCF_MAKE_NEXT_DISPATCH_ID(id) \
3928 ::RCF::FutureImpl<R > func( \
3929 ::RCF::RemoveOut<A1 >::type a1, \
3930 ::RCF::RemoveOut<A2 >::type a2, \
3931 ::RCF::RemoveOut<A3 >::type a3, \
3932 ::RCF::RemoveOut<A4 >::type a4, \
3933 ::RCF::RemoveOut<A5 >::type a5, \
3934 ::RCF::RemoveOut<A6 >::type a6, \
3935 ::RCF::RemoveOut<A7 >::type a7, \
3936 ::RCF::RemoveOut<A8 >::type a8, \
3937 ::RCF::RemoveOut<A9 >::type a9) \
3938 { \
3939 return func( \
3940 ::RCF::CallOptions() , \
3941 a1,a2,a3,a4,a5,a6,a7,a8,a9); \
3942 } \
3943 ::RCF::FutureImpl<R > func( \
3944 const ::RCF::CallOptions &callOptions , \
3945 ::RCF::RemoveOut<A1 >::type a1, \
3946 ::RCF::RemoveOut<A2 >::type a2, \
3947 ::RCF::RemoveOut<A3 >::type a3, \
3948 ::RCF::RemoveOut<A4 >::type a4, \
3949 ::RCF::RemoveOut<A5 >::type a5, \
3950 ::RCF::RemoveOut<A6 >::type a6, \
3951 ::RCF::RemoveOut<A7 >::type a7, \
3952 ::RCF::RemoveOut<A8 >::type a8, \
3953 ::RCF::RemoveOut<A9 >::type a9) \
3954 { \
3955 getClientStub().setAsync(false); \
3956 return RCF::FutureImpl<R >( \
3957 ::RCF::AllocateClientParameters< \
3958 R , \
3959 A1,A2,A3,A4,A5,A6,A7,A8,A9 , \
3960 V,V,V,V,V,V >()( \
3961 getClientStub() , \
3962 a1,a2,a3,a4,a5,a6,a7,a8,a9 , \
3963 V(),V(),V(),V(),V(),V()).r.get(), \
3964 getClientStub(), \
3965 mInterfaceName, \
3966 id::value, \
3967 callOptions.apply(getClientStub()), \
3968 #func, \
3969 "R9"); \
3970 } \
3971 const char * getFunctionName(const id &) \
3972 { \
3973 return #func; \
3974 } \
3975 const char * getArity(const id &) \
3976 { \
3977 return "R9"; \
3978 } \
3979 \
3980 private: \
3981 template<typename T> \
3982 void invoke( \
3983 const id &, \
3984 ::RCF::RcfSession &session, \
3985 T &t) \
3986 { \
3987 if (session.isInProcess()) \
3988 { \
3989 ::RCF::ClientParameters< \
3990 R , \
3991 A1,A2,A3,A4,A5,A6,A7,A8,A9 , V,V,V,V,V,V > &p = static_cast<\
3992 ::RCF::ClientParameters< \
3993 R , \
3994 A1,A2,A3,A4,A5,A6,A7,A8,A9 , V,V,V,V,V,V > &>(* session.getInProcessParameters());\
3995 p.r.set( t.func( p.a1.get(), \
3996 p.a2.get(), \
3997 p.a3.get(), \
3998 p.a4.get(), \
3999 p.a5.get(), \
4000 p.a6.get(), \
4001 p.a7.get(), \
4002 p.a8.get(), \
4003 p.a9.get() ) ); \
4004 } \
4005 else \
4006 { \
4007 ::RCF::ServerParameters< \
4008 R , \
4009 A1,A2,A3,A4,A5,A6,A7,A8,A9 > &p = \
4010 ::RCF::AllocateServerParameters< \
4011 R , \
4012 A1,A2,A3,A4,A5,A6,A7,A8,A9 >()(session); \
4013 p.r.set( \
4014 session.getAutoSend(), \
4015 t.func( \
4016 p.a1.get(), \
4017 p.a2.get(), \
4018 p.a3.get(), \
4019 p.a4.get(), \
4020 p.a5.get(), \
4021 p.a6.get(), \
4022 p.a7.get(), \
4023 p.a8.get(), \
4024 p.a9.get())); \
4025 } \
4026 }
4027
4028 // RCF_METHOD_R9_DECL
4029 #define RCF_METHOD_R9_DECL(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9) \
4030 RCF_METHOD_R9_DECL_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9, RCF_MAKE_UNIQUE_ID(func, R9))
4031
4032 #define RCF_METHOD_R9_DECL_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9, id) \
4033 public: \
4034 RCF_MAKE_NEXT_DISPATCH_ID(id) \
4035 ::RCF::FutureImpl<R > func( \
4036 ::RCF::RemoveOut<A1 >::type a1, \
4037 ::RCF::RemoveOut<A2 >::type a2, \
4038 ::RCF::RemoveOut<A3 >::type a3, \
4039 ::RCF::RemoveOut<A4 >::type a4, \
4040 ::RCF::RemoveOut<A5 >::type a5, \
4041 ::RCF::RemoveOut<A6 >::type a6, \
4042 ::RCF::RemoveOut<A7 >::type a7, \
4043 ::RCF::RemoveOut<A8 >::type a8, \
4044 ::RCF::RemoveOut<A9 >::type a9) \
4045 { \
4046 return func( \
4047 ::RCF::CallOptions() , \
4048 a1,a2,a3,a4,a5,a6,a7,a8,a9); \
4049 } \
4050 \
4051 ::RCF::FutureImpl<R > func( \
4052 const ::RCF::CallOptions &callOptions , \
4053 ::RCF::RemoveOut<A1 >::type a1, \
4054 ::RCF::RemoveOut<A2 >::type a2, \
4055 ::RCF::RemoveOut<A3 >::type a3, \
4056 ::RCF::RemoveOut<A4 >::type a4, \
4057 ::RCF::RemoveOut<A5 >::type a5, \
4058 ::RCF::RemoveOut<A6 >::type a6, \
4059 ::RCF::RemoveOut<A7 >::type a7, \
4060 ::RCF::RemoveOut<A8 >::type a8, \
4061 ::RCF::RemoveOut<A9 >::type a9); \
4062 \
4063 void error__method_defined_out_of_order__##func( \
4064 id * , \
4065 ::RCF::RemoveOut<A1 >::type a1, \
4066 ::RCF::RemoveOut<A2 >::type a2, \
4067 ::RCF::RemoveOut<A3 >::type a3, \
4068 ::RCF::RemoveOut<A4 >::type a4, \
4069 ::RCF::RemoveOut<A5 >::type a5, \
4070 ::RCF::RemoveOut<A6 >::type a6, \
4071 ::RCF::RemoveOut<A7 >::type a7, \
4072 ::RCF::RemoveOut<A8 >::type a8, \
4073 ::RCF::RemoveOut<A9 >::type a9); \
4074 \
4075 const char * getFunctionName(const id &) \
4076 { \
4077 return #func; \
4078 } \
4079 const char * getArity(const id &) \
4080 { \
4081 return "R9"; \
4082 } \
4083 \
4084 private: \
4085 template<typename T> \
4086 void invoke( \
4087 const id &, \
4088 ::RCF::RcfSession &session, \
4089 T &t) \
4090 { \
4091 if (session.isInProcess()) \
4092 { \
4093 ::RCF::ClientParameters< \
4094 R , \
4095 A1,A2,A3,A4,A5,A6,A7,A8,A9 , V,V,V,V,V,V > &p = static_cast<\
4096 ::RCF::ClientParameters< \
4097 R , \
4098 A1,A2,A3,A4,A5,A6,A7,A8,A9 , V,V,V,V,V,V > &>(* session.getInProcessParameters());\
4099 p.r.set( t.func( p.a1.get(), \
4100 p.a2.get(), \
4101 p.a3.get(), \
4102 p.a4.get(), \
4103 p.a5.get(), \
4104 p.a6.get(), \
4105 p.a7.get(), \
4106 p.a8.get(), \
4107 p.a9.get() ) ); \
4108 } \
4109 else \
4110 { \
4111 ::RCF::ServerParameters< \
4112 R , \
4113 A1,A2,A3,A4,A5,A6,A7,A8,A9 > &p = \
4114 ::RCF::AllocateServerParameters< \
4115 R , \
4116 A1,A2,A3,A4,A5,A6,A7,A8,A9 >()(session); \
4117 p.r.set( \
4118 session.getAutoSend(), \
4119 t.func( \
4120 p.a1.get(), \
4121 p.a2.get(), \
4122 p.a3.get(), \
4123 p.a4.get(), \
4124 p.a5.get(), \
4125 p.a6.get(), \
4126 p.a7.get(), \
4127 p.a8.get(), \
4128 p.a9.get())); \
4129 } \
4130 }
4131
4132 // RCF_METHOD_R9_DEF
4133 #define RCF_METHOD_R9_DEF(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9) \
4134 RCF_METHOD_R9_DEF_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9, RCF_PP_CAT(rcf_interface_id_1_, func, R9, __LINE__), RCF_MAKE_UNIQUE_ID(func, R9), RCF_PP_CAT(rcf_interface_id_2_, func, R9, __LINE__))
4135
4136 #define RCF_METHOD_R9_DEF_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9, interfaceId, funcId, genParms)\
4137 RCF_CURRENT_STATIC_ID(interfaceId, RCF_interface_id_helper, int, int) \
4138 typedef GeneratorParms<interfaceId> genParms; \
4139 RCF_ADVANCE_STATIC_ID(funcId, RCF_def_dispatch_id_helper, ::RCF::Dummy<genParms::RcfClientT>, genParms::RcfClientT, static)\
4140 RCF_EXPORT_INTERFACE ::RCF::FutureImpl<R > genParms::RcfClientT::func( \
4141 const ::RCF::CallOptions &callOptions , \
4142 ::RCF::RemoveOut<A1 >::type a1, \
4143 ::RCF::RemoveOut<A2 >::type a2, \
4144 ::RCF::RemoveOut<A3 >::type a3, \
4145 ::RCF::RemoveOut<A4 >::type a4, \
4146 ::RCF::RemoveOut<A5 >::type a5, \
4147 ::RCF::RemoveOut<A6 >::type a6, \
4148 ::RCF::RemoveOut<A7 >::type a7, \
4149 ::RCF::RemoveOut<A8 >::type a8, \
4150 ::RCF::RemoveOut<A9 >::type a9) \
4151 { \
4152 getClientStub().setAsync(false); \
4153 return RCF::FutureImpl<R >( \
4154 ::RCF::AllocateClientParameters< \
4155 R , \
4156 A1,A2,A3,A4,A5,A6,A7,A8,A9 , \
4157 V,V,V,V,V,V >()( \
4158 getClientStub() , \
4159 a1,a2,a3,a4,a5,a6,a7,a8,a9 , \
4160 V(),V(),V(),V(),V(),V()).r.get(), \
4161 getClientStub(), \
4162 mInterfaceName, \
4163 funcId::value, \
4164 callOptions.apply(getClientStub()), \
4165 #func, \
4166 "R9"); \
4167 } \
4168 void genParms::RcfClientT::error__method_defined_out_of_order__##func( \
4169 funcId * , \
4170 ::RCF::RemoveOut<A1 >::type a1, \
4171 ::RCF::RemoveOut<A2 >::type a2, \
4172 ::RCF::RemoveOut<A3 >::type a3, \
4173 ::RCF::RemoveOut<A4 >::type a4, \
4174 ::RCF::RemoveOut<A5 >::type a5, \
4175 ::RCF::RemoveOut<A6 >::type a6, \
4176 ::RCF::RemoveOut<A7 >::type a7, \
4177 ::RCF::RemoveOut<A8 >::type a8, \
4178 ::RCF::RemoveOut<A9 >::type a9) \
4179 { \
4180 }
4181
4182
4183
4184 //------------------------------------------------------------------------------
4185 // Parameters - V9
4186 //------------------------------------------------------------------------------
4187
4188 // RCF_METHOD_V9
4189 #define RCF_METHOD_V9_INLINE(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9) \
4190 RCF_METHOD_V9_INLINE_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9, RCF_MAKE_UNIQUE_ID(func, V9))
4191
4192 #define RCF_METHOD_V9_INLINE_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9, id) \
4193 public: \
4194 BOOST_STATIC_ASSERT(( boost::is_same<R, void>::value )); \
4195 RCF_MAKE_NEXT_DISPATCH_ID(id) \
4196 ::RCF::FutureImpl<V> func( \
4197 ::RCF::RemoveOut<A1 >::type a1, \
4198 ::RCF::RemoveOut<A2 >::type a2, \
4199 ::RCF::RemoveOut<A3 >::type a3, \
4200 ::RCF::RemoveOut<A4 >::type a4, \
4201 ::RCF::RemoveOut<A5 >::type a5, \
4202 ::RCF::RemoveOut<A6 >::type a6, \
4203 ::RCF::RemoveOut<A7 >::type a7, \
4204 ::RCF::RemoveOut<A8 >::type a8, \
4205 ::RCF::RemoveOut<A9 >::type a9) \
4206 { \
4207 return func( \
4208 ::RCF::CallOptions() , \
4209 a1,a2,a3,a4,a5,a6,a7,a8,a9); \
4210 } \
4211 ::RCF::FutureImpl<V> func( \
4212 const ::RCF::CallOptions &callOptions , \
4213 ::RCF::RemoveOut<A1 >::type a1, \
4214 ::RCF::RemoveOut<A2 >::type a2, \
4215 ::RCF::RemoveOut<A3 >::type a3, \
4216 ::RCF::RemoveOut<A4 >::type a4, \
4217 ::RCF::RemoveOut<A5 >::type a5, \
4218 ::RCF::RemoveOut<A6 >::type a6, \
4219 ::RCF::RemoveOut<A7 >::type a7, \
4220 ::RCF::RemoveOut<A8 >::type a8, \
4221 ::RCF::RemoveOut<A9 >::type a9) \
4222 { \
4223 getClientStub().setAsync(false); \
4224 return RCF::FutureImpl<V>( \
4225 ::RCF::AllocateClientParameters< \
4226 V , \
4227 A1,A2,A3,A4,A5,A6,A7,A8,A9 , \
4228 V,V,V,V,V,V >()( \
4229 getClientStub() , \
4230 a1,a2,a3,a4,a5,a6,a7,a8,a9 , \
4231 V(),V(),V(),V(),V(),V()).r.get(), \
4232 getClientStub(), \
4233 mInterfaceName, \
4234 id::value, \
4235 callOptions.apply(getClientStub()), \
4236 #func, \
4237 "V9"); \
4238 } \
4239 const char * getFunctionName(const id &) \
4240 { \
4241 return #func; \
4242 } \
4243 const char * getArity(const id &) \
4244 { \
4245 return "V9"; \
4246 } \
4247 \
4248 private: \
4249 template<typename T> \
4250 void invoke( \
4251 const id &, \
4252 ::RCF::RcfSession &session, \
4253 T &t) \
4254 { \
4255 if (session.isInProcess()) \
4256 { \
4257 ::RCF::ClientParameters< \
4258 V , \
4259 A1,A2,A3,A4,A5,A6,A7,A8,A9 , V,V,V,V,V,V > &p = static_cast<\
4260 ::RCF::ClientParameters< \
4261 V , \
4262 A1,A2,A3,A4,A5,A6,A7,A8,A9 , V,V,V,V,V,V > &>(* session.getInProcessParameters());\
4263 RCF_UNUSED_VARIABLE(p); \
4264 t.func( \
4265 p.a1.get(), \
4266 p.a2.get(), \
4267 p.a3.get(), \
4268 p.a4.get(), \
4269 p.a5.get(), \
4270 p.a6.get(), \
4271 p.a7.get(), \
4272 p.a8.get(), \
4273 p.a9.get() ); \
4274 } \
4275 else \
4276 { \
4277 ::RCF::ServerParameters< \
4278 V , \
4279 A1,A2,A3,A4,A5,A6,A7,A8,A9 > &p = \
4280 ::RCF::AllocateServerParameters< \
4281 V , \
4282 A1,A2,A3,A4,A5,A6,A7,A8,A9 >()(session); \
4283 RCF_UNUSED_VARIABLE(p); \
4284 t.func( \
4285 p.a1.get(), \
4286 p.a2.get(), \
4287 p.a3.get(), \
4288 p.a4.get(), \
4289 p.a5.get(), \
4290 p.a6.get(), \
4291 p.a7.get(), \
4292 p.a8.get(), \
4293 p.a9.get()); \
4294 } \
4295 }
4296
4297 // RCF_METHOD_V9_DECL
4298 #define RCF_METHOD_V9_DECL(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9) \
4299 RCF_METHOD_V9_DECL_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9, RCF_MAKE_UNIQUE_ID(func, V9))
4300
4301 #define RCF_METHOD_V9_DECL_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9, id) \
4302 public: \
4303 BOOST_STATIC_ASSERT(( boost::is_same<R, void>::value )); \
4304 RCF_MAKE_NEXT_DISPATCH_ID(id) \
4305 ::RCF::FutureImpl<V> func( \
4306 ::RCF::RemoveOut<A1 >::type a1, \
4307 ::RCF::RemoveOut<A2 >::type a2, \
4308 ::RCF::RemoveOut<A3 >::type a3, \
4309 ::RCF::RemoveOut<A4 >::type a4, \
4310 ::RCF::RemoveOut<A5 >::type a5, \
4311 ::RCF::RemoveOut<A6 >::type a6, \
4312 ::RCF::RemoveOut<A7 >::type a7, \
4313 ::RCF::RemoveOut<A8 >::type a8, \
4314 ::RCF::RemoveOut<A9 >::type a9) \
4315 { \
4316 return func( \
4317 ::RCF::CallOptions() , \
4318 a1,a2,a3,a4,a5,a6,a7,a8,a9); \
4319 } \
4320 \
4321 ::RCF::FutureImpl<V> func( \
4322 const ::RCF::CallOptions &callOptions , \
4323 ::RCF::RemoveOut<A1 >::type a1, \
4324 ::RCF::RemoveOut<A2 >::type a2, \
4325 ::RCF::RemoveOut<A3 >::type a3, \
4326 ::RCF::RemoveOut<A4 >::type a4, \
4327 ::RCF::RemoveOut<A5 >::type a5, \
4328 ::RCF::RemoveOut<A6 >::type a6, \
4329 ::RCF::RemoveOut<A7 >::type a7, \
4330 ::RCF::RemoveOut<A8 >::type a8, \
4331 ::RCF::RemoveOut<A9 >::type a9); \
4332 \
4333 void error__method_defined_out_of_order__##func( \
4334 id * , \
4335 ::RCF::RemoveOut<A1 >::type a1, \
4336 ::RCF::RemoveOut<A2 >::type a2, \
4337 ::RCF::RemoveOut<A3 >::type a3, \
4338 ::RCF::RemoveOut<A4 >::type a4, \
4339 ::RCF::RemoveOut<A5 >::type a5, \
4340 ::RCF::RemoveOut<A6 >::type a6, \
4341 ::RCF::RemoveOut<A7 >::type a7, \
4342 ::RCF::RemoveOut<A8 >::type a8, \
4343 ::RCF::RemoveOut<A9 >::type a9); \
4344 \
4345 const char * getFunctionName(const id &) \
4346 { \
4347 return #func; \
4348 } \
4349 const char * getArity(const id &) \
4350 { \
4351 return "V9"; \
4352 } \
4353 \
4354 private: \
4355 template<typename T> \
4356 void invoke( \
4357 const id &, \
4358 ::RCF::RcfSession &session, \
4359 T &t) \
4360 { \
4361 if (session.isInProcess()) \
4362 { \
4363 ::RCF::ClientParameters< \
4364 V , \
4365 A1,A2,A3,A4,A5,A6,A7,A8,A9 , V,V,V,V,V,V > &p = static_cast<\
4366 ::RCF::ClientParameters< \
4367 V , \
4368 A1,A2,A3,A4,A5,A6,A7,A8,A9 , V,V,V,V,V,V > &>(* session.getInProcessParameters());\
4369 RCF_UNUSED_VARIABLE(p); \
4370 t.func( \
4371 p.a1.get(), \
4372 p.a2.get(), \
4373 p.a3.get(), \
4374 p.a4.get(), \
4375 p.a5.get(), \
4376 p.a6.get(), \
4377 p.a7.get(), \
4378 p.a8.get(), \
4379 p.a9.get() ); \
4380 } \
4381 else \
4382 { \
4383 ::RCF::ServerParameters< \
4384 V , \
4385 A1,A2,A3,A4,A5,A6,A7,A8,A9 > &p = \
4386 ::RCF::AllocateServerParameters< \
4387 V , \
4388 A1,A2,A3,A4,A5,A6,A7,A8,A9 >()(session); \
4389 RCF_UNUSED_VARIABLE(p); \
4390 t.func( \
4391 p.a1.get(), \
4392 p.a2.get(), \
4393 p.a3.get(), \
4394 p.a4.get(), \
4395 p.a5.get(), \
4396 p.a6.get(), \
4397 p.a7.get(), \
4398 p.a8.get(), \
4399 p.a9.get()); \
4400 } \
4401 }
4402
4403 // RCF_METHOD_V9_DEF
4404 #define RCF_METHOD_V9_DEF(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9) \
4405 RCF_METHOD_V9_DEF_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9, RCF_PP_CAT(rcf_interface_id_1_, func, R9, __LINE__), RCF_MAKE_UNIQUE_ID(func, R9), RCF_PP_CAT(rcf_interface_id_2_, func, R9, __LINE__))
4406
4407 #define RCF_METHOD_V9_DEF_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9, interfaceId, funcId, genParms)\
4408 RCF_CURRENT_STATIC_ID(interfaceId, RCF_interface_id_helper, int, int) \
4409 typedef GeneratorParms<interfaceId> genParms; \
4410 RCF_ADVANCE_STATIC_ID(funcId, RCF_def_dispatch_id_helper, ::RCF::Dummy<genParms::RcfClientT>, genParms::RcfClientT, static)\
4411 RCF_EXPORT_INTERFACE ::RCF::FutureImpl<::RCF::Void> genParms::RcfClientT::func(\
4412 const ::RCF::CallOptions &callOptions , \
4413 ::RCF::RemoveOut<A1 >::type a1, \
4414 ::RCF::RemoveOut<A2 >::type a2, \
4415 ::RCF::RemoveOut<A3 >::type a3, \
4416 ::RCF::RemoveOut<A4 >::type a4, \
4417 ::RCF::RemoveOut<A5 >::type a5, \
4418 ::RCF::RemoveOut<A6 >::type a6, \
4419 ::RCF::RemoveOut<A7 >::type a7, \
4420 ::RCF::RemoveOut<A8 >::type a8, \
4421 ::RCF::RemoveOut<A9 >::type a9) \
4422 { \
4423 typedef ::RCF::Void V; \
4424 getClientStub().setAsync(false); \
4425 return RCF::FutureImpl<V >( \
4426 ::RCF::AllocateClientParameters< \
4427 V , \
4428 A1,A2,A3,A4,A5,A6,A7,A8,A9 , \
4429 V,V,V,V,V,V >()( \
4430 getClientStub() , \
4431 a1,a2,a3,a4,a5,a6,a7,a8,a9 , \
4432 V(),V(),V(),V(),V(),V()).r.get(), \
4433 getClientStub(), \
4434 mInterfaceName, \
4435 funcId::value, \
4436 callOptions.apply(getClientStub()), \
4437 #func, \
4438 "V9"); \
4439 } \
4440 void genParms::RcfClientT::error__method_defined_out_of_order__##func( \
4441 funcId * , \
4442 ::RCF::RemoveOut<A1 >::type a1, \
4443 ::RCF::RemoveOut<A2 >::type a2, \
4444 ::RCF::RemoveOut<A3 >::type a3, \
4445 ::RCF::RemoveOut<A4 >::type a4, \
4446 ::RCF::RemoveOut<A5 >::type a5, \
4447 ::RCF::RemoveOut<A6 >::type a6, \
4448 ::RCF::RemoveOut<A7 >::type a7, \
4449 ::RCF::RemoveOut<A8 >::type a8, \
4450 ::RCF::RemoveOut<A9 >::type a9) \
4451 { \
4452 }
4453
4454
4455
4456
4457 //------------------------------------------------------------------------------
4458 // Parameters - R10
4459 //------------------------------------------------------------------------------
4460
4461 // RCF_METHOD_R10
4462 #define RCF_METHOD_R10_INLINE(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10) \
4463 RCF_METHOD_R10_INLINE_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10, RCF_MAKE_UNIQUE_ID(func, R10))
4464
4465 #define RCF_METHOD_R10_INLINE_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10, id) \
4466 public: \
4467 RCF_MAKE_NEXT_DISPATCH_ID(id) \
4468 ::RCF::FutureImpl<R > func( \
4469 ::RCF::RemoveOut<A1 >::type a1, \
4470 ::RCF::RemoveOut<A2 >::type a2, \
4471 ::RCF::RemoveOut<A3 >::type a3, \
4472 ::RCF::RemoveOut<A4 >::type a4, \
4473 ::RCF::RemoveOut<A5 >::type a5, \
4474 ::RCF::RemoveOut<A6 >::type a6, \
4475 ::RCF::RemoveOut<A7 >::type a7, \
4476 ::RCF::RemoveOut<A8 >::type a8, \
4477 ::RCF::RemoveOut<A9 >::type a9, \
4478 ::RCF::RemoveOut<A10 >::type a10) \
4479 { \
4480 return func( \
4481 ::RCF::CallOptions() , \
4482 a1,a2,a3,a4,a5,a6,a7,a8,a9,a10); \
4483 } \
4484 ::RCF::FutureImpl<R > func( \
4485 const ::RCF::CallOptions &callOptions , \
4486 ::RCF::RemoveOut<A1 >::type a1, \
4487 ::RCF::RemoveOut<A2 >::type a2, \
4488 ::RCF::RemoveOut<A3 >::type a3, \
4489 ::RCF::RemoveOut<A4 >::type a4, \
4490 ::RCF::RemoveOut<A5 >::type a5, \
4491 ::RCF::RemoveOut<A6 >::type a6, \
4492 ::RCF::RemoveOut<A7 >::type a7, \
4493 ::RCF::RemoveOut<A8 >::type a8, \
4494 ::RCF::RemoveOut<A9 >::type a9, \
4495 ::RCF::RemoveOut<A10 >::type a10) \
4496 { \
4497 getClientStub().setAsync(false); \
4498 return RCF::FutureImpl<R >( \
4499 ::RCF::AllocateClientParameters< \
4500 R , \
4501 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10 , \
4502 V,V,V,V,V >()( \
4503 getClientStub() , \
4504 a1,a2,a3,a4,a5,a6,a7,a8,a9,a10 , \
4505 V(),V(),V(),V(),V()).r.get(), \
4506 getClientStub(), \
4507 mInterfaceName, \
4508 id::value, \
4509 callOptions.apply(getClientStub()), \
4510 #func, \
4511 "R10"); \
4512 } \
4513 const char * getFunctionName(const id &) \
4514 { \
4515 return #func; \
4516 } \
4517 const char * getArity(const id &) \
4518 { \
4519 return "R10"; \
4520 } \
4521 \
4522 private: \
4523 template<typename T> \
4524 void invoke( \
4525 const id &, \
4526 ::RCF::RcfSession &session, \
4527 T &t) \
4528 { \
4529 if (session.isInProcess()) \
4530 { \
4531 ::RCF::ClientParameters< \
4532 R , \
4533 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10 , V,V,V,V,V > &p = static_cast<\
4534 ::RCF::ClientParameters< \
4535 R , \
4536 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10 , V,V,V,V,V > &>(* session.getInProcessParameters());\
4537 p.r.set( t.func( p.a1.get(), \
4538 p.a2.get(), \
4539 p.a3.get(), \
4540 p.a4.get(), \
4541 p.a5.get(), \
4542 p.a6.get(), \
4543 p.a7.get(), \
4544 p.a8.get(), \
4545 p.a9.get(), \
4546 p.a10.get() ) ); \
4547 } \
4548 else \
4549 { \
4550 ::RCF::ServerParameters< \
4551 R , \
4552 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10 > &p = \
4553 ::RCF::AllocateServerParameters< \
4554 R , \
4555 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10 >()(session); \
4556 p.r.set( \
4557 session.getAutoSend(), \
4558 t.func( \
4559 p.a1.get(), \
4560 p.a2.get(), \
4561 p.a3.get(), \
4562 p.a4.get(), \
4563 p.a5.get(), \
4564 p.a6.get(), \
4565 p.a7.get(), \
4566 p.a8.get(), \
4567 p.a9.get(), \
4568 p.a10.get())); \
4569 } \
4570 }
4571
4572 // RCF_METHOD_R10_DECL
4573 #define RCF_METHOD_R10_DECL(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10) \
4574 RCF_METHOD_R10_DECL_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10, RCF_MAKE_UNIQUE_ID(func, R10))
4575
4576 #define RCF_METHOD_R10_DECL_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10, id) \
4577 public: \
4578 RCF_MAKE_NEXT_DISPATCH_ID(id) \
4579 ::RCF::FutureImpl<R > func( \
4580 ::RCF::RemoveOut<A1 >::type a1, \
4581 ::RCF::RemoveOut<A2 >::type a2, \
4582 ::RCF::RemoveOut<A3 >::type a3, \
4583 ::RCF::RemoveOut<A4 >::type a4, \
4584 ::RCF::RemoveOut<A5 >::type a5, \
4585 ::RCF::RemoveOut<A6 >::type a6, \
4586 ::RCF::RemoveOut<A7 >::type a7, \
4587 ::RCF::RemoveOut<A8 >::type a8, \
4588 ::RCF::RemoveOut<A9 >::type a9, \
4589 ::RCF::RemoveOut<A10 >::type a10) \
4590 { \
4591 return func( \
4592 ::RCF::CallOptions() , \
4593 a1,a2,a3,a4,a5,a6,a7,a8,a9,a10); \
4594 } \
4595 \
4596 ::RCF::FutureImpl<R > func( \
4597 const ::RCF::CallOptions &callOptions , \
4598 ::RCF::RemoveOut<A1 >::type a1, \
4599 ::RCF::RemoveOut<A2 >::type a2, \
4600 ::RCF::RemoveOut<A3 >::type a3, \
4601 ::RCF::RemoveOut<A4 >::type a4, \
4602 ::RCF::RemoveOut<A5 >::type a5, \
4603 ::RCF::RemoveOut<A6 >::type a6, \
4604 ::RCF::RemoveOut<A7 >::type a7, \
4605 ::RCF::RemoveOut<A8 >::type a8, \
4606 ::RCF::RemoveOut<A9 >::type a9, \
4607 ::RCF::RemoveOut<A10 >::type a10); \
4608 \
4609 void error__method_defined_out_of_order__##func( \
4610 id * , \
4611 ::RCF::RemoveOut<A1 >::type a1, \
4612 ::RCF::RemoveOut<A2 >::type a2, \
4613 ::RCF::RemoveOut<A3 >::type a3, \
4614 ::RCF::RemoveOut<A4 >::type a4, \
4615 ::RCF::RemoveOut<A5 >::type a5, \
4616 ::RCF::RemoveOut<A6 >::type a6, \
4617 ::RCF::RemoveOut<A7 >::type a7, \
4618 ::RCF::RemoveOut<A8 >::type a8, \
4619 ::RCF::RemoveOut<A9 >::type a9, \
4620 ::RCF::RemoveOut<A10 >::type a10); \
4621 \
4622 const char * getFunctionName(const id &) \
4623 { \
4624 return #func; \
4625 } \
4626 const char * getArity(const id &) \
4627 { \
4628 return "R10"; \
4629 } \
4630 \
4631 private: \
4632 template<typename T> \
4633 void invoke( \
4634 const id &, \
4635 ::RCF::RcfSession &session, \
4636 T &t) \
4637 { \
4638 if (session.isInProcess()) \
4639 { \
4640 ::RCF::ClientParameters< \
4641 R , \
4642 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10 , V,V,V,V,V > &p = static_cast<\
4643 ::RCF::ClientParameters< \
4644 R , \
4645 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10 , V,V,V,V,V > &>(* session.getInProcessParameters());\
4646 p.r.set( t.func( p.a1.get(), \
4647 p.a2.get(), \
4648 p.a3.get(), \
4649 p.a4.get(), \
4650 p.a5.get(), \
4651 p.a6.get(), \
4652 p.a7.get(), \
4653 p.a8.get(), \
4654 p.a9.get(), \
4655 p.a10.get() ) ); \
4656 } \
4657 else \
4658 { \
4659 ::RCF::ServerParameters< \
4660 R , \
4661 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10 > &p = \
4662 ::RCF::AllocateServerParameters< \
4663 R , \
4664 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10 >()(session); \
4665 p.r.set( \
4666 session.getAutoSend(), \
4667 t.func( \
4668 p.a1.get(), \
4669 p.a2.get(), \
4670 p.a3.get(), \
4671 p.a4.get(), \
4672 p.a5.get(), \
4673 p.a6.get(), \
4674 p.a7.get(), \
4675 p.a8.get(), \
4676 p.a9.get(), \
4677 p.a10.get())); \
4678 } \
4679 }
4680
4681 // RCF_METHOD_R10_DEF
4682 #define RCF_METHOD_R10_DEF(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10) \
4683 RCF_METHOD_R10_DEF_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10, RCF_PP_CAT(rcf_interface_id_1_, func, R10, __LINE__), RCF_MAKE_UNIQUE_ID(func, R10), RCF_PP_CAT(rcf_interface_id_2_, func, R10, __LINE__))
4684
4685 #define RCF_METHOD_R10_DEF_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10, interfaceId, funcId, genParms)\
4686 RCF_CURRENT_STATIC_ID(interfaceId, RCF_interface_id_helper, int, int) \
4687 typedef GeneratorParms<interfaceId> genParms; \
4688 RCF_ADVANCE_STATIC_ID(funcId, RCF_def_dispatch_id_helper, ::RCF::Dummy<genParms::RcfClientT>, genParms::RcfClientT, static)\
4689 RCF_EXPORT_INTERFACE ::RCF::FutureImpl<R > genParms::RcfClientT::func( \
4690 const ::RCF::CallOptions &callOptions , \
4691 ::RCF::RemoveOut<A1 >::type a1, \
4692 ::RCF::RemoveOut<A2 >::type a2, \
4693 ::RCF::RemoveOut<A3 >::type a3, \
4694 ::RCF::RemoveOut<A4 >::type a4, \
4695 ::RCF::RemoveOut<A5 >::type a5, \
4696 ::RCF::RemoveOut<A6 >::type a6, \
4697 ::RCF::RemoveOut<A7 >::type a7, \
4698 ::RCF::RemoveOut<A8 >::type a8, \
4699 ::RCF::RemoveOut<A9 >::type a9, \
4700 ::RCF::RemoveOut<A10 >::type a10) \
4701 { \
4702 getClientStub().setAsync(false); \
4703 return RCF::FutureImpl<R >( \
4704 ::RCF::AllocateClientParameters< \
4705 R , \
4706 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10 , \
4707 V,V,V,V,V >()( \
4708 getClientStub() , \
4709 a1,a2,a3,a4,a5,a6,a7,a8,a9,a10 , \
4710 V(),V(),V(),V(),V()).r.get(), \
4711 getClientStub(), \
4712 mInterfaceName, \
4713 funcId::value, \
4714 callOptions.apply(getClientStub()), \
4715 #func, \
4716 "R10"); \
4717 } \
4718 void genParms::RcfClientT::error__method_defined_out_of_order__##func( \
4719 funcId * , \
4720 ::RCF::RemoveOut<A1 >::type a1, \
4721 ::RCF::RemoveOut<A2 >::type a2, \
4722 ::RCF::RemoveOut<A3 >::type a3, \
4723 ::RCF::RemoveOut<A4 >::type a4, \
4724 ::RCF::RemoveOut<A5 >::type a5, \
4725 ::RCF::RemoveOut<A6 >::type a6, \
4726 ::RCF::RemoveOut<A7 >::type a7, \
4727 ::RCF::RemoveOut<A8 >::type a8, \
4728 ::RCF::RemoveOut<A9 >::type a9, \
4729 ::RCF::RemoveOut<A10 >::type a10) \
4730 { \
4731 }
4732
4733
4734
4735 //------------------------------------------------------------------------------
4736 // Parameters - V10
4737 //------------------------------------------------------------------------------
4738
4739 // RCF_METHOD_V10
4740 #define RCF_METHOD_V10_INLINE(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10) \
4741 RCF_METHOD_V10_INLINE_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10, RCF_MAKE_UNIQUE_ID(func, V10))
4742
4743 #define RCF_METHOD_V10_INLINE_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10, id) \
4744 public: \
4745 BOOST_STATIC_ASSERT(( boost::is_same<R, void>::value )); \
4746 RCF_MAKE_NEXT_DISPATCH_ID(id) \
4747 ::RCF::FutureImpl<V> func( \
4748 ::RCF::RemoveOut<A1 >::type a1, \
4749 ::RCF::RemoveOut<A2 >::type a2, \
4750 ::RCF::RemoveOut<A3 >::type a3, \
4751 ::RCF::RemoveOut<A4 >::type a4, \
4752 ::RCF::RemoveOut<A5 >::type a5, \
4753 ::RCF::RemoveOut<A6 >::type a6, \
4754 ::RCF::RemoveOut<A7 >::type a7, \
4755 ::RCF::RemoveOut<A8 >::type a8, \
4756 ::RCF::RemoveOut<A9 >::type a9, \
4757 ::RCF::RemoveOut<A10 >::type a10) \
4758 { \
4759 return func( \
4760 ::RCF::CallOptions() , \
4761 a1,a2,a3,a4,a5,a6,a7,a8,a9,a10); \
4762 } \
4763 ::RCF::FutureImpl<V> func( \
4764 const ::RCF::CallOptions &callOptions , \
4765 ::RCF::RemoveOut<A1 >::type a1, \
4766 ::RCF::RemoveOut<A2 >::type a2, \
4767 ::RCF::RemoveOut<A3 >::type a3, \
4768 ::RCF::RemoveOut<A4 >::type a4, \
4769 ::RCF::RemoveOut<A5 >::type a5, \
4770 ::RCF::RemoveOut<A6 >::type a6, \
4771 ::RCF::RemoveOut<A7 >::type a7, \
4772 ::RCF::RemoveOut<A8 >::type a8, \
4773 ::RCF::RemoveOut<A9 >::type a9, \
4774 ::RCF::RemoveOut<A10 >::type a10) \
4775 { \
4776 getClientStub().setAsync(false); \
4777 return RCF::FutureImpl<V>( \
4778 ::RCF::AllocateClientParameters< \
4779 V , \
4780 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10 , \
4781 V,V,V,V,V >()( \
4782 getClientStub() , \
4783 a1,a2,a3,a4,a5,a6,a7,a8,a9,a10 , \
4784 V(),V(),V(),V(),V()).r.get(), \
4785 getClientStub(), \
4786 mInterfaceName, \
4787 id::value, \
4788 callOptions.apply(getClientStub()), \
4789 #func, \
4790 "V10"); \
4791 } \
4792 const char * getFunctionName(const id &) \
4793 { \
4794 return #func; \
4795 } \
4796 const char * getArity(const id &) \
4797 { \
4798 return "V10"; \
4799 } \
4800 \
4801 private: \
4802 template<typename T> \
4803 void invoke( \
4804 const id &, \
4805 ::RCF::RcfSession &session, \
4806 T &t) \
4807 { \
4808 if (session.isInProcess()) \
4809 { \
4810 ::RCF::ClientParameters< \
4811 V , \
4812 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10 , V,V,V,V,V > &p = static_cast<\
4813 ::RCF::ClientParameters< \
4814 V , \
4815 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10 , V,V,V,V,V > &>(* session.getInProcessParameters());\
4816 RCF_UNUSED_VARIABLE(p); \
4817 t.func( \
4818 p.a1.get(), \
4819 p.a2.get(), \
4820 p.a3.get(), \
4821 p.a4.get(), \
4822 p.a5.get(), \
4823 p.a6.get(), \
4824 p.a7.get(), \
4825 p.a8.get(), \
4826 p.a9.get(), \
4827 p.a10.get() ); \
4828 } \
4829 else \
4830 { \
4831 ::RCF::ServerParameters< \
4832 V , \
4833 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10 > &p = \
4834 ::RCF::AllocateServerParameters< \
4835 V , \
4836 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10 >()(session); \
4837 RCF_UNUSED_VARIABLE(p); \
4838 t.func( \
4839 p.a1.get(), \
4840 p.a2.get(), \
4841 p.a3.get(), \
4842 p.a4.get(), \
4843 p.a5.get(), \
4844 p.a6.get(), \
4845 p.a7.get(), \
4846 p.a8.get(), \
4847 p.a9.get(), \
4848 p.a10.get()); \
4849 } \
4850 }
4851
4852 // RCF_METHOD_V10_DECL
4853 #define RCF_METHOD_V10_DECL(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10) \
4854 RCF_METHOD_V10_DECL_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10, RCF_MAKE_UNIQUE_ID(func, V10))
4855
4856 #define RCF_METHOD_V10_DECL_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10, id) \
4857 public: \
4858 BOOST_STATIC_ASSERT(( boost::is_same<R, void>::value )); \
4859 RCF_MAKE_NEXT_DISPATCH_ID(id) \
4860 ::RCF::FutureImpl<V> func( \
4861 ::RCF::RemoveOut<A1 >::type a1, \
4862 ::RCF::RemoveOut<A2 >::type a2, \
4863 ::RCF::RemoveOut<A3 >::type a3, \
4864 ::RCF::RemoveOut<A4 >::type a4, \
4865 ::RCF::RemoveOut<A5 >::type a5, \
4866 ::RCF::RemoveOut<A6 >::type a6, \
4867 ::RCF::RemoveOut<A7 >::type a7, \
4868 ::RCF::RemoveOut<A8 >::type a8, \
4869 ::RCF::RemoveOut<A9 >::type a9, \
4870 ::RCF::RemoveOut<A10 >::type a10) \
4871 { \
4872 return func( \
4873 ::RCF::CallOptions() , \
4874 a1,a2,a3,a4,a5,a6,a7,a8,a9,a10); \
4875 } \
4876 \
4877 ::RCF::FutureImpl<V> func( \
4878 const ::RCF::CallOptions &callOptions , \
4879 ::RCF::RemoveOut<A1 >::type a1, \
4880 ::RCF::RemoveOut<A2 >::type a2, \
4881 ::RCF::RemoveOut<A3 >::type a3, \
4882 ::RCF::RemoveOut<A4 >::type a4, \
4883 ::RCF::RemoveOut<A5 >::type a5, \
4884 ::RCF::RemoveOut<A6 >::type a6, \
4885 ::RCF::RemoveOut<A7 >::type a7, \
4886 ::RCF::RemoveOut<A8 >::type a8, \
4887 ::RCF::RemoveOut<A9 >::type a9, \
4888 ::RCF::RemoveOut<A10 >::type a10); \
4889 \
4890 void error__method_defined_out_of_order__##func( \
4891 id * , \
4892 ::RCF::RemoveOut<A1 >::type a1, \
4893 ::RCF::RemoveOut<A2 >::type a2, \
4894 ::RCF::RemoveOut<A3 >::type a3, \
4895 ::RCF::RemoveOut<A4 >::type a4, \
4896 ::RCF::RemoveOut<A5 >::type a5, \
4897 ::RCF::RemoveOut<A6 >::type a6, \
4898 ::RCF::RemoveOut<A7 >::type a7, \
4899 ::RCF::RemoveOut<A8 >::type a8, \
4900 ::RCF::RemoveOut<A9 >::type a9, \
4901 ::RCF::RemoveOut<A10 >::type a10); \
4902 \
4903 const char * getFunctionName(const id &) \
4904 { \
4905 return #func; \
4906 } \
4907 const char * getArity(const id &) \
4908 { \
4909 return "V10"; \
4910 } \
4911 \
4912 private: \
4913 template<typename T> \
4914 void invoke( \
4915 const id &, \
4916 ::RCF::RcfSession &session, \
4917 T &t) \
4918 { \
4919 if (session.isInProcess()) \
4920 { \
4921 ::RCF::ClientParameters< \
4922 V , \
4923 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10 , V,V,V,V,V > &p = static_cast<\
4924 ::RCF::ClientParameters< \
4925 V , \
4926 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10 , V,V,V,V,V > &>(* session.getInProcessParameters());\
4927 RCF_UNUSED_VARIABLE(p); \
4928 t.func( \
4929 p.a1.get(), \
4930 p.a2.get(), \
4931 p.a3.get(), \
4932 p.a4.get(), \
4933 p.a5.get(), \
4934 p.a6.get(), \
4935 p.a7.get(), \
4936 p.a8.get(), \
4937 p.a9.get(), \
4938 p.a10.get() ); \
4939 } \
4940 else \
4941 { \
4942 ::RCF::ServerParameters< \
4943 V , \
4944 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10 > &p = \
4945 ::RCF::AllocateServerParameters< \
4946 V , \
4947 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10 >()(session); \
4948 RCF_UNUSED_VARIABLE(p); \
4949 t.func( \
4950 p.a1.get(), \
4951 p.a2.get(), \
4952 p.a3.get(), \
4953 p.a4.get(), \
4954 p.a5.get(), \
4955 p.a6.get(), \
4956 p.a7.get(), \
4957 p.a8.get(), \
4958 p.a9.get(), \
4959 p.a10.get()); \
4960 } \
4961 }
4962
4963 // RCF_METHOD_V10_DEF
4964 #define RCF_METHOD_V10_DEF(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10) \
4965 RCF_METHOD_V10_DEF_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10, RCF_PP_CAT(rcf_interface_id_1_, func, R10, __LINE__), RCF_MAKE_UNIQUE_ID(func, R10), RCF_PP_CAT(rcf_interface_id_2_, func, R10, __LINE__))
4966
4967 #define RCF_METHOD_V10_DEF_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10, interfaceId, funcId, genParms)\
4968 RCF_CURRENT_STATIC_ID(interfaceId, RCF_interface_id_helper, int, int) \
4969 typedef GeneratorParms<interfaceId> genParms; \
4970 RCF_ADVANCE_STATIC_ID(funcId, RCF_def_dispatch_id_helper, ::RCF::Dummy<genParms::RcfClientT>, genParms::RcfClientT, static)\
4971 RCF_EXPORT_INTERFACE ::RCF::FutureImpl<::RCF::Void> genParms::RcfClientT::func(\
4972 const ::RCF::CallOptions &callOptions , \
4973 ::RCF::RemoveOut<A1 >::type a1, \
4974 ::RCF::RemoveOut<A2 >::type a2, \
4975 ::RCF::RemoveOut<A3 >::type a3, \
4976 ::RCF::RemoveOut<A4 >::type a4, \
4977 ::RCF::RemoveOut<A5 >::type a5, \
4978 ::RCF::RemoveOut<A6 >::type a6, \
4979 ::RCF::RemoveOut<A7 >::type a7, \
4980 ::RCF::RemoveOut<A8 >::type a8, \
4981 ::RCF::RemoveOut<A9 >::type a9, \
4982 ::RCF::RemoveOut<A10 >::type a10) \
4983 { \
4984 typedef ::RCF::Void V; \
4985 getClientStub().setAsync(false); \
4986 return RCF::FutureImpl<V >( \
4987 ::RCF::AllocateClientParameters< \
4988 V , \
4989 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10 , \
4990 V,V,V,V,V >()( \
4991 getClientStub() , \
4992 a1,a2,a3,a4,a5,a6,a7,a8,a9,a10 , \
4993 V(),V(),V(),V(),V()).r.get(), \
4994 getClientStub(), \
4995 mInterfaceName, \
4996 funcId::value, \
4997 callOptions.apply(getClientStub()), \
4998 #func, \
4999 "V10"); \
5000 } \
5001 void genParms::RcfClientT::error__method_defined_out_of_order__##func( \
5002 funcId * , \
5003 ::RCF::RemoveOut<A1 >::type a1, \
5004 ::RCF::RemoveOut<A2 >::type a2, \
5005 ::RCF::RemoveOut<A3 >::type a3, \
5006 ::RCF::RemoveOut<A4 >::type a4, \
5007 ::RCF::RemoveOut<A5 >::type a5, \
5008 ::RCF::RemoveOut<A6 >::type a6, \
5009 ::RCF::RemoveOut<A7 >::type a7, \
5010 ::RCF::RemoveOut<A8 >::type a8, \
5011 ::RCF::RemoveOut<A9 >::type a9, \
5012 ::RCF::RemoveOut<A10 >::type a10) \
5013 { \
5014 }
5015
5016
5017
5018
5019 //------------------------------------------------------------------------------
5020 // Parameters - R11
5021 //------------------------------------------------------------------------------
5022
5023 // RCF_METHOD_R11
5024 #define RCF_METHOD_R11_INLINE(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11) \
5025 RCF_METHOD_R11_INLINE_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11, RCF_MAKE_UNIQUE_ID(func, R11))
5026
5027 #define RCF_METHOD_R11_INLINE_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11, id)\
5028 public: \
5029 RCF_MAKE_NEXT_DISPATCH_ID(id) \
5030 ::RCF::FutureImpl<R > func( \
5031 ::RCF::RemoveOut<A1 >::type a1, \
5032 ::RCF::RemoveOut<A2 >::type a2, \
5033 ::RCF::RemoveOut<A3 >::type a3, \
5034 ::RCF::RemoveOut<A4 >::type a4, \
5035 ::RCF::RemoveOut<A5 >::type a5, \
5036 ::RCF::RemoveOut<A6 >::type a6, \
5037 ::RCF::RemoveOut<A7 >::type a7, \
5038 ::RCF::RemoveOut<A8 >::type a8, \
5039 ::RCF::RemoveOut<A9 >::type a9, \
5040 ::RCF::RemoveOut<A10 >::type a10, \
5041 ::RCF::RemoveOut<A11 >::type a11) \
5042 { \
5043 return func( \
5044 ::RCF::CallOptions() , \
5045 a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11); \
5046 } \
5047 ::RCF::FutureImpl<R > func( \
5048 const ::RCF::CallOptions &callOptions , \
5049 ::RCF::RemoveOut<A1 >::type a1, \
5050 ::RCF::RemoveOut<A2 >::type a2, \
5051 ::RCF::RemoveOut<A3 >::type a3, \
5052 ::RCF::RemoveOut<A4 >::type a4, \
5053 ::RCF::RemoveOut<A5 >::type a5, \
5054 ::RCF::RemoveOut<A6 >::type a6, \
5055 ::RCF::RemoveOut<A7 >::type a7, \
5056 ::RCF::RemoveOut<A8 >::type a8, \
5057 ::RCF::RemoveOut<A9 >::type a9, \
5058 ::RCF::RemoveOut<A10 >::type a10, \
5059 ::RCF::RemoveOut<A11 >::type a11) \
5060 { \
5061 getClientStub().setAsync(false); \
5062 return RCF::FutureImpl<R >( \
5063 ::RCF::AllocateClientParameters< \
5064 R , \
5065 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11 , \
5066 V,V,V,V >()( \
5067 getClientStub() , \
5068 a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11 , \
5069 V(),V(),V(),V()).r.get(), \
5070 getClientStub(), \
5071 mInterfaceName, \
5072 id::value, \
5073 callOptions.apply(getClientStub()), \
5074 #func, \
5075 "R11"); \
5076 } \
5077 const char * getFunctionName(const id &) \
5078 { \
5079 return #func; \
5080 } \
5081 const char * getArity(const id &) \
5082 { \
5083 return "R11"; \
5084 } \
5085 \
5086 private: \
5087 template<typename T> \
5088 void invoke( \
5089 const id &, \
5090 ::RCF::RcfSession &session, \
5091 T &t) \
5092 { \
5093 if (session.isInProcess()) \
5094 { \
5095 ::RCF::ClientParameters< \
5096 R , \
5097 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11 , V,V,V,V > &p = static_cast<\
5098 ::RCF::ClientParameters< \
5099 R , \
5100 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11 , V,V,V,V > &>(* session.getInProcessParameters());\
5101 p.r.set( t.func( p.a1.get(), \
5102 p.a2.get(), \
5103 p.a3.get(), \
5104 p.a4.get(), \
5105 p.a5.get(), \
5106 p.a6.get(), \
5107 p.a7.get(), \
5108 p.a8.get(), \
5109 p.a9.get(), \
5110 p.a10.get(), \
5111 p.a11.get() ) ); \
5112 } \
5113 else \
5114 { \
5115 ::RCF::ServerParameters< \
5116 R , \
5117 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11 > &p = \
5118 ::RCF::AllocateServerParameters< \
5119 R , \
5120 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11 >()(session); \
5121 p.r.set( \
5122 session.getAutoSend(), \
5123 t.func( \
5124 p.a1.get(), \
5125 p.a2.get(), \
5126 p.a3.get(), \
5127 p.a4.get(), \
5128 p.a5.get(), \
5129 p.a6.get(), \
5130 p.a7.get(), \
5131 p.a8.get(), \
5132 p.a9.get(), \
5133 p.a10.get(), \
5134 p.a11.get())); \
5135 } \
5136 }
5137
5138 // RCF_METHOD_R11_DECL
5139 #define RCF_METHOD_R11_DECL(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11) \
5140 RCF_METHOD_R11_DECL_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11, RCF_MAKE_UNIQUE_ID(func, R11))
5141
5142 #define RCF_METHOD_R11_DECL_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11, id) \
5143 public: \
5144 RCF_MAKE_NEXT_DISPATCH_ID(id) \
5145 ::RCF::FutureImpl<R > func( \
5146 ::RCF::RemoveOut<A1 >::type a1, \
5147 ::RCF::RemoveOut<A2 >::type a2, \
5148 ::RCF::RemoveOut<A3 >::type a3, \
5149 ::RCF::RemoveOut<A4 >::type a4, \
5150 ::RCF::RemoveOut<A5 >::type a5, \
5151 ::RCF::RemoveOut<A6 >::type a6, \
5152 ::RCF::RemoveOut<A7 >::type a7, \
5153 ::RCF::RemoveOut<A8 >::type a8, \
5154 ::RCF::RemoveOut<A9 >::type a9, \
5155 ::RCF::RemoveOut<A10 >::type a10, \
5156 ::RCF::RemoveOut<A11 >::type a11) \
5157 { \
5158 return func( \
5159 ::RCF::CallOptions() , \
5160 a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11); \
5161 } \
5162 \
5163 ::RCF::FutureImpl<R > func( \
5164 const ::RCF::CallOptions &callOptions , \
5165 ::RCF::RemoveOut<A1 >::type a1, \
5166 ::RCF::RemoveOut<A2 >::type a2, \
5167 ::RCF::RemoveOut<A3 >::type a3, \
5168 ::RCF::RemoveOut<A4 >::type a4, \
5169 ::RCF::RemoveOut<A5 >::type a5, \
5170 ::RCF::RemoveOut<A6 >::type a6, \
5171 ::RCF::RemoveOut<A7 >::type a7, \
5172 ::RCF::RemoveOut<A8 >::type a8, \
5173 ::RCF::RemoveOut<A9 >::type a9, \
5174 ::RCF::RemoveOut<A10 >::type a10, \
5175 ::RCF::RemoveOut<A11 >::type a11); \
5176 \
5177 void error__method_defined_out_of_order__##func( \
5178 id * , \
5179 ::RCF::RemoveOut<A1 >::type a1, \
5180 ::RCF::RemoveOut<A2 >::type a2, \
5181 ::RCF::RemoveOut<A3 >::type a3, \
5182 ::RCF::RemoveOut<A4 >::type a4, \
5183 ::RCF::RemoveOut<A5 >::type a5, \
5184 ::RCF::RemoveOut<A6 >::type a6, \
5185 ::RCF::RemoveOut<A7 >::type a7, \
5186 ::RCF::RemoveOut<A8 >::type a8, \
5187 ::RCF::RemoveOut<A9 >::type a9, \
5188 ::RCF::RemoveOut<A10 >::type a10, \
5189 ::RCF::RemoveOut<A11 >::type a11); \
5190 \
5191 const char * getFunctionName(const id &) \
5192 { \
5193 return #func; \
5194 } \
5195 const char * getArity(const id &) \
5196 { \
5197 return "R11"; \
5198 } \
5199 \
5200 private: \
5201 template<typename T> \
5202 void invoke( \
5203 const id &, \
5204 ::RCF::RcfSession &session, \
5205 T &t) \
5206 { \
5207 if (session.isInProcess()) \
5208 { \
5209 ::RCF::ClientParameters< \
5210 R , \
5211 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11 , V,V,V,V > &p = static_cast<\
5212 ::RCF::ClientParameters< \
5213 R , \
5214 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11 , V,V,V,V > &>(* session.getInProcessParameters());\
5215 p.r.set( t.func( p.a1.get(), \
5216 p.a2.get(), \
5217 p.a3.get(), \
5218 p.a4.get(), \
5219 p.a5.get(), \
5220 p.a6.get(), \
5221 p.a7.get(), \
5222 p.a8.get(), \
5223 p.a9.get(), \
5224 p.a10.get(), \
5225 p.a11.get() ) ); \
5226 } \
5227 else \
5228 { \
5229 ::RCF::ServerParameters< \
5230 R , \
5231 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11 > &p = \
5232 ::RCF::AllocateServerParameters< \
5233 R , \
5234 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11 >()(session); \
5235 p.r.set( \
5236 session.getAutoSend(), \
5237 t.func( \
5238 p.a1.get(), \
5239 p.a2.get(), \
5240 p.a3.get(), \
5241 p.a4.get(), \
5242 p.a5.get(), \
5243 p.a6.get(), \
5244 p.a7.get(), \
5245 p.a8.get(), \
5246 p.a9.get(), \
5247 p.a10.get(), \
5248 p.a11.get())); \
5249 } \
5250 }
5251
5252 // RCF_METHOD_R11_DEF
5253 #define RCF_METHOD_R11_DEF(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11) \
5254 RCF_METHOD_R11_DEF_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11, RCF_PP_CAT(rcf_interface_id_1_, func, R11, __LINE__), RCF_MAKE_UNIQUE_ID(func, R11), RCF_PP_CAT(rcf_interface_id_2_, func, R11, __LINE__))
5255
5256 #define RCF_METHOD_R11_DEF_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11, interfaceId, funcId, genParms)\
5257 RCF_CURRENT_STATIC_ID(interfaceId, RCF_interface_id_helper, int, int) \
5258 typedef GeneratorParms<interfaceId> genParms; \
5259 RCF_ADVANCE_STATIC_ID(funcId, RCF_def_dispatch_id_helper, ::RCF::Dummy<genParms::RcfClientT>, genParms::RcfClientT, static)\
5260 RCF_EXPORT_INTERFACE ::RCF::FutureImpl<R > genParms::RcfClientT::func( \
5261 const ::RCF::CallOptions &callOptions , \
5262 ::RCF::RemoveOut<A1 >::type a1, \
5263 ::RCF::RemoveOut<A2 >::type a2, \
5264 ::RCF::RemoveOut<A3 >::type a3, \
5265 ::RCF::RemoveOut<A4 >::type a4, \
5266 ::RCF::RemoveOut<A5 >::type a5, \
5267 ::RCF::RemoveOut<A6 >::type a6, \
5268 ::RCF::RemoveOut<A7 >::type a7, \
5269 ::RCF::RemoveOut<A8 >::type a8, \
5270 ::RCF::RemoveOut<A9 >::type a9, \
5271 ::RCF::RemoveOut<A10 >::type a10, \
5272 ::RCF::RemoveOut<A11 >::type a11) \
5273 { \
5274 getClientStub().setAsync(false); \
5275 return RCF::FutureImpl<R >( \
5276 ::RCF::AllocateClientParameters< \
5277 R , \
5278 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11 , \
5279 V,V,V,V >()( \
5280 getClientStub() , \
5281 a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11 , \
5282 V(),V(),V(),V()).r.get(), \
5283 getClientStub(), \
5284 mInterfaceName, \
5285 funcId::value, \
5286 callOptions.apply(getClientStub()), \
5287 #func, \
5288 "R11"); \
5289 } \
5290 void genParms::RcfClientT::error__method_defined_out_of_order__##func( \
5291 funcId * , \
5292 ::RCF::RemoveOut<A1 >::type a1, \
5293 ::RCF::RemoveOut<A2 >::type a2, \
5294 ::RCF::RemoveOut<A3 >::type a3, \
5295 ::RCF::RemoveOut<A4 >::type a4, \
5296 ::RCF::RemoveOut<A5 >::type a5, \
5297 ::RCF::RemoveOut<A6 >::type a6, \
5298 ::RCF::RemoveOut<A7 >::type a7, \
5299 ::RCF::RemoveOut<A8 >::type a8, \
5300 ::RCF::RemoveOut<A9 >::type a9, \
5301 ::RCF::RemoveOut<A10 >::type a10, \
5302 ::RCF::RemoveOut<A11 >::type a11) \
5303 { \
5304 }
5305
5306
5307
5308 //------------------------------------------------------------------------------
5309 // Parameters - V11
5310 //------------------------------------------------------------------------------
5311
5312 // RCF_METHOD_V11
5313 #define RCF_METHOD_V11_INLINE(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11) \
5314 RCF_METHOD_V11_INLINE_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11, RCF_MAKE_UNIQUE_ID(func, V11))
5315
5316 #define RCF_METHOD_V11_INLINE_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11, id)\
5317 public: \
5318 BOOST_STATIC_ASSERT(( boost::is_same<R, void>::value )); \
5319 RCF_MAKE_NEXT_DISPATCH_ID(id) \
5320 ::RCF::FutureImpl<V> func( \
5321 ::RCF::RemoveOut<A1 >::type a1, \
5322 ::RCF::RemoveOut<A2 >::type a2, \
5323 ::RCF::RemoveOut<A3 >::type a3, \
5324 ::RCF::RemoveOut<A4 >::type a4, \
5325 ::RCF::RemoveOut<A5 >::type a5, \
5326 ::RCF::RemoveOut<A6 >::type a6, \
5327 ::RCF::RemoveOut<A7 >::type a7, \
5328 ::RCF::RemoveOut<A8 >::type a8, \
5329 ::RCF::RemoveOut<A9 >::type a9, \
5330 ::RCF::RemoveOut<A10 >::type a10, \
5331 ::RCF::RemoveOut<A11 >::type a11) \
5332 { \
5333 return func( \
5334 ::RCF::CallOptions() , \
5335 a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11); \
5336 } \
5337 ::RCF::FutureImpl<V> func( \
5338 const ::RCF::CallOptions &callOptions , \
5339 ::RCF::RemoveOut<A1 >::type a1, \
5340 ::RCF::RemoveOut<A2 >::type a2, \
5341 ::RCF::RemoveOut<A3 >::type a3, \
5342 ::RCF::RemoveOut<A4 >::type a4, \
5343 ::RCF::RemoveOut<A5 >::type a5, \
5344 ::RCF::RemoveOut<A6 >::type a6, \
5345 ::RCF::RemoveOut<A7 >::type a7, \
5346 ::RCF::RemoveOut<A8 >::type a8, \
5347 ::RCF::RemoveOut<A9 >::type a9, \
5348 ::RCF::RemoveOut<A10 >::type a10, \
5349 ::RCF::RemoveOut<A11 >::type a11) \
5350 { \
5351 getClientStub().setAsync(false); \
5352 return RCF::FutureImpl<V>( \
5353 ::RCF::AllocateClientParameters< \
5354 V , \
5355 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11 , \
5356 V,V,V,V >()( \
5357 getClientStub() , \
5358 a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11 , \
5359 V(),V(),V(),V()).r.get(), \
5360 getClientStub(), \
5361 mInterfaceName, \
5362 id::value, \
5363 callOptions.apply(getClientStub()), \
5364 #func, \
5365 "V11"); \
5366 } \
5367 const char * getFunctionName(const id &) \
5368 { \
5369 return #func; \
5370 } \
5371 const char * getArity(const id &) \
5372 { \
5373 return "V11"; \
5374 } \
5375 \
5376 private: \
5377 template<typename T> \
5378 void invoke( \
5379 const id &, \
5380 ::RCF::RcfSession &session, \
5381 T &t) \
5382 { \
5383 if (session.isInProcess()) \
5384 { \
5385 ::RCF::ClientParameters< \
5386 V , \
5387 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11 , V,V,V,V > &p = static_cast<\
5388 ::RCF::ClientParameters< \
5389 V , \
5390 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11 , V,V,V,V > &>(* session.getInProcessParameters());\
5391 RCF_UNUSED_VARIABLE(p); \
5392 t.func( \
5393 p.a1.get(), \
5394 p.a2.get(), \
5395 p.a3.get(), \
5396 p.a4.get(), \
5397 p.a5.get(), \
5398 p.a6.get(), \
5399 p.a7.get(), \
5400 p.a8.get(), \
5401 p.a9.get(), \
5402 p.a10.get(), \
5403 p.a11.get() ); \
5404 } \
5405 else \
5406 { \
5407 ::RCF::ServerParameters< \
5408 V , \
5409 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11 > &p = \
5410 ::RCF::AllocateServerParameters< \
5411 V , \
5412 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11 >()(session);\
5413 RCF_UNUSED_VARIABLE(p); \
5414 t.func( \
5415 p.a1.get(), \
5416 p.a2.get(), \
5417 p.a3.get(), \
5418 p.a4.get(), \
5419 p.a5.get(), \
5420 p.a6.get(), \
5421 p.a7.get(), \
5422 p.a8.get(), \
5423 p.a9.get(), \
5424 p.a10.get(), \
5425 p.a11.get()); \
5426 } \
5427 }
5428
5429 // RCF_METHOD_V11_DECL
5430 #define RCF_METHOD_V11_DECL(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11) \
5431 RCF_METHOD_V11_DECL_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11, RCF_MAKE_UNIQUE_ID(func, V11))
5432
5433 #define RCF_METHOD_V11_DECL_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11, id) \
5434 public: \
5435 BOOST_STATIC_ASSERT(( boost::is_same<R, void>::value )); \
5436 RCF_MAKE_NEXT_DISPATCH_ID(id) \
5437 ::RCF::FutureImpl<V> func( \
5438 ::RCF::RemoveOut<A1 >::type a1, \
5439 ::RCF::RemoveOut<A2 >::type a2, \
5440 ::RCF::RemoveOut<A3 >::type a3, \
5441 ::RCF::RemoveOut<A4 >::type a4, \
5442 ::RCF::RemoveOut<A5 >::type a5, \
5443 ::RCF::RemoveOut<A6 >::type a6, \
5444 ::RCF::RemoveOut<A7 >::type a7, \
5445 ::RCF::RemoveOut<A8 >::type a8, \
5446 ::RCF::RemoveOut<A9 >::type a9, \
5447 ::RCF::RemoveOut<A10 >::type a10, \
5448 ::RCF::RemoveOut<A11 >::type a11) \
5449 { \
5450 return func( \
5451 ::RCF::CallOptions() , \
5452 a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11); \
5453 } \
5454 \
5455 ::RCF::FutureImpl<V> func( \
5456 const ::RCF::CallOptions &callOptions , \
5457 ::RCF::RemoveOut<A1 >::type a1, \
5458 ::RCF::RemoveOut<A2 >::type a2, \
5459 ::RCF::RemoveOut<A3 >::type a3, \
5460 ::RCF::RemoveOut<A4 >::type a4, \
5461 ::RCF::RemoveOut<A5 >::type a5, \
5462 ::RCF::RemoveOut<A6 >::type a6, \
5463 ::RCF::RemoveOut<A7 >::type a7, \
5464 ::RCF::RemoveOut<A8 >::type a8, \
5465 ::RCF::RemoveOut<A9 >::type a9, \
5466 ::RCF::RemoveOut<A10 >::type a10, \
5467 ::RCF::RemoveOut<A11 >::type a11); \
5468 \
5469 void error__method_defined_out_of_order__##func( \
5470 id * , \
5471 ::RCF::RemoveOut<A1 >::type a1, \
5472 ::RCF::RemoveOut<A2 >::type a2, \
5473 ::RCF::RemoveOut<A3 >::type a3, \
5474 ::RCF::RemoveOut<A4 >::type a4, \
5475 ::RCF::RemoveOut<A5 >::type a5, \
5476 ::RCF::RemoveOut<A6 >::type a6, \
5477 ::RCF::RemoveOut<A7 >::type a7, \
5478 ::RCF::RemoveOut<A8 >::type a8, \
5479 ::RCF::RemoveOut<A9 >::type a9, \
5480 ::RCF::RemoveOut<A10 >::type a10, \
5481 ::RCF::RemoveOut<A11 >::type a11); \
5482 \
5483 const char * getFunctionName(const id &) \
5484 { \
5485 return #func; \
5486 } \
5487 const char * getArity(const id &) \
5488 { \
5489 return "V11"; \
5490 } \
5491 \
5492 private: \
5493 template<typename T> \
5494 void invoke( \
5495 const id &, \
5496 ::RCF::RcfSession &session, \
5497 T &t) \
5498 { \
5499 if (session.isInProcess()) \
5500 { \
5501 ::RCF::ClientParameters< \
5502 V , \
5503 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11 , V,V,V,V > &p = static_cast<\
5504 ::RCF::ClientParameters< \
5505 V , \
5506 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11 , V,V,V,V > &>(* session.getInProcessParameters());\
5507 RCF_UNUSED_VARIABLE(p); \
5508 t.func( \
5509 p.a1.get(), \
5510 p.a2.get(), \
5511 p.a3.get(), \
5512 p.a4.get(), \
5513 p.a5.get(), \
5514 p.a6.get(), \
5515 p.a7.get(), \
5516 p.a8.get(), \
5517 p.a9.get(), \
5518 p.a10.get(), \
5519 p.a11.get() ); \
5520 } \
5521 else \
5522 { \
5523 ::RCF::ServerParameters< \
5524 V , \
5525 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11 > &p = \
5526 ::RCF::AllocateServerParameters< \
5527 V , \
5528 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11 >()(session);\
5529 RCF_UNUSED_VARIABLE(p); \
5530 t.func( \
5531 p.a1.get(), \
5532 p.a2.get(), \
5533 p.a3.get(), \
5534 p.a4.get(), \
5535 p.a5.get(), \
5536 p.a6.get(), \
5537 p.a7.get(), \
5538 p.a8.get(), \
5539 p.a9.get(), \
5540 p.a10.get(), \
5541 p.a11.get()); \
5542 } \
5543 }
5544
5545 // RCF_METHOD_V11_DEF
5546 #define RCF_METHOD_V11_DEF(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11) \
5547 RCF_METHOD_V11_DEF_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11, RCF_PP_CAT(rcf_interface_id_1_, func, R11, __LINE__), RCF_MAKE_UNIQUE_ID(func, R11), RCF_PP_CAT(rcf_interface_id_2_, func, R11, __LINE__))
5548
5549 #define RCF_METHOD_V11_DEF_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11, interfaceId, funcId, genParms)\
5550 RCF_CURRENT_STATIC_ID(interfaceId, RCF_interface_id_helper, int, int) \
5551 typedef GeneratorParms<interfaceId> genParms; \
5552 RCF_ADVANCE_STATIC_ID(funcId, RCF_def_dispatch_id_helper, ::RCF::Dummy<genParms::RcfClientT>, genParms::RcfClientT, static)\
5553 RCF_EXPORT_INTERFACE ::RCF::FutureImpl<::RCF::Void> genParms::RcfClientT::func(\
5554 const ::RCF::CallOptions &callOptions , \
5555 ::RCF::RemoveOut<A1 >::type a1, \
5556 ::RCF::RemoveOut<A2 >::type a2, \
5557 ::RCF::RemoveOut<A3 >::type a3, \
5558 ::RCF::RemoveOut<A4 >::type a4, \
5559 ::RCF::RemoveOut<A5 >::type a5, \
5560 ::RCF::RemoveOut<A6 >::type a6, \
5561 ::RCF::RemoveOut<A7 >::type a7, \
5562 ::RCF::RemoveOut<A8 >::type a8, \
5563 ::RCF::RemoveOut<A9 >::type a9, \
5564 ::RCF::RemoveOut<A10 >::type a10, \
5565 ::RCF::RemoveOut<A11 >::type a11) \
5566 { \
5567 typedef ::RCF::Void V; \
5568 getClientStub().setAsync(false); \
5569 return RCF::FutureImpl<V >( \
5570 ::RCF::AllocateClientParameters< \
5571 V , \
5572 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11 , \
5573 V,V,V,V >()( \
5574 getClientStub() , \
5575 a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11 , \
5576 V(),V(),V(),V()).r.get(), \
5577 getClientStub(), \
5578 mInterfaceName, \
5579 funcId::value, \
5580 callOptions.apply(getClientStub()), \
5581 #func, \
5582 "V11"); \
5583 } \
5584 void genParms::RcfClientT::error__method_defined_out_of_order__##func( \
5585 funcId * , \
5586 ::RCF::RemoveOut<A1 >::type a1, \
5587 ::RCF::RemoveOut<A2 >::type a2, \
5588 ::RCF::RemoveOut<A3 >::type a3, \
5589 ::RCF::RemoveOut<A4 >::type a4, \
5590 ::RCF::RemoveOut<A5 >::type a5, \
5591 ::RCF::RemoveOut<A6 >::type a6, \
5592 ::RCF::RemoveOut<A7 >::type a7, \
5593 ::RCF::RemoveOut<A8 >::type a8, \
5594 ::RCF::RemoveOut<A9 >::type a9, \
5595 ::RCF::RemoveOut<A10 >::type a10, \
5596 ::RCF::RemoveOut<A11 >::type a11) \
5597 { \
5598 }
5599
5600
5601
5602
5603 //------------------------------------------------------------------------------
5604 // Parameters - R12
5605 //------------------------------------------------------------------------------
5606
5607 // RCF_METHOD_R12
5608 #define RCF_METHOD_R12_INLINE(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12)\
5609 RCF_METHOD_R12_INLINE_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12, RCF_MAKE_UNIQUE_ID(func, R12))
5610
5611 #define RCF_METHOD_R12_INLINE_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12, id)\
5612 public: \
5613 RCF_MAKE_NEXT_DISPATCH_ID(id) \
5614 ::RCF::FutureImpl<R > func( \
5615 ::RCF::RemoveOut<A1 >::type a1, \
5616 ::RCF::RemoveOut<A2 >::type a2, \
5617 ::RCF::RemoveOut<A3 >::type a3, \
5618 ::RCF::RemoveOut<A4 >::type a4, \
5619 ::RCF::RemoveOut<A5 >::type a5, \
5620 ::RCF::RemoveOut<A6 >::type a6, \
5621 ::RCF::RemoveOut<A7 >::type a7, \
5622 ::RCF::RemoveOut<A8 >::type a8, \
5623 ::RCF::RemoveOut<A9 >::type a9, \
5624 ::RCF::RemoveOut<A10 >::type a10, \
5625 ::RCF::RemoveOut<A11 >::type a11, \
5626 ::RCF::RemoveOut<A12 >::type a12) \
5627 { \
5628 return func( \
5629 ::RCF::CallOptions() , \
5630 a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12); \
5631 } \
5632 ::RCF::FutureImpl<R > func( \
5633 const ::RCF::CallOptions &callOptions , \
5634 ::RCF::RemoveOut<A1 >::type a1, \
5635 ::RCF::RemoveOut<A2 >::type a2, \
5636 ::RCF::RemoveOut<A3 >::type a3, \
5637 ::RCF::RemoveOut<A4 >::type a4, \
5638 ::RCF::RemoveOut<A5 >::type a5, \
5639 ::RCF::RemoveOut<A6 >::type a6, \
5640 ::RCF::RemoveOut<A7 >::type a7, \
5641 ::RCF::RemoveOut<A8 >::type a8, \
5642 ::RCF::RemoveOut<A9 >::type a9, \
5643 ::RCF::RemoveOut<A10 >::type a10, \
5644 ::RCF::RemoveOut<A11 >::type a11, \
5645 ::RCF::RemoveOut<A12 >::type a12) \
5646 { \
5647 getClientStub().setAsync(false); \
5648 return RCF::FutureImpl<R >( \
5649 ::RCF::AllocateClientParameters< \
5650 R , \
5651 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12 , \
5652 V,V,V >()( \
5653 getClientStub() , \
5654 a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12 , \
5655 V(),V(),V()).r.get(), \
5656 getClientStub(), \
5657 mInterfaceName, \
5658 id::value, \
5659 callOptions.apply(getClientStub()), \
5660 #func, \
5661 "R12"); \
5662 } \
5663 const char * getFunctionName(const id &) \
5664 { \
5665 return #func; \
5666 } \
5667 const char * getArity(const id &) \
5668 { \
5669 return "R12"; \
5670 } \
5671 \
5672 private: \
5673 template<typename T> \
5674 void invoke( \
5675 const id &, \
5676 ::RCF::RcfSession &session, \
5677 T &t) \
5678 { \
5679 if (session.isInProcess()) \
5680 { \
5681 ::RCF::ClientParameters< \
5682 R , \
5683 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12 , V,V,V > &p = static_cast<\
5684 ::RCF::ClientParameters< \
5685 R , \
5686 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12 , V,V,V > &>(* session.getInProcessParameters());\
5687 p.r.set( t.func( p.a1.get(), \
5688 p.a2.get(), \
5689 p.a3.get(), \
5690 p.a4.get(), \
5691 p.a5.get(), \
5692 p.a6.get(), \
5693 p.a7.get(), \
5694 p.a8.get(), \
5695 p.a9.get(), \
5696 p.a10.get(), \
5697 p.a11.get(), \
5698 p.a12.get() ) ); \
5699 } \
5700 else \
5701 { \
5702 ::RCF::ServerParameters< \
5703 R , \
5704 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12 > &p = \
5705 ::RCF::AllocateServerParameters< \
5706 R , \
5707 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12 >()(session);\
5708 p.r.set( \
5709 session.getAutoSend(), \
5710 t.func( \
5711 p.a1.get(), \
5712 p.a2.get(), \
5713 p.a3.get(), \
5714 p.a4.get(), \
5715 p.a5.get(), \
5716 p.a6.get(), \
5717 p.a7.get(), \
5718 p.a8.get(), \
5719 p.a9.get(), \
5720 p.a10.get(), \
5721 p.a11.get(), \
5722 p.a12.get())); \
5723 } \
5724 }
5725
5726 // RCF_METHOD_R12_DECL
5727 #define RCF_METHOD_R12_DECL(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12) \
5728 RCF_METHOD_R12_DECL_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12, RCF_MAKE_UNIQUE_ID(func, R12))
5729
5730 #define RCF_METHOD_R12_DECL_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12, id)\
5731 public: \
5732 RCF_MAKE_NEXT_DISPATCH_ID(id) \
5733 ::RCF::FutureImpl<R > func( \
5734 ::RCF::RemoveOut<A1 >::type a1, \
5735 ::RCF::RemoveOut<A2 >::type a2, \
5736 ::RCF::RemoveOut<A3 >::type a3, \
5737 ::RCF::RemoveOut<A4 >::type a4, \
5738 ::RCF::RemoveOut<A5 >::type a5, \
5739 ::RCF::RemoveOut<A6 >::type a6, \
5740 ::RCF::RemoveOut<A7 >::type a7, \
5741 ::RCF::RemoveOut<A8 >::type a8, \
5742 ::RCF::RemoveOut<A9 >::type a9, \
5743 ::RCF::RemoveOut<A10 >::type a10, \
5744 ::RCF::RemoveOut<A11 >::type a11, \
5745 ::RCF::RemoveOut<A12 >::type a12) \
5746 { \
5747 return func( \
5748 ::RCF::CallOptions() , \
5749 a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12); \
5750 } \
5751 \
5752 ::RCF::FutureImpl<R > func( \
5753 const ::RCF::CallOptions &callOptions , \
5754 ::RCF::RemoveOut<A1 >::type a1, \
5755 ::RCF::RemoveOut<A2 >::type a2, \
5756 ::RCF::RemoveOut<A3 >::type a3, \
5757 ::RCF::RemoveOut<A4 >::type a4, \
5758 ::RCF::RemoveOut<A5 >::type a5, \
5759 ::RCF::RemoveOut<A6 >::type a6, \
5760 ::RCF::RemoveOut<A7 >::type a7, \
5761 ::RCF::RemoveOut<A8 >::type a8, \
5762 ::RCF::RemoveOut<A9 >::type a9, \
5763 ::RCF::RemoveOut<A10 >::type a10, \
5764 ::RCF::RemoveOut<A11 >::type a11, \
5765 ::RCF::RemoveOut<A12 >::type a12); \
5766 \
5767 void error__method_defined_out_of_order__##func( \
5768 id * , \
5769 ::RCF::RemoveOut<A1 >::type a1, \
5770 ::RCF::RemoveOut<A2 >::type a2, \
5771 ::RCF::RemoveOut<A3 >::type a3, \
5772 ::RCF::RemoveOut<A4 >::type a4, \
5773 ::RCF::RemoveOut<A5 >::type a5, \
5774 ::RCF::RemoveOut<A6 >::type a6, \
5775 ::RCF::RemoveOut<A7 >::type a7, \
5776 ::RCF::RemoveOut<A8 >::type a8, \
5777 ::RCF::RemoveOut<A9 >::type a9, \
5778 ::RCF::RemoveOut<A10 >::type a10, \
5779 ::RCF::RemoveOut<A11 >::type a11, \
5780 ::RCF::RemoveOut<A12 >::type a12); \
5781 \
5782 const char * getFunctionName(const id &) \
5783 { \
5784 return #func; \
5785 } \
5786 const char * getArity(const id &) \
5787 { \
5788 return "R12"; \
5789 } \
5790 \
5791 private: \
5792 template<typename T> \
5793 void invoke( \
5794 const id &, \
5795 ::RCF::RcfSession &session, \
5796 T &t) \
5797 { \
5798 if (session.isInProcess()) \
5799 { \
5800 ::RCF::ClientParameters< \
5801 R , \
5802 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12 , V,V,V > &p = static_cast<\
5803 ::RCF::ClientParameters< \
5804 R , \
5805 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12 , V,V,V > &>(* session.getInProcessParameters());\
5806 p.r.set( t.func( p.a1.get(), \
5807 p.a2.get(), \
5808 p.a3.get(), \
5809 p.a4.get(), \
5810 p.a5.get(), \
5811 p.a6.get(), \
5812 p.a7.get(), \
5813 p.a8.get(), \
5814 p.a9.get(), \
5815 p.a10.get(), \
5816 p.a11.get(), \
5817 p.a12.get() ) ); \
5818 } \
5819 else \
5820 { \
5821 ::RCF::ServerParameters< \
5822 R , \
5823 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12 > &p = \
5824 ::RCF::AllocateServerParameters< \
5825 R , \
5826 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12 >()(session);\
5827 p.r.set( \
5828 session.getAutoSend(), \
5829 t.func( \
5830 p.a1.get(), \
5831 p.a2.get(), \
5832 p.a3.get(), \
5833 p.a4.get(), \
5834 p.a5.get(), \
5835 p.a6.get(), \
5836 p.a7.get(), \
5837 p.a8.get(), \
5838 p.a9.get(), \
5839 p.a10.get(), \
5840 p.a11.get(), \
5841 p.a12.get())); \
5842 } \
5843 }
5844
5845 // RCF_METHOD_R12_DEF
5846 #define RCF_METHOD_R12_DEF(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12) \
5847 RCF_METHOD_R12_DEF_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12, RCF_PP_CAT(rcf_interface_id_1_, func, R12, __LINE__), RCF_MAKE_UNIQUE_ID(func, R12), RCF_PP_CAT(rcf_interface_id_2_, func, R12, __LINE__))
5848
5849 #define RCF_METHOD_R12_DEF_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12, interfaceId, funcId, genParms)\
5850 RCF_CURRENT_STATIC_ID(interfaceId, RCF_interface_id_helper, int, int) \
5851 typedef GeneratorParms<interfaceId> genParms; \
5852 RCF_ADVANCE_STATIC_ID(funcId, RCF_def_dispatch_id_helper, ::RCF::Dummy<genParms::RcfClientT>, genParms::RcfClientT, static)\
5853 RCF_EXPORT_INTERFACE ::RCF::FutureImpl<R > genParms::RcfClientT::func( \
5854 const ::RCF::CallOptions &callOptions , \
5855 ::RCF::RemoveOut<A1 >::type a1, \
5856 ::RCF::RemoveOut<A2 >::type a2, \
5857 ::RCF::RemoveOut<A3 >::type a3, \
5858 ::RCF::RemoveOut<A4 >::type a4, \
5859 ::RCF::RemoveOut<A5 >::type a5, \
5860 ::RCF::RemoveOut<A6 >::type a6, \
5861 ::RCF::RemoveOut<A7 >::type a7, \
5862 ::RCF::RemoveOut<A8 >::type a8, \
5863 ::RCF::RemoveOut<A9 >::type a9, \
5864 ::RCF::RemoveOut<A10 >::type a10, \
5865 ::RCF::RemoveOut<A11 >::type a11, \
5866 ::RCF::RemoveOut<A12 >::type a12) \
5867 { \
5868 getClientStub().setAsync(false); \
5869 return RCF::FutureImpl<R >( \
5870 ::RCF::AllocateClientParameters< \
5871 R , \
5872 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12 , \
5873 V,V,V >()( \
5874 getClientStub() , \
5875 a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12 , \
5876 V(),V(),V()).r.get(), \
5877 getClientStub(), \
5878 mInterfaceName, \
5879 funcId::value, \
5880 callOptions.apply(getClientStub()), \
5881 #func, \
5882 "R12"); \
5883 } \
5884 void genParms::RcfClientT::error__method_defined_out_of_order__##func( \
5885 funcId * , \
5886 ::RCF::RemoveOut<A1 >::type a1, \
5887 ::RCF::RemoveOut<A2 >::type a2, \
5888 ::RCF::RemoveOut<A3 >::type a3, \
5889 ::RCF::RemoveOut<A4 >::type a4, \
5890 ::RCF::RemoveOut<A5 >::type a5, \
5891 ::RCF::RemoveOut<A6 >::type a6, \
5892 ::RCF::RemoveOut<A7 >::type a7, \
5893 ::RCF::RemoveOut<A8 >::type a8, \
5894 ::RCF::RemoveOut<A9 >::type a9, \
5895 ::RCF::RemoveOut<A10 >::type a10, \
5896 ::RCF::RemoveOut<A11 >::type a11, \
5897 ::RCF::RemoveOut<A12 >::type a12) \
5898 { \
5899 }
5900
5901
5902
5903 //------------------------------------------------------------------------------
5904 // Parameters - V12
5905 //------------------------------------------------------------------------------
5906
5907 // RCF_METHOD_V12
5908 #define RCF_METHOD_V12_INLINE(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12)\
5909 RCF_METHOD_V12_INLINE_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12, RCF_MAKE_UNIQUE_ID(func, V12))
5910
5911 #define RCF_METHOD_V12_INLINE_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12, id)\
5912 public: \
5913 BOOST_STATIC_ASSERT(( boost::is_same<R, void>::value )); \
5914 RCF_MAKE_NEXT_DISPATCH_ID(id) \
5915 ::RCF::FutureImpl<V> func( \
5916 ::RCF::RemoveOut<A1 >::type a1, \
5917 ::RCF::RemoveOut<A2 >::type a2, \
5918 ::RCF::RemoveOut<A3 >::type a3, \
5919 ::RCF::RemoveOut<A4 >::type a4, \
5920 ::RCF::RemoveOut<A5 >::type a5, \
5921 ::RCF::RemoveOut<A6 >::type a6, \
5922 ::RCF::RemoveOut<A7 >::type a7, \
5923 ::RCF::RemoveOut<A8 >::type a8, \
5924 ::RCF::RemoveOut<A9 >::type a9, \
5925 ::RCF::RemoveOut<A10 >::type a10, \
5926 ::RCF::RemoveOut<A11 >::type a11, \
5927 ::RCF::RemoveOut<A12 >::type a12) \
5928 { \
5929 return func( \
5930 ::RCF::CallOptions() , \
5931 a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12); \
5932 } \
5933 ::RCF::FutureImpl<V> func( \
5934 const ::RCF::CallOptions &callOptions , \
5935 ::RCF::RemoveOut<A1 >::type a1, \
5936 ::RCF::RemoveOut<A2 >::type a2, \
5937 ::RCF::RemoveOut<A3 >::type a3, \
5938 ::RCF::RemoveOut<A4 >::type a4, \
5939 ::RCF::RemoveOut<A5 >::type a5, \
5940 ::RCF::RemoveOut<A6 >::type a6, \
5941 ::RCF::RemoveOut<A7 >::type a7, \
5942 ::RCF::RemoveOut<A8 >::type a8, \
5943 ::RCF::RemoveOut<A9 >::type a9, \
5944 ::RCF::RemoveOut<A10 >::type a10, \
5945 ::RCF::RemoveOut<A11 >::type a11, \
5946 ::RCF::RemoveOut<A12 >::type a12) \
5947 { \
5948 getClientStub().setAsync(false); \
5949 return RCF::FutureImpl<V>( \
5950 ::RCF::AllocateClientParameters< \
5951 V , \
5952 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12 , \
5953 V,V,V >()( \
5954 getClientStub() , \
5955 a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12 , \
5956 V(),V(),V()).r.get(), \
5957 getClientStub(), \
5958 mInterfaceName, \
5959 id::value, \
5960 callOptions.apply(getClientStub()), \
5961 #func, \
5962 "V12"); \
5963 } \
5964 const char * getFunctionName(const id &) \
5965 { \
5966 return #func; \
5967 } \
5968 const char * getArity(const id &) \
5969 { \
5970 return "V12"; \
5971 } \
5972 \
5973 private: \
5974 template<typename T> \
5975 void invoke( \
5976 const id &, \
5977 ::RCF::RcfSession &session, \
5978 T &t) \
5979 { \
5980 if (session.isInProcess()) \
5981 { \
5982 ::RCF::ClientParameters< \
5983 V , \
5984 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12 , V,V,V > &p = static_cast<\
5985 ::RCF::ClientParameters< \
5986 V , \
5987 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12 , V,V,V > &>(* session.getInProcessParameters());\
5988 RCF_UNUSED_VARIABLE(p); \
5989 t.func( \
5990 p.a1.get(), \
5991 p.a2.get(), \
5992 p.a3.get(), \
5993 p.a4.get(), \
5994 p.a5.get(), \
5995 p.a6.get(), \
5996 p.a7.get(), \
5997 p.a8.get(), \
5998 p.a9.get(), \
5999 p.a10.get(), \
6000 p.a11.get(), \
6001 p.a12.get() ); \
6002 } \
6003 else \
6004 { \
6005 ::RCF::ServerParameters< \
6006 V , \
6007 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12 > &p = \
6008 ::RCF::AllocateServerParameters< \
6009 V , \
6010 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12 >()(session);\
6011 RCF_UNUSED_VARIABLE(p); \
6012 t.func( \
6013 p.a1.get(), \
6014 p.a2.get(), \
6015 p.a3.get(), \
6016 p.a4.get(), \
6017 p.a5.get(), \
6018 p.a6.get(), \
6019 p.a7.get(), \
6020 p.a8.get(), \
6021 p.a9.get(), \
6022 p.a10.get(), \
6023 p.a11.get(), \
6024 p.a12.get()); \
6025 } \
6026 }
6027
6028 // RCF_METHOD_V12_DECL
6029 #define RCF_METHOD_V12_DECL(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12) \
6030 RCF_METHOD_V12_DECL_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12, RCF_MAKE_UNIQUE_ID(func, V12))
6031
6032 #define RCF_METHOD_V12_DECL_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12, id)\
6033 public: \
6034 BOOST_STATIC_ASSERT(( boost::is_same<R, void>::value )); \
6035 RCF_MAKE_NEXT_DISPATCH_ID(id) \
6036 ::RCF::FutureImpl<V> func( \
6037 ::RCF::RemoveOut<A1 >::type a1, \
6038 ::RCF::RemoveOut<A2 >::type a2, \
6039 ::RCF::RemoveOut<A3 >::type a3, \
6040 ::RCF::RemoveOut<A4 >::type a4, \
6041 ::RCF::RemoveOut<A5 >::type a5, \
6042 ::RCF::RemoveOut<A6 >::type a6, \
6043 ::RCF::RemoveOut<A7 >::type a7, \
6044 ::RCF::RemoveOut<A8 >::type a8, \
6045 ::RCF::RemoveOut<A9 >::type a9, \
6046 ::RCF::RemoveOut<A10 >::type a10, \
6047 ::RCF::RemoveOut<A11 >::type a11, \
6048 ::RCF::RemoveOut<A12 >::type a12) \
6049 { \
6050 return func( \
6051 ::RCF::CallOptions() , \
6052 a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12); \
6053 } \
6054 \
6055 ::RCF::FutureImpl<V> func( \
6056 const ::RCF::CallOptions &callOptions , \
6057 ::RCF::RemoveOut<A1 >::type a1, \
6058 ::RCF::RemoveOut<A2 >::type a2, \
6059 ::RCF::RemoveOut<A3 >::type a3, \
6060 ::RCF::RemoveOut<A4 >::type a4, \
6061 ::RCF::RemoveOut<A5 >::type a5, \
6062 ::RCF::RemoveOut<A6 >::type a6, \
6063 ::RCF::RemoveOut<A7 >::type a7, \
6064 ::RCF::RemoveOut<A8 >::type a8, \
6065 ::RCF::RemoveOut<A9 >::type a9, \
6066 ::RCF::RemoveOut<A10 >::type a10, \
6067 ::RCF::RemoveOut<A11 >::type a11, \
6068 ::RCF::RemoveOut<A12 >::type a12); \
6069 \
6070 void error__method_defined_out_of_order__##func( \
6071 id * , \
6072 ::RCF::RemoveOut<A1 >::type a1, \
6073 ::RCF::RemoveOut<A2 >::type a2, \
6074 ::RCF::RemoveOut<A3 >::type a3, \
6075 ::RCF::RemoveOut<A4 >::type a4, \
6076 ::RCF::RemoveOut<A5 >::type a5, \
6077 ::RCF::RemoveOut<A6 >::type a6, \
6078 ::RCF::RemoveOut<A7 >::type a7, \
6079 ::RCF::RemoveOut<A8 >::type a8, \
6080 ::RCF::RemoveOut<A9 >::type a9, \
6081 ::RCF::RemoveOut<A10 >::type a10, \
6082 ::RCF::RemoveOut<A11 >::type a11, \
6083 ::RCF::RemoveOut<A12 >::type a12); \
6084 \
6085 const char * getFunctionName(const id &) \
6086 { \
6087 return #func; \
6088 } \
6089 const char * getArity(const id &) \
6090 { \
6091 return "V12"; \
6092 } \
6093 \
6094 private: \
6095 template<typename T> \
6096 void invoke( \
6097 const id &, \
6098 ::RCF::RcfSession &session, \
6099 T &t) \
6100 { \
6101 if (session.isInProcess()) \
6102 { \
6103 ::RCF::ClientParameters< \
6104 V , \
6105 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12 , V,V,V > &p = static_cast<\
6106 ::RCF::ClientParameters< \
6107 V , \
6108 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12 , V,V,V > &>(* session.getInProcessParameters());\
6109 RCF_UNUSED_VARIABLE(p); \
6110 t.func( \
6111 p.a1.get(), \
6112 p.a2.get(), \
6113 p.a3.get(), \
6114 p.a4.get(), \
6115 p.a5.get(), \
6116 p.a6.get(), \
6117 p.a7.get(), \
6118 p.a8.get(), \
6119 p.a9.get(), \
6120 p.a10.get(), \
6121 p.a11.get(), \
6122 p.a12.get() ); \
6123 } \
6124 else \
6125 { \
6126 ::RCF::ServerParameters< \
6127 V , \
6128 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12 > &p = \
6129 ::RCF::AllocateServerParameters< \
6130 V , \
6131 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12 >()(session);\
6132 RCF_UNUSED_VARIABLE(p); \
6133 t.func( \
6134 p.a1.get(), \
6135 p.a2.get(), \
6136 p.a3.get(), \
6137 p.a4.get(), \
6138 p.a5.get(), \
6139 p.a6.get(), \
6140 p.a7.get(), \
6141 p.a8.get(), \
6142 p.a9.get(), \
6143 p.a10.get(), \
6144 p.a11.get(), \
6145 p.a12.get()); \
6146 } \
6147 }
6148
6149 // RCF_METHOD_V12_DEF
6150 #define RCF_METHOD_V12_DEF(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12) \
6151 RCF_METHOD_V12_DEF_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12, RCF_PP_CAT(rcf_interface_id_1_, func, R12, __LINE__), RCF_MAKE_UNIQUE_ID(func, R12), RCF_PP_CAT(rcf_interface_id_2_, func, R12, __LINE__))
6152
6153 #define RCF_METHOD_V12_DEF_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12, interfaceId, funcId, genParms)\
6154 RCF_CURRENT_STATIC_ID(interfaceId, RCF_interface_id_helper, int, int) \
6155 typedef GeneratorParms<interfaceId> genParms; \
6156 RCF_ADVANCE_STATIC_ID(funcId, RCF_def_dispatch_id_helper, ::RCF::Dummy<genParms::RcfClientT>, genParms::RcfClientT, static)\
6157 RCF_EXPORT_INTERFACE ::RCF::FutureImpl<::RCF::Void> genParms::RcfClientT::func(\
6158 const ::RCF::CallOptions &callOptions , \
6159 ::RCF::RemoveOut<A1 >::type a1, \
6160 ::RCF::RemoveOut<A2 >::type a2, \
6161 ::RCF::RemoveOut<A3 >::type a3, \
6162 ::RCF::RemoveOut<A4 >::type a4, \
6163 ::RCF::RemoveOut<A5 >::type a5, \
6164 ::RCF::RemoveOut<A6 >::type a6, \
6165 ::RCF::RemoveOut<A7 >::type a7, \
6166 ::RCF::RemoveOut<A8 >::type a8, \
6167 ::RCF::RemoveOut<A9 >::type a9, \
6168 ::RCF::RemoveOut<A10 >::type a10, \
6169 ::RCF::RemoveOut<A11 >::type a11, \
6170 ::RCF::RemoveOut<A12 >::type a12) \
6171 { \
6172 typedef ::RCF::Void V; \
6173 getClientStub().setAsync(false); \
6174 return RCF::FutureImpl<V >( \
6175 ::RCF::AllocateClientParameters< \
6176 V , \
6177 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12 , \
6178 V,V,V >()( \
6179 getClientStub() , \
6180 a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12 , \
6181 V(),V(),V()).r.get(), \
6182 getClientStub(), \
6183 mInterfaceName, \
6184 funcId::value, \
6185 callOptions.apply(getClientStub()), \
6186 #func, \
6187 "V12"); \
6188 } \
6189 void genParms::RcfClientT::error__method_defined_out_of_order__##func( \
6190 funcId * , \
6191 ::RCF::RemoveOut<A1 >::type a1, \
6192 ::RCF::RemoveOut<A2 >::type a2, \
6193 ::RCF::RemoveOut<A3 >::type a3, \
6194 ::RCF::RemoveOut<A4 >::type a4, \
6195 ::RCF::RemoveOut<A5 >::type a5, \
6196 ::RCF::RemoveOut<A6 >::type a6, \
6197 ::RCF::RemoveOut<A7 >::type a7, \
6198 ::RCF::RemoveOut<A8 >::type a8, \
6199 ::RCF::RemoveOut<A9 >::type a9, \
6200 ::RCF::RemoveOut<A10 >::type a10, \
6201 ::RCF::RemoveOut<A11 >::type a11, \
6202 ::RCF::RemoveOut<A12 >::type a12) \
6203 { \
6204 }
6205
6206
6207
6208
6209 //------------------------------------------------------------------------------
6210 // Parameters - R13
6211 //------------------------------------------------------------------------------
6212
6213 // RCF_METHOD_R13
6214 #define RCF_METHOD_R13_INLINE(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13)\
6215 RCF_METHOD_R13_INLINE_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13, RCF_MAKE_UNIQUE_ID(func, R13))
6216
6217 #define RCF_METHOD_R13_INLINE_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13, id)\
6218 public: \
6219 RCF_MAKE_NEXT_DISPATCH_ID(id) \
6220 ::RCF::FutureImpl<R > func( \
6221 ::RCF::RemoveOut<A1 >::type a1, \
6222 ::RCF::RemoveOut<A2 >::type a2, \
6223 ::RCF::RemoveOut<A3 >::type a3, \
6224 ::RCF::RemoveOut<A4 >::type a4, \
6225 ::RCF::RemoveOut<A5 >::type a5, \
6226 ::RCF::RemoveOut<A6 >::type a6, \
6227 ::RCF::RemoveOut<A7 >::type a7, \
6228 ::RCF::RemoveOut<A8 >::type a8, \
6229 ::RCF::RemoveOut<A9 >::type a9, \
6230 ::RCF::RemoveOut<A10 >::type a10, \
6231 ::RCF::RemoveOut<A11 >::type a11, \
6232 ::RCF::RemoveOut<A12 >::type a12, \
6233 ::RCF::RemoveOut<A13 >::type a13) \
6234 { \
6235 return func( \
6236 ::RCF::CallOptions() , \
6237 a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13); \
6238 } \
6239 ::RCF::FutureImpl<R > func( \
6240 const ::RCF::CallOptions &callOptions , \
6241 ::RCF::RemoveOut<A1 >::type a1, \
6242 ::RCF::RemoveOut<A2 >::type a2, \
6243 ::RCF::RemoveOut<A3 >::type a3, \
6244 ::RCF::RemoveOut<A4 >::type a4, \
6245 ::RCF::RemoveOut<A5 >::type a5, \
6246 ::RCF::RemoveOut<A6 >::type a6, \
6247 ::RCF::RemoveOut<A7 >::type a7, \
6248 ::RCF::RemoveOut<A8 >::type a8, \
6249 ::RCF::RemoveOut<A9 >::type a9, \
6250 ::RCF::RemoveOut<A10 >::type a10, \
6251 ::RCF::RemoveOut<A11 >::type a11, \
6252 ::RCF::RemoveOut<A12 >::type a12, \
6253 ::RCF::RemoveOut<A13 >::type a13) \
6254 { \
6255 getClientStub().setAsync(false); \
6256 return RCF::FutureImpl<R >( \
6257 ::RCF::AllocateClientParameters< \
6258 R , \
6259 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13 , \
6260 V,V >()( \
6261 getClientStub() , \
6262 a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13 , \
6263 V(),V()).r.get(), \
6264 getClientStub(), \
6265 mInterfaceName, \
6266 id::value, \
6267 callOptions.apply(getClientStub()), \
6268 #func, \
6269 "R13"); \
6270 } \
6271 const char * getFunctionName(const id &) \
6272 { \
6273 return #func; \
6274 } \
6275 const char * getArity(const id &) \
6276 { \
6277 return "R13"; \
6278 } \
6279 \
6280 private: \
6281 template<typename T> \
6282 void invoke( \
6283 const id &, \
6284 ::RCF::RcfSession &session, \
6285 T &t) \
6286 { \
6287 if (session.isInProcess()) \
6288 { \
6289 ::RCF::ClientParameters< \
6290 R , \
6291 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13 , V,V > &p = static_cast<\
6292 ::RCF::ClientParameters< \
6293 R , \
6294 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13 , V,V > &>(* session.getInProcessParameters());\
6295 p.r.set( t.func( p.a1.get(), \
6296 p.a2.get(), \
6297 p.a3.get(), \
6298 p.a4.get(), \
6299 p.a5.get(), \
6300 p.a6.get(), \
6301 p.a7.get(), \
6302 p.a8.get(), \
6303 p.a9.get(), \
6304 p.a10.get(), \
6305 p.a11.get(), \
6306 p.a12.get(), \
6307 p.a13.get() ) ); \
6308 } \
6309 else \
6310 { \
6311 ::RCF::ServerParameters< \
6312 R , \
6313 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13 > &p = \
6314 ::RCF::AllocateServerParameters< \
6315 R , \
6316 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13 >()(session);\
6317 p.r.set( \
6318 session.getAutoSend(), \
6319 t.func( \
6320 p.a1.get(), \
6321 p.a2.get(), \
6322 p.a3.get(), \
6323 p.a4.get(), \
6324 p.a5.get(), \
6325 p.a6.get(), \
6326 p.a7.get(), \
6327 p.a8.get(), \
6328 p.a9.get(), \
6329 p.a10.get(), \
6330 p.a11.get(), \
6331 p.a12.get(), \
6332 p.a13.get())); \
6333 } \
6334 }
6335
6336 // RCF_METHOD_R13_DECL
6337 #define RCF_METHOD_R13_DECL(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13)\
6338 RCF_METHOD_R13_DECL_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13, RCF_MAKE_UNIQUE_ID(func, R13))
6339
6340 #define RCF_METHOD_R13_DECL_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13, id)\
6341 public: \
6342 RCF_MAKE_NEXT_DISPATCH_ID(id) \
6343 ::RCF::FutureImpl<R > func( \
6344 ::RCF::RemoveOut<A1 >::type a1, \
6345 ::RCF::RemoveOut<A2 >::type a2, \
6346 ::RCF::RemoveOut<A3 >::type a3, \
6347 ::RCF::RemoveOut<A4 >::type a4, \
6348 ::RCF::RemoveOut<A5 >::type a5, \
6349 ::RCF::RemoveOut<A6 >::type a6, \
6350 ::RCF::RemoveOut<A7 >::type a7, \
6351 ::RCF::RemoveOut<A8 >::type a8, \
6352 ::RCF::RemoveOut<A9 >::type a9, \
6353 ::RCF::RemoveOut<A10 >::type a10, \
6354 ::RCF::RemoveOut<A11 >::type a11, \
6355 ::RCF::RemoveOut<A12 >::type a12, \
6356 ::RCF::RemoveOut<A13 >::type a13) \
6357 { \
6358 return func( \
6359 ::RCF::CallOptions() , \
6360 a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13); \
6361 } \
6362 \
6363 ::RCF::FutureImpl<R > func( \
6364 const ::RCF::CallOptions &callOptions , \
6365 ::RCF::RemoveOut<A1 >::type a1, \
6366 ::RCF::RemoveOut<A2 >::type a2, \
6367 ::RCF::RemoveOut<A3 >::type a3, \
6368 ::RCF::RemoveOut<A4 >::type a4, \
6369 ::RCF::RemoveOut<A5 >::type a5, \
6370 ::RCF::RemoveOut<A6 >::type a6, \
6371 ::RCF::RemoveOut<A7 >::type a7, \
6372 ::RCF::RemoveOut<A8 >::type a8, \
6373 ::RCF::RemoveOut<A9 >::type a9, \
6374 ::RCF::RemoveOut<A10 >::type a10, \
6375 ::RCF::RemoveOut<A11 >::type a11, \
6376 ::RCF::RemoveOut<A12 >::type a12, \
6377 ::RCF::RemoveOut<A13 >::type a13); \
6378 \
6379 void error__method_defined_out_of_order__##func( \
6380 id * , \
6381 ::RCF::RemoveOut<A1 >::type a1, \
6382 ::RCF::RemoveOut<A2 >::type a2, \
6383 ::RCF::RemoveOut<A3 >::type a3, \
6384 ::RCF::RemoveOut<A4 >::type a4, \
6385 ::RCF::RemoveOut<A5 >::type a5, \
6386 ::RCF::RemoveOut<A6 >::type a6, \
6387 ::RCF::RemoveOut<A7 >::type a7, \
6388 ::RCF::RemoveOut<A8 >::type a8, \
6389 ::RCF::RemoveOut<A9 >::type a9, \
6390 ::RCF::RemoveOut<A10 >::type a10, \
6391 ::RCF::RemoveOut<A11 >::type a11, \
6392 ::RCF::RemoveOut<A12 >::type a12, \
6393 ::RCF::RemoveOut<A13 >::type a13); \
6394 \
6395 const char * getFunctionName(const id &) \
6396 { \
6397 return #func; \
6398 } \
6399 const char * getArity(const id &) \
6400 { \
6401 return "R13"; \
6402 } \
6403 \
6404 private: \
6405 template<typename T> \
6406 void invoke( \
6407 const id &, \
6408 ::RCF::RcfSession &session, \
6409 T &t) \
6410 { \
6411 if (session.isInProcess()) \
6412 { \
6413 ::RCF::ClientParameters< \
6414 R , \
6415 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13 , V,V > &p = static_cast<\
6416 ::RCF::ClientParameters< \
6417 R , \
6418 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13 , V,V > &>(* session.getInProcessParameters());\
6419 p.r.set( t.func( p.a1.get(), \
6420 p.a2.get(), \
6421 p.a3.get(), \
6422 p.a4.get(), \
6423 p.a5.get(), \
6424 p.a6.get(), \
6425 p.a7.get(), \
6426 p.a8.get(), \
6427 p.a9.get(), \
6428 p.a10.get(), \
6429 p.a11.get(), \
6430 p.a12.get(), \
6431 p.a13.get() ) ); \
6432 } \
6433 else \
6434 { \
6435 ::RCF::ServerParameters< \
6436 R , \
6437 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13 > &p = \
6438 ::RCF::AllocateServerParameters< \
6439 R , \
6440 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13 >()(session);\
6441 p.r.set( \
6442 session.getAutoSend(), \
6443 t.func( \
6444 p.a1.get(), \
6445 p.a2.get(), \
6446 p.a3.get(), \
6447 p.a4.get(), \
6448 p.a5.get(), \
6449 p.a6.get(), \
6450 p.a7.get(), \
6451 p.a8.get(), \
6452 p.a9.get(), \
6453 p.a10.get(), \
6454 p.a11.get(), \
6455 p.a12.get(), \
6456 p.a13.get())); \
6457 } \
6458 }
6459
6460 // RCF_METHOD_R13_DEF
6461 #define RCF_METHOD_R13_DEF(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13)\
6462 RCF_METHOD_R13_DEF_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13, RCF_PP_CAT(rcf_interface_id_1_, func, R13, __LINE__), RCF_MAKE_UNIQUE_ID(func, R13), RCF_PP_CAT(rcf_interface_id_2_, func, R13, __LINE__))
6463
6464 #define RCF_METHOD_R13_DEF_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13, interfaceId, funcId, genParms)\
6465 RCF_CURRENT_STATIC_ID(interfaceId, RCF_interface_id_helper, int, int) \
6466 typedef GeneratorParms<interfaceId> genParms; \
6467 RCF_ADVANCE_STATIC_ID(funcId, RCF_def_dispatch_id_helper, ::RCF::Dummy<genParms::RcfClientT>, genParms::RcfClientT, static)\
6468 RCF_EXPORT_INTERFACE ::RCF::FutureImpl<R > genParms::RcfClientT::func( \
6469 const ::RCF::CallOptions &callOptions , \
6470 ::RCF::RemoveOut<A1 >::type a1, \
6471 ::RCF::RemoveOut<A2 >::type a2, \
6472 ::RCF::RemoveOut<A3 >::type a3, \
6473 ::RCF::RemoveOut<A4 >::type a4, \
6474 ::RCF::RemoveOut<A5 >::type a5, \
6475 ::RCF::RemoveOut<A6 >::type a6, \
6476 ::RCF::RemoveOut<A7 >::type a7, \
6477 ::RCF::RemoveOut<A8 >::type a8, \
6478 ::RCF::RemoveOut<A9 >::type a9, \
6479 ::RCF::RemoveOut<A10 >::type a10, \
6480 ::RCF::RemoveOut<A11 >::type a11, \
6481 ::RCF::RemoveOut<A12 >::type a12, \
6482 ::RCF::RemoveOut<A13 >::type a13) \
6483 { \
6484 getClientStub().setAsync(false); \
6485 return RCF::FutureImpl<R >( \
6486 ::RCF::AllocateClientParameters< \
6487 R , \
6488 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13 , \
6489 V,V >()( \
6490 getClientStub() , \
6491 a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13 , \
6492 V(),V()).r.get(), \
6493 getClientStub(), \
6494 mInterfaceName, \
6495 funcId::value, \
6496 callOptions.apply(getClientStub()), \
6497 #func, \
6498 "R13"); \
6499 } \
6500 void genParms::RcfClientT::error__method_defined_out_of_order__##func( \
6501 funcId * , \
6502 ::RCF::RemoveOut<A1 >::type a1, \
6503 ::RCF::RemoveOut<A2 >::type a2, \
6504 ::RCF::RemoveOut<A3 >::type a3, \
6505 ::RCF::RemoveOut<A4 >::type a4, \
6506 ::RCF::RemoveOut<A5 >::type a5, \
6507 ::RCF::RemoveOut<A6 >::type a6, \
6508 ::RCF::RemoveOut<A7 >::type a7, \
6509 ::RCF::RemoveOut<A8 >::type a8, \
6510 ::RCF::RemoveOut<A9 >::type a9, \
6511 ::RCF::RemoveOut<A10 >::type a10, \
6512 ::RCF::RemoveOut<A11 >::type a11, \
6513 ::RCF::RemoveOut<A12 >::type a12, \
6514 ::RCF::RemoveOut<A13 >::type a13) \
6515 { \
6516 }
6517
6518
6519
6520 //------------------------------------------------------------------------------
6521 // Parameters - V13
6522 //------------------------------------------------------------------------------
6523
6524 // RCF_METHOD_V13
6525 #define RCF_METHOD_V13_INLINE(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13)\
6526 RCF_METHOD_V13_INLINE_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13, RCF_MAKE_UNIQUE_ID(func, V13))
6527
6528 #define RCF_METHOD_V13_INLINE_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13, id)\
6529 public: \
6530 BOOST_STATIC_ASSERT(( boost::is_same<R, void>::value )); \
6531 RCF_MAKE_NEXT_DISPATCH_ID(id) \
6532 ::RCF::FutureImpl<V> func( \
6533 ::RCF::RemoveOut<A1 >::type a1, \
6534 ::RCF::RemoveOut<A2 >::type a2, \
6535 ::RCF::RemoveOut<A3 >::type a3, \
6536 ::RCF::RemoveOut<A4 >::type a4, \
6537 ::RCF::RemoveOut<A5 >::type a5, \
6538 ::RCF::RemoveOut<A6 >::type a6, \
6539 ::RCF::RemoveOut<A7 >::type a7, \
6540 ::RCF::RemoveOut<A8 >::type a8, \
6541 ::RCF::RemoveOut<A9 >::type a9, \
6542 ::RCF::RemoveOut<A10 >::type a10, \
6543 ::RCF::RemoveOut<A11 >::type a11, \
6544 ::RCF::RemoveOut<A12 >::type a12, \
6545 ::RCF::RemoveOut<A13 >::type a13) \
6546 { \
6547 return func( \
6548 ::RCF::CallOptions() , \
6549 a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13); \
6550 } \
6551 ::RCF::FutureImpl<V> func( \
6552 const ::RCF::CallOptions &callOptions , \
6553 ::RCF::RemoveOut<A1 >::type a1, \
6554 ::RCF::RemoveOut<A2 >::type a2, \
6555 ::RCF::RemoveOut<A3 >::type a3, \
6556 ::RCF::RemoveOut<A4 >::type a4, \
6557 ::RCF::RemoveOut<A5 >::type a5, \
6558 ::RCF::RemoveOut<A6 >::type a6, \
6559 ::RCF::RemoveOut<A7 >::type a7, \
6560 ::RCF::RemoveOut<A8 >::type a8, \
6561 ::RCF::RemoveOut<A9 >::type a9, \
6562 ::RCF::RemoveOut<A10 >::type a10, \
6563 ::RCF::RemoveOut<A11 >::type a11, \
6564 ::RCF::RemoveOut<A12 >::type a12, \
6565 ::RCF::RemoveOut<A13 >::type a13) \
6566 { \
6567 getClientStub().setAsync(false); \
6568 return RCF::FutureImpl<V>( \
6569 ::RCF::AllocateClientParameters< \
6570 V , \
6571 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13 , \
6572 V,V >()( \
6573 getClientStub() , \
6574 a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13 , \
6575 V(),V()).r.get(), \
6576 getClientStub(), \
6577 mInterfaceName, \
6578 id::value, \
6579 callOptions.apply(getClientStub()), \
6580 #func, \
6581 "V13"); \
6582 } \
6583 const char * getFunctionName(const id &) \
6584 { \
6585 return #func; \
6586 } \
6587 const char * getArity(const id &) \
6588 { \
6589 return "V13"; \
6590 } \
6591 \
6592 private: \
6593 template<typename T> \
6594 void invoke( \
6595 const id &, \
6596 ::RCF::RcfSession &session, \
6597 T &t) \
6598 { \
6599 if (session.isInProcess()) \
6600 { \
6601 ::RCF::ClientParameters< \
6602 V , \
6603 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13 , V,V > &p = static_cast<\
6604 ::RCF::ClientParameters< \
6605 V , \
6606 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13 , V,V > &>(* session.getInProcessParameters());\
6607 RCF_UNUSED_VARIABLE(p); \
6608 t.func( \
6609 p.a1.get(), \
6610 p.a2.get(), \
6611 p.a3.get(), \
6612 p.a4.get(), \
6613 p.a5.get(), \
6614 p.a6.get(), \
6615 p.a7.get(), \
6616 p.a8.get(), \
6617 p.a9.get(), \
6618 p.a10.get(), \
6619 p.a11.get(), \
6620 p.a12.get(), \
6621 p.a13.get() ); \
6622 } \
6623 else \
6624 { \
6625 ::RCF::ServerParameters< \
6626 V , \
6627 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13 > &p = \
6628 ::RCF::AllocateServerParameters< \
6629 V , \
6630 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13 >()(session);\
6631 RCF_UNUSED_VARIABLE(p); \
6632 t.func( \
6633 p.a1.get(), \
6634 p.a2.get(), \
6635 p.a3.get(), \
6636 p.a4.get(), \
6637 p.a5.get(), \
6638 p.a6.get(), \
6639 p.a7.get(), \
6640 p.a8.get(), \
6641 p.a9.get(), \
6642 p.a10.get(), \
6643 p.a11.get(), \
6644 p.a12.get(), \
6645 p.a13.get()); \
6646 } \
6647 }
6648
6649 // RCF_METHOD_V13_DECL
6650 #define RCF_METHOD_V13_DECL(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13)\
6651 RCF_METHOD_V13_DECL_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13, RCF_MAKE_UNIQUE_ID(func, V13))
6652
6653 #define RCF_METHOD_V13_DECL_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13, id)\
6654 public: \
6655 BOOST_STATIC_ASSERT(( boost::is_same<R, void>::value )); \
6656 RCF_MAKE_NEXT_DISPATCH_ID(id) \
6657 ::RCF::FutureImpl<V> func( \
6658 ::RCF::RemoveOut<A1 >::type a1, \
6659 ::RCF::RemoveOut<A2 >::type a2, \
6660 ::RCF::RemoveOut<A3 >::type a3, \
6661 ::RCF::RemoveOut<A4 >::type a4, \
6662 ::RCF::RemoveOut<A5 >::type a5, \
6663 ::RCF::RemoveOut<A6 >::type a6, \
6664 ::RCF::RemoveOut<A7 >::type a7, \
6665 ::RCF::RemoveOut<A8 >::type a8, \
6666 ::RCF::RemoveOut<A9 >::type a9, \
6667 ::RCF::RemoveOut<A10 >::type a10, \
6668 ::RCF::RemoveOut<A11 >::type a11, \
6669 ::RCF::RemoveOut<A12 >::type a12, \
6670 ::RCF::RemoveOut<A13 >::type a13) \
6671 { \
6672 return func( \
6673 ::RCF::CallOptions() , \
6674 a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13); \
6675 } \
6676 \
6677 ::RCF::FutureImpl<V> func( \
6678 const ::RCF::CallOptions &callOptions , \
6679 ::RCF::RemoveOut<A1 >::type a1, \
6680 ::RCF::RemoveOut<A2 >::type a2, \
6681 ::RCF::RemoveOut<A3 >::type a3, \
6682 ::RCF::RemoveOut<A4 >::type a4, \
6683 ::RCF::RemoveOut<A5 >::type a5, \
6684 ::RCF::RemoveOut<A6 >::type a6, \
6685 ::RCF::RemoveOut<A7 >::type a7, \
6686 ::RCF::RemoveOut<A8 >::type a8, \
6687 ::RCF::RemoveOut<A9 >::type a9, \
6688 ::RCF::RemoveOut<A10 >::type a10, \
6689 ::RCF::RemoveOut<A11 >::type a11, \
6690 ::RCF::RemoveOut<A12 >::type a12, \
6691 ::RCF::RemoveOut<A13 >::type a13); \
6692 \
6693 void error__method_defined_out_of_order__##func( \
6694 id * , \
6695 ::RCF::RemoveOut<A1 >::type a1, \
6696 ::RCF::RemoveOut<A2 >::type a2, \
6697 ::RCF::RemoveOut<A3 >::type a3, \
6698 ::RCF::RemoveOut<A4 >::type a4, \
6699 ::RCF::RemoveOut<A5 >::type a5, \
6700 ::RCF::RemoveOut<A6 >::type a6, \
6701 ::RCF::RemoveOut<A7 >::type a7, \
6702 ::RCF::RemoveOut<A8 >::type a8, \
6703 ::RCF::RemoveOut<A9 >::type a9, \
6704 ::RCF::RemoveOut<A10 >::type a10, \
6705 ::RCF::RemoveOut<A11 >::type a11, \
6706 ::RCF::RemoveOut<A12 >::type a12, \
6707 ::RCF::RemoveOut<A13 >::type a13); \
6708 \
6709 const char * getFunctionName(const id &) \
6710 { \
6711 return #func; \
6712 } \
6713 const char * getArity(const id &) \
6714 { \
6715 return "V13"; \
6716 } \
6717 \
6718 private: \
6719 template<typename T> \
6720 void invoke( \
6721 const id &, \
6722 ::RCF::RcfSession &session, \
6723 T &t) \
6724 { \
6725 if (session.isInProcess()) \
6726 { \
6727 ::RCF::ClientParameters< \
6728 V , \
6729 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13 , V,V > &p = static_cast<\
6730 ::RCF::ClientParameters< \
6731 V , \
6732 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13 , V,V > &>(* session.getInProcessParameters());\
6733 RCF_UNUSED_VARIABLE(p); \
6734 t.func( \
6735 p.a1.get(), \
6736 p.a2.get(), \
6737 p.a3.get(), \
6738 p.a4.get(), \
6739 p.a5.get(), \
6740 p.a6.get(), \
6741 p.a7.get(), \
6742 p.a8.get(), \
6743 p.a9.get(), \
6744 p.a10.get(), \
6745 p.a11.get(), \
6746 p.a12.get(), \
6747 p.a13.get() ); \
6748 } \
6749 else \
6750 { \
6751 ::RCF::ServerParameters< \
6752 V , \
6753 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13 > &p = \
6754 ::RCF::AllocateServerParameters< \
6755 V , \
6756 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13 >()(session);\
6757 RCF_UNUSED_VARIABLE(p); \
6758 t.func( \
6759 p.a1.get(), \
6760 p.a2.get(), \
6761 p.a3.get(), \
6762 p.a4.get(), \
6763 p.a5.get(), \
6764 p.a6.get(), \
6765 p.a7.get(), \
6766 p.a8.get(), \
6767 p.a9.get(), \
6768 p.a10.get(), \
6769 p.a11.get(), \
6770 p.a12.get(), \
6771 p.a13.get()); \
6772 } \
6773 }
6774
6775 // RCF_METHOD_V13_DEF
6776 #define RCF_METHOD_V13_DEF(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13)\
6777 RCF_METHOD_V13_DEF_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13, RCF_PP_CAT(rcf_interface_id_1_, func, R13, __LINE__), RCF_MAKE_UNIQUE_ID(func, R13), RCF_PP_CAT(rcf_interface_id_2_, func, R13, __LINE__))
6778
6779 #define RCF_METHOD_V13_DEF_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13, interfaceId, funcId, genParms)\
6780 RCF_CURRENT_STATIC_ID(interfaceId, RCF_interface_id_helper, int, int) \
6781 typedef GeneratorParms<interfaceId> genParms; \
6782 RCF_ADVANCE_STATIC_ID(funcId, RCF_def_dispatch_id_helper, ::RCF::Dummy<genParms::RcfClientT>, genParms::RcfClientT, static)\
6783 RCF_EXPORT_INTERFACE ::RCF::FutureImpl<::RCF::Void> genParms::RcfClientT::func(\
6784 const ::RCF::CallOptions &callOptions , \
6785 ::RCF::RemoveOut<A1 >::type a1, \
6786 ::RCF::RemoveOut<A2 >::type a2, \
6787 ::RCF::RemoveOut<A3 >::type a3, \
6788 ::RCF::RemoveOut<A4 >::type a4, \
6789 ::RCF::RemoveOut<A5 >::type a5, \
6790 ::RCF::RemoveOut<A6 >::type a6, \
6791 ::RCF::RemoveOut<A7 >::type a7, \
6792 ::RCF::RemoveOut<A8 >::type a8, \
6793 ::RCF::RemoveOut<A9 >::type a9, \
6794 ::RCF::RemoveOut<A10 >::type a10, \
6795 ::RCF::RemoveOut<A11 >::type a11, \
6796 ::RCF::RemoveOut<A12 >::type a12, \
6797 ::RCF::RemoveOut<A13 >::type a13) \
6798 { \
6799 typedef ::RCF::Void V; \
6800 getClientStub().setAsync(false); \
6801 return RCF::FutureImpl<V >( \
6802 ::RCF::AllocateClientParameters< \
6803 V , \
6804 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13 , \
6805 V,V >()( \
6806 getClientStub() , \
6807 a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13 , \
6808 V(),V()).r.get(), \
6809 getClientStub(), \
6810 mInterfaceName, \
6811 funcId::value, \
6812 callOptions.apply(getClientStub()), \
6813 #func, \
6814 "V13"); \
6815 } \
6816 void genParms::RcfClientT::error__method_defined_out_of_order__##func( \
6817 funcId * , \
6818 ::RCF::RemoveOut<A1 >::type a1, \
6819 ::RCF::RemoveOut<A2 >::type a2, \
6820 ::RCF::RemoveOut<A3 >::type a3, \
6821 ::RCF::RemoveOut<A4 >::type a4, \
6822 ::RCF::RemoveOut<A5 >::type a5, \
6823 ::RCF::RemoveOut<A6 >::type a6, \
6824 ::RCF::RemoveOut<A7 >::type a7, \
6825 ::RCF::RemoveOut<A8 >::type a8, \
6826 ::RCF::RemoveOut<A9 >::type a9, \
6827 ::RCF::RemoveOut<A10 >::type a10, \
6828 ::RCF::RemoveOut<A11 >::type a11, \
6829 ::RCF::RemoveOut<A12 >::type a12, \
6830 ::RCF::RemoveOut<A13 >::type a13) \
6831 { \
6832 }
6833
6834
6835
6836
6837 //------------------------------------------------------------------------------
6838 // Parameters - R14
6839 //------------------------------------------------------------------------------
6840
6841 // RCF_METHOD_R14
6842 #define RCF_METHOD_R14_INLINE(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14)\
6843 RCF_METHOD_R14_INLINE_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14, RCF_MAKE_UNIQUE_ID(func, R14))
6844
6845 #define RCF_METHOD_R14_INLINE_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14, id)\
6846 public: \
6847 RCF_MAKE_NEXT_DISPATCH_ID(id) \
6848 ::RCF::FutureImpl<R > func( \
6849 ::RCF::RemoveOut<A1 >::type a1, \
6850 ::RCF::RemoveOut<A2 >::type a2, \
6851 ::RCF::RemoveOut<A3 >::type a3, \
6852 ::RCF::RemoveOut<A4 >::type a4, \
6853 ::RCF::RemoveOut<A5 >::type a5, \
6854 ::RCF::RemoveOut<A6 >::type a6, \
6855 ::RCF::RemoveOut<A7 >::type a7, \
6856 ::RCF::RemoveOut<A8 >::type a8, \
6857 ::RCF::RemoveOut<A9 >::type a9, \
6858 ::RCF::RemoveOut<A10 >::type a10, \
6859 ::RCF::RemoveOut<A11 >::type a11, \
6860 ::RCF::RemoveOut<A12 >::type a12, \
6861 ::RCF::RemoveOut<A13 >::type a13, \
6862 ::RCF::RemoveOut<A14 >::type a14) \
6863 { \
6864 return func( \
6865 ::RCF::CallOptions() , \
6866 a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14); \
6867 } \
6868 ::RCF::FutureImpl<R > func( \
6869 const ::RCF::CallOptions &callOptions , \
6870 ::RCF::RemoveOut<A1 >::type a1, \
6871 ::RCF::RemoveOut<A2 >::type a2, \
6872 ::RCF::RemoveOut<A3 >::type a3, \
6873 ::RCF::RemoveOut<A4 >::type a4, \
6874 ::RCF::RemoveOut<A5 >::type a5, \
6875 ::RCF::RemoveOut<A6 >::type a6, \
6876 ::RCF::RemoveOut<A7 >::type a7, \
6877 ::RCF::RemoveOut<A8 >::type a8, \
6878 ::RCF::RemoveOut<A9 >::type a9, \
6879 ::RCF::RemoveOut<A10 >::type a10, \
6880 ::RCF::RemoveOut<A11 >::type a11, \
6881 ::RCF::RemoveOut<A12 >::type a12, \
6882 ::RCF::RemoveOut<A13 >::type a13, \
6883 ::RCF::RemoveOut<A14 >::type a14) \
6884 { \
6885 getClientStub().setAsync(false); \
6886 return RCF::FutureImpl<R >( \
6887 ::RCF::AllocateClientParameters< \
6888 R , \
6889 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14 , \
6890 V >()( \
6891 getClientStub() , \
6892 a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14 , \
6893 V()).r.get(), \
6894 getClientStub(), \
6895 mInterfaceName, \
6896 id::value, \
6897 callOptions.apply(getClientStub()), \
6898 #func, \
6899 "R14"); \
6900 } \
6901 const char * getFunctionName(const id &) \
6902 { \
6903 return #func; \
6904 } \
6905 const char * getArity(const id &) \
6906 { \
6907 return "R14"; \
6908 } \
6909 \
6910 private: \
6911 template<typename T> \
6912 void invoke( \
6913 const id &, \
6914 ::RCF::RcfSession &session, \
6915 T &t) \
6916 { \
6917 if (session.isInProcess()) \
6918 { \
6919 ::RCF::ClientParameters< \
6920 R , \
6921 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14 , V > &p = static_cast<\
6922 ::RCF::ClientParameters< \
6923 R , \
6924 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14 , V > &>(* session.getInProcessParameters());\
6925 p.r.set( t.func( p.a1.get(), \
6926 p.a2.get(), \
6927 p.a3.get(), \
6928 p.a4.get(), \
6929 p.a5.get(), \
6930 p.a6.get(), \
6931 p.a7.get(), \
6932 p.a8.get(), \
6933 p.a9.get(), \
6934 p.a10.get(), \
6935 p.a11.get(), \
6936 p.a12.get(), \
6937 p.a13.get(), \
6938 p.a14.get() ) ); \
6939 } \
6940 else \
6941 { \
6942 ::RCF::ServerParameters< \
6943 R , \
6944 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14 > &p = \
6945 ::RCF::AllocateServerParameters< \
6946 R , \
6947 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14 >()(session);\
6948 p.r.set( \
6949 session.getAutoSend(), \
6950 t.func( \
6951 p.a1.get(), \
6952 p.a2.get(), \
6953 p.a3.get(), \
6954 p.a4.get(), \
6955 p.a5.get(), \
6956 p.a6.get(), \
6957 p.a7.get(), \
6958 p.a8.get(), \
6959 p.a9.get(), \
6960 p.a10.get(), \
6961 p.a11.get(), \
6962 p.a12.get(), \
6963 p.a13.get(), \
6964 p.a14.get())); \
6965 } \
6966 }
6967
6968 // RCF_METHOD_R14_DECL
6969 #define RCF_METHOD_R14_DECL(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14)\
6970 RCF_METHOD_R14_DECL_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14, RCF_MAKE_UNIQUE_ID(func, R14))
6971
6972 #define RCF_METHOD_R14_DECL_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14, id)\
6973 public: \
6974 RCF_MAKE_NEXT_DISPATCH_ID(id) \
6975 ::RCF::FutureImpl<R > func( \
6976 ::RCF::RemoveOut<A1 >::type a1, \
6977 ::RCF::RemoveOut<A2 >::type a2, \
6978 ::RCF::RemoveOut<A3 >::type a3, \
6979 ::RCF::RemoveOut<A4 >::type a4, \
6980 ::RCF::RemoveOut<A5 >::type a5, \
6981 ::RCF::RemoveOut<A6 >::type a6, \
6982 ::RCF::RemoveOut<A7 >::type a7, \
6983 ::RCF::RemoveOut<A8 >::type a8, \
6984 ::RCF::RemoveOut<A9 >::type a9, \
6985 ::RCF::RemoveOut<A10 >::type a10, \
6986 ::RCF::RemoveOut<A11 >::type a11, \
6987 ::RCF::RemoveOut<A12 >::type a12, \
6988 ::RCF::RemoveOut<A13 >::type a13, \
6989 ::RCF::RemoveOut<A14 >::type a14) \
6990 { \
6991 return func( \
6992 ::RCF::CallOptions() , \
6993 a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14); \
6994 } \
6995 \
6996 ::RCF::FutureImpl<R > func( \
6997 const ::RCF::CallOptions &callOptions , \
6998 ::RCF::RemoveOut<A1 >::type a1, \
6999 ::RCF::RemoveOut<A2 >::type a2, \
7000 ::RCF::RemoveOut<A3 >::type a3, \
7001 ::RCF::RemoveOut<A4 >::type a4, \
7002 ::RCF::RemoveOut<A5 >::type a5, \
7003 ::RCF::RemoveOut<A6 >::type a6, \
7004 ::RCF::RemoveOut<A7 >::type a7, \
7005 ::RCF::RemoveOut<A8 >::type a8, \
7006 ::RCF::RemoveOut<A9 >::type a9, \
7007 ::RCF::RemoveOut<A10 >::type a10, \
7008 ::RCF::RemoveOut<A11 >::type a11, \
7009 ::RCF::RemoveOut<A12 >::type a12, \
7010 ::RCF::RemoveOut<A13 >::type a13, \
7011 ::RCF::RemoveOut<A14 >::type a14); \
7012 \
7013 void error__method_defined_out_of_order__##func( \
7014 id * , \
7015 ::RCF::RemoveOut<A1 >::type a1, \
7016 ::RCF::RemoveOut<A2 >::type a2, \
7017 ::RCF::RemoveOut<A3 >::type a3, \
7018 ::RCF::RemoveOut<A4 >::type a4, \
7019 ::RCF::RemoveOut<A5 >::type a5, \
7020 ::RCF::RemoveOut<A6 >::type a6, \
7021 ::RCF::RemoveOut<A7 >::type a7, \
7022 ::RCF::RemoveOut<A8 >::type a8, \
7023 ::RCF::RemoveOut<A9 >::type a9, \
7024 ::RCF::RemoveOut<A10 >::type a10, \
7025 ::RCF::RemoveOut<A11 >::type a11, \
7026 ::RCF::RemoveOut<A12 >::type a12, \
7027 ::RCF::RemoveOut<A13 >::type a13, \
7028 ::RCF::RemoveOut<A14 >::type a14); \
7029 \
7030 const char * getFunctionName(const id &) \
7031 { \
7032 return #func; \
7033 } \
7034 const char * getArity(const id &) \
7035 { \
7036 return "R14"; \
7037 } \
7038 \
7039 private: \
7040 template<typename T> \
7041 void invoke( \
7042 const id &, \
7043 ::RCF::RcfSession &session, \
7044 T &t) \
7045 { \
7046 if (session.isInProcess()) \
7047 { \
7048 ::RCF::ClientParameters< \
7049 R , \
7050 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14 , V > &p = static_cast<\
7051 ::RCF::ClientParameters< \
7052 R , \
7053 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14 , V > &>(* session.getInProcessParameters());\
7054 p.r.set( t.func( p.a1.get(), \
7055 p.a2.get(), \
7056 p.a3.get(), \
7057 p.a4.get(), \
7058 p.a5.get(), \
7059 p.a6.get(), \
7060 p.a7.get(), \
7061 p.a8.get(), \
7062 p.a9.get(), \
7063 p.a10.get(), \
7064 p.a11.get(), \
7065 p.a12.get(), \
7066 p.a13.get(), \
7067 p.a14.get() ) ); \
7068 } \
7069 else \
7070 { \
7071 ::RCF::ServerParameters< \
7072 R , \
7073 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14 > &p = \
7074 ::RCF::AllocateServerParameters< \
7075 R , \
7076 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14 >()(session);\
7077 p.r.set( \
7078 session.getAutoSend(), \
7079 t.func( \
7080 p.a1.get(), \
7081 p.a2.get(), \
7082 p.a3.get(), \
7083 p.a4.get(), \
7084 p.a5.get(), \
7085 p.a6.get(), \
7086 p.a7.get(), \
7087 p.a8.get(), \
7088 p.a9.get(), \
7089 p.a10.get(), \
7090 p.a11.get(), \
7091 p.a12.get(), \
7092 p.a13.get(), \
7093 p.a14.get())); \
7094 } \
7095 }
7096
7097 // RCF_METHOD_R14_DEF
7098 #define RCF_METHOD_R14_DEF(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14)\
7099 RCF_METHOD_R14_DEF_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14, RCF_PP_CAT(rcf_interface_id_1_, func, R14, __LINE__), RCF_MAKE_UNIQUE_ID(func, R14), RCF_PP_CAT(rcf_interface_id_2_, func, R14, __LINE__))
7100
7101 #define RCF_METHOD_R14_DEF_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14, interfaceId, funcId, genParms)\
7102 RCF_CURRENT_STATIC_ID(interfaceId, RCF_interface_id_helper, int, int) \
7103 typedef GeneratorParms<interfaceId> genParms; \
7104 RCF_ADVANCE_STATIC_ID(funcId, RCF_def_dispatch_id_helper, ::RCF::Dummy<genParms::RcfClientT>, genParms::RcfClientT, static)\
7105 RCF_EXPORT_INTERFACE ::RCF::FutureImpl<R > genParms::RcfClientT::func( \
7106 const ::RCF::CallOptions &callOptions , \
7107 ::RCF::RemoveOut<A1 >::type a1, \
7108 ::RCF::RemoveOut<A2 >::type a2, \
7109 ::RCF::RemoveOut<A3 >::type a3, \
7110 ::RCF::RemoveOut<A4 >::type a4, \
7111 ::RCF::RemoveOut<A5 >::type a5, \
7112 ::RCF::RemoveOut<A6 >::type a6, \
7113 ::RCF::RemoveOut<A7 >::type a7, \
7114 ::RCF::RemoveOut<A8 >::type a8, \
7115 ::RCF::RemoveOut<A9 >::type a9, \
7116 ::RCF::RemoveOut<A10 >::type a10, \
7117 ::RCF::RemoveOut<A11 >::type a11, \
7118 ::RCF::RemoveOut<A12 >::type a12, \
7119 ::RCF::RemoveOut<A13 >::type a13, \
7120 ::RCF::RemoveOut<A14 >::type a14) \
7121 { \
7122 getClientStub().setAsync(false); \
7123 return RCF::FutureImpl<R >( \
7124 ::RCF::AllocateClientParameters< \
7125 R , \
7126 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14 , \
7127 V >()( \
7128 getClientStub() , \
7129 a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14 , \
7130 V()).r.get(), \
7131 getClientStub(), \
7132 mInterfaceName, \
7133 funcId::value, \
7134 callOptions.apply(getClientStub()), \
7135 #func, \
7136 "R14"); \
7137 } \
7138 void genParms::RcfClientT::error__method_defined_out_of_order__##func( \
7139 funcId * , \
7140 ::RCF::RemoveOut<A1 >::type a1, \
7141 ::RCF::RemoveOut<A2 >::type a2, \
7142 ::RCF::RemoveOut<A3 >::type a3, \
7143 ::RCF::RemoveOut<A4 >::type a4, \
7144 ::RCF::RemoveOut<A5 >::type a5, \
7145 ::RCF::RemoveOut<A6 >::type a6, \
7146 ::RCF::RemoveOut<A7 >::type a7, \
7147 ::RCF::RemoveOut<A8 >::type a8, \
7148 ::RCF::RemoveOut<A9 >::type a9, \
7149 ::RCF::RemoveOut<A10 >::type a10, \
7150 ::RCF::RemoveOut<A11 >::type a11, \
7151 ::RCF::RemoveOut<A12 >::type a12, \
7152 ::RCF::RemoveOut<A13 >::type a13, \
7153 ::RCF::RemoveOut<A14 >::type a14) \
7154 { \
7155 }
7156
7157
7158
7159 //------------------------------------------------------------------------------
7160 // Parameters - V14
7161 //------------------------------------------------------------------------------
7162
7163 // RCF_METHOD_V14
7164 #define RCF_METHOD_V14_INLINE(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14)\
7165 RCF_METHOD_V14_INLINE_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14, RCF_MAKE_UNIQUE_ID(func, V14))
7166
7167 #define RCF_METHOD_V14_INLINE_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14, id)\
7168 public: \
7169 BOOST_STATIC_ASSERT(( boost::is_same<R, void>::value )); \
7170 RCF_MAKE_NEXT_DISPATCH_ID(id) \
7171 ::RCF::FutureImpl<V> func( \
7172 ::RCF::RemoveOut<A1 >::type a1, \
7173 ::RCF::RemoveOut<A2 >::type a2, \
7174 ::RCF::RemoveOut<A3 >::type a3, \
7175 ::RCF::RemoveOut<A4 >::type a4, \
7176 ::RCF::RemoveOut<A5 >::type a5, \
7177 ::RCF::RemoveOut<A6 >::type a6, \
7178 ::RCF::RemoveOut<A7 >::type a7, \
7179 ::RCF::RemoveOut<A8 >::type a8, \
7180 ::RCF::RemoveOut<A9 >::type a9, \
7181 ::RCF::RemoveOut<A10 >::type a10, \
7182 ::RCF::RemoveOut<A11 >::type a11, \
7183 ::RCF::RemoveOut<A12 >::type a12, \
7184 ::RCF::RemoveOut<A13 >::type a13, \
7185 ::RCF::RemoveOut<A14 >::type a14) \
7186 { \
7187 return func( \
7188 ::RCF::CallOptions() , \
7189 a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14); \
7190 } \
7191 ::RCF::FutureImpl<V> func( \
7192 const ::RCF::CallOptions &callOptions , \
7193 ::RCF::RemoveOut<A1 >::type a1, \
7194 ::RCF::RemoveOut<A2 >::type a2, \
7195 ::RCF::RemoveOut<A3 >::type a3, \
7196 ::RCF::RemoveOut<A4 >::type a4, \
7197 ::RCF::RemoveOut<A5 >::type a5, \
7198 ::RCF::RemoveOut<A6 >::type a6, \
7199 ::RCF::RemoveOut<A7 >::type a7, \
7200 ::RCF::RemoveOut<A8 >::type a8, \
7201 ::RCF::RemoveOut<A9 >::type a9, \
7202 ::RCF::RemoveOut<A10 >::type a10, \
7203 ::RCF::RemoveOut<A11 >::type a11, \
7204 ::RCF::RemoveOut<A12 >::type a12, \
7205 ::RCF::RemoveOut<A13 >::type a13, \
7206 ::RCF::RemoveOut<A14 >::type a14) \
7207 { \
7208 getClientStub().setAsync(false); \
7209 return RCF::FutureImpl<V>( \
7210 ::RCF::AllocateClientParameters< \
7211 V , \
7212 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14 , \
7213 V >()( \
7214 getClientStub() , \
7215 a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14 , \
7216 V()).r.get(), \
7217 getClientStub(), \
7218 mInterfaceName, \
7219 id::value, \
7220 callOptions.apply(getClientStub()), \
7221 #func, \
7222 "V14"); \
7223 } \
7224 const char * getFunctionName(const id &) \
7225 { \
7226 return #func; \
7227 } \
7228 const char * getArity(const id &) \
7229 { \
7230 return "V14"; \
7231 } \
7232 \
7233 private: \
7234 template<typename T> \
7235 void invoke( \
7236 const id &, \
7237 ::RCF::RcfSession &session, \
7238 T &t) \
7239 { \
7240 if (session.isInProcess()) \
7241 { \
7242 ::RCF::ClientParameters< \
7243 V , \
7244 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14 , V > &p = static_cast<\
7245 ::RCF::ClientParameters< \
7246 V , \
7247 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14 , V > &>(* session.getInProcessParameters());\
7248 RCF_UNUSED_VARIABLE(p); \
7249 t.func( \
7250 p.a1.get(), \
7251 p.a2.get(), \
7252 p.a3.get(), \
7253 p.a4.get(), \
7254 p.a5.get(), \
7255 p.a6.get(), \
7256 p.a7.get(), \
7257 p.a8.get(), \
7258 p.a9.get(), \
7259 p.a10.get(), \
7260 p.a11.get(), \
7261 p.a12.get(), \
7262 p.a13.get(), \
7263 p.a14.get() ); \
7264 } \
7265 else \
7266 { \
7267 ::RCF::ServerParameters< \
7268 V , \
7269 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14 > &p = \
7270 ::RCF::AllocateServerParameters< \
7271 V , \
7272 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14 >()(session);\
7273 RCF_UNUSED_VARIABLE(p); \
7274 t.func( \
7275 p.a1.get(), \
7276 p.a2.get(), \
7277 p.a3.get(), \
7278 p.a4.get(), \
7279 p.a5.get(), \
7280 p.a6.get(), \
7281 p.a7.get(), \
7282 p.a8.get(), \
7283 p.a9.get(), \
7284 p.a10.get(), \
7285 p.a11.get(), \
7286 p.a12.get(), \
7287 p.a13.get(), \
7288 p.a14.get()); \
7289 } \
7290 }
7291
7292 // RCF_METHOD_V14_DECL
7293 #define RCF_METHOD_V14_DECL(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14)\
7294 RCF_METHOD_V14_DECL_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14, RCF_MAKE_UNIQUE_ID(func, V14))
7295
7296 #define RCF_METHOD_V14_DECL_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14, id)\
7297 public: \
7298 BOOST_STATIC_ASSERT(( boost::is_same<R, void>::value )); \
7299 RCF_MAKE_NEXT_DISPATCH_ID(id) \
7300 ::RCF::FutureImpl<V> func( \
7301 ::RCF::RemoveOut<A1 >::type a1, \
7302 ::RCF::RemoveOut<A2 >::type a2, \
7303 ::RCF::RemoveOut<A3 >::type a3, \
7304 ::RCF::RemoveOut<A4 >::type a4, \
7305 ::RCF::RemoveOut<A5 >::type a5, \
7306 ::RCF::RemoveOut<A6 >::type a6, \
7307 ::RCF::RemoveOut<A7 >::type a7, \
7308 ::RCF::RemoveOut<A8 >::type a8, \
7309 ::RCF::RemoveOut<A9 >::type a9, \
7310 ::RCF::RemoveOut<A10 >::type a10, \
7311 ::RCF::RemoveOut<A11 >::type a11, \
7312 ::RCF::RemoveOut<A12 >::type a12, \
7313 ::RCF::RemoveOut<A13 >::type a13, \
7314 ::RCF::RemoveOut<A14 >::type a14) \
7315 { \
7316 return func( \
7317 ::RCF::CallOptions() , \
7318 a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14); \
7319 } \
7320 \
7321 ::RCF::FutureImpl<V> func( \
7322 const ::RCF::CallOptions &callOptions , \
7323 ::RCF::RemoveOut<A1 >::type a1, \
7324 ::RCF::RemoveOut<A2 >::type a2, \
7325 ::RCF::RemoveOut<A3 >::type a3, \
7326 ::RCF::RemoveOut<A4 >::type a4, \
7327 ::RCF::RemoveOut<A5 >::type a5, \
7328 ::RCF::RemoveOut<A6 >::type a6, \
7329 ::RCF::RemoveOut<A7 >::type a7, \
7330 ::RCF::RemoveOut<A8 >::type a8, \
7331 ::RCF::RemoveOut<A9 >::type a9, \
7332 ::RCF::RemoveOut<A10 >::type a10, \
7333 ::RCF::RemoveOut<A11 >::type a11, \
7334 ::RCF::RemoveOut<A12 >::type a12, \
7335 ::RCF::RemoveOut<A13 >::type a13, \
7336 ::RCF::RemoveOut<A14 >::type a14); \
7337 \
7338 void error__method_defined_out_of_order__##func( \
7339 id * , \
7340 ::RCF::RemoveOut<A1 >::type a1, \
7341 ::RCF::RemoveOut<A2 >::type a2, \
7342 ::RCF::RemoveOut<A3 >::type a3, \
7343 ::RCF::RemoveOut<A4 >::type a4, \
7344 ::RCF::RemoveOut<A5 >::type a5, \
7345 ::RCF::RemoveOut<A6 >::type a6, \
7346 ::RCF::RemoveOut<A7 >::type a7, \
7347 ::RCF::RemoveOut<A8 >::type a8, \
7348 ::RCF::RemoveOut<A9 >::type a9, \
7349 ::RCF::RemoveOut<A10 >::type a10, \
7350 ::RCF::RemoveOut<A11 >::type a11, \
7351 ::RCF::RemoveOut<A12 >::type a12, \
7352 ::RCF::RemoveOut<A13 >::type a13, \
7353 ::RCF::RemoveOut<A14 >::type a14); \
7354 \
7355 const char * getFunctionName(const id &) \
7356 { \
7357 return #func; \
7358 } \
7359 const char * getArity(const id &) \
7360 { \
7361 return "V14"; \
7362 } \
7363 \
7364 private: \
7365 template<typename T> \
7366 void invoke( \
7367 const id &, \
7368 ::RCF::RcfSession &session, \
7369 T &t) \
7370 { \
7371 if (session.isInProcess()) \
7372 { \
7373 ::RCF::ClientParameters< \
7374 V , \
7375 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14 , V > &p = static_cast<\
7376 ::RCF::ClientParameters< \
7377 V , \
7378 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14 , V > &>(* session.getInProcessParameters());\
7379 RCF_UNUSED_VARIABLE(p); \
7380 t.func( \
7381 p.a1.get(), \
7382 p.a2.get(), \
7383 p.a3.get(), \
7384 p.a4.get(), \
7385 p.a5.get(), \
7386 p.a6.get(), \
7387 p.a7.get(), \
7388 p.a8.get(), \
7389 p.a9.get(), \
7390 p.a10.get(), \
7391 p.a11.get(), \
7392 p.a12.get(), \
7393 p.a13.get(), \
7394 p.a14.get() ); \
7395 } \
7396 else \
7397 { \
7398 ::RCF::ServerParameters< \
7399 V , \
7400 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14 > &p = \
7401 ::RCF::AllocateServerParameters< \
7402 V , \
7403 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14 >()(session);\
7404 RCF_UNUSED_VARIABLE(p); \
7405 t.func( \
7406 p.a1.get(), \
7407 p.a2.get(), \
7408 p.a3.get(), \
7409 p.a4.get(), \
7410 p.a5.get(), \
7411 p.a6.get(), \
7412 p.a7.get(), \
7413 p.a8.get(), \
7414 p.a9.get(), \
7415 p.a10.get(), \
7416 p.a11.get(), \
7417 p.a12.get(), \
7418 p.a13.get(), \
7419 p.a14.get()); \
7420 } \
7421 }
7422
7423 // RCF_METHOD_V14_DEF
7424 #define RCF_METHOD_V14_DEF(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14)\
7425 RCF_METHOD_V14_DEF_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14, RCF_PP_CAT(rcf_interface_id_1_, func, R14, __LINE__), RCF_MAKE_UNIQUE_ID(func, R14), RCF_PP_CAT(rcf_interface_id_2_, func, R14, __LINE__))
7426
7427 #define RCF_METHOD_V14_DEF_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14, interfaceId, funcId, genParms)\
7428 RCF_CURRENT_STATIC_ID(interfaceId, RCF_interface_id_helper, int, int) \
7429 typedef GeneratorParms<interfaceId> genParms; \
7430 RCF_ADVANCE_STATIC_ID(funcId, RCF_def_dispatch_id_helper, ::RCF::Dummy<genParms::RcfClientT>, genParms::RcfClientT, static)\
7431 RCF_EXPORT_INTERFACE ::RCF::FutureImpl<::RCF::Void> genParms::RcfClientT::func(\
7432 const ::RCF::CallOptions &callOptions , \
7433 ::RCF::RemoveOut<A1 >::type a1, \
7434 ::RCF::RemoveOut<A2 >::type a2, \
7435 ::RCF::RemoveOut<A3 >::type a3, \
7436 ::RCF::RemoveOut<A4 >::type a4, \
7437 ::RCF::RemoveOut<A5 >::type a5, \
7438 ::RCF::RemoveOut<A6 >::type a6, \
7439 ::RCF::RemoveOut<A7 >::type a7, \
7440 ::RCF::RemoveOut<A8 >::type a8, \
7441 ::RCF::RemoveOut<A9 >::type a9, \
7442 ::RCF::RemoveOut<A10 >::type a10, \
7443 ::RCF::RemoveOut<A11 >::type a11, \
7444 ::RCF::RemoveOut<A12 >::type a12, \
7445 ::RCF::RemoveOut<A13 >::type a13, \
7446 ::RCF::RemoveOut<A14 >::type a14) \
7447 { \
7448 typedef ::RCF::Void V; \
7449 getClientStub().setAsync(false); \
7450 return RCF::FutureImpl<V >( \
7451 ::RCF::AllocateClientParameters< \
7452 V , \
7453 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14 , \
7454 V >()( \
7455 getClientStub() , \
7456 a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14 , \
7457 V()).r.get(), \
7458 getClientStub(), \
7459 mInterfaceName, \
7460 funcId::value, \
7461 callOptions.apply(getClientStub()), \
7462 #func, \
7463 "V14"); \
7464 } \
7465 void genParms::RcfClientT::error__method_defined_out_of_order__##func( \
7466 funcId * , \
7467 ::RCF::RemoveOut<A1 >::type a1, \
7468 ::RCF::RemoveOut<A2 >::type a2, \
7469 ::RCF::RemoveOut<A3 >::type a3, \
7470 ::RCF::RemoveOut<A4 >::type a4, \
7471 ::RCF::RemoveOut<A5 >::type a5, \
7472 ::RCF::RemoveOut<A6 >::type a6, \
7473 ::RCF::RemoveOut<A7 >::type a7, \
7474 ::RCF::RemoveOut<A8 >::type a8, \
7475 ::RCF::RemoveOut<A9 >::type a9, \
7476 ::RCF::RemoveOut<A10 >::type a10, \
7477 ::RCF::RemoveOut<A11 >::type a11, \
7478 ::RCF::RemoveOut<A12 >::type a12, \
7479 ::RCF::RemoveOut<A13 >::type a13, \
7480 ::RCF::RemoveOut<A14 >::type a14) \
7481 { \
7482 }
7483
7484
7485
7486
7487 //------------------------------------------------------------------------------
7488 // Parameters - R15
7489 //------------------------------------------------------------------------------
7490
7491 // RCF_METHOD_R15
7492 #define RCF_METHOD_R15_INLINE(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15)\
7493 RCF_METHOD_R15_INLINE_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15, RCF_MAKE_UNIQUE_ID(func, R15))
7494
7495 #define RCF_METHOD_R15_INLINE_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15, id)\
7496 public: \
7497 RCF_MAKE_NEXT_DISPATCH_ID(id) \
7498 ::RCF::FutureImpl<R > func( \
7499 ::RCF::RemoveOut<A1 >::type a1, \
7500 ::RCF::RemoveOut<A2 >::type a2, \
7501 ::RCF::RemoveOut<A3 >::type a3, \
7502 ::RCF::RemoveOut<A4 >::type a4, \
7503 ::RCF::RemoveOut<A5 >::type a5, \
7504 ::RCF::RemoveOut<A6 >::type a6, \
7505 ::RCF::RemoveOut<A7 >::type a7, \
7506 ::RCF::RemoveOut<A8 >::type a8, \
7507 ::RCF::RemoveOut<A9 >::type a9, \
7508 ::RCF::RemoveOut<A10 >::type a10, \
7509 ::RCF::RemoveOut<A11 >::type a11, \
7510 ::RCF::RemoveOut<A12 >::type a12, \
7511 ::RCF::RemoveOut<A13 >::type a13, \
7512 ::RCF::RemoveOut<A14 >::type a14, \
7513 ::RCF::RemoveOut<A15 >::type a15) \
7514 { \
7515 return func( \
7516 ::RCF::CallOptions() , \
7517 a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15); \
7518 } \
7519 ::RCF::FutureImpl<R > func( \
7520 const ::RCF::CallOptions &callOptions , \
7521 ::RCF::RemoveOut<A1 >::type a1, \
7522 ::RCF::RemoveOut<A2 >::type a2, \
7523 ::RCF::RemoveOut<A3 >::type a3, \
7524 ::RCF::RemoveOut<A4 >::type a4, \
7525 ::RCF::RemoveOut<A5 >::type a5, \
7526 ::RCF::RemoveOut<A6 >::type a6, \
7527 ::RCF::RemoveOut<A7 >::type a7, \
7528 ::RCF::RemoveOut<A8 >::type a8, \
7529 ::RCF::RemoveOut<A9 >::type a9, \
7530 ::RCF::RemoveOut<A10 >::type a10, \
7531 ::RCF::RemoveOut<A11 >::type a11, \
7532 ::RCF::RemoveOut<A12 >::type a12, \
7533 ::RCF::RemoveOut<A13 >::type a13, \
7534 ::RCF::RemoveOut<A14 >::type a14, \
7535 ::RCF::RemoveOut<A15 >::type a15) \
7536 { \
7537 getClientStub().setAsync(false); \
7538 return RCF::FutureImpl<R >( \
7539 ::RCF::AllocateClientParameters< \
7540 R , \
7541 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15 \
7542 >()( \
7543 getClientStub() , \
7544 a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15 \
7545 ).r.get(), \
7546 getClientStub(), \
7547 mInterfaceName, \
7548 id::value, \
7549 callOptions.apply(getClientStub()), \
7550 #func, \
7551 "R15"); \
7552 } \
7553 const char * getFunctionName(const id &) \
7554 { \
7555 return #func; \
7556 } \
7557 const char * getArity(const id &) \
7558 { \
7559 return "R15"; \
7560 } \
7561 \
7562 private: \
7563 template<typename T> \
7564 void invoke( \
7565 const id &, \
7566 ::RCF::RcfSession &session, \
7567 T &t) \
7568 { \
7569 if (session.isInProcess()) \
7570 { \
7571 ::RCF::ClientParameters< \
7572 R , \
7573 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15 > &p = static_cast<\
7574 ::RCF::ClientParameters< \
7575 R , \
7576 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15 > &>(* session.getInProcessParameters());\
7577 p.r.set( t.func( p.a1.get(), \
7578 p.a2.get(), \
7579 p.a3.get(), \
7580 p.a4.get(), \
7581 p.a5.get(), \
7582 p.a6.get(), \
7583 p.a7.get(), \
7584 p.a8.get(), \
7585 p.a9.get(), \
7586 p.a10.get(), \
7587 p.a11.get(), \
7588 p.a12.get(), \
7589 p.a13.get(), \
7590 p.a14.get(), \
7591 p.a15.get() ) ); \
7592 } \
7593 else \
7594 { \
7595 ::RCF::ServerParameters< \
7596 R , \
7597 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15 > &p =\
7598 ::RCF::AllocateServerParameters< \
7599 R , \
7600 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15 >()(session);\
7601 p.r.set( \
7602 session.getAutoSend(), \
7603 t.func( \
7604 p.a1.get(), \
7605 p.a2.get(), \
7606 p.a3.get(), \
7607 p.a4.get(), \
7608 p.a5.get(), \
7609 p.a6.get(), \
7610 p.a7.get(), \
7611 p.a8.get(), \
7612 p.a9.get(), \
7613 p.a10.get(), \
7614 p.a11.get(), \
7615 p.a12.get(), \
7616 p.a13.get(), \
7617 p.a14.get(), \
7618 p.a15.get())); \
7619 } \
7620 }
7621
7622 // RCF_METHOD_R15_DECL
7623 #define RCF_METHOD_R15_DECL(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15)\
7624 RCF_METHOD_R15_DECL_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15, RCF_MAKE_UNIQUE_ID(func, R15))
7625
7626 #define RCF_METHOD_R15_DECL_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15, id)\
7627 public: \
7628 RCF_MAKE_NEXT_DISPATCH_ID(id) \
7629 ::RCF::FutureImpl<R > func( \
7630 ::RCF::RemoveOut<A1 >::type a1, \
7631 ::RCF::RemoveOut<A2 >::type a2, \
7632 ::RCF::RemoveOut<A3 >::type a3, \
7633 ::RCF::RemoveOut<A4 >::type a4, \
7634 ::RCF::RemoveOut<A5 >::type a5, \
7635 ::RCF::RemoveOut<A6 >::type a6, \
7636 ::RCF::RemoveOut<A7 >::type a7, \
7637 ::RCF::RemoveOut<A8 >::type a8, \
7638 ::RCF::RemoveOut<A9 >::type a9, \
7639 ::RCF::RemoveOut<A10 >::type a10, \
7640 ::RCF::RemoveOut<A11 >::type a11, \
7641 ::RCF::RemoveOut<A12 >::type a12, \
7642 ::RCF::RemoveOut<A13 >::type a13, \
7643 ::RCF::RemoveOut<A14 >::type a14, \
7644 ::RCF::RemoveOut<A15 >::type a15) \
7645 { \
7646 return func( \
7647 ::RCF::CallOptions() , \
7648 a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15); \
7649 } \
7650 \
7651 ::RCF::FutureImpl<R > func( \
7652 const ::RCF::CallOptions &callOptions , \
7653 ::RCF::RemoveOut<A1 >::type a1, \
7654 ::RCF::RemoveOut<A2 >::type a2, \
7655 ::RCF::RemoveOut<A3 >::type a3, \
7656 ::RCF::RemoveOut<A4 >::type a4, \
7657 ::RCF::RemoveOut<A5 >::type a5, \
7658 ::RCF::RemoveOut<A6 >::type a6, \
7659 ::RCF::RemoveOut<A7 >::type a7, \
7660 ::RCF::RemoveOut<A8 >::type a8, \
7661 ::RCF::RemoveOut<A9 >::type a9, \
7662 ::RCF::RemoveOut<A10 >::type a10, \
7663 ::RCF::RemoveOut<A11 >::type a11, \
7664 ::RCF::RemoveOut<A12 >::type a12, \
7665 ::RCF::RemoveOut<A13 >::type a13, \
7666 ::RCF::RemoveOut<A14 >::type a14, \
7667 ::RCF::RemoveOut<A15 >::type a15); \
7668 \
7669 void error__method_defined_out_of_order__##func( \
7670 id * , \
7671 ::RCF::RemoveOut<A1 >::type a1, \
7672 ::RCF::RemoveOut<A2 >::type a2, \
7673 ::RCF::RemoveOut<A3 >::type a3, \
7674 ::RCF::RemoveOut<A4 >::type a4, \
7675 ::RCF::RemoveOut<A5 >::type a5, \
7676 ::RCF::RemoveOut<A6 >::type a6, \
7677 ::RCF::RemoveOut<A7 >::type a7, \
7678 ::RCF::RemoveOut<A8 >::type a8, \
7679 ::RCF::RemoveOut<A9 >::type a9, \
7680 ::RCF::RemoveOut<A10 >::type a10, \
7681 ::RCF::RemoveOut<A11 >::type a11, \
7682 ::RCF::RemoveOut<A12 >::type a12, \
7683 ::RCF::RemoveOut<A13 >::type a13, \
7684 ::RCF::RemoveOut<A14 >::type a14, \
7685 ::RCF::RemoveOut<A15 >::type a15); \
7686 \
7687 const char * getFunctionName(const id &) \
7688 { \
7689 return #func; \
7690 } \
7691 const char * getArity(const id &) \
7692 { \
7693 return "R15"; \
7694 } \
7695 \
7696 private: \
7697 template<typename T> \
7698 void invoke( \
7699 const id &, \
7700 ::RCF::RcfSession &session, \
7701 T &t) \
7702 { \
7703 if (session.isInProcess()) \
7704 { \
7705 ::RCF::ClientParameters< \
7706 R , \
7707 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15 > &p = static_cast<\
7708 ::RCF::ClientParameters< \
7709 R , \
7710 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15 > &>(* session.getInProcessParameters());\
7711 p.r.set( t.func( p.a1.get(), \
7712 p.a2.get(), \
7713 p.a3.get(), \
7714 p.a4.get(), \
7715 p.a5.get(), \
7716 p.a6.get(), \
7717 p.a7.get(), \
7718 p.a8.get(), \
7719 p.a9.get(), \
7720 p.a10.get(), \
7721 p.a11.get(), \
7722 p.a12.get(), \
7723 p.a13.get(), \
7724 p.a14.get(), \
7725 p.a15.get() ) ); \
7726 } \
7727 else \
7728 { \
7729 ::RCF::ServerParameters< \
7730 R , \
7731 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15 > &p =\
7732 ::RCF::AllocateServerParameters< \
7733 R , \
7734 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15 >()(session);\
7735 p.r.set( \
7736 session.getAutoSend(), \
7737 t.func( \
7738 p.a1.get(), \
7739 p.a2.get(), \
7740 p.a3.get(), \
7741 p.a4.get(), \
7742 p.a5.get(), \
7743 p.a6.get(), \
7744 p.a7.get(), \
7745 p.a8.get(), \
7746 p.a9.get(), \
7747 p.a10.get(), \
7748 p.a11.get(), \
7749 p.a12.get(), \
7750 p.a13.get(), \
7751 p.a14.get(), \
7752 p.a15.get())); \
7753 } \
7754 }
7755
7756 // RCF_METHOD_R15_DEF
7757 #define RCF_METHOD_R15_DEF(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15)\
7758 RCF_METHOD_R15_DEF_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15, RCF_PP_CAT(rcf_interface_id_1_, func, R15, __LINE__), RCF_MAKE_UNIQUE_ID(func, R15), RCF_PP_CAT(rcf_interface_id_2_, func, R15, __LINE__))
7759
7760 #define RCF_METHOD_R15_DEF_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15, interfaceId, funcId, genParms)\
7761 RCF_CURRENT_STATIC_ID(interfaceId, RCF_interface_id_helper, int, int) \
7762 typedef GeneratorParms<interfaceId> genParms; \
7763 RCF_ADVANCE_STATIC_ID(funcId, RCF_def_dispatch_id_helper, ::RCF::Dummy<genParms::RcfClientT>, genParms::RcfClientT, static)\
7764 RCF_EXPORT_INTERFACE ::RCF::FutureImpl<R > genParms::RcfClientT::func( \
7765 const ::RCF::CallOptions &callOptions , \
7766 ::RCF::RemoveOut<A1 >::type a1, \
7767 ::RCF::RemoveOut<A2 >::type a2, \
7768 ::RCF::RemoveOut<A3 >::type a3, \
7769 ::RCF::RemoveOut<A4 >::type a4, \
7770 ::RCF::RemoveOut<A5 >::type a5, \
7771 ::RCF::RemoveOut<A6 >::type a6, \
7772 ::RCF::RemoveOut<A7 >::type a7, \
7773 ::RCF::RemoveOut<A8 >::type a8, \
7774 ::RCF::RemoveOut<A9 >::type a9, \
7775 ::RCF::RemoveOut<A10 >::type a10, \
7776 ::RCF::RemoveOut<A11 >::type a11, \
7777 ::RCF::RemoveOut<A12 >::type a12, \
7778 ::RCF::RemoveOut<A13 >::type a13, \
7779 ::RCF::RemoveOut<A14 >::type a14, \
7780 ::RCF::RemoveOut<A15 >::type a15) \
7781 { \
7782 getClientStub().setAsync(false); \
7783 return RCF::FutureImpl<R >( \
7784 ::RCF::AllocateClientParameters< \
7785 R , \
7786 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15 \
7787 >()( \
7788 getClientStub() , \
7789 a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15 \
7790 ).r.get(), \
7791 getClientStub(), \
7792 mInterfaceName, \
7793 funcId::value, \
7794 callOptions.apply(getClientStub()), \
7795 #func, \
7796 "R15"); \
7797 } \
7798 void genParms::RcfClientT::error__method_defined_out_of_order__##func( \
7799 funcId * , \
7800 ::RCF::RemoveOut<A1 >::type a1, \
7801 ::RCF::RemoveOut<A2 >::type a2, \
7802 ::RCF::RemoveOut<A3 >::type a3, \
7803 ::RCF::RemoveOut<A4 >::type a4, \
7804 ::RCF::RemoveOut<A5 >::type a5, \
7805 ::RCF::RemoveOut<A6 >::type a6, \
7806 ::RCF::RemoveOut<A7 >::type a7, \
7807 ::RCF::RemoveOut<A8 >::type a8, \
7808 ::RCF::RemoveOut<A9 >::type a9, \
7809 ::RCF::RemoveOut<A10 >::type a10, \
7810 ::RCF::RemoveOut<A11 >::type a11, \
7811 ::RCF::RemoveOut<A12 >::type a12, \
7812 ::RCF::RemoveOut<A13 >::type a13, \
7813 ::RCF::RemoveOut<A14 >::type a14, \
7814 ::RCF::RemoveOut<A15 >::type a15) \
7815 { \
7816 }
7817
7818
7819
7820 //------------------------------------------------------------------------------
7821 // Parameters - V15
7822 //------------------------------------------------------------------------------
7823
7824 // RCF_METHOD_V15
7825 #define RCF_METHOD_V15_INLINE(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15)\
7826 RCF_METHOD_V15_INLINE_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15, RCF_MAKE_UNIQUE_ID(func, V15))
7827
7828 #define RCF_METHOD_V15_INLINE_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15, id)\
7829 public: \
7830 BOOST_STATIC_ASSERT(( boost::is_same<R, void>::value )); \
7831 RCF_MAKE_NEXT_DISPATCH_ID(id) \
7832 ::RCF::FutureImpl<V> func( \
7833 ::RCF::RemoveOut<A1 >::type a1, \
7834 ::RCF::RemoveOut<A2 >::type a2, \
7835 ::RCF::RemoveOut<A3 >::type a3, \
7836 ::RCF::RemoveOut<A4 >::type a4, \
7837 ::RCF::RemoveOut<A5 >::type a5, \
7838 ::RCF::RemoveOut<A6 >::type a6, \
7839 ::RCF::RemoveOut<A7 >::type a7, \
7840 ::RCF::RemoveOut<A8 >::type a8, \
7841 ::RCF::RemoveOut<A9 >::type a9, \
7842 ::RCF::RemoveOut<A10 >::type a10, \
7843 ::RCF::RemoveOut<A11 >::type a11, \
7844 ::RCF::RemoveOut<A12 >::type a12, \
7845 ::RCF::RemoveOut<A13 >::type a13, \
7846 ::RCF::RemoveOut<A14 >::type a14, \
7847 ::RCF::RemoveOut<A15 >::type a15) \
7848 { \
7849 return func( \
7850 ::RCF::CallOptions() , \
7851 a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15); \
7852 } \
7853 ::RCF::FutureImpl<V> func( \
7854 const ::RCF::CallOptions &callOptions , \
7855 ::RCF::RemoveOut<A1 >::type a1, \
7856 ::RCF::RemoveOut<A2 >::type a2, \
7857 ::RCF::RemoveOut<A3 >::type a3, \
7858 ::RCF::RemoveOut<A4 >::type a4, \
7859 ::RCF::RemoveOut<A5 >::type a5, \
7860 ::RCF::RemoveOut<A6 >::type a6, \
7861 ::RCF::RemoveOut<A7 >::type a7, \
7862 ::RCF::RemoveOut<A8 >::type a8, \
7863 ::RCF::RemoveOut<A9 >::type a9, \
7864 ::RCF::RemoveOut<A10 >::type a10, \
7865 ::RCF::RemoveOut<A11 >::type a11, \
7866 ::RCF::RemoveOut<A12 >::type a12, \
7867 ::RCF::RemoveOut<A13 >::type a13, \
7868 ::RCF::RemoveOut<A14 >::type a14, \
7869 ::RCF::RemoveOut<A15 >::type a15) \
7870 { \
7871 getClientStub().setAsync(false); \
7872 return RCF::FutureImpl<V>( \
7873 ::RCF::AllocateClientParameters< \
7874 V , \
7875 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15 \
7876 >()( \
7877 getClientStub() , \
7878 a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15 \
7879 ).r.get(), \
7880 getClientStub(), \
7881 mInterfaceName, \
7882 id::value, \
7883 callOptions.apply(getClientStub()), \
7884 #func, \
7885 "V15"); \
7886 } \
7887 const char * getFunctionName(const id &) \
7888 { \
7889 return #func; \
7890 } \
7891 const char * getArity(const id &) \
7892 { \
7893 return "V15"; \
7894 } \
7895 \
7896 private: \
7897 template<typename T> \
7898 void invoke( \
7899 const id &, \
7900 ::RCF::RcfSession &session, \
7901 T &t) \
7902 { \
7903 if (session.isInProcess()) \
7904 { \
7905 ::RCF::ClientParameters< \
7906 V , \
7907 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15 > &p = static_cast<\
7908 ::RCF::ClientParameters< \
7909 V , \
7910 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15 > &>(* session.getInProcessParameters());\
7911 RCF_UNUSED_VARIABLE(p); \
7912 t.func( \
7913 p.a1.get(), \
7914 p.a2.get(), \
7915 p.a3.get(), \
7916 p.a4.get(), \
7917 p.a5.get(), \
7918 p.a6.get(), \
7919 p.a7.get(), \
7920 p.a8.get(), \
7921 p.a9.get(), \
7922 p.a10.get(), \
7923 p.a11.get(), \
7924 p.a12.get(), \
7925 p.a13.get(), \
7926 p.a14.get(), \
7927 p.a15.get() ); \
7928 } \
7929 else \
7930 { \
7931 ::RCF::ServerParameters< \
7932 V , \
7933 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15 > &p =\
7934 ::RCF::AllocateServerParameters< \
7935 V , \
7936 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15 >()(session);\
7937 RCF_UNUSED_VARIABLE(p); \
7938 t.func( \
7939 p.a1.get(), \
7940 p.a2.get(), \
7941 p.a3.get(), \
7942 p.a4.get(), \
7943 p.a5.get(), \
7944 p.a6.get(), \
7945 p.a7.get(), \
7946 p.a8.get(), \
7947 p.a9.get(), \
7948 p.a10.get(), \
7949 p.a11.get(), \
7950 p.a12.get(), \
7951 p.a13.get(), \
7952 p.a14.get(), \
7953 p.a15.get()); \
7954 } \
7955 }
7956
7957 // RCF_METHOD_V15_DECL
7958 #define RCF_METHOD_V15_DECL(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15)\
7959 RCF_METHOD_V15_DECL_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15, RCF_MAKE_UNIQUE_ID(func, V15))
7960
7961 #define RCF_METHOD_V15_DECL_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15, id)\
7962 public: \
7963 BOOST_STATIC_ASSERT(( boost::is_same<R, void>::value )); \
7964 RCF_MAKE_NEXT_DISPATCH_ID(id) \
7965 ::RCF::FutureImpl<V> func( \
7966 ::RCF::RemoveOut<A1 >::type a1, \
7967 ::RCF::RemoveOut<A2 >::type a2, \
7968 ::RCF::RemoveOut<A3 >::type a3, \
7969 ::RCF::RemoveOut<A4 >::type a4, \
7970 ::RCF::RemoveOut<A5 >::type a5, \
7971 ::RCF::RemoveOut<A6 >::type a6, \
7972 ::RCF::RemoveOut<A7 >::type a7, \
7973 ::RCF::RemoveOut<A8 >::type a8, \
7974 ::RCF::RemoveOut<A9 >::type a9, \
7975 ::RCF::RemoveOut<A10 >::type a10, \
7976 ::RCF::RemoveOut<A11 >::type a11, \
7977 ::RCF::RemoveOut<A12 >::type a12, \
7978 ::RCF::RemoveOut<A13 >::type a13, \
7979 ::RCF::RemoveOut<A14 >::type a14, \
7980 ::RCF::RemoveOut<A15 >::type a15) \
7981 { \
7982 return func( \
7983 ::RCF::CallOptions() , \
7984 a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15); \
7985 } \
7986 \
7987 ::RCF::FutureImpl<V> func( \
7988 const ::RCF::CallOptions &callOptions , \
7989 ::RCF::RemoveOut<A1 >::type a1, \
7990 ::RCF::RemoveOut<A2 >::type a2, \
7991 ::RCF::RemoveOut<A3 >::type a3, \
7992 ::RCF::RemoveOut<A4 >::type a4, \
7993 ::RCF::RemoveOut<A5 >::type a5, \
7994 ::RCF::RemoveOut<A6 >::type a6, \
7995 ::RCF::RemoveOut<A7 >::type a7, \
7996 ::RCF::RemoveOut<A8 >::type a8, \
7997 ::RCF::RemoveOut<A9 >::type a9, \
7998 ::RCF::RemoveOut<A10 >::type a10, \
7999 ::RCF::RemoveOut<A11 >::type a11, \
8000 ::RCF::RemoveOut<A12 >::type a12, \
8001 ::RCF::RemoveOut<A13 >::type a13, \
8002 ::RCF::RemoveOut<A14 >::type a14, \
8003 ::RCF::RemoveOut<A15 >::type a15); \
8004 \
8005 void error__method_defined_out_of_order__##func( \
8006 id * , \
8007 ::RCF::RemoveOut<A1 >::type a1, \
8008 ::RCF::RemoveOut<A2 >::type a2, \
8009 ::RCF::RemoveOut<A3 >::type a3, \
8010 ::RCF::RemoveOut<A4 >::type a4, \
8011 ::RCF::RemoveOut<A5 >::type a5, \
8012 ::RCF::RemoveOut<A6 >::type a6, \
8013 ::RCF::RemoveOut<A7 >::type a7, \
8014 ::RCF::RemoveOut<A8 >::type a8, \
8015 ::RCF::RemoveOut<A9 >::type a9, \
8016 ::RCF::RemoveOut<A10 >::type a10, \
8017 ::RCF::RemoveOut<A11 >::type a11, \
8018 ::RCF::RemoveOut<A12 >::type a12, \
8019 ::RCF::RemoveOut<A13 >::type a13, \
8020 ::RCF::RemoveOut<A14 >::type a14, \
8021 ::RCF::RemoveOut<A15 >::type a15); \
8022 \
8023 const char * getFunctionName(const id &) \
8024 { \
8025 return #func; \
8026 } \
8027 const char * getArity(const id &) \
8028 { \
8029 return "V15"; \
8030 } \
8031 \
8032 private: \
8033 template<typename T> \
8034 void invoke( \
8035 const id &, \
8036 ::RCF::RcfSession &session, \
8037 T &t) \
8038 { \
8039 if (session.isInProcess()) \
8040 { \
8041 ::RCF::ClientParameters< \
8042 V , \
8043 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15 > &p = static_cast<\
8044 ::RCF::ClientParameters< \
8045 V , \
8046 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15 > &>(* session.getInProcessParameters());\
8047 RCF_UNUSED_VARIABLE(p); \
8048 t.func( \
8049 p.a1.get(), \
8050 p.a2.get(), \
8051 p.a3.get(), \
8052 p.a4.get(), \
8053 p.a5.get(), \
8054 p.a6.get(), \
8055 p.a7.get(), \
8056 p.a8.get(), \
8057 p.a9.get(), \
8058 p.a10.get(), \
8059 p.a11.get(), \
8060 p.a12.get(), \
8061 p.a13.get(), \
8062 p.a14.get(), \
8063 p.a15.get() ); \
8064 } \
8065 else \
8066 { \
8067 ::RCF::ServerParameters< \
8068 V , \
8069 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15 > &p =\
8070 ::RCF::AllocateServerParameters< \
8071 V , \
8072 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15 >()(session);\
8073 RCF_UNUSED_VARIABLE(p); \
8074 t.func( \
8075 p.a1.get(), \
8076 p.a2.get(), \
8077 p.a3.get(), \
8078 p.a4.get(), \
8079 p.a5.get(), \
8080 p.a6.get(), \
8081 p.a7.get(), \
8082 p.a8.get(), \
8083 p.a9.get(), \
8084 p.a10.get(), \
8085 p.a11.get(), \
8086 p.a12.get(), \
8087 p.a13.get(), \
8088 p.a14.get(), \
8089 p.a15.get()); \
8090 } \
8091 }
8092
8093 // RCF_METHOD_V15_DEF
8094 #define RCF_METHOD_V15_DEF(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15)\
8095 RCF_METHOD_V15_DEF_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15, RCF_PP_CAT(rcf_interface_id_1_, func, R15, __LINE__), RCF_MAKE_UNIQUE_ID(func, R15), RCF_PP_CAT(rcf_interface_id_2_, func, R15, __LINE__))
8096
8097 #define RCF_METHOD_V15_DEF_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15, interfaceId, funcId, genParms)\
8098 RCF_CURRENT_STATIC_ID(interfaceId, RCF_interface_id_helper, int, int) \
8099 typedef GeneratorParms<interfaceId> genParms; \
8100 RCF_ADVANCE_STATIC_ID(funcId, RCF_def_dispatch_id_helper, ::RCF::Dummy<genParms::RcfClientT>, genParms::RcfClientT, static)\
8101 RCF_EXPORT_INTERFACE ::RCF::FutureImpl<::RCF::Void> genParms::RcfClientT::func(\
8102 const ::RCF::CallOptions &callOptions , \
8103 ::RCF::RemoveOut<A1 >::type a1, \
8104 ::RCF::RemoveOut<A2 >::type a2, \
8105 ::RCF::RemoveOut<A3 >::type a3, \
8106 ::RCF::RemoveOut<A4 >::type a4, \
8107 ::RCF::RemoveOut<A5 >::type a5, \
8108 ::RCF::RemoveOut<A6 >::type a6, \
8109 ::RCF::RemoveOut<A7 >::type a7, \
8110 ::RCF::RemoveOut<A8 >::type a8, \
8111 ::RCF::RemoveOut<A9 >::type a9, \
8112 ::RCF::RemoveOut<A10 >::type a10, \
8113 ::RCF::RemoveOut<A11 >::type a11, \
8114 ::RCF::RemoveOut<A12 >::type a12, \
8115 ::RCF::RemoveOut<A13 >::type a13, \
8116 ::RCF::RemoveOut<A14 >::type a14, \
8117 ::RCF::RemoveOut<A15 >::type a15) \
8118 { \
8119 typedef ::RCF::Void V; \
8120 getClientStub().setAsync(false); \
8121 return RCF::FutureImpl<V >( \
8122 ::RCF::AllocateClientParameters< \
8123 V , \
8124 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15 \
8125 >()( \
8126 getClientStub() , \
8127 a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15 \
8128 ).r.get(), \
8129 getClientStub(), \
8130 mInterfaceName, \
8131 funcId::value, \
8132 callOptions.apply(getClientStub()), \
8133 #func, \
8134 "V15"); \
8135 } \
8136 void genParms::RcfClientT::error__method_defined_out_of_order__##func( \
8137 funcId * , \
8138 ::RCF::RemoveOut<A1 >::type a1, \
8139 ::RCF::RemoveOut<A2 >::type a2, \
8140 ::RCF::RemoveOut<A3 >::type a3, \
8141 ::RCF::RemoveOut<A4 >::type a4, \
8142 ::RCF::RemoveOut<A5 >::type a5, \
8143 ::RCF::RemoveOut<A6 >::type a6, \
8144 ::RCF::RemoveOut<A7 >::type a7, \
8145 ::RCF::RemoveOut<A8 >::type a8, \
8146 ::RCF::RemoveOut<A9 >::type a9, \
8147 ::RCF::RemoveOut<A10 >::type a10, \
8148 ::RCF::RemoveOut<A11 >::type a11, \
8149 ::RCF::RemoveOut<A12 >::type a12, \
8150 ::RCF::RemoveOut<A13 >::type a13, \
8151 ::RCF::RemoveOut<A14 >::type a14, \
8152 ::RCF::RemoveOut<A15 >::type a15) \
8153 { \
8154 }
8155
8156 #endif // ! INCLUDE_RCF_RCFMETHODGEN_HPP