Mercurial > jdk8-mips64-public > corba / file comparison

comparison: src/share/classes/org/omg/CORBA/ir.idl

src/share/classes/org/omg/CORBA/ir.idl

changeset 0
7ef37b2cdcad
child 748
6845b95cba6b
equal deleted inserted replaced
-1:000000000000 0:7ef37b2cdcad
1 /*
2 * Copyright (c) 1997, 2009, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 /*
27 * This file contains OMG IDL from CORBA V2.0, July 1995.
28 * It also contains the TypeCode creation APIs in CORBA::ORB
29 **/
30
31 #pragma prefix "omg.org"
32 //#pragma javaPackage org.omg
33
34 module CORBA {
35 typedef string Identifier;
36 typedef string ScopedName;
37 typedef string RepositoryId;
38
39 enum DefinitionKind {
40 dk_none, dk_all,
41 dk_Attribute, dk_Constant, dk_Exception, dk_Interface,
42 dk_Module, dk_Operation, dk_Typedef,
43 dk_Alias, dk_Struct, dk_Union, dk_Enum,
44 dk_Primitive, dk_String, dk_Sequence, dk_Array,
45 dk_Repository,
46 dk_Wstring, dk_Fixed,
47 dk_Value, dk_ValueBox, dk_ValueMember, // orbos 98-01-18: Objects By Value
48 dk_Native
49 };
50
51
52 interface IRObject
53 /**
54 An IRObject IDL interface represents the most generic interface
55 from which all other Interface Repository interfaces are derived,
56 even the Repository itself.
57 */
58 {
59 // read interface
60 readonly attribute DefinitionKind def_kind;
61
62 // write interface
63 void destroy ();
64 };
65
66
67
68 typedef string VersionSpec;
69
70 interface Contained;
71 interface Repository;
72 interface Container;
73
74 interface Contained : IRObject
75 /**
76 The Contained Interface is inherited by all Interface Repository
77 interfaces that are contained by other objects.
78 */
79 {
80 // read/write interface
81
82 attribute RepositoryId id;
83 attribute Identifier name;
84 attribute VersionSpec version;
85
86 // read interface
87
88 readonly attribute Container defined_in;
89 readonly attribute ScopedName absolute_name;
90 readonly attribute Repository containing_repository;
91
92 struct Description {
93 DefinitionKind kind;
94 any value;
95 };
96
97 Description describe ();
98
99 // write interface
100
101 void move (
102 in Container new_container,
103 in Identifier new_name,
104 in VersionSpec new_version
105 );
106 };
107
108
109 interface ModuleDef;
110 interface ConstantDef;
111 interface IDLType;
112 interface StructDef;
113 interface UnionDef;
114 interface EnumDef;
115 interface AliasDef;
116 interface InterfaceDef;
117 interface ExceptionDef;
118 interface ValueDef; // orbos 98-01-18: Objects By Value
119 interface ValueMemberDef; // orbos 98-01-18: Objects By Value
120 interface ValueBoxDef; // orbos 98-01-18: Objects By Value
121 interface NativeDef;
122
123
124 typedef sequence <InterfaceDef> InterfaceDefSeq;
125
126
127 typedef sequence <Contained> ContainedSeq;
128
129 struct StructMember {
130 Identifier name;
131 TypeCode type;
132 IDLType type_def;
133 };
134 typedef sequence <StructMember> StructMemberSeq;
135
136 struct UnionMember {
137 Identifier name;
138 any label;
139 TypeCode type;
140 IDLType type_def;
141 };
142 typedef sequence <UnionMember> UnionMemberSeq;
143
144
145 typedef sequence <Identifier> EnumMemberSeq;
146
147 // orbos 98-01-18: Objects By Value -- begin
148 typedef short Visibility;
149 const Visibility PRIVATE_MEMBER = 0;
150 const Visibility PUBLIC_MEMBER = 1;
151
152 struct ValueMember {
153 Identifier name;
154 RepositoryId id;
155 RepositoryId defined_in;
156 VersionSpec version;
157 TypeCode type;
158 IDLType type_def;
159 Visibility access;
160 };
161 typedef sequence <ValueMember> ValueMemberSeq;
162
163 struct Initializer {
164 StructMemberSeq members;
165 };
166 typedef sequence <Initializer> InitializerSeq;
167
168 typedef sequence <ValueDef> ValueDefSeq;
169
170 // orbos 98-01-18: Objects By Value -- end
171
172
173 interface Container : IRObject
174 /**
175 The Container interface is used to form a containment hierarchy
176 in the Interface Repository. A Container can contain any number
177 of objects derived from the Contained interface.
178 */
179 {
180 // read interface
181
182 Contained lookup ( in ScopedName search_name);
183
184 ContainedSeq contents (
185 in DefinitionKind limit_type,
186 in boolean exclude_inherited
187 );
188
189 ContainedSeq lookup_name (
190 in Identifier search_name,
191 in long levels_to_search,
192 in DefinitionKind limit_type,
193 in boolean exclude_inherited
194 );
195
196 struct Description {
197 Contained contained_object;
198 DefinitionKind kind;
199 any value;
200 };
201
202 typedef sequence<Description> DescriptionSeq;
203
204 DescriptionSeq describe_contents (
205 in DefinitionKind limit_type,
206 in boolean exclude_inherited,
207 in long max_returned_objs
208 );
209
210 // write interface
211
212 ModuleDef create_module (
213 in RepositoryId id,
214 in Identifier name,
215 in VersionSpec version
216 );
217
218 ConstantDef create_constant (
219 in RepositoryId id,
220 in Identifier name,
221 in VersionSpec version,
222 in IDLType type,
223 in any value
224 );
225
226 StructDef create_struct (
227 in RepositoryId id,
228 in Identifier name,
229 in VersionSpec version,
230 in StructMemberSeq members
231 );
232
233 UnionDef create_union (
234 in RepositoryId id,
235 in Identifier name,
236 in VersionSpec version,
237 in IDLType discriminator_type,
238 in UnionMemberSeq members
239 );
240
241 EnumDef create_enum (
242 in RepositoryId id,
243 in Identifier name,
244 in VersionSpec version,
245 in EnumMemberSeq members
246 );
247
248 AliasDef create_alias (
249 in RepositoryId id,
250 in Identifier name,
251 in VersionSpec version,
252 in IDLType original_type
253 );
254
255 ExceptionDef create_exception (
256 in RepositoryId id,
257 in Identifier name,
258 in VersionSpec version,
259 in StructMemberSeq members
260 );
261
262
263 InterfaceDef create_interface (
264 in RepositoryId id,
265 in Identifier name,
266 in VersionSpec version,
267 in boolean is_abstract,
268 in InterfaceDefSeq base_interfaces
269 );
270
271 // orbos 98-01-18: Objects By Value
272 ValueDef create_value(
273 in RepositoryId id,
274 in Identifier name,
275 in VersionSpec version,
276 in boolean is_custom,
277 in boolean is_abstract,
278 in octet flags, // must be 0
279 in ValueDef base_value,
280 in boolean has_safe_base,
281 in ValueDefSeq abstract_base_values,
282 in InterfaceDefSeq supported_interfaces,
283 in InitializerSeq initializers
284 );
285
286 // orbos 98-01-18: Objects By Value
287 ValueBoxDef create_value_box(
288 in RepositoryId id,
289 in Identifier name,
290 in VersionSpec version,
291 in IDLType original_type_def
292 );
293
294 NativeDef create_native(
295 in RepositoryId id,
296 in Identifier name,
297 in VersionSpec version
298 );
299
300 };
301
302
303
304 interface IDLType : IRObject
305 /**
306 The IDLType interface is an abstract interface inherited by all
307 IR objects that represent the OMG IDL types. It provides access
308 to the TypeCode describing the type, and is used in defining the
309 other interfaces wherever definitions of IDLType must be referenced.
310 */
311 {
312 readonly attribute TypeCode type;
313 };
314
315
316
317 interface PrimitiveDef;
318 interface StringDef;
319 interface SequenceDef;
320 interface ArrayDef;
321
322 enum PrimitiveKind {
323 pk_null, pk_void, pk_short, pk_long, pk_ushort, pk_ulong,
324 pk_float, pk_double, pk_boolean, pk_char, pk_octet,
325 pk_any, pk_TypeCode, pk_Principal, pk_string, pk_objref
326 };
327
328 interface Repository : Container
329 /**
330 Repository is an interface that provides global access to the
331 Interface Repository. Repository objects can contain constants,
332 typedefs, exceptions, interfaces, and modules.
333 */
334 {
335 // read interface
336
337 Contained lookup_id (in RepositoryId search_id);
338
339 PrimitiveDef get_primitive (in PrimitiveKind kind);
340
341 // write interface
342
343 StringDef create_string (in unsigned long bound);
344
345 SequenceDef create_sequence (
346 in unsigned long bound,
347 in IDLType element_type
348 );
349
350 ArrayDef create_array (
351 in unsigned long length,
352 in IDLType element_type
353 );
354 };
355
356
357 interface ModuleDef : Container, Contained
358 /**
359 A ModuleDef can contain constants, typedefs, exceptions, interfaces,
360 and other module objects.
361 */
362 {
363 };
364
365 struct ModuleDescription {
366 Identifier name;
367 RepositoryId id;
368 RepositoryId defined_in;
369 VersionSpec version;
370 };
371
372
373 interface ConstantDef : Contained
374 /**
375 A ConstantDef object defines a named constant.
376 */
377 {
378 readonly attribute TypeCode type;
379 attribute IDLType type_def;
380 attribute any value;
381 };
382
383 struct ConstantDescription {
384 Identifier name;
385 RepositoryId id;
386 RepositoryId defined_in;
387 VersionSpec version;
388 TypeCode type;
389 any value;
390 };
391
392
393 interface TypedefDef : Contained, IDLType
394 /**
395 TypedefDef is an abstract interface used as a base interface for
396 all named non-object types(structures, unions, enumerations,
397 aliases). The TypedefDef interface is not inherited by the definition
398 objects for the primitive or anonymous types.
399 */
400 {
401 };
402
403 struct TypeDescription {
404 Identifier name;
405 RepositoryId id;
406 RepositoryId defined_in;
407 VersionSpec version;
408 TypeCode type;
409 };
410
411
412 interface StructDef : TypedefDef, Container
413 /**
414 A StructDef represents an OMG IDL structure definition.
415 */
416 {
417 attribute StructMemberSeq members;
418 };
419
420
421 interface UnionDef : TypedefDef, Container
422 /**
423 A UnionDef represents an OMG IDL union definition.
424 */
425 {
426 readonly attribute TypeCode discriminator_type;
427 attribute IDLType discriminator_type_def;
428 attribute UnionMemberSeq members;
429 };
430
431
432 interface EnumDef : TypedefDef
433 /**
434 A EnumDef represents an OMG IDL enum definition.
435 */
436 {
437 attribute EnumMemberSeq members;
438 };
439
440
441 interface AliasDef : TypedefDef
442 /**
443 An AliasDef represents an OMG IDL typedef that aliases other
444 definition.
445 */
446 {
447 attribute IDLType original_type_def;
448 };
449
450
451 interface PrimitiveDef: IDLType
452 /**
453 A PrimitiveDef represents one of the IDL primitive types. As
454 primitive types are unnamed, this interface is not derived from
455 TypedefDef or Contained.
456 */
457 {
458 readonly attribute PrimitiveKind kind;
459 };
460
461
462 interface StringDef : IDLType
463 /**
464 A StringDef represents an OMG IDL string type. As string
465 types are anonymous, this interface is not derived from TypedefDef
466 or Contained.
467 */
468 {
469 attribute unsigned long bound;
470 };
471
472
473 interface SequenceDef : IDLType
474 /**
475 A SequenceDef represents an OMG IDL sequence type. As sequence
476 types are anonymous, this interface is not derived from TypedefDef
477 or Contained.
478 */
479 {
480 attribute unsigned long bound;
481 readonly attribute TypeCode element_type;
482 attribute IDLType element_type_def;
483 };
484
485 interface ArrayDef : IDLType
486 /**
487 An ArrayDef represents an OMG IDL array type. As array
488 types are anonymous, this interface is not derived from TypedefDef
489 or Contained.
490 */
491 {
492 attribute unsigned long length;
493 readonly attribute TypeCode element_type;
494 attribute IDLType element_type_def;
495 };
496
497
498 interface ExceptionDef : Contained, Container
499 /**
500 An ExceptionDef represents an exception definition.
501 */
502 {
503 readonly attribute TypeCode type;
504 attribute StructMemberSeq members;
505 };
506 struct ExceptionDescription {
507 Identifier name;
508 RepositoryId id;
509 RepositoryId defined_in;
510 VersionSpec version;
511 TypeCode type;
512 };
513
514
515
516 enum AttributeMode {ATTR_NORMAL, ATTR_READONLY};
517
518 interface AttributeDef : Contained
519 /**
520 An AttributeDef represents the information that defines an
521 attribute of an interface.
522 */
523 {
524 readonly attribute TypeCode type;
525 attribute IDLType type_def;
526 attribute AttributeMode mode;
527 };
528
529 struct AttributeDescription {
530 Identifier name;
531 RepositoryId id;
532 RepositoryId defined_in;
533 VersionSpec version;
534 TypeCode type;
535 AttributeMode mode;
536 };
537
538
539
540 enum OperationMode {OP_NORMAL, OP_ONEWAY};
541
542 enum ParameterMode {PARAM_IN, PARAM_OUT, PARAM_INOUT};
543 struct ParameterDescription {
544 Identifier name;
545 TypeCode type;
546 IDLType type_def;
547 ParameterMode mode;
548 };
549 typedef sequence <ParameterDescription> ParDescriptionSeq;
550
551 typedef Identifier ContextIdentifier;
552 typedef sequence <ContextIdentifier> ContextIdSeq;
553
554 typedef sequence <ExceptionDef> ExceptionDefSeq;
555 typedef sequence <ExceptionDescription> ExcDescriptionSeq;
556
557 interface OperationDef : Contained
558 /**
559 An OperationDef represents the information that defines an
560 operation of an interface.
561 */
562 {
563 readonly attribute TypeCode result;
564 attribute IDLType result_def;
565 attribute ParDescriptionSeq params;
566 attribute OperationMode mode;
567 attribute ContextIdSeq contexts;
568 attribute ExceptionDefSeq exceptions;
569 };
570
571 struct OperationDescription {
572 Identifier name;
573 RepositoryId id;
574 RepositoryId defined_in;
575 VersionSpec version;
576 TypeCode result;
577 OperationMode mode;
578 ContextIdSeq contexts;
579 ParDescriptionSeq parameters;
580 ExcDescriptionSeq exceptions;
581 };
582
583
584
585 typedef sequence <RepositoryId> RepositoryIdSeq;
586 typedef sequence <OperationDescription> OpDescriptionSeq;
587 typedef sequence <AttributeDescription> AttrDescriptionSeq;
588
589 interface InterfaceDef : Container, Contained, IDLType
590 /**
591 An InterfaceDef object represents an interface definition. It can
592 contains constants, typedefs, exceptions, operations, and
593 attributes.
594 */
595 {
596 // read/write interface
597
598 attribute InterfaceDefSeq base_interfaces;
599 attribute boolean is_abstract;
600
601 // read interface
602
603 boolean is_a (in RepositoryId interface_id);
604
605 struct FullInterfaceDescription {
606 Identifier name;
607 RepositoryId id;
608 RepositoryId defined_in;
609 VersionSpec version;
610 boolean is_abstract;
611 OpDescriptionSeq operations;
612 AttrDescriptionSeq attributes;
613 RepositoryIdSeq base_interfaces;
614 TypeCode type;
615 };
616
617 FullInterfaceDescription describe_interface();
618
619 // write interface
620
621 AttributeDef create_attribute (
622 in RepositoryId id,
623 in Identifier name,
624 in VersionSpec version,
625 in IDLType type,
626 in AttributeMode mode
627 );
628
629 OperationDef create_operation (
630 in RepositoryId id,
631 in Identifier name,
632 in VersionSpec version,
633 in IDLType result,
634 in OperationMode mode,
635 in ParDescriptionSeq params,
636 in ExceptionDefSeq exceptions,
637 in ContextIdSeq contexts
638 );
639 };
640
641 struct InterfaceDescription {
642 Identifier name;
643 RepositoryId id;
644 RepositoryId defined_in;
645 VersionSpec version;
646 RepositoryIdSeq base_interfaces;
647 };
648
649
650 // orbos 98-01-18: Objects By Value -- begin
651
652 interface ValueMemberDef : Contained
653
654 /** A <code>ValueMemberDef</code> object represents the public
655 and private data member definition of a <code>Value</code> type
656 */
657
658 {
659 readonly attribute TypeCode type;
660 attribute IDLType type_def;
661 attribute Visibility access;
662 };
663
664 interface ValueDef : Container, Contained, IDLType
665 /**
666 A ValueDef object represents the definition of the
667 <code>Value</code> object used to pass the object state
668 between hosts
669 */
670
671 {
672 // read/write interface
673 attribute InterfaceDefSeq supported_interfaces;
674 attribute InitializerSeq initializers;
675 attribute ValueDef base_value;
676 attribute ValueDefSeq abstract_base_values;
677 attribute boolean is_abstract;
678 attribute boolean is_custom;
679 attribute octet flags; // always 0
680 attribute boolean has_safe_base;
681
682 // read interface
683 boolean is_a(in RepositoryId value_id);
684
685 struct FullValueDescription {
686 Identifier name;
687 RepositoryId id;
688 boolean is_abstract;
689 boolean is_custom;
690 octet flags; // always 0
691 RepositoryId defined_in;
692 VersionSpec version;
693 OpDescriptionSeq operations;
694 AttrDescriptionSeq attributes;
695 ValueMemberSeq members;
696 InitializerSeq initializers;
697 RepositoryIdSeq supported_interfaces;
698 RepositoryIdSeq abstract_base_values;
699 boolean has_safe_base;
700 RepositoryId base_value;
701 TypeCode type;
702 };
703
704 FullValueDescription describe_value();
705
706 // write interface
707
708 ValueMemberDef create_value_member(
709 in RepositoryId id,
710 in Identifier name,
711 in VersionSpec version,
712 in IDLType type_def,
713 in Visibility access
714 );
715
716 AttributeDef create_attribute(
717 in RepositoryId id,
718 in Identifier name,
719 in VersionSpec version,
720 in IDLType type,
721 in AttributeMode mode
722 );
723
724 OperationDef create_operation(
725 in RepositoryId id,
726 in Identifier name,
727 in VersionSpec version,
728 in IDLType result,
729 in OperationMode mode,
730 in ParDescriptionSeq params,
731 in ExceptionDefSeq exceptions,
732 in ContextIdSeq contexts
733 );
734 };
735 struct ValueDescription {
736 Identifier name;
737 RepositoryId id;
738 boolean is_abstract;
739 boolean is_custom;
740 octet flags; // always 0
741 RepositoryId defined_in;
742 VersionSpec version;
743 RepositoryIdSeq supported_interfaces;
744 RepositoryIdSeq abstract_base_values;
745 boolean has_safe_base;
746 RepositoryId base_value;
747 };
748
749 interface ValueBoxDef : IDLType
750
751 /** ValueBoxDef is an interface that reresents a value type with
752 a single data member inside its state section and no
753 inheritance or methods. For example, when transmitting a
754 string or sequence as an actual parameter on an interface
755 operation or as a data member of a value type that is an
756 actual parameter, it may be important to preserve any sharing
757 of the string or sequence within the object graph being
758 transmitted. Because current IDL data types do not preserve
759 referential integrity in this way, this requirement is
760 conveniently handled by using a value type. Value types also
761 support the transmission of nulls (as a distinguished value),
762 whereas IDL data types such as string and sequence (which are
763 mapped to empty strings and sequences) do not. The Java to IDL
764 mapping requires both preservation of referential integrity
765 and transmission of nulls. Because it would be cumbersome to
766 require the full IDL syntax for a value type for this specific
767 usage, this shorthand notation is introduced to cover this use
768 of value types for simple containment of a single data member.
769 */
770
771 {
772 attribute IDLType original_type_def;
773 };
774
775 // orbos 98-01-18: Objects By Value -- end
776
777 enum TCKind {
778 tk_null, tk_void,
779 tk_short, tk_long, tk_ushort, tk_ulong,
780 tk_float, tk_double, tk_boolean, tk_char,
781 tk_octet, tk_any, tk_TypeCode, tk_Principal, tk_objref,
782 tk_struct, tk_union, tk_enum, tk_string,
783 tk_sequence, tk_array, tk_alias, tk_except,
784 tk_longlong, tk_ulonglong, tk_longdouble,
785 tk_wchar, tk_wstring, tk_fixed,
786 tk_value, tk_value_box,
787 tk_native,
788 tk_abstract_interface
789 };
790
791 interface NativeDef : TypedefDef {
792 };
793 };

Mercurial Repository: jdk8-mips64-public/corba

mercurial