jdk8-mips64-public/corba: src/share/classes/org/omg/CORBA/ir.idl@009fc3f785a9

8042789: org.omg.CORBA.ORBSingletonClass loading no longer uses context class loader
Reviewed-by: alanb, lancea

     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  */

    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  **/

    31 #pragma prefix "omg.org"

    32 //#pragma javaPackage org.omg

    34 module CORBA {

    35     typedef string Identifier;

    36     typedef string ScopedName;

    37     typedef string RepositoryId;

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

    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;

    62 	// write interface

    63 	void destroy ();

    64     };

    68     typedef string VersionSpec;

    70     interface Contained;

    71     interface Repository;

    72     interface Container;

    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

    82 	attribute RepositoryId id;

    83 	attribute Identifier name;

    84 	attribute VersionSpec version;

    86 	// read interface

    88 	readonly attribute Container defined_in;

    89 	readonly attribute ScopedName absolute_name;

    90 	readonly attribute Repository containing_repository;

    92 	struct Description {

    93 	    DefinitionKind kind;

    94 	    any value;

    95 	};

    97 	Description describe ();

    99 	// write interface

   101 	void move (

   102 	    in Container new_container,

   103 	    in Identifier new_name,

   104 	    in VersionSpec new_version

   105 	    );

   106     };

   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;

   124     typedef sequence <InterfaceDef> InterfaceDefSeq;

   127     typedef sequence <Contained> ContainedSeq;

   129     struct StructMember {

   130 	Identifier name;

   131 	TypeCode type;

   132 	IDLType type_def;

   133     };

   134     typedef sequence <StructMember> StructMemberSeq;

   136     struct UnionMember {

   137 	Identifier name;

   138 	any label;

   139 	TypeCode type;

   140 	IDLType type_def;

   141     };

   142     typedef sequence <UnionMember> UnionMemberSeq;

   145     typedef sequence <Identifier> EnumMemberSeq;

   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;

   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;

   163     struct Initializer {

   164         StructMemberSeq members;

   165     };

   166     typedef sequence <Initializer> InitializerSeq;

   168     typedef sequence <ValueDef> ValueDefSeq;

   170     // orbos 98-01-18: Objects By Value -- end

   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

   182 	Contained lookup ( in ScopedName search_name);

   184 	ContainedSeq contents (

   185 	    in DefinitionKind limit_type,

   186 	    in boolean exclude_inherited

   187 	    );

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

   196 	struct Description {

   197 	    Contained contained_object;

   198 	    DefinitionKind kind;

   199 	    any value;

   200 	};

   202 	typedef sequence<Description> DescriptionSeq;

   204 	DescriptionSeq describe_contents (

   205 	    in DefinitionKind limit_type,

   206 	    in boolean exclude_inherited,

   207 	    in long max_returned_objs

   208 	    );

   210 	// write interface

   212 	ModuleDef create_module (

   213 	    in RepositoryId id,

   214 	    in Identifier name,

   215 	    in VersionSpec version

   216 	    );

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

   226 	StructDef create_struct (

   227 	    in RepositoryId id,

   228 	    in Identifier name,

   229 	    in VersionSpec version,

   230 	    in StructMemberSeq members

   231 	    );

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

   241 	EnumDef create_enum (

   242 	    in RepositoryId id,

   243 	    in Identifier name,

   244 	    in VersionSpec version,

   245 	    in EnumMemberSeq members

   246 	    );

   248 	AliasDef create_alias (

   249 	    in RepositoryId id,

   250 	    in Identifier name,

   251 	    in VersionSpec version,

   252 	    in IDLType original_type

   253 	    );

   255         ExceptionDef create_exception (

   256             in RepositoryId    id,

   257             in Identifier      name,

   258             in VersionSpec     version,

   259             in StructMemberSeq members

   260         );

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

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

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

   294 	NativeDef create_native(

   295 	    in RepositoryId id,

   296 	    in Identifier name,

   297 	    in VersionSpec version

   298 	    );

   300     };

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

   317     interface PrimitiveDef;

   318     interface StringDef;

   319     interface SequenceDef;

   320     interface ArrayDef;

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

   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

   337 	Contained lookup_id (in RepositoryId search_id);

   339 	PrimitiveDef get_primitive (in PrimitiveKind kind);

   341 	// write interface

   343 	StringDef create_string (in unsigned long bound);

   345 	SequenceDef create_sequence (

   346 	    in unsigned long bound,

   347 	    in IDLType element_type

   348 	    );

   350 	ArrayDef create_array (

   351 	    in unsigned long length,

   352 	    in IDLType element_type

   353 	    );

   354     };

   357     interface ModuleDef : Container, Contained

   358     /**

   359       A ModuleDef can contain constants, typedefs, exceptions, interfaces,

   360       and other module objects.

   361     */

   362     {

   363     };

   365     struct ModuleDescription {

   366 	Identifier name;

   367 	RepositoryId id;

   368 	RepositoryId defined_in;

   369 	VersionSpec version;

   370     };

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

   383     struct ConstantDescription {

   384 	Identifier name;

   385 	RepositoryId id;

   386 	RepositoryId defined_in;

   387 	VersionSpec version;

   388 	TypeCode type;

   389 	any value;

   390     };

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

   403     struct TypeDescription {

   404 	Identifier name;

   405 	RepositoryId id;

   406 	RepositoryId defined_in;

   407 	VersionSpec version;

   408 	TypeCode type;

   409     };

   412     interface StructDef : TypedefDef, Container

   413     /**

   414        A StructDef represents an OMG IDL structure definition.

   415     */

   416     {

   417 	attribute StructMemberSeq members;

   418     };

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

   432     interface EnumDef : TypedefDef

   433     /**

   434       A EnumDef represents an OMG IDL enum definition.

   435      */

   436     {

   437 	attribute EnumMemberSeq members;

   438     };

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

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

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

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

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

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

   516     enum AttributeMode {ATTR_NORMAL, ATTR_READONLY};

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

   529     struct AttributeDescription {

   530 	Identifier name;

   531 	RepositoryId id;

   532 	RepositoryId defined_in;

   533 	VersionSpec version;

   534 	TypeCode type;

   535 	AttributeMode mode;

   536     };

   540     enum OperationMode {OP_NORMAL, OP_ONEWAY};

   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;

   551     typedef Identifier ContextIdentifier;

   552     typedef sequence <ContextIdentifier> ContextIdSeq;

   554     typedef sequence <ExceptionDef> ExceptionDefSeq;

   555     typedef sequence <ExceptionDescription> ExcDescriptionSeq;

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

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

   585     typedef sequence <RepositoryId> RepositoryIdSeq;

   586     typedef sequence <OperationDescription> OpDescriptionSeq;

   587     typedef sequence <AttributeDescription> AttrDescriptionSeq;

   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

   598 	attribute InterfaceDefSeq base_interfaces;

   599 	attribute boolean is_abstract;

   601 	// read interface

   603 	boolean is_a (in RepositoryId interface_id);

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

   617 	FullInterfaceDescription describe_interface();

   619 	// write interface

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

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

   641     struct InterfaceDescription {

   642 	Identifier name;

   643 	RepositoryId id;

   644 	RepositoryId defined_in;

   645 	VersionSpec version;

   646 	RepositoryIdSeq base_interfaces;

   647     };

   650     // orbos 98-01-18: Objects By Value -- begin

   652     interface ValueMemberDef : Contained

   654       /** A <code>ValueMemberDef</code> object represents the public

   655       and private data member definition of a <code>Value</code> type

   656       */

   658  {

   659         readonly attribute TypeCode type;

   660 	         attribute IDLType type_def;

   661 		 attribute Visibility access;

   662     };

   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 	*/

   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;

   682 	    // read interface

   683 	    boolean is_a(in RepositoryId value_id);

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

   704 	  FullValueDescription describe_value();

   706 	  // write interface

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

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

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

   749     interface ValueBoxDef : IDLType

   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 	*/

   771     {

   772         attribute IDLType original_type_def;

   773     };

   775     // orbos 98-01-18: Objects By Value -- end

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

   791     interface NativeDef : TypedefDef {

   792     };

   793 };

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

src/share/classes/org/omg/CORBA/ir.idl@009fc3f785a9

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