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