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