← Back to branch summary

~ubuntu-branches/ubuntu/natty/orbit2/natty

« back to all changes in this revision

Viewing changes to src/idl/CORBA/CORBA_InterfaceRepository.idl

  • Committer: Bazaar Package Importer
  • Author(s): Chris Waters
  • Date: 2002-03-25 17:24:03 UTC
  • Revision ID: james.westby@ubuntu.com-20020325172403-8lexv63608acfqgt
Tags: upstream-2.3.107
Import upstream version 2.3.107

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/idl/CORBA/CORBA_InterfaceRepository.idl
 
1
// File: CORBA_InterfaceRepository.idl
 
2
// CORBA 2.3, Chapter 10
 
3
 
 
4
#pragma prefix "omg.org"
 
5
 
 
6
    interface Container;
 
7
    interface Repository;
 
8
    interface AliasDef;
 
9
    interface ArrayDef;
 
10
    interface AttributeDef;
 
11
    interface ConstantDef;
 
12
    interface Contained;
 
13
    interface Container;
 
14
    interface EnumDef;
 
15
    interface ExceptionDef;
 
16
    interface FixedDef;
 
17
    interface IDLType;
 
18
    interface InterfaceDef;
 
19
    interface IRObject;
 
20
    interface ModuleDef;
 
21
    interface NativeDef;
 
22
    interface OperationDef;
 
23
    interface PrimitiveDef;
 
24
    interface Repository;
 
25
    interface SequenceDef;
 
26
    interface StringDef;
 
27
    interface StructDef;
 
28
 
 
29
    typedef string ScopedName;
 
30
    typedef string RepositoryId;
 
31
    enum DefinitionKind {
 
32
#       pragma version DefinitionKind 2.3
 
33
        dk_none,        dk_all,
 
34
        dk_Attribute,   dk_Constant,    dk_Exception,   dk_Interface,
 
35
        dk_Module,      dk_Operation,   dk_Typedef,
 
36
        dk_Alias,       dk_Struct,      dk_Union,       dk_Enum,
 
37
        dk_Primitive,   dk_String,      dk_Sequence,    dk_Array,
 
38
        dk_Repository,
 
39
        dk_Wstring,     dk_Fixed,
 
40
        dk_Value,       dk_ValueBox,    dk_ValueMember,
 
41
        dk_Native
 
42
    };
 
43
    
 
44
    interface IRObject {
 
45
#       pragma version IRObject 2.3
 
46
        // read interface
 
47
        readonly attribute  DefinitionKind  def_kind;
 
48
        // write interface
 
49
        void                destroy ();
 
50
    };
 
51
    
 
52
    typedef string VersionSpec;
 
53
 
 
54
    interface Contained : IRObject {
 
55
#       pragma version Contained 2.3
 
56
 
 
57
        // read/write interface
 
58
        attribute           RepositoryId    id;
 
59
        attribute           Identifier      name;
 
60
        attribute           VersionSpec     version;
 
61
        // read interface
 
62
        readonly attribute  Container       defined_in;
 
63
        readonly attribute  ScopedName      absolute_name;
 
64
        readonly attribute  Repository      containing_repository;
 
65
        struct Description {
 
66
            DefinitionKind  kind;
 
67
            any             value; 
 
68
        }; 
 
69
        Description         describe ();
 
70
        // write interface
 
71
        void                move (  in Container    new_container,
 
72
                                    in Identifier   new_name,
 
73
                                    in VersionSpec  new_version
 
74
        );
 
75
    };
 
76
    typedef sequence <InterfaceDef> InterfaceDefSeq;
 
77
    typedef sequence <ValueDef> ValueDefSeq;
 
78
    typedef sequence <Contained> ContainedSeq;
 
79
    
 
80
    struct StructMember {
 
81
        Identifier          name;
 
82
        TypeCode            type;
 
83
        IDLType             type_def;
 
84
    };
 
85
    typedef sequence <StructMember> StructMemberSeq;
 
86
    struct Initializer {
 
87
#       pragma version Initializer 2.3
 
88
        StructMemberSeq     members;
 
89
        Identifier          name;
 
90
    };
 
91
    typedef sequence <Initializer> InitializerSeq;
 
92
     struct UnionMember {
 
93
        Identifier          name;
 
94
        any                 label;
 
95
        TypeCode            type;
 
96
        IDLType             type_def;
 
97
    };
 
98
    typedef sequence <UnionMember> UnionMemberSeq;
 
99
    typedef sequence <Identifier> EnumMemberSeq;
 
100
    interface Container : IRObject {
 
101
#       pragma version Container 2.3
 
102
        // read interface
 
103
        Contained lookup (
 
104
            in ScopedName                   search_name);
 
105
        ContainedSeq contents (
 
106
            in DefinitionKind               limit_type,
 
107
            in boolean                      exclude_inherited
 
108
        );
 
109
        ContainedSeq lookup_name (
 
110
            in Identifier                   search_name, 
 
111
            in long                         levels_to_search, 
 
112
            in DefinitionKind               limit_type,
 
113
            in boolean                      exclude_inherited
 
114
        );
 
115
        struct Description {
 
116
            Contained                       contained_object; 
 
117
            DefinitionKind                  kind;
 
118
            any                             value; 
 
119
        };
 
120
        typedef sequence<Description> DescriptionSeq;
 
121
        DescriptionSeq describe_contents (
 
122
            in DefinitionKind               limit_type,
 
123
            in boolean                      exclude_inherited,
 
124
            in long                         max_returned_objs
 
125
        );
 
126
        // write interface
 
127
        ModuleDef create_module (
 
128
            in RepositoryId                 id,
 
129
            in Identifier                   name,
 
130
            in VersionSpec                  version
 
131
        );
 
132
        ConstantDef create_constant (
 
133
            in RepositoryId                 id,
 
134
            in Identifier                   name,
 
135
            in VersionSpec                  version,
 
136
            in IDLType                      type,
 
137
            in any                          value
 
138
        );
 
139
        StructDef create_struct (
 
140
            in RepositoryId                 id,
 
141
            in Identifier                   name,
 
142
            in VersionSpec                  version,
 
143
            in StructMemberSeq              members
 
144
        );
 
145
        UnionDef create_union (
 
146
            in RepositoryId                 id,
 
147
            in Identifier                   name,
 
148
            in VersionSpec                  version,
 
149
            in IDLType                      discriminator_type,
 
150
            in UnionMemberSeq               members
 
151
        );
 
152
        EnumDef create_enum (
 
153
            in RepositoryId                 id,
 
154
            in Identifier                   name,
 
155
            in VersionSpec                  version,
 
156
            in EnumMemberSeq                members
 
157
        );
 
158
        AliasDef create_alias (
 
159
            in RepositoryId                 id,
 
160
            in Identifier                   name,
 
161
            in VersionSpec                  version,
 
162
            in IDLType                      original_type
 
163
        );
 
164
        InterfaceDef create_interface (
 
165
            in RepositoryId                 id,
 
166
            in Identifier                   name,
 
167
            in VersionSpec                  version,
 
168
            in InterfaceDefSeq              base_interfaces,
 
169
            in boolean                      is_abstract
 
170
        );
 
171
        ValueDef create_value(
 
172
            in RepositoryId                 id,
 
173
            in Identifier                   name,
 
174
            in VersionSpec                  version,
 
175
            in boolean                      is_custom,
 
176
            in boolean                      is_abstract,
 
177
            in ValueDef                     base_value,
 
178
            in boolean                      is_truncatable,
 
179
            in ValueDefSeq                  abstract_base_values,
 
180
            in InterfaceDefSeq              supported_interfaces,
 
181
            in InitializerSeq               initializers
 
182
        );
 
183
        ValueBoxDef create_value_box(
 
184
            in RepositoryId                 id,
 
185
            in Identifier                   name,
 
186
            in VersionSpec                  version,
 
187
            in IDLType                      original_type_def
 
188
        );
 
189
        ExceptionDef create_exception(
 
190
            in RepositoryId                 id,
 
191
            in Identifier                   name,
 
192
            in VersionSpec                  version,
 
193
            in StructMemberSeq              members
 
194
        );
 
195
        NativeDef create_native(
 
196
            in RepositoryId                 id,
 
197
            in Identifier                   name,
 
198
            in VersionSpec                  version
 
199
        );
 
200
    };
 
201
    interface IDLType : IRObject {
 
202
#       pragma version IDLType 2.3
 
203
        readonly attribute TypeCode     type;
 
204
    };
 
205
 
 
206
    enum PrimitiveKind {
 
207
#       pragma version PrimitiveKind 2.3
 
208
        pk_null,    pk_void,      pk_short,     pk_long,   pk_ushort, pk_ulong,
 
209
        pk_float,   pk_double,    pk_boolean,   pk_char,   pk_octet,
 
210
        pk_any,     pk_TypeCode,  pk_Principal, pk_string, pk_objref,
 
211
        pk_longlong,pk_ulonglong, pk_longdouble, 
 
212
        pk_wchar,   pk_wstring,   pk_value_base
 
213
    };
 
214
    
 
215
    interface Repository : Container {
 
216
#       pragma version Repository 2.3
 
217
        // read interface
 
218
        Contained   lookup_id               (in RepositoryId    search_id);
 
219
        TypeCode    get_canonical_typecode  (in TypeCode        tc); 
 
220
        PrimitiveDef get_primitive          (in PrimitiveKind   kind);
 
221
        // write interface
 
222
        StringDef   create_string           (in unsigned long   bound);
 
223
        WstringDef  create_wstring          (in unsigned long   bound);
 
224
        SequenceDef create_sequence         (in unsigned long   bound,
 
225
                                             in IDLType         element_type
 
226
        );
 
227
        ArrayDef create_array               (in unsigned long   length,
 
228
                                             in IDLType         element_type
 
229
        );
 
230
        FixedDef create_fixed               (in unsigned short  digits,
 
231
                                             in short           scale
 
232
        );
 
233
    };
 
234
    interface ModuleDef : Container, Contained {
 
235
#       pragma version ModuleDef 2.3
 
236
    };
 
237
    
 
238
    struct ModuleDescription {
 
239
        Identifier                      name; 
 
240
        RepositoryId                    id; 
 
241
        RepositoryId                    defined_in;
 
242
        VersionSpec                     version;
 
243
    };
 
244
 
 
245
    interface ConstantDef : Contained {
 
246
#       pragma version ConstantDef 2.3
 
247
        readonly attribute TypeCode     type;
 
248
        attribute IDLType               type_def;
 
249
        attribute any                   value;
 
250
    };
 
251
    struct ConstantDescription {
 
252
        Identifier                      name; 
 
253
        RepositoryId                    id; 
 
254
        RepositoryId                    defined_in; 
 
255
        VersionSpec                     version;
 
256
        TypeCode                        type; 
 
257
        any                             value; 
 
258
    };
 
259
    
 
260
    interface TypedefDef : Contained, IDLType {
 
261
#       pragma version TypedefDef 2.3
 
262
    };
 
263
    
 
264
    struct TypeDescription {
 
265
        Identifier                      name; 
 
266
        RepositoryId                    id; 
 
267
        RepositoryId                    defined_in; 
 
268
        VersionSpec                     version;
 
269
        TypeCode                        type; 
 
270
    };
 
271
    
 
272
    interface StructDef : TypedefDef, Container {
 
273
#       pragma version StructDef 2.3
 
274
        attribute StructMemberSeq       members;
 
275
    };
 
276
    
 
277
    interface UnionDef : TypedefDef, Container {
 
278
#       pragma version UnionDef 2.3
 
279
        readonly attribute TypeCode     discriminator_type;
 
280
        attribute IDLType               discriminator_type_def;
 
281
        attribute UnionMemberSeq        members;
 
282
    };
 
283
 
 
284
    interface EnumDef : TypedefDef {
 
285
#       pragma version EnumDef 2.3
 
286
        attribute EnumMemberSeq         members;
 
287
    };
 
288
    interface AliasDef : TypedefDef {
 
289
#       pragma version AliasDef 2.3
 
290
        attribute IDLType               original_type_def;
 
291
    };
 
292
    interface NativeDef : TypedefDef {
 
293
#       pragma version NativeDef 2.3
 
294
    };
 
295
    interface PrimitiveDef: IDLType {
 
296
#       pragma version PrimitiveDef 2.3
 
297
        readonly attribute PrimitiveKind kind;
 
298
    };
 
299
    interface StringDef : IDLType {
 
300
#       pragma version StringDef 2.3
 
301
        attribute unsigned long         bound;
 
302
    };
 
303
    interface WstringDef : IDLType {
 
304
#       pragma version WstringDef 2.3
 
305
        attribute unsigned long         bound;
 
306
    };
 
307
    interface FixedDef : IDLType {
 
308
#       pragma version FixedDef 2.3
 
309
        attribute unsigned short        digits;
 
310
        attribute short                 scale;
 
311
    };
 
312
    interface SequenceDef : IDLType {
 
313
#       pragma version SequenceDef 2.3
 
314
        attribute unsigned long         bound;
 
315
        readonly attribute TypeCode     element_type;
 
316
        attribute IDLType               element_type_def;
 
317
    };
 
318
    interface ArrayDef : IDLType {
 
319
#       pragma version ArrayDef 2.3
 
320
        attribute unsigned long         length;
 
321
        readonly attribute TypeCode     element_type;
 
322
        attribute IDLType               element_type_def;
 
323
    };
 
324
    interface ExceptionDef : Contained, Container {
 
325
#       pragma version ExceptionDef 2.3
 
326
        readonly attribute TypeCode     type;
 
327
        attribute StructMemberSeq       members;
 
328
    };
 
329
    struct ExceptionDescription {
 
330
        Identifier                      name; 
 
331
        RepositoryId                    id; 
 
332
        RepositoryId                    defined_in; 
 
333
        VersionSpec                     version;
 
334
        TypeCode                        type; 
 
335
    };
 
336
    enum AttributeMode {ATTR_NORMAL, ATTR_READONLY};
 
337
    interface AttributeDef : Contained {
 
338
#       pragma version AttributeDef 2.3
 
339
        readonly attribute TypeCode     type;
 
340
        attribute IDLType               type_def;
 
341
        attribute AttributeMode         mode;
 
342
        };
 
343
    struct AttributeDescription {
 
344
        Identifier                      name; 
 
345
        RepositoryId                    id; 
 
346
        RepositoryId                    defined_in; 
 
347
        VersionSpec                     version;
 
348
        TypeCode                        type;
 
349
        AttributeMode                   mode; 
 
350
    };
 
351
    enum OperationMode {OP_NORMAL, OP_ONEWAY};
 
352
    enum ParameterMode {PARAM_IN, PARAM_OUT, PARAM_INOUT};
 
353
    struct ParameterDescription {
 
354
        Identifier                      name; 
 
355
        TypeCode                        type; 
 
356
        IDLType                         type_def;
 
357
        ParameterMode                   mode;
 
358
    };
 
359
    typedef sequence <ParameterDescription> ParDescriptionSeq;
 
360
    typedef Identifier                      ContextIdentifier;
 
361
    typedef sequence <ContextIdentifier>    ContextIdSeq;
 
362
    typedef sequence <ExceptionDef>         ExceptionDefSeq;
 
363
    typedef sequence <ExceptionDescription> ExcDescriptionSeq;
 
364
    
 
365
    interface OperationDef : Contained {
 
366
#       pragma version OperationDef 2.3
 
367
        readonly attribute TypeCode     result;
 
368
        attribute IDLType               result_def;
 
369
        attribute ParDescriptionSeq     params;
 
370
        attribute OperationMode         mode; 
 
371
        attribute ContextIdSeq          contexts;
 
372
        attribute ExceptionDefSeq       exceptions;
 
373
    };
 
374
    
 
375
    struct OperationDescription {
 
376
        Identifier                      name; 
 
377
        RepositoryId                    id; 
 
378
        RepositoryId                    defined_in; 
 
379
        VersionSpec                     version;
 
380
        TypeCode                        result; 
 
381
        OperationMode                   mode; 
 
382
        ContextIdSeq                    contexts; 
 
383
        ParDescriptionSeq               parameters;
 
384
        ExcDescriptionSeq               exceptions;
 
385
    };
 
386
    typedef sequence <RepositoryId>         RepositoryIdSeq;
 
387
    typedef sequence <OperationDescription> OpDescriptionSeq;
 
388
    typedef sequence <AttributeDescription> AttrDescriptionSeq;
 
389
    
 
390
    interface InterfaceDef : Container, Contained, IDLType {
 
391
#       pragma version InterfaceDef 2.3
 
392
        // read/write interface
 
393
        attribute InterfaceDefSeq       base_interfaces;
 
394
        attribute boolean               is_abstract;
 
395
        // read interface
 
396
        boolean is_a (in RepositoryId   interface_id
 
397
        );
 
398
        struct FullInterfaceDescription {
 
399
#           pragma version FullInterfaceDescription 2.3
 
400
            Identifier                  name;
 
401
            RepositoryId                id;
 
402
            RepositoryId                defined_in;
 
403
            VersionSpec                 version;
 
404
            OpDescriptionSeq            operations;
 
405
            AttrDescriptionSeq          attributes;
 
406
            RepositoryIdSeq             base_interfaces;
 
407
            TypeCode                    type;
 
408
            boolean                     is_abstract;
 
409
        };
 
410
        FullInterfaceDescription describe_interface();
 
411
        // write interface
 
412
        AttributeDef create_attribute (
 
413
            in RepositoryId             id,
 
414
            in Identifier               name,
 
415
            in VersionSpec              version,
 
416
            in IDLType                  type,
 
417
            in AttributeMode            mode
 
418
        );
 
419
        OperationDef create_operation ( 
 
420
            in RepositoryId             id,
 
421
            in Identifier               name,
 
422
            in VersionSpec              version,
 
423
            in IDLType                  result,
 
424
            in OperationMode            mode, 
 
425
            in ParDescriptionSeq        params,
 
426
            in ExceptionDefSeq          exceptions,
 
427
            in ContextIdSeq             contexts
 
428
        );
 
429
    };
 
430
    struct InterfaceDescription {
 
431
#       pragma version InterfaceDescription 2.3
 
432
        Identifier                      name; 
 
433
        RepositoryId                    id; 
 
434
        RepositoryId                    defined_in; 
 
435
        VersionSpec                     version;
 
436
        RepositoryIdSeq                 base_interfaces;
 
437
        boolean                         is_abstract;
 
438
    };
 
439
    typedef short Visibility;
 
440
    const Visibility PRIVATE_MEMBER = 0;
 
441
    const Visibility PUBLIC_MEMBER  = 1;
 
442
    
 
443
    struct ValueMember {
 
444
#       pragma version ValueMember 2.3
 
445
        Identifier                      name;
 
446
        RepositoryId                    id;
 
447
        RepositoryId                    defined_in;
 
448
        VersionSpec                     version;
 
449
        TypeCode                        type;
 
450
        IDLType                         type_def;
 
451
        Visibility                      access; 
 
452
    };
 
453
    typedef sequence <ValueMember> ValueMemberSeq;
 
454
    interface ValueMemberDef : Contained {
 
455
#       pragma version ValueMemberDef 2.3
 
456
        readonly attribute              TypeCode type;
 
457
        attribute IDLType               type_def;
 
458
        attribute Visibility            access;
 
459
    };
 
460
    interface ValueDef : Container, Contained, IDLType {
 
461
#       pragma version ValueDef 2.3
 
462
        // read/write interface
 
463
        attribute InterfaceDefSeq       supported_interfaces;
 
464
        attribute InitializerSeq        initializers;
 
465
        attribute ValueDef              base_value;
 
466
        attribute ValueDefSeq           abstract_base_values;
 
467
        attribute boolean               is_abstract;
 
468
        attribute boolean               is_custom;
 
469
        attribute boolean               is_truncatable;
 
470
        // read interface
 
471
        boolean is_a(in RepositoryId    id);
 
472
        struct FullValueDescription {
 
473
#           pragma version FullValueDescription 2.3
 
474
            Identifier                  name;
 
475
            RepositoryId                id;
 
476
            boolean                     is_abstract;
 
477
            boolean                     is_custom;
 
478
            RepositoryId                defined_in;
 
479
            VersionSpec                 version;
 
480
            OpDescriptionSeq            operations;
 
481
            AttrDescriptionSeq          attributes;
 
482
            ValueMemberSeq              members;
 
483
            InitializerSeq              initializers;
 
484
            RepositoryIdSeq             supported_interfaces;
 
485
            RepositoryIdSeq             abstract_base_values;
 
486
            boolean                     is_truncatable;
 
487
            RepositoryId                base_value;
 
488
            TypeCode                    type;
 
489
        };
 
490
        FullValueDescription describe_value();
 
491
        ValueMemberDef create_value_member(
 
492
            in RepositoryId             id,
 
493
            in Identifier               name,
 
494
            in VersionSpec              version,
 
495
            in IDLType                  type,
 
496
            in Visibility               access
 
497
        );
 
498
        AttributeDef create_attribute(
 
499
            in RepositoryId             id,
 
500
            in Identifier               name,
 
501
            in VersionSpec              version,
 
502
            in IDLType                  type,
 
503
            in AttributeMode            mode
 
504
        );
 
505
        OperationDef create_operation (
 
506
            in RepositoryId             id,
 
507
            in Identifier               name,
 
508
            in VersionSpec              version,
 
509
            in IDLType                  result,
 
510
            in OperationMode            mode,
 
511
            in ParDescriptionSeq        params,
 
512
            in ExceptionDefSeq          exceptions,
 
513
            in ContextIdSeq             contexts
 
514
        );
 
515
    };
 
516
    struct ValueDescription {
 
517
#       pragma version ValueDescription 2.3
 
518
        Identifier                      name;
 
519
        RepositoryId                    id;
 
520
        boolean                         is_abstract;
 
521
        boolean                         is_custom;
 
522
        RepositoryId                    defined_in;
 
523
        VersionSpec                     version;
 
524
        RepositoryIdSeq                 supported_interfaces;
 
525
        RepositoryIdSeq                 abstract_base_values;
 
526
        boolean                         is_truncatable;
 
527
        RepositoryId                    base_value; 
 
528
    };
 
529
    interface ValueBoxDef : TypedefDef {
 
530
#       pragma version ValueBoxDef 2.3
 
531
        attribute IDLType original_type_def;
 
532
    };
 
533
    enum TCKind {                               // PIDL
 
534
#       pragma version TCKind 2.3
 
535
        tk_null,    tk_void, 
 
536
        tk_short,   tk_long,        tk_ushort,  tk_ulong, 
 
537
        tk_float,   tk_double,      tk_boolean, tk_char, 
 
538
        tk_octet,   tk_any,         tk_TypeCode,tk_Principal, tk_objref, 
 
539
        tk_struct,  tk_union,       tk_enum,    tk_string, 
 
540
        tk_sequence,tk_array,       tk_alias,   tk_except,
 
541
        tk_longlong,tk_ulonglong,   tk_longdouble,
 
542
        tk_wchar,   tk_wstring,     tk_fixed,
 
543
        tk_value,   tk_value_box,
 
544
        tk_native,
 
545
        tk_abstract_interface
 
546
    };
 
547
    typedef short ValueModifier;                        // PIDL
 
548
    const ValueModifier VM_NONE         = 0;
 
549
    const ValueModifier VM_CUSTOM       = 1;
 
550
    const ValueModifier VM_ABSTRACT     = 2;
 
551
    const ValueModifier VM_TRUNCATABLE  = 3;
 
552
 
 
553
#pragma pidl push
 
554
    interface TypeCode {                            // PIDL
 
555
#       pragma version TTypeCode 2.3
 
556
        exception   Bounds {};
 
557
        exception   BadKind {};
 
558
        // for all TypeCode kinds
 
559
        boolean     equal       (in TypeCode tc);
 
560
        boolean     equivalent  (in TypeCode tc); 
 
561
        TypeCode    get_compact_typecode(); 
 
562
        TCKind      kind ();
 
563
        // for tk_objref, tk_struct,    tk_union,  tk_enum, tk_alias, 
 
564
        //     tk_value,  tk_value_box, tk_native, tk_abstract_interface
 
565
        // and tk_except
 
566
        RepositoryId    id () raises (BadKind);
 
567
        // for tk_objref, tk_struct,    tk_union,  tk_enum, tk_alias, 
 
568
        //     tk_value,  tk_value_box, tk_native, tk_abstract_interface
 
569
        // and tk_except
 
570
        Identifier name () raises (BadKind);
 
571
        // for tk_struct, tk_union, tk_enum, tk_value, 
 
572
        // and tk_except
 
573
        unsigned long   member_count () raises (BadKind);
 
574
        Identifier      member_name (in unsigned long index) 
 
575
                                                raises (BadKind, Bounds);
 
576
        // for tk_struct, tk_union, tk_value, and tk_except
 
577
        TypeCode        member_type (in unsigned long index) 
 
578
                                                raises (BadKind, Bounds);
 
579
        // for tk_union
 
580
        any             member_label (in unsigned long index) 
 
581
                                                raises (BadKind, Bounds);
 
582
        TypeCode        discriminator_type ()   raises (BadKind);
 
583
        long            default_index ()        raises (BadKind); 
 
584
        // for tk_string, tk_sequence, and tk_array
 
585
        unsigned long   length ()               raises (BadKind);
 
586
        // for tk_sequence, tk_array, tk_value_box, and tk_alias
 
587
        TypeCode        content_type ()         raises (BadKind);
 
588
        // for tk_fixed
 
589
        unsigned short  fixed_digits()          raises (BadKind);
 
590
        short           fixed_scale()           raises (BadKind);
 
591
        // for tk_value
 
592
        Visibility      member_visibility(in unsigned long index)
 
593
                                                raises(BadKind, Bounds);
 
594
        ValueModifier   type_modifier()         raises(BadKind);
 
595
        TypeCode        concrete_base_type()    raises(BadKind);
 
596
    };
 
597
#pragma pidl pop