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