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