blob: 7c149f965d0135a1f880711c06d2ff30e309700f (
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
|
/* -*- C++ -*- */
// $Id$
interface Cubit
{
// = TITLE
// Defines an interface that encapsulates operations that cube
// numbers.
//
// = DESCRIPTION
// This interface encapsulates operations that cube
// octets, shorts, longs, structs and unions.
oneway void cube_oneway ();
// Test the basic latency of a nil oneway operation.
void cube_void ();
// Test the basic latency of a nil operation.
octet cube_octet (in octet o);
// cube an octet
short cube_short (in short s);
// cube a short
long cube_long (in long l);
// cube a long
struct Many
{
octet o; // + 3 bytes padding (normally) ...
long l;
short s; // + 2 bytes padding (normally) ...
};
Many cube_struct (in Many values);
// Cube a struct
enum discrim
{
e_0th,
e_1st,
e_2nd,
e_3rd
};
// Enumeration of the different elements in a union.
union oneof switch (discrim)
{
// this is an easy union to interpret; no padding
// is needed between discriminant and value.
case e_0th:
octet o;
case e_1st:
short s;
case e_2nd:
long l;
case e_3rd:
Many cm;
// default:
// Many cm;
};
// Union of different types.
oneof cube_union (in oneof values);
// cube a union.
typedef sequence<long> long_seq;
void cube_long_sequence (in long_seq input,
out long_seq output);
// Cube several longs.
typedef sequence<octet> octet_seq;
void cube_octet_sequence (in octet_seq input, out octet_seq output);
// Cube an octet sequence.
typedef sequence<Many> many_seq;
void cube_many_sequence (in many_seq input,
out many_seq output);
// Cube several manys.
oneway void shutdown ();
// shutdown the application.
// = The following types provide a torture-test for structs.
struct RtiPacketHeader
{
unsigned long packetLength; // this is probably redundant
unsigned short federationHandle;
unsigned long channelHandle;
unsigned long packetColor;
};
struct HandleValuePair
{
unsigned short handle;
octet_seq data;
};
enum MessageHeaderTypes
{
objectUpdate,
interaction
// others omitted
};
typedef sequence<HandleValuePair> HandleValuePairSeq;
struct RtiObjectUpdateMessageHeader
{
unsigned long updateLength; // probably redundant
unsigned long updateTag;
unsigned long objectHandle;
double timestamp;
unsigned long long eventRetractionHandle;
unsigned short classHandle;
unsigned short sendingFederateHandle;
string userTag;
octet_seq regionData;
octet transportationHandle;
octet orderingHandle;
HandleValuePairSeq messagePayload;
};
struct RtiInteractionMessageHeader
{
unsigned long updateLength;
// similar to object update
};
union MessageUnion switch(MessageHeaderTypes)
{
case objectUpdate:
RtiObjectUpdateMessageHeader oumh;
case interaction:
RtiInteractionMessageHeader imh;
};
typedef sequence <MessageUnion> MessageUnionSeq;
struct RtiPacket
{
RtiPacketHeader packetHeader;
MessageUnionSeq msgs;
};
void cube_rti_data (in RtiPacket input,
out RtiPacket output);
};
interface Cubit_Factory
{
// = TITLE
// Creates Cubit objects.
Cubit make_cubit ();
};
|
