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
Copyright (C)
Delta V Software
2022