< prev index next >
src/java.corba/share/classes/org/omg/CORBA/package.html
Print this page
*** 32,42 ****
-->
</HEAD>
<BODY BGCOLOR="#FFFFFF">
Provides the mapping of the OMG CORBA APIs to the Java<SUP><FONT
SIZE=-2>TM</FONT></SUP>
! programming language, including the class <TT>ORB</TT>, which is implemented
so that a programmer can use it as a fully-functional Object Request Broker
(ORB).
<P>For a precise list of supported sections of official CORBA specifications with which
the Java[TM] Platform, Standard Edition 6 complies, see <A
--- 32,42 ----
-->
</HEAD>
<BODY BGCOLOR="#FFFFFF">
Provides the mapping of the OMG CORBA APIs to the Java<SUP><FONT
SIZE=-2>TM</FONT></SUP>
! programming language, including the class <code>ORB</code>, which is implemented
so that a programmer can use it as a fully-functional Object Request Broker
(ORB).
<P>For a precise list of supported sections of official CORBA specifications with which
the Java[TM] Platform, Standard Edition 6 complies, see <A
*** 48,78 ****
The information in this section is information relevant to someone who
compiles Interface Definition Language (IDL) files and uses the
ORB to write clients and servers.
<P>The classes and interfaces described in this section can be put into
! four groups: <tt>ORB classes</tt>, Exceptions, <tt>Helper</tt> classes,
! and <tt>Holder</tt> classes.
<H2>
! The <tt>ORB</tt> Class</H2>
<P>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.
<P>Most of what an ORB does is completely transparent to the user, and a major
! portion of the <TT>CORBA</TT> 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 <TT>ORB</TT> class, some exceptions, and
occasionally,
a holder class.
<H3>
! <TT>ORB</TT> Methods</H3>
<P>Before an application can enter the CORBA environment, it must first:
<UL>
<LI>Be initialized into the ORB and possibly the object adapter (POA) environments.
<LI>Get references to ORB object (for use in future ORB operations)
--- 48,78 ----
The information in this section is information relevant to someone who
compiles Interface Definition Language (IDL) files and uses the
ORB to write clients and servers.
<P>The classes and interfaces described in this section can be put into
! four groups: <code>ORB classes</code>, Exceptions, <code>Helper</code> classes,
! and <code>Holder</code> classes.
<H2>
! The <code>ORB</code> Class</H2>
<P>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.
<P>Most of what an ORB does is completely transparent to the user, and a major
! portion of the <code>CORBA</code> 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 <code>ORB</code> class, some exceptions, and
occasionally,
a holder class.
<H3>
! <code>ORB</code> Methods</H3>
<P>Before an application can enter the CORBA environment, it must first:
<UL>
<LI>Be initialized into the ORB and possibly the object adapter (POA) environments.
<LI>Get references to ORB object (for use in future ORB operations)
*** 94,125 ****
an application into the ORB and OA environments. Second, it returns the
ORB object reference and the OA object reference to the application
for use in future ORB and OA operations.
<P>In order to obtain an ORB object reference, applications call
! the <tt>ORB.init</tt> operation. The parameters to the call can comprise an
identifier for the ORB for which the object reference is required,
and an arg_list, which is used to allow environment-specific data to be
passed into the call.
! <P>These are the <TT>ORB</TT> methods
that provide access to the ORB:
<UL>
<LI>
! <TT><b>init</b>()</TT>
<LI>
! <TT><b>init</b>(String [] args, Properties props)</TT>
<LI>
! <TT><b>init</b>(Applet app, Properties props)</TT>
</UL>
! <P>Using the <tt>init()</tt> method without parameters initiates
a singleton ORB, which can only
! give typecode creation <tt>any</tt>s needed in code generated
! in Helper classes by <tt>idlj</tt>.
<P>Applications require a portable means by which to obtain their
initial object references. References are required for the root
POA, POA Current, Interface Repository, and various Object Services
instances. The functionality required by the application is similar
--- 94,125 ----
an application into the ORB and OA environments. Second, it returns the
ORB object reference and the OA object reference to the application
for use in future ORB and OA operations.
<P>In order to obtain an ORB object reference, applications call
! the <code>ORB.init</code> operation. The parameters to the call can comprise an
identifier for the ORB for which the object reference is required,
and an arg_list, which is used to allow environment-specific data to be
passed into the call.
! <P>These are the <code>ORB</code> methods
that provide access to the ORB:
<UL>
<LI>
! <code><b>init</b>()</code>
<LI>
! <code><b>init</b>(String [] args, Properties props)</code>
<LI>
! <code><b>init</b>(Applet app, Properties props)</code>
</UL>
! <P>Using the <code>init()</code> method without parameters initiates
a singleton ORB, which can only
! give typecode creation <code>any</code>s needed in code generated
! in Helper classes by <code>idlj</code>.
<P>Applications require a portable means by which to obtain their
initial object references. References are required for the root
POA, POA Current, Interface Repository, and various Object Services
instances. The functionality required by the application is similar
*** 138,176 ****
<P>Initial references are obtained via two operations provided in
the ORB object interface, providing facilities to list and
resolve initial object references. These are:
<UL>
<LI>
! <TT><b>resolve_initial_references</b>(String name)</TT>
<LI>
! <TT><b>list_initial_services</b>()</TT>
<LI>
! <TT><b>register_initial_reference</b>(String id,
! org.omg.CORBA.Object obj)</TT>
</UL>
<P>An example that uses some of these methods is <A
HREF="{@docRoot}/../technotes/guides/idl/GShome.html">
<em>Getting Started with Java IDL</em></A>.
<H2>
Exceptions</H2>
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 <TT>try</TT>/<TT>catch</TT>
block and handle that exception when it is thrown.
<P>The documentation on <A
HREF="{@docRoot}/../technotes/guides/idl/jidlExceptions.html"><em>Java
IDL exceptions</em></A> has more information and explains the difference between
system exceptions and user-defined exceptions.
<P>The following is a list of the system exceptions (which are unchecked
! exceptions inheriting through <TT><a href="SystemException.html">
! org.omg.CORBA.SystemException</a></TT> from
! <TT>java.lang.RuntimeException</TT>) that are defined in the package
! <TT>org.omg.CORBA</TT>:
<PRE><code>
BAD_CONTEXT
BAD_INV_ORDER
BAD_OPERATION
BAD_PARAM
--- 138,175 ----
<P>Initial references are obtained via two operations provided in
the ORB object interface, providing facilities to list and
resolve initial object references. These are:
<UL>
<LI>
! <code><b>resolve_initial_references</b>(String name)</code>
<LI>
! <code><b>list_initial_services</b>()</code>
<LI>
! <code><b>register_initial_reference</b>(String id, org.omg.CORBA.Object obj)</code>
</UL>
<P>An example that uses some of these methods is <A
HREF="{@docRoot}/../technotes/guides/idl/GShome.html">
<em>Getting Started with Java IDL</em></A>.
<H2>
Exceptions</H2>
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 <code>try</code>/<code>catch</code>
block and handle that exception when it is thrown.
<P>The documentation on <A
HREF="{@docRoot}/../technotes/guides/idl/jidlExceptions.html"><em>Java
IDL exceptions</em></A> has more information and explains the difference between
system exceptions and user-defined exceptions.
<P>The following is a list of the system exceptions (which are unchecked
! exceptions inheriting through <code><a href="SystemException.html">
! org.omg.CORBA.SystemException</a></code> from
! <code>java.lang.RuntimeException</code>) that are defined in the package
! <code>org.omg.CORBA</code>:
<PRE><code>
BAD_CONTEXT
BAD_INV_ORDER
BAD_OPERATION
BAD_PARAM
*** 201,248 ****
TRANSIENT
UNKNOWN
</code></PRE>
<P>
The following is a list of user-defined exceptions defined in the package
! <TT>org.omg.CORBA</TT>.
<PRE><code>
Bounds
UnknownUserException
WrongTransaction
PolicyError
</code></PRE>
<H2>Subpackages</H2>
! There are some packages inside the <TT>CORBA</TT> 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 <TT>CORBA</TT> package.
! <P>For example, the package <TT><a href="TypeCodePackage/package-summary.html">
! org.omg.CORBA.TypeCodePackage</a></TT> contains
! two exceptions thrown by methods in the class <TT>TypeCode</TT>. These
exceptions are:
<UL>
<LI>
! <TT>BadKind</TT>
<LI>
! <TT>Bounds</TT>
</UL>
! The package <TT><a href="ORBPackage/package-summary.html">
! org.omg.CORBA.ORBPackage</a></TT> contains two exceptions:
<UL>
<LI>
! <TT>InvalidName</TT>
<LI>
! <TT>InconsistentTypeCode</TT>
</UL>
! <P>Another package that is a subpackage of <tt>CORBA</tt> is the <tt>
! <a href="portable/package-summary.html">portable</a></tt> package. It
! provides a set of ORB APIs that makes it
possible for code generated by one vendor's IDL compiler to run
on another vendor's ORB.
--- 200,247 ----
TRANSIENT
UNKNOWN
</code></PRE>
<P>
The following is a list of user-defined exceptions defined in the package
! <code>org.omg.CORBA</code>.
<PRE><code>
Bounds
UnknownUserException
WrongTransaction
PolicyError
</code></PRE>
<H2>Subpackages</H2>
! There are some packages inside the <code>CORBA</code> 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 <code>CORBA</code> package.
! <P>For example, the package <code><a href="TypeCodePackage/package-summary.html">
! org.omg.CORBA.TypeCodePackage</a></code> contains
! two exceptions thrown by methods in the class <code>TypeCode</code>. These
exceptions are:
<UL>
<LI>
! <code>BadKind</code>
<LI>
! <code>Bounds</code>
</UL>
! The package <code><a href="ORBPackage/package-summary.html">
! org.omg.CORBA.ORBPackage</a></code> contains two exceptions:
<UL>
<LI>
! <code>InvalidName</code>
<LI>
! <code>InconsistentTypeCode</code>
</UL>
! <P>Another package that is a subpackage of <code>CORBA</code> is the
! <code><a href="portable/package-summary.html">portable</a></code>
! package. It provides a set of ORB APIs that makes it
possible for code generated by one vendor's IDL compiler to run
on another vendor's ORB.
*** 253,299 ****
<P>Support for out and inout parameter passing modes requires the use of
additional <em><a href="doc-files/generatedfiles.html#holder">holder
classes</a></em>. Because the Java programming language does not support out or
inout parameters, holder classes are needed as a means of passing a parameter
! that can be modified. To support portable stubs and skeletons, holder classes also implement
! the <tt><a href="portable/Streamable.html">org.omg.CORBA.portable.Streamable</a>
! </tt> interface.
<P>Holder classes are named by appending "Holder" to the name of the type.
The name of the type refers to its name in the Java programming language. For
! example, a holder class for the interface named <tt>Account</tt> in the Java programming
! language would be named <tt>AccountHolder</tt>.
<P>Holder classes are available for all of the basic IDL
! datatypes in the <tt>org.omg.CORBA</tt> package. So, for example,
! there are already-defined classes for <tt>LongHolder</tt>, <tt>ShortHolder</tt>,
! <tt>FloatHolder</tt>, and so on. Classes are also generated for
! all named user-defined IDL types except those defined by <tt>typedefs</tt>.
(Note that in this context user defined includes types that are
defined in OMG specifications such as those for the Interface
Repository, and other OMG services.)
<P>Each holder class has:
<UL>
<LI>a constructor from an instance
<LI>a default constructor
! <LI>a public instance member, <tt>value</tt> which is the typed value.
<LI>a method for reading an input stream and assigning the contents to the
! type's <tt>value</tt> field
! <LI>a method for writing the value of the <tt>value</tt> field to an output stream
<LI>a method for getting the typecode of the type
</UL>
<P>The default constructor sets the value field to the default value for the
type as defined by the Java language:
<UL>
! <LI><tt>false</tt> for boolean
! <LI><tt>0</tt> for numeric and char types
! <LI><tt>null</tt> for strings and object references
</UL>
<P>
--- 252,300 ----
<P>Support for out and inout parameter passing modes requires the use of
additional <em><a href="doc-files/generatedfiles.html#holder">holder
classes</a></em>. Because the Java programming language does not support out or
inout parameters, holder classes are needed as a means of passing a parameter
! that can be modified. To support portable stubs and skeletons,
! holder classes also implement the
! <code><a href="portable/Streamable.html">org.omg.CORBA.portable.Streamable</a></code>
! interface.
<P>Holder classes are named by appending "Holder" to the name of the type.
The name of the type refers to its name in the Java programming language. For
! example, a holder class for the interface named <code>Account</code>
! in the Java programming
! language would be named <code>AccountHolder</code>.
<P>Holder classes are available for all of the basic IDL
! datatypes in the <code>org.omg.CORBA</code> package. So, for example,
! there are already-defined classes for <code>LongHolder</code>, <code>ShortHolder</code>,
! <code>FloatHolder</code>, and so on. Classes are also generated for
! all named user-defined IDL types except those defined by <code>typedefs</code>.
(Note that in this context user defined includes types that are
defined in OMG specifications such as those for the Interface
Repository, and other OMG services.)
<P>Each holder class has:
<UL>
<LI>a constructor from an instance
<LI>a default constructor
! <LI>a public instance member, <code>value</code> which is the typed value.
<LI>a method for reading an input stream and assigning the contents to the
! type's <code>value</code> field
! <LI>a method for writing the value of the <code>value</code> field to an output stream
<LI>a method for getting the typecode of the type
</UL>
<P>The default constructor sets the value field to the default value for the
type as defined by the Java language:
<UL>
! <LI><code>false</code> for boolean
! <LI><code>0</code> for numeric and char types
! <LI><code>null</code> for strings and object references
</UL>
<P>
*** 340,411 ****
</PRE>
<P>For more information on Holder classes, see Chapter 1.4, <em>Mapping for
Basic Types</em> in the <a href="http://www.omg.org/cgi-bin/doc?ptc/00-01-08">
<em>OMG IDL to Java Language Mapping</em></a>. The Holder classes defined
! in the package <TT>org.omg.CORBA</TT> are:
! <PRE>
! <TT>AnyHolder
! </TT> <TT>AnySeqHolder
! </TT> <TT>BooleanHolder
! </TT> <TT>BooleanSeqHolder
! </TT> <TT>ByteHolder
! </TT> <TT>CharHolder
! </TT> <TT>CharSeqHolder
! </TT> <TT>CurrentHolder
! </TT> <TT>DoubleHolder
! </TT> <TT>DoubleSeqHolder
! </TT> <TT>FixedHolder
! </TT> <TT>FloatHolder
! </TT> <TT>FloatSeqHolder
! </TT> <TT>IntHolder
! </TT> <TT>LongHolder
! </TT> <TT>LongLongSeqHolder
! </TT> <TT>LongSeqHolder
! </TT> <TT>ObjectHolder
! </TT> <TT>OctetSeqHolder
! </TT> <TT>ParameterModeHolder
! </TT> <TT>PolicyErrorHolder
! </TT> <TT>PolicyListHolder
! </TT> <TT>PrincipalHolder
! </TT> <TT>ServiceInformationHolder
! </TT> <TT>ShortHolder
! </TT> <TT>ShortSeqHolder
! </TT> <TT>StringHolder
! </TT> <TT>StringSeqHolder
! </TT> <TT>TypeCodeHolder
! </TT> <TT>ULongLongSeqHolder
! </TT> <TT>ULongSeqHolder
! </TT> <TT>UnknownUserExceptionHolder
! </TT> <TT>UShortSeqHolder
! </TT> <TT>ValueBaseHolder
! </TT> <TT>WCharSeqHolder
! </TT> <TT>WrongTransactionHolder
! </TT> <TT>WStringSeqHolder</TT>
!
! </PRE>
<h2>Helper Classes </h2>
<P>Helper files supply several static methods needed to manipulate the type.
These include:
<UL>
! <LI><tt>Any</tt> insert and extract operations for the type
<LI>getting the repository id
<LI>getting the typecode
<LI>reading and writing the type from and to a stream
<LI>implement the <code>ValueHelper</code> interface (if it is a user-defined
value type)
</UL>
<P>The helper class for a mapped IDL interface or abstract interface
! also include narrow operation(s). The static narrow method allows
! an <tt>org.omg.CORBA.Object</tt> to be narrowed to the object reference
! of a more specific type. The IDL exception <tt>CORBA.BAD_PARAM</tt>
! is thrown if the narrow fails because the object reference does not
! support the requested type. A different system exception is raised
! to indicate other kinds of errors. Trying to narrow a <tt>null</tt> will always
! succeed with a return value of <tt>null</tt>. Generally, the only helper method an application programmer uses is
the <code>narrow</code> method. The other methods are normally used behind
the scenes and are transparent to the programmer.
<P>Helper classes
fall into two broad categories, <a href="#value">helpers for value types</a> and
--- 341,412 ----
</PRE>
<P>For more information on Holder classes, see Chapter 1.4, <em>Mapping for
Basic Types</em> in the <a href="http://www.omg.org/cgi-bin/doc?ptc/00-01-08">
<em>OMG IDL to Java Language Mapping</em></a>. The Holder classes defined
! in the package <code>org.omg.CORBA</code> are:
! <PRE><code>
! AnyHolder
! AnySeqHolder
! BooleanHolder
! BooleanSeqHolder
! ByteHolder
! CharHolder
! CharSeqHolder
! CurrentHolder
! DoubleHolder
! DoubleSeqHolder
! FixedHolder
! FloatHolder
! FloatSeqHolder
! IntHolder
! LongHolder
! LongLongSeqHolder
! LongSeqHolder
! ObjectHolder
! OctetSeqHolder
! ParameterModeHolder
! PolicyErrorHolder
! PolicyListHolder
! PrincipalHolder
! ServiceInformationHolder
! ShortHolder
! ShortSeqHolder
! StringHolder
! StringSeqHolder
! TypeCodeHolder
! ULongLongSeqHolder
! ULongSeqHolder
! UnknownUserExceptionHolder
! UShortSeqHolder
! ValueBaseHolder
! WCharSeqHolder
! WrongTransactionHolder
! WStringSeqHolder
! </code></PRE>
<h2>Helper Classes </h2>
<P>Helper files supply several static methods needed to manipulate the type.
These include:
<UL>
! <LI><code>Any</code> insert and extract operations for the type
<LI>getting the repository id
<LI>getting the typecode
<LI>reading and writing the type from and to a stream
<LI>implement the <code>ValueHelper</code> interface (if it is a user-defined
value type)
</UL>
<P>The helper class for a mapped IDL interface or abstract interface
! also include narrow operation(s). The static narrow method allows
! an <code>org.omg.CORBA.Object</code> to be narrowed to the object reference
! of a more specific type. The IDL exception <code>CORBA.BAD_PARAM</code>
! is thrown if the narrow fails because the object reference does not
! support the requested type. A different system exception is raised
! to indicate other kinds of errors. Trying to narrow a <code>null</code> will always
! succeed with a return value of <code>null</code>.
! Generally, the only helper method an application programmer uses is
the <code>narrow</code> method. The other methods are normally used behind
the scenes and are transparent to the programmer.
<P>Helper classes
fall into two broad categories, <a href="#value">helpers for value types</a> and
*** 441,457 ****
<code>java.lang.Object</code> object. Whether the interface is abstract or
not determines which <code>narrow</code> method its helper class will provide.
The helper class for an interface
that is not abstract will have a <code>narrow</code> method that takes a CORBA
object, whereas the <code>narrow</code> method for an interface that is abstract
! will
! take an object in the Java programming language. The helper class for a
non-abstract interface that has at least one abstract base interface will provide
both versions of the <code>narrow</code> method.
<P>The <A HREF="{@docRoot}/../technotes/guides/idl/jidlExample.html"><em>Hello World</em></A>
! tutorial uses a <tt>narrow</tt> method that looks
! like this:
<PRE>
// create and initialize the ORB
ORB orb = ORB.init(args, null);
// get the root naming context
--- 442,456 ----
<code>java.lang.Object</code> object. Whether the interface is abstract or
not determines which <code>narrow</code> method its helper class will provide.
The helper class for an interface
that is not abstract will have a <code>narrow</code> method that takes a CORBA
object, whereas the <code>narrow</code> method for an interface that is abstract
! will take an object in the Java programming language. The helper class for a
non-abstract interface that has at least one abstract base interface will provide
both versions of the <code>narrow</code> method.
<P>The <A HREF="{@docRoot}/../technotes/guides/idl/jidlExample.html"><em>Hello World</em></A>
! tutorial uses a <code>narrow</code> method that looks like this:
<PRE>
// create and initialize the ORB
ORB orb = ORB.init(args, null);
// get the root naming context
*** 624,750 ****
}
</pre>
! <P>The Helper classes defined in the package <TT>org.omg.CORBA</TT> are:
<PRE><code>
! <TT>AnySeqHelper
! </TT> <TT>BooleanSeqHelper
! </TT> <TT>CharSeqHelper
! </TT> <TT>CompletionStatusHelper
! </TT> <TT>CurrentHelper
! </TT> <TT>DefinitionKindHelper
! </TT> <TT>DoubleSeqHelper
! </TT> <TT>FieldNameHelper
! </TT> <TT>FloatSeqHelper
! </TT> <TT>IdentifierHelper
! </TT> <TT>IDLTypeHelper
! </TT> <TT>LongLongSeqHelper
! </TT> <TT>LongSeqHelper
! </TT> <TT>NameValuePairHelper
! </TT> <TT>ObjectHelper
! </TT> <TT>OctetSeqHelper
! </TT> <TT>ParameterModeHelper
! </TT> <TT>PolicyErrorCodeHelper
! </TT> <TT>PolicyErrorHelper
! </TT> <TT>PolicyHelper
! </TT> <TT>PolicyListHelper
! </TT> <TT>PolicyTypeHelper
! </TT> <TT>RepositoryIdHelper
! </TT> <TT>ServiceDetailHelper
! </TT> <TT>ServiceInformationHelper
! </TT> <TT>SetOverrideTypeHelper
! </TT> <TT>ShortSeqHelper
! </TT> <TT>StringSeqHelper
! </TT> <TT>StringValueHelper
! </TT> <TT>StructMemberHelper
! </TT> <TT>ULongLongSeqHelper
! </TT> <TT>ULongSeqHelper
! </TT> <TT>UnionMemberHelper
! </TT> <TT>UnknownUserExceptionHelper
! </TT> <TT>UShortSeqHelper
! </TT> <TT>ValueBaseHelper
! </TT> <TT>ValueMemberHelper
! </TT> <TT>VersionSpecHelper
! </TT> <TT>VisibilityHelper
! </TT> <TT>WCharSeqHelper
! </TT> <TT>WrongTransactionHelper
! </TT> <TT>WStringSeqHelper
! </TT> <TT>WStringValueHelper</TT>
!
</code></PRE>
<a name="adv"></a>
<H1>
Other Classes</H1>
! The other classes and interfaces in the <TT>CORBA</TT> 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.
<H2>
Classes Created by an ORB</H2>
The first group contains classes that are created by an ORB and contain
information used in request operations.
<UL>
<LI>
! <TT>TCKind</TT> -- indicates the kind (datatype) for a <TT>TypeCode</TT>
object
<LI>
! <TT>TypeCode</TT> -- indicates a datatype and possibly other information
<LI>
! <TT>Any</TT> -- contains a value and its typecode
<LI>
! <TT>NamedValue</TT> -- contains a name, an <TT>Any</TT> object, and an
! argument mode flag. <TT>NamedValue</TT> objects contain information about
method arguments, method return values, or a context.
<LI>
! <TT>ContextList</TT> -- a list of strings that describe the contexts that
need to be resolved and sent with an invocation
<LI>
! <TT>ExceptionList</TT> -- a list of <TT>TypeCode</TT>s for exceptions that
may be thrown by a method
<LI>
! <TT>Environment</TT> -- a container for the exception thrown during a method
invocation
<LI>
! <TT>Context</TT> -- a list of <TT>NamedValue</TT> objects used to pass
auxiliary information from client to server
<LI>
! <TT>NVList</TT> -- a list of <TT>NamedValue</TT> objects, used to pass
arguments or get results
</UL>
<H2>
Classes That Deal with Requests</H2>
The second group of classes deals with requests:
<UL>
<LI>
! <TT>Object</TT> -- the base class for all CORBA object references
<LI>
! <TT>Request</TT> -- 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
<LI>
! <TT>DynamicImplementation</TT> -- the base class for server implementations
! using the DSI. It has the method <TT>invoke</TT>, which is used by an
implementation
! of this class to determine the state of a <TT>ServerRequest</TT> object
and to set its result or exception
<LI>
! <TT>ServerRequest</TT> -- captures the explicit state of a request for
the Dynamic Skeleton Interface
</UL>
<H2>
Interfaces That Serve as Constants</H2>
--- 623,748 ----
}
</pre>
! <P>The Helper classes defined in the package <code>org.omg.CORBA</code> are:
<PRE><code>
! AnySeqHelper
! BooleanSeqHelper
! CharSeqHelper
! CompletionStatusHelper
! CurrentHelper
! DefinitionKindHelper
! DoubleSeqHelper
! FieldNameHelper
! FloatSeqHelper
! IdentifierHelper
! IDLTypeHelper
! LongLongSeqHelper
! LongSeqHelper
! NameValuePairHelper
! ObjectHelper
! OctetSeqHelper
! ParameterModeHelper
! PolicyErrorCodeHelper
! PolicyErrorHelper
! PolicyHelper
! PolicyListHelper
! PolicyTypeHelper
! RepositoryIdHelper
! ServiceDetailHelper
! ServiceInformationHelper
! SetOverrideTypeHelper
! ShortSeqHelper
! StringSeqHelper
! StringValueHelper
! StructMemberHelper
! ULongLongSeqHelper
! ULongSeqHelper
! UnionMemberHelper
! UnknownUserExceptionHelper
! UShortSeqHelper
! ValueBaseHelper
! ValueMemberHelper
! VersionSpecHelper
! VisibilityHelper
! WCharSeqHelper
! WrongTransactionHelper
! WStringSeqHelper
! WStringValueHelper
</code></PRE>
<a name="adv"></a>
<H1>
Other Classes</H1>
! The other classes and interfaces in the <code>CORBA</code> 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.
<H2>
Classes Created by an ORB</H2>
The first group contains classes that are created by an ORB and contain
information used in request operations.
<UL>
<LI>
! <code>TCKind</code> -- indicates the kind (datatype) for a <code>TypeCode</code>
object
<LI>
! <code>TypeCode</code> -- indicates a datatype and possibly other information
<LI>
! <code>Any</code> -- contains a value and its typecode
<LI>
! <code>NamedValue</code> -- contains a name, an <code>Any</code> object, and an
! argument mode flag. <code>NamedValue</code> objects contain information about
method arguments, method return values, or a context.
<LI>
! <code>ContextList</code> -- a list of strings that describe the contexts that
need to be resolved and sent with an invocation
<LI>
! <code>ExceptionList</code> -- a list of <code>TypeCode</code>s for exceptions that
may be thrown by a method
<LI>
! <code>Environment</code> -- a container for the exception thrown during a method
invocation
<LI>
! <code>Context</code> -- a list of <code>NamedValue</code> objects used to pass
auxiliary information from client to server
<LI>
! <code>NVList</code> -- a list of <code>NamedValue</code> objects, used to pass
arguments or get results
</UL>
<H2>
Classes That Deal with Requests</H2>
The second group of classes deals with requests:
<UL>
<LI>
! <code>Object</code> -- the base class for all CORBA object references
<LI>
! <code>Request</code> -- 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
<LI>
! <code>DynamicImplementation</code> -- the base class for server implementations
! using the DSI. It has the method <code>invoke</code>, which is used by an
implementation
! of this class to determine the state of a <code>ServerRequest</code> object
and to set its result or exception
<LI>
! <code>ServerRequest</code> -- captures the explicit state of a request for
the Dynamic Skeleton Interface
</UL>
<H2>
Interfaces That Serve as Constants</H2>
*** 753,833 ****
values represented as public static final fields in that class (e.g.
DefinitionKind).
On the other hand IDL constants defined outside of an IDL interface are
mapped to a Java interface for each constant.
! <P>This is why several interfaces in the <TT>org.omg.CORBA</TT> package
! consist of a single field, <TT>value</TT>, which is a <TT>short</TT>. This
field is a constant used for such things as an error code or value modifier.
! For example, the <TT>value</TT> field of the interface <TT>BAD_POLICY</TT>
! is one of the possible reasons for the exception <TT>PolicyError</TT> to
! be thrown. To specify this error code, you would use <TT>BAD_POLICY.value</TT>.
! <P>The exception <TT>PolicyError</TT> uses the <TT>value</TT> field of
the following interfaces as its possible error codes.
<UL>
<LI>
! <TT>BAD_POLICY</TT>
<LI>
! <TT>BAD_POLICY_TYPE</TT>
<LI>
! <TT>BAD_POLICY_VALUE</TT>
<LI>
! <TT>UNSUPPORTED_POLICY</TT>
<LI>
! <TT>UNSUPPORTED_POLICY_VALUE</TT>
</UL>
! The method <TT>TypeCode.type_modifier</TT> returns the <TT>value</TT> field
! of one of the following interfaces. The <TT>VM</TT> in the names of these
interfaces stands for "value modifier."
<UL>
<LI>
! <TT>VM_NONE</TT>
<LI>
! <TT>VM_ABSTRACT</TT>
<LI>
! <TT>VM_CUSTOM</TT>
<LI>
! <TT>VM_TRUNCATABLE</TT>
</UL>
The following constants are returned by a <code>ValueMember</code> object's
access method to denote the visibility of the <code>ValueMember</code> object.
<UL>
<LI>
! <TT>PRIVATE_MEMBER</TT>
<LI>
! <TT>PUBLIC_MEMBER</TT>
</UL>
! These flags, used in <TT>NamedValue</TT> objects or as parameters to methods,
are defined in the following interfaces:
<UL>
<LI>
! <TT>ARG_IN</TT>
<LI>
! <TT>ARG_INOUT</TT>
<LI>
! <TT>ARG_OUT</TT>
<LI>
! <TT>CTX_RESTRICT_SCOPE</TT>
</UL>
<H2>
Interface Repository Interfaces and Classes</H2>
A fourth group contains the Interface Repository interfaces and classes,
! which are generated by the <TT>idlj</TT> compiler from the OMG IDL
! interface <TT>ir.idl</TT>. 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.
--- 751,831 ----
values represented as public static final fields in that class (e.g.
DefinitionKind).
On the other hand IDL constants defined outside of an IDL interface are
mapped to a Java interface for each constant.
! <P>This is why several interfaces in the <code>org.omg.CORBA</code> package
! consist of a single field, <code>value</code>, which is a <code>short</code>. This
field is a constant used for such things as an error code or value modifier.
! For example, the <code>value</code> field of the interface <code>BAD_POLICY</code>
! is one of the possible reasons for the exception <code>PolicyError</code> to
! be thrown. To specify this error code, you would use <code>BAD_POLICY.value</code>.
! <P>The exception <code>PolicyError</code> uses the <code>value</code> field of
the following interfaces as its possible error codes.
<UL>
<LI>
! <code>BAD_POLICY</code>
<LI>
! <code>BAD_POLICY_TYPE</code>
<LI>
! <code>BAD_POLICY_VALUE</code>
<LI>
! <code>UNSUPPORTED_POLICY</code>
<LI>
! <code>UNSUPPORTED_POLICY_VALUE</code>
</UL>
! The method <code>TypeCode.type_modifier</code> returns the <code>value</code> field
! of one of the following interfaces. The <code>VM</code> in the names of these
interfaces stands for "value modifier."
<UL>
<LI>
! <code>VM_NONE</code>
<LI>
! <code>VM_ABSTRACT</code>
<LI>
! <code>VM_CUSTOM</code>
<LI>
! <code>VM_TRUNCATABLE</code>
</UL>
The following constants are returned by a <code>ValueMember</code> object's
access method to denote the visibility of the <code>ValueMember</code> object.
<UL>
<LI>
! <code>PRIVATE_MEMBER</code>
<LI>
! <code>PUBLIC_MEMBER</code>
</UL>
! These flags, used in <code>NamedValue</code> objects or as parameters to methods,
are defined in the following interfaces:
<UL>
<LI>
! <code>ARG_IN</code>
<LI>
! <code>ARG_INOUT</code>
<LI>
! <code>ARG_OUT</code>
<LI>
! <code>CTX_RESTRICT_SCOPE</code>
</UL>
<H2>
Interface Repository Interfaces and Classes</H2>
A fourth group contains the Interface Repository interfaces and classes,
! which are generated by the <code>idlj</code> compiler from the OMG IDL
! interface <code>ir.idl</code>. 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.
*** 872,905 ****
<P><A NAME="unimpl"></A>
<H1>
CORBA Features Not Implemented in Java IDL</H1>
! <P>Some of the API included in <TT>org.omg</TT> subpackages is provided for
conformance with the current OMG CORBA specification but is not implemented
in Sun's release of the JDK<SUP><FONT SIZE=-2>TM</FONT></SUP>. This enables
other JDK licensees to provide implementations of this API in standard
extensions and products.
<P><A NAME="NO_IMPLEMENT"></A>
<h2>Features That Throw NO_IMPLEMENT</h2>
! <P>Some of the API included in <TT>org.omg</TT> subpackages throw
! <tt>NO_IMPLEMENT</tt> exceptions for various reasons. Among these reasons
are:
<UL>
! <LI>In some cases, for example <tt>LocalObject</tt>, the complete
implementation according to the specification indicates that
! these API should throw <tt>NO_IMPLEMENT</tt>.
! <LI>In most cases, for example methods in <tt>ORB.java</tt>,
methods that throw
! <tt>NO_IMPLEMENT</tt> are actually implemented in subclasses
elsewhere in the ORB code.
! <LI>In some cases, for example <tt>_get_interface_def()</tt>
! and <tt>_get_interface</tt>, API are really not yet implemented.
</UL>
--- 870,903 ----
<P><A NAME="unimpl"></A>
<H1>
CORBA Features Not Implemented in Java IDL</H1>
! <P>Some of the API included in <code>org.omg</code> subpackages is provided for
conformance with the current OMG CORBA specification but is not implemented
in Sun's release of the JDK<SUP><FONT SIZE=-2>TM</FONT></SUP>. This enables
other JDK licensees to provide implementations of this API in standard
extensions and products.
<P><A NAME="NO_IMPLEMENT"></A>
<h2>Features That Throw NO_IMPLEMENT</h2>
! <P>Some of the API included in <code>org.omg</code> subpackages throw
! <code>NO_IMPLEMENT</code> exceptions for various reasons. Among these reasons
are:
<UL>
! <LI>In some cases, for example <code>LocalObject</code>, the complete
implementation according to the specification indicates that
! these API should throw <code>NO_IMPLEMENT</code>.
! <LI>In most cases, for example methods in <code>ORB.java</code>,
methods that throw
! <code>NO_IMPLEMENT</code> are actually implemented in subclasses
elsewhere in the ORB code.
! <LI>In some cases, for example <code>_get_interface_def()</code>
! and <code>_get_interface</code>, API are really not yet implemented.
</UL>
*** 910,978 ****
<LI>
Interface Repository. An Interface Repository is not required for normal
operation of Java IDL.
<LI>
! Java IDL does not support <TT>long double</TT>.
<LI>
! Policies (<TT><a href="Policy.html">org.omg.CORBA.Policy</a></TT>) and methods for getting them are not implemented.
<LI>
! Domain managers (<TT><a href="DomainManager.html">org.omg.CORBA.DomainManager</a></TT>) and methods for
getting them are not implemented.
<LI>
! Service Information <TT><a href="ServiceInformation.html">org.omg.CORBA.ServiceInformation</a></TT> and ORB method <TT>public boolean get_service_information(short service_type,
! ServiceInformationHolder
! service_info)</TT> are not implemented.
! <LI>ORB methods for supporting single-threading (<tt>perform_work</tt>, <tt>work_pending</tt>) are not implemented.
<LI>IDL contexts.
</UL>
<HR>
<H2>
! Specific List of Unimplemented Features in Package <TT>org.omg.CORBA</TT></H2>
<H3>
! Unimplemented Methods in package <TT>org.omg.CORBA</TT>:</H3>
<UL>
<LI>
! <TT>ORB</TT>
<UL>
<LI>
! <TT>public org.omg.CORBA.Policy create_policy(int type, org.omg.CORBA.Any
! val)</TT>
<LI>
! <TT>public void perform_work()</TT>
<LI>
! <TT>public boolean work_pending()</TT>
<LI>
! <TT>public org.omg.CORBA.Current get_current()</TT>
<LI>
! <TT>create_operation_list</TT>
<LI>
! <TT>get_default_context</TT>
<LI>
! <TT>get_service_information</TT>
<LI>
! obsolete <TT>DynAnys</TT> (deprecated in favor of <tt>DynamicAny</tt> package)
</UL>
--- 908,978 ----
<LI>
Interface Repository. An Interface Repository is not required for normal
operation of Java IDL.
<LI>
! Java IDL does not support <code>long double</code>.
<LI>
! Policies (<code><a href="Policy.html">org.omg.CORBA.Policy</a></code>)
! and methods for getting them are not implemented.
<LI>
! Domain managers (<code><a href="DomainManager.html">org.omg.CORBA.DomainManager</a></code>) and methods for
getting them are not implemented.
<LI>
! Service Information <code><a href="ServiceInformation.html">org.omg.CORBA.ServiceInformation</a></code>
! and ORB method
! <code>public boolean get_service_information(short service_type, ServiceInformationHolder service_info)</code>
! are not implemented.
! <LI>ORB methods for supporting single-threading
! (<code>perform_work</code>, <code>work_pending</code>) are not implemented.
<LI>IDL contexts.
</UL>
<HR>
<H2>
! Specific List of Unimplemented Features in Package <code>org.omg.CORBA</code></H2>
<H3>
! Unimplemented Methods in package <code>org.omg.CORBA</code>:</H3>
<UL>
<LI>
! <code>ORB</code>
<UL>
<LI>
! <code>public org.omg.CORBA.Policy create_policy(int type, org.omg.CORBA.Any val)</code>
<LI>
! <code>public void perform_work()</code>
<LI>
! <code>public boolean work_pending()</code>
<LI>
! <code>public org.omg.CORBA.Current get_current()</code>
<LI>
! <code>create_operation_list</code>
<LI>
! <code>get_default_context</code>
<LI>
! <code>get_service_information</code>
<LI>
! obsolete <code>DynAnys</code> (deprecated in favor of <code>DynamicAny</code> package)
</UL>
< prev index next >