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