blob: b50a94d0c7af48521b4bc0b1646a14509d66adbb (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
|
//
// Copyright (c) ZeroC, Inc. All rights reserved.
//
#pragma once
module Test
{
class SBase
{
string sb;
}
class SBSKnownDerived extends SBase
{
string sbskd;
}
class B
{
string sb;
B pb;
}
class D1 extends B
{
string sd1;
B pd1;
}
sequence<B> BSeq;
class SS1
{
BSeq s;
}
class SS2
{
BSeq s;
}
struct SS3
{
SS1 c1;
SS2 c2;
}
dictionary<int, B> BDict;
exception BaseException
{
string sbe;
B pb;
}
exception DerivedException extends BaseException
{
string sde;
D1 pd1;
}
class Forward;
class PBase
{
int pi;
}
sequence<PBase> PBaseSeq;
["preserve-slice"]
class Preserved extends PBase
{
string ps;
}
class PDerived extends Preserved
{
PBase pb;
}
class CompactPDerived(56) extends Preserved
{
PBase pb;
}
["preserve-slice"]
class PNode
{
PNode next;
}
["preserve-slice"]
exception PreservedException
{
}
["format:sliced"]
interface TestIntf
{
Object SBaseAsObject();
SBase SBaseAsSBase();
SBase SBSKnownDerivedAsSBase();
SBSKnownDerived SBSKnownDerivedAsSBSKnownDerived();
SBase SBSUnknownDerivedAsSBase();
["format:compact"] SBase SBSUnknownDerivedAsSBaseCompact();
Object SUnknownAsObject();
void checkSUnknown(Object o);
B oneElementCycle();
B twoElementCycle();
B D1AsB();
D1 D1AsD1();
B D2AsB();
void paramTest1(out B p1, out B p2);
void paramTest2(out B p2, out B p1);
B paramTest3(out B p1, out B p2);
B paramTest4(out B p);
B returnTest1(out B p1, out B p2);
B returnTest2(out B p2, out B p1);
B returnTest3(B p1, B p2);
SS3 sequenceTest(SS1 p1, SS2 p2);
BDict dictionaryTest(BDict bin, out BDict bout);
PBase exchangePBase(PBase pb);
Preserved PBSUnknownAsPreserved();
void checkPBSUnknown(Preserved p);
["amd"] Preserved PBSUnknownAsPreservedWithGraph();
void checkPBSUnknownWithGraph(Preserved p);
["amd"] Preserved PBSUnknown2AsPreservedWithGraph();
void checkPBSUnknown2WithGraph(Preserved p);
PNode exchangePNode(PNode pn);
void throwBaseAsBase() throws BaseException;
void throwDerivedAsBase() throws BaseException;
void throwDerivedAsDerived() throws DerivedException;
void throwUnknownDerivedAsBase() throws BaseException;
["amd"] void throwPreservedException() throws PreservedException;
void useForward(out Forward f); /* Use of forward-declared class to verify that code is generated correctly. */
void shutdown();
}
class Hidden
{
Forward f;
}
class Forward
{
Hidden h;
}
}
|
