1 /*

     2  * Copyright (c) 1995, 2014, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Oracle designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Oracle in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    22  * or visit www.oracle.com if you need additional information or have any

    23  * questions.

    24  */

    25 

    26 package org.omg.CORBA;

    27 

    28 import org.omg.CORBA.portable.*;

    29 import org.omg.CORBA.ORBPackage.InvalidName;

    30 

    31 import java.util.Properties;

    32 import java.applet.Applet;

    33 import java.io.File;

    34 import java.io.FileInputStream;

    35 

    36 import java.security.AccessController;

    37 import java.security.PrivilegedAction;

    38 

    39 import sun.reflect.misc.ReflectUtil;

    40 

    41 /**

    42  * A class providing APIs for the CORBA Object Request Broker

    43  * features.  The <code>ORB</code> class also provides

    44  * "pluggable ORB implementation" APIs that allow another vendor's ORB

    45  * implementation to be used.

    46  * <P>

    47  * An ORB makes it possible for CORBA objects to communicate

    48  * with each other by connecting objects making requests (clients) with

    49  * objects servicing requests (servers).

    50  * <P>

    51  *

    52  * The <code>ORB</code> class, which

    53  * encapsulates generic CORBA functionality, does the following:

    54  * (Note that items 5 and 6, which include most of the methods in

    55  * the class <code>ORB</code>, are typically used with the <code>Dynamic Invocation

    56  * Interface</code> (DII) and the <code>Dynamic Skeleton Interface</code>

    57  * (DSI).

    58  * These interfaces may be used by a developer directly, but

    59  * most commonly they are used by the ORB internally and are

    60  * not seen by the general programmer.)

    61  * <OL>

    62  * <li> initializes the ORB implementation by supplying values for

    63  *      predefined properties and environmental parameters

    64  * <li> obtains initial object references to services such as

    65  * the NameService using the method <code>resolve_initial_references</code>

    66  * <li> converts object references to strings and back

    67  * <li> connects the ORB to a servant (an instance of a CORBA object

    68  * implementation) and disconnects the ORB from a servant

    69  * <li> creates objects such as

    70  *   <ul>

    71  *   <li><code>TypeCode</code>

    72  *   <li><code>Any</code>

    73  *   <li><code>NamedValue</code>

    74  *   <li><code>Context</code>

    75  *   <li><code>Environment</code>

    76  *   <li>lists (such as <code>NVList</code>) containing these objects

    77  *   </ul>

    78  * <li> sends multiple messages in the DII

    79  * </OL>

    80  *

    81  * <P>

    82  * The <code>ORB</code> class can be used to obtain references to objects

    83  * implemented anywhere on the network.

    84  * <P>

    85  * An application or applet gains access to the CORBA environment

    86  * by initializing itself into an <code>ORB</code> using one of

    87  * three <code>init</code> methods.  Two of the three methods use the properties

    88  * (associations of a name with a value) shown in the

    89  * table below.<BR>

    90  * <TABLE BORDER=1 SUMMARY="Standard Java CORBA Properties">

    91  * <TR><TH>Property Name</TH>   <TH>Property Value</TH></TR>

    92  * <CAPTION>Standard Java CORBA Properties:</CAPTION>

    93  *     <TR><TD>org.omg.CORBA.ORBClass</TD>

    94  *     <TD>class name of an ORB implementation</TD></TR>

    95  *     <TR><TD>org.omg.CORBA.ORBSingletonClass</TD>

    96  *     <TD>class name of the ORB returned by <code>init()</code></TD></TR>

    97  * </TABLE>

    98  * <P>

    99  * These properties allow a different vendor's <code>ORB</code>

   100  * implementation to be "plugged in."

   101  * <P>

   102  * When an ORB instance is being created, the class name of the ORB

   103  * implementation is located using

   104  * the following standard search order:<P>

   105  *

   106  * <OL>

   107  *     <LI>check in Applet parameter or application string array, if any

   108  *

   109  *     <LI>check in properties parameter, if any

   110  *

   111  *     <LI>check in the System properties

   112  *

   113  *     <LI>check in the orb.properties file located in the user.home

   114  *         directory (if any)

   115  *

   116  *     <LI>check in the orb.properties file located in the java.home/lib

   117  *         directory (if any)

   118  *

   119  *     <LI>fall back on a hardcoded default behavior (use the Java&nbsp;IDL

   120  *         implementation)

   121  * </OL>

   122  * <P>

   123  * Note that Java IDL provides a default implementation for the

   124  * fully-functional ORB and for the Singleton ORB.  When the method

   125  * <code>init</code> is given no parameters, the default Singleton

   126  * ORB is returned.  When the method <code>init</code> is given parameters

   127  * but no ORB class is specified, the Java IDL ORB implementation

   128  * is returned.

   129  * <P>

   130  * The following code fragment creates an <code>ORB</code> object

   131  * initialized with the default ORB Singleton.

   132  * This ORB has a

   133  * restricted implementation to prevent malicious applets from doing

   134  * anything beyond creating typecodes.

   135  * It is called a singleton

   136  * because there is only one instance for an entire virtual machine.

   137  * <PRE>

   138  *    ORB orb = ORB.init();

   139  * </PRE>

   140  * <P>

   141  * The following code fragment creates an <code>ORB</code> object

   142  * for an application.  The parameter <code>args</code>

   143  * represents the arguments supplied to the application's <code>main</code>

   144  * method.  Since the property specifies the ORB class to be

   145  * "SomeORBImplementation", the new ORB will be initialized with

   146  * that ORB implementation.  If p had been null,

   147  * and the arguments had not specified an ORB class,

   148  * the new ORB would have been

   149  * initialized with the default Java IDL implementation.

   150  * <PRE>

   151  *    Properties p = new Properties();

   152  *    p.put("org.omg.CORBA.ORBClass", "SomeORBImplementation");

   153  *    ORB orb = ORB.init(args, p);

   154  * </PRE>

   155  * <P>

   156  * The following code fragment creates an <code>ORB</code> object

   157  * for the applet supplied as the first parameter.  If the given

   158  * applet does not specify an ORB class, the new ORB will be

   159  * initialized with the default Java IDL implementation.

   160  * <PRE>

   161  *    ORB orb = ORB.init(myApplet, null);

   162  * </PRE>

   163  * <P>

   164  * An application or applet can be initialized in one or more ORBs.

   165  * ORB initialization is a bootstrap call into the CORBA world.

   166  *

   167  *

   168  * @implNote

   169  * As described above it is possible to specify, at runtime, an alternative ORBSingleton class and

   170  * an alternative ORB implementation class, via the system properties {@code org.omg.CORBA.ORBSingletonClass}

   171  * and {@code org.omg.CORBA.ORBClass} respectively.

   172  * The class loading strategy is organized, such that, in the case of the ORBSingleton

   173  * the system class loader is used to load the alternative singleton ORB.

   174  * Thus, it is necessary that an application's CLASSPATH

   175  * includes the classes for this alternative ORBSingleton, when specified.

   176  *

   177  * In the case of specifying an alternative ORB implementation class, the loading

   178  * strategy will use the thread context class loader, as appropriate.

   179  *

   180  * @since   JDK1.2

   181  */

   182 abstract public class ORB {

   183 

   184     //

   185     // This is the ORB implementation used when nothing else is specified.

   186     // Whoever provides this class customizes this string to

   187     // point at their ORB implementation.

   188     //

   189     private static final String ORBClassKey = "org.omg.CORBA.ORBClass";

   190     private static final String ORBSingletonClassKey = "org.omg.CORBA.ORBSingletonClass";

   191 

   192     //

   193     // The global instance of the singleton ORB implementation which

   194     // acts as a factory for typecodes for generated Helper classes.

   195     // TypeCodes should be immutable since they may be shared across

   196     // different security contexts (applets). There should be no way to

   197     // use a TypeCode as a storage depot for illicitly passing

   198     // information or Java objects between different security contexts.

   199     //

   200     static private ORB singleton;

   201 

   202     // Get System property

   203     private static String getSystemProperty(final String name) {

   204 

   205         // This will not throw a SecurityException because this

   206         // class was loaded from rt.jar using the bootstrap classloader.

   207         String propValue = (String) AccessController.doPrivileged(

   208             new PrivilegedAction() {

   209                 public java.lang.Object run() {

   210                     return System.getProperty(name);

   211                 }

   212             }

   213         );

   214 

   215         return propValue;

   216     }

   217 

   218     // Get property from orb.properties in either <user.home> or <java-home>/lib

   219     // directories.

   220     private static String getPropertyFromFile(final String name) {

   221         // This will not throw a SecurityException because this

   222         // class was loaded from rt.jar using the bootstrap classloader.

   223 

   224         String propValue = (String) AccessController.doPrivileged(

   225             new PrivilegedAction() {

   226                 private Properties getFileProperties( String fileName ) {

   227                     try {

   228                         File propFile = new File( fileName ) ;

   229                         if (!propFile.exists())

   230                             return null ;

   231 

   232                         Properties props = new Properties() ;

   233                         FileInputStream fis = new FileInputStream(propFile);

   234                         try {

   235                             props.load( fis );

   236                         } finally {

   237                             fis.close() ;

   238                         }

   239 

   240                         return props ;

   241                     } catch (Exception exc) {

   242                         return null ;

   243                     }

   244                 }

   245 

   246                 public java.lang.Object run() {

   247                     String userHome = System.getProperty("user.home");

   248                     String fileName = userHome + File.separator +

   249                         "orb.properties" ;

   250                     Properties props = getFileProperties( fileName ) ;

   251 

   252                     if (props != null) {

   253                         String value = props.getProperty( name ) ;

   254                         if (value != null)

   255                             return value ;

   256                     }

   257 

   258                     String javaHome = System.getProperty("java.home");

   259                     fileName = javaHome + File.separator

   260                         + "lib" + File.separator + "orb.properties";

   261                     props = getFileProperties( fileName ) ;

   262 

   263                     if (props == null)

   264                         return null ;

   265                     else

   266                         return props.getProperty( name ) ;

   267                 }

   268             }

   269         );

   270 

   271         return propValue;

   272     }

   273 

   274     /**

   275      * Returns the <code>ORB</code> singleton object. This method always returns the

   276      * same ORB instance, which is an instance of the class described by the

   277      * <code>org.omg.CORBA.ORBSingletonClass</code> system property.

   278      * <P>

   279      * This no-argument version of the method <code>init</code> is used primarily

   280      * as a factory for <code>TypeCode</code> objects, which are used by

   281      * <code>Helper</code> classes to implement the method <code>type</code>.

   282      * It is also used to create <code>Any</code> objects that are used to

   283      * describe <code>union</code> labels (as part of creating a <code>

   284      * TypeCode</code> object for a <code>union</code>).

   285      * <P>

   286      * This method is not intended to be used by applets, and in the event

   287      * that it is called in an applet environment, the ORB it returns

   288      * is restricted so that it can be used only as a factory for

   289      * <code>TypeCode</code> objects.  Any <code>TypeCode</code> objects

   290      * it produces can be safely shared among untrusted applets.

   291      * <P>

   292      * If an ORB is created using this method from an applet,

   293      * a system exception will be thrown if

   294      * methods other than those for

   295      * creating <code>TypeCode</code> objects are invoked.

   296      *

   297      * @return the singleton ORB

   298      */

   299     public static synchronized ORB init() {

   300         if (singleton == null) {

   301             String className = getSystemProperty(ORBSingletonClassKey);

   302             if (className == null)

   303                 className = getPropertyFromFile(ORBSingletonClassKey);

   304             if ((className == null) ||

   305                     (className.equals("com.sun.corba.se.impl.orb.ORBSingleton"))) {

   306                 singleton = new com.sun.corba.se.impl.orb.ORBSingleton();

   307             } else {

   308                 singleton = create_impl_with_systemclassloader(className);

   309             }

   310         }

   311         return singleton;

   312     }

   313 

   314    private static ORB create_impl_with_systemclassloader(String className) {

   315 

   316         try {

   317             ReflectUtil.checkPackageAccess(className);

   318             ClassLoader cl = ClassLoader.getSystemClassLoader();

   319             Class<org.omg.CORBA.ORB> orbBaseClass = org.omg.CORBA.ORB.class;

   320             Class<?> singletonOrbClass = Class.forName(className, true, cl).asSubclass(orbBaseClass);

   321             return (ORB)singletonOrbClass.newInstance();

   322         } catch (Throwable ex) {

   323             SystemException systemException = new INITIALIZE(

   324                 "can't instantiate default ORB implementation " + className);

   325             systemException.initCause(ex);

   326             throw systemException;

   327         }

   328     }

   329 

   330     private static ORB create_impl(String className) {

   331         ClassLoader cl = Thread.currentThread().getContextClassLoader();

   332         if (cl == null)

   333             cl = ClassLoader.getSystemClassLoader();

   334 

   335         try {

   336             ReflectUtil.checkPackageAccess(className);

   337             Class<org.omg.CORBA.ORB> orbBaseClass = org.omg.CORBA.ORB.class;

   338             Class<?> orbClass = Class.forName(className, true, cl).asSubclass(orbBaseClass);

   339             return (ORB)orbClass.newInstance();

   340         } catch (Throwable ex) {

   341             SystemException systemException = new INITIALIZE(

   342                "can't instantiate default ORB implementation " + className);

   343             systemException.initCause(ex);

   344             throw systemException;

   345         }

   346     }

   347 

   348     /**

   349      * Creates a new <code>ORB</code> instance for a standalone

   350      * application.  This method may be called from applications

   351      * only and returns a new fully functional <code>ORB</code> object

   352      * each time it is called.

   353      * @param args command-line arguments for the application's <code>main</code>

   354      *             method; may be <code>null</code>

   355      * @param props application-specific properties; may be <code>null</code>

   356      * @return the newly-created ORB instance

   357      */

   358     public static ORB init(String[] args, Properties props) {

   359         //

   360         // Note that there is no standard command-line argument for

   361         // specifying the default ORB implementation. For an

   362         // application you can choose an implementation either by

   363         // setting the CLASSPATH to pick a different org.omg.CORBA

   364         // and it's baked-in ORB implementation default or by

   365         // setting an entry in the properties object or in the

   366         // system properties.

   367         //

   368         String className = null;

   369         ORB orb;

   370 

   371         if (props != null)

   372             className = props.getProperty(ORBClassKey);

   373         if (className == null)

   374             className = getSystemProperty(ORBClassKey);

   375         if (className == null)

   376             className = getPropertyFromFile(ORBClassKey);

   377         if ((className == null) ||

   378                     (className.equals("com.sun.corba.se.impl.orb.ORBImpl"))) {

   379             orb = new com.sun.corba.se.impl.orb.ORBImpl();

   380         } else {

   381             orb = create_impl(className);

   382         }

   383         orb.set_parameters(args, props);

   384         return orb;

   385     }

   386 

   387 

   388     /**

   389      * Creates a new <code>ORB</code> instance for an applet.  This

   390      * method may be called from applets only and returns a new

   391      * fully-functional <code>ORB</code> object each time it is called.

   392      * @param app the applet; may be <code>null</code>

   393      * @param props applet-specific properties; may be <code>null</code>

   394      * @return the newly-created ORB instance

   395      */

   396     public static ORB init(Applet app, Properties props) {

   397         String className;

   398         ORB orb;

   399 

   400         className = app.getParameter(ORBClassKey);

   401         if (className == null && props != null)

   402             className = props.getProperty(ORBClassKey);

   403         if (className == null)

   404             className = getSystemProperty(ORBClassKey);

   405         if (className == null)

   406             className = getPropertyFromFile(ORBClassKey);

   407         if ((className == null) ||

   408                     (className.equals("com.sun.corba.se.impl.orb.ORBImpl"))) {

   409             orb = new com.sun.corba.se.impl.orb.ORBImpl();

   410         } else {

   411             orb = create_impl(className);

   412         }

   413         orb.set_parameters(app, props);

   414         return orb;

   415     }

   416 

   417     /**

   418      * Allows the ORB implementation to be initialized with the given

   419      * parameters and properties. This method, used in applications only,

   420      * is implemented by subclass ORB implementations and called

   421      * by the appropriate <code>init</code> method to pass in its parameters.

   422      *

   423      * @param args command-line arguments for the application's <code>main</code>

   424      *             method; may be <code>null</code>

   425      * @param props application-specific properties; may be <code>null</code>

   426      */

   427     abstract protected void set_parameters(String[] args, Properties props);

   428 

   429     /**

   430      * Allows the ORB implementation to be initialized with the given

   431      * applet and parameters. This method, used in applets only,

   432      * is implemented by subclass ORB implementations and called

   433      * by the appropriate <code>init</code> method to pass in its parameters.

   434      *

   435      * @param app the applet; may be <code>null</code>

   436      * @param props applet-specific properties; may be <code>null</code>

   437      */

   438     abstract protected void set_parameters(Applet app, Properties props);

   439 

   440     /**

   441      * Connects the given servant object (a Java object that is

   442      * an instance of the server implementation class)

   443      * to the ORB. The servant class must

   444      * extend the <code>ImplBase</code> class corresponding to the interface that is

   445      * supported by the server. The servant must thus be a CORBA object

   446      * reference, and inherit from <code>org.omg.CORBA.Object</code>.

   447      * Servants created by the user can start receiving remote invocations

   448      * after the method <code>connect</code> has been called. A servant may also be

   449      * automatically and implicitly connected to the ORB if it is passed as

   450      * an IDL parameter in an IDL method invocation on a non-local object,

   451      * that is, if the servant object has to be marshalled and sent outside of the

   452      * process address space.

   453      * <P>

   454      * Calling the method <code>connect</code> has no effect

   455      * when the servant object is already connected to the ORB.

   456      * <P>

   457      * Deprecated by the OMG in favor of the Portable Object Adapter APIs.

   458      *

   459      * @param obj The servant object reference

   460      */

   461     public void connect(org.omg.CORBA.Object obj) {

   462         throw new NO_IMPLEMENT();

   463     }

   464 

   465     /**

   466      * Destroys the ORB so that its resources can be reclaimed.

   467      * Any operation invoked on a destroyed ORB reference will throw the

   468      * <code>OBJECT_NOT_EXIST</code> exception.

   469      * Once an ORB has been destroyed, another call to <code>init</code>

   470      * with the same ORBid will return a reference to a newly constructed ORB.<p>

   471      * If <code>destroy</code> is called on an ORB that has not been shut down,

   472      * it will start the shut down process and block until the ORB has shut down

   473      * before it destroys the ORB.<br>

   474      * If an application calls <code>destroy</code> in a thread that is currently servicing

   475      * an invocation, the <code>BAD_INV_ORDER</code> system exception will be thrown

   476      * with the OMG minor code 3, since blocking would result in a deadlock.<p>

   477      * For maximum portability and to avoid resource leaks, an application should

   478      * always call <code>shutdown</code> and <code>destroy</code>

   479      * on all ORB instances before exiting.

   480      *

   481      * @throws org.omg.CORBA.BAD_INV_ORDER if the current thread is servicing an invocation

   482      */

   483     public void destroy( ) {

   484         throw new NO_IMPLEMENT();

   485     }

   486 

   487     /**

   488      * Disconnects the given servant object from the ORB. After this method returns,

   489      * the ORB will reject incoming remote requests for the disconnected

   490      * servant and will send the exception

   491      * <code>org.omg.CORBA.OBJECT_NOT_EXIST</code> back to the

   492      * remote client. Thus the object appears to be destroyed from the

   493      * point of view of remote clients. Note, however, that local requests issued

   494      * using the servant  directly do not

   495      * pass through the ORB; hence, they will continue to be processed by the

   496      * servant.

   497      * <P>

   498      * Calling the method <code>disconnect</code> has no effect

   499      * if the servant is not connected to the ORB.

   500      * <P>

   501      * Deprecated by the OMG in favor of the Portable Object Adapter APIs.

   502      *

   503      * @param obj The servant object to be disconnected from the ORB

   504      */

   505     public void disconnect(org.omg.CORBA.Object obj) {

   506         throw new NO_IMPLEMENT();

   507     }

   508 

   509     //

   510     // ORB method implementations.

   511     //

   512     // We are trying to accomplish 2 things at once in this class.

   513     // It can act as a default ORB implementation front-end,

   514     // creating an actual ORB implementation object which is a

   515     // subclass of this ORB class and then delegating the method

   516     // implementations.

   517     //

   518     // To accomplish the delegation model, the 'delegate' private instance

   519     // variable is set if an instance of this class is created directly.

   520     //

   521 

   522     /**

   523      * Returns a list of the initially available CORBA object references,

   524      * such as "NameService" and "InterfaceRepository".

   525      *

   526      * @return an array of <code>String</code> objects that represent

   527      *         the object references for CORBA services

   528      *         that are initially available with this ORB

   529      */

   530     abstract public String[] list_initial_services();

   531 

   532     /**

   533      * Resolves a specific object reference from the set of available

   534      * initial service names.

   535      *

   536      * @param object_name the name of the initial service as a string

   537      * @return  the object reference associated with the given name

   538      * @exception InvalidName if the given name is not associated with a

   539      *                         known service

   540      */

   541     abstract public org.omg.CORBA.Object resolve_initial_references(String object_name)

   542         throws InvalidName;

   543 

   544     /**

   545      * Converts the given CORBA object reference to a string.

   546      * Note that the format of this string is predefined by IIOP, allowing

   547      * strings generated by a different ORB to be converted back into an object

   548      * reference.

   549      * <P>

   550      * The resulting <code>String</code> object may be stored or communicated

   551      * in any way that a <code>String</code> object can be manipulated.

   552      *

   553      * @param obj the object reference to stringify

   554      * @return the string representing the object reference

   555      */

   556     abstract public String object_to_string(org.omg.CORBA.Object obj);

   557 

   558     /**

   559      * Converts a string produced by the method <code>object_to_string</code>

   560      * back to a CORBA object reference.

   561      *

   562      * @param str the string to be converted back to an object reference.  It must

   563      * be the result of converting an object reference to a string using the

   564      * method <code>object_to_string</code>.

   565      * @return the object reference

   566      */

   567     abstract public org.omg.CORBA.Object string_to_object(String str);

   568 

   569     /**

   570      * Allocates an <code>NVList</code> with (probably) enough

   571      * space for the specified number of <code>NamedValue</code> objects.

   572      * Note that the specified size is only a hint to help with

   573      * storage allocation and does not imply the maximum size of the list.

   574      *

   575      * @param count  suggested number of <code>NamedValue</code> objects for

   576      *               which to allocate space

   577      * @return the newly-created <code>NVList</code>

   578      *

   579      * @see NVList

   580      */

   581     abstract public NVList create_list(int count);

   582 

   583     /**

   584      * Creates an <code>NVList</code> initialized with argument

   585      * descriptions for the operation described in the given

   586      * <code>OperationDef</code> object.  This <code>OperationDef</code> object

   587      * is obtained from an Interface Repository. The arguments in the

   588      * returned <code>NVList</code> object are in the same order as in the

   589      * original IDL operation definition, which makes it possible for the list

   590      * to be used in dynamic invocation requests.

   591      *

   592      * @param oper      the <code>OperationDef</code> object to use to create the list

   593      * @return          a newly-created <code>NVList</code> object containing

   594      * descriptions of the arguments to the method described in the given

   595      * <code>OperationDef</code> object

   596      *

   597      * @see NVList

   598      */

   599     public NVList create_operation_list(org.omg.CORBA.Object oper)

   600     {

   601         // If we came here, it means that the actual ORB implementation

   602         // did not have a create_operation_list(...CORBA.Object oper) method,

   603         // so lets check if it has a create_operation_list(OperationDef oper)

   604         // method.

   605         try {

   606             // First try to load the OperationDef class

   607             String opDefClassName = "org.omg.CORBA.OperationDef";

   608             Class<?> opDefClass = null;

   609 

   610             ClassLoader cl = Thread.currentThread().getContextClassLoader();

   611             if ( cl == null )

   612                 cl = ClassLoader.getSystemClassLoader();

   613             // if this throws a ClassNotFoundException, it will be caught below.

   614             opDefClass = Class.forName(opDefClassName, true, cl);

   615 

   616             // OK, we loaded OperationDef. Now try to get the

   617             // create_operation_list(OperationDef oper) method.

   618             Class<?>[] argc = { opDefClass };

   619             java.lang.reflect.Method meth =

   620                 this.getClass().getMethod("create_operation_list", argc);

   621 

   622             // OK, the method exists, so invoke it and be happy.

   623             java.lang.Object[] argx = { oper };

   624             return (org.omg.CORBA.NVList)meth.invoke(this, argx);

   625         }

   626         catch( java.lang.reflect.InvocationTargetException exs ) {

   627             Throwable t = exs.getTargetException();

   628             if (t instanceof Error) {

   629                 throw (Error) t;

   630             }

   631             else if (t instanceof RuntimeException) {

   632                 throw (RuntimeException) t;

   633             }

   634             else {

   635                 throw new org.omg.CORBA.NO_IMPLEMENT();

   636             }

   637         }

   638         catch( RuntimeException ex ) {

   639             throw ex;

   640         }

   641         catch( Exception exr ) {

   642             throw new org.omg.CORBA.NO_IMPLEMENT();

   643         }

   644     }

   645 

   646 

   647     /**

   648      * Creates a <code>NamedValue</code> object

   649      * using the given name, value, and argument mode flags.

   650      * <P>

   651      * A <code>NamedValue</code> object serves as (1) a parameter or return

   652      * value or (2) a context property.

   653      * It may be used by itself or

   654      * as an element in an <code>NVList</code> object.

   655      *

   656      * @param s  the name of the <code>NamedValue</code> object

   657      * @param any  the <code>Any</code> value to be inserted into the

   658      *             <code>NamedValue</code> object

   659      * @param flags  the argument mode flags for the <code>NamedValue</code>: one of

   660      * <code>ARG_IN.value</code>, <code>ARG_OUT.value</code>,

   661      * or <code>ARG_INOUT.value</code>.

   662      *

   663      * @return  the newly-created <code>NamedValue</code> object

   664      * @see NamedValue

   665      */

   666     abstract public NamedValue create_named_value(String s, Any any, int flags);

   667 

   668     /**

   669      * Creates an empty <code>ExceptionList</code> object.

   670      *

   671      * @return  the newly-created <code>ExceptionList</code> object

   672      */

   673     abstract public ExceptionList create_exception_list();

   674 

   675     /**

   676      * Creates an empty <code>ContextList</code> object.

   677      *

   678      * @return  the newly-created <code>ContextList</code> object

   679      * @see ContextList

   680      * @see Context

   681      */

   682     abstract public ContextList create_context_list();

   683 

   684     /**

   685      * Gets the default <code>Context</code> object.

   686      *

   687      * @return the default <code>Context</code> object

   688      * @see Context

   689      */

   690     abstract public Context get_default_context();

   691 

   692     /**

   693      * Creates an <code>Environment</code> object.

   694      *

   695      * @return  the newly-created <code>Environment</code> object

   696      * @see Environment

   697      */

   698     abstract public Environment create_environment();

   699 

   700     /**

   701      * Creates a new <code>org.omg.CORBA.portable.OutputStream</code> into which

   702      * IDL method parameters can be marshalled during method invocation.

   703      * @return          the newly-created

   704      *              <code>org.omg.CORBA.portable.OutputStream</code> object

   705      */

   706     abstract public org.omg.CORBA.portable.OutputStream create_output_stream();

   707 

   708     /**

   709      * Sends multiple dynamic (DII) requests asynchronously without expecting

   710      * any responses. Note that oneway invocations are not guaranteed to

   711      * reach the server.

   712      *

   713      * @param req               an array of request objects

   714      */

   715     abstract public void send_multiple_requests_oneway(Request[] req);

   716 

   717     /**

   718      * Sends multiple dynamic (DII) requests asynchronously.

   719      *

   720      * @param req               an array of <code>Request</code> objects

   721      */

   722     abstract public void send_multiple_requests_deferred(Request[] req);

   723 

   724     /**

   725      * Finds out if any of the deferred (asynchronous) invocations have

   726      * a response yet.

   727      * @return <code>true</code> if there is a response available;

   728      *         <code> false</code> otherwise

   729      */

   730     abstract public boolean poll_next_response();

   731 

   732     /**

   733      * Gets the next <code>Request</code> instance for which a response

   734      * has been received.

   735      *

   736      * @return          the next <code>Request</code> object ready with a response

   737      * @exception WrongTransaction if the method <code>get_next_response</code>

   738      * is called from a transaction scope different

   739      * from the one from which the original request was sent. See the

   740      * OMG Transaction Service specification for details.

   741      */

   742     abstract public Request get_next_response() throws WrongTransaction;

   743 

   744     /**

   745      * Retrieves the <code>TypeCode</code> object that represents

   746      * the given primitive IDL type.

   747      *

   748      * @param tcKind    the <code>TCKind</code> instance corresponding to the

   749      *                  desired primitive type

   750      * @return          the requested <code>TypeCode</code> object

   751      */

   752     abstract public TypeCode get_primitive_tc(TCKind tcKind);

   753 

   754     /**

   755      * Creates a <code>TypeCode</code> object representing an IDL <code>struct</code>.

   756      * The <code>TypeCode</code> object is initialized with the given id,

   757      * name, and members.

   758      *

   759      * @param id        the repository id for the <code>struct</code>

   760      * @param name      the name of the <code>struct</code>

   761      * @param members   an array describing the members of the <code>struct</code>

   762      * @return          a newly-created <code>TypeCode</code> object describing

   763      *              an IDL <code>struct</code>

   764      */

   765     abstract public TypeCode create_struct_tc(String id, String name,

   766                                               StructMember[] members);

   767 

   768     /**

   769      * Creates a <code>TypeCode</code> object representing an IDL <code>union</code>.

   770      * The <code>TypeCode</code> object is initialized with the given id,

   771      * name, discriminator type, and members.

   772      *

   773      * @param id        the repository id of the <code>union</code>

   774      * @param name      the name of the <code>union</code>

   775      * @param discriminator_type        the type of the <code>union</code> discriminator

   776      * @param members   an array describing the members of the <code>union</code>

   777      * @return          a newly-created <code>TypeCode</code> object describing

   778      *              an IDL <code>union</code>

   779      */

   780     abstract public TypeCode create_union_tc(String id, String name,

   781                                              TypeCode discriminator_type,

   782                                              UnionMember[] members);

   783 

   784     /**

   785      * Creates a <code>TypeCode</code> object representing an IDL <code>enum</code>.

   786      * The <code>TypeCode</code> object is initialized with the given id,

   787      * name, and members.

   788      *

   789      * @param id        the repository id for the <code>enum</code>

   790      * @param name      the name for the <code>enum</code>

   791      * @param members   an array describing the members of the <code>enum</code>

   792      * @return          a newly-created <code>TypeCode</code> object describing

   793      *              an IDL <code>enum</code>

   794      */

   795     abstract public TypeCode create_enum_tc(String id, String name, String[] members);

   796 

   797     /**

   798      * Creates a <code>TypeCode</code> object representing an IDL <code>alias</code>

   799      * (<code>typedef</code>).

   800      * The <code>TypeCode</code> object is initialized with the given id,

   801      * name, and original type.

   802      *

   803      * @param id        the repository id for the alias

   804      * @param name      the name for the alias

   805      * @param original_type

   806      *                  the <code>TypeCode</code> object describing the original type

   807      *          for which this is an alias

   808      * @return          a newly-created <code>TypeCode</code> object describing

   809      *              an IDL <code>alias</code>

   810      */

   811     abstract public TypeCode create_alias_tc(String id, String name,

   812                                              TypeCode original_type);

   813 

   814     /**

   815      * Creates a <code>TypeCode</code> object representing an IDL <code>exception</code>.

   816      * The <code>TypeCode</code> object is initialized with the given id,

   817      * name, and members.

   818      *

   819      * @param id        the repository id for the <code>exception</code>

   820      * @param name      the name for the <code>exception</code>

   821      * @param members   an array describing the members of the <code>exception</code>

   822      * @return          a newly-created <code>TypeCode</code> object describing

   823      *              an IDL <code>exception</code>

   824      */

   825     abstract public TypeCode create_exception_tc(String id, String name,

   826                                                  StructMember[] members);

   827 

   828     /**

   829      * Creates a <code>TypeCode</code> object representing an IDL <code>interface</code>.

   830      * The <code>TypeCode</code> object is initialized with the given id

   831      * and name.

   832      *

   833      * @param id        the repository id for the interface

   834      * @param name      the name for the interface

   835      * @return          a newly-created <code>TypeCode</code> object describing

   836      *              an IDL <code>interface</code>

   837      */

   838 

   839     abstract public TypeCode create_interface_tc(String id, String name);

   840 

   841     /**

   842      * Creates a <code>TypeCode</code> object representing a bounded IDL

   843      * <code>string</code>.

   844      * The <code>TypeCode</code> object is initialized with the given bound,

   845      * which represents the maximum length of the string. Zero indicates

   846      * that the string described by this type code is unbounded.

   847      *

   848      * @param bound     the bound for the <code>string</code>; cannot be negative

   849      * @return          a newly-created <code>TypeCode</code> object describing

   850      *              a bounded IDL <code>string</code>

   851      * @exception BAD_PARAM if bound is a negative value

   852      */

   853 

   854     abstract public TypeCode create_string_tc(int bound);

   855 

   856     /**

   857      * Creates a <code>TypeCode</code> object representing a bounded IDL

   858      * <code>wstring</code> (wide string).

   859      * The <code>TypeCode</code> object is initialized with the given bound,

   860      * which represents the maximum length of the wide string. Zero indicates

   861      * that the string described by this type code is unbounded.

   862      *

   863      * @param bound     the bound for the <code>wstring</code>; cannot be negative

   864      * @return          a newly-created <code>TypeCode</code> object describing

   865      *              a bounded IDL <code>wstring</code>

   866      * @exception BAD_PARAM if bound is a negative value

   867      */

   868     abstract public TypeCode create_wstring_tc(int bound);

   869 

   870     /**

   871      * Creates a <code>TypeCode</code> object representing an IDL <code>sequence</code>.

   872      * The <code>TypeCode</code> object is initialized with the given bound and

   873      * element type.

   874      *

   875      * @param bound     the bound for the <code>sequence</code>, 0 if unbounded

   876      * @param element_type

   877      *                  the <code>TypeCode</code> object describing the elements

   878      *          contained in the <code>sequence</code>

   879      * @return          a newly-created <code>TypeCode</code> object describing

   880      *              an IDL <code>sequence</code>

   881      */

   882     abstract public TypeCode create_sequence_tc(int bound, TypeCode element_type);

   883 

   884     /**

   885      * Creates a <code>TypeCode</code> object representing a

   886      * a recursive IDL <code>sequence</code>.

   887      * <P>

   888      * For the IDL <code>struct</code> Node in following code fragment,

   889      * the offset parameter for creating its sequence would be 1:

   890      * <PRE>

   891      *    Struct Node {

   892      *        long value;

   893      *        Sequence <Node> subnodes;

   894      *    };

   895      * </PRE>

   896      *

   897      * @param bound     the bound for the sequence, 0 if unbounded

   898      * @param offset    the index to the enclosing <code>TypeCode</code> object

   899      *                  that describes the elements of this sequence

   900      * @return          a newly-created <code>TypeCode</code> object describing

   901      *                   a recursive sequence

   902      * @deprecated Use a combination of create_recursive_tc and create_sequence_tc instead

   903      * @see #create_recursive_tc(String) create_recursive_tc

   904      * @see #create_sequence_tc(int, TypeCode) create_sequence_tc

   905      */

   906     @Deprecated

   907     abstract public TypeCode create_recursive_sequence_tc(int bound, int offset);

   908 

   909     /**

   910      * Creates a <code>TypeCode</code> object representing an IDL <code>array</code>.

   911      * The <code>TypeCode</code> object is initialized with the given length and

   912      * element type.

   913      *

   914      * @param length    the length of the <code>array</code>

   915      * @param element_type  a <code>TypeCode</code> object describing the type

   916      *                      of element contained in the <code>array</code>

   917      * @return          a newly-created <code>TypeCode</code> object describing

   918      *              an IDL <code>array</code>

   919      */

   920     abstract public TypeCode create_array_tc(int length, TypeCode element_type);

   921 

   922     /**

   923      * Create a <code>TypeCode</code> object for an IDL native type.

   924      *

   925      * @param id        the logical id for the native type.

   926      * @param name      the name of the native type.

   927      * @return          the requested TypeCode.

   928      */

   929     public org.omg.CORBA.TypeCode create_native_tc(String id,

   930                                                    String name)

   931     {

   932         throw new org.omg.CORBA.NO_IMPLEMENT();

   933     }

   934 

   935     /**

   936      * Create a <code>TypeCode</code> object for an IDL abstract interface.

   937      *

   938      * @param id        the logical id for the abstract interface type.

   939      * @param name      the name of the abstract interface type.

   940      * @return          the requested TypeCode.

   941      */

   942     public org.omg.CORBA.TypeCode create_abstract_interface_tc(

   943                                                                String id,

   944                                                                String name)

   945     {

   946         throw new org.omg.CORBA.NO_IMPLEMENT();

   947     }

   948 

   949 

   950     /**

   951      * Create a <code>TypeCode</code> object for an IDL fixed type.

   952      *

   953      * @param digits    specifies the total number of decimal digits in the number

   954      *                  and must be from 1 to 31 inclusive.

   955      * @param scale     specifies the position of the decimal point.

   956      * @return          the requested TypeCode.

   957      */

   958     public org.omg.CORBA.TypeCode create_fixed_tc(short digits, short scale)

   959     {

   960         throw new org.omg.CORBA.NO_IMPLEMENT();

   961     }

   962 

   963 

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

   965 

   966 

   967     /**

   968      * Create a <code>TypeCode</code> object for an IDL value type.

   969      * The concrete_base parameter is the TypeCode for the immediate

   970      * concrete valuetype base of the valuetype for which the TypeCode

   971      * is being created.

   972      * It may be null if the valuetype does not have a concrete base.

   973      *

   974      * @param id                 the logical id for the value type.

   975      * @param name               the name of the value type.

   976      * @param type_modifier      one of the value type modifier constants:

   977      *                           VM_NONE, VM_CUSTOM, VM_ABSTRACT or VM_TRUNCATABLE

   978      * @param concrete_base      a <code>TypeCode</code> object

   979      *                           describing the concrete valuetype base

   980      * @param members            an array containing the members of the value type

   981      * @return                   the requested TypeCode

   982      */

   983     public org.omg.CORBA.TypeCode create_value_tc(String id,

   984                                                   String name,

   985                                                   short type_modifier,

   986                                                   TypeCode concrete_base,

   987                                                   ValueMember[] members)

   988     {

   989         throw new org.omg.CORBA.NO_IMPLEMENT();

   990     }

   991 

   992     /**

   993      * Create a recursive <code>TypeCode</code> object which

   994      * serves as a placeholder for a concrete TypeCode during the process of creating

   995      * TypeCodes which contain recursion. The id parameter specifies the repository id of

   996      * the type for which the recursive TypeCode is serving as a placeholder. Once the

   997      * recursive TypeCode has been properly embedded in the enclosing TypeCode which

   998      * corresponds to the specified repository id, it will function as a normal TypeCode.

   999      * Invoking operations on the recursive TypeCode before it has been embedded in the

  1000      * enclosing TypeCode will result in a <code>BAD_TYPECODE</code> exception.

  1001      * <P>

  1002      * For example, the following IDL type declaration contains recursion:

  1003      * <PRE>

  1004      *    Struct Node {

  1005      *        Sequence<Node> subnodes;

  1006      *    };

  1007      * </PRE>

  1008      * <P>

  1009      * To create a TypeCode for struct Node, you would invoke the TypeCode creation

  1010      * operations as shown below:

  1011      * <PRE>

  1012      * String nodeID = "IDL:Node:1.0";

  1013      * TypeCode recursiveSeqTC = orb.create_sequence_tc(0, orb.create_recursive_tc(nodeID));

  1014      * StructMember[] members = { new StructMember("subnodes", recursiveSeqTC, null) };

  1015      * TypeCode structNodeTC = orb.create_struct_tc(nodeID, "Node", members);

  1016      * </PRE>

  1017      * <P>

  1018      * Also note that the following is an illegal IDL type declaration:

  1019      * <PRE>

  1020      *    Struct Node {

  1021      *        Node next;

  1022      *    };

  1023      * </PRE>

  1024      * <P>

  1025      * Recursive types can only appear within sequences which can be empty.

  1026      * That way marshaling problems, when transmitting the struct in an Any, are avoided.

  1027      * <P>

  1028      * @param id                 the logical id of the referenced type

  1029      * @return                   the requested TypeCode

  1030      */

  1031     public org.omg.CORBA.TypeCode create_recursive_tc(String id) {

  1032         // implemented in subclass

  1033         throw new org.omg.CORBA.NO_IMPLEMENT();

  1034     }

  1035 

  1036     /**

  1037      * Creates a <code>TypeCode</code> object for an IDL value box.

  1038      *

  1039      * @param id                 the logical id for the value type

  1040      * @param name               the name of the value type

  1041      * @param boxed_type         the TypeCode for the type

  1042      * @return                   the requested TypeCode

  1043      */

  1044     public org.omg.CORBA.TypeCode create_value_box_tc(String id,

  1045                                                       String name,

  1046                                                       TypeCode boxed_type)

  1047     {

  1048         // implemented in subclass

  1049         throw new org.omg.CORBA.NO_IMPLEMENT();

  1050     }

  1051 

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

  1053 

  1054     /**

  1055      * Creates an IDL <code>Any</code> object initialized to

  1056      * contain a <code>Typecode</code> object whose <code>kind</code> field

  1057      * is set to <code>TCKind.tc_null</code>.

  1058      *

  1059      * @return          a newly-created <code>Any</code> object

  1060      */

  1061     abstract public Any create_any();

  1062 

  1063 

  1064 

  1065 

  1066     /**

  1067      * Retrieves a <code>Current</code> object.

  1068      * The <code>Current</code> interface is used to manage thread-specific

  1069      * information for use by services such as transactions and security.

  1070      *

  1071      * @see <a href="package-summary.html#unimpl"><code>CORBA</code> package

  1072      *      comments for unimplemented features</a>

  1073      *

  1074      * @return          a newly-created <code>Current</code> object

  1075      * @deprecated      use <code>resolve_initial_references</code>.

  1076      */

  1077     @Deprecated

  1078     public org.omg.CORBA.Current get_current()

  1079     {

  1080         throw new org.omg.CORBA.NO_IMPLEMENT();

  1081     }

  1082 

  1083     /**

  1084      * This operation blocks the current thread until the ORB has

  1085      * completed the shutdown process, initiated when some thread calls

  1086      * <code>shutdown</code>. It may be used by multiple threads which

  1087      * get all notified when the ORB shuts down.

  1088      *

  1089      */

  1090     public void run()

  1091     {

  1092         throw new org.omg.CORBA.NO_IMPLEMENT();

  1093     }

  1094 

  1095     /**

  1096      * Instructs the ORB to shut down, which causes all

  1097      * object adapters to shut down, in preparation for destruction.<br>

  1098      * If the <code>wait_for_completion</code> parameter

  1099      * is true, this operation blocks until all ORB processing (including

  1100      * processing of currently executing requests, object deactivation,

  1101      * and other object adapter operations) has completed.

  1102      * If an application does this in a thread that is currently servicing

  1103      * an invocation, the <code>BAD_INV_ORDER</code> system exception

  1104      * will be thrown with the OMG minor code 3,

  1105      * since blocking would result in a deadlock.<br>

  1106      * If the <code>wait_for_completion</code> parameter is <code>FALSE</code>,

  1107      * then shutdown may not have completed upon return.<p>

  1108      * While the ORB is in the process of shutting down, the ORB operates as normal,

  1109      * servicing incoming and outgoing requests until all requests have been completed.

  1110      * Once an ORB has shutdown, only object reference management operations

  1111      * may be invoked on the ORB or any object reference obtained from it.

  1112      * An application may also invoke the <code>destroy</code> operation on the ORB itself.

  1113      * Invoking any other operation will throw the <code>BAD_INV_ORDER</code>

  1114      * system exception with the OMG minor code 4.<p>

  1115      * The <code>ORB.run</code> method will return after

  1116      * <code>shutdown</code> has been called.

  1117      *

  1118      * @param wait_for_completion <code>true</code> if the call

  1119      *        should block until the shutdown is complete;

  1120      *        <code>false</code> if it should return immediately

  1121      * @throws org.omg.CORBA.BAD_INV_ORDER if the current thread is servicing

  1122      *         an invocation

  1123      */

  1124     public void shutdown(boolean wait_for_completion)

  1125     {

  1126         throw new org.omg.CORBA.NO_IMPLEMENT();

  1127     }

  1128 

  1129     /**

  1130      * Returns <code>true</code> if the ORB needs the main thread to

  1131      * perform some work, and <code>false</code> if the ORB does not

  1132      * need the main thread.

  1133      *

  1134      * @return <code>true</code> if there is work pending, meaning that the ORB