jdk-sandbox: comparison corba/src/java.corba/share/classes/org/omg/CORBA/ORB.java

equal deleted inserted replaced

-:6521875cb63e
+:936c391804a5
 import sun.reflect.misc.ReflectUtil;
 /**
 * A class providing APIs for the CORBA Object Request Broker
-* features.  The <code>ORB</code> class also provides
+* features.  The {@code ORB} class also provides
 * "pluggable ORB implementation" APIs that allow another vendor's ORB
 * implementation to be used.
 * <P>
 * An ORB makes it possible for CORBA objects to communicate
 * with each other by connecting objects making requests (clients) with
 * objects servicing requests (servers).
 * <P>
 *
-* The <code>ORB</code> class, which
+* The {@code ORB} class, which
 * encapsulates generic CORBA functionality, does the following:
 * (Note that items 5 and 6, which include most of the methods in
-* the class <code>ORB</code>, are typically used with the <code>Dynamic Invocation
+* the class {@code ORB}, are typically used with the
-* Interface</code> (DII) and the <code>Dynamic Skeleton Interface</code>
+* {@code Dynamic Invocation Interface} (DII) and
-* (DSI).
+* the {@code Dynamic Skeleton Interface} (DSI).
 * These interfaces may be used by a developer directly, but
 * most commonly they are used by the ORB internally and are
 * not seen by the general programmer.)
 * <OL>
 * <li> initializes the ORB implementation by supplying values for
 *      predefined properties and environmental parameters
 * <li> obtains initial object references to services such as
-* the NameService using the method <code>resolve_initial_references</code>
+* the NameService using the method {@code resolve_initial_references}
 * <li> converts object references to strings and back
 * <li> connects the ORB to a servant (an instance of a CORBA object
 * implementation) and disconnects the ORB from a servant
 * <li> creates objects such as
 *   <ul>
-*   <li><code>TypeCode</code>
+*   <li>{@code TypeCode}
-*   <li><code>Any</code>
+*   <li>{@code Any}
-*   <li><code>NamedValue</code>
+*   <li>{@code NamedValue}
-*   <li><code>Context</code>
+*   <li>{@code Context}
-*   <li><code>Environment</code>
+*   <li>{@code Environment}
-*   <li>lists (such as <code>NVList</code>) containing these objects
+*   <li>lists (such as {@code NVList}) containing these objects
 *   </ul>
 * <li> sends multiple messages in the DII
 * </OL>
 *
 * <P>
-* The <code>ORB</code> class can be used to obtain references to objects
+* The {@code ORB} class can be used to obtain references to objects
 * implemented anywhere on the network.
 * <P>
 * An application or applet gains access to the CORBA environment
-* by initializing itself into an <code>ORB</code> using one of
+* by initializing itself into an {@code ORB} using one of
-* three <code>init</code> methods.  Two of the three methods use the properties
+* three {@code init} methods.  Two of the three methods use the properties
 * (associations of a name with a value) shown in the
 * table below.<BR>
 * <TABLE BORDER=1 SUMMARY="Standard Java CORBA Properties">
 * <TR><TH>Property Name</TH>   <TH>Property Value</TH></TR>
 * <CAPTION>Standard Java CORBA Properties:</CAPTION>
 *     <TR><TD>org.omg.CORBA.ORBClass</TD>
 *     <TD>class name of an ORB implementation</TD></TR>
 *     <TR><TD>org.omg.CORBA.ORBSingletonClass</TD>
-*     <TD>class name of the ORB returned by <code>init()</code></TD></TR>
+*     <TD>class name of the ORB returned by {@code init()}</TD></TR>
 * </TABLE>
 * <P>
-* These properties allow a different vendor's <code>ORB</code>
+* These properties allow a different vendor's {@code ORB}
 * implementation to be "plugged in."
 * <P>
 * When an ORB instance is being created, the class name of the ORB
 * implementation is located using
 * the following standard search order:
 *         implementation)
 * </OL>
 * <P>
 * Note that Java&nbsp;IDL provides a default implementation for the
 * fully-functional ORB and for the Singleton ORB.  When the method
-* <code>init</code> is given no parameters, the default Singleton
+* {@code init} is given no parameters, the default Singleton
-* ORB is returned.  When the method <code>init</code> is given parameters
+* ORB is returned.  When the method {@code init} is given parameters
 * but no ORB class is specified, the Java&nbsp;IDL ORB implementation
 * is returned.
 * <P>
-* The following code fragment creates an <code>ORB</code> object
+* The following code fragment creates an {@code ORB} object
 * initialized with the default ORB Singleton.
 * This ORB has a
 * restricted implementation to prevent malicious applets from doing
 * anything beyond creating typecodes.
 * It is called a singleton
 * because there is only one instance for an entire virtual machine.
 * <PRE>
 *    ORB orb = ORB.init();
 * </PRE>
 * <P>
-* The following code fragment creates an <code>ORB</code> object
+* The following code fragment creates an {@code ORB} object
-* for an application.  The parameter <code>args</code>
+* for an application.  The parameter {@code args}
-* represents the arguments supplied to the application's <code>main</code>
+* represents the arguments supplied to the application's {@code main}
 * method.  Since the property specifies the ORB class to be
 * "SomeORBImplementation", the new ORB will be initialized with
 * that ORB implementation.  If p had been null,
 * and the arguments had not specified an ORB class,
 * the new ORB would have been
 *    Properties p = new Properties();
 *    p.put("org.omg.CORBA.ORBClass", "SomeORBImplementation");
 *    ORB orb = ORB.init(args, p);
 * </PRE>
 * <P>
-* The following code fragment creates an <code>ORB</code> object
+* The following code fragment creates an {@code ORB} object
 * for the applet supplied as the first parameter.  If the given
 * applet does not specify an ORB class, the new ORB will be
 * initialized with the default Java&nbsp;IDL implementation.
 * <PRE>
 *    ORB orb = ORB.init(myApplet, null);
 return propValue;
 }
 /**
-* Returns the <code>ORB</code> singleton object. This method always returns the
+* Returns the {@code ORB} singleton object. This method always returns the
 * same ORB instance, which is an instance of the class described by the
-* <code>org.omg.CORBA.ORBSingletonClass</code> system property.
+* {@code org.omg.CORBA.ORBSingletonClass} system property.
 * <P>
-* This no-argument version of the method <code>init</code> is used primarily
+* This no-argument version of the method {@code init} is used primarily
-* as a factory for <code>TypeCode</code> objects, which are used by
+* as a factory for {@code TypeCode} objects, which are used by
-* <code>Helper</code> classes to implement the method <code>type</code>.
+* {@code Helper} classes to implement the method {@code type}.
-* It is also used to create <code>Any</code> objects that are used to
+* It is also used to create {@code Any} objects that are used to
-* describe <code>union</code> labels (as part of creating a <code>
+* describe {@code union} labels (as part of creating a
-* TypeCode</code> object for a <code>union</code>).
+* {@code TypeCode} object for a {@code union}).
 * <P>
 * This method is not intended to be used by applets, and in the event
 * that it is called in an applet environment, the ORB it returns
 * is restricted so that it can be used only as a factory for
-* <code>TypeCode</code> objects.  Any <code>TypeCode</code> objects
+* {@code TypeCode} objects.  Any {@code TypeCode} objects
 * it produces can be safely shared among untrusted applets.
 * <P>
 * If an ORB is created using this method from an applet,
 * a system exception will be thrown if
 * methods other than those for
-* creating <code>TypeCode</code> objects are invoked.
+* creating {@code TypeCode} objects are invoked.
 *
 * @return the singleton ORB
 *
 * @implNote
 * When configured via the system property, or orb.properties,
 throw systemException;
 }
 }
 /**
-* Creates a new <code>ORB</code> instance for a standalone
+* Creates a new {@code ORB} instance for a standalone
 * application.  This method may be called from applications
-* only and returns a new fully functional <code>ORB</code> object
+* only and returns a new fully functional {@code ORB} object
 * each time it is called.
-* @param args command-line arguments for the application's <code>main</code>
+* @param args command-line arguments for the application's {@code main}
-*             method; may be <code>null</code>
+*             method; may be {@code null}
-* @param props application-specific properties; may be <code>null</code>
+* @param props application-specific properties; may be {@code null}
 * @return the newly-created ORB instance
 *
 * @implNote
 * When configured via the system property, or orb.properties,
 * the ORB is located via the thread context class loader.
 return orb;
 }
 /**
-* Creates a new <code>ORB</code> instance for an applet.  This
+* Creates a new {@code ORB} instance for an applet.  This
 * method may be called from applets only and returns a new
-* fully-functional <code>ORB</code> object each time it is called.
+* fully-functional {@code ORB} object each time it is called.
-* @param app the applet; may be <code>null</code>
+* @param app the applet; may be {@code null}
-* @param props applet-specific properties; may be <code>null</code>
+* @param props applet-specific properties; may be {@code null}
 * @return the newly-created ORB instance
 *
 * @implNote
 * When configured via the system property, or orb.properties,
 * the ORB is located via the thread context class loader.
 /**
 * Allows the ORB implementation to be initialized with the given
 * parameters and properties. This method, used in applications only,
 * is implemented by subclass ORB implementations and called
-* by the appropriate <code>init</code> method to pass in its parameters.
+* by the appropriate {@code init} method to pass in its parameters.
 *
-* @param args command-line arguments for the application's <code>main</code>
+* @param args command-line arguments for the application's {@code main}
-*             method; may be <code>null</code>
+*             method; may be {@code null}
-* @param props application-specific properties; may be <code>null</code>
+* @param props application-specific properties; may be {@code null}
 */
 abstract protected void set_parameters(String[] args, Properties props);
 /**
 * Allows the ORB implementation to be initialized with the given
 * applet and parameters. This method, used in applets only,
 * is implemented by subclass ORB implementations and called
-* by the appropriate <code>init</code> method to pass in its parameters.
+* by the appropriate {@code init} method to pass in its parameters.
 *
-* @param app the applet; may be <code>null</code>
+* @param app the applet; may be {@code null}
-* @param props applet-specific properties; may be <code>null</code>
+* @param props applet-specific properties; may be {@code null}
 */
 abstract protected void set_parameters(Applet app, Properties props);
 /**
 * Connects the given servant object (a Java object that is
 * an instance of the server implementation class)
 * to the ORB. The servant class must
-* extend the <code>ImplBase</code> class corresponding to the interface that is
+* extend the {@code ImplBase} class corresponding to the interface that is
 * supported by the server. The servant must thus be a CORBA object
-* reference, and inherit from <code>org.omg.CORBA.Object</code>.
+* reference, and inherit from {@code org.omg.CORBA.Object}.
 * Servants created by the user can start receiving remote invocations
-* after the method <code>connect</code> has been called. A servant may also be
+* after the method {@code connect} has been called. A servant may also be
 * automatically and implicitly connected to the ORB if it is passed as
 * an IDL parameter in an IDL method invocation on a non-local object,
 * that is, if the servant object has to be marshalled and sent outside of the
 * process address space.
 * <P>
-* Calling the method <code>connect</code> has no effect
+* Calling the method {@code connect} has no effect
 * when the servant object is already connected to the ORB.
 * <P>
 * Deprecated by the OMG in favor of the Portable Object Adapter APIs.
 *
 * @param obj The servant object reference
 }
 /**
 * Destroys the ORB so that its resources can be reclaimed.
 * Any operation invoked on a destroyed ORB reference will throw the
-* <code>OBJECT_NOT_EXIST</code> exception.
+* {@code OBJECT_NOT_EXIST} exception.
-* Once an ORB has been destroyed, another call to <code>init</code>
+* Once an ORB has been destroyed, another call to {@code init}
 * with the same ORBid will return a reference to a newly constructed ORB.<p>
-* If <code>destroy</code> is called on an ORB that has not been shut down,
+* If {@code destroy} is called on an ORB that has not been shut down,
 * it will start the shut down process and block until the ORB has shut down
 * before it destroys the ORB.<br>
-* If an application calls <code>destroy</code> in a thread that is currently servicing
+* If an application calls {@code destroy} in a thread that is currently servicing
-* an invocation, the <code>BAD_INV_ORDER</code> system exception will be thrown
+* an invocation, the {@code BAD_INV_ORDER} system exception will be thrown
 * with the OMG minor code 3, since blocking would result in a deadlock.<p>
 * For maximum portability and to avoid resource leaks, an application should
-* always call <code>shutdown</code> and <code>destroy</code>
+* always call {@code shutdown} and {@code destroy}
 * on all ORB instances before exiting.
 *
 * @throws org.omg.CORBA.BAD_INV_ORDER if the current thread is servicing an invocation
 */
 public void destroy( ) {
 /**
 * Disconnects the given servant object from the ORB. After this method returns,
 * the ORB will reject incoming remote requests for the disconnected
 * servant and will send the exception
-* <code>org.omg.CORBA.OBJECT_NOT_EXIST</code> back to the
+* {@code org.omg.CORBA.OBJECT_NOT_EXIST} back to the
 * remote client. Thus the object appears to be destroyed from the
 * point of view of remote clients. Note, however, that local requests issued
 * using the servant  directly do not
 * pass through the ORB; hence, they will continue to be processed by the
 * servant.
 * <P>
-* Calling the method <code>disconnect</code> has no effect
+* Calling the method {@code disconnect} has no effect
 * if the servant is not connected to the ORB.
 * <P>
 * Deprecated by the OMG in favor of the Portable Object Adapter APIs.
 *
 * @param obj The servant object to be disconnected from the ORB
 /**
 * Returns a list of the initially available CORBA object references,
 * such as "NameService" and "InterfaceRepository".
 *
-* @return an array of <code>String</code> objects that represent
+* @return an array of {@code String} objects that represent
 *         the object references for CORBA services
 *         that are initially available with this ORB
 */
 abstract public String[] list_initial_services();
 * Converts the given CORBA object reference to a string.
 * Note that the format of this string is predefined by IIOP, allowing
 * strings generated by a different ORB to be converted back into an object
 * reference.
 * <P>
-* The resulting <code>String</code> object may be stored or communicated
+* The resulting {@code String} object may be stored or communicated
-* in any way that a <code>String</code> object can be manipulated.
+* in any way that a {@code String} object can be manipulated.
 *
 * @param obj the object reference to stringify
 * @return the string representing the object reference
 */
 abstract public String object_to_string(org.omg.CORBA.Object obj);
 /**
-* Converts a string produced by the method <code>object_to_string</code>
+* Converts a string produced by the method {@code object_to_string}
 * back to a CORBA object reference.
 *
 * @param str the string to be converted back to an object reference.  It must
 * be the result of converting an object reference to a string using the
-* method <code>object_to_string</code>.
+* method {@code object_to_string}.
 * @return the object reference
 */
 abstract public org.omg.CORBA.Object string_to_object(String str);
 /**
-* Allocates an <code>NVList</code> with (probably) enough
+* Allocates an {@code NVList} with (probably) enough
-* space for the specified number of <code>NamedValue</code> objects.
+* space for the specified number of {@code NamedValue} objects.
 * Note that the specified size is only a hint to help with
 * storage allocation and does not imply the maximum size of the list.
 *
-* @param count  suggested number of <code>NamedValue</code> objects for
+* @param count  suggested number of {@code NamedValue} objects for
 *               which to allocate space
-* @return the newly-created <code>NVList</code>
+* @return the newly-created {@code NVList}
 *
 * @see NVList
 */
 abstract public NVList create_list(int count);
 /**
-* Creates an <code>NVList</code> initialized with argument
+* Creates an {@code NVList} initialized with argument
 * descriptions for the operation described in the given
-* <code>OperationDef</code> object.  This <code>OperationDef</code> object
+* {@code OperationDef} object.  This {@code OperationDef} object
 * is obtained from an Interface Repository. The arguments in the
-* returned <code>NVList</code> object are in the same order as in the
+* returned {@code NVList} object are in the same order as in the
 * original IDL operation definition, which makes it possible for the list
 * to be used in dynamic invocation requests.
 *
-* @param oper      the <code>OperationDef</code> object to use to create the list
+* @param oper      the {@code OperationDef} object to use to create the list
-* @return          a newly-created <code>NVList</code> object containing
+* @return          a newly-created {@code NVList} object containing
 * descriptions of the arguments to the method described in the given
-* <code>OperationDef</code> object
+* {@code OperationDef} object
 *
 * @see NVList
 */
 public NVList create_operation_list(org.omg.CORBA.Object oper)
 {
 }
 }
 /**
-* Creates a <code>NamedValue</code> object
+* Creates a {@code NamedValue} object
 * using the given name, value, and argument mode flags.
 * <P>
-* A <code>NamedValue</code> object serves as (1) a parameter or return
+* A {@code NamedValue} object serves as (1) a parameter or return
 * value or (2) a context property.
 * It may be used by itself or
-* as an element in an <code>NVList</code> object.
+* as an element in an {@code NVList} object.
 *
-* @param s  the name of the <code>NamedValue</code> object
+* @param s  the name of the {@code NamedValue} object
-* @param any  the <code>Any</code> value to be inserted into the
+* @param any  the {@code Any} value to be inserted into the
-*             <code>NamedValue</code> object
+*             {@code NamedValue} object
-* @param flags  the argument mode flags for the <code>NamedValue</code>: one of
+* @param flags  the argument mode flags for the {@code NamedValue}: one of
-* <code>ARG_IN.value</code>, <code>ARG_OUT.value</code>,
+* {@code ARG_IN.value}, {@code ARG_OUT.value},
-* or <code>ARG_INOUT.value</code>.
+* or {@code ARG_INOUT.value}.
 *
-* @return  the newly-created <code>NamedValue</code> object
+* @return  the newly-created {@code NamedValue} object
 * @see NamedValue
 */
 abstract public NamedValue create_named_value(String s, Any any, int flags);
 /**
-* Creates an empty <code>ExceptionList</code> object.
+* Creates an empty {@code ExceptionList} object.
 *
-* @return  the newly-created <code>ExceptionList</code> object
+* @return  the newly-created {@code ExceptionList} object
 */
 abstract public ExceptionList create_exception_list();
 /**
-* Creates an empty <code>ContextList</code> object.
+* Creates an empty {@code ContextList} object.
 *
-* @return  the newly-created <code>ContextList</code> object
+* @return  the newly-created {@code ContextList} object
 * @see ContextList
 * @see Context
 */
 abstract public ContextList create_context_list();
 /**
-* Gets the default <code>Context</code> object.
+* Gets the default {@code Context} object.
 *
-* @return the default <code>Context</code> object
+* @return the default {@code Context} object
 * @see Context
 */
 abstract public Context get_default_context();
 /**
-* Creates an <code>Environment</code> object.
+* Creates an {@code Environment} object.
 *
-* @return  the newly-created <code>Environment</code> object
+* @return  the newly-created {@code Environment} object
 * @see Environment
 */
 abstract public Environment create_environment();
 /**
-* Creates a new <code>org.omg.CORBA.portable.OutputStream</code> into which
+* Creates a new {@code org.omg.CORBA.portable.OutputStream} into which
 * IDL method parameters can be marshalled during method invocation.
-* @return          the newly-created
+* @return  the newly-created
-*              <code>org.omg.CORBA.portable.OutputStream</code> object
+*          {@code org.omg.CORBA.portable.OutputStream} object
 */
 abstract public org.omg.CORBA.portable.OutputStream create_output_stream();
 /**
 * Sends multiple dynamic (DII) requests asynchronously without expecting
 * any responses. Note that oneway invocations are not guaranteed to
 * reach the server.
 *
-* @param req               an array of request objects
+* @param req  an array of request objects
 */
 abstract public void send_multiple_requests_oneway(Request[] req);
 /**
 * Sends multiple dynamic (DII) requests asynchronously.
 *
-* @param req               an array of <code>Request</code> objects
+* @param req  an array of {@code Request} objects
 */
 abstract public void send_multiple_requests_deferred(Request[] req);
 /**
 * Finds out if any of the deferred (asynchronous) invocations have
 * a response yet.
-* @return <code>true</code> if there is a response available;
+* @return {@code true} if there is a response available;
-*         <code> false</code> otherwise
+*         {@code false} otherwise
 */
 abstract public boolean poll_next_response();
 /**
-* Gets the next <code>Request</code> instance for which a response
+* Gets the next {@code Request} instance for which a response
 * has been received.
 *
-* @return          the next <code>Request</code> object ready with a response
+* @return the next {@code Request} object ready with a response
-* @exception WrongTransaction if the method <code>get_next_response</code>
+* @exception WrongTransaction if the method {@code get_next_response}
 * is called from a transaction scope different
 * from the one from which the original request was sent. See the
 * OMG Transaction Service specification for details.
 */
 abstract public Request get_next_response() throws WrongTransaction;
 /**
-* Retrieves the <code>TypeCode</code> object that represents
+* Retrieves the {@code TypeCode} object that represents
 * the given primitive IDL type.
 *
-* @param tcKind    the <code>TCKind</code> instance corresponding to the
+* @param tcKind    the {@code TCKind} instance corresponding to the
 *                  desired primitive type
-* @return          the requested <code>TypeCode</code> object
+* @return          the requested {@code TypeCode} object
 */
 abstract public TypeCode get_primitive_tc(TCKind tcKind);
 /**
-* Creates a <code>TypeCode</code> object representing an IDL <code>struct</code>.
+* Creates a {@code TypeCode} object representing an IDL {@code struct}.
-* The <code>TypeCode</code> object is initialized with the given id,
+* The {@code TypeCode} object is initialized with the given id,
 * name, and members.
 *
-* @param id        the repository id for the <code>struct</code>
+* @param id        the repository id for the {@code struct}
-* @param name      the name of the <code>struct</code>
+* @param name      the name of the {@code struct}
-* @param members   an array describing the members of the <code>struct</code>
+* @param members   an array describing the members of the {@code struct}
-* @return          a newly-created <code>TypeCode</code> object describing
+* @return          a newly-created {@code TypeCode} object describing
-*              an IDL <code>struct</code>
+*                  an IDL {@code struct}
 */
 abstract public TypeCode create_struct_tc(String id, String name,
 StructMember[] members);
 /**
-* Creates a <code>TypeCode</code> object representing an IDL <code>union</code>.
+* Creates a {@code TypeCode} object representing an IDL {@code union}.
-* The <code>TypeCode</code> object is initialized with the given id,
+* The {@code TypeCode} object is initialized with the given id,
 * name, discriminator type, and members.
 *
-* @param id        the repository id of the <code>union</code>
+* @param id        the repository id of the {@code union}
-* @param name      the name of the <code>union</code>
+* @param name      the name of the {@code union}
-* @param discriminator_type        the type of the <code>union</code> discriminator
+* @param discriminator_type        the type of the {@code union} discriminator
-* @param members   an array describing the members of the <code>union</code>
+* @param members   an array describing the members of the {@code union}
-* @return          a newly-created <code>TypeCode</code> object describing
+* @return          a newly-created {@code TypeCode} object describing
-*              an IDL <code>union</code>
+*                  an IDL {@code union}
 */
 abstract public TypeCode create_union_tc(String id, String name,
 TypeCode discriminator_type,
 UnionMember[] members);
 /**
-* Creates a <code>TypeCode</code> object representing an IDL <code>enum</code>.
+* Creates a {@code TypeCode} object representing an IDL {@code enum}.
-* The <code>TypeCode</code> object is initialized with the given id,
+* The {@code TypeCode} object is initialized with the given id,
 * name, and members.
 *
-* @param id        the repository id for the <code>enum</code>
+* @param id        the repository id for the {@code enum}
-* @param name      the name for the <code>enum</code>
+* @param name      the name for the {@code enum}
-* @param members   an array describing the members of the <code>enum</code>
+* @param members   an array describing the members of the {@code enum}
-* @return          a newly-created <code>TypeCode</code> object describing
+* @return          a newly-created {@code TypeCode} object describing
-*              an IDL <code>enum</code>
+*                  an IDL {@code enum}
 */
 abstract public TypeCode create_enum_tc(String id, String name, String[] members);
 /**
-* Creates a <code>TypeCode</code> object representing an IDL <code>alias</code>
+* Creates a {@code TypeCode} object representing an IDL {@code alias}
-* (<code>typedef</code>).
+* ({@code typedef}).
-* The <code>TypeCode</code> object is initialized with the given id,
+* The {@code TypeCode} object is initialized with the given id,
 * name, and original type.
 *
 * @param id        the repository id for the alias
 * @param name      the name for the alias
 * @param original_type
-*                  the <code>TypeCode</code> object describing the original type
+*                  the {@code TypeCode} object describing the original type
-*          for which this is an alias
+*                  for which this is an alias
-* @return          a newly-created <code>TypeCode</code> object describing
+* @return          a newly-created {@code TypeCode} object describing
-*              an IDL <code>alias</code>
+*                  an IDL {@code alias}
 */
 abstract public TypeCode create_alias_tc(String id, String name,
 TypeCode original_type);
 /**
-* Creates a <code>TypeCode</code> object representing an IDL <code>exception</code>.
+* Creates a {@code TypeCode} object representing an IDL {@code exception}.
-* The <code>TypeCode</code> object is initialized with the given id,
+* The {@code TypeCode} object is initialized with the given id,
 * name, and members.
 *
-* @param id        the repository id for the <code>exception</code>
+* @param id        the repository id for the {@code exception}
-* @param name      the name for the <code>exception</code>
+* @param name      the name for the {@code exception}
-* @param members   an array describing the members of the <code>exception</code>
+* @param members   an array describing the members of the {@code exception}
-* @return          a newly-created <code>TypeCode</code> object describing
+* @return          a newly-created {@code TypeCode} object describing
-*              an IDL <code>exception</code>
+*                  an IDL {@code exception}
 */
 abstract public TypeCode create_exception_tc(String id, String name,
 StructMember[] members);
 /**
-* Creates a <code>TypeCode</code> object representing an IDL <code>interface</code>.
+* Creates a {@code TypeCode} object representing an IDL {@code interface}.
-* The <code>TypeCode</code> object is initialized with the given id
+* The {@code TypeCode} object is initialized with the given id
 * and name.
 *
-* @param id        the repository id for the interface
+* @param id    the repository id for the interface
-* @param name      the name for the interface
+* @param name  the name for the interface
-* @return          a newly-created <code>TypeCode</code> object describing
+* @return      a newly-created {@code TypeCode} object describing
-*              an IDL <code>interface</code>
+*              an IDL {@code interface}
 */
 abstract public TypeCode create_interface_tc(String id, String name);
 /**
-* Creates a <code>TypeCode</code> object representing a bounded IDL
+* Creates a {@code TypeCode} object representing a bounded IDL
-* <code>string</code>.
+* {@code string}.
-* The <code>TypeCode</code> object is initialized with the given bound,
+* The {@code TypeCode} object is initialized with the given bound,
 * which represents the maximum length of the string. Zero indicates
 * that the string described by this type code is unbounded.
 *
-* @param bound     the bound for the <code>string</code>; cannot be negative
+* @param bound the bound for the {@code string}; cannot be negative
-* @return          a newly-created <code>TypeCode</code> object describing
+* @return      a newly-created {@code TypeCode} object describing
-*              a bounded IDL <code>string</code>
+*              a bounded IDL {@code string}
 * @exception BAD_PARAM if bound is a negative value
 */
 abstract public TypeCode create_string_tc(int bound);
 /**
-* Creates a <code>TypeCode</code> object representing a bounded IDL
+* Creates a {@code TypeCode} object representing a bounded IDL
-* <code>wstring</code> (wide string).
+* {@code wstring} (wide string).
-* The <code>TypeCode</code> object is initialized with the given bound,
+* The {@code TypeCode} object is initialized with the given bound,
 * which represents the maximum length of the wide string. Zero indicates
 * that the string described by this type code is unbounded.
 *
-* @param bound     the bound for the <code>wstring</code>; cannot be negative
+* @param bound the bound for the {@code wstring}; cannot be negative
-* @return          a newly-created <code>TypeCode</code> object describing
+* @return      a newly-created {@code TypeCode} object describing
-*              a bounded IDL <code>wstring</code>
+*              a bounded IDL {@code wstring}
 * @exception BAD_PARAM if bound is a negative value
 */
 abstract public TypeCode create_wstring_tc(int bound);
 /**
-* Creates a <code>TypeCode</code> object representing an IDL <code>sequence</code>.
+* Creates a {@code TypeCode} object representing an IDL {@code sequence}.
-* The <code>TypeCode</code> object is initialized with the given bound and
+* The {@code TypeCode} object is initialized with the given bound and
 * element type.
 *
-* @param bound     the bound for the <code>sequence</code>, 0 if unbounded
+* @param bound     the bound for the {@code sequence}, 0 if unbounded
-* @param element_type
+* @param element_type the {@code TypeCode} object describing
-*                  the <code>TypeCode</code> object describing the elements
+*        the elements contained in the {@code sequence}
-*          contained in the <code>sequence</code>
+*
-* @return          a newly-created <code>TypeCode</code> object describing
+* @return  a newly-created {@code TypeCode} object describing
-*              an IDL <code>sequence</code>
+*          an IDL {@code sequence}
 */
 abstract public TypeCode create_sequence_tc(int bound, TypeCode element_type);
 /**
-* Creates a <code>TypeCode</code> object representing a
+* Creates a {@code TypeCode} object representing a
-* a recursive IDL <code>sequence</code>.
+* a recursive IDL {@code sequence}.
 * <P>
-* For the IDL <code>struct</code> Node in following code fragment,
+* For the IDL {@code struct} Node in following code fragment,
 * the offset parameter for creating its sequence would be 1:
 * <PRE>
 *    Struct Node {
 *        long value;
 *        Sequence &lt;Node&gt; subnodes;
 *    };
 * </PRE>
 *
 * @param bound     the bound for the sequence, 0 if unbounded
-* @param offset    the index to the enclosing <code>TypeCode</code> object
+* @param offset    the index to the enclosing {@code TypeCode} object
 *                  that describes the elements of this sequence
-* @return          a newly-created <code>TypeCode</code> object describing
+* @return          a newly-created {@code TypeCode} object describing
-*                   a recursive sequence
+*                  a recursive sequence
 * @deprecated Use a combination of create_recursive_tc and create_sequence_tc instead
 * @see #create_recursive_tc(String) create_recursive_tc
 * @see #create_sequence_tc(int, TypeCode) create_sequence_tc
 */
 @Deprecated
 abstract public TypeCode create_recursive_sequence_tc(int bound, int offset);
 /**
-* Creates a <code>TypeCode</code> object representing an IDL <code>array</code>.
+* Creates a {@code TypeCode} object representing an IDL {@code array}.
-* The <code>TypeCode</code> object is initialized with the given length and
+* The {@code TypeCode} object is initialized with the given length and
 * element type.
 *
-* @param length    the length of the <code>array</code>
+* @param length    the length of the {@code array}
-* @param element_type  a <code>TypeCode</code> object describing the type
+* @param element_type  a {@code TypeCode} object describing the type
-*                      of element contained in the <code>array</code>
+*                      of element contained in the {@code array}
-* @return          a newly-created <code>TypeCode</code> object describing
+* @return  a newly-created {@code TypeCode} object describing
-*              an IDL <code>array</code>
+*          an IDL {@code array}
 */
 abstract public TypeCode create_array_tc(int length, TypeCode element_type);
 /**
-* Create a <code>TypeCode</code> object for an IDL native type.
+* Create a {@code TypeCode} object for an IDL native type.
 *
 * @param id        the logical id for the native type.
 * @param name      the name of the native type.
 * @return          the requested TypeCode.
 */
 {
 throw new org.omg.CORBA.NO_IMPLEMENT();
 }
 /**
-* Create a <code>TypeCode</code> object for an IDL abstract interface.
+* Create a {@code TypeCode} object for an IDL abstract interface.
 *
 * @param id        the logical id for the abstract interface type.
 * @param name      the name of the abstract interface type.
 * @return          the requested TypeCode.
 */
 throw new org.omg.CORBA.NO_IMPLEMENT();
 }
 /**
-* Create a <code>TypeCode</code> object for an IDL fixed type.
+* Create a {@code TypeCode} object for an IDL fixed type.
 *
 * @param digits    specifies the total number of decimal digits in the number
 *                  and must be from 1 to 31 inclusive.
 * @param scale     specifies the position of the decimal point.
 * @return          the requested TypeCode.
 // orbos 98-01-18: Objects By Value -- begin
 /**
-* Create a <code>TypeCode</code> object for an IDL value type.
+* Create a {@code TypeCode} object for an IDL value type.
 * The concrete_base parameter is the TypeCode for the immediate
 * concrete valuetype base of the valuetype for which the TypeCode
 * is being created.
 * It may be null if the valuetype does not have a concrete base.
 *
 * @param id                 the logical id for the value type.
 * @param name               the name of the value type.
 * @param type_modifier      one of the value type modifier constants:
 *                           VM_NONE, VM_CUSTOM, VM_ABSTRACT or VM_TRUNCATABLE
-* @param concrete_base      a <code>TypeCode</code> object
+* @param concrete_base      a {@code TypeCode} object
 *                           describing the concrete valuetype base
 * @param members            an array containing the members of the value type
 * @return                   the requested TypeCode
 */
 public org.omg.CORBA.TypeCode create_value_tc(String id,
 {
 throw new org.omg.CORBA.NO_IMPLEMENT();
 }
 /**
-* Create a recursive <code>TypeCode</code> object which
+* Create a recursive {@code TypeCode} object which
 * serves as a placeholder for a concrete TypeCode during the process of creating
 * TypeCodes which contain recursion. The id parameter specifies the repository id of
 * the type for which the recursive TypeCode is serving as a placeholder. Once the
 * recursive TypeCode has been properly embedded in the enclosing TypeCode which
 * corresponds to the specified repository id, it will function as a normal TypeCode.
 * Invoking operations on the recursive TypeCode before it has been embedded in the
-* enclosing TypeCode will result in a <code>BAD_TYPECODE</code> exception.
+* enclosing TypeCode will result in a {@code BAD_TYPECODE} exception.
 * <P>
 * For example, the following IDL type declaration contains recursion:
 * <PRE>
 *    Struct Node {
 *        Sequence&lt;Node&gt; subnodes;
 // implemented in subclass
 throw new org.omg.CORBA.NO_IMPLEMENT();
 }
 /**
-* Creates a <code>TypeCode</code> object for an IDL value box.
+* Creates a {@code TypeCode} object for an IDL value box.
 *
 * @param id                 the logical id for the value type
 * @param name               the name of the value type
 * @param boxed_type         the TypeCode for the type
 * @return                   the requested TypeCode
 }
 // orbos 98-01-18: Objects By Value -- end
 /**
-* Creates an IDL <code>Any</code> object initialized to
+* Creates an IDL {@code Any} object initialized to
-* contain a <code>Typecode</code> object whose <code>kind</code> field
+* contain a {@code Typecode} object whose {@code kind} field
-* is set to <code>TCKind.tc_null</code>.
+* is set to {@code TCKind.tc_null}.
 *
-* @return          a newly-created <code>Any</code> object
+* @return          a newly-created {@code Any} object
 */
 abstract public Any create_any();
 /**
-* Retrieves a <code>Current</code> object.
+* Retrieves a {@code Current} object.
-* The <code>Current</code> interface is used to manage thread-specific
+* The {@code Current} interface is used to manage thread-specific
 * information for use by services such as transactions and security.
 *
 * @see <a href="package-summary.html#unimpl"><code>CORBA</code> package
 *      comments for unimplemented features</a>
 *
-* @return          a newly-created <code>Current</code> object
+* @return          a newly-created {@code Current} object
-* @deprecated      use <code>resolve_initial_references</code>.
+* @deprecated      use {@code resolve_initial_references}.
 */
 @Deprecated
 public org.omg.CORBA.Current get_current()
 {
 throw new org.omg.CORBA.NO_IMPLEMENT();
 }
 /**
 * This operation blocks the current thread until the ORB has
 * completed the shutdown process, initiated when some thread calls
-* <code>shutdown</code>. It may be used by multiple threads which
+* {@code shutdown}. It may be used by multiple threads which
 * get all notified when the ORB shuts down.
 *
 */
 public void run()
 {
 }
 /**
 * Instructs the ORB to shut down, which causes all
 * object adapters to shut down, in preparation for destruction.<br>
-* If the <code>wait_for_completion</code> parameter
+* If the {@code wait_for_completion} parameter
 * is true, this operation blocks until all ORB processing (including
 * processing of currently executing requests, object deactivation,
 * and other object adapter operations) has completed.
 * If an application does this in a thread that is currently servicing
-* an invocation, the <code>BAD_INV_ORDER</code> system exception
+* an invocation, the {@code BAD_INV_ORDER} system exception
 * will be thrown with the OMG minor code 3,
 * since blocking would result in a deadlock.<br>
-* If the <code>wait_for_completion</code> parameter is <code>FALSE</code>,
+* If the {@code wait_for_completion} parameter is {@code FALSE},
 * then shutdown may not have completed upon return.<p>
 * While the ORB is in the process of shutting down, the ORB operates as normal,
 * servicing incoming and outgoing requests until all requests have been completed.
 * Once an ORB has shutdown, only object reference management operations
 * may be invoked on the ORB or any object reference obtained from it.
-* An application may also invoke the <code>destroy</code> operation on the ORB itself.
+* An application may also invoke the {@code destroy} operation on the ORB itself.
-* Invoking any other operation will throw the <code>BAD_INV_ORDER</code>
+* Invoking any other operation will throw the {@code BAD_INV_ORDER}
 * system exception with the OMG minor code 4.<p>
-* The <code>ORB.run</code> method will return after
+* The {@code ORB.run} method will return after
-* <code>shutdown</code> has been called.
+* {@code shutdown} has been called.
 *
-* @param wait_for_completion <code>true</code> if the call
+* @param wait_for_completion {@code true} if the call
 *        should block until the shutdown is complete;
-*        <code>false</code> if it should return immediately
+*        {@code false} if it should return immediately
 * @throws org.omg.CORBA.BAD_INV_ORDER if the current thread is servicing
 *         an invocation
 */
 public void shutdown(boolean wait_for_completion)
 {
 throw new org.omg.CORBA.NO_IMPLEMENT();
 }
 /**
-* Returns <code>true</code> if the ORB needs the main thread to
+* Returns {@code true} if the ORB needs the main thread to
-* perform some work, and <code>false</code> if the ORB does not
+* perform some work, and {@code false} if the ORB does not
 * need the main thread.
 *
-* @return <code>true</code> if there is work pending, meaning that the ORB
+* @return {@code true} if there is work pending, meaning that the ORB
-*         needs the main thread to perform some work; <code>false</code>
+*         needs the main thread to perform some work; {@code false}
 *         if there is no work pending and thus the ORB does not need the
 *         main thread
 *
 */
 public boolean work_pending()
 }
 /**
 * Performs an implementation-dependent unit of work if called
 * by the main thread. Otherwise it does nothing.
-* The methods <code>work_pending</code> and <code>perform_work</code>
+* The methods {@code work_pending} and {@code perform_work}
 * can be used in
 * conjunction to implement a simple polling loop that multiplexes
 * the main thread among the ORB and other activities.
 *
 */
 /**
 * Used to obtain information about CORBA facilities and services
 * that are supported by this ORB. The service type for which
 * information is being requested is passed in as the in
-* parameter <tt>service_type</tt>, the values defined by
+* parameter {@code service_type}, the values defined by
 * constants in the CORBA module. If service information is
 * available for that type, that is returned in the out parameter
-* <tt>service_info</tt>, and the operation returns the
+* {@code service_info}, and the operation returns the
-* value <tt>true</tt>. If no information for the requested
+* value {@code true}. If no information for the requested
-* services type is available, the operation returns <tt>false</tt>
+* services type is available, the operation returns {@code false}
 *  (i.e., the service is not supported by this ORB).
 *
-* @param service_type a <code>short</code> indicating the
+* @param service_type a {@code short} indicating the
 *        service type for which information is being requested
-* @param service_info a <code>ServiceInformationHolder</code> object
+* @param service_info a {@code ServiceInformationHolder} object
-*        that will hold the <code>ServiceInformation</code> object
+*        that will hold the {@code ServiceInformation} object
 *        produced by this method
-* @return <code>true</code> if service information is available
+* @return {@code true} if service information is available
-*        for the <tt>service_type</tt>;
+*        for the {@code service_type};
-*         <tt>false</tt> if no information for the
+*        {@code false} if no information for the
-*         requested services type is available
+*        requested services type is available
 * @see <a href="package-summary.html#unimpl"><code>CORBA</code> package
 *      comments for unimplemented features</a>
 */
 public boolean get_service_information(short service_type,
 ServiceInformationHolder service_info)
 }
 // orbos 98-01-18: Objects By Value -- begin
 /**
-* Creates a new <code>DynAny</code> object from the given
+* Creates a new {@code DynAny} object from the given
-* <code>Any</code> object.
+* {@code Any} object.
 *
-* @param value the <code>Any</code> object from which to create a new
+* @param value the {@code Any} object from which to create a new
-*        <code>DynAny</code> object
+*        {@code DynAny} object
-* @return the new <code>DynAny</code> object created from the given
+* @return the new {@code DynAny} object created from the given
-*         <code>Any</code> object
+*         {@code Any} object
 * @see <a href="package-summary.html#unimpl"><code>CORBA</code> package
 *      comments for unimplemented features</a>
 * @deprecated Use the new <a href="../DynamicAny/DynAnyFactory.html">DynAnyFactory</a> API instead
 */
 @Deprecated
 {
 throw new org.omg.CORBA.NO_IMPLEMENT();
 }
 /**
-* Creates a basic <code>DynAny</code> object from the given
+* Creates a basic {@code DynAny} object from the given
-* <code>TypeCode</code> object.
+* {@code TypeCode} object.
 *
-* @param type the <code>TypeCode</code> object from which to create a new
+* @param type the {@code TypeCode} object from which to create a new
-*        <code>DynAny</code> object
+*        {@code DynAny} object
-* @return the new <code>DynAny</code> object created from the given
+* @return the new {@code DynAny} object created from the given
-*         <code>TypeCode</code> object
+*         {@code TypeCode} object
 * @throws org.omg.CORBA.ORBPackage.InconsistentTypeCode if the given
-*         <code>TypeCode</code> object is not consistent with the operation.
+*         {@code TypeCode} object is not consistent with the operation.
 * @see <a href="package-summary.html#unimpl"><code>CORBA</code> package
 *      comments for unimplemented features</a>
 * @deprecated Use the new <a href="../DynamicAny/DynAnyFactory.html">DynAnyFactory</a> API instead
 */
 @Deprecated
 {
 throw new org.omg.CORBA.NO_IMPLEMENT();
 }
 /**
-* Creates a new <code>DynStruct</code> object from the given
+* Creates a new {@code DynStruct} object from the given
-* <code>TypeCode</code> object.
+* {@code TypeCode} object.
 *
-* @param type the <code>TypeCode</code> object from which to create a new
+* @param type the {@code TypeCode} object from which to create a new
-*        <code>DynStruct</code> object
+*        {@code DynStruct} object
-* @return the new <code>DynStruct</code> object created from the given
+* @return the new {@code DynStruct} object created from the given
-*         <code>TypeCode</code> object
+*         {@code TypeCode} object
 * @throws org.omg.CORBA.ORBPackage.InconsistentTypeCode if the given
-*         <code>TypeCode</code> object is not consistent with the operation.
+*         {@code TypeCode} object is not consistent with the operation.
 * @see <a href="package-summary.html#unimpl"><code>CORBA</code> package
 *      comments for unimplemented features</a>
 * @deprecated Use the new <a href="../DynamicAny/DynAnyFactory.html">DynAnyFactory</a> API instead
 */
 @Deprecated
 {
 throw new org.omg.CORBA.NO_IMPLEMENT();
 }
 /**
-* Creates a new <code>DynSequence</code> object from the given
+* Creates a new {@code DynSequence} object from the given
-* <code>TypeCode</code> object.
+* {@code TypeCode} object.
 *
-* @param type the <code>TypeCode</code> object from which to create a new
+* @param type the {@code TypeCode} object from which to create a new
-*        <code>DynSequence</code> object
+*        {@code DynSequence} object
-* @return the new <code>DynSequence</code> object created from the given
+* @return the new {@code DynSequence} object created from the given
-*         <code>TypeCode</code> object
+*         {@code TypeCode} object
 * @throws org.omg.CORBA.ORBPackage.InconsistentTypeCode if the given
-*         <code>TypeCode</code> object is not consistent with the operation.
+*         {@code TypeCode} object is not consistent with the operation.
 * @see <a href="package-summary.html#unimpl"><code>CORBA</code> package
 *      comments for unimplemented features</a>
 * @deprecated Use the new <a href="../DynamicAny/DynAnyFactory.html">DynAnyFactory</a> API instead
 */
 @Deprecated
 throw new org.omg.CORBA.NO_IMPLEMENT();
 }
 /**
-* Creates a new <code>DynArray</code> object from the given
+* Creates a new {@code DynArray} object from the given
-* <code>TypeCode</code> object.
+* {@code TypeCode} object.
 *
-* @param type the <code>TypeCode</code> object from which to create a new
+* @param type the {@code TypeCode} object from which to create a new
-*        <code>DynArray</code> object
+*        {@code DynArray} object
-* @return the new <code>DynArray</code> object created from the given
+* @return the new {@code DynArray} object created from the given
-*         <code>TypeCode</code> object
+*         {@code TypeCode} object
 * @throws org.omg.CORBA.ORBPackage.InconsistentTypeCode if the given
-*         <code>TypeCode</code> object is not consistent with the operation.
+*         {@code TypeCode} object is not consistent with the operation.
 * @see <a href="package-summary.html#unimpl"><code>CORBA</code> package
 *      comments for unimplemented features</a>
 * @deprecated Use the new <a href="../DynamicAny/DynAnyFactory.html">DynAnyFactory</a> API instead
 */
 @Deprecated
 {
 throw new org.omg.CORBA.NO_IMPLEMENT();
 }
 /**
-* Creates a new <code>DynUnion</code> object from the given
+* Creates a new {@code DynUnion} object from the given
-* <code>TypeCode</code> object.
+* {@code TypeCode} object.
 *
-* @param type the <code>TypeCode</code> object from which to create a new
+* @param type the {@code TypeCode} object from which to create a new
-*        <code>DynUnion</code> object
+*        {@code DynUnion} object
-* @return the new <code>DynUnion</code> object created from the given
+* @return the new {@code DynUnion} object created from the given
-*         <code>TypeCode</code> object
+*         {@code TypeCode} object
 * @throws org.omg.CORBA.ORBPackage.InconsistentTypeCode if the given
-*         <code>TypeCode</code> object is not consistent with the operation.
+*         {@code TypeCode} object is not consistent with the operation.
 * @see <a href="package-summary.html#unimpl"><code>CORBA</code> package
 *      comments for unimplemented features</a>
 * @deprecated Use the new <a href="../DynamicAny/DynAnyFactory.html">DynAnyFactory</a> API instead
 */
 @Deprecated
 {
 throw new org.omg.CORBA.NO_IMPLEMENT();
 }
 /**
-* Creates a new <code>DynEnum</code> object from the given
+* Creates a new {@code DynEnum} object from the given
-* <code>TypeCode</code> object.
+* {@code TypeCode} object.
 *
-* @param type the <code>TypeCode</code> object from which to create a new
+* @param type the {@code TypeCode} object from which to create a new
-*        <code>DynEnum</code> object
+*        {@code DynEnum} object
-* @return the new <code>DynEnum</code> object created from the given
+* @return the new {@code DynEnum} object created from the given
-*         <code>TypeCode</code> object
+*         {@code TypeCode} object
 * @throws org.omg.CORBA.ORBPackage.InconsistentTypeCode if the given
-*         <code>TypeCode</code> object is not consistent with the operation.
+*         {@code TypeCode} object is not consistent with the operation.
 * @see <a href="package-summary.html#unimpl"><code>CORBA</code> package
 *      comments for unimplemented features</a>
 * @deprecated Use the new <a href="../DynamicAny/DynAnyFactory.html">DynAnyFactory</a> API instead
 */
 @Deprecated
 }
 /**
 * Can be invoked to create new instances of policy objects
 * of a specific type with specified initial state. If
-* <tt>create_policy</tt> fails to instantiate a new Policy
+* {@code create_policy} fails to instantiate a new Policy
 * object due to its inability to interpret the requested type
-* and content of the policy, it raises the <tt>PolicyError</tt>
+* and content of the policy, it raises the {@code PolicyError}
 * exception with the appropriate reason.
-* @param type the <tt>PolicyType</tt> of the policy object to
+* @param type the {@code PolicyType} of the policy object to
 *        be created
 * @param val the value that will be used to set the initial
-*        state of the <tt>Policy</tt> object that is created
+*        state of the {@code Policy} object that is created
-* @return Reference to a newly created <tt>Policy</tt> object
+* @return Reference to a newly created {@code Policy} object
-*        of type specified by the <tt>type</tt> parameter and
+*        of type specified by the {@code type} parameter and
-*        initialized to a state specified by the <tt>val</tt>
+*        initialized to a state specified by the {@code val}
 *        parameter
-* @throws <tt>org.omg.CORBA.PolicyError</tt> when the requested
+* @throws org.omg.CORBA.PolicyError when the requested
 *        policy is not supported or a requested initial state
 *        for the policy is not supported.
 */
 public org.omg.CORBA.Policy create_policy(int type, org.omg.CORBA.Any val)
 throws org.omg.CORBA.PolicyError

changeset 32688	936c391804a5
parent 29827	aac4782e69ac
child 43345	a3460624dc33