Remote Call Framework 3.0
RcfMethodGen.hpp
1 
2 //******************************************************************************
3 // RCF - Remote Call Framework
4 //
5 // Copyright (c) 2005 - 2018, 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: 3.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(R,func ) \
31  RCF_METHOD_R0_(R,func , RCF_MAKE_UNIQUE_ID(func, R0))
32 
33 #define RCF_METHOD_R0_(R,func , id) \
34  public: \
35  RCF_MAKE_NEXT_DISPATCH_ID(id) \
36  ::RCF::FutureConverter<R > func( \
37  ) \
38  { \
39  return func( \
40  ::RCF::CallOptions() \
41  ); \
42  } \
43  ::RCF::FutureConverter<R > func( \
44  const ::RCF::CallOptions &callOptions \
45  ) \
46  { \
47  getClientStub().setAsync(false); \
48  return RCF::FutureConverter<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  id::value, \
58  callOptions.apply(getClientStub()), \
59  #func, \
60  "R0"); \
61  } \
62  const char * getFunctionName(const id &) \
63  { \
64  return #func; \
65  } \
66  const char * getArity(const id &) \
67  { \
68  return "R0"; \
69  } \
70  \
71  private: \
72  template<typename T> \
73  void callMethod( \
74  const id &, \
75  ::RCF::RcfSession &session, \
76  T &t) \
77  { \
78  ::RCF::ServerParameters< \
79  R \
80  > &p = \
81  ::RCF::AllocateServerParameters< \
82  R \
83  >()(session); \
84  p.r.set( \
85  session.getAutoSend(), \
86  t.func( \
87  )); \
88  }
89 
90 
91 
92 
93 //------------------------------------------------------------------------------
94 // Parameters - V0
95 //------------------------------------------------------------------------------
96 
97 // RCF_METHOD_V0
98 #define RCF_METHOD_V0(R,func ) \
99  RCF_METHOD_V0_(R,func , RCF_MAKE_UNIQUE_ID(func, V0))
100 
101 #define RCF_METHOD_V0_(R,func , id) \
102  public: \
103  static_assert( std::is_same<R, void>::value, "RCF_METHOD_Vn() must be used for methods returning void." );\
104  RCF_MAKE_NEXT_DISPATCH_ID(id) \
105  ::RCF::FutureConverter<V> func( \
106  ) \
107  { \
108  return func( \
109  ::RCF::CallOptions() \
110  ); \
111  } \
112  ::RCF::FutureConverter<V> func( \
113  const ::RCF::CallOptions &callOptions \
114  ) \
115  { \
116  getClientStub().setAsync(false); \
117  return RCF::FutureConverter<V>( \
118  ::RCF::AllocateClientParameters< \
119  V \
120  , \
121  V,V,V,V,V,V,V,V,V,V,V,V,V,V,V >()( \
122  getClientStub() \
123  , \
124  V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V()).r.get(),\
125  getClientStub(), \
126  id::value, \
127  callOptions.apply(getClientStub()), \
128  #func, \
129  "V0"); \
130  } \
131  const char * getFunctionName(const id &) \
132  { \
133  return #func; \
134  } \
135  const char * getArity(const id &) \
136  { \
137  return "V0"; \
138  } \
139  \
140  private: \
141  template<typename T> \
142  void callMethod( \
143  const id &, \
144  ::RCF::RcfSession &session, \
145  T &t) \
146  { \
147  ::RCF::ServerParameters< \
148  V \
149  > &p = \
150  ::RCF::AllocateServerParameters< \
151  V \
152  >()(session); \
153  RCF_UNUSED_VARIABLE(p); \
154  t.func( \
155  ); \
156  }
157 
158 
159 
160 
161 //------------------------------------------------------------------------------
162 // Parameters - R1
163 //------------------------------------------------------------------------------
164 
165 // RCF_METHOD_R1
166 #define RCF_METHOD_R1(R,func , A1) \
167  RCF_METHOD_R1_(R,func , A1, RCF_MAKE_UNIQUE_ID(func, R1))
168 
169 #define RCF_METHOD_R1_(R,func , A1, id) \
170  public: \
171  RCF_MAKE_NEXT_DISPATCH_ID(id) \
172  ::RCF::FutureConverter<R > func( \
173  ::RCF::RemoveOut<A1 >::type a1) \
174  { \
175  return func( \
176  ::RCF::CallOptions() , \
177  a1); \
178  } \
179  ::RCF::FutureConverter<R > func( \
180  const ::RCF::CallOptions &callOptions , \
181  ::RCF::RemoveOut<A1 >::type a1) \
182  { \
183  getClientStub().setAsync(false); \
184  return RCF::FutureConverter<R >( \
185  ::RCF::AllocateClientParameters< \
186  R , \
187  A1 , \
188  V,V,V,V,V,V,V,V,V,V,V,V,V,V >()( \
189  getClientStub() , \
190  a1 , \
191  V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V()).r.get(),\
192  getClientStub(), \
193  id::value, \
194  callOptions.apply(getClientStub()), \
195  #func, \
196  "R1"); \
197  } \
198  const char * getFunctionName(const id &) \
199  { \
200  return #func; \
201  } \
202  const char * getArity(const id &) \
203  { \
204  return "R1"; \
205  } \
206  \
207  private: \
208  template<typename T> \
209  void callMethod( \
210  const id &, \
211  ::RCF::RcfSession &session, \
212  T &t) \
213  { \
214  ::RCF::ServerParameters< \
215  R , \
216  A1 > &p = \
217  ::RCF::AllocateServerParameters< \
218  R , \
219  A1 >()(session); \
220  p.r.set( \
221  session.getAutoSend(), \
222  t.func( \
223  p.a1.get())); \
224  }
225 
226 
227 
228 
229 //------------------------------------------------------------------------------
230 // Parameters - V1
231 //------------------------------------------------------------------------------
232 
233 // RCF_METHOD_V1
234 #define RCF_METHOD_V1(R,func , A1) \
235  RCF_METHOD_V1_(R,func , A1, RCF_MAKE_UNIQUE_ID(func, V1))
236 
237 #define RCF_METHOD_V1_(R,func , A1, id) \
238  public: \
239  static_assert( std::is_same<R, void>::value, "RCF_METHOD_Vn() must be used for methods returning void." );\
240  RCF_MAKE_NEXT_DISPATCH_ID(id) \
241  ::RCF::FutureConverter<V> func( \
242  ::RCF::RemoveOut<A1 >::type a1) \
243  { \
244  return func( \
245  ::RCF::CallOptions() , \
246  a1); \
247  } \
248  ::RCF::FutureConverter<V> func( \
249  const ::RCF::CallOptions &callOptions , \
250  ::RCF::RemoveOut<A1 >::type a1) \
251  { \
252  getClientStub().setAsync(false); \
253  return RCF::FutureConverter<V>( \
254  ::RCF::AllocateClientParameters< \
255  V , \
256  A1 , \
257  V,V,V,V,V,V,V,V,V,V,V,V,V,V >()( \
258  getClientStub() , \
259  a1 , \
260  V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V()).r.get(),\
261  getClientStub(), \
262  id::value, \
263  callOptions.apply(getClientStub()), \
264  #func, \
265  "V1"); \
266  } \
267  const char * getFunctionName(const id &) \
268  { \
269  return #func; \
270  } \
271  const char * getArity(const id &) \
272  { \
273  return "V1"; \
274  } \
275  \
276  private: \
277  template<typename T> \
278  void callMethod( \
279  const id &, \
280  ::RCF::RcfSession &session, \
281  T &t) \
282  { \
283  ::RCF::ServerParameters< \
284  V , \
285  A1 > &p = \
286  ::RCF::AllocateServerParameters< \
287  V , \
288  A1 >()(session); \
289  RCF_UNUSED_VARIABLE(p); \
290  t.func( \
291  p.a1.get()); \
292  }
293 
294 
295 
296 
297 //------------------------------------------------------------------------------
298 // Parameters - R2
299 //------------------------------------------------------------------------------
300 
301 // RCF_METHOD_R2
302 #define RCF_METHOD_R2(R,func , A1,A2) \
303  RCF_METHOD_R2_(R,func , A1,A2, RCF_MAKE_UNIQUE_ID(func, R2))
304 
305 #define RCF_METHOD_R2_(R,func , A1,A2, id) \
306  public: \
307  RCF_MAKE_NEXT_DISPATCH_ID(id) \
308  ::RCF::FutureConverter<R > func( \
309  ::RCF::RemoveOut<A1 >::type a1, \
310  ::RCF::RemoveOut<A2 >::type a2) \
311  { \
312  return func( \
313  ::RCF::CallOptions() , \
314  a1,a2); \
315  } \
316  ::RCF::FutureConverter<R > func( \
317  const ::RCF::CallOptions &callOptions , \
318  ::RCF::RemoveOut<A1 >::type a1, \
319  ::RCF::RemoveOut<A2 >::type a2) \
320  { \
321  getClientStub().setAsync(false); \
322  return RCF::FutureConverter<R >( \
323  ::RCF::AllocateClientParameters< \
324  R , \
325  A1,A2 , \
326  V,V,V,V,V,V,V,V,V,V,V,V,V >()( \
327  getClientStub() , \
328  a1,a2 , \
329  V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V()).r.get(),\
330  getClientStub(), \
331  id::value, \
332  callOptions.apply(getClientStub()), \
333  #func, \
334  "R2"); \
335  } \
336  const char * getFunctionName(const id &) \
337  { \
338  return #func; \
339  } \
340  const char * getArity(const id &) \
341  { \
342  return "R2"; \
343  } \
344  \
345  private: \
346  template<typename T> \
347  void callMethod( \
348  const id &, \
349  ::RCF::RcfSession &session, \
350  T &t) \
351  { \
352  ::RCF::ServerParameters< \
353  R , \
354  A1,A2 > &p = \
355  ::RCF::AllocateServerParameters< \
356  R , \
357  A1,A2 >()(session); \
358  p.r.set( \
359  session.getAutoSend(), \
360  t.func( \
361  p.a1.get(), \
362  p.a2.get())); \
363  }
364 
365 
366 
367 
368 //------------------------------------------------------------------------------
369 // Parameters - V2
370 //------------------------------------------------------------------------------
371 
372 // RCF_METHOD_V2
373 #define RCF_METHOD_V2(R,func , A1,A2) \
374  RCF_METHOD_V2_(R,func , A1,A2, RCF_MAKE_UNIQUE_ID(func, V2))
375 
376 #define RCF_METHOD_V2_(R,func , A1,A2, id) \
377  public: \
378  static_assert( std::is_same<R, void>::value, "RCF_METHOD_Vn() must be used for methods returning void." );\
379  RCF_MAKE_NEXT_DISPATCH_ID(id) \
380  ::RCF::FutureConverter<V> func( \
381  ::RCF::RemoveOut<A1 >::type a1, \
382  ::RCF::RemoveOut<A2 >::type a2) \
383  { \
384  return func( \
385  ::RCF::CallOptions() , \
386  a1,a2); \
387  } \
388  ::RCF::FutureConverter<V> func( \
389  const ::RCF::CallOptions &callOptions , \
390  ::RCF::RemoveOut<A1 >::type a1, \
391  ::RCF::RemoveOut<A2 >::type a2) \
392  { \
393  getClientStub().setAsync(false); \
394  return RCF::FutureConverter<V>( \
395  ::RCF::AllocateClientParameters< \
396  V , \
397  A1,A2 , \
398  V,V,V,V,V,V,V,V,V,V,V,V,V >()( \
399  getClientStub() , \
400  a1,a2 , \
401  V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V()).r.get(),\
402  getClientStub(), \
403  id::value, \
404  callOptions.apply(getClientStub()), \
405  #func, \
406  "V2"); \
407  } \
408  const char * getFunctionName(const id &) \
409  { \
410  return #func; \
411  } \
412  const char * getArity(const id &) \
413  { \
414  return "V2"; \
415  } \
416  \
417  private: \
418  template<typename T> \
419  void callMethod( \
420  const id &, \
421  ::RCF::RcfSession &session, \
422  T &t) \
423  { \
424  ::RCF::ServerParameters< \
425  V , \
426  A1,A2 > &p = \
427  ::RCF::AllocateServerParameters< \
428  V , \
429  A1,A2 >()(session); \
430  RCF_UNUSED_VARIABLE(p); \
431  t.func( \
432  p.a1.get(), \
433  p.a2.get()); \
434  }
435 
436 
437 
438 
439 //------------------------------------------------------------------------------
440 // Parameters - R3
441 //------------------------------------------------------------------------------
442 
443 // RCF_METHOD_R3
444 #define RCF_METHOD_R3(R,func , A1,A2,A3) \
445  RCF_METHOD_R3_(R,func , A1,A2,A3, RCF_MAKE_UNIQUE_ID(func, R3))
446 
447 #define RCF_METHOD_R3_(R,func , A1,A2,A3, id) \
448  public: \
449  RCF_MAKE_NEXT_DISPATCH_ID(id) \
450  ::RCF::FutureConverter<R > func( \
451  ::RCF::RemoveOut<A1 >::type a1, \
452  ::RCF::RemoveOut<A2 >::type a2, \
453  ::RCF::RemoveOut<A3 >::type a3) \
454  { \
455  return func( \
456  ::RCF::CallOptions() , \
457  a1,a2,a3); \
458  } \
459  ::RCF::FutureConverter<R > func( \
460  const ::RCF::CallOptions &callOptions , \
461  ::RCF::RemoveOut<A1 >::type a1, \
462  ::RCF::RemoveOut<A2 >::type a2, \
463  ::RCF::RemoveOut<A3 >::type a3) \
464  { \
465  getClientStub().setAsync(false); \
466  return RCF::FutureConverter<R >( \
467  ::RCF::AllocateClientParameters< \
468  R , \
469  A1,A2,A3 , \
470  V,V,V,V,V,V,V,V,V,V,V,V >()( \
471  getClientStub() , \
472  a1,a2,a3 , \
473  V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V()).r.get(),\
474  getClientStub(), \
475  id::value, \
476  callOptions.apply(getClientStub()), \
477  #func, \
478  "R3"); \
479  } \
480  const char * getFunctionName(const id &) \
481  { \
482  return #func; \
483  } \
484  const char * getArity(const id &) \
485  { \
486  return "R3"; \
487  } \
488  \
489  private: \
490  template<typename T> \
491  void callMethod( \
492  const id &, \
493  ::RCF::RcfSession &session, \
494  T &t) \
495  { \
496  ::RCF::ServerParameters< \
497  R , \
498  A1,A2,A3 > &p = \
499  ::RCF::AllocateServerParameters< \
500  R , \
501  A1,A2,A3 >()(session); \
502  p.r.set( \
503  session.getAutoSend(), \
504  t.func( \
505  p.a1.get(), \
506  p.a2.get(), \
507  p.a3.get())); \
508  }
509 
510 
511 
512 
513 //------------------------------------------------------------------------------
514 // Parameters - V3
515 //------------------------------------------------------------------------------
516 
517 // RCF_METHOD_V3
518 #define RCF_METHOD_V3(R,func , A1,A2,A3) \
519  RCF_METHOD_V3_(R,func , A1,A2,A3, RCF_MAKE_UNIQUE_ID(func, V3))
520 
521 #define RCF_METHOD_V3_(R,func , A1,A2,A3, id) \
522  public: \
523  static_assert( std::is_same<R, void>::value, "RCF_METHOD_Vn() must be used for methods returning void." );\
524  RCF_MAKE_NEXT_DISPATCH_ID(id) \
525  ::RCF::FutureConverter<V> func( \
526  ::RCF::RemoveOut<A1 >::type a1, \
527  ::RCF::RemoveOut<A2 >::type a2, \
528  ::RCF::RemoveOut<A3 >::type a3) \
529  { \
530  return func( \
531  ::RCF::CallOptions() , \
532  a1,a2,a3); \
533  } \
534  ::RCF::FutureConverter<V> func( \
535  const ::RCF::CallOptions &callOptions , \
536  ::RCF::RemoveOut<A1 >::type a1, \
537  ::RCF::RemoveOut<A2 >::type a2, \
538  ::RCF::RemoveOut<A3 >::type a3) \
539  { \
540  getClientStub().setAsync(false); \
541  return RCF::FutureConverter<V>( \
542  ::RCF::AllocateClientParameters< \
543  V , \
544  A1,A2,A3 , \
545  V,V,V,V,V,V,V,V,V,V,V,V >()( \
546  getClientStub() , \
547  a1,a2,a3 , \
548  V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V()).r.get(),\
549  getClientStub(), \
550  id::value, \
551  callOptions.apply(getClientStub()), \
552  #func, \
553  "V3"); \
554  } \
555  const char * getFunctionName(const id &) \
556  { \
557  return #func; \
558  } \
559  const char * getArity(const id &) \
560  { \
561  return "V3"; \
562  } \
563  \
564  private: \
565  template<typename T> \
566  void callMethod( \
567  const id &, \
568  ::RCF::RcfSession &session, \
569  T &t) \
570  { \
571  ::RCF::ServerParameters< \
572  V , \
573  A1,A2,A3 > &p = \
574  ::RCF::AllocateServerParameters< \
575  V , \
576  A1,A2,A3 >()(session); \
577  RCF_UNUSED_VARIABLE(p); \
578  t.func( \
579  p.a1.get(), \
580  p.a2.get(), \
581  p.a3.get()); \
582  }
583 
584 
585 
586 
587 //------------------------------------------------------------------------------
588 // Parameters - R4
589 //------------------------------------------------------------------------------
590 
591 // RCF_METHOD_R4
592 #define RCF_METHOD_R4(R,func , A1,A2,A3,A4) \
593  RCF_METHOD_R4_(R,func , A1,A2,A3,A4, RCF_MAKE_UNIQUE_ID(func, R4))
594 
595 #define RCF_METHOD_R4_(R,func , A1,A2,A3,A4, id) \
596  public: \
597  RCF_MAKE_NEXT_DISPATCH_ID(id) \
598  ::RCF::FutureConverter<R > func( \
599  ::RCF::RemoveOut<A1 >::type a1, \
600  ::RCF::RemoveOut<A2 >::type a2, \
601  ::RCF::RemoveOut<A3 >::type a3, \
602  ::RCF::RemoveOut<A4 >::type a4) \
603  { \
604  return func( \
605  ::RCF::CallOptions() , \
606  a1,a2,a3,a4); \
607  } \
608  ::RCF::FutureConverter<R > func( \
609  const ::RCF::CallOptions &callOptions , \
610  ::RCF::RemoveOut<A1 >::type a1, \
611  ::RCF::RemoveOut<A2 >::type a2, \
612  ::RCF::RemoveOut<A3 >::type a3, \
613  ::RCF::RemoveOut<A4 >::type a4) \
614  { \
615  getClientStub().setAsync(false); \
616  return RCF::FutureConverter<R >( \
617  ::RCF::AllocateClientParameters< \
618  R , \
619  A1,A2,A3,A4 , \
620  V,V,V,V,V,V,V,V,V,V,V >()( \
621  getClientStub() , \
622  a1,a2,a3,a4 , \
623  V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V()).r.get(),\
624  getClientStub(), \
625  id::value, \
626  callOptions.apply(getClientStub()), \
627  #func, \
628  "R4"); \
629  } \
630  const char * getFunctionName(const id &) \
631  { \
632  return #func; \
633  } \
634  const char * getArity(const id &) \
635  { \
636  return "R4"; \
637  } \
638  \
639  private: \
640  template<typename T> \
641  void callMethod( \
642  const id &, \
643  ::RCF::RcfSession &session, \
644  T &t) \
645  { \
646  ::RCF::ServerParameters< \
647  R , \
648  A1,A2,A3,A4 > &p = \
649  ::RCF::AllocateServerParameters< \
650  R , \
651  A1,A2,A3,A4 >()(session); \
652  p.r.set( \
653  session.getAutoSend(), \
654  t.func( \
655  p.a1.get(), \
656  p.a2.get(), \
657  p.a3.get(), \
658  p.a4.get())); \
659  }
660 
661 
662 
663 
664 //------------------------------------------------------------------------------
665 // Parameters - V4
666 //------------------------------------------------------------------------------
667 
668 // RCF_METHOD_V4
669 #define RCF_METHOD_V4(R,func , A1,A2,A3,A4) \
670  RCF_METHOD_V4_(R,func , A1,A2,A3,A4, RCF_MAKE_UNIQUE_ID(func, V4))
671 
672 #define RCF_METHOD_V4_(R,func , A1,A2,A3,A4, id) \
673  public: \
674  static_assert( std::is_same<R, void>::value, "RCF_METHOD_Vn() must be used for methods returning void." );\
675  RCF_MAKE_NEXT_DISPATCH_ID(id) \
676  ::RCF::FutureConverter<V> func( \
677  ::RCF::RemoveOut<A1 >::type a1, \
678  ::RCF::RemoveOut<A2 >::type a2, \
679  ::RCF::RemoveOut<A3 >::type a3, \
680  ::RCF::RemoveOut<A4 >::type a4) \
681  { \
682  return func( \
683  ::RCF::CallOptions() , \
684  a1,a2,a3,a4); \
685  } \
686  ::RCF::FutureConverter<V> func( \
687  const ::RCF::CallOptions &callOptions , \
688  ::RCF::RemoveOut<A1 >::type a1, \
689  ::RCF::RemoveOut<A2 >::type a2, \
690  ::RCF::RemoveOut<A3 >::type a3, \
691  ::RCF::RemoveOut<A4 >::type a4) \
692  { \
693  getClientStub().setAsync(false); \
694  return RCF::FutureConverter<V>( \
695  ::RCF::AllocateClientParameters< \
696  V , \
697  A1,A2,A3,A4 , \
698  V,V,V,V,V,V,V,V,V,V,V >()( \
699  getClientStub() , \
700  a1,a2,a3,a4 , \
701  V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V()).r.get(),\
702  getClientStub(), \
703  id::value, \
704  callOptions.apply(getClientStub()), \
705  #func, \
706  "V4"); \
707  } \
708  const char * getFunctionName(const id &) \
709  { \
710  return #func; \
711  } \
712  const char * getArity(const id &) \
713  { \
714  return "V4"; \
715  } \
716  \
717  private: \
718  template<typename T> \
719  void callMethod( \
720  const id &, \
721  ::RCF::RcfSession &session, \
722  T &t) \
723  { \
724  ::RCF::ServerParameters< \
725  V , \
726  A1,A2,A3,A4 > &p = \
727  ::RCF::AllocateServerParameters< \
728  V , \
729  A1,A2,A3,A4 >()(session); \
730  RCF_UNUSED_VARIABLE(p); \
731  t.func( \
732  p.a1.get(), \
733  p.a2.get(), \
734  p.a3.get(), \
735  p.a4.get()); \
736  }
737 
738 
739 
740 
741 //------------------------------------------------------------------------------
742 // Parameters - R5
743 //------------------------------------------------------------------------------
744 
745 // RCF_METHOD_R5
746 #define RCF_METHOD_R5(R,func , A1,A2,A3,A4,A5) \
747  RCF_METHOD_R5_(R,func , A1,A2,A3,A4,A5, RCF_MAKE_UNIQUE_ID(func, R5))
748 
749 #define RCF_METHOD_R5_(R,func , A1,A2,A3,A4,A5, id) \
750  public: \
751  RCF_MAKE_NEXT_DISPATCH_ID(id) \
752  ::RCF::FutureConverter<R > func( \
753  ::RCF::RemoveOut<A1 >::type a1, \
754  ::RCF::RemoveOut<A2 >::type a2, \
755  ::RCF::RemoveOut<A3 >::type a3, \
756  ::RCF::RemoveOut<A4 >::type a4, \
757  ::RCF::RemoveOut<A5 >::type a5) \
758  { \
759  return func( \
760  ::RCF::CallOptions() , \
761  a1,a2,a3,a4,a5); \
762  } \
763  ::RCF::FutureConverter<R > func( \
764  const ::RCF::CallOptions &callOptions , \
765  ::RCF::RemoveOut<A1 >::type a1, \
766  ::RCF::RemoveOut<A2 >::type a2, \
767  ::RCF::RemoveOut<A3 >::type a3, \
768  ::RCF::RemoveOut<A4 >::type a4, \
769  ::RCF::RemoveOut<A5 >::type a5) \
770  { \
771  getClientStub().setAsync(false); \
772  return RCF::FutureConverter<R >( \
773  ::RCF::AllocateClientParameters< \
774  R , \
775  A1,A2,A3,A4,A5 , \
776  V,V,V,V,V,V,V,V,V,V >()( \
777  getClientStub() , \
778  a1,a2,a3,a4,a5 , \
779  V(),V(),V(),V(),V(),V(),V(),V(),V(),V()).r.get(), \
780  getClientStub(), \
781  id::value, \
782  callOptions.apply(getClientStub()), \
783  #func, \
784  "R5"); \
785  } \
786  const char * getFunctionName(const id &) \
787  { \
788  return #func; \
789  } \
790  const char * getArity(const id &) \
791  { \
792  return "R5"; \
793  } \
794  \
795  private: \
796  template<typename T> \
797  void callMethod( \
798  const id &, \
799  ::RCF::RcfSession &session, \
800  T &t) \
801  { \
802  ::RCF::ServerParameters< \
803  R , \
804  A1,A2,A3,A4,A5 > &p = \
805  ::RCF::AllocateServerParameters< \
806  R , \
807  A1,A2,A3,A4,A5 >()(session); \
808  p.r.set( \
809  session.getAutoSend(), \
810  t.func( \
811  p.a1.get(), \
812  p.a2.get(), \
813  p.a3.get(), \
814  p.a4.get(), \
815  p.a5.get())); \
816  }
817 
818 
819 
820 
821 //------------------------------------------------------------------------------
822 // Parameters - V5
823 //------------------------------------------------------------------------------
824 
825 // RCF_METHOD_V5
826 #define RCF_METHOD_V5(R,func , A1,A2,A3,A4,A5) \
827  RCF_METHOD_V5_(R,func , A1,A2,A3,A4,A5, RCF_MAKE_UNIQUE_ID(func, V5))
828 
829 #define RCF_METHOD_V5_(R,func , A1,A2,A3,A4,A5, id) \
830  public: \
831  static_assert( std::is_same<R, void>::value, "RCF_METHOD_Vn() must be used for methods returning void." );\
832  RCF_MAKE_NEXT_DISPATCH_ID(id) \
833  ::RCF::FutureConverter<V> func( \
834  ::RCF::RemoveOut<A1 >::type a1, \
835  ::RCF::RemoveOut<A2 >::type a2, \
836  ::RCF::RemoveOut<A3 >::type a3, \
837  ::RCF::RemoveOut<A4 >::type a4, \
838  ::RCF::RemoveOut<A5 >::type a5) \
839  { \
840  return func( \
841  ::RCF::CallOptions() , \
842  a1,a2,a3,a4,a5); \
843  } \
844  ::RCF::FutureConverter<V> func( \
845  const ::RCF::CallOptions &callOptions , \
846  ::RCF::RemoveOut<A1 >::type a1, \
847  ::RCF::RemoveOut<A2 >::type a2, \
848  ::RCF::RemoveOut<A3 >::type a3, \
849  ::RCF::RemoveOut<A4 >::type a4, \
850  ::RCF::RemoveOut<A5 >::type a5) \
851  { \
852  getClientStub().setAsync(false); \
853  return RCF::FutureConverter<V>( \
854  ::RCF::AllocateClientParameters< \
855  V , \
856  A1,A2,A3,A4,A5 , \
857  V,V,V,V,V,V,V,V,V,V >()( \
858  getClientStub() , \
859  a1,a2,a3,a4,a5 , \
860  V(),V(),V(),V(),V(),V(),V(),V(),V(),V()).r.get(), \
861  getClientStub(), \
862  id::value, \
863  callOptions.apply(getClientStub()), \
864  #func, \
865  "V5"); \
866  } \
867  const char * getFunctionName(const id &) \
868  { \
869  return #func; \
870  } \
871  const char * getArity(const id &) \
872  { \
873  return "V5"; \
874  } \
875  \
876  private: \
877  template<typename T> \
878  void callMethod( \
879  const id &, \
880  ::RCF::RcfSession &session, \
881  T &t) \
882  { \
883  ::RCF::ServerParameters< \
884  V , \
885  A1,A2,A3,A4,A5 > &p = \
886  ::RCF::AllocateServerParameters< \
887  V , \
888  A1,A2,A3,A4,A5 >()(session); \
889  RCF_UNUSED_VARIABLE(p); \
890  t.func( \
891  p.a1.get(), \
892  p.a2.get(), \
893  p.a3.get(), \
894  p.a4.get(), \
895  p.a5.get()); \
896  }
897 
898 
899 
900 
901 //------------------------------------------------------------------------------
902 // Parameters - R6
903 //------------------------------------------------------------------------------
904 
905 // RCF_METHOD_R6
906 #define RCF_METHOD_R6(R,func , A1,A2,A3,A4,A5,A6) \
907  RCF_METHOD_R6_(R,func , A1,A2,A3,A4,A5,A6, RCF_MAKE_UNIQUE_ID(func, R6))
908 
909 #define RCF_METHOD_R6_(R,func , A1,A2,A3,A4,A5,A6, id) \
910  public: \
911  RCF_MAKE_NEXT_DISPATCH_ID(id) \
912  ::RCF::FutureConverter<R > func( \
913  ::RCF::RemoveOut<A1 >::type a1, \
914  ::RCF::RemoveOut<A2 >::type a2, \
915  ::RCF::RemoveOut<A3 >::type a3, \
916  ::RCF::RemoveOut<A4 >::type a4, \
917  ::RCF::RemoveOut<A5 >::type a5, \
918  ::RCF::RemoveOut<A6 >::type a6) \
919  { \
920  return func( \
921  ::RCF::CallOptions() , \
922  a1,a2,a3,a4,a5,a6); \
923  } \
924  ::RCF::FutureConverter<R > func( \
925  const ::RCF::CallOptions &callOptions , \
926  ::RCF::RemoveOut<A1 >::type a1, \
927  ::RCF::RemoveOut<A2 >::type a2, \
928  ::RCF::RemoveOut<A3 >::type a3, \
929  ::RCF::RemoveOut<A4 >::type a4, \
930  ::RCF::RemoveOut<A5 >::type a5, \
931  ::RCF::RemoveOut<A6 >::type a6) \
932  { \
933  getClientStub().setAsync(false); \
934  return RCF::FutureConverter<R >( \
935  ::RCF::AllocateClientParameters< \
936  R , \
937  A1,A2,A3,A4,A5,A6 , \
938  V,V,V,V,V,V,V,V,V >()( \
939  getClientStub() , \
940  a1,a2,a3,a4,a5,a6 , \
941  V(),V(),V(),V(),V(),V(),V(),V(),V()).r.get(), \
942  getClientStub(), \
943  id::value, \
944  callOptions.apply(getClientStub()), \
945  #func, \
946  "R6"); \
947  } \
948  const char * getFunctionName(const id &) \
949  { \
950  return #func; \
951  } \
952  const char * getArity(const id &) \
953  { \
954  return "R6"; \
955  } \
956  \
957  private: \
958  template<typename T> \
959  void callMethod( \
960  const id &, \
961  ::RCF::RcfSession &session, \
962  T &t) \
963  { \
964  ::RCF::ServerParameters< \
965  R , \
966  A1,A2,A3,A4,A5,A6 > &p = \
967  ::RCF::AllocateServerParameters< \
968  R , \
969  A1,A2,A3,A4,A5,A6 >()(session); \
970  p.r.set( \
971  session.getAutoSend(), \
972  t.func( \
973  p.a1.get(), \
974  p.a2.get(), \
975  p.a3.get(), \
976  p.a4.get(), \
977  p.a5.get(), \
978  p.a6.get())); \
979  }
980 
981 
982 
983 
984 //------------------------------------------------------------------------------
985 // Parameters - V6
986 //------------------------------------------------------------------------------
987 
988 // RCF_METHOD_V6
989 #define RCF_METHOD_V6(R,func , A1,A2,A3,A4,A5,A6) \
990  RCF_METHOD_V6_(R,func , A1,A2,A3,A4,A5,A6, RCF_MAKE_UNIQUE_ID(func, V6))
991 
992 #define RCF_METHOD_V6_(R,func , A1,A2,A3,A4,A5,A6, id) \
993  public: \
994  static_assert( std::is_same<R, void>::value, "RCF_METHOD_Vn() must be used for methods returning void." );\
995  RCF_MAKE_NEXT_DISPATCH_ID(id) \
996  ::RCF::FutureConverter<V> func( \
997  ::RCF::RemoveOut<A1 >::type a1, \
998  ::RCF::RemoveOut<A2 >::type a2, \
999  ::RCF::RemoveOut<A3 >::type a3, \
1000  ::RCF::RemoveOut<A4 >::type a4, \
1001  ::RCF::RemoveOut<A5 >::type a5, \
1002  ::RCF::RemoveOut<A6 >::type a6) \
1003  { \
1004  return func( \
1005  ::RCF::CallOptions() , \
1006  a1,a2,a3,a4,a5,a6); \
1007  } \
1008  ::RCF::FutureConverter<V> func( \
1009  const ::RCF::CallOptions &callOptions , \
1010  ::RCF::RemoveOut<A1 >::type a1, \
1011  ::RCF::RemoveOut<A2 >::type a2, \
1012  ::RCF::RemoveOut<A3 >::type a3, \
1013  ::RCF::RemoveOut<A4 >::type a4, \
1014  ::RCF::RemoveOut<A5 >::type a5, \
1015  ::RCF::RemoveOut<A6 >::type a6) \
1016  { \
1017  getClientStub().setAsync(false); \
1018  return RCF::FutureConverter<V>( \
1019  ::RCF::AllocateClientParameters< \
1020  V , \
1021  A1,A2,A3,A4,A5,A6 , \
1022  V,V,V,V,V,V,V,V,V >()( \
1023  getClientStub() , \
1024  a1,a2,a3,a4,a5,a6 , \
1025  V(),V(),V(),V(),V(),V(),V(),V(),V()).r.get(), \
1026  getClientStub(), \
1027  id::value, \
1028  callOptions.apply(getClientStub()), \
1029  #func, \
1030  "V6"); \
1031  } \
1032  const char * getFunctionName(const id &) \
1033  { \
1034  return #func; \
1035  } \
1036  const char * getArity(const id &) \
1037  { \
1038  return "V6"; \
1039  } \
1040  \
1041  private: \
1042  template<typename T> \
1043  void callMethod( \
1044  const id &, \
1045  ::RCF::RcfSession &session, \
1046  T &t) \
1047  { \
1048  ::RCF::ServerParameters< \
1049  V , \
1050  A1,A2,A3,A4,A5,A6 > &p = \
1051  ::RCF::AllocateServerParameters< \
1052  V , \
1053  A1,A2,A3,A4,A5,A6 >()(session); \
1054  RCF_UNUSED_VARIABLE(p); \
1055  t.func( \
1056  p.a1.get(), \
1057  p.a2.get(), \
1058  p.a3.get(), \
1059  p.a4.get(), \
1060  p.a5.get(), \
1061  p.a6.get()); \
1062  }
1063 
1064 
1065 
1066 
1067 //------------------------------------------------------------------------------
1068 // Parameters - R7
1069 //------------------------------------------------------------------------------
1070 
1071 // RCF_METHOD_R7
1072 #define RCF_METHOD_R7(R,func , A1,A2,A3,A4,A5,A6,A7) \
1073  RCF_METHOD_R7_(R,func , A1,A2,A3,A4,A5,A6,A7, RCF_MAKE_UNIQUE_ID(func, R7))
1074 
1075 #define RCF_METHOD_R7_(R,func , A1,A2,A3,A4,A5,A6,A7, id) \
1076  public: \
1077  RCF_MAKE_NEXT_DISPATCH_ID(id) \
1078  ::RCF::FutureConverter<R > func( \
1079  ::RCF::RemoveOut<A1 >::type a1, \
1080  ::RCF::RemoveOut<A2 >::type a2, \
1081  ::RCF::RemoveOut<A3 >::type a3, \
1082  ::RCF::RemoveOut<A4 >::type a4, \
1083  ::RCF::RemoveOut<A5 >::type a5, \
1084  ::RCF::RemoveOut<A6 >::type a6, \
1085  ::RCF::RemoveOut<A7 >::type a7) \
1086  { \
1087  return func( \
1088  ::RCF::CallOptions() , \
1089  a1,a2,a3,a4,a5,a6,a7); \
1090  } \
1091  ::RCF::FutureConverter<R > func( \
1092  const ::RCF::CallOptions &callOptions , \
1093  ::RCF::RemoveOut<A1 >::type a1, \
1094  ::RCF::RemoveOut<A2 >::type a2, \
1095  ::RCF::RemoveOut<A3 >::type a3, \
1096  ::RCF::RemoveOut<A4 >::type a4, \
1097  ::RCF::RemoveOut<A5 >::type a5, \
1098  ::RCF::RemoveOut<A6 >::type a6, \
1099  ::RCF::RemoveOut<A7 >::type a7) \
1100  { \
1101  getClientStub().setAsync(false); \
1102  return RCF::FutureConverter<R >( \
1103  ::RCF::AllocateClientParameters< \
1104  R , \
1105  A1,A2,A3,A4,A5,A6,A7 , \
1106  V,V,V,V,V,V,V,V >()( \
1107  getClientStub() , \
1108  a1,a2,a3,a4,a5,a6,a7 , \
1109  V(),V(),V(),V(),V(),V(),V(),V()).r.get(), \
1110  getClientStub(), \
1111  id::value, \
1112  callOptions.apply(getClientStub()), \
1113  #func, \
1114  "R7"); \
1115  } \
1116  const char * getFunctionName(const id &) \
1117  { \
1118  return #func; \
1119  } \
1120  const char * getArity(const id &) \
1121  { \
1122  return "R7"; \
1123  } \
1124  \
1125  private: \
1126  template<typename T> \
1127  void callMethod( \
1128  const id &, \
1129  ::RCF::RcfSession &session, \
1130  T &t) \
1131  { \
1132  ::RCF::ServerParameters< \
1133  R , \
1134  A1,A2,A3,A4,A5,A6,A7 > &p = \
1135  ::RCF::AllocateServerParameters< \
1136  R , \
1137  A1,A2,A3,A4,A5,A6,A7 >()(session); \
1138  p.r.set( \
1139  session.getAutoSend(), \
1140  t.func( \
1141  p.a1.get(), \
1142  p.a2.get(), \
1143  p.a3.get(), \
1144  p.a4.get(), \
1145  p.a5.get(), \
1146  p.a6.get(), \
1147  p.a7.get())); \
1148  }
1149 
1150 
1151 
1152 
1153 //------------------------------------------------------------------------------
1154 // Parameters - V7
1155 //------------------------------------------------------------------------------
1156 
1157 // RCF_METHOD_V7
1158 #define RCF_METHOD_V7(R,func , A1,A2,A3,A4,A5,A6,A7) \
1159  RCF_METHOD_V7_(R,func , A1,A2,A3,A4,A5,A6,A7, RCF_MAKE_UNIQUE_ID(func, V7))
1160 
1161 #define RCF_METHOD_V7_(R,func , A1,A2,A3,A4,A5,A6,A7, id) \
1162  public: \
1163  static_assert( std::is_same<R, void>::value, "RCF_METHOD_Vn() must be used for methods returning void." );\
1164  RCF_MAKE_NEXT_DISPATCH_ID(id) \
1165  ::RCF::FutureConverter<V> func( \
1166  ::RCF::RemoveOut<A1 >::type a1, \
1167  ::RCF::RemoveOut<A2 >::type a2, \
1168  ::RCF::RemoveOut<A3 >::type a3, \
1169  ::RCF::RemoveOut<A4 >::type a4, \
1170  ::RCF::RemoveOut<A5 >::type a5, \
1171  ::RCF::RemoveOut<A6 >::type a6, \
1172  ::RCF::RemoveOut<A7 >::type a7) \
1173  { \
1174  return func( \
1175  ::RCF::CallOptions() , \
1176  a1,a2,a3,a4,a5,a6,a7); \
1177  } \
1178  ::RCF::FutureConverter<V> func( \
1179  const ::RCF::CallOptions &callOptions , \
1180  ::RCF::RemoveOut<A1 >::type a1, \
1181  ::RCF::RemoveOut<A2 >::type a2, \
1182  ::RCF::RemoveOut<A3 >::type a3, \
1183  ::RCF::RemoveOut<A4 >::type a4, \
1184  ::RCF::RemoveOut<A5 >::type a5, \
1185  ::RCF::RemoveOut<A6 >::type a6, \
1186  ::RCF::RemoveOut<A7 >::type a7) \
1187  { \
1188  getClientStub().setAsync(false); \
1189  return RCF::FutureConverter<V>( \
1190  ::RCF::AllocateClientParameters< \
1191  V , \
1192  A1,A2,A3,A4,A5,A6,A7 , \
1193  V,V,V,V,V,V,V,V >()( \
1194  getClientStub() , \
1195  a1,a2,a3,a4,a5,a6,a7 , \
1196  V(),V(),V(),V(),V(),V(),V(),V()).r.get(), \
1197  getClientStub(), \
1198  id::value, \
1199  callOptions.apply(getClientStub()), \
1200  #func, \
1201  "V7"); \
1202  } \
1203  const char * getFunctionName(const id &) \
1204  { \
1205  return #func; \
1206  } \
1207  const char * getArity(const id &) \
1208  { \
1209  return "V7"; \
1210  } \
1211  \
1212  private: \
1213  template<typename T> \
1214  void callMethod( \
1215  const id &, \
1216  ::RCF::RcfSession &session, \
1217  T &t) \
1218  { \
1219  ::RCF::ServerParameters< \
1220  V , \
1221  A1,A2,A3,A4,A5,A6,A7 > &p = \
1222  ::RCF::AllocateServerParameters< \
1223  V , \
1224  A1,A2,A3,A4,A5,A6,A7 >()(session); \
1225  RCF_UNUSED_VARIABLE(p); \
1226  t.func( \
1227  p.a1.get(), \
1228  p.a2.get(), \
1229  p.a3.get(), \
1230  p.a4.get(), \
1231  p.a5.get(), \
1232  p.a6.get(), \
1233  p.a7.get()); \
1234  }
1235 
1236 
1237 
1238 
1239 //------------------------------------------------------------------------------
1240 // Parameters - R8
1241 //------------------------------------------------------------------------------
1242 
1243 // RCF_METHOD_R8
1244 #define RCF_METHOD_R8(R,func , A1,A2,A3,A4,A5,A6,A7,A8) \
1245  RCF_METHOD_R8_(R,func , A1,A2,A3,A4,A5,A6,A7,A8, RCF_MAKE_UNIQUE_ID(func, R8))
1246 
1247 #define RCF_METHOD_R8_(R,func , A1,A2,A3,A4,A5,A6,A7,A8, id) \
1248  public: \
1249  RCF_MAKE_NEXT_DISPATCH_ID(id) \
1250  ::RCF::FutureConverter<R > func( \
1251  ::RCF::RemoveOut<A1 >::type a1, \
1252  ::RCF::RemoveOut<A2 >::type a2, \
1253  ::RCF::RemoveOut<A3 >::type a3, \
1254  ::RCF::RemoveOut<A4 >::type a4, \
1255  ::RCF::RemoveOut<A5 >::type a5, \
1256  ::RCF::RemoveOut<A6 >::type a6, \
1257  ::RCF::RemoveOut<A7 >::type a7, \
1258  ::RCF::RemoveOut<A8 >::type a8) \
1259  { \
1260  return func( \
1261  ::RCF::CallOptions() , \
1262  a1,a2,a3,a4,a5,a6,a7,a8); \
1263  } \
1264  ::RCF::FutureConverter<R > func( \
1265  const ::RCF::CallOptions &callOptions , \
1266  ::RCF::RemoveOut<A1 >::type a1, \
1267  ::RCF::RemoveOut<A2 >::type a2, \
1268  ::RCF::RemoveOut<A3 >::type a3, \
1269  ::RCF::RemoveOut<A4 >::type a4, \
1270  ::RCF::RemoveOut<A5 >::type a5, \
1271  ::RCF::RemoveOut<A6 >::type a6, \
1272  ::RCF::RemoveOut<A7 >::type a7, \
1273  ::RCF::RemoveOut<A8 >::type a8) \
1274  { \
1275  getClientStub().setAsync(false); \
1276  return RCF::FutureConverter<R >( \
1277  ::RCF::AllocateClientParameters< \
1278  R , \
1279  A1,A2,A3,A4,A5,A6,A7,A8 , \
1280  V,V,V,V,V,V,V >()( \
1281  getClientStub() , \
1282  a1,a2,a3,a4,a5,a6,a7,a8 , \
1283  V(),V(),V(),V(),V(),V(),V()).r.get(), \
1284  getClientStub(), \
1285  id::value, \
1286  callOptions.apply(getClientStub()), \
1287  #func, \
1288  "R8"); \
1289  } \
1290  const char * getFunctionName(const id &) \
1291  { \
1292  return #func; \
1293  } \
1294  const char * getArity(const id &) \
1295  { \
1296  return "R8"; \
1297  } \
1298  \
1299  private: \
1300  template<typename T> \
1301  void callMethod( \
1302  const id &, \
1303  ::RCF::RcfSession &session, \
1304  T &t) \
1305  { \
1306  ::RCF::ServerParameters< \
1307  R , \
1308  A1,A2,A3,A4,A5,A6,A7,A8 > &p = \
1309  ::RCF::AllocateServerParameters< \
1310  R , \
1311  A1,A2,A3,A4,A5,A6,A7,A8 >()(session); \
1312  p.r.set( \
1313  session.getAutoSend(), \
1314  t.func( \
1315  p.a1.get(), \
1316  p.a2.get(), \
1317  p.a3.get(), \
1318  p.a4.get(), \
1319  p.a5.get(), \
1320  p.a6.get(), \
1321  p.a7.get(), \
1322  p.a8.get())); \
1323  }
1324 
1325 
1326 
1327 
1328 //------------------------------------------------------------------------------
1329 // Parameters - V8
1330 //------------------------------------------------------------------------------
1331 
1332 // RCF_METHOD_V8
1333 #define RCF_METHOD_V8(R,func , A1,A2,A3,A4,A5,A6,A7,A8) \
1334  RCF_METHOD_V8_(R,func , A1,A2,A3,A4,A5,A6,A7,A8, RCF_MAKE_UNIQUE_ID(func, V8))
1335 
1336 #define RCF_METHOD_V8_(R,func , A1,A2,A3,A4,A5,A6,A7,A8, id) \
1337  public: \
1338  static_assert( std::is_same<R, void>::value, "RCF_METHOD_Vn() must be used for methods returning void." );\
1339  RCF_MAKE_NEXT_DISPATCH_ID(id) \
1340  ::RCF::FutureConverter<V> func( \
1341  ::RCF::RemoveOut<A1 >::type a1, \
1342  ::RCF::RemoveOut<A2 >::type a2, \
1343  ::RCF::RemoveOut<A3 >::type a3, \
1344  ::RCF::RemoveOut<A4 >::type a4, \
1345  ::RCF::RemoveOut<A5 >::type a5, \
1346  ::RCF::RemoveOut<A6 >::type a6, \
1347  ::RCF::RemoveOut<A7 >::type a7, \
1348  ::RCF::RemoveOut<A8 >::type a8) \
1349  { \
1350  return func( \
1351  ::RCF::CallOptions() , \
1352  a1,a2,a3,a4,a5,a6,a7,a8); \
1353  } \
1354  ::RCF::FutureConverter<V> func( \
1355  const ::RCF::CallOptions &callOptions , \
1356  ::RCF::RemoveOut<A1 >::type a1, \
1357  ::RCF::RemoveOut<A2 >::type a2, \
1358  ::RCF::RemoveOut<A3 >::type a3, \
1359  ::RCF::RemoveOut<A4 >::type a4, \
1360  ::RCF::RemoveOut<A5 >::type a5, \
1361  ::RCF::RemoveOut<A6 >::type a6, \
1362  ::RCF::RemoveOut<A7 >::type a7, \
1363  ::RCF::RemoveOut<A8 >::type a8) \
1364  { \
1365  getClientStub().setAsync(false); \
1366  return RCF::FutureConverter<V>( \
1367  ::RCF::AllocateClientParameters< \
1368  V , \
1369  A1,A2,A3,A4,A5,A6,A7,A8 , \
1370  V,V,V,V,V,V,V >()( \
1371  getClientStub() , \
1372  a1,a2,a3,a4,a5,a6,a7,a8 , \
1373  V(),V(),V(),V(),V(),V(),V()).r.get(), \
1374  getClientStub(), \
1375  id::value, \
1376  callOptions.apply(getClientStub()), \
1377  #func, \
1378  "V8"); \
1379  } \
1380  const char * getFunctionName(const id &) \
1381  { \
1382  return #func; \
1383  } \
1384  const char * getArity(const id &) \
1385  { \
1386  return "V8"; \
1387  } \
1388  \
1389  private: \
1390  template<typename T> \
1391  void callMethod( \
1392  const id &, \
1393  ::RCF::RcfSession &session, \
1394  T &t) \
1395  { \
1396  ::RCF::ServerParameters< \
1397  V , \
1398  A1,A2,A3,A4,A5,A6,A7,A8 > &p = \
1399  ::RCF::AllocateServerParameters< \
1400  V , \
1401  A1,A2,A3,A4,A5,A6,A7,A8 >()(session); \
1402  RCF_UNUSED_VARIABLE(p); \
1403  t.func( \
1404  p.a1.get(), \
1405  p.a2.get(), \
1406  p.a3.get(), \
1407  p.a4.get(), \
1408  p.a5.get(), \
1409  p.a6.get(), \
1410  p.a7.get(), \
1411  p.a8.get()); \
1412  }
1413 
1414 
1415 
1416 
1417 //------------------------------------------------------------------------------
1418 // Parameters - R9
1419 //------------------------------------------------------------------------------
1420 
1421 // RCF_METHOD_R9
1422 #define RCF_METHOD_R9(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9) \
1423  RCF_METHOD_R9_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9, RCF_MAKE_UNIQUE_ID(func, R9))
1424 
1425 #define RCF_METHOD_R9_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9, id) \
1426  public: \
1427  RCF_MAKE_NEXT_DISPATCH_ID(id) \
1428  ::RCF::FutureConverter<R > func( \
1429  ::RCF::RemoveOut<A1 >::type a1, \
1430  ::RCF::RemoveOut<A2 >::type a2, \
1431  ::RCF::RemoveOut<A3 >::type a3, \
1432  ::RCF::RemoveOut<A4 >::type a4, \
1433  ::RCF::RemoveOut<A5 >::type a5, \
1434  ::RCF::RemoveOut<A6 >::type a6, \
1435  ::RCF::RemoveOut<A7 >::type a7, \
1436  ::RCF::RemoveOut<A8 >::type a8, \
1437  ::RCF::RemoveOut<A9 >::type a9) \
1438  { \
1439  return func( \
1440  ::RCF::CallOptions() , \
1441  a1,a2,a3,a4,a5,a6,a7,a8,a9); \
1442  } \
1443  ::RCF::FutureConverter<R > func( \
1444  const ::RCF::CallOptions &callOptions , \
1445  ::RCF::RemoveOut<A1 >::type a1, \
1446  ::RCF::RemoveOut<A2 >::type a2, \
1447  ::RCF::RemoveOut<A3 >::type a3, \
1448  ::RCF::RemoveOut<A4 >::type a4, \
1449  ::RCF::RemoveOut<A5 >::type a5, \
1450  ::RCF::RemoveOut<A6 >::type a6, \
1451  ::RCF::RemoveOut<A7 >::type a7, \
1452  ::RCF::RemoveOut<A8 >::type a8, \
1453  ::RCF::RemoveOut<A9 >::type a9) \
1454  { \
1455  getClientStub().setAsync(false); \
1456  return RCF::FutureConverter<R >( \
1457  ::RCF::AllocateClientParameters< \
1458  R , \
1459  A1,A2,A3,A4,A5,A6,A7,A8,A9 , \
1460  V,V,V,V,V,V >()( \
1461  getClientStub() , \
1462  a1,a2,a3,a4,a5,a6,a7,a8,a9 , \
1463  V(),V(),V(),V(),V(),V()).r.get(), \
1464  getClientStub(), \
1465  id::value, \
1466  callOptions.apply(getClientStub()), \
1467  #func, \
1468  "R9"); \
1469  } \
1470  const char * getFunctionName(const id &) \
1471  { \
1472  return #func; \
1473  } \
1474  const char * getArity(const id &) \
1475  { \
1476  return "R9"; \
1477  } \
1478  \
1479  private: \
1480  template<typename T> \
1481  void callMethod( \
1482  const id &, \
1483  ::RCF::RcfSession &session, \
1484  T &t) \
1485  { \
1486  ::RCF::ServerParameters< \
1487  R , \
1488  A1,A2,A3,A4,A5,A6,A7,A8,A9 > &p = \
1489  ::RCF::AllocateServerParameters< \
1490  R , \
1491  A1,A2,A3,A4,A5,A6,A7,A8,A9 >()(session); \
1492  p.r.set( \
1493  session.getAutoSend(), \
1494  t.func( \
1495  p.a1.get(), \
1496  p.a2.get(), \
1497  p.a3.get(), \
1498  p.a4.get(), \
1499  p.a5.get(), \
1500  p.a6.get(), \
1501  p.a7.get(), \
1502  p.a8.get(), \
1503  p.a9.get())); \
1504  }
1505 
1506 
1507 
1508 
1509 //------------------------------------------------------------------------------
1510 // Parameters - V9
1511 //------------------------------------------------------------------------------
1512 
1513 // RCF_METHOD_V9
1514 #define RCF_METHOD_V9(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9) \
1515  RCF_METHOD_V9_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9, RCF_MAKE_UNIQUE_ID(func, V9))
1516 
1517 #define RCF_METHOD_V9_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9, id) \
1518  public: \
1519  static_assert( std::is_same<R, void>::value, "RCF_METHOD_Vn() must be used for methods returning void." );\
1520  RCF_MAKE_NEXT_DISPATCH_ID(id) \
1521  ::RCF::FutureConverter<V> func( \
1522  ::RCF::RemoveOut<A1 >::type a1, \
1523  ::RCF::RemoveOut<A2 >::type a2, \
1524  ::RCF::RemoveOut<A3 >::type a3, \
1525  ::RCF::RemoveOut<A4 >::type a4, \
1526  ::RCF::RemoveOut<A5 >::type a5, \
1527  ::RCF::RemoveOut<A6 >::type a6, \
1528  ::RCF::RemoveOut<A7 >::type a7, \
1529  ::RCF::RemoveOut<A8 >::type a8, \
1530  ::RCF::RemoveOut<A9 >::type a9) \
1531  { \
1532  return func( \
1533  ::RCF::CallOptions() , \
1534  a1,a2,a3,a4,a5,a6,a7,a8,a9); \
1535  } \
1536  ::RCF::FutureConverter<V> func( \
1537  const ::RCF::CallOptions &callOptions , \
1538  ::RCF::RemoveOut<A1 >::type a1, \
1539  ::RCF::RemoveOut<A2 >::type a2, \
1540  ::RCF::RemoveOut<A3 >::type a3, \
1541  ::RCF::RemoveOut<A4 >::type a4, \
1542  ::RCF::RemoveOut<A5 >::type a5, \
1543  ::RCF::RemoveOut<A6 >::type a6, \
1544  ::RCF::RemoveOut<A7 >::type a7, \
1545  ::RCF::RemoveOut<A8 >::type a8, \
1546  ::RCF::RemoveOut<A9 >::type a9) \
1547  { \
1548  getClientStub().setAsync(false); \
1549  return RCF::FutureConverter<V>( \
1550  ::RCF::AllocateClientParameters< \
1551  V , \
1552  A1,A2,A3,A4,A5,A6,A7,A8,A9 , \
1553  V,V,V,V,V,V >()( \
1554  getClientStub() , \
1555  a1,a2,a3,a4,a5,a6,a7,a8,a9 , \
1556  V(),V(),V(),V(),V(),V()).r.get(), \
1557  getClientStub(), \
1558  id::value, \
1559  callOptions.apply(getClientStub()), \
1560  #func, \
1561  "V9"); \
1562  } \
1563  const char * getFunctionName(const id &) \
1564  { \
1565  return #func; \
1566  } \
1567  const char * getArity(const id &) \
1568  { \
1569  return "V9"; \
1570  } \
1571  \
1572  private: \
1573  template<typename T> \
1574  void callMethod( \
1575  const id &, \
1576  ::RCF::RcfSession &session, \
1577  T &t) \
1578  { \
1579  ::RCF::ServerParameters< \
1580  V , \
1581  A1,A2,A3,A4,A5,A6,A7,A8,A9 > &p = \
1582  ::RCF::AllocateServerParameters< \
1583  V , \
1584  A1,A2,A3,A4,A5,A6,A7,A8,A9 >()(session); \
1585  RCF_UNUSED_VARIABLE(p); \
1586  t.func( \
1587  p.a1.get(), \
1588  p.a2.get(), \
1589  p.a3.get(), \
1590  p.a4.get(), \
1591  p.a5.get(), \
1592  p.a6.get(), \
1593  p.a7.get(), \
1594  p.a8.get(), \
1595  p.a9.get()); \
1596  }
1597 
1598 
1599 
1600 
1601 //------------------------------------------------------------------------------
1602 // Parameters - R10
1603 //------------------------------------------------------------------------------
1604 
1605 // RCF_METHOD_R10
1606 #define RCF_METHOD_R10(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10) \
1607  RCF_METHOD_R10_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10, RCF_MAKE_UNIQUE_ID(func, R10))
1608 
1609 #define RCF_METHOD_R10_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10, id) \
1610  public: \
1611  RCF_MAKE_NEXT_DISPATCH_ID(id) \
1612  ::RCF::FutureConverter<R > func( \
1613  ::RCF::RemoveOut<A1 >::type a1, \
1614  ::RCF::RemoveOut<A2 >::type a2, \
1615  ::RCF::RemoveOut<A3 >::type a3, \
1616  ::RCF::RemoveOut<A4 >::type a4, \
1617  ::RCF::RemoveOut<A5 >::type a5, \
1618  ::RCF::RemoveOut<A6 >::type a6, \
1619  ::RCF::RemoveOut<A7 >::type a7, \
1620  ::RCF::RemoveOut<A8 >::type a8, \
1621  ::RCF::RemoveOut<A9 >::type a9, \
1622  ::RCF::RemoveOut<A10 >::type a10) \
1623  { \
1624  return func( \
1625  ::RCF::CallOptions() , \
1626  a1,a2,a3,a4,a5,a6,a7,a8,a9,a10); \
1627  } \
1628  ::RCF::FutureConverter<R > func( \
1629  const ::RCF::CallOptions &callOptions , \
1630  ::RCF::RemoveOut<A1 >::type a1, \
1631  ::RCF::RemoveOut<A2 >::type a2, \
1632  ::RCF::RemoveOut<A3 >::type a3, \
1633  ::RCF::RemoveOut<A4 >::type a4, \
1634  ::RCF::RemoveOut<A5 >::type a5, \
1635  ::RCF::RemoveOut<A6 >::type a6, \
1636  ::RCF::RemoveOut<A7 >::type a7, \
1637  ::RCF::RemoveOut<A8 >::type a8, \
1638  ::RCF::RemoveOut<A9 >::type a9, \
1639  ::RCF::RemoveOut<A10 >::type a10) \
1640  { \
1641  getClientStub().setAsync(false); \
1642  return RCF::FutureConverter<R >( \
1643  ::RCF::AllocateClientParameters< \
1644  R , \
1645  A1,A2,A3,A4,A5,A6,A7,A8,A9,A10 , \
1646  V,V,V,V,V >()( \
1647  getClientStub() , \
1648  a1,a2,a3,a4,a5,a6,a7,a8,a9,a10 , \
1649  V(),V(),V(),V(),V()).r.get(), \
1650  getClientStub(), \
1651  id::value, \
1652  callOptions.apply(getClientStub()), \
1653  #func, \
1654  "R10"); \
1655  } \
1656  const char * getFunctionName(const id &) \
1657  { \
1658  return #func; \
1659  } \
1660  const char * getArity(const id &) \
1661  { \
1662  return "R10"; \
1663  } \
1664  \
1665  private: \
1666  template<typename T> \
1667  void callMethod( \
1668  const id &, \
1669  ::RCF::RcfSession &session, \
1670  T &t) \
1671  { \
1672  ::RCF::ServerParameters< \
1673  R , \
1674  A1,A2,A3,A4,A5,A6,A7,A8,A9,A10 > &p = \
1675  ::RCF::AllocateServerParameters< \
1676  R , \
1677  A1,A2,A3,A4,A5,A6,A7,A8,A9,A10 >()(session); \
1678  p.r.set( \
1679  session.getAutoSend(), \
1680  t.func( \
1681  p.a1.get(), \
1682  p.a2.get(), \
1683  p.a3.get(), \
1684  p.a4.get(), \
1685  p.a5.get(), \
1686  p.a6.get(), \
1687  p.a7.get(), \
1688  p.a8.get(), \
1689  p.a9.get(), \
1690  p.a10.get())); \
1691  }
1692 
1693 
1694 
1695 
1696 //------------------------------------------------------------------------------
1697 // Parameters - V10
1698 //------------------------------------------------------------------------------
1699 
1700 // RCF_METHOD_V10
1701 #define RCF_METHOD_V10(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10) \
1702  RCF_METHOD_V10_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10, RCF_MAKE_UNIQUE_ID(func, V10))
1703 
1704 #define RCF_METHOD_V10_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10, id) \
1705  public: \
1706  static_assert( std::is_same<R, void>::value, "RCF_METHOD_Vn() must be used for methods returning void." );\
1707  RCF_MAKE_NEXT_DISPATCH_ID(id) \
1708  ::RCF::FutureConverter<V> func( \
1709  ::RCF::RemoveOut<A1 >::type a1, \
1710  ::RCF::RemoveOut<A2 >::type a2, \
1711  ::RCF::RemoveOut<A3 >::type a3, \
1712  ::RCF::RemoveOut<A4 >::type a4, \
1713  ::RCF::RemoveOut<A5 >::type a5, \
1714  ::RCF::RemoveOut<A6 >::type a6, \
1715  ::RCF::RemoveOut<A7 >::type a7, \
1716  ::RCF::RemoveOut<A8 >::type a8, \
1717  ::RCF::RemoveOut<A9 >::type a9, \
1718  ::RCF::RemoveOut<A10 >::type a10) \
1719  { \
1720  return func( \
1721  ::RCF::CallOptions() , \
1722  a1,a2,a3,a4,a5,a6,a7,a8,a9,a10); \
1723  } \
1724  ::RCF::FutureConverter<V> func( \
1725  const ::RCF::CallOptions &callOptions , \
1726  ::RCF::RemoveOut<A1 >::type a1, \
1727  ::RCF::RemoveOut<A2 >::type a2, \
1728  ::RCF::RemoveOut<A3 >::type a3, \
1729  ::RCF::RemoveOut<A4 >::type a4, \
1730  ::RCF::RemoveOut<A5 >::type a5, \
1731  ::RCF::RemoveOut<A6 >::type a6, \
1732  ::RCF::RemoveOut<A7 >::type a7, \
1733  ::RCF::RemoveOut<A8 >::type a8, \
1734  ::RCF::RemoveOut<A9 >::type a9, \
1735  ::RCF::RemoveOut<A10 >::type a10) \
1736  { \
1737  getClientStub().setAsync(false); \
1738  return RCF::FutureConverter<V>( \
1739  ::RCF::AllocateClientParameters< \
1740  V , \
1741  A1,A2,A3,A4,A5,A6,A7,A8,A9,A10 , \
1742  V,V,V,V,V >()( \
1743  getClientStub() , \
1744  a1,a2,a3,a4,a5,a6,a7,a8,a9,a10 , \
1745  V(),V(),V(),V(),V()).r.get(), \
1746  getClientStub(), \
1747  id::value, \
1748  callOptions.apply(getClientStub()), \
1749  #func, \
1750  "V10"); \
1751  } \
1752  const char * getFunctionName(const id &) \
1753  { \
1754  return #func; \
1755  } \
1756  const char * getArity(const id &) \
1757  { \
1758  return "V10"; \
1759  } \
1760  \
1761  private: \
1762  template<typename T> \
1763  void callMethod( \
1764  const id &, \
1765  ::RCF::RcfSession &session, \
1766  T &t) \
1767  { \
1768  ::RCF::ServerParameters< \
1769  V , \
1770  A1,A2,A3,A4,A5,A6,A7,A8,A9,A10 > &p = \
1771  ::RCF::AllocateServerParameters< \
1772  V , \
1773  A1,A2,A3,A4,A5,A6,A7,A8,A9,A10 >()(session); \
1774  RCF_UNUSED_VARIABLE(p); \
1775  t.func( \
1776  p.a1.get(), \
1777  p.a2.get(), \
1778  p.a3.get(), \
1779  p.a4.get(), \
1780  p.a5.get(), \
1781  p.a6.get(), \
1782  p.a7.get(), \
1783  p.a8.get(), \
1784  p.a9.get(), \
1785  p.a10.get()); \
1786  }
1787 
1788 
1789 
1790 
1791 //------------------------------------------------------------------------------
1792 // Parameters - R11
1793 //------------------------------------------------------------------------------
1794 
1795 // RCF_METHOD_R11
1796 #define RCF_METHOD_R11(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11) \
1797  RCF_METHOD_R11_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11, RCF_MAKE_UNIQUE_ID(func, R11))
1798 
1799 #define RCF_METHOD_R11_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11, id) \
1800  public: \
1801  RCF_MAKE_NEXT_DISPATCH_ID(id) \
1802  ::RCF::FutureConverter<R > func( \
1803  ::RCF::RemoveOut<A1 >::type a1, \
1804  ::RCF::RemoveOut<A2 >::type a2, \
1805  ::RCF::RemoveOut<A3 >::type a3, \
1806  ::RCF::RemoveOut<A4 >::type a4, \
1807  ::RCF::RemoveOut<A5 >::type a5, \
1808  ::RCF::RemoveOut<A6 >::type a6, \
1809  ::RCF::RemoveOut<A7 >::type a7, \
1810  ::RCF::RemoveOut<A8 >::type a8, \
1811  ::RCF::RemoveOut<A9 >::type a9, \
1812  ::RCF::RemoveOut<A10 >::type a10, \
1813  ::RCF::RemoveOut<A11 >::type a11) \
1814  { \
1815  return func( \
1816  ::RCF::CallOptions() , \
1817  a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11); \
1818  } \
1819  ::RCF::FutureConverter<R > func( \
1820  const ::RCF::CallOptions &callOptions , \
1821  ::RCF::RemoveOut<A1 >::type a1, \
1822  ::RCF::RemoveOut<A2 >::type a2, \
1823  ::RCF::RemoveOut<A3 >::type a3, \
1824  ::RCF::RemoveOut<A4 >::type a4, \
1825  ::RCF::RemoveOut<A5 >::type a5, \
1826  ::RCF::RemoveOut<A6 >::type a6, \
1827  ::RCF::RemoveOut<A7 >::type a7, \
1828  ::RCF::RemoveOut<A8 >::type a8, \
1829  ::RCF::RemoveOut<A9 >::type a9, \
1830  ::RCF::RemoveOut<A10 >::type a10, \
1831  ::RCF::RemoveOut<A11 >::type a11) \
1832  { \
1833  getClientStub().setAsync(false); \
1834  return RCF::FutureConverter<R >( \
1835  ::RCF::AllocateClientParameters< \
1836  R , \
1837  A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11 , \
1838  V,V,V,V >()( \
1839  getClientStub() , \
1840  a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11 , \
1841  V(),V(),V(),V()).r.get(), \
1842  getClientStub(), \
1843  id::value, \
1844  callOptions.apply(getClientStub()), \
1845  #func, \
1846  "R11"); \
1847  } \
1848  const char * getFunctionName(const id &) \
1849  { \
1850  return #func; \
1851  } \
1852  const char * getArity(const id &) \
1853  { \
1854  return "R11"; \
1855  } \
1856  \
1857  private: \
1858  template<typename T> \
1859  void callMethod( \
1860  const id &, \
1861  ::RCF::RcfSession &session, \
1862  T &t) \
1863  { \
1864  ::RCF::ServerParameters< \
1865  R , \
1866  A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11 > &p = \
1867  ::RCF::AllocateServerParameters< \
1868  R , \
1869  A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11 >()(session); \
1870  p.r.set( \
1871  session.getAutoSend(), \
1872  t.func( \
1873  p.a1.get(), \
1874  p.a2.get(), \
1875  p.a3.get(), \
1876  p.a4.get(), \
1877  p.a5.get(), \
1878  p.a6.get(), \
1879  p.a7.get(), \
1880  p.a8.get(), \
1881  p.a9.get(), \
1882  p.a10.get(), \
1883  p.a11.get())); \
1884  }
1885 
1886 
1887 
1888 
1889 //------------------------------------------------------------------------------
1890 // Parameters - V11
1891 //------------------------------------------------------------------------------
1892 
1893 // RCF_METHOD_V11
1894 #define RCF_METHOD_V11(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11) \
1895  RCF_METHOD_V11_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11, RCF_MAKE_UNIQUE_ID(func, V11))
1896 
1897 #define RCF_METHOD_V11_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11, id) \
1898  public: \
1899  static_assert( std::is_same<R, void>::value, "RCF_METHOD_Vn() must be used for methods returning void." );\
1900  RCF_MAKE_NEXT_DISPATCH_ID(id) \
1901  ::RCF::FutureConverter<V> func( \
1902  ::RCF::RemoveOut<A1 >::type a1, \
1903  ::RCF::RemoveOut<A2 >::type a2, \
1904  ::RCF::RemoveOut<A3 >::type a3, \
1905  ::RCF::RemoveOut<A4 >::type a4, \
1906  ::RCF::RemoveOut<A5 >::type a5, \
1907  ::RCF::RemoveOut<A6 >::type a6, \
1908  ::RCF::RemoveOut<A7 >::type a7, \
1909  ::RCF::RemoveOut<A8 >::type a8, \
1910  ::RCF::RemoveOut<A9 >::type a9, \
1911  ::RCF::RemoveOut<A10 >::type a10, \
1912  ::RCF::RemoveOut<A11 >::type a11) \
1913  { \
1914  return func( \
1915  ::RCF::CallOptions() , \
1916  a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11); \
1917  } \
1918  ::RCF::FutureConverter<V> func( \
1919  const ::RCF::CallOptions &callOptions , \
1920  ::RCF::RemoveOut<A1 >::type a1, \
1921  ::RCF::RemoveOut<A2 >::type a2, \
1922  ::RCF::RemoveOut<A3 >::type a3, \
1923  ::RCF::RemoveOut<A4 >::type a4, \
1924  ::RCF::RemoveOut<A5 >::type a5, \
1925  ::RCF::RemoveOut<A6 >::type a6, \
1926  ::RCF::RemoveOut<A7 >::type a7, \
1927  ::RCF::RemoveOut<A8 >::type a8, \
1928  ::RCF::RemoveOut<A9 >::type a9, \
1929  ::RCF::RemoveOut<A10 >::type a10, \
1930  ::RCF::RemoveOut<A11 >::type a11) \
1931  { \
1932  getClientStub().setAsync(false); \
1933  return RCF::FutureConverter<V>( \
1934  ::RCF::AllocateClientParameters< \
1935  V , \
1936  A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11 , \
1937  V,V,V,V >()( \
1938  getClientStub() , \
1939  a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11 , \
1940  V(),V(),V(),V()).r.get(), \
1941  getClientStub(), \
1942  id::value, \
1943  callOptions.apply(getClientStub()), \
1944  #func, \
1945  "V11"); \
1946  } \
1947  const char * getFunctionName(const id &) \
1948  { \
1949  return #func; \
1950  } \
1951  const char * getArity(const id &) \
1952  { \
1953  return "V11"; \
1954  } \
1955  \
1956  private: \
1957  template<typename T> \
1958  void callMethod( \
1959  const id &, \
1960  ::RCF::RcfSession &session, \
1961  T &t) \
1962  { \
1963  ::RCF::ServerParameters< \
1964  V , \
1965  A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11 > &p = \
1966  ::RCF::AllocateServerParameters< \
1967  V , \
1968  A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11 >()(session); \
1969  RCF_UNUSED_VARIABLE(p); \
1970  t.func( \
1971  p.a1.get(), \
1972  p.a2.get(), \
1973  p.a3.get(), \
1974  p.a4.get(), \
1975  p.a5.get(), \
1976  p.a6.get(), \
1977  p.a7.get(), \
1978  p.a8.get(), \
1979  p.a9.get(), \
1980  p.a10.get(), \
1981  p.a11.get()); \
1982  }
1983 
1984 
1985 
1986 
1987 //------------------------------------------------------------------------------
1988 // Parameters - R12
1989 //------------------------------------------------------------------------------
1990 
1991 // RCF_METHOD_R12
1992 #define RCF_METHOD_R12(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12) \
1993  RCF_METHOD_R12_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12, RCF_MAKE_UNIQUE_ID(func, R12))
1994 
1995 #define RCF_METHOD_R12_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12, id) \
1996  public: \
1997  RCF_MAKE_NEXT_DISPATCH_ID(id) \
1998  ::RCF::FutureConverter<R > func( \
1999  ::RCF::RemoveOut<A1 >::type a1, \
2000  ::RCF::RemoveOut<A2 >::type a2, \
2001  ::RCF::RemoveOut<A3 >::type a3, \
2002  ::RCF::RemoveOut<A4 >::type a4, \
2003  ::RCF::RemoveOut<A5 >::type a5, \
2004  ::RCF::RemoveOut<A6 >::type a6, \
2005  ::RCF::RemoveOut<A7 >::type a7, \
2006  ::RCF::RemoveOut<A8 >::type a8, \
2007  ::RCF::RemoveOut<A9 >::type a9, \
2008  ::RCF::RemoveOut<A10 >::type a10, \
2009  ::RCF::RemoveOut<A11 >::type a11, \
2010  ::RCF::RemoveOut<A12 >::type a12) \
2011  { \
2012  return func( \
2013  ::RCF::CallOptions() , \
2014  a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12); \
2015  } \
2016  ::RCF::FutureConverter<R > func( \
2017  const ::RCF::CallOptions &callOptions , \
2018  ::RCF::RemoveOut<A1 >::type a1, \
2019  ::RCF::RemoveOut<A2 >::type a2, \
2020  ::RCF::RemoveOut<A3 >::type a3, \
2021  ::RCF::RemoveOut<A4 >::type a4, \
2022  ::RCF::RemoveOut<A5 >::type a5, \
2023  ::RCF::RemoveOut<A6 >::type a6, \
2024  ::RCF::RemoveOut<A7 >::type a7, \
2025  ::RCF::RemoveOut<A8 >::type a8, \
2026  ::RCF::RemoveOut<A9 >::type a9, \
2027  ::RCF::RemoveOut<A10 >::type a10, \
2028  ::RCF::RemoveOut<A11 >::type a11, \
2029  ::RCF::RemoveOut<A12 >::type a12) \
2030  { \
2031  getClientStub().setAsync(false); \
2032  return RCF::FutureConverter<R >( \
2033  ::RCF::AllocateClientParameters< \
2034  R , \
2035  A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12 , \
2036  V,V,V >()( \
2037  getClientStub() , \
2038  a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12 , \
2039  V(),V(),V()).r.get(), \
2040  getClientStub(), \
2041  id::value, \
2042  callOptions.apply(getClientStub()), \
2043  #func, \
2044  "R12"); \
2045  } \
2046  const char * getFunctionName(const id &) \
2047  { \
2048  return #func; \
2049  } \
2050  const char * getArity(const id &) \
2051  { \
2052  return "R12"; \
2053  } \
2054  \
2055  private: \
2056  template<typename T> \
2057  void callMethod( \
2058  const id &, \
2059  ::RCF::RcfSession &session, \
2060  T &t) \
2061  { \
2062  ::RCF::ServerParameters< \
2063  R , \
2064  A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12 > &p = \
2065  ::RCF::AllocateServerParameters< \
2066  R , \
2067  A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12 >()(session); \
2068  p.r.set( \
2069  session.getAutoSend(), \
2070  t.func( \
2071  p.a1.get(), \
2072  p.a2.get(), \
2073  p.a3.get(), \
2074  p.a4.get(), \
2075  p.a5.get(), \
2076  p.a6.get(), \
2077  p.a7.get(), \
2078  p.a8.get(), \
2079  p.a9.get(), \
2080  p.a10.get(), \
2081  p.a11.get(), \
2082  p.a12.get())); \
2083  }
2084 
2085 
2086 
2087 
2088 //------------------------------------------------------------------------------
2089 // Parameters - V12
2090 //------------------------------------------------------------------------------
2091 
2092 // RCF_METHOD_V12
2093 #define RCF_METHOD_V12(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12) \
2094  RCF_METHOD_V12_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12, RCF_MAKE_UNIQUE_ID(func, V12))
2095 
2096 #define RCF_METHOD_V12_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12, id) \
2097  public: \
2098  static_assert( std::is_same<R, void>::value, "RCF_METHOD_Vn() must be used for methods returning void." );\
2099  RCF_MAKE_NEXT_DISPATCH_ID(id) \
2100  ::RCF::FutureConverter<V> func( \
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  ::RCF::RemoveOut<A6 >::type a6, \
2107  ::RCF::RemoveOut<A7 >::type a7, \
2108  ::RCF::RemoveOut<A8 >::type a8, \
2109  ::RCF::RemoveOut<A9 >::type a9, \
2110  ::RCF::RemoveOut<A10 >::type a10, \
2111  ::RCF::RemoveOut<A11 >::type a11, \
2112  ::RCF::RemoveOut<A12 >::type a12) \
2113  { \
2114  return func( \
2115  ::RCF::CallOptions() , \
2116  a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12); \
2117  } \
2118  ::RCF::FutureConverter<V> func( \
2119  const ::RCF::CallOptions &callOptions , \
2120  ::RCF::RemoveOut<A1 >::type a1, \
2121  ::RCF::RemoveOut<A2 >::type a2, \
2122  ::RCF::RemoveOut<A3 >::type a3, \
2123  ::RCF::RemoveOut<A4 >::type a4, \
2124  ::RCF::RemoveOut<A5 >::type a5, \
2125  ::RCF::RemoveOut<A6 >::type a6, \
2126  ::RCF::RemoveOut<A7 >::type a7, \
2127  ::RCF::RemoveOut<A8 >::type a8, \
2128  ::RCF::RemoveOut<A9 >::type a9, \
2129  ::RCF::RemoveOut<A10 >::type a10, \
2130  ::RCF::RemoveOut<A11 >::type a11, \
2131  ::RCF::RemoveOut<A12 >::type a12) \
2132  { \
2133  getClientStub().setAsync(false); \
2134  return RCF::FutureConverter<V>( \
2135  ::RCF::AllocateClientParameters< \
2136  V , \
2137  A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12 , \
2138  V,V,V >()( \
2139  getClientStub() , \
2140  a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12 , \
2141  V(),V(),V()).r.get(), \
2142  getClientStub(), \
2143  id::value, \
2144  callOptions.apply(getClientStub()), \
2145  #func, \
2146  "V12"); \
2147  } \
2148  const char * getFunctionName(const id &) \
2149  { \
2150  return #func; \
2151  } \
2152  const char * getArity(const id &) \
2153  { \
2154  return "V12"; \
2155  } \
2156  \
2157  private: \
2158  template<typename T> \
2159  void callMethod( \
2160  const id &, \
2161  ::RCF::RcfSession &session, \
2162  T &t) \
2163  { \
2164  ::RCF::ServerParameters< \
2165  V , \
2166  A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12 > &p = \
2167  ::RCF::AllocateServerParameters< \
2168  V , \
2169  A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12 >()(session);\
2170  RCF_UNUSED_VARIABLE(p); \
2171  t.func( \
2172  p.a1.get(), \
2173  p.a2.get(), \
2174  p.a3.get(), \
2175  p.a4.get(), \
2176  p.a5.get(), \
2177  p.a6.get(), \
2178  p.a7.get(), \
2179  p.a8.get(), \
2180  p.a9.get(), \
2181  p.a10.get(), \
2182  p.a11.get(), \
2183  p.a12.get()); \
2184  }
2185 
2186 
2187 
2188 
2189 //------------------------------------------------------------------------------
2190 // Parameters - R13
2191 //------------------------------------------------------------------------------
2192 
2193 // RCF_METHOD_R13
2194 #define RCF_METHOD_R13(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13) \
2195  RCF_METHOD_R13_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13, RCF_MAKE_UNIQUE_ID(func, R13))
2196 
2197 #define RCF_METHOD_R13_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13, id)\
2198  public: \
2199  RCF_MAKE_NEXT_DISPATCH_ID(id) \
2200  ::RCF::FutureConverter<R > func( \
2201  ::RCF::RemoveOut<A1 >::type a1, \
2202  ::RCF::RemoveOut<A2 >::type a2, \
2203  ::RCF::RemoveOut<A3 >::type a3, \
2204  ::RCF::RemoveOut<A4 >::type a4, \
2205  ::RCF::RemoveOut<A5 >::type a5, \
2206  ::RCF::RemoveOut<A6 >::type a6, \
2207  ::RCF::RemoveOut<A7 >::type a7, \
2208  ::RCF::RemoveOut<A8 >::type a8, \
2209  ::RCF::RemoveOut<A9 >::type a9, \
2210  ::RCF::RemoveOut<A10 >::type a10, \
2211  ::RCF::RemoveOut<A11 >::type a11, \
2212  ::RCF::RemoveOut<A12 >::type a12, \
2213  ::RCF::RemoveOut<A13 >::type a13) \
2214  { \
2215  return func( \
2216  ::RCF::CallOptions() , \
2217  a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13); \
2218  } \
2219  ::RCF::FutureConverter<R > func( \
2220  const ::RCF::CallOptions &callOptions , \
2221  ::RCF::RemoveOut<A1 >::type a1, \
2222  ::RCF::RemoveOut<A2 >::type a2, \
2223  ::RCF::RemoveOut<A3 >::type a3, \
2224  ::RCF::RemoveOut<A4 >::type a4, \
2225  ::RCF::RemoveOut<A5 >::type a5, \
2226  ::RCF::RemoveOut<A6 >::type a6, \
2227  ::RCF::RemoveOut<A7 >::type a7, \
2228  ::RCF::RemoveOut<A8 >::type a8, \
2229  ::RCF::RemoveOut<A9 >::type a9, \
2230  ::RCF::RemoveOut<A10 >::type a10, \
2231  ::RCF::RemoveOut<A11 >::type a11, \
2232  ::RCF::RemoveOut<A12 >::type a12, \
2233  ::RCF::RemoveOut<A13 >::type a13) \
2234  { \
2235  getClientStub().setAsync(false); \
2236  return RCF::FutureConverter<R >( \
2237  ::RCF::AllocateClientParameters< \
2238  R , \
2239  A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13 , \
2240  V,V >()( \
2241  getClientStub() , \
2242  a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13 , \
2243  V(),V()).r.get(), \
2244  getClientStub(), \
2245  id::value, \
2246  callOptions.apply(getClientStub()), \
2247  #func, \
2248  "R13"); \
2249  } \
2250  const char * getFunctionName(const id &) \
2251  { \
2252  return #func; \
2253  } \
2254  const char * getArity(const id &) \
2255  { \
2256  return "R13"; \
2257  } \
2258  \
2259  private: \
2260  template<typename T> \
2261  void callMethod( \
2262  const id &, \
2263  ::RCF::RcfSession &session, \
2264  T &t) \
2265  { \
2266  ::RCF::ServerParameters< \
2267  R , \
2268  A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13 > &p = \
2269  ::RCF::AllocateServerParameters< \
2270  R , \
2271  A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13 >()(session);\
2272  p.r.set( \
2273  session.getAutoSend(), \
2274  t.func( \
2275  p.a1.get(), \
2276  p.a2.get(), \
2277  p.a3.get(), \
2278  p.a4.get(), \
2279  p.a5.get(), \
2280  p.a6.get(), \
2281  p.a7.get(), \
2282  p.a8.get(), \
2283  p.a9.get(), \
2284  p.a10.get(), \
2285  p.a11.get(), \
2286  p.a12.get(), \
2287  p.a13.get())); \
2288  }
2289 
2290 
2291 
2292 
2293 //------------------------------------------------------------------------------
2294 // Parameters - V13
2295 //------------------------------------------------------------------------------
2296 
2297 // RCF_METHOD_V13
2298 #define RCF_METHOD_V13(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13) \
2299  RCF_METHOD_V13_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13, RCF_MAKE_UNIQUE_ID(func, V13))
2300 
2301 #define RCF_METHOD_V13_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13, id)\
2302  public: \
2303  static_assert( std::is_same<R, void>::value, "RCF_METHOD_Vn() must be used for methods returning void." );\
2304  RCF_MAKE_NEXT_DISPATCH_ID(id) \
2305  ::RCF::FutureConverter<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  ::RCF::RemoveOut<A6 >::type a6, \
2312  ::RCF::RemoveOut<A7 >::type a7, \
2313  ::RCF::RemoveOut<A8 >::type a8, \
2314  ::RCF::RemoveOut<A9 >::type a9, \
2315  ::RCF::RemoveOut<A10 >::type a10, \
2316  ::RCF::RemoveOut<A11 >::type a11, \
2317  ::RCF::RemoveOut<A12 >::type a12, \
2318  ::RCF::RemoveOut<A13 >::type a13) \
2319  { \
2320  return func( \
2321  ::RCF::CallOptions() , \
2322  a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13); \
2323  } \
2324  ::RCF::FutureConverter<V> func( \
2325  const ::RCF::CallOptions &callOptions , \
2326  ::RCF::RemoveOut<A1 >::type a1, \
2327  ::RCF::RemoveOut<A2 >::type a2, \
2328  ::RCF::RemoveOut<A3 >::type a3, \
2329  ::RCF::RemoveOut<A4 >::type a4, \
2330  ::RCF::RemoveOut<A5 >::type a5, \
2331  ::RCF::RemoveOut<A6 >::type a6, \
2332  ::RCF::RemoveOut<A7 >::type a7, \
2333  ::RCF::RemoveOut<A8 >::type a8, \
2334  ::RCF::RemoveOut<A9 >::type a9, \
2335  ::RCF::RemoveOut<A10 >::type a10, \
2336  ::RCF::RemoveOut<A11 >::type a11, \
2337  ::RCF::RemoveOut<A12 >::type a12, \
2338  ::RCF::RemoveOut<A13 >::type a13) \
2339  { \
2340  getClientStub().setAsync(false); \
2341  return RCF::FutureConverter<V>( \
2342  ::RCF::AllocateClientParameters< \
2343  V , \
2344  A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13 , \
2345  V,V >()( \
2346  getClientStub() , \
2347  a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13 , \
2348  V(),V()).r.get(), \
2349  getClientStub(), \
2350  id::value, \
2351  callOptions.apply(getClientStub()), \
2352  #func, \
2353  "V13"); \
2354  } \
2355  const char * getFunctionName(const id &) \
2356  { \
2357  return #func; \
2358  } \
2359  const char * getArity(const id &) \
2360  { \
2361  return "V13"; \
2362  } \
2363  \
2364  private: \
2365  template<typename T> \
2366  void callMethod( \
2367  const id &, \
2368  ::RCF::RcfSession &session, \
2369  T &t) \
2370  { \
2371  ::RCF::ServerParameters< \
2372  V , \
2373  A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13 > &p = \
2374  ::RCF::AllocateServerParameters< \
2375  V , \
2376  A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13 >()(session);\
2377  RCF_UNUSED_VARIABLE(p); \
2378  t.func( \
2379  p.a1.get(), \
2380  p.a2.get(), \
2381  p.a3.get(), \
2382  p.a4.get(), \
2383  p.a5.get(), \
2384  p.a6.get(), \
2385  p.a7.get(), \
2386  p.a8.get(), \
2387  p.a9.get(), \
2388  p.a10.get(), \
2389  p.a11.get(), \
2390  p.a12.get(), \
2391  p.a13.get()); \
2392  }
2393 
2394 
2395 
2396 
2397 //------------------------------------------------------------------------------
2398 // Parameters - R14
2399 //------------------------------------------------------------------------------
2400 
2401 // RCF_METHOD_R14
2402 #define RCF_METHOD_R14(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14)\
2403  RCF_METHOD_R14_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14, RCF_MAKE_UNIQUE_ID(func, R14))
2404 
2405 #define RCF_METHOD_R14_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14, id)\
2406  public: \
2407  RCF_MAKE_NEXT_DISPATCH_ID(id) \
2408  ::RCF::FutureConverter<R > func( \
2409  ::RCF::RemoveOut<A1 >::type a1, \
2410  ::RCF::RemoveOut<A2 >::type a2, \
2411  ::RCF::RemoveOut<A3 >::type a3, \
2412  ::RCF::RemoveOut<A4 >::type a4, \
2413  ::RCF::RemoveOut<A5 >::type a5, \
2414  ::RCF::RemoveOut<A6 >::type a6, \
2415  ::RCF::RemoveOut<A7 >::type a7, \
2416  ::RCF::RemoveOut<A8 >::type a8, \
2417  ::RCF::RemoveOut<A9 >::type a9, \
2418  ::RCF::RemoveOut<A10 >::type a10, \
2419  ::RCF::RemoveOut<A11 >::type a11, \
2420  ::RCF::RemoveOut<A12 >::type a12, \
2421  ::RCF::RemoveOut<A13 >::type a13, \
2422  ::RCF::RemoveOut<A14 >::type a14) \
2423  { \
2424  return func( \
2425  ::RCF::CallOptions() , \
2426  a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14); \
2427  } \
2428  ::RCF::FutureConverter<R > func( \
2429  const ::RCF::CallOptions &callOptions , \
2430  ::RCF::RemoveOut<A1 >::type a1, \
2431  ::RCF::RemoveOut<A2 >::type a2, \
2432  ::RCF::RemoveOut<A3 >::type a3, \
2433  ::RCF::RemoveOut<A4 >::type a4, \
2434  ::RCF::RemoveOut<A5 >::type a5, \
2435  ::RCF::RemoveOut<A6 >::type a6, \
2436  ::RCF::RemoveOut<A7 >::type a7, \
2437  ::RCF::RemoveOut<A8 >::type a8, \
2438  ::RCF::RemoveOut<A9 >::type a9, \
2439  ::RCF::RemoveOut<A10 >::type a10, \
2440  ::RCF::RemoveOut<A11 >::type a11, \
2441  ::RCF::RemoveOut<A12 >::type a12, \
2442  ::RCF::RemoveOut<A13 >::type a13, \
2443  ::RCF::RemoveOut<A14 >::type a14) \
2444  { \
2445  getClientStub().setAsync(false); \
2446  return RCF::FutureConverter<R >( \
2447  ::RCF::AllocateClientParameters< \
2448  R , \
2449  A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14 , \
2450  V >()( \
2451  getClientStub() , \
2452  a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14 , \
2453  V()).r.get(), \
2454  getClientStub(), \
2455  id::value, \
2456  callOptions.apply(getClientStub()), \
2457  #func, \
2458  "R14"); \
2459  } \
2460  const char * getFunctionName(const id &) \
2461  { \
2462  return #func; \
2463  } \
2464  const char * getArity(const id &) \
2465  { \
2466  return "R14"; \
2467  } \
2468  \
2469  private: \
2470  template<typename T> \
2471  void callMethod( \
2472  const id &, \
2473  ::RCF::RcfSession &session, \
2474  T &t) \
2475  { \
2476  ::RCF::ServerParameters< \
2477  R , \
2478  A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14 > &p = \
2479  ::RCF::AllocateServerParameters< \
2480  R , \
2481  A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14 >()(session);\
2482  p.r.set( \
2483  session.getAutoSend(), \
2484  t.func( \
2485  p.a1.get(), \
2486  p.a2.get(), \
2487  p.a3.get(), \
2488  p.a4.get(), \
2489  p.a5.get(), \
2490  p.a6.get(), \
2491  p.a7.get(), \
2492  p.a8.get(), \
2493  p.a9.get(), \
2494  p.a10.get(), \
2495  p.a11.get(), \
2496  p.a12.get(), \
2497  p.a13.get(), \
2498  p.a14.get())); \
2499  }
2500 
2501 
2502 
2503 
2504 //------------------------------------------------------------------------------
2505 // Parameters - V14
2506 //------------------------------------------------------------------------------
2507 
2508 // RCF_METHOD_V14
2509 #define RCF_METHOD_V14(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14)\
2510  RCF_METHOD_V14_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14, RCF_MAKE_UNIQUE_ID(func, V14))
2511 
2512 #define RCF_METHOD_V14_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14, id)\
2513  public: \
2514  static_assert( std::is_same<R, void>::value, "RCF_METHOD_Vn() must be used for methods returning void." );\
2515  RCF_MAKE_NEXT_DISPATCH_ID(id) \
2516  ::RCF::FutureConverter<V> func( \
2517  ::RCF::RemoveOut<A1 >::type a1, \
2518  ::RCF::RemoveOut<A2 >::type a2, \
2519  ::RCF::RemoveOut<A3 >::type a3, \
2520  ::RCF::RemoveOut<A4 >::type a4, \
2521  ::RCF::RemoveOut<A5 >::type a5, \
2522  ::RCF::RemoveOut<A6 >::type a6, \
2523  ::RCF::RemoveOut<A7 >::type a7, \
2524  ::RCF::RemoveOut<A8 >::type a8, \
2525  ::RCF::RemoveOut<A9 >::type a9, \
2526  ::RCF::RemoveOut<A10 >::type a10, \
2527  ::RCF::RemoveOut<A11 >::type a11, \
2528  ::RCF::RemoveOut<A12 >::type a12, \
2529  ::RCF::RemoveOut<A13 >::type a13, \
2530  ::RCF::RemoveOut<A14 >::type a14) \
2531  { \
2532  return func( \
2533  ::RCF::CallOptions() , \
2534  a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14); \
2535  } \
2536  ::RCF::FutureConverter<V> func( \
2537  const ::RCF::CallOptions &callOptions , \
2538  ::RCF::RemoveOut<A1 >::type a1, \
2539  ::RCF::RemoveOut<A2 >::type a2, \
2540  ::RCF::RemoveOut<A3 >::type a3, \
2541  ::RCF::RemoveOut<A4 >::type a4, \
2542  ::RCF::RemoveOut<A5 >::type a5, \
2543  ::RCF::RemoveOut<A6 >::type a6, \
2544  ::RCF::RemoveOut<A7 >::type a7, \
2545  ::RCF::RemoveOut<A8 >::type a8, \
2546  ::RCF::RemoveOut<A9 >::type a9, \
2547  ::RCF::RemoveOut<A10 >::type a10, \
2548  ::RCF::RemoveOut<A11 >::type a11, \
2549  ::RCF::RemoveOut<A12 >::type a12, \
2550  ::RCF::RemoveOut<A13 >::type a13, \
2551  ::RCF::RemoveOut<A14 >::type a14) \
2552  { \
2553  getClientStub().setAsync(false); \
2554  return RCF::FutureConverter<V>( \
2555  ::RCF::AllocateClientParameters< \
2556  V , \
2557  A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14 , \
2558  V >()( \
2559  getClientStub() , \
2560  a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14 , \
2561  V()).r.get(), \
2562  getClientStub(), \
2563  id::value, \
2564  callOptions.apply(getClientStub()), \
2565  #func, \
2566  "V14"); \
2567  } \
2568  const char * getFunctionName(const id &) \
2569  { \
2570  return #func; \
2571  } \
2572  const char * getArity(const id &) \
2573  { \
2574  return "V14"; \
2575  } \
2576  \
2577  private: \
2578  template<typename T> \
2579  void callMethod( \
2580  const id &, \
2581  ::RCF::RcfSession &session, \
2582  T &t) \
2583  { \
2584  ::RCF::ServerParameters< \
2585  V , \
2586  A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14 > &p = \
2587  ::RCF::AllocateServerParameters< \
2588  V , \
2589  A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14 >()(session);\
2590  RCF_UNUSED_VARIABLE(p); \
2591  t.func( \
2592  p.a1.get(), \
2593  p.a2.get(), \
2594  p.a3.get(), \
2595  p.a4.get(), \
2596  p.a5.get(), \
2597  p.a6.get(), \
2598  p.a7.get(), \
2599  p.a8.get(), \
2600  p.a9.get(), \
2601  p.a10.get(), \
2602  p.a11.get(), \
2603  p.a12.get(), \
2604  p.a13.get(), \
2605  p.a14.get()); \
2606  }
2607 
2608 
2609 
2610 
2611 //------------------------------------------------------------------------------
2612 // Parameters - R15
2613 //------------------------------------------------------------------------------
2614 
2615 // RCF_METHOD_R15
2616 #define RCF_METHOD_R15(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15)\
2617  RCF_METHOD_R15_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15, RCF_MAKE_UNIQUE_ID(func, R15))
2618 
2619 #define RCF_METHOD_R15_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15, id)\
2620  public: \
2621  RCF_MAKE_NEXT_DISPATCH_ID(id) \
2622  ::RCF::FutureConverter<R > func( \
2623  ::RCF::RemoveOut<A1 >::type a1, \
2624  ::RCF::RemoveOut<A2 >::type a2, \
2625  ::RCF::RemoveOut<A3 >::type a3, \
2626  ::RCF::RemoveOut<A4 >::type a4, \
2627  ::RCF::RemoveOut<A5 >::type a5, \
2628  ::RCF::RemoveOut<A6 >::type a6, \
2629  ::RCF::RemoveOut<A7 >::type a7, \
2630  ::RCF::RemoveOut<A8 >::type a8, \
2631  ::RCF::RemoveOut<A9 >::type a9, \
2632  ::RCF::RemoveOut<A10 >::type a10, \
2633  ::RCF::RemoveOut<A11 >::type a11, \
2634  ::RCF::RemoveOut<A12 >::type a12, \
2635  ::RCF::RemoveOut<A13 >::type a13, \
2636  ::RCF::RemoveOut<A14 >::type a14, \
2637  ::RCF::RemoveOut<A15 >::type a15) \
2638  { \
2639  return func( \
2640  ::RCF::CallOptions() , \
2641  a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15); \
2642  } \
2643  ::RCF::FutureConverter<R > func( \
2644  const ::RCF::CallOptions &callOptions , \
2645  ::RCF::RemoveOut<A1 >::type a1, \
2646  ::RCF::RemoveOut<A2 >::type a2, \
2647  ::RCF::RemoveOut<A3 >::type a3, \
2648  ::RCF::RemoveOut<A4 >::type a4, \
2649  ::RCF::RemoveOut<A5 >::type a5, \
2650  ::RCF::RemoveOut<A6 >::type a6, \
2651  ::RCF::RemoveOut<A7 >::type a7, \
2652  ::RCF::RemoveOut<A8 >::type a8, \
2653  ::RCF::RemoveOut<A9 >::type a9, \
2654  ::RCF::RemoveOut<A10 >::type a10, \
2655  ::RCF::RemoveOut<A11 >::type a11, \
2656  ::RCF::RemoveOut<A12 >::type a12, \
2657  ::RCF::RemoveOut<A13 >::type a13, \
2658  ::RCF::RemoveOut<A14 >::type a14, \
2659  ::RCF::RemoveOut<A15 >::type a15) \
2660  { \
2661  getClientStub().setAsync(false); \
2662  return RCF::FutureConverter<R >( \
2663  ::RCF::AllocateClientParameters< \
2664  R , \
2665  A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15 \
2666  >()( \
2667  getClientStub() , \
2668  a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15 \
2669  ).r.get(), \
2670  getClientStub(), \
2671  id::value, \
2672  callOptions.apply(getClientStub()), \
2673  #func, \
2674  "R15"); \
2675  } \
2676  const char * getFunctionName(const id &) \
2677  { \
2678  return #func; \
2679  } \
2680  const char * getArity(const id &) \
2681  { \
2682  return "R15"; \
2683  } \
2684  \
2685  private: \
2686  template<typename T> \
2687  void callMethod( \
2688  const id &, \
2689  ::RCF::RcfSession &session, \
2690  T &t) \
2691  { \
2692  ::RCF::ServerParameters< \
2693  R , \
2694  A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15 > &p = \
2695  ::RCF::AllocateServerParameters< \
2696  R , \
2697  A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15 >()(session);\
2698  p.r.set( \
2699  session.getAutoSend(), \
2700  t.func( \
2701  p.a1.get(), \
2702  p.a2.get(), \
2703  p.a3.get(), \
2704  p.a4.get(), \
2705  p.a5.get(), \
2706  p.a6.get(), \
2707  p.a7.get(), \
2708  p.a8.get(), \
2709  p.a9.get(), \
2710  p.a10.get(), \
2711  p.a11.get(), \
2712  p.a12.get(), \
2713  p.a13.get(), \
2714  p.a14.get(), \
2715  p.a15.get())); \
2716  }
2717 
2718 
2719 
2720 
2721 //------------------------------------------------------------------------------
2722 // Parameters - V15
2723 //------------------------------------------------------------------------------
2724 
2725 // RCF_METHOD_V15
2726 #define RCF_METHOD_V15(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15)\
2727  RCF_METHOD_V15_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15, RCF_MAKE_UNIQUE_ID(func, V15))
2728 
2729 #define RCF_METHOD_V15_(R,func , A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15, id)\
2730  public: \
2731  static_assert( std::is_same<R, void>::value, "RCF_METHOD_Vn() must be used for methods returning void." );\
2732  RCF_MAKE_NEXT_DISPATCH_ID(id) \
2733  ::RCF::FutureConverter<V> func( \
2734  ::RCF::RemoveOut<A1 >::type a1, \
2735  ::RCF::RemoveOut<A2 >::type a2, \
2736  ::RCF::RemoveOut<A3 >::type a3, \
2737  ::RCF::RemoveOut<A4 >::type a4, \
2738  ::RCF::RemoveOut<A5 >::type a5, \
2739  ::RCF::RemoveOut<A6 >::type a6, \
2740  ::RCF::RemoveOut<A7 >::type a7, \
2741  ::RCF::RemoveOut<A8 >::type a8, \
2742  ::RCF::RemoveOut<A9 >::type a9, \
2743  ::RCF::RemoveOut<A10 >::type a10, \
2744  ::RCF::RemoveOut<A11 >::type a11, \
2745  ::RCF::RemoveOut<A12 >::type a12, \
2746  ::RCF::RemoveOut<A13 >::type a13, \
2747  ::RCF::RemoveOut<A14 >::type a14, \
2748  ::RCF::RemoveOut<A15 >::type a15) \
2749  { \
2750  return func( \
2751  ::RCF::CallOptions() , \
2752  a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15); \
2753  } \
2754  ::RCF::FutureConverter<V> func( \
2755  const ::RCF::CallOptions &callOptions , \
2756  ::RCF::RemoveOut<A1 >::type a1, \
2757  ::RCF::RemoveOut<A2 >::type a2, \
2758  ::RCF::RemoveOut<A3 >::type a3, \
2759  ::RCF::RemoveOut<A4 >::type a4, \
2760  ::RCF::RemoveOut<A5 >::type a5, \
2761  ::RCF::RemoveOut<A6 >::type a6, \
2762  ::RCF::RemoveOut<A7 >::type a7, \
2763  ::RCF::RemoveOut<A8 >::type a8, \
2764  ::RCF::RemoveOut<A9 >::type a9, \
2765  ::RCF::RemoveOut<A10 >::type a10, \
2766  ::RCF::RemoveOut<A11 >::type a11, \
2767  ::RCF::RemoveOut<A12 >::type a12, \
2768  ::RCF::RemoveOut<A13 >::type a13, \
2769  ::RCF::RemoveOut<A14 >::type a14, \
2770  ::RCF::RemoveOut<A15 >::type a15) \
2771  { \
2772  getClientStub().setAsync(false); \
2773  return RCF::FutureConverter<V>( \
2774  ::RCF::AllocateClientParameters< \
2775  V , \
2776  A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15 \
2777  >()( \
2778  getClientStub() , \
2779  a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15 \
2780  ).r.get(), \
2781  getClientStub(), \
2782  id::value, \
2783  callOptions.apply(getClientStub()), \
2784  #func, \
2785  "V15"); \
2786  } \
2787  const char * getFunctionName(const id &) \
2788  { \
2789  return #func; \
2790  } \
2791  const char * getArity(const id &) \
2792  { \
2793  return "V15"; \
2794  } \
2795  \
2796  private: \
2797  template<typename T> \
2798  void callMethod( \
2799  const id &, \
2800  ::RCF::RcfSession &session, \
2801  T &t) \
2802  { \
2803  ::RCF::ServerParameters< \
2804  V , \
2805  A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15 > &p = \
2806  ::RCF::AllocateServerParameters< \
2807  V , \
2808  A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15 >()(session);\
2809  RCF_UNUSED_VARIABLE(p); \
2810  t.func( \
2811  p.a1.get(), \
2812  p.a2.get(), \
2813  p.a3.get(), \
2814  p.a4.get(), \
2815  p.a5.get(), \
2816  p.a6.get(), \
2817  p.a7.get(), \
2818  p.a8.get(), \
2819  p.a9.get(), \
2820  p.a10.get(), \
2821  p.a11.get(), \
2822  p.a12.get(), \
2823  p.a13.get(), \
2824  p.a14.get(), \
2825  p.a15.get()); \
2826  }
2827 
2828 #endif // ! INCLUDE_RCF_RCFMETHODGEN_HPP