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 };