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