Overview

Package

Class

Use

Tree

Deprecated

Index

Help

Java Platform 1.2

PREV PACKAGE NEXT PACKAGE

FRAMES NO FRAMES

Package org.omg.CORBA

Provides the mapping of the OMG CORBA APIs to the Java^TM programming language, including the class ORB, which is implemented so that a programmer can use it as a fully-functional Object Request Broker (ORB).

See:
Description

Interface Summary
*ARG_IN*	Signifies an "input" argument to an invocation, meaning that the argument is being passed from the client to the server.
*ARG_INOUT*	Signifies an argument used for both input and output in an invocation, meaning that the argument is being passed from the client to the server and then back from the server to the client.
*ARG_OUT*	Signifies an "output" argument to an invocation, meaning that the argument is being passed from the server to the client.
*BAD_POLICY*
*BAD_POLICY_TYPE*
*BAD_POLICY_VALUE*
*CTX_RESTRICT_SCOPE*	A flag that can be used as the second parameter to the method `Context.get_values` to restrict the search scope.
*Current*	An interface that makes it possible to access information associated with a particular thread of execution, such as security information or a transaction identifier.
*DomainManager*	The DomainManager has associated with it the policy objects for a particular domain.
*DynAny*	org.omg.CORBA.Any values can be dynamically interpreted (traversed) and constructed through DynAny objects.
*DynArray*	The DynArray interface represents a DynAny object which is associated with an array.
*DynEnum*	The DynEnum interface represents a DynAny object which is associated with an IDL enum.
*DynFixed*	The DynFixed interface represents a DynAny object which is associated with an IDL fixed type.
*DynSequence*	The DynArray interface represents a DynAny object which is associated with an IDL sequence.
*DynStruct*	The DynStruct interface represents a DynAny object which is associated with an IDL struct.
*DynUnion*	The DynUnion interface represents a DynAny object which is associated with an IDL union.
*DynValue*
*IDLType*	The IDLType interface is an abstract interface inherited by all IR objects that represent the OMG IDL types.
*IRObject*	An IRObject IDL interface represents the most generic interface from which all other Interface Repository interfaces are derived, even the Repository itself.
*Object*	The definition for a CORBA object reference.
*Policy*	The Policy interface provides a mechanism for ORBs and Object Services to allow access to certain choices that affect their operation.
*PRIVATE_MEMBER*
*PUBLIC_MEMBER*
*UNSUPPORTED_POLICY*
*UNSUPPORTED_POLICY_VALUE*
*VM_ABSTRACT*
*VM_CUSTOM*
*VM_NONE*
*VM_TRUNCATABLE*

Class Summary
Any	Serves as a container for any data that can be described in IDL or for any IDL primitive type.
AnyHolder	A Holder class for `Any` objects that is used to store "out" and "inout" parameters in IDL methods.
BooleanHolder	A Holder class for a `boolean` that is used to store "out" and "inout" parameters in IDL methods.
ByteHolder	A Holder class for a `byte` that is used to store "out" and "inout" parameters in IDL methods.
CharHolder	A Holder class for a `char` that is used to store "out" and "inout" parameters in IDL methods.
CompletionStatus	An object that indicates whether a method had completed running when a `SystemException` was thrown.
Context	An object used in `Request` operations to specify the context object in which context strings must be resolved before being sent along with the request invocation.
ContextList	An object containing a modifiable list of `String` objects that represent property names.
DefinitionKind
DoubleHolder	A Holder class for a `double` that is used to store "out" and "inout" parameters in IDL methods.
DynamicImplementation	The base class for all object implementations using the DSI.
Environment	A container (holder) for an exception that is used in `Request` operations to make exceptions available to the client.
ExceptionList	An object used in `Request` operations to describe the exceptions that can be thrown by a method.
FixedHolder	FixedHolder is a container class for values of IDL type "fixed", which is mapped to the Java class java.math.BigDecimal.
FloatHolder	A Holder class for a `float` that is used to store "out" and "inout" parameters in IDL methods.
IntHolder	A Holder class for an `int` that is used to store "out" and "inout" parameters in IDL methods.
LongHolder	A Holder class for a `long` that is used to store "out" and "inout" parameters in IDL methods.
NamedValue	An object used in the DII and DSI to describe arguments and return values.
NameValuePair	The NameValuePair interface is used to hold names and values of IDL structs in the DynStruct APIs.
NVList	A modifiable list containing `NamedValue` objects.
ObjectHolder	A Holder class for a CORBA object reference (a value of type `org.omg.CORBA.Object`).
ORB	A class providing APIs for the CORBA Object Request Broker features.
Principal	Deprecated. Deprecated by CORBA 2.2.
PrincipalHolder	Deprecated. Deprecated by CORBA 2.2.
Request	An object containing the information necessary for invoking a method.
ServerRequest	An object that captures the explicit state of a request for the Dynamic Skeleton Interface (DSI).
ServiceDetail
ServiceDetailHelper
ServiceInformation	ServiceInformation is an IDL struct in the CORBA module.
ServiceInformationHelper
ServiceInformationHolder	A Holder class for a `ServiceInformation` object that is used to store "out" and "inout" parameters in IDL methods.
SetOverrideType
ShortHolder	A Holder class for a `short` that is used to store "out" and "inout" parameters in IDL operations.
StringHolder	A Holder class for a `String` that is used to store "out" and "inout" parameters in IDL operations.
StructMember	A description of a member of an IDL `struct`.
TCKind	The Java mapping of the IDL enum `TCKind`, which specifies the kind of a `TypeCode` object.
TypeCode	A container for information about a specific CORBA data type.
TypeCodeHolder	A Holder class for a `TypeCode` object that is used to store "out" and "inout" parameters in IDL operations.
UnionMember	A description in the Interface Repository of a member of an IDL union.
ValueMember	A description in the Interface Repository of a member of a `value` object.

Exception Summary
BAD_CONTEXT	The CORBA `BAD_CONTEXT` exception, which is thrown when there is an error processing a context object.
BAD_INV_ORDER	The CORBA `BAD_INV_ORDER` exception, which is thrown when methods are called out of order.
BAD_OPERATION	The CORBA `BAD_OPERATION` exception, which is thrown when a method is invalid.
BAD_PARAM	The CORBA `BAD_PARAM` exception, which is thrown when an invalid parameter is passed to a method.
BAD_TYPECODE	The CORBA `BAD_TYPECODE` exception, which is thrown when the specified typecode is invalid.
Bounds
COMM_FAILURE	The CORBA `COMM_FAILURE` exception, which is thrown when there is a communication failure.
DATA_CONVERSION	The CORBA `DATA_CONVERSION` exception, which is thrown when there is a data conversion error.
FREE_MEM	The CORBA `FREE_MEM` exception, which is thrown when the system is unable to free memory.
IMP_LIMIT	The CORBA `IMP_LIMIT` exception, which is thrown when the implementation limit has been violated.
INITIALIZE	The CORBA `INITIALIZE` exception, which is thrown when there is an ORB initialization error.
INTERNAL	The CORBA `INTERNAL` exception, which is thrown when there is an ORB internal error.
INTF_REPOS	The CORBA `INTF_REPOS` exception, which is thrown when there is an error accessing the interface repository.
INV_FLAG	The CORBA `INV_FLAG` exception, which is thrown when an invalid flag is specified.
INV_IDENT	The CORBA `INV_IDENT` exception, which is thrown when identifier syntax is invalid.
INV_OBJREF	The CORBA `INV_OBJREF` exception, which is thrown when an invalid object reference is specified.
INV_POLICY	The CORBA `INV_POLICY` standard exception, which is thrown when an invocation cannot be made because of an incompatibility between Policy overrides.
INVALID_TRANSACTION	The CORBA `INVALID_TRANSACTION` exception, which is thrown when there is a transaction error.
MARSHAL	The CORBA `MARSHAL` exception, which is thrown when the ORB has a problem marshalling or unmarshalling parameters.
NO_IMPLEMENT	The CORBA `NO_IMPLEMENT` exception, which is thrown when the implementation for a method is not available.
NO_MEMORY	The CORBA `NO_MEMORY` exception, which may be thrown by either the client or the server when there is not enough memory for a dynamic memory allocation.
NO_PERMISSION	The CORBA `NO_PERMISSION` exception, which is thrown if the client does not have permission to perform the request.
NO_RESOURCES	The CORBA `NO_RESOURCES` exception, which is thrown when either the client or the server does not have sufficient resources to perform the request.
NO_RESPONSE	The CORBA `NO_RESPONSE` exception, which is thrown when a response to the request is not yet available.
OBJ_ADAPTER	The CORBA `OBJ_ADAPTER` exception, which is thrown by the object adapter on the server to indicate some error.
OBJECT_NOT_EXIST	The CORBA `OBJECT_NOT_EXIST` exception, which is usually thrown from the server to indicate that the target object does not exist.
PERSIST_STORE	The CORBA `PERSIST_STORE` exception, which is thrown when there is an error with the persistent storage on the server.
PolicyError
SystemException	The root class for all CORBA standard exceptions.
TRANSACTION_REQUIRED	The CORBA `TRANSACTION_REQUIRED` exception, which is thrown by the ORB on the client or server during the processing of a request that is required to be enclosed in a transaction.
TRANSACTION_ROLLEDBACK	The CORBA `TRANSACTION_ROLLEDBACK` exception, which is thrown when a transactional operation did not complete because the transaction was rolled back.
TRANSIENT	The CORBA `TRANSIENT` exception, which is thrown by the server to signal a transient failure that might not occur again if the request is retried.
UNKNOWN	The CORBA `UNKNOWN` exception, which is thrown when there is an error whose cause is unknown to the ORB.
UnknownUserException	A class that contains user exceptions returned by the server.
UserException	The root class for CORBA IDL-defined user exceptions.
WrongTransaction	The CORBA `WrongTransaction` user-defined exception.

Package org.omg.CORBA Description

An ORB handles (or brokers) method invocations between a client and the method's implementation on a server. Because the client and server may be anywhere on a network, and because the invocation and implementation may be written in different programming languages, an ORB does a great deal of work behind the scenes to accomplish this communication.

What the General User Needs to Know

Most of what an ORB does is completely transparent to the user, and a major portion of the CORBA package consists of classes used by the ORB behind the scenes. The result is that most programmers will use only a small part of this package directly. In fact, most programmers will use only a few methods from the ORB class, some exceptions, and occasionally, a holder class.

`ORB` Methods

These are the ORB methods that a general user might invoke:

connect()
disconnect()
init()
init(String [] args, Properties props)
init(Applet app, Properties props)
list_initial_services()
resolve_initial_references(String name)
object_to_string(Object obj)
string_to_object(String str)

Exceptions

Exceptions in Java IDL are similar to those in any code written in the Java programming language. If a method is defined to throw an exception, then any code using that method must have a try/catch block and handle that exception when it is thrown.

The documentation on Java IDL exceptions has more information and explains the difference between system exceptions and user-defined exceptions.

The following is a list of the system exceptions (which are unchecked exceptions inheriting through org.omg.CORBA.SystemException from java.lang.RuntimeException) that are defined in the package org.omg.CORBA:

 
        BAD_CONTEXT
        BAD_INV_ORDER
        BAD_OPERATION
        BAD_PARAM
        BAD_TYPECODE
        COMM_FAILURE
        DATA_CONVERSION
        FREE_MEM
        IMP_LIMIT
        INITIALIZE
        INTERNAL
        INTF_REPOS
        INVALID_TRANSACTION
        INV_FLAG
        INV_IDENT
        INV_OBJREF
	INV_POLICY
        MARSHAL
        NO_IMPLEMENT
        NO_MEMORY
        NO_PERMISSION
        NO_RESOURCES
        NO_RESPONSE
        OBJECT_NOT_EXIST
        OBJ_ADAPTER
        PERSIST_STORE
        TRANSACTION_REQUIRED
        TRANSACTION_ROLLEDBACK
        TRANSIENT
        UNKNOWN

The following is a list of user-defined exceptions defined in the package org.omg.CORBA.

 
        Bounds
        UnknownUserException
        WrongTransaction 
        PolicyError

Note that there are some packages inside the CORBA package with "Package" as part of their names. These packages are generally quite small because all they do is provide exceptions or classes for use by interfaces and classes in the CORBA package.

For example, the package org.omg.CORBA.TypeCodePackage contains two exceptions thrown by methods in the class TypeCode. These exceptions are:

BadKind
Bounds

The package org.omg.CORBA.ORBPackage contains two exceptions:

InvalidName
InconsistentTypeCode

The package org.omg.CORBA.DynAnyPackage contains four exceptions:

InvalidValue, thrown by methods in
Invalid, thrown by methods in
TypeMismatch, thrown by methods in
InvalidSeq, thrown by methods in

Holder classes

Operations in an IDL interface may take out or inout parameters as well as in parameters. The Java programming language only passes parameters by value and thus does not have out or inout parameters, so these are mapped to what are called Holder classes. In place of the IDL out parameter, the Java programming language method will take an instance of the Holder class of the appropriate type. The result that was assigned to the out or inout parameter in the IDL interface is assigned to the value field of the Holder class.

The package org.omg.CORBA contains a Holder class for each of the basic types (BooleanHolder, LongHolder, StringHolder, and so on). It also has Holder classes for each generated class (such as TypeCodeHolder), but these are used transparently by the ORB, and the programmer usually does not see them.

The Holder classes defined in the package org.omg.CORBA are:

     AnyHolder
     BooleanHolder
     ByteHolder
     CharHolder
     DoubleHolder
     FloatHolder
     FixedHolder
     IntHolder
     LongHolder
     ObjectHolder
     PrincipalHolder
     ShortHolder
     StringHolder
     TypeCodeHolder

For Advanced Users

The other classes and interfaces in the CORBA package, which are used behind the scenes, can be put into four groups. Three of the groups are used with requests in some capacity, and the fourth group, concerning the Interface Repository, is a category by itself.

Classes Created by an ORB

The first group contains classes that are created by an ORB and contain information used in request operations. They are listed in roughly increasing order of complexity:

TCKind -- indicates the kind (datatype) for a TypeCode object
TypeCode -- indicates a datatype and possibly other information
Any -- contains a value and its typecode
NamedValue -- contains a name, an Any object, and an argument mode flag. NamedValue objects contain information about method arguments, method return values, or a context.
ContextList -- a list of strings that describe the contexts that need to be resolved and sent with an invocation
ExceptionList -- a list of TypeCodes for exceptions that may be thrown by a method
Environment -- a container for the exception thrown during a method invocation
Context -- a list of NamedValue objects used to pass auxiliary information from client to server
NVList -- a list of NamedValue objects, used to pass arguments or get results

Classes That Deal with Requests

The second group of classes deals with requests:

Object -- the base class for all CORBA object references
Request -- the main class in the DII, which contains methods for adding arguments to the request, for accessing information about the method being invoked (the method name, its arguments, exceptions it throws, and so on), and for making invocations on the request
DynamicImplementation -- the base class for server implementations using the DSI. It has the method invoke, which is used by an implementation of this class to determine the state of a ServerRequest object and to set its result or exception
ServerRequest -- captures the explicit state of a request for the Dynamic Skeleton Interface

Constants Used as Flags

The third group contains interfaces that define constants used as flags. These flags, used in NamedValue objects or as parameters to methods, are defined in the following interfaces:

ARG_IN
ARG_INOUT
ARG_OUT
CTX_RESTRICT_SCOPE

Interface Repository Interfaces and Classes

A fourth group contains the Interface Repository interfaces and classes, which are generated by the idltojava compiler from the OMG IDL interface ir.idl. The purpose of the Interface Repository is to identify the interfaces stored in it so that they can be accessed by an ORB. Each module, type, interface, attribute, operation, parameter, exception, constant, and so on is described completely by the Interface Repository API.

An ORB does not require that there be an interface repository, and Java IDL does not include one.

Specification

In addition to this document, the specification for Java IDL includes the following:

Supplementary documentation

CORBA Features Not Implemented in Java IDL

Some of the API included in org.omg.CORBA is provided for conformance with the current OMG CORBA specification but is not implemented in Sun's release of the JDK^TM. This enables other JDK licensees to provide implementations of this API in standard extensions and products.

General Summary of Features or API Not Implemented in This Release:

Interface Repository. An Interface Repository is not required for normal operation of Java IDL. Java IDL clients can access an Interface Repository provided by another Java or C++ ORB.
RMI/IIOP
Objects-by-Value
Of the recently added type extensions to IDL, only longlong (signed and unsigned) is supported. The wide character IDL types wchar and wstring are not supported. The types long double and fixed are also not supported.
Recursive TypeCodes are not implemented. This means that org.omg.CORBA.Any objects for recursive IDL types (for example, recursive sequences) cannot be created.
The method org.omg.CORBA.Any.equal is not implemented for complex TypeCodes (tk_objref, tk_Principal, tk_struct, tk_union, tk_sequence, tk_array, tk_alias, and tk_except).
There is no implementation for org.omg.CORBA.DynAny and other dynamic-Any interfaces.
The API for org.omg.CORBA.Context is not implemented.
NOTE: Abstract classes, such as Context, by definition have methods that are not implemented.
Policies (org.omg.CORBA.Policy) and methods for getting them are not implemented.
Domain managers (org.omg.CORBA.DomainManager) and methods for getting them are not implemented.
org.omg.CORBA.ServiceInformation and ORB methods for getting these objects are not implemented.
org.omg.CORBA.portable.ServantObject and Delegate/ObjectImpl methods _servant_preinvoke, _servant_postinvoke and _is_local are not implemented.
ORB methods for supporting single-threading (perform_work, work_pending) are not implemented.
TypeCodes for native types (ORB.create_native_tc) are not implemented.

Specific List of Unimplemented Features in Package `org.omg.CORBA`

Unimplemented Interfaces in package `org.omg.CORBA`:


Current
DynAny
DynStruct
DynEnum
DynArray
DomainManager
Policy
DynFixed
DynUnion
DynSequence
DynValue
IRObject

IDLType

Unimplemented Methods in package `org.omg.CORBA`:


ORB
  
    public org.omg.CORBA.Policy create_policy(int type, org.omg.CORBA.Any val)
    
public org.omg.CORBA.DynEnum create_dyn_enum(org.omg.CORBA.TypeCode type) throws
    
public org.omg.CORBA.DynUnion create_dyn_union(org.omg.CORBA.TypeCode type)
    
public org.omg.CORBA.DynArray create_dyn_array(org.omg.CORBA.TypeCode type)
    
public org.omg.CORBA.DynSequence create_dyn_sequence(org.omg.CORBA.TypeCode type)
    
public org.omg.CORBA.DynStruct create_dyn_struct(org.omg.CORBA.TypeCode type)
    
public org.omg.CORBA.DynAny create_basic_dyn_any(org.omg.CORBA.TypeCode type)
    
public org.omg.CORBA.DynAny create_dyn_any(org.omg.CORBA.Any value)
    
public boolean get_service_information(short service_type,
          ServiceInformationHolder service_info)
    
public void perform_work()
    
public boolean work_pending()
    
public void shutdown(boolean wait_for_completion)
    
public void run()
    
public org.omg.CORBA.Current get_current()
    
public org.omg.CORBA.TypeCode create_boxed_value_tc(String id,
							String name,
							TypeCode boxed_type)
    
public org.omg.CORBA.TypeCode create_recursive_value_tc(int offset)
    
public org.omg.CORBA.TypeCode create_value_tc(String id,
						  String name,
						  short type_modifier,
						  TypeCode concrete_base,
						  ValueMember[] members)
    
public org.omg.CORBA.TypeCode create_native_tc(String repository_id,
                                                   String type_name)
  
Any
  
	
    public void insert_Value(java.io.Serializable v, TypeCode t)
    
public void insert_Value(java.io.Serializable v)
    
public java.io.Serializable extract_Value()
    
public void insert_fixed(java.math.BigDecimal value,
			     org.omg.CORBA.TypeCode type)
    
public void insert_fixed(java.math.BigDecimal value)
    public java.math.BigDecimal extract_fixed()
  
  
TypeCode
  
  
  public TypeCode concrete_base_type()
  
public short type_modifier()
  public short member_visibility(int index)
  
  
ServerRequest
  
  
    public void set_exception(Any any)
    
public void set_result(org.omg.CORBA.Any any)
    
public void arguments(org.omg.CORBA.NVList args)
    public String operation()







Since: 
JDK1.2










  
      Overview 
    Package 
      Class 
      Use 
      Tree 
      Deprecated 
      Index 
      Help 
  



Java Platform 1.2






 PREV PACKAGE 
 NEXT PACKAGE

  FRAMES   
 NO FRAMES





Submit a bug or feature Version 1.2 of Java Platform API Specification
Java is a trademark or registered trademark of Sun Microsystems,  Inc. in the US and other countries.
Copyright 1993-1998 Sun Microsystems, Inc. 901 San Antonio Road,
Palo Alto, California, 94303, U.S.A.  All Rights Reserved.