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