blob: 41c14ae4d3435a941dbeaaa8d544332fd75fb2db (
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
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
|
// **********************************************************************
//
// Copyright (c) 2003-2016 ZeroC, Inc. All rights reserved.
//
// This copy of Ice is licensed to you under the terms described in the
// ICE_LICENSE file included in this distribution.
//
// **********************************************************************
#pragma once
["objc:prefix:TestSlicingObjectsServer"]
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 SS
{
SS1 c1;
SS2 c2;
};
dictionary<int, B> BDict;
exception BaseException
{
string sbe;
B pb;
};
exception DerivedException extends BaseException
{
string sde;
D1 pd1;
};
class Forward; /* Forward-declared class defined in another compilation unit */
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;
};
class MyClass
{
int i;
};
class PSUnknown extends Preserved
{
string psu;
PNode graph;
MyClass cl;
};
class PSUnknown2 extends Preserved
{
PBase pb;
};
["preserve-slice"]
exception PreservedException
{
};
exception PSUnknownException extends PreservedException
{
PSUnknown2 p;
};
["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);
SS sequenceTest(SS1 p1, SS2 p2);
BDict dictionaryTest(BDict bin, out BDict bout);
PBase exchangePBase(PBase pb);
Preserved PBSUnknownAsPreserved();
void checkPBSUnknown(Preserved p);
Preserved PBSUnknownAsPreservedWithGraph();
void checkPBSUnknownWithGraph(Preserved p);
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();
};
// Things private to the server.
class SBSUnknownDerived extends SBase
{
string sbsud;
};
class SUnknown
{
string su;
};
class D2 extends B
{
string sd2;
B pd2;
};
class D4 extends B
{
B p1;
B p2;
};
exception UnknownDerivedException extends BaseException
{
string sude;
D2 pd2;
};
};
|
