View Javadoc
1   /*
2    * Copyright (c) 1995, 2013, 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  /**
40   * A class providing APIs for the CORBA Object Request Broker
41   * features.  The <code>ORB</code> class also provides
42   * "pluggable ORB implementation" APIs that allow another vendor's ORB
43   * implementation to be used.
44   * <P>
45   * An ORB makes it possible for CORBA objects to communicate
46   * with each other by connecting objects making requests (clients) with
47   * objects servicing requests (servers).
48   * <P>
49   *
50   * The <code>ORB</code> class, which
51   * encapsulates generic CORBA functionality, does the following:
52   * (Note that items 5 and 6, which include most of the methods in
53   * the class <code>ORB</code>, are typically used with the <code>Dynamic Invocation
54   * Interface</code> (DII) and the <code>Dynamic Skeleton Interface</code>
55   * (DSI).
56   * These interfaces may be used by a developer directly, but
57   * most commonly they are used by the ORB internally and are
58   * not seen by the general programmer.)
59   * <OL>
60   * <li> initializes the ORB implementation by supplying values for
61   *      predefined properties and environmental parameters
62   * <li> obtains initial object references to services such as
63   * the NameService using the method <code>resolve_initial_references</code>
64   * <li> converts object references to strings and back
65   * <li> connects the ORB to a servant (an instance of a CORBA object
66   * implementation) and disconnects the ORB from a servant
67   * <li> creates objects such as
68   *   <ul>
69   *   <li><code>TypeCode</code>
70   *   <li><code>Any</code>
71   *   <li><code>NamedValue</code>
72   *   <li><code>Context</code>
73   *   <li><code>Environment</code>
74   *   <li>lists (such as <code>NVList</code>) containing these objects
75   *   </ul>
76   * <li> sends multiple messages in the DII
77   * </OL>
78   *
79   * <P>
80   * The <code>ORB</code> class can be used to obtain references to objects
81   * implemented anywhere on the network.
82   * <P>
83   * An application or applet gains access to the CORBA environment
84   * by initializing itself into an <code>ORB</code> using one of
85   * three <code>init</code> methods.  Two of the three methods use the properties
86   * (associations of a name with a value) shown in the
87   * table below.<BR>
88   * <TABLE BORDER=1 SUMMARY="Standard Java CORBA Properties">
89   * <TR><TH>Property Name</TH>   <TH>Property Value</TH></TR>
90   * <CAPTION>Standard Java CORBA Properties:</CAPTION>
91   *     <TR><TD>org.omg.CORBA.ORBClass</TD>
92   *     <TD>class name of an ORB implementation</TD></TR>
93   *     <TR><TD>org.omg.CORBA.ORBSingletonClass</TD>
94   *     <TD>class name of the ORB returned by <code>init()</code></TD></TR>
95   * </TABLE>
96   * <P>
97   * These properties allow a different vendor's <code>ORB</code>
98   * implementation to be "plugged in."
99   * <P>
100  * When an ORB instance is being created, the class name of the ORB
101  * implementation is located using
102  * the following standard search order:<P>
103  *
104  * <OL>
105  *     <LI>check in Applet parameter or application string array, if any
106  *
107  *     <LI>check in properties parameter, if any
108  *
109  *     <LI>check in the System properties
110  *
111  *     <LI>check in the orb.properties file located in the user.home
112  *         directory (if any)
113  *
114  *     <LI>check in the orb.properties file located in the java.home/lib
115  *         directory (if any)
116  *
117  *     <LI>fall back on a hardcoded default behavior (use the Java&nbsp;IDL
118  *         implementation)
119  * </OL>
120  * <P>
121  * Note that Java&nbsp;IDL provides a default implementation for the
122  * fully-functional ORB and for the Singleton ORB.  When the method
123  * <code>init</code> is given no parameters, the default Singleton
124  * ORB is returned.  When the method <code>init</code> is given parameters
125  * but no ORB class is specified, the Java&nbsp;IDL ORB implementation
126  * is returned.
127  * <P>
128  * The following code fragment creates an <code>ORB</code> object
129  * initialized with the default ORB Singleton.
130  * This ORB has a
131  * restricted implementation to prevent malicious applets from doing
132  * anything beyond creating typecodes.
133  * It is called a singleton
134  * because there is only one instance for an entire virtual machine.
135  * <PRE>
136  *    ORB orb = ORB.init();
137  * </PRE>
138  * <P>
139  * The following code fragment creates an <code>ORB</code> object
140  * for an application.  The parameter <code>args</code>
141  * represents the arguments supplied to the application's <code>main</code>
142  * method.  Since the property specifies the ORB class to be
143  * "SomeORBImplementation", the new ORB will be initialized with
144  * that ORB implementation.  If p had been null,
145  * and the arguments had not specified an ORB class,
146  * the new ORB would have been
147  * initialized with the default Java&nbsp;IDL implementation.
148  * <PRE>
149  *    Properties p = new Properties();
150  *    p.put("org.omg.CORBA.ORBClass", "SomeORBImplementation");
151  *    ORB orb = ORB.init(args, p);
152  * </PRE>
153  * <P>
154  * The following code fragment creates an <code>ORB</code> object
155  * for the applet supplied as the first parameter.  If the given
156  * applet does not specify an ORB class, the new ORB will be
157  * initialized with the default Java&nbsp;IDL implementation.
158  * <PRE>
159  *    ORB orb = ORB.init(myApplet, null);
160  * </PRE>
161  * <P>
162  * An application or applet can be initialized in one or more ORBs.
163  * ORB initialization is a bootstrap call into the CORBA world.
164  * @since   JDK1.2
165  */
166 abstract public class ORB {
167 
168     //
169     // This is the ORB implementation used when nothing else is specified.
170     // Whoever provides this class customizes this string to
171     // point at their ORB implementation.
172     //
173     private static final String ORBClassKey = "org.omg.CORBA.ORBClass";
174     private static final String ORBSingletonClassKey = "org.omg.CORBA.ORBSingletonClass";
175 
176     //
177     // The global instance of the singleton ORB implementation which
178     // acts as a factory for typecodes for generated Helper classes.
179     // TypeCodes should be immutable since they may be shared across
180     // different security contexts (applets). There should be no way to
181     // use a TypeCode as a storage depot for illicitly passing
182     // information or Java objects between different security contexts.
183     //
184     static private ORB singleton;
185 
186     // Get System property
187     private static String getSystemProperty(final String name) {
188 
189         // This will not throw a SecurityException because this
190         // class was loaded from rt.jar using the bootstrap classloader.
191         String propValue = (String) AccessController.doPrivileged(
192             new PrivilegedAction() {
193                 public java.lang.Object run() {
194                     return System.getProperty(name);
195                 }
196             }
197         );
198 
199         return propValue;
200     }
201 
202     // Get property from orb.properties in either <user.home> or <java-home>/lib
203     // directories.
204     private static String getPropertyFromFile(final String name) {
205         // This will not throw a SecurityException because this
206         // class was loaded from rt.jar using the bootstrap classloader.
207 
208         String propValue = (String) AccessController.doPrivileged(
209             new PrivilegedAction() {
210                 private Properties getFileProperties( String fileName ) {
211                     try {
212                         File propFile = new File( fileName ) ;
213                         if (!propFile.exists())
214                             return null ;
215 
216                         Properties props = new Properties() ;
217                         FileInputStream fis = new FileInputStream(propFile);
218                         try {
219                             props.load( fis );
220                         } finally {
221                             fis.close() ;
222                         }
223 
224                         return props ;
225                     } catch (Exception exc) {
226                         return null ;
227                     }
228                 }
229 
230                 public java.lang.Object run() {
231                     String userHome = System.getProperty("user.home");
232                     String fileName = userHome + File.separator +
233                         "orb.properties" ;
234                     Properties props = getFileProperties( fileName ) ;
235 
236                     if (props != null) {
237                         String value = props.getProperty( name ) ;
238                         if (value != null)
239                             return value ;
240                     }
241 
242                     String javaHome = System.getProperty("java.home");
243                     fileName = javaHome + File.separator
244                         + "lib" + File.separator + "orb.properties";
245                     props = getFileProperties( fileName ) ;
246 
247                     if (props == null)
248                         return null ;
249                     else
250                         return props.getProperty( name ) ;
251                 }
252             }
253         );
254 
255         return propValue;
256     }
257 
258     /**
259      * Returns the <code>ORB</code> singleton object. This method always returns the
260      * same ORB instance, which is an instance of the class described by the
261      * <code>org.omg.CORBA.ORBSingletonClass</code> system property.
262      * <P>
263      * This no-argument version of the method <code>init</code> is used primarily
264      * as a factory for <code>TypeCode</code> objects, which are used by
265      * <code>Helper</code> classes to implement the method <code>type</code>.
266      * It is also used to create <code>Any</code> objects that are used to
267      * describe <code>union</code> labels (as part of creating a <code>
268      * TypeCode</code> object for a <code>union</code>).
269      * <P>
270      * This method is not intended to be used by applets, and in the event
271      * that it is called in an applet environment, the ORB it returns
272      * is restricted so that it can be used only as a factory for
273      * <code>TypeCode</code> objects.  Any <code>TypeCode</code> objects
274      * it produces can be safely shared among untrusted applets.
275      * <P>
276      * If an ORB is created using this method from an applet,
277      * a system exception will be thrown if
278      * methods other than those for
279      * creating <code>TypeCode</code> objects are invoked.
280      *
281      * @return the singleton ORB
282      */
283     public static synchronized ORB init() {
284         if (singleton == null) {
285             String className = getSystemProperty(ORBSingletonClassKey);
286             if (className == null)
287                 className = getPropertyFromFile(ORBSingletonClassKey);
288             if ((className == null) ||
289                     (className.equals("com.sun.corba.se.impl.orb.ORBSingleton"))) {
290                 singleton = new com.sun.corba.se.impl.orb.ORBSingleton();
291             } else {
292                 singleton = create_impl(className);
293             }
294         }
295         return singleton;
296     }
297 
298     private static ORB create_impl(String className) {
299 
300         ClassLoader cl = Thread.currentThread().getContextClassLoader();
301         if (cl == null)
302             cl = ClassLoader.getSystemClassLoader();
303 
304         try {
305             return (ORB) Class.forName(className, true, cl).newInstance();
306         } catch (Throwable ex) {
307             SystemException systemException = new INITIALIZE(
308                "can't instantiate default ORB implementation " + className);
309             systemException.initCause(ex);
310             throw systemException;
311         }
312     }
313 
314     /**
315      * Creates a new <code>ORB</code> instance for a standalone
316      * application.  This method may be called from applications
317      * only and returns a new fully functional <code>ORB</code> object
318      * each time it is called.
319      * @param args command-line arguments for the application's <code>main</code>
320      *             method; may be <code>null</code>
321      * @param props application-specific properties; may be <code>null</code>
322      * @return the newly-created ORB instance
323      */
324     public static ORB init(String[] args, Properties props) {
325         //
326         // Note that there is no standard command-line argument for
327         // specifying the default ORB implementation. For an
328         // application you can choose an implementation either by
329         // setting the CLASSPATH to pick a different org.omg.CORBA
330         // and it's baked-in ORB implementation default or by
331         // setting an entry in the properties object or in the
332         // system properties.
333         //
334         String className = null;
335         ORB orb;
336 
337         if (props != null)
338             className = props.getProperty(ORBClassKey);
339         if (className == null)
340             className = getSystemProperty(ORBClassKey);
341         if (className == null)
342             className = getPropertyFromFile(ORBClassKey);
343         if ((className == null) ||
344                     (className.equals("com.sun.corba.se.impl.orb.ORBImpl"))) {
345             orb = new com.sun.corba.se.impl.orb.ORBImpl();
346         } else {
347             orb = create_impl(className);
348         }
349 
350         orb.set_parameters(args, props);
351         return orb;
352     }
353 
354 
355     /**
356      * Creates a new <code>ORB</code> instance for an applet.  This
357      * method may be called from applets only and returns a new
358      * fully-functional <code>ORB</code> object each time it is called.
359      * @param app the applet; may be <code>null</code>
360      * @param props applet-specific properties; may be <code>null</code>
361      * @return the newly-created ORB instance
362      */
363     public static ORB init(Applet app, Properties props) {
364         String className;
365         ORB orb;
366 
367         className = app.getParameter(ORBClassKey);
368         if (className == null && props != null)
369             className = props.getProperty(ORBClassKey);
370         if (className == null)
371             className = getSystemProperty(ORBClassKey);
372         if (className == null)
373             className = getPropertyFromFile(ORBClassKey);
374         if ((className == null) ||
375                     (className.equals("com.sun.corba.se.impl.orb.ORBImpl"))) {
376             orb = new com.sun.corba.se.impl.orb.ORBImpl();
377         } else {
378             orb = create_impl(className);
379         }
380 
381         orb.set_parameters(app, props);
382         return orb;
383     }
384 
385     /**
386      * Allows the ORB implementation to be initialized with the given
387      * parameters and properties. This method, used in applications only,
388      * is implemented by subclass ORB implementations and called
389      * by the appropriate <code>init</code> method to pass in its parameters.
390      *
391      * @param args command-line arguments for the application's <code>main</code>
392      *             method; may be <code>null</code>
393      * @param props application-specific properties; may be <code>null</code>
394      */
395     abstract protected void set_parameters(String[] args, Properties props);
396 
397     /**
398      * Allows the ORB implementation to be initialized with the given
399      * applet and parameters. This method, used in applets only,
400      * is implemented by subclass ORB implementations and called
401      * by the appropriate <code>init</code> method to pass in its parameters.
402      *
403      * @param app the applet; may be <code>null</code>
404      * @param props applet-specific properties; may be <code>null</code>
405      */
406     abstract protected void set_parameters(Applet app, Properties props);
407 
408     /**
409      * Connects the given servant object (a Java object that is
410      * an instance of the server implementation class)
411      * to the ORB. The servant class must
412      * extend the <code>ImplBase</code> class corresponding to the interface that is
413      * supported by the server. The servant must thus be a CORBA object
414      * reference, and inherit from <code>org.omg.CORBA.Object</code>.
415      * Servants created by the user can start receiving remote invocations
416      * after the method <code>connect</code> has been called. A servant may also be
417      * automatically and implicitly connected to the ORB if it is passed as
418      * an IDL parameter in an IDL method invocation on a non-local object,
419      * that is, if the servant object has to be marshalled and sent outside of the
420      * process address space.
421      * <P>
422      * Calling the method <code>connect</code> has no effect
423      * when the servant object is already connected to the ORB.
424      * <P>
425      * Deprecated by the OMG in favor of the Portable Object Adapter APIs.
426      *
427      * @param obj The servant object reference
428      */
429     public void connect(org.omg.CORBA.Object obj) {
430         throw new NO_IMPLEMENT();
431     }
432 
433     /**
434      * Destroys the ORB so that its resources can be reclaimed.
435      * Any operation invoked on a destroyed ORB reference will throw the
436      * <code>OBJECT_NOT_EXIST</code> exception.
437      * Once an ORB has been destroyed, another call to <code>init</code>
438      * with the same ORBid will return a reference to a newly constructed ORB.<p>
439      * If <code>destroy</code> is called on an ORB that has not been shut down,
440      * it will start the shut down process and block until the ORB has shut down
441      * before it destroys the ORB.<br>
442      * If an application calls <code>destroy</code> in a thread that is currently servicing
443      * an invocation, the <code>BAD_INV_ORDER</code> system exception will be thrown
444      * with the OMG minor code 3, since blocking would result in a deadlock.<p>
445      * For maximum portability and to avoid resource leaks, an application should
446      * always call <code>shutdown</code> and <code>destroy</code>
447      * on all ORB instances before exiting.
448      *
449      * @throws org.omg.CORBA.BAD_INV_ORDER if the current thread is servicing an invocation
450      */
451     public void destroy( ) {
452         throw new NO_IMPLEMENT();
453     }
454 
455     /**
456      * Disconnects the given servant object from the ORB. After this method returns,
457      * the ORB will reject incoming remote requests for the disconnected
458      * servant and will send the exception
459      * <code>org.omg.CORBA.OBJECT_NOT_EXIST</code> back to the
460      * remote client. Thus the object appears to be destroyed from the
461      * point of view of remote clients. Note, however, that local requests issued
462      * using the servant  directly do not
463      * pass through the ORB; hence, they will continue to be processed by the
464      * servant.
465      * <P>
466      * Calling the method <code>disconnect</code> has no effect
467      * if the servant is not connected to the ORB.
468      * <P>
469      * Deprecated by the OMG in favor of the Portable Object Adapter APIs.
470      *
471      * @param obj The servant object to be disconnected from the ORB
472      */
473     public void disconnect(org.omg.CORBA.Object obj) {
474         throw new NO_IMPLEMENT();
475     }
476 
477     //
478     // ORB method implementations.
479     //
480     // We are trying to accomplish 2 things at once in this class.
481     // It can act as a default ORB implementation front-end,
482     // creating an actual ORB implementation object which is a
483     // subclass of this ORB class and then delegating the method
484     // implementations.
485     //
486     // To accomplish the delegation model, the 'delegate' private instance
487     // variable is set if an instance of this class is created directly.
488     //
489 
490     /**
491      * Returns a list of the initially available CORBA object references,
492      * such as "NameService" and "InterfaceRepository".
493      *
494      * @return an array of <code>String</code> objects that represent
495      *         the object references for CORBA services
496      *         that are initially available with this ORB
497      */
498     abstract public String[] list_initial_services();
499 
500     /**
501      * Resolves a specific object reference from the set of available
502      * initial service names.
503      *
504      * @param object_name the name of the initial service as a string
505      * @return  the object reference associated with the given name
506      * @exception InvalidName if the given name is not associated with a
507      *                         known service
508      */
509     abstract public org.omg.CORBA.Object resolve_initial_references(String object_name)
510         throws InvalidName;
511 
512     /**
513      * Converts the given CORBA object reference to a string.
514      * Note that the format of this string is predefined by IIOP, allowing
515      * strings generated by a different ORB to be converted back into an object
516      * reference.
517      * <P>
518      * The resulting <code>String</code> object may be stored or communicated
519      * in any way that a <code>String</code> object can be manipulated.
520      *
521      * @param obj the object reference to stringify
522      * @return the string representing the object reference
523      */
524     abstract public String object_to_string(org.omg.CORBA.Object obj);
525 
526     /**
527      * Converts a string produced by the method <code>object_to_string</code>
528      * back to a CORBA object reference.
529      *
530      * @param str the string to be converted back to an object reference.  It must
531      * be the result of converting an object reference to a string using the
532      * method <code>object_to_string</code>.
533      * @return the object reference
534      */
535     abstract public org.omg.CORBA.Object string_to_object(String str);
536 
537     /**
538      * Allocates an <code>NVList</code> with (probably) enough
539      * space for the specified number of <code>NamedValue</code> objects.
540      * Note that the specified size is only a hint to help with
541      * storage allocation and does not imply the maximum size of the list.
542      *
543      * @param count  suggested number of <code>NamedValue</code> objects for
544      *               which to allocate space
545      * @return the newly-created <code>NVList</code>
546      *
547      * @see NVList
548      */
549     abstract public NVList create_list(int count);
550 
551     /**
552      * Creates an <code>NVList</code> initialized with argument
553      * descriptions for the operation described in the given
554      * <code>OperationDef</code> object.  This <code>OperationDef</code> object
555      * is obtained from an Interface Repository. The arguments in the
556      * returned <code>NVList</code> object are in the same order as in the
557      * original IDL operation definition, which makes it possible for the list
558      * to be used in dynamic invocation requests.
559      *
560      * @param oper      the <code>OperationDef</code> object to use to create the list
561      * @return          a newly-created <code>NVList</code> object containing
562      * descriptions of the arguments to the method described in the given
563      * <code>OperationDef</code> object
564      *
565      * @see NVList
566      */
567     public NVList create_operation_list(org.omg.CORBA.Object oper)
568     {
569         // If we came here, it means that the actual ORB implementation
570         // did not have a create_operation_list(...CORBA.Object oper) method,
571         // so lets check if it has a create_operation_list(OperationDef oper)
572         // method.
573         try {
574             // First try to load the OperationDef class
575             String opDefClassName = "org.omg.CORBA.OperationDef";
576             Class opDefClass = null;
577 
578             ClassLoader cl = Thread.currentThread().getContextClassLoader();
579             if ( cl == null )
580                 cl = ClassLoader.getSystemClassLoader();
581             // if this throws a ClassNotFoundException, it will be caught below.
582             opDefClass = Class.forName(opDefClassName, true, cl);
583 
584             // OK, we loaded OperationDef. Now try to get the
585             // create_operation_list(OperationDef oper) method.
586             Class[] argc = { opDefClass };
587             java.lang.reflect.Method meth =
588                 this.getClass().getMethod("create_operation_list", argc);
589 
590             // OK, the method exists, so invoke it and be happy.
591             java.lang.Object[] argx = { oper };
592             return (org.omg.CORBA.NVList)meth.invoke(this, argx);
593         }
594         catch( java.lang.reflect.InvocationTargetException exs ) {
595             Throwable t = exs.getTargetException();
596             if (t instanceof Error) {
597                 throw (Error) t;
598             }
599             else if (t instanceof RuntimeException) {
600                 throw (RuntimeException) t;
601             }
602             else {
603                 throw new org.omg.CORBA.NO_IMPLEMENT();
604             }
605         }
606         catch( RuntimeException ex ) {
607             throw ex;
608         }
609         catch( Exception exr ) {
610             throw new org.omg.CORBA.NO_IMPLEMENT();
611         }
612     }
613 
614 
615     /**
616      * Creates a <code>NamedValue</code> object
617      * using the given name, value, and argument mode flags.
618      * <P>
619      * A <code>NamedValue</code> object serves as (1) a parameter or return
620      * value or (2) a context property.
621      * It may be used by itself or
622      * as an element in an <code>NVList</code> object.
623      *
624      * @param s  the name of the <code>NamedValue</code> object
625      * @param any  the <code>Any</code> value to be inserted into the
626      *             <code>NamedValue</code> object
627      * @param flags  the argument mode flags for the <code>NamedValue</code>: one of
628      * <code>ARG_IN.value</code>, <code>ARG_OUT.value</code>,
629      * or <code>ARG_INOUT.value</code>.
630      *
631      * @return  the newly-created <code>NamedValue</code> object
632      * @see NamedValue
633      */
634     abstract public NamedValue create_named_value(String s, Any any, int flags);
635 
636     /**
637      * Creates an empty <code>ExceptionList</code> object.
638      *
639      * @return  the newly-created <code>ExceptionList</code> object
640      */
641     abstract public ExceptionList create_exception_list();
642 
643     /**
644      * Creates an empty <code>ContextList</code> object.
645      *
646      * @return  the newly-created <code>ContextList</code> object
647      * @see ContextList
648      * @see Context
649      */
650     abstract public ContextList create_context_list();
651 
652     /**
653      * Gets the default <code>Context</code> object.
654      *
655      * @return the default <code>Context</code> object
656      * @see Context
657      */
658     abstract public Context get_default_context();
659 
660     /**
661      * Creates an <code>Environment</code> object.
662      *
663      * @return  the newly-created <code>Environment</code> object
664      * @see Environment
665      */
666     abstract public Environment create_environment();
667 
668     /**
669      * Creates a new <code>org.omg.CORBA.portable.OutputStream</code> into which
670      * IDL method parameters can be marshalled during method invocation.
671      * @return          the newly-created
672      *              <code>org.omg.CORBA.portable.OutputStream</code> object
673      */
674     abstract public org.omg.CORBA.portable.OutputStream create_output_stream();
675 
676     /**
677      * Sends multiple dynamic (DII) requests asynchronously without expecting
678      * any responses. Note that oneway invocations are not guaranteed to
679      * reach the server.
680      *
681      * @param req               an array of request objects
682      */
683     abstract public void send_multiple_requests_oneway(Request[] req);
684 
685     /**
686      * Sends multiple dynamic (DII) requests asynchronously.
687      *
688      * @param req               an array of <code>Request</code> objects
689      */
690     abstract public void send_multiple_requests_deferred(Request[] req);
691 
692     /**
693      * Finds out if any of the deferred (asynchronous) invocations have
694      * a response yet.
695      * @return <code>true</code> if there is a response available;
696      *         <code> false</code> otherwise
697      */
698     abstract public boolean poll_next_response();
699 
700     /**
701      * Gets the next <code>Request</code> instance for which a response
702      * has been received.
703      *
704      * @return          the next <code>Request</code> object ready with a response
705      * @exception WrongTransaction if the method <code>get_next_response</code>
706      * is called from a transaction scope different
707      * from the one from which the original request was sent. See the
708      * OMG Transaction Service specification for details.
709      */
710     abstract public Request get_next_response() throws WrongTransaction;
711 
712     /**
713      * Retrieves the <code>TypeCode</code> object that represents
714      * the given primitive IDL type.
715      *
716      * @param tcKind    the <code>TCKind</code> instance corresponding to the
717      *                  desired primitive type
718      * @return          the requested <code>TypeCode</code> object
719      */
720     abstract public TypeCode get_primitive_tc(TCKind tcKind);
721 
722     /**
723      * Creates a <code>TypeCode</code> object representing an IDL <code>struct</code>.
724      * The <code>TypeCode</code> object is initialized with the given id,
725      * name, and members.
726      *
727      * @param id        the repository id for the <code>struct</code>
728      * @param name      the name of the <code>struct</code>
729      * @param members   an array describing the members of the <code>struct</code>
730      * @return          a newly-created <code>TypeCode</code> object describing
731      *              an IDL <code>struct</code>
732      */
733     abstract public TypeCode create_struct_tc(String id, String name,
734                                               StructMember[] members);
735 
736     /**
737      * Creates a <code>TypeCode</code> object representing an IDL <code>union</code>.
738      * The <code>TypeCode</code> object is initialized with the given id,
739      * name, discriminator type, and members.
740      *
741      * @param id        the repository id of the <code>union</code>
742      * @param name      the name of the <code>union</code>
743      * @param discriminator_type        the type of the <code>union</code> discriminator
744      * @param members   an array describing the members of the <code>union</code>
745      * @return          a newly-created <code>TypeCode</code> object describing
746      *              an IDL <code>union</code>
747      */
748     abstract public TypeCode create_union_tc(String id, String name,
749                                              TypeCode discriminator_type,
750                                              UnionMember[] members);
751 
752     /**
753      * Creates a <code>TypeCode</code> object representing an IDL <code>enum</code>.
754      * The <code>TypeCode</code> object is initialized with the given id,
755      * name, and members.
756      *
757      * @param id        the repository id for the <code>enum</code>
758      * @param name      the name for the <code>enum</code>
759      * @param members   an array describing the members of the <code>enum</code>
760      * @return          a newly-created <code>TypeCode</code> object describing
761      *              an IDL <code>enum</code>
762      */
763     abstract public TypeCode create_enum_tc(String id, String name, String[] members);
764 
765     /**
766      * Creates a <code>TypeCode</code> object representing an IDL <code>alias</code>
767      * (<code>typedef</code>).
768      * The <code>TypeCode</code> object is initialized with the given id,
769      * name, and original type.
770      *
771      * @param id        the repository id for the alias
772      * @param name      the name for the alias
773      * @param original_type
774      *                  the <code>TypeCode</code> object describing the original type
775      *          for which this is an alias
776      * @return          a newly-created <code>TypeCode</code> object describing
777      *              an IDL <code>alias</code>
778      */
779     abstract public TypeCode create_alias_tc(String id, String name,
780                                              TypeCode original_type);
781 
782     /**
783      * Creates a <code>TypeCode</code> object representing an IDL <code>exception</code>.
784      * The <code>TypeCode</code> object is initialized with the given id,
785      * name, and members.
786      *
787      * @param id        the repository id for the <code>exception</code>
788      * @param name      the name for the <code>exception</code>
789      * @param members   an array describing the members of the <code>exception</code>
790      * @return          a newly-created <code>TypeCode</code> object describing
791      *              an IDL <code>exception</code>
792      */
793     abstract public TypeCode create_exception_tc(String id, String name,
794                                                  StructMember[] members);
795 
796     /**
797      * Creates a <code>TypeCode</code> object representing an IDL <code>interface</code>.
798      * The <code>TypeCode</code> object is initialized with the given id
799      * and name.
800      *
801      * @param id        the repository id for the interface
802      * @param name      the name for the interface
803      * @return          a newly-created <code>TypeCode</code> object describing
804      *              an IDL <code>interface</code>
805      */
806 
807     abstract public TypeCode create_interface_tc(String id, String name);
808 
809     /**
810      * Creates a <code>TypeCode</code> object representing a bounded IDL
811      * <code>string</code>.
812      * The <code>TypeCode</code> object is initialized with the given bound,
813      * which represents the maximum length of the string. Zero indicates
814      * that the string described by this type code is unbounded.
815      *
816      * @param bound     the bound for the <code>string</code>; cannot be negative
817      * @return          a newly-created <code>TypeCode</code> object describing
818      *              a bounded IDL <code>string</code>
819      * @exception BAD_PARAM if bound is a negative value
820      */
821 
822     abstract public TypeCode create_string_tc(int bound);
823 
824     /**
825      * Creates a <code>TypeCode</code> object representing a bounded IDL
826      * <code>wstring</code> (wide string).
827      * The <code>TypeCode</code> object is initialized with the given bound,
828      * which represents the maximum length of the wide string. Zero indicates
829      * that the string described by this type code is unbounded.
830      *
831      * @param bound     the bound for the <code>wstring</code>; cannot be negative
832      * @return          a newly-created <code>TypeCode</code> object describing
833      *              a bounded IDL <code>wstring</code>
834      * @exception BAD_PARAM if bound is a negative value
835      */
836     abstract public TypeCode create_wstring_tc(int bound);
837 
838     /**
839      * Creates a <code>TypeCode</code> object representing an IDL <code>sequence</code>.
840      * The <code>TypeCode</code> object is initialized with the given bound and
841      * element type.
842      *
843      * @param bound     the bound for the <code>sequence</code>, 0 if unbounded
844      * @param element_type
845      *                  the <code>TypeCode</code> object describing the elements
846      *          contained in the <code>sequence</code>
847      * @return          a newly-created <code>TypeCode</code> object describing
848      *              an IDL <code>sequence</code>
849      */
850     abstract public TypeCode create_sequence_tc(int bound, TypeCode element_type);
851 
852     /**
853      * Creates a <code>TypeCode</code> object representing a
854      * a recursive IDL <code>sequence</code>.
855      * <P>
856      * For the IDL <code>struct</code> Node in following code fragment,
857      * the offset parameter for creating its sequence would be 1:
858      * <PRE>
859      *    Struct Node {
860      *        long value;
861      *        Sequence &lt;Node&gt; subnodes;
862      *    };
863      * </PRE>
864      *
865      * @param bound     the bound for the sequence, 0 if unbounded
866      * @param offset    the index to the enclosing <code>TypeCode</code> object
867      *                  that describes the elements of this sequence
868      * @return          a newly-created <code>TypeCode</code> object describing
869      *                   a recursive sequence
870      * @deprecated Use a combination of create_recursive_tc and create_sequence_tc instead
871      * @see #create_recursive_tc(String) create_recursive_tc
872      * @see #create_sequence_tc(int, TypeCode) create_sequence_tc
873      */
874     @Deprecated
875     abstract public TypeCode create_recursive_sequence_tc(int bound, int offset);
876 
877     /**
878      * Creates a <code>TypeCode</code> object representing an IDL <code>array</code>.
879      * The <code>TypeCode</code> object is initialized with the given length and
880      * element type.
881      *
882      * @param length    the length of the <code>array</code>
883      * @param element_type  a <code>TypeCode</code> object describing the type
884      *                      of element contained in the <code>array</code>
885      * @return          a newly-created <code>TypeCode</code> object describing
886      *              an IDL <code>array</code>
887      */
888     abstract public TypeCode create_array_tc(int length, TypeCode element_type);
889 
890     /**
891      * Create a <code>TypeCode</code> object for an IDL native type.
892      *
893      * @param id        the logical id for the native type.
894      * @param name      the name of the native type.
895      * @return          the requested TypeCode.
896      */
897     public org.omg.CORBA.TypeCode create_native_tc(String id,
898                                                    String name)
899     {
900         throw new org.omg.CORBA.NO_IMPLEMENT();
901     }
902 
903     /**
904      * Create a <code>TypeCode</code> object for an IDL abstract interface.
905      *
906      * @param id        the logical id for the abstract interface type.
907      * @param name      the name of the abstract interface type.
908      * @return          the requested TypeCode.
909      */
910     public org.omg.CORBA.TypeCode create_abstract_interface_tc(
911                                                                String id,
912                                                                String name)
913     {
914         throw new org.omg.CORBA.NO_IMPLEMENT();
915     }
916 
917 
918     /**
919      * Create a <code>TypeCode</code> object for an IDL fixed type.
920      *
921      * @param digits    specifies the total number of decimal digits in the number
922      *                  and must be from 1 to 31 inclusive.
923      * @param scale     specifies the position of the decimal point.
924      * @return          the requested TypeCode.
925      */
926     public org.omg.CORBA.TypeCode create_fixed_tc(short digits, short scale)
927     {
928         throw new org.omg.CORBA.NO_IMPLEMENT();
929     }
930 
931 
932     // orbos 98-01-18: Objects By Value -- begin
933 
934 
935     /**
936      * Create a <code>TypeCode</code> object for an IDL value type.
937      * The concrete_base parameter is the TypeCode for the immediate
938      * concrete valuetype base of the valuetype for which the TypeCode
939      * is being created.
940      * It may be null if the valuetype does not have a concrete base.
941      *
942      * @param id                 the logical id for the value type.
943      * @param name               the name of the value type.
944      * @param type_modifier      one of the value type modifier constants:
945      *                           VM_NONE, VM_CUSTOM, VM_ABSTRACT or VM_TRUNCATABLE
946      * @param concrete_base      a <code>TypeCode</code> object
947      *                           describing the concrete valuetype base
948      * @param members            an array containing the members of the value type
949      * @return                   the requested TypeCode
950      */
951     public org.omg.CORBA.TypeCode create_value_tc(String id,
952                                                   String name,
953                                                   short type_modifier,
954                                                   TypeCode concrete_base,
955                                                   ValueMember[] members)
956     {
957         throw new org.omg.CORBA.NO_IMPLEMENT();
958     }
959 
960     /**
961      * Create a recursive <code>TypeCode</code> object which
962      * serves as a placeholder for a concrete TypeCode during the process of creating
963      * TypeCodes which contain recursion. The id parameter specifies the repository id of
964      * the type for which the recursive TypeCode is serving as a placeholder. Once the
965      * recursive TypeCode has been properly embedded in the enclosing TypeCode which
966      * corresponds to the specified repository id, it will function as a normal TypeCode.
967      * Invoking operations on the recursive TypeCode before it has been embedded in the
968      * enclosing TypeCode will result in a <code>BAD_TYPECODE</code> exception.
969      * <P>
970      * For example, the following IDL type declaration contains recursion:
971      * <PRE>
972      *    Struct Node {
973      *        Sequence&lt;Node&gt; subnodes;
974      *    };
975      * </PRE>
976      * <P>
977      * To create a TypeCode for struct Node, you would invoke the TypeCode creation
978      * operations as shown below:
979      * <PRE>
980      * String nodeID = "IDL:Node:1.0";
981      * TypeCode recursiveSeqTC = orb.create_sequence_tc(0, orb.create_recursive_tc(nodeID));
982      * StructMember[] members = { new StructMember("subnodes", recursiveSeqTC, null) };
983      * TypeCode structNodeTC = orb.create_struct_tc(nodeID, "Node", members);
984      * </PRE>
985      * <P>
986      * Also note that the following is an illegal IDL type declaration:
987      * <PRE>
988      *    Struct Node {
989      *        Node next;
990      *    };
991      * </PRE>
992      * <P>
993      * Recursive types can only appear within sequences which can be empty.
994      * That way marshaling problems, when transmitting the struct in an Any, are avoided.
995      * <P>
996      * @param id                 the logical id of the referenced type
997      * @return                   the requested TypeCode
998      */
999     public org.omg.CORBA.TypeCode create_recursive_tc(String id) {
1000         // implemented in subclass
1001         throw new org.omg.CORBA.NO_IMPLEMENT();
1002     }
1003 
1004     /**
1005      * Creates a <code>TypeCode</code> object for an IDL value box.
1006      *
1007      * @param id                 the logical id for the value type
1008      * @param name               the name of the value type
1009      * @param boxed_type         the TypeCode for the type
1010      * @return                   the requested TypeCode
1011      */
1012     public org.omg.CORBA.TypeCode create_value_box_tc(String id,
1013                                                       String name,
1014                                                       TypeCode boxed_type)
1015     {
1016         // implemented in subclass
1017         throw new org.omg.CORBA.NO_IMPLEMENT();
1018     }
1019 
1020     // orbos 98-01-18: Objects By Value -- end
1021 
1022     /**
1023      * Creates an IDL <code>Any</code> object initialized to
1024      * contain a <code>Typecode</code> object whose <code>kind</code> field
1025      * is set to <code>TCKind.tc_null</code>.
1026      *
1027      * @return          a newly-created <code>Any</code> object
1028      */
1029     abstract public Any create_any();
1030 
1031 
1032 
1033 
1034     /**
1035      * Retrieves a <code>Current</code> object.
1036      * The <code>Current</code> interface is used to manage thread-specific
1037      * information for use by services such as transactions and security.
1038      *
1039      * @see <a href="package-summary.html#unimpl"><code>CORBA</code> package
1040      *      comments for unimplemented features</a>
1041      *
1042      * @return          a newly-created <code>Current</code> object
1043      * @deprecated      use <code>resolve_initial_references</code>.
1044      */
1045     @Deprecated
1046     public org.omg.CORBA.Current get_current()
1047     {
1048         throw new org.omg.CORBA.NO_IMPLEMENT();
1049     }
1050 
1051     /**
1052      * This operation blocks the current thread until the ORB has
1053      * completed the shutdown process, initiated when some thread calls
1054      * <code>shutdown</code>. It may be used by multiple threads which
1055      * get all notified when the ORB shuts down.
1056      *
1057      */
1058     public void run()
1059     {
1060         throw new org.omg.CORBA.NO_IMPLEMENT();
1061     }
1062 
1063     /**
1064      * Instructs the ORB to shut down, which causes all
1065      * object adapters to shut down, in preparation for destruction.<br>
1066      * If the <code>wait_for_completion</code> parameter
1067      * is true, this operation blocks until all ORB processing (including
1068      * processing of currently executing requests, object deactivation,
1069      * and other object adapter operations) has completed.
1070      * If an application does this in a thread that is currently servicing
1071      * an invocation, the <code>BAD_INV_ORDER</code> system exception
1072      * will be thrown with the OMG minor code 3,
1073      * since blocking would result in a deadlock.<br>
1074      * If the <code>wait_for_completion</code> parameter is <code>FALSE</code>,
1075      * then shutdown may not have completed upon return.<p>
1076      * While the ORB is in the process of shutting down, the ORB operates as normal,
1077      * servicing incoming and outgoing requests until all requests have been completed.
1078      * Once an ORB has shutdown, only object reference management operations
1079      * may be invoked on the ORB or any object reference obtained from it.
1080      * An application may also invoke the <code>destroy</code> operation on the ORB itself.
1081      * Invoking any other operation will throw the <code>BAD_INV_ORDER</code>
1082      * system exception with the OMG minor code 4.<p>
1083      * The <code>ORB.run</code> method will return after
1084      * <code>shutdown</code> has been called.
1085      *
1086      * @param wait_for_completion <code>true</code> if the call
1087      *        should block until the shutdown is complete;
1088      *        <code>false</code> if it should return immediately
1089      * @throws org.omg.CORBA.BAD_INV_ORDER if the current thread is servicing
1090      *         an invocation
1091      */
1092     public void shutdown(boolean wait_for_completion)
1093     {
1094         throw new org.omg.CORBA.NO_IMPLEMENT();
1095     }
1096 
1097     /**
1098      * Returns <code>true</code> if the ORB needs the main thread to
1099      * perform some work, and <code>false</code> if the ORB does not
1100      * need the main thread.
1101      *
1102      * @return <code>true</code> if there is work pending, meaning that the ORB
1103      *         needs the main thread to perform some work; <code>false</code>
1104      *         if there is no work pending and thus the ORB does not need the
1105      *         main thread
1106      *
1107      */
1108     public boolean work_pending()
1109     {
1110         throw new org.omg.CORBA.NO_IMPLEMENT();
1111     }
1112 
1113     /**
1114      * Performs an implementation-dependent unit of work if called
1115      * by the main thread. Otherwise it does nothing.
1116      * The methods <code>work_pending</code> and <code>perform_work</code>
1117      * can be used in
1118      * conjunction to implement a simple polling loop that multiplexes
1119      * the main thread among the ORB and other activities.
1120      *
1121      */
1122     public void perform_work()
1123     {
1124         throw new org.omg.CORBA.NO_IMPLEMENT();
1125     }
1126 
1127     /**
1128      * Used to obtain information about CORBA facilities and services
1129      * that are supported by this ORB. The service type for which
1130      * information is being requested is passed in as the in
1131      * parameter <tt>service_type</tt>, the values defined by
1132      * constants in the CORBA module. If service information is
1133      * available for that type, that is returned in the out parameter
1134      * <tt>service_info</tt>, and the operation returns the
1135      * value <tt>true</tt>. If no information for the requested
1136      * services type is available, the operation returns <tt>false</tt>
1137      *  (i.e., the service is not supported by this ORB).
1138      * <P>
1139      * @param service_type a <code>short</code> indicating the
1140      *        service type for which information is being requested
1141      * @param service_info a <code>ServiceInformationHolder</code> object
1142      *        that will hold the <code>ServiceInformation</code> object
1143      *        produced by this method
1144      * @return <code>true</code> if service information is available
1145      *        for the <tt>service_type</tt>;
1146      *         <tt>false</tt> if no information for the
1147      *         requested services type is available
1148      * @see <a href="package-summary.html#unimpl"><code>CORBA</code> package
1149      *      comments for unimplemented features</a>
1150      */
1151     public boolean get_service_information(short service_type,
1152                                            ServiceInformationHolder service_info)
1153     {
1154         throw new org.omg.CORBA.NO_IMPLEMENT();
1155     }
1156 
1157     // orbos 98-01-18: Objects By Value -- begin
1158 
1159     /**
1160      * Creates a new <code>DynAny</code> object from the given
1161      * <code>Any</code> object.
1162      * <P>
1163      * @param value the <code>Any</code> object from which to create a new
1164      *        <code>DynAny</code> object
1165      * @return the new <code>DynAny</code> object created from the given
1166      *         <code>Any</code> object
1167      * @see <a href="package-summary.html#unimpl"><code>CORBA</code> package
1168      *      comments for unimplemented features</a>
1169      * @deprecated Use the new <a href="../DynamicAny/DynAnyFactory.html">DynAnyFactory</a> API instead
1170      */
1171     @Deprecated
1172     public org.omg.CORBA.DynAny create_dyn_any(org.omg.CORBA.Any value)
1173     {
1174         throw new org.omg.CORBA.NO_IMPLEMENT();
1175     }
1176 
1177     /**
1178      * Creates a basic <code>DynAny</code> object from the given
1179      * <code>TypeCode</code> object.
1180      * <P>
1181      * @param type the <code>TypeCode</code> object from which to create a new
1182      *        <code>DynAny</code> object
1183      * @return the new <code>DynAny</code> object created from the given
1184      *         <code>TypeCode</code> object
1185      * @throws org.omg.CORBA.ORBPackage.InconsistentTypeCode if the given
1186      *         <code>TypeCode</code> object is not consistent with the operation.
1187      * @see <a href="package-summary.html#unimpl"><code>CORBA</code> package
1188      *      comments for unimplemented features</a>
1189      * @deprecated Use the new <a href="../DynamicAny/DynAnyFactory.html">DynAnyFactory</a> API instead
1190      */
1191     @Deprecated
1192     public org.omg.CORBA.DynAny create_basic_dyn_any(org.omg.CORBA.TypeCode type) throws org.omg.CORBA.ORBPackage.InconsistentTypeCode
1193     {
1194         throw new org.omg.CORBA.NO_IMPLEMENT();
1195     }
1196 
1197     /**
1198      * Creates a new <code>DynStruct</code> object from the given
1199      * <code>TypeCode</code> object.
1200      * <P>
1201      * @param type the <code>TypeCode</code> object from which to create a new
1202      *        <code>DynStruct</code> object
1203      * @return the new <code>DynStruct</code> object created from the given
1204      *         <code>TypeCode</code> object
1205      * @throws org.omg.CORBA.ORBPackage.InconsistentTypeCode if the given
1206      *         <code>TypeCode</code> object is not consistent with the operation.
1207      * @see <a href="package-summary.html#unimpl"><code>CORBA</code> package
1208      *      comments for unimplemented features</a>
1209      * @deprecated Use the new <a href="../DynamicAny/DynAnyFactory.html">DynAnyFactory</a> API instead
1210      */
1211     @Deprecated
1212     public org.omg.CORBA.DynStruct create_dyn_struct(org.omg.CORBA.TypeCode type) throws org.omg.CORBA.ORBPackage.InconsistentTypeCode
1213     {
1214         throw new org.omg.CORBA.NO_IMPLEMENT();
1215     }
1216 
1217     /**
1218      * Creates a new <code>DynSequence</code> object from the given
1219      * <code>TypeCode</code> object.
1220      * <P>
1221      * @param type the <code>TypeCode</code> object from which to create a new
1222      *        <code>DynSequence</code> object
1223      * @return the new <code>DynSequence</code> object created from the given
1224      *         <code>TypeCode</code> object
1225      * @throws org.omg.CORBA.ORBPackage.InconsistentTypeCode if the given
1226      *         <code>TypeCode</code> object is not consistent with the operation.
1227      * @see <a href="package-summary.html#unimpl"><code>CORBA</code> package
1228      *      comments for unimplemented features</a>
1229      * @deprecated Use the new <a href="../DynamicAny/DynAnyFactory.html">DynAnyFactory</a> API instead
1230      */
1231     @Deprecated
1232     public org.omg.CORBA.DynSequence create_dyn_sequence(org.omg.CORBA.TypeCode type) throws org.omg.CORBA.ORBPackage.InconsistentTypeCode
1233     {
1234         throw new org.omg.CORBA.NO_IMPLEMENT();
1235     }
1236 
1237 
1238     /**
1239      * Creates a new <code>DynArray</code> object from the given
1240      * <code>TypeCode</code> object.
1241      * <P>
1242      * @param type the <code>TypeCode</code> object from which to create a new
1243      *        <code>DynArray</code> object
1244      * @return the new <code>DynArray</code> object created from the given
1245      *         <code>TypeCode</code> object
1246      * @throws org.omg.CORBA.ORBPackage.InconsistentTypeCode if the given
1247      *         <code>TypeCode</code> object is not consistent with the operation.
1248      * @see <a href="package-summary.html#unimpl"><code>CORBA</code> package
1249      *      comments for unimplemented features</a>
1250      * @deprecated Use the new <a href="../DynamicAny/DynAnyFactory.html">DynAnyFactory</a> API instead
1251      */
1252     @Deprecated
1253     public org.omg.CORBA.DynArray create_dyn_array(org.omg.CORBA.TypeCode type) throws org.omg.CORBA.ORBPackage.InconsistentTypeCode
1254     {
1255         throw new org.omg.CORBA.NO_IMPLEMENT();
1256     }
1257 
1258     /**
1259      * Creates a new <code>DynUnion</code> object from the given
1260      * <code>TypeCode</code> object.
1261      * <P>
1262      * @param type the <code>TypeCode</code> object from which to create a new
1263      *        <code>DynUnion</code> object
1264      * @return the new <code>DynUnion</code> object created from the given
1265      *         <code>TypeCode</code> object
1266      * @throws org.omg.CORBA.ORBPackage.InconsistentTypeCode if the given
1267      *         <code>TypeCode</code> object is not consistent with the operation.
1268      * @see <a href="package-summary.html#unimpl"><code>CORBA</code> package
1269      *      comments for unimplemented features</a>
1270      * @deprecated Use the new <a href="../DynamicAny/DynAnyFactory.html">DynAnyFactory</a> API instead
1271      */
1272     @Deprecated
1273     public org.omg.CORBA.DynUnion create_dyn_union(org.omg.CORBA.TypeCode type) throws org.omg.CORBA.ORBPackage.InconsistentTypeCode
1274     {
1275         throw new org.omg.CORBA.NO_IMPLEMENT();
1276     }
1277 
1278     /**
1279      * Creates a new <code>DynEnum</code> object from the given
1280      * <code>TypeCode</code> object.
1281      * <P>
1282      * @param type the <code>TypeCode</code> object from which to create a new
1283      *        <code>DynEnum</code> object
1284      * @return the new <code>DynEnum</code> object created from the given
1285      *         <code>TypeCode</code> object
1286      * @throws org.omg.CORBA.ORBPackage.InconsistentTypeCode if the given
1287      *         <code>TypeCode</code> object is not consistent with the operation.
1288      * @see <a href="package-summary.html#unimpl"><code>CORBA</code> package
1289      *      comments for unimplemented features</a>
1290      * @deprecated Use the new <a href="../DynamicAny/DynAnyFactory.html">DynAnyFactory</a> API instead
1291      */
1292     @Deprecated
1293     public org.omg.CORBA.DynEnum create_dyn_enum(org.omg.CORBA.TypeCode type) throws org.omg.CORBA.ORBPackage.InconsistentTypeCode
1294     {
1295         throw new org.omg.CORBA.NO_IMPLEMENT();
1296     }
1297 
1298     /**
1299     * Can be invoked to create new instances of policy objects
1300     * of a specific type with specified initial state. If
1301     * <tt>create_policy</tt> fails to instantiate a new Policy
1302     * object due to its inability to interpret the requested type
1303     * and content of the policy, it raises the <tt>PolicyError</tt>
1304     * exception with the appropriate reason.
1305     * @param type the <tt>PolicyType</tt> of the policy object to
1306     *        be created
1307     * @param val the value that will be used to set the initial
1308     *        state of the <tt>Policy</tt> object that is created
1309     * @return Reference to a newly created <tt>Policy</tt> object
1310     *        of type specified by the <tt>type</tt> parameter and
1311     *        initialized to a state specified by the <tt>val</tt>
1312     *        parameter
1313     * @throws <tt>org.omg.CORBA.PolicyError</tt> when the requested
1314     *        policy is not supported or a requested initial state
1315     *        for the policy is not supported.
1316     */
1317     public org.omg.CORBA.Policy create_policy(int type, org.omg.CORBA.Any val)
1318         throws org.omg.CORBA.PolicyError
1319     {
1320         // Currently not implemented until PIORB.
1321         throw new org.omg.CORBA.NO_IMPLEMENT();
1322     }
1323 }