jdk8-mips64-public/corba: comparison src/share/classes/org/omg/CORBA/ORB.java

--1:000000000000
+:7ef37b2cdcad
+/*
+* Copyright (c) 1995, 2014, Oracle and/or its affiliates. All rights reserved.
+* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+*
+* This code is free software; you can redistribute it and/or modify it
+* under the terms of the GNU General Public License version 2 only, as
+* published by the Free Software Foundation.  Oracle designates this
+* particular file as subject to the "Classpath" exception as provided
+* by Oracle in the LICENSE file that accompanied this code.
+*
+* This code is distributed in the hope that it will be useful, but WITHOUT
+* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+* FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+* version 2 for more details (a copy is included in the LICENSE file that
+* accompanied this code).
+*
+* You should have received a copy of the GNU General Public License version
+* 2 along with this work; if not, write to the Free Software Foundation,
+* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+*
+* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+* or visit www.oracle.com if you need additional information or have any
+* questions.
+*/
+package org.omg.CORBA;
+import org.omg.CORBA.portable.*;
+import org.omg.CORBA.ORBPackage.InvalidName;
+import java.util.Properties;
+import java.applet.Applet;
+import java.io.File;
+import java.io.FileInputStream;
+import java.security.AccessController;
+import java.security.PrivilegedAction;
+import sun.reflect.misc.ReflectUtil;
+/**
+* A class providing APIs for the CORBA Object Request Broker
+* features.  The <code>ORB</code> 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
+* 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
+* Interface</code> (DII) and the <code>Dynamic Skeleton Interface</code>
+* (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>
+* <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>Any</code>
+*   <li><code>NamedValue</code>
+*   <li><code>Context</code>
+*   <li><code>Environment</code>
+*   <li>lists (such as <code>NVList</code>) 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
+* 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
+* three <code>init</code> 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>
+* </TABLE>
+* <P>
+* These properties allow a different vendor's <code>ORB</code>
+* 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:<P>
+*
+* <OL>
+*     <LI>check in Applet parameter or application string array, if any
+*
+*     <LI>check in properties parameter, if any
+*
+*     <LI>check in the System properties
+*
+*     <LI>check in the orb.properties file located in the user.home
+*         directory (if any)
+*
+*     <LI>check in the orb.properties file located in the java.home/lib
+*         directory (if any)
+*
+*     <LI>fall back on a hardcoded default behavior (use the Java&nbsp;IDL
+*         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
+* ORB is returned.  When the method <code>init</code> 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
+* 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
+* for an application.  The parameter <code>args</code>
+* represents the arguments supplied to the application's <code>main</code>
+* 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
+* initialized with the default Java&nbsp;IDL implementation.
+* <PRE>
+*    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
+* 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);
+* </PRE>
+* <P>
+* An application or applet can be initialized in one or more ORBs.
+* ORB initialization is a bootstrap call into the CORBA world.
+* @since   JDK1.2
+*/
+abstract public class ORB {
+//
+// This is the ORB implementation used when nothing else is specified.
+// Whoever provides this class customizes this string to
+// point at their ORB implementation.
+//
+private static final String ORBClassKey = "org.omg.CORBA.ORBClass";
+private static final String ORBSingletonClassKey = "org.omg.CORBA.ORBSingletonClass";
+//
+// The global instance of the singleton ORB implementation which
+// acts as a factory for typecodes for generated Helper classes.
+// TypeCodes should be immutable since they may be shared across
+// different security contexts (applets). There should be no way to
+// use a TypeCode as a storage depot for illicitly passing
+// information or Java objects between different security contexts.
+//
+static private ORB singleton;
+// Get System property
+private static String getSystemProperty(final String name) {
+// This will not throw a SecurityException because this
+// class was loaded from rt.jar using the bootstrap classloader.
+String propValue = (String) AccessController.doPrivileged(
+new PrivilegedAction() {
+public java.lang.Object run() {
+return System.getProperty(name);
+}
+}
+);
+return propValue;
+}
+// Get property from orb.properties in either <user.home> or <java-home>/lib
+// directories.
+private static String getPropertyFromFile(final String name) {
+// This will not throw a SecurityException because this
+// class was loaded from rt.jar using the bootstrap classloader.
+String propValue = (String) AccessController.doPrivileged(
+new PrivilegedAction() {
+private Properties getFileProperties( String fileName ) {
+try {
+File propFile = new File( fileName ) ;
+if (!propFile.exists())
+return null ;
+Properties props = new Properties() ;
+FileInputStream fis = new FileInputStream(propFile);
+try {
+props.load( fis );
+} finally {
+fis.close() ;
+}
+return props ;
+} catch (Exception exc) {
+return null ;
+}
+}
+public java.lang.Object run() {
+String userHome = System.getProperty("user.home");
+String fileName = userHome + File.separator +
+"orb.properties" ;
+Properties props = getFileProperties( fileName ) ;
+if (props != null) {
+String value = props.getProperty( name ) ;
+if (value != null)
+return value ;
+}
+String javaHome = System.getProperty("java.home");
+fileName = javaHome + File.separator
++ "lib" + File.separator + "orb.properties";
+props = getFileProperties( fileName ) ;
+if (props == null)
+return null ;
+else
+return props.getProperty( name ) ;
+}
+}
+);
+return propValue;
+}
+/**
+* Returns the <code>ORB</code> 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.
+* <P>
+* This no-argument version of the method <code>init</code> is used primarily
+* as a factory for <code>TypeCode</code> objects, which are used by
+* <code>Helper</code> classes to implement the method <code>type</code>.
+* It is also used to create <code>Any</code> objects that are used to
+* describe <code>union</code> labels (as part of creating a <code>
+* TypeCode</code> object for a <code>union</code>).
+* <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
+* 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.
+*
+* @return the singleton ORB
+*/
+public static synchronized ORB init() {
+if (singleton == null) {
+String className = getSystemProperty(ORBSingletonClassKey);
+if (className == null)
+className = getPropertyFromFile(ORBSingletonClassKey);
+if ((className == null) ||
+(className.equals("com.sun.corba.se.impl.orb.ORBSingleton"))) {
+singleton = new com.sun.corba.se.impl.orb.ORBSingleton();
+} else {
+singleton = create_impl(className);
+}
+}
+return singleton;
+}
+private static ORB create_impl(String className) {
+ClassLoader cl = Thread.currentThread().getContextClassLoader();
+if (cl == null)
+cl = ClassLoader.getSystemClassLoader();
+try {
+ReflectUtil.checkPackageAccess(className);
+Class<org.omg.CORBA.ORB> orbBaseClass = org.omg.CORBA.ORB.class;
+Class<?> orbClass = Class.forName(className, true, cl).asSubclass(orbBaseClass);
+return (ORB)orbClass.newInstance();
+} catch (Throwable ex) {
+SystemException systemException = new INITIALIZE(
+"can't instantiate default ORB implementation " + className);
+systemException.initCause(ex);
+throw systemException;
+}
+}
+/**
+* Creates a new <code>ORB</code> instance for a standalone
+* application.  This method may be called from applications
+* only and returns a new fully functional <code>ORB</code> object
+* each time it is called.
+* @param args command-line arguments for the application's <code>main</code>
+*             method; may be <code>null</code>
+* @param props application-specific properties; may be <code>null</code>
+* @return the newly-created ORB instance
+*/
+public static ORB init(String[] args, Properties props) {
+//
+// Note that there is no standard command-line argument for
+// specifying the default ORB implementation. For an
+// application you can choose an implementation either by
+// setting the CLASSPATH to pick a different org.omg.CORBA
+// and it's baked-in ORB implementation default or by
+// setting an entry in the properties object or in the
+// system properties.
+//
+String className = null;
+ORB orb;
+if (props != null)
+className = props.getProperty(ORBClassKey);
+if (className == null)
+className = getSystemProperty(ORBClassKey);
+if (className == null)
+className = getPropertyFromFile(ORBClassKey);
+if ((className == null) ||
+(className.equals("com.sun.corba.se.impl.orb.ORBImpl"))) {
+orb = new com.sun.corba.se.impl.orb.ORBImpl();
+} else {
+orb = create_impl(className);
+}
+orb.set_parameters(args, props);
+return orb;
+}
+/**
+* Creates a new <code>ORB</code> 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.
+* @param app the applet; may be <code>null</code>
+* @param props applet-specific properties; may be <code>null</code>
+* @return the newly-created ORB instance
+*/
+public static ORB init(Applet app, Properties props) {
+String className;
+ORB orb;
+className = app.getParameter(ORBClassKey);
+if (className == null && props != null)
+className = props.getProperty(ORBClassKey);
+if (className == null)
+className = getSystemProperty(ORBClassKey);
+if (className == null)
+className = getPropertyFromFile(ORBClassKey);
+if ((className == null) ||
+(className.equals("com.sun.corba.se.impl.orb.ORBImpl"))) {
+orb = new com.sun.corba.se.impl.orb.ORBImpl();
+} else {
+orb = create_impl(className);
+}
+orb.set_parameters(app, props);
+return orb;
+}
+/**
+* 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.
+*
+* @param args command-line arguments for the application's <code>main</code>
+*             method; may be <code>null</code>
+* @param props application-specific properties; may be <code>null</code>
+*/
+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.
+*
+* @param app the applet; may be <code>null</code>
+* @param props applet-specific properties; may be <code>null</code>
+*/
+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
+* supported by the server. The servant must thus be a CORBA object
+* reference, and inherit from <code>org.omg.CORBA.Object</code>.
+* Servants created by the user can start receiving remote invocations
+* after the method <code>connect</code> 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
+* 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
+*/
+public void connect(org.omg.CORBA.Object obj) {
+throw new NO_IMPLEMENT();
+}
+/**
+* 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.
+* Once an ORB has been destroyed, another call to <code>init</code>
+* 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,
+* 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
+* an invocation, the <code>BAD_INV_ORDER</code> 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>
+* on all ORB instances before exiting.
+*
+* @throws org.omg.CORBA.BAD_INV_ORDER if the current thread is servicing an invocation
+*/
+public void destroy( ) {
+throw new NO_IMPLEMENT();
+}
+/**
+* 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
+* 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
+* 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
+*/
+public void disconnect(org.omg.CORBA.Object obj) {
+throw new NO_IMPLEMENT();
+}
+//
+// ORB method implementations.
+//
+// We are trying to accomplish 2 things at once in this class.
+// It can act as a default ORB implementation front-end,
+// creating an actual ORB implementation object which is a
+// subclass of this ORB class and then delegating the method
+// implementations.
+//
+// To accomplish the delegation model, the 'delegate' private instance
+// variable is set if an instance of this class is created directly.
+//
+/**
+* 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
+*         the object references for CORBA services
+*         that are initially available with this ORB
+*/
+abstract public String[] list_initial_services();
+/**
+* Resolves a specific object reference from the set of available
+* initial service names.
+*
+* @param object_name the name of the initial service as a string
+* @return  the object reference associated with the given name
+* @exception InvalidName if the given name is not associated with a
+*                         known service
+*/
+abstract public org.omg.CORBA.Object resolve_initial_references(String object_name)
+throws InvalidName;
+/**
+* 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
+* in any way that a <code>String</code> 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>
+* 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>.
+* @return the object reference
+*/
+abstract public org.omg.CORBA.Object string_to_object(String str);
+/**
+* Allocates an <code>NVList</code> with (probably) enough
+* space for the specified number of <code>NamedValue</code> 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
+*               which to allocate space
+* @return the newly-created <code>NVList</code>
+*
+* @see NVList
+*/
+abstract public NVList create_list(int count);
+/**
+* Creates an <code>NVList</code> initialized with argument
+* descriptions for the operation described in the given
+* <code>OperationDef</code> object.  This <code>OperationDef</code> object
+* is obtained from an Interface Repository. The arguments in the
+* returned <code>NVList</code> 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
+* @return          a newly-created <code>NVList</code> object containing
+* descriptions of the arguments to the method described in the given
+* <code>OperationDef</code> object
+*
+* @see NVList
+*/
+public NVList create_operation_list(org.omg.CORBA.Object oper)
+{
+// If we came here, it means that the actual ORB implementation
+// did not have a create_operation_list(...CORBA.Object oper) method,
+// so lets check if it has a create_operation_list(OperationDef oper)
+// method.
+try {
+// First try to load the OperationDef class
+String opDefClassName = "org.omg.CORBA.OperationDef";
+Class<?> opDefClass = null;
+ClassLoader cl = Thread.currentThread().getContextClassLoader();
+if ( cl == null )
+cl = ClassLoader.getSystemClassLoader();
+// if this throws a ClassNotFoundException, it will be caught below.
+opDefClass = Class.forName(opDefClassName, true, cl);
+// OK, we loaded OperationDef. Now try to get the
+// create_operation_list(OperationDef oper) method.
+Class<?>[] argc = { opDefClass };
+java.lang.reflect.Method meth =
+this.getClass().getMethod("create_operation_list", argc);
+// OK, the method exists, so invoke it and be happy.
+java.lang.Object[] argx = { oper };
+return (org.omg.CORBA.NVList)meth.invoke(this, argx);
+}
+catch( java.lang.reflect.InvocationTargetException exs ) {
+Throwable t = exs.getTargetException();
+if (t instanceof Error) {
+throw (Error) t;
+}
+else if (t instanceof RuntimeException) {
+throw (RuntimeException) t;
+}
+else {
+throw new org.omg.CORBA.NO_IMPLEMENT();
+}
+}
+catch( RuntimeException ex ) {
+throw ex;
+}
+catch( Exception exr ) {
+throw new org.omg.CORBA.NO_IMPLEMENT();
+}
+}
+/**
+* Creates a <code>NamedValue</code> object
+* using the given name, value, and argument mode flags.
+* <P>
+* A <code>NamedValue</code> 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.
+*
+* @param s  the name of the <code>NamedValue</code> object
+* @param any  the <code>Any</code> value to be inserted into the
+*             <code>NamedValue</code> object
+* @param flags  the argument mode flags for the <code>NamedValue</code>: one of
+* <code>ARG_IN.value</code>, <code>ARG_OUT.value</code>,
+* or <code>ARG_INOUT.value</code>.
+*
+* @return  the newly-created <code>NamedValue</code> object
+* @see NamedValue
+*/
+abstract public NamedValue create_named_value(String s, Any any, int flags);
+/**
+* Creates an empty <code>ExceptionList</code> object.
+*
+* @return  the newly-created <code>ExceptionList</code> object
+*/
+abstract public ExceptionList create_exception_list();
+/**
+* Creates an empty <code>ContextList</code> object.
+*
+* @return  the newly-created <code>ContextList</code> object
+* @see ContextList
+* @see Context
+*/
+abstract public ContextList create_context_list();
+/**
+* Gets the default <code>Context</code> object.
+*
+* @return the default <code>Context</code> object
+* @see Context
+*/
+abstract public Context get_default_context();
+/**
+* Creates an <code>Environment</code> object.
+*
+* @return  the newly-created <code>Environment</code> object
+* @see Environment
+*/
+abstract public Environment create_environment();
+/**
+* Creates a new <code>org.omg.CORBA.portable.OutputStream</code> into which
+* IDL method parameters can be marshalled during method invocation.
+* @return          the newly-created
+*              <code>org.omg.CORBA.portable.OutputStream</code> 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
+*/
+abstract public void send_multiple_requests_oneway(Request[] req);
+/**
+* Sends multiple dynamic (DII) requests asynchronously.
+*
+* @param req               an array of <code>Request</code> 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;
+*         <code> false</code> otherwise
+*/
+abstract public boolean poll_next_response();
+/**
+* Gets the next <code>Request</code> instance for which a response
+* has been received.
+*
+* @return          the next <code>Request</code> object ready with a response
+* @exception WrongTransaction if the method <code>get_next_response</code>
+* 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
+* the given primitive IDL type.
+*
+* @param tcKind    the <code>TCKind</code> instance corresponding to the
+*                  desired primitive type
+* @return          the requested <code>TypeCode</code> object
+*/
+abstract public TypeCode get_primitive_tc(TCKind tcKind);
+/**
+* Creates a <code>TypeCode</code> object representing an IDL <code>struct</code>.
+* The <code>TypeCode</code> object is initialized with the given id,
+* name, and members.
+*
+* @param id        the repository id for the <code>struct</code>
+* @param name      the name of the <code>struct</code>
+* @param members   an array describing the members of the <code>struct</code>
+* @return          a newly-created <code>TypeCode</code> object describing
+*              an IDL <code>struct</code>
+*/
+abstract public TypeCode create_struct_tc(String id, String name,
+StructMember[] members);
+/**
+* Creates a <code>TypeCode</code> object representing an IDL <code>union</code>.
+* The <code>TypeCode</code> object is initialized with the given id,
+* name, discriminator type, and members.
+*
+* @param id        the repository id of the <code>union</code>
+* @param name      the name of the <code>union</code>
+* @param discriminator_type        the type of the <code>union</code> discriminator
+* @param members   an array describing the members of the <code>union</code>
+* @return          a newly-created <code>TypeCode</code> object describing
+*              an IDL <code>union</code>
+*/
+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>.
+* The <code>TypeCode</code> object is initialized with the given id,
+* name, and members.
+*
+* @param id        the repository id for the <code>enum</code>
+* @param name      the name for the <code>enum</code>
+* @param members   an array describing the members of the <code>enum</code>
+* @return          a newly-created <code>TypeCode</code> object describing
+*              an IDL <code>enum</code>
+*/
+abstract public TypeCode create_enum_tc(String id, String name, String[] members);
+/**
+* Creates a <code>TypeCode</code> object representing an IDL <code>alias</code>
+* (<code>typedef</code>).
+* The <code>TypeCode</code> 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
+*          for which this is an alias
+* @return          a newly-created <code>TypeCode</code> object describing
+*              an IDL <code>alias</code>
+*/
+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>.
+* The <code>TypeCode</code> object is initialized with the given id,
+* name, and members.
+*
+* @param id        the repository id for the <code>exception</code>
+* @param name      the name for the <code>exception</code>
+* @param members   an array describing the members of the <code>exception</code>
+* @return          a newly-created <code>TypeCode</code> object describing
+*              an IDL <code>exception</code>
+*/
+abstract public TypeCode create_exception_tc(String id, String name,
+StructMember[] members);
+/**
+* Creates a <code>TypeCode</code> object representing an IDL <code>interface</code>.
+* The <code>TypeCode</code> object is initialized with the given id
+* and name.
+*
+* @param id        the repository id for the interface
+* @param name      the name for the interface
+* @return          a newly-created <code>TypeCode</code> object describing
+*              an IDL <code>interface</code>
+*/
+abstract public TypeCode create_interface_tc(String id, String name);
+/**
+* Creates a <code>TypeCode</code> object representing a bounded IDL
+* <code>string</code>.
+* The <code>TypeCode</code> 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
+* @return          a newly-created <code>TypeCode</code> object describing
+*              a bounded IDL <code>string</code>
+* @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
+* <code>wstring</code> (wide string).
+* The <code>TypeCode</code> 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
+* @return          a newly-created <code>TypeCode</code> object describing
+*              a bounded IDL <code>wstring</code>
+* @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>.
+* The <code>TypeCode</code> object is initialized with the given bound and
+* element type.
+*
+* @param bound     the bound for the <code>sequence</code>, 0 if unbounded
+* @param element_type
+*                  the <code>TypeCode</code> object describing the elements
+*          contained in the <code>sequence</code>
+* @return          a newly-created <code>TypeCode</code> object describing
+*              an IDL <code>sequence</code>
+*/
+abstract public TypeCode create_sequence_tc(int bound, TypeCode element_type);
+/**
+* Creates a <code>TypeCode</code> object representing a
+* a recursive IDL <code>sequence</code>.
+* <P>
+* For the IDL <code>struct</code> 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
+*                  that describes the elements of this sequence
+* @return          a newly-created <code>TypeCode</code> object describing
+*                   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>.
+* The <code>TypeCode</code> object is initialized with the given length and
+* element type.
+*
+* @param length    the length of the <code>array</code>
+* @param element_type  a <code>TypeCode</code> object describing the type
+*                      of element contained in the <code>array</code>
+* @return          a newly-created <code>TypeCode</code> object describing
+*              an IDL <code>array</code>
+*/
+abstract public TypeCode create_array_tc(int length, TypeCode element_type);
+/**
+* Create a <code>TypeCode</code> 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.
+*/
+public org.omg.CORBA.TypeCode create_native_tc(String id,
+String name)
+{
+throw new org.omg.CORBA.NO_IMPLEMENT();
+}
+/**
+* Create a <code>TypeCode</code> 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.
+*/
+public org.omg.CORBA.TypeCode create_abstract_interface_tc(
+String id,
+String name)
+{
+throw new org.omg.CORBA.NO_IMPLEMENT();
+}
+/**
+* Create a <code>TypeCode</code> 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.
+*/
+public org.omg.CORBA.TypeCode create_fixed_tc(short digits, short scale)
+{
+throw new org.omg.CORBA.NO_IMPLEMENT();
+}
+// orbos 98-01-18: Objects By Value -- begin
+/**
+* Create a <code>TypeCode</code> 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
+*                           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,
+String name,
+short type_modifier,
+TypeCode concrete_base,
+ValueMember[] members)
+{
+throw new org.omg.CORBA.NO_IMPLEMENT();
+}
+/**
+* Create a recursive <code>TypeCode</code> 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.
+* <P>
+* For example, the following IDL type declaration contains recursion:
+* <PRE>
+*    Struct Node {
+*        Sequence&lt;Node&gt; subnodes;
+*    };
+* </PRE>
+* <P>
+* To create a TypeCode for struct Node, you would invoke the TypeCode creation
+* operations as shown below:
+* <PRE>
+* String nodeID = "IDL:Node:1.0";
+* TypeCode recursiveSeqTC = orb.create_sequence_tc(0, orb.create_recursive_tc(nodeID));
+* StructMember[] members = { new StructMember("subnodes", recursiveSeqTC, null) };
+* TypeCode structNodeTC = orb.create_struct_tc(nodeID, "Node", members);
+* </PRE>
+* <P>
+* Also note that the following is an illegal IDL type declaration:
+* <PRE>
+*    Struct Node {
+*        Node next;
+*    };
+* </PRE>
+* <P>
+* Recursive types can only appear within sequences which can be empty.
+* That way marshaling problems, when transmitting the struct in an Any, are avoided.
+* <P>
+* @param id                 the logical id of the referenced type
+* @return                   the requested TypeCode
+*/
+public org.omg.CORBA.TypeCode create_recursive_tc(String id) {
+// implemented in subclass
+throw new org.omg.CORBA.NO_IMPLEMENT();
+}
+/**
+* Creates a <code>TypeCode</code> 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
+*/
+public org.omg.CORBA.TypeCode create_value_box_tc(String id,
+String name,
+TypeCode boxed_type)
+{
+// implemented in subclass
+throw new org.omg.CORBA.NO_IMPLEMENT();
+}
+// orbos 98-01-18: Objects By Value -- end
+/**
+* Creates an IDL <code>Any</code> object initialized to
+* contain a <code>Typecode</code> object whose <code>kind</code> field
+* is set to <code>TCKind.tc_null</code>.
+*
+* @return          a newly-created <code>Any</code> object
+*/
+abstract public Any create_any();
+/**
+* Retrieves a <code>Current</code> object.
+* The <code>Current</code> 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
+* @deprecated      use <code>resolve_initial_references</code>.
+*/
+@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
+* get all notified when the ORB shuts down.
+*
+*/
+public void run()
+{
+throw new org.omg.CORBA.NO_IMPLEMENT();
+}
+/**
+* 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
+* 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
+* 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>,
+* 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.
+* Invoking any other operation will throw the <code>BAD_INV_ORDER</code>
+* system exception with the OMG minor code 4.<p>
+* The <code>ORB.run</code> method will return after
+* <code>shutdown</code> has been called.
+*
+* @param wait_for_completion <code>true</code> if the call
+*        should block until the shutdown is complete;
+*        <code>false</code> 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
+* perform some work, and <code>false</code> if the ORB does not
+* need the main thread.
+*
+* @return <code>true</code> if there is work pending, meaning that the ORB
+*         needs the main thread to perform some work; <code>false</code>
+*         if there is no work pending and thus the ORB does not need the
+*         main thread
+*
+*/
+public boolean work_pending()
+{
+throw new org.omg.CORBA.NO_IMPLEMENT();
+}
+/**
+* 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>
+* can be used in
+* conjunction to implement a simple polling loop that multiplexes
+* the main thread among the ORB and other activities.
+*
+*/
+public void perform_work()
+{
+throw new org.omg.CORBA.NO_IMPLEMENT();
+}
+/**
+* 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
+* 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
+* value <tt>true</tt>. If no information for the requested
+* services type is available, the operation returns <tt>false</tt>
+*  (i.e., the service is not supported by this ORB).
+* <P>
+* @param service_type a <code>short</code> indicating the
+*        service type for which information is being requested
+* @param service_info a <code>ServiceInformationHolder</code> object
+*        that will hold the <code>ServiceInformation</code> object
+*        produced by this method
+* @return <code>true</code> if service information is available
+*        for the <tt>service_type</tt>;
+*         <tt>false</tt> if no information for the
+*         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)
+{
+throw new org.omg.CORBA.NO_IMPLEMENT();
+}
+// orbos 98-01-18: Objects By Value -- begin
+/**
+* Creates a new <code>DynAny</code> object from the given
+* <code>Any</code> object.
+* <P>
+* @param value the <code>Any</code> object from which to create a new
+*        <code>DynAny</code> object
+* @return the new <code>DynAny</code> object created from the given
+*         <code>Any</code> 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
+public org.omg.CORBA.DynAny create_dyn_any(org.omg.CORBA.Any value)
+{
+throw new org.omg.CORBA.NO_IMPLEMENT();
+}
+/**
+* Creates a basic <code>DynAny</code> object from the given
+* <code>TypeCode</code> object.
+* <P>
+* @param type the <code>TypeCode</code> object from which to create a new
+*        <code>DynAny</code> object
+* @return the new <code>DynAny</code> object created from the given
+*         <code>TypeCode</code> object
+* @throws org.omg.CORBA.ORBPackage.InconsistentTypeCode if the given
+*         <code>TypeCode</code> 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
+public org.omg.CORBA.DynAny create_basic_dyn_any(org.omg.CORBA.TypeCode type) throws org.omg.CORBA.ORBPackage.InconsistentTypeCode
+{
+throw new org.omg.CORBA.NO_IMPLEMENT();
+}
+/**
+* Creates a new <code>DynStruct</code> object from the given
+* <code>TypeCode</code> object.
+* <P>
+* @param type the <code>TypeCode</code> object from which to create a new
+*        <code>DynStruct</code> object
+* @return the new <code>DynStruct</code> object created from the given
+*         <code>TypeCode</code> object
+* @throws org.omg.CORBA.ORBPackage.InconsistentTypeCode if the given
+*         <code>TypeCode</code> 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
+public org.omg.CORBA.DynStruct create_dyn_struct(org.omg.CORBA.TypeCode type) throws org.omg.CORBA.ORBPackage.InconsistentTypeCode
+{
+throw new org.omg.CORBA.NO_IMPLEMENT();
+}
+/**
+* Creates a new <code>DynSequence</code> object from the given
+* <code>TypeCode</code> object.
+* <P>
+* @param type the <code>TypeCode</code> object from which to create a new
+*        <code>DynSequence</code> object
+* @return the new <code>DynSequence</code> object created from the given
+*         <code>TypeCode</code> object
+* @throws org.omg.CORBA.ORBPackage.InconsistentTypeCode if the given
+*         <code>TypeCode</code> 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
+public org.omg.CORBA.DynSequence create_dyn_sequence(org.omg.CORBA.TypeCode type) throws org.omg.CORBA.ORBPackage.InconsistentTypeCode
+{
+throw new org.omg.CORBA.NO_IMPLEMENT();
+}
+/**
+* Creates a new <code>DynArray</code> object from the given
+* <code>TypeCode</code> object.
+* <P>
+* @param type the <code>TypeCode</code> object from which to create a new
+*        <code>DynArray</code> object
+* @return the new <code>DynArray</code> object created from the given
+*         <code>TypeCode</code> object
+* @throws org.omg.CORBA.ORBPackage.InconsistentTypeCode if the given
+*         <code>TypeCode</code> 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
+public org.omg.CORBA.DynArray create_dyn_array(org.omg.CORBA.TypeCode type) throws org.omg.CORBA.ORBPackage.InconsistentTypeCode
+{
+throw new org.omg.CORBA.NO_IMPLEMENT();
+}
+/**
+* Creates a new <code>DynUnion</code> object from the given
+* <code>TypeCode</code> object.
+* <P>
+* @param type the <code>TypeCode</code> object from which to create a new
+*        <code>DynUnion</code> object
+* @return the new <code>DynUnion</code> object created from the given
+*         <code>TypeCode</code> object
+* @throws org.omg.CORBA.ORBPackage.InconsistentTypeCode if the given
+*         <code>TypeCode</code> 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
+public org.omg.CORBA.DynUnion create_dyn_union(org.omg.CORBA.TypeCode type) throws org.omg.CORBA.ORBPackage.InconsistentTypeCode
+{
+throw new org.omg.CORBA.NO_IMPLEMENT();
+}
+/**
+* Creates a new <code>DynEnum</code> object from the given
+* <code>TypeCode</code> object.
+* <P>
+* @param type the <code>TypeCode</code> object from which to create a new
+*        <code>DynEnum</code> object
+* @return the new <code>DynEnum</code> object created from the given
+*         <code>TypeCode</code> object
+* @throws org.omg.CORBA.ORBPackage.InconsistentTypeCode if the given
+*         <code>TypeCode</code> 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
+public org.omg.CORBA.DynEnum create_dyn_enum(org.omg.CORBA.TypeCode type) throws org.omg.CORBA.ORBPackage.InconsistentTypeCode
+{
+throw new org.omg.CORBA.NO_IMPLEMENT();
+}
+/**
+* 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
+* object due to its inability to interpret the requested type
+* and content of the policy, it raises the <tt>PolicyError</tt>
+* exception with the appropriate reason.
+* @param type the <tt>PolicyType</tt> 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
+* @return Reference to a newly created <tt>Policy</tt> object
+*        of type specified by the <tt>type</tt> parameter and
+*        initialized to a state specified by the <tt>val</tt>
+*        parameter
+* @throws <tt>org.omg.CORBA.PolicyError</tt> 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
+{
+// Currently not implemented until PIORB.
+throw new org.omg.CORBA.NO_IMPLEMENT();
+}
+}

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

comparison: src/share/classes/org/omg/CORBA/ORB.java

src/share/classes/org/omg/CORBA/ORB.java