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
|
// **********************************************************************
//
// Copyright (c) 2003-2014 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
#include <Ice/Current.ice>
module Test
{
enum MyEnum
{
enum1,
enum2,
enum3
};
class MyClass;
struct AnotherStruct
{
string s;
};
struct Structure
{
MyClass* p;
MyEnum e;
AnotherStruct s;
};
sequence<byte> ByteS;
sequence<bool> BoolS;
sequence<short> ShortS;
sequence<int> IntS;
sequence<long> LongS;
sequence<float> FloatS;
sequence<double> DoubleS;
sequence<string> StringS;
sequence<MyEnum> MyEnumS;
sequence<MyClass*> MyClassS;
sequence<ByteS> ByteSS;
sequence<BoolS> BoolSS;
sequence<ShortS> ShortSS;
sequence<IntS> IntSS;
sequence<LongS> LongSS;
sequence<FloatS> FloatSS;
sequence<DoubleS> DoubleSS;
sequence<StringS> StringSS;
sequence<MyEnumS> MyEnumSS;
sequence<MyClassS> MyClassSS;
sequence<StringSS> StringSSS;
struct MyStruct
{
int i;
int j;
};
dictionary<byte, bool> ByteBoolD;
dictionary<short, int> ShortIntD;
dictionary<long, float> LongFloatD;
dictionary<string, string> StringStringD;
dictionary<string, MyEnum> StringMyEnumD;
dictionary<MyEnum, string> MyEnumStringD;
dictionary<MyStruct, MyEnum> MyStructMyEnumD;
exception SomeException {};
["ami"] class MyClass
{
void shutdown();
void delay(int ms);
void opVoid();
byte opByte(byte p1, byte p2,
out byte p3);
bool opBool(bool p1, bool p2,
out bool p3);
long opShortIntLong(short p1, int p2, long p3,
out short p4, out int p5, out long p6);
double opFloatDouble(float p1, double p2,
out float p3, out double p4);
string opString(string p1, string p2,
out string p3);
MyEnum opMyEnum(MyEnum p1, out MyEnum p2);
MyClass* opMyClass(MyClass* p1, out MyClass* p2, out MyClass* p3);
Structure opStruct(Structure p1, Structure p2,
out Structure p3);
ByteS opByteS(ByteS p1, ByteS p2,
out ByteS p3);
BoolS opBoolS(BoolS p1, BoolS p2,
out BoolS p3);
LongS opShortIntLongS(Test::ShortS p1, IntS p2, LongS p3,
out ::Test::ShortS p4, out IntS p5, out LongS p6);
DoubleS opFloatDoubleS(FloatS p1, DoubleS p2,
out FloatS p3, out DoubleS p4);
StringS opStringS(StringS p1, StringS p2,
out StringS p3);
ByteSS opByteSS(ByteSS p1, ByteSS p2,
out ByteSS p3);
BoolSS opBoolSS(BoolSS p1, BoolSS p2,
out BoolSS p3);
LongSS opShortIntLongSS(ShortSS p1, IntSS p2, LongSS p3,
out ShortSS p4, out IntSS p5, out LongSS p6);
DoubleSS opFloatDoubleSS(FloatSS p1, DoubleSS p2,
out FloatSS p3, out DoubleSS p4);
StringSS opStringSS(StringSS p1, StringSS p2,
out StringSS p3);
StringSSS opStringSSS(StringSSS p1, StringSSS p2,
out StringSSS p3);
ByteBoolD opByteBoolD(ByteBoolD p1, ByteBoolD p2,
out ByteBoolD p3);
ShortIntD opShortIntD(ShortIntD p1, ShortIntD p2,
out ShortIntD p3);
LongFloatD opLongFloatD(LongFloatD p1, LongFloatD p2,
out LongFloatD p3);
StringStringD opStringStringD(StringStringD p1, StringStringD p2,
out StringStringD p3);
StringMyEnumD opStringMyEnumD(StringMyEnumD p1, StringMyEnumD p2,
out StringMyEnumD p3);
MyEnumStringD opMyEnumStringD(MyEnumStringD p1, MyEnumStringD p2,
out MyEnumStringD p3);
MyStructMyEnumD opMyStructMyEnumD(MyStructMyEnumD p1, MyStructMyEnumD p2,
out MyStructMyEnumD p3);
IntS opIntS(IntS s);
void opByteSOneway(ByteS s);
Ice::Context opContext();
void opDoubleMarshaling(double p1, DoubleS p2);
idempotent void opIdempotent();
["nonmutating"] idempotent void opNonmutating();
};
["ami"] class MyDerivedClass extends MyClass
{
void opDerived();
};
};
|
