| /* |
| * Copyright (c) 1995, 2014, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. Oracle designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Oracle in the LICENSE file that accompanied this code. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| |
| package org.omg.CORBA; |
| |
| import org.omg.CORBA.portable.*; |
| import org.omg.CORBA.ORBPackage.InvalidName; |
| |
| import java.util.Properties; |
| import java.applet.Applet; |
| import java.io.File; |
| import java.io.FileInputStream; |
| |
| import java.security.AccessController; |
| import java.security.PrivilegedAction; |
| |
| import sun.reflect.misc.ReflectUtil; |
| |
| /** |
| * A class providing APIs for the CORBA Object Request Broker |
| * features. The <code>ORB</code> class also provides |
| * "pluggable ORB implementation" APIs that allow another vendor's ORB |
| * implementation to be used. |
| * <P> |
| * An ORB makes it possible for CORBA objects to communicate |
| * with each other by connecting objects making requests (clients) with |
| * objects servicing requests (servers). |
| * <P> |
| * |
| * The <code>ORB</code> class, which |
| * encapsulates generic CORBA functionality, does the following: |
| * (Note that items 5 and 6, which include most of the methods in |
| * the class <code>ORB</code>, are typically used with the <code>Dynamic Invocation |
| * Interface</code> (DII) and the <code>Dynamic Skeleton Interface</code> |
| * (DSI). |
| * These interfaces may be used by a developer directly, but |
| * most commonly they are used by the ORB internally and are |
| * not seen by the general programmer.) |
| * <OL> |
| * <li> initializes the ORB implementation by supplying values for |
| * predefined properties and environmental parameters |
| * <li> obtains initial object references to services such as |
| * the NameService using the method <code>resolve_initial_references</code> |
| * <li> converts object references to strings and back |
| * <li> connects the ORB to a servant (an instance of a CORBA object |
| * implementation) and disconnects the ORB from a servant |
| * <li> creates objects such as |
| * <ul> |
| * <li><code>TypeCode</code> |
| * <li><code>Any</code> |
| * <li><code>NamedValue</code> |
| * <li><code>Context</code> |
| * <li><code>Environment</code> |
| * <li>lists (such as <code>NVList</code>) containing these objects |
| * </ul> |
| * <li> sends multiple messages in the DII |
| * </OL> |
| * |
| * <P> |
| * The <code>ORB</code> class can be used to obtain references to objects |
| * implemented anywhere on the network. |
| * <P> |
| * An application or applet gains access to the CORBA environment |
| * by initializing itself into an <code>ORB</code> using one of |
| * three <code>init</code> methods. Two of the three methods use the properties |
| * (associations of a name with a value) shown in the |
| * table below.<BR> |
| * <TABLE BORDER=1 SUMMARY="Standard Java CORBA Properties"> |
| * <TR><TH>Property Name</TH> <TH>Property Value</TH></TR> |
| * <CAPTION>Standard Java CORBA Properties:</CAPTION> |
| * <TR><TD>org.omg.CORBA.ORBClass</TD> |
| * <TD>class name of an ORB implementation</TD></TR> |
| * <TR><TD>org.omg.CORBA.ORBSingletonClass</TD> |
| * <TD>class name of the ORB returned by <code>init()</code></TD></TR> |
| * </TABLE> |
| * <P> |
| * These properties allow a different vendor's <code>ORB</code> |
| * implementation to be "plugged in." |
| * <P> |
| * When an ORB instance is being created, the class name of the ORB |
| * implementation is located using |
| * the following standard search order:<P> |
| * |
| * <OL> |
| * <LI>check in Applet parameter or application string array, if any |
| * |
| * <LI>check in properties parameter, if any |
| * |
| * <LI>check in the System properties |
| * |
| * <LI>check in the orb.properties file located in the user.home |
| * directory (if any) |
| * |
| * <LI>check in the orb.properties file located in the java.home/lib |
| * directory (if any) |
| * |
| * <LI>fall back on a hardcoded default behavior (use the Java IDL |
| * implementation) |
| * </OL> |
| * <P> |
| * Note that Java IDL provides a default implementation for the |
| * fully-functional ORB and for the Singleton ORB. When the method |
| * <code>init</code> is given no parameters, the default Singleton |
| * ORB is returned. When the method <code>init</code> is given parameters |
| * but no ORB class is specified, the Java IDL ORB implementation |
| * is returned. |
| * <P> |
| * The following code fragment creates an <code>ORB</code> object |
| * initialized with the default ORB Singleton. |
| * This ORB has a |
| * restricted implementation to prevent malicious applets from doing |
| * anything beyond creating typecodes. |
| * It is called a singleton |
| * because there is only one instance for an entire virtual machine. |
| * <PRE> |
| * ORB orb = ORB.init(); |
| * </PRE> |
| * <P> |
| * The following code fragment creates an <code>ORB</code> object |
| * for an application. The parameter <code>args</code> |
| * represents the arguments supplied to the application's <code>main</code> |
| * method. Since the property specifies the ORB class to be |
| * "SomeORBImplementation", the new ORB will be initialized with |
| * that ORB implementation. If p had been null, |
| * and the arguments had not specified an ORB class, |
| * the new ORB would have been |
| * initialized with the default Java IDL implementation. |
| * <PRE> |
| * Properties p = new Properties(); |
| * p.put("org.omg.CORBA.ORBClass", "SomeORBImplementation"); |
| * ORB orb = ORB.init(args, p); |
| * </PRE> |
| * <P> |
| * The following code fragment creates an <code>ORB</code> object |
| * for the applet supplied as the first parameter. If the given |
| * applet does not specify an ORB class, the new ORB will be |
| * initialized with the default Java IDL implementation. |
| * <PRE> |
| * ORB orb = ORB.init(myApplet, null); |
| * </PRE> |
| * <P> |
| * An application or applet can be initialized in one or more ORBs. |
| * ORB initialization is a bootstrap call into the CORBA world. |
| * @since JDK1.2 |
| */ |
| abstract public class ORB { |
| |
| // |
| // This is the ORB implementation used when nothing else is specified. |
| // Whoever provides this class customizes this string to |
| // point at their ORB implementation. |
| // |
| private static final String ORBClassKey = "org.omg.CORBA.ORBClass"; |
| private static final String ORBSingletonClassKey = "org.omg.CORBA.ORBSingletonClass"; |
| |
| // |
| // The global instance of the singleton ORB implementation which |
| // acts as a factory for typecodes for generated Helper classes. |
| // TypeCodes should be immutable since they may be shared across |
| // different security contexts (applets). There should be no way to |
| // use a TypeCode as a storage depot for illicitly passing |
| // information or Java objects between different security contexts. |
| // |
| static private ORB singleton; |
| |
| // Get System property |
| private static String getSystemProperty(final String name) { |
| |
| // This will not throw a SecurityException because this |
| // class was loaded from rt.jar using the bootstrap classloader. |
| String propValue = (String) AccessController.doPrivileged( |
| new PrivilegedAction() { |
| public java.lang.Object run() { |
| return System.getProperty(name); |
| } |
| } |
| ); |
| |
| return propValue; |
| } |
| |
| // Get property from orb.properties in either <user.home> or <java-home>/lib |
| // directories. |
| private static String getPropertyFromFile(final String name) { |
| // This will not throw a SecurityException because this |
| // class was loaded from rt.jar using the bootstrap classloader. |
| |
| String propValue = (String) AccessController.doPrivileged( |
| new PrivilegedAction() { |
| private Properties getFileProperties( String fileName ) { |
| try { |
| File propFile = new File( fileName ) ; |
| if (!propFile.exists()) |
| return null ; |
| |
| Properties props = new Properties() ; |
| FileInputStream fis = new FileInputStream(propFile); |
| try { |
| props.load( fis ); |
| } finally { |
| fis.close() ; |
| } |
| |
| return props ; |
| } catch (Exception exc) { |
| return null ; |
| } |
| } |
| |
| public java.lang.Object run() { |
| String userHome = System.getProperty("user.home"); |
| String fileName = userHome + File.separator + |
| "orb.properties" ; |
| Properties props = getFileProperties( fileName ) ; |
| |
| if (props != null) { |
| String value = props.getProperty( name ) ; |
| if (value != null) |
| return value ; |
| } |
| |
| String javaHome = System.getProperty("java.home"); |
| fileName = javaHome + File.separator |
| + "lib" + File.separator + "orb.properties"; |
| props = getFileProperties( fileName ) ; |
| |
| if (props == null) |
| return null ; |
| else |
| return props.getProperty( name ) ; |
| } |
| } |
| ); |
| |
| return propValue; |
| } |
| |
| /** |
| * Returns the <code>ORB</code> singleton object. This method always returns the |
| * same ORB instance, which is an instance of the class described by the |
| * <code>org.omg.CORBA.ORBSingletonClass</code> system property. |
| * <P> |
| * This no-argument version of the method <code>init</code> is used primarily |
| * as a factory for <code>TypeCode</code> objects, which are used by |
| * <code>Helper</code> classes to implement the method <code>type</code>. |
| * It is also used to create <code>Any</code> objects that are used to |
| * describe <code>union</code> labels (as part of creating a <code> |
| * TypeCode</code> object for a <code>union</code>). |
| * <P> |
| * This method is not intended to be used by applets, and in the event |
| * that it is called in an applet environment, the ORB it returns |
| * is restricted so that it can be used only as a factory for |
| * <code>TypeCode</code> objects. Any <code>TypeCode</code> objects |
| * it produces can be safely shared among untrusted applets. |
| * <P> |
| * If an ORB is created using this method from an applet, |
| * a system exception will be thrown if |
| * methods other than those for |
| * creating <code>TypeCode</code> objects are invoked. |
| * |
| * @return the singleton ORB |
| */ |
| public static synchronized ORB init() { |
| if (singleton == null) { |
| String className = getSystemProperty(ORBSingletonClassKey); |
| if (className == null) |
| className = getPropertyFromFile(ORBSingletonClassKey); |
| if ((className == null) || |
| (className.equals("com.sun.corba.se.impl.orb.ORBSingleton"))) { |
| singleton = new com.sun.corba.se.impl.orb.ORBSingleton(); |
| } else { |
| singleton = create_impl(className); |
| } |
| } |
| return singleton; |
| } |
| |
| private static ORB create_impl(String className) { |
| ClassLoader cl = Thread.currentThread().getContextClassLoader(); |
| if (cl == null) |
| cl = ClassLoader.getSystemClassLoader(); |
| |
| try { |
| ReflectUtil.checkPackageAccess(className); |
| Class<org.omg.CORBA.ORB> orbBaseClass = org.omg.CORBA.ORB.class; |
| Class<?> orbClass = Class.forName(className, true, cl).asSubclass(orbBaseClass); |
| return (ORB)orbClass.newInstance(); |
| } catch (Throwable ex) { |
| SystemException systemException = new INITIALIZE( |
| "can't instantiate default ORB implementation " + className); |
| systemException.initCause(ex); |
| throw systemException; |
| } |
| } |
| |
| /** |
| * Creates a new <code>ORB</code> instance for a standalone |
| * application. This method may be called from applications |
| * only and returns a new fully functional <code>ORB</code> object |
| * each time it is called. |
| * @param args command-line arguments for the application's <code>main</code> |
| * method; may be <code>null</code> |
| * @param props application-specific properties; may be <code>null</code> |
| * @return the newly-created ORB instance |
| */ |
| public static ORB init(String[] args, Properties props) { |
| // |
| // Note that there is no standard command-line argument for |
| // specifying the default ORB implementation. For an |
| // application you can choose an implementation either by |
| // setting the CLASSPATH to pick a different org.omg.CORBA |
| // and it's baked-in ORB implementation default or by |
| // setting an entry in the properties object or in the |
| // system properties. |
| // |
| String className = null; |
| ORB orb; |
| |
| if (props != null) |
| className = props.getProperty(ORBClassKey); |
| if (className == null) |
| className = getSystemProperty(ORBClassKey); |
| if (className == null) |
| className = getPropertyFromFile(ORBClassKey); |
| if ((className == null) || |
| (className.equals("com.sun.corba.se.impl.orb.ORBImpl"))) { |
| orb = new com.sun.corba.se.impl.orb.ORBImpl(); |
| } else { |
| orb = create_impl(className); |
| } |
| orb.set_parameters(args, props); |
| return orb; |
| } |
| |
| |
| /** |
| * Creates a new <code>ORB</code> instance for an applet. This |
| * method may be called from applets only and returns a new |
| * fully-functional <code>ORB</code> object each time it is called. |
| * @param app the applet; may be <code>null</code> |
| * @param props applet-specific properties; may be <code>null</code> |
| * @return the newly-created ORB instance |
| */ |
| public static ORB init(Applet app, Properties props) { |
| String className; |
| ORB orb; |
| |
| className = app.getParameter(ORBClassKey); |
| if (className == null && props != null) |
| className = props.getProperty(ORBClassKey); |
| if (className == null) |
| className = getSystemProperty(ORBClassKey); |
| if (className == null) |
| className = getPropertyFromFile(ORBClassKey); |
| if ((className == null) || |
| (className.equals("com.sun.corba.se.impl.orb.ORBImpl"))) { |
| orb = new com.sun.corba.se.impl.orb.ORBImpl(); |
| } else { |
| orb = create_impl(className); |
| } |
| orb.set_parameters(app, props); |
| return orb; |
| } |
| |
| /** |
| * Allows the ORB implementation to be initialized with the given |
| * parameters and properties. This method, used in applications only, |
| * is implemented by subclass ORB implementations and called |
| * by the appropriate <code>init</code> method to pass in its parameters. |
| * |
| * @param args command-line arguments for the application's <code>main</code> |
| * method; may be <code>null</code> |
| * @param props application-specific properties; may be <code>null</code> |
| */ |
| abstract protected void set_parameters(String[] args, Properties props); |
| |
| /** |
| * Allows the ORB implementation to be initialized with the given |
| * applet and parameters. This method, used in applets only, |
| * is implemented by subclass ORB implementations and called |
| * by the appropriate <code>init</code> method to pass in its parameters. |
| * |
| * @param app the applet; may be <code>null</code> |
| * @param props applet-specific properties; may be <code>null</code> |
| */ |
| abstract protected void set_parameters(Applet app, Properties props); |
| |
| /** |
| * Connects the given servant object (a Java object that is |
| * an instance of the server implementation class) |
| * to the ORB. The servant class must |
| * extend the <code>ImplBase</code> class corresponding to the interface that is |
| * supported by the server. The servant must thus be a CORBA object |
| * reference, and inherit from <code>org.omg.CORBA.Object</code>. |
| * Servants created by the user can start receiving remote invocations |
| * after the method <code>connect</code> has been called. A servant may also be |
| * automatically and implicitly connected to the ORB if it is passed as |
| * an IDL parameter in an IDL method invocation on a non-local object, |
| * that is, if the servant object has to be marshalled and sent outside of the |
| * process address space. |
| * <P> |
| * Calling the method <code>connect</code> has no effect |
| * when the servant object is already connected to the ORB. |
| * <P> |
| * Deprecated by the OMG in favor of the Portable Object Adapter APIs. |
| * |
| * @param obj The servant object reference |
| */ |
| public void connect(org.omg.CORBA.Object obj) { |
| throw new NO_IMPLEMENT(); |
| } |
| |
| /** |
| * Destroys the ORB so that its resources can be reclaimed. |
| * Any operation invoked on a destroyed ORB reference will throw the |
| * <code>OBJECT_NOT_EXIST</code> exception. |
| * Once an ORB has been destroyed, another call to <code>init</code> |
| * with the same ORBid will return a reference to a newly constructed ORB.<p> |
| * If <code>destroy</code> is called on an ORB that has not been shut down, |
| * it will start the shut down process and block until the ORB has shut down |
| * before it destroys the ORB.<br> |
| * If an application calls <code>destroy</code> in a thread that is currently servicing |
| * an invocation, the <code>BAD_INV_ORDER</code> system exception will be thrown |
| * with the OMG minor code 3, since blocking would result in a deadlock.<p> |
| * For maximum portability and to avoid resource leaks, an application should |
| * always call <code>shutdown</code> and <code>destroy</code> |
| * on all ORB instances before exiting. |
| * |
| * @throws org.omg.CORBA.BAD_INV_ORDER if the current thread is servicing an invocation |
| */ |
| public void destroy( ) { |
| throw new NO_IMPLEMENT(); |
| } |
| |
| /** |
| * Disconnects the given servant object from the ORB. After this method returns, |
| * the ORB will reject incoming remote requests for the disconnected |
| * servant and will send the exception |
| * <code>org.omg.CORBA.OBJECT_NOT_EXIST</code> back to the |
| * remote client. Thus the object appears to be destroyed from the |
| * point of view of remote clients. Note, however, that local requests issued |
| * using the servant directly do not |
| * pass through the ORB; hence, they will continue to be processed by the |
| * servant. |
| * <P> |
| * Calling the method <code>disconnect</code> has no effect |
| * if the servant is not connected to the ORB. |
| * <P> |
| * Deprecated by the OMG in favor of the Portable Object Adapter APIs. |
| * |
| * @param obj The servant object to be disconnected from the ORB |
| */ |
| public void disconnect(org.omg.CORBA.Object obj) { |
| throw new NO_IMPLEMENT(); |
| } |
| |
| // |
| // ORB method implementations. |
| // |
| // We are trying to accomplish 2 things at once in this class. |
| // It can act as a default ORB implementation front-end, |
| // creating an actual ORB implementation object which is a |
| // subclass of this ORB class and then delegating the method |
| // implementations. |
| // |
| // To accomplish the delegation model, the 'delegate' private instance |
| // variable is set if an instance of this class is created directly. |
| // |
| |
| /** |
| * Returns a list of the initially available CORBA object references, |
| * such as "NameService" and "InterfaceRepository". |
| * |
| * @return an array of <code>String</code> objects that represent |
| * the object references for CORBA services |
| * that are initially available with this ORB |
| */ |
| abstract public String[] list_initial_services(); |
| |
| /** |
| * Resolves a specific object reference from the set of available |
| * initial service names. |
| * |
| * @param object_name the name of the initial service as a string |
| * @return the object reference associated with the given name |
| * @exception InvalidName if the given name is not associated with a |
| * known service |
| */ |
| abstract public org.omg.CORBA.Object resolve_initial_references(String object_name) |
| throws InvalidName; |
| |
| /** |
| * Converts the given CORBA object reference to a string. |
| * Note that the format of this string is predefined by IIOP, allowing |
| * strings generated by a different ORB to be converted back into an object |
| * reference. |
| * <P> |
| * The resulting <code>String</code> object may be stored or communicated |
| * in any way that a <code>String</code> object can be manipulated. |
| * |
| * @param obj the object reference to stringify |
| * @return the string representing the object reference |
| */ |
| abstract public String object_to_string(org.omg.CORBA.Object obj); |
| |
| /** |
| * Converts a string produced by the method <code>object_to_string</code> |
| * back to a CORBA object reference. |
| * |
| * @param str the string to be converted back to an object reference. It must |
| * be the result of converting an object reference to a string using the |
| * method <code>object_to_string</code>. |
| * @return the object reference |
| */ |
| abstract public org.omg.CORBA.Object string_to_object(String str); |
| |
| /** |
| * Allocates an <code>NVList</code> with (probably) enough |
| * space for the specified number of <code>NamedValue</code> objects. |
| * Note that the specified size is only a hint to help with |
| * storage allocation and does not imply the maximum size of the list. |
| * |
| * @param count suggested number of <code>NamedValue</code> objects for |
| * which to allocate space |
| * @return the newly-created <code>NVList</code> |
| * |
| * @see NVList |
| */ |
| abstract public NVList create_list(int count); |
| |
| /** |
| * Creates an <code>NVList</code> initialized with argument |
| * descriptions for the operation described in the given |
| * <code>OperationDef</code> object. This <code>OperationDef</code> object |
| * is obtained from an Interface Repository. The arguments in the |
| * returned <code>NVList</code> object are in the same order as in the |
| * original IDL operation definition, which makes it possible for the list |
| * to be used in dynamic invocation requests. |
| * |
| * @param oper the <code>OperationDef</code> object to use to create the list |
| * @return a newly-created <code>NVList</code> object containing |
| * descriptions of the arguments to the method described in the given |
| * <code>OperationDef</code> object |
| * |
| * @see NVList |
| */ |
| public NVList create_operation_list(org.omg.CORBA.Object oper) |
| { |
| // If we came here, it means that the actual ORB implementation |
| // did not have a create_operation_list(...CORBA.Object oper) method, |
| // so lets check if it has a create_operation_list(OperationDef oper) |
| // method. |
| try { |
| // First try to load the OperationDef class |
| String opDefClassName = "org.omg.CORBA.OperationDef"; |
| Class<?> opDefClass = null; |
| |
| ClassLoader cl = Thread.currentThread().getContextClassLoader(); |
| if ( cl == null ) |
| cl = ClassLoader.getSystemClassLoader(); |
| // if this throws a ClassNotFoundException, it will be caught below. |
| opDefClass = Class.forName(opDefClassName, true, cl); |
| |
| // OK, we loaded OperationDef. Now try to get the |
| // create_operation_list(OperationDef oper) method. |
| Class<?>[] argc = { opDefClass }; |
| java.lang.reflect.Method meth = |
| this.getClass().getMethod("create_operation_list", argc); |
| |
| // OK, the method exists, so invoke it and be happy. |
| java.lang.Object[] argx = { oper }; |
| return (org.omg.CORBA.NVList)meth.invoke(this, argx); |
| } |
| catch( java.lang.reflect.InvocationTargetException exs ) { |
| Throwable t = exs.getTargetException(); |
| if (t instanceof Error) { |
| throw (Error) t; |
| } |
| else if (t instanceof RuntimeException) { |
| throw (RuntimeException) t; |
| } |
| else { |
| throw new org.omg.CORBA.NO_IMPLEMENT(); |
| } |
| } |
| catch( RuntimeException ex ) { |
| throw ex; |
| } |
| catch( Exception exr ) { |
| throw new org.omg.CORBA.NO_IMPLEMENT(); |
| } |
| } |
| |
| |
| /** |
| * Creates a <code>NamedValue</code> object |
| * using the given name, value, and argument mode flags. |
| * <P> |
| * A <code>NamedValue</code> object serves as (1) a parameter or return |
| * value or (2) a context property. |
| * It may be used by itself or |
| * as an element in an <code>NVList</code> object. |
| * |
| * @param s the name of the <code>NamedValue</code> object |
| * @param any the <code>Any</code> value to be inserted into the |
| * <code>NamedValue</code> object |
| * @param flags the argument mode flags for the <code>NamedValue</code>: one of |
| * <code>ARG_IN.value</code>, <code>ARG_OUT.value</code>, |
| * or <code>ARG_INOUT.value</code>. |
| * |
| * @return the newly-created <code>NamedValue</code> object |
| * @see NamedValue |
| */ |
| abstract public NamedValue create_named_value(String s, Any any, int flags); |
| |
| /** |
| * Creates an empty <code>ExceptionList</code> object. |
| * |
| * @return the newly-created <code>ExceptionList</code> object |
| */ |
| abstract public ExceptionList create_exception_list(); |
| |
| /** |
| * Creates an empty <code>ContextList</code> object. |
| * |
| * @return the newly-created <code>ContextList</code> object |
| * @see ContextList |
| * @see Context |
| */ |
| abstract public ContextList create_context_list(); |
| |
| /** |
| * Gets the default <code>Context</code> object. |
| * |
| * @return the default <code>Context</code> object |
| * @see Context |
| */ |
| abstract public Context get_default_context(); |
| |
| /** |
| * Creates an <code>Environment</code> object. |
| * |
| * @return the newly-created <code>Environment</code> object |
| * @see Environment |
| */ |
| abstract public Environment create_environment(); |
| |
| /** |
| * Creates a new <code>org.omg.CORBA.portable.OutputStream</code> into which |
| * IDL method parameters can be marshalled during method invocation. |
| * @return the newly-created |
| * <code>org.omg.CORBA.portable.OutputStream</code> object |
| */ |
| abstract public org.omg.CORBA.portable.OutputStream create_output_stream(); |
| |
| /** |
| * Sends multiple dynamic (DII) requests asynchronously without expecting |
| * any responses. Note that oneway invocations are not guaranteed to |
| * reach the server. |
| * |
| * @param req an array of request objects |
| */ |
| abstract public void send_multiple_requests_oneway(Request[] req); |
| |
| /** |
| * Sends multiple dynamic (DII) requests asynchronously. |
| * |
| * @param req an array of <code>Request</code> objects |
| */ |
| abstract public void send_multiple_requests_deferred(Request[] req); |
| |
| /** |
| * Finds out if any of the deferred (asynchronous) invocations have |
| * a response yet. |
| * @return <code>true</code> if there is a response available; |
| * <code> false</code> otherwise |
| */ |
| abstract public boolean poll_next_response(); |
| |
| /** |
| * Gets the next <code>Request</code> instance for which a response |
| * has been received. |
| * |
| * @return the next <code>Request</code> object ready with a response |
| * @exception WrongTransaction if the method <code>get_next_response</code> |
| * is called from a transaction scope different |
| * from the one from which the original request was sent. See the |
| * OMG Transaction Service specification for details. |
| */ |
| abstract public Request get_next_response() throws WrongTransaction; |
| |
| /** |
| * Retrieves the <code>TypeCode</code> object that represents |
| * the given primitive IDL type. |
| * |
| * @param tcKind the <code>TCKind</code> instance corresponding to the |
| * desired primitive type |
| * @return the requested <code>TypeCode</code> object |
| */ |
| abstract public TypeCode get_primitive_tc(TCKind tcKind); |
| |
| /** |
| * Creates a <code>TypeCode</code> object representing an IDL <code>struct</code>. |
| * The <code>TypeCode</code> object is initialized with the given id, |
| * name, and members. |
| * |
| * @param id the repository id for the <code>struct</code> |
| * @param name the name of the <code>struct</code> |
| * @param members an array describing the members of the <code>struct</code> |
| * @return a newly-created <code>TypeCode</code> object describing |
| * an IDL <code>struct</code> |
| */ |
| abstract public TypeCode create_struct_tc(String id, String name, |
| StructMember[] members); |
| |
| /** |
| * Creates a <code>TypeCode</code> object representing an IDL <code>union</code>. |
| * The <code>TypeCode</code> object is initialized with the given id, |
| * name, discriminator type, and members. |
| * |
| * @param id the repository id of the <code>union</code> |
| * @param name the name of the <code>union</code> |
| * @param discriminator_type the type of the <code>union</code> discriminator |
| * @param members an array describing the members of the <code>union</code> |
| * @return a newly-created <code>TypeCode</code> object describing |
| * an IDL <code>union</code> |
| */ |
| abstract public TypeCode create_union_tc(String id, String name, |
| TypeCode discriminator_type, |
| UnionMember[] members); |
| |
| /** |
| * Creates a <code>TypeCode</code> object representing an IDL <code>enum</code>. |
| * The <code>TypeCode</code> object is initialized with the given id, |
| * name, and members. |
| * |
| * @param id the repository id for the <code>enum</code> |
| * @param name the name for the <code>enum</code> |
| * @param members an array describing the members of the <code>enum</code> |
| * @return a newly-created <code>TypeCode</code> object describing |
| * an IDL <code>enum</code> |
| */ |
| abstract public TypeCode create_enum_tc(String id, String name, String[] members); |
| |
| /** |
| * Creates a <code>TypeCode</code> object representing an IDL <code>alias</code> |
| * (<code>typedef</code>). |
| * The <code>TypeCode</code> object is initialized with the given id, |
| * name, and original type. |
| * |
| * @param id the repository id for the alias |
| * @param name the name for the alias |
| * @param original_type |
| * the <code>TypeCode</code> object describing the original type |
| * for which this is an alias |
| * @return a newly-created <code>TypeCode</code> object describing |
| * an IDL <code>alias</code> |
| */ |
| abstract public TypeCode create_alias_tc(String id, String name, |
| TypeCode original_type); |
| |
| /** |
| * Creates a <code>TypeCode</code> object representing an IDL <code>exception</code>. |
| * The <code>TypeCode</code> object is initialized with the given id, |
| * name, and members. |
| * |
| * @param id the repository id for the <code>exception</code> |
| * @param name the name for the <code>exception</code> |
| * @param members an array describing the members of the <code>exception</code> |
| * @return a newly-created <code>TypeCode</code> object describing |
| * an IDL <code>exception</code> |
| */ |
| abstract public TypeCode create_exception_tc(String id, String name, |
| StructMember[] members); |
| |
| /** |
| * Creates a <code>TypeCode</code> object representing an IDL <code>interface</code>. |
| * The <code>TypeCode</code> object is initialized with the given id |
| * and name. |
| * |
| * @param id the repository id for the interface |
| * @param name the name for the interface |
| * @return a newly-created <code>TypeCode</code> object describing |
| * an IDL <code>interface</code> |
| */ |
| |
| abstract public TypeCode create_interface_tc(String id, String name); |
| |
| /** |
| * Creates a <code>TypeCode</code> object representing a bounded IDL |
| * <code>string</code>. |
| * The <code>TypeCode</code> object is initialized with the given bound, |
| * which represents the maximum length of the string. Zero indicates |
| * that the string described by this type code is unbounded. |
| * |
| * @param bound the bound for the <code>string</code>; cannot be negative |
| * @return a newly-created <code>TypeCode</code> object describing |
| * a bounded IDL <code>string</code> |
| * @exception BAD_PARAM if bound is a negative value |
| */ |
| |
| abstract public TypeCode create_string_tc(int bound); |
| |
| /** |
| * Creates a <code>TypeCode</code> object representing a bounded IDL |
| * <code>wstring</code> (wide string). |
| * The <code>TypeCode</code> object is initialized with the given bound, |
| * which represents the maximum length of the wide string. Zero indicates |
| * that the string described by this type code is unbounded. |
| * |
| * @param bound the bound for the <code>wstring</code>; cannot be negative |
| * @return a newly-created <code>TypeCode</code> object describing |
| * a bounded IDL <code>wstring</code> |
| * @exception BAD_PARAM if bound is a negative value |
| */ |
| abstract public TypeCode create_wstring_tc(int bound); |
| |
| /** |
| * Creates a <code>TypeCode</code> object representing an IDL <code>sequence</code>. |
| * The <code>TypeCode</code> object is initialized with the given bound and |
| * element type. |
| * |
| * @param bound the bound for the <code>sequence</code>, 0 if unbounded |
| * @param element_type |
| * the <code>TypeCode</code> object describing the elements |
| * contained in the <code>sequence</code> |
| * @return a newly-created <code>TypeCode</code> object describing |
| * an IDL <code>sequence</code> |
| */ |
| abstract public TypeCode create_sequence_tc(int bound, TypeCode element_type); |
| |
| /** |
| * Creates a <code>TypeCode</code> object representing a |
| * a recursive IDL <code>sequence</code>. |
| * <P> |
| * For the IDL <code>struct</code> Node in following code fragment, |
| * the offset parameter for creating its sequence would be 1: |
| * <PRE> |
| * Struct Node { |
| * long value; |
| * Sequence <Node> subnodes; |
| * }; |
| * </PRE> |
| * |
| * @param bound the bound for the sequence, 0 if unbounded |
| * @param offset the index to the enclosing <code>TypeCode</code> object |
| * that describes the elements of this sequence |
| * @return a newly-created <code>TypeCode</code> object describing |
| * a recursive sequence |
| * @deprecated Use a combination of create_recursive_tc and create_sequence_tc instead |
| * @see #create_recursive_tc(String) create_recursive_tc |
| * @see #create_sequence_tc(int, TypeCode) create_sequence_tc |
| */ |
| @Deprecated |
| abstract public TypeCode create_recursive_sequence_tc(int bound, int offset); |
| |
| /** |
| * Creates a <code>TypeCode</code> object representing an IDL <code>array</code>. |
| * The <code>TypeCode</code> object is initialized with the given length and |
| * element type. |
| * |
| * @param length the length of the <code>array</code> |
| * @param element_type a <code>TypeCode</code> object describing the type |
| * of element contained in the <code>array</code> |
| * @return a newly-created <code>TypeCode</code> object describing |
| * an IDL <code>array</code> |
| */ |
| abstract public TypeCode create_array_tc(int length, TypeCode element_type); |
| |
| /** |
| * Create a <code>TypeCode</code> object for an IDL native type. |
| * |
| * @param id the logical id for the native type. |
| * @param name the name of the native type. |
| * @return the requested TypeCode. |
| */ |
| public org.omg.CORBA.TypeCode create_native_tc(String id, |
| String name) |
| { |
| throw new org.omg.CORBA.NO_IMPLEMENT(); |
| } |
| |
| /** |
| * Create a <code>TypeCode</code> object for an IDL abstract interface. |
| * |
| * @param id the logical id for the abstract interface type. |
| * @param name the name of the abstract interface type. |
| * @return the requested TypeCode. |
| */ |
| public org.omg.CORBA.TypeCode create_abstract_interface_tc( |
| String id, |
| String name) |
| { |
| throw new org.omg.CORBA.NO_IMPLEMENT(); |
| } |
| |
| |
| /** |
| * Create a <code>TypeCode</code> object for an IDL fixed type. |
| * |
| * @param digits specifies the total number of decimal digits in the number |
| * and must be from 1 to 31 inclusive. |
| * @param scale specifies the position of the decimal point. |
| * @return the requested TypeCode. |
| */ |
| public org.omg.CORBA.TypeCode create_fixed_tc(short digits, short scale) |
| { |
| throw new org.omg.CORBA.NO_IMPLEMENT(); |
| } |
| |
| |
| // orbos 98-01-18: Objects By Value -- begin |
| |
| |
| /** |
| * Create a <code>TypeCode</code> object for an IDL value type. |
| * The concrete_base parameter is the TypeCode for the immediate |
| * concrete valuetype base of the valuetype for which the TypeCode |
| * is being created. |
| * It may be null if the valuetype does not have a concrete base. |
| * |
| * @param id the logical id for the value type. |
| * @param name the name of the value type. |
| * @param type_modifier one of the value type modifier constants: |
| * VM_NONE, VM_CUSTOM, VM_ABSTRACT or VM_TRUNCATABLE |
| * @param concrete_base a <code>TypeCode</code> object |
| * describing the concrete valuetype base |
| * @param members an array containing the members of the value type |
| * @return the requested TypeCode |
| */ |
| public org.omg.CORBA.TypeCode create_value_tc(String id, |
| String name, |
| short type_modifier, |
| TypeCode concrete_base, |
| ValueMember[] members) |
| { |
| throw new org.omg.CORBA.NO_IMPLEMENT(); |
| } |
| |
| /** |
| * Create a recursive <code>TypeCode</code> object which |
| * serves as a placeholder for a concrete TypeCode during the process of creating |
| * TypeCodes which contain recursion. The id parameter specifies the repository id of |
| * the type for which the recursive TypeCode is serving as a placeholder. Once the |
| * recursive TypeCode has been properly embedded in the enclosing TypeCode which |
| * corresponds to the specified repository id, it will function as a normal TypeCode. |
| * Invoking operations on the recursive TypeCode before it has been embedded in the |
| * enclosing TypeCode will result in a <code>BAD_TYPECODE</code> exception. |
| * <P> |
| * For example, the following IDL type declaration contains recursion: |
| * <PRE> |
| * Struct Node { |
| * Sequence<Node> subnodes; |
| * }; |
| * </PRE> |
| * <P> |
| * To create a TypeCode for struct Node, you would invoke the TypeCode creation |
| * operations as shown below: |
| * <PRE> |
| * String nodeID = "IDL:Node:1.0"; |
| * TypeCode recursiveSeqTC = orb.create_sequence_tc(0, orb.create_recursive_tc(nodeID)); |
| * StructMember[] members = { new StructMember("subnodes", recursiveSeqTC, null) }; |
| * TypeCode structNodeTC = orb.create_struct_tc(nodeID, "Node", members); |
| * </PRE> |
| * <P> |
| * Also note that the following is an illegal IDL type declaration: |
| * <PRE> |
| * Struct Node { |
| * Node next; |
| * }; |
| * </PRE> |
| * <P> |
| * Recursive types can only appear within sequences which can be empty. |
| * That way marshaling problems, when transmitting the struct in an Any, are avoided. |
| * <P> |
| * @param id the logical id of the referenced type |
| * @return the requested TypeCode |
| */ |
| public org.omg.CORBA.TypeCode create_recursive_tc(String id) { |
| // implemented in subclass |
| throw new org.omg.CORBA.NO_IMPLEMENT(); |
| } |
| |
| /** |
| * Creates a <code>TypeCode</code> object for an IDL value box. |
| * |
| * @param id the logical id for the value type |
| * @param name the name of the value type |
| * @param boxed_type the TypeCode for the type |
| * @return the requested TypeCode |
| */ |
| public org.omg.CORBA.TypeCode create_value_box_tc(String id, |
| String name, |
| TypeCode boxed_type) |
| { |
| // implemented in subclass |
| throw new org.omg.CORBA.NO_IMPLEMENT(); |
| } |
| |
| // orbos 98-01-18: Objects By Value -- end |
| |
| /** |
| * Creates an IDL <code>Any</code> object initialized to |
| * contain a <code>Typecode</code> object whose <code>kind</code> field |
| * is set to <code>TCKind.tc_null</code>. |
| * |
| * @return a newly-created <code>Any</code> object |
| */ |
| abstract public Any create_any(); |
| |
| |
| |
| |
| /** |
| * Retrieves a <code>Current</code> object. |
| * The <code>Current</code> interface is used to manage thread-specific |
| * information for use by services such as transactions and security. |
| * |
| * @see <a href="package-summary.html#unimpl"><code>CORBA</code> package |
| * comments for unimplemented features</a> |
| * |
| * @return a newly-created <code>Current</code> object |
| * @deprecated use <code>resolve_initial_references</code>. |
| */ |
| @Deprecated |
| public org.omg.CORBA.Current get_current() |
| { |
| throw new org.omg.CORBA.NO_IMPLEMENT(); |
| } |
| |
| /** |
| * This operation blocks the current thread until the ORB has |
| * completed the shutdown process, initiated when some thread calls |
| * <code>shutdown</code>. It may be used by multiple threads which |
| * get all notified when the ORB shuts down. |
| * |
| */ |
| public void run() |
| { |
| throw new org.omg.CORBA.NO_IMPLEMENT(); |
| } |
| |
| /** |
| * Instructs the ORB to shut down, which causes all |
| * object adapters to shut down, in preparation for destruction.<br> |
| * If the <code>wait_for_completion</code> parameter |
| * is true, this operation blocks until all ORB processing (including |
| * processing of currently executing requests, object deactivation, |
| * and other object adapter operations) has completed. |
| * If an application does this in a thread that is currently servicing |
| * an invocation, the <code>BAD_INV_ORDER</code> system exception |
| * will be thrown with the OMG minor code 3, |
| * since blocking would result in a deadlock.<br> |
| * If the <code>wait_for_completion</code> parameter is <code>FALSE</code>, |
| * then shutdown may not have completed upon return.<p> |
| * While the ORB is in the process of shutting down, the ORB operates as normal, |
| * servicing incoming and outgoing requests until all requests have been completed. |
| * Once an ORB has shutdown, only object reference management operations |
| * may be invoked on the ORB or any object reference obtained from it. |
| * An application may also invoke the <code>destroy</code> operation on the ORB itself. |
| * Invoking any other operation will throw the <code>BAD_INV_ORDER</code> |
| * system exception with the OMG minor code 4.<p> |
| * The <code>ORB.run</code> method will return after |
| * <code>shutdown</code> has been called. |
| * |
| * @param wait_for_completion <code>true</code> if the call |
| * should block until the shutdown is complete; |
| * <code>false</code> if it should return immediately |
| * @throws org.omg.CORBA.BAD_INV_ORDER if the current thread is servicing |
| * an invocation |
| */ |
| public void shutdown(boolean wait_for_completion) |
| { |
| throw new org.omg.CORBA.NO_IMPLEMENT(); |
| } |
| |
| /** |
| * Returns <code>true</code> if the ORB needs the main thread to |
| * perform some work, and <code>false</code> if the ORB does not |
| * need the main thread. |
| * |
| * @return <code>true</code> if there is work pending, meaning that the ORB |
| * needs the main thread to perform some work; <code>false</code> |
| * if there is no work pending and thus the ORB does not need the |
| * main thread |
| * |
| */ |
| public boolean work_pending() |
| { |
| throw new org.omg.CORBA.NO_IMPLEMENT(); |
| } |
| |
| /** |
| * Performs an implementation-dependent unit of work if called |
| * by the main thread. Otherwise it does nothing. |
| * The methods <code>work_pending</code> and <code>perform_work</code> |
| * can be used in |
| * conjunction to implement a simple polling loop that multiplexes |
| * the main thread among the ORB and other activities. |
| * |
| */ |
| public void perform_work() |
| { |
| throw new org.omg.CORBA.NO_IMPLEMENT(); |
| } |
| |
| /** |
| * Used to obtain information about CORBA facilities and services |
| * that are supported by this ORB. The service type for which |
| * information is being requested is passed in as the in |
| * parameter <tt>service_type</tt>, the values defined by |
| * constants in the CORBA module. If service information is |
| * available for that type, that is returned in the out parameter |
| * <tt>service_info</tt>, and the operation returns the |
| * value <tt>true</tt>. If no information for the requested |
| * services type is available, the operation returns <tt>false</tt> |
| * (i.e., the service is not supported by this ORB). |
| * <P> |
| * @param service_type a <code>short</code> indicating the |
| * service type for which information is being requested |
| * @param service_info a <code>ServiceInformationHolder</code> object |
| * that will hold the <code>ServiceInformation</code> object |
| * produced by this method |
| * @return <code>true</code> if service information is available |
| * for the <tt>service_type</tt>; |
| * <tt>false</tt> if no information for the |
| * requested services type is available |
| * @see <a href="package-summary.html#unimpl"><code>CORBA</code> package |
| * comments for unimplemented features</a> |
| */ |
| public boolean get_service_information(short service_type, |
| ServiceInformationHolder service_info) |
| { |
| throw new org.omg.CORBA.NO_IMPLEMENT(); |
| } |
| |
| // orbos 98-01-18: Objects By Value -- begin |
| |
| /** |
| * Creates a new <code>DynAny</code> object from the given |
| * <code>Any</code> object. |
| * <P> |
| * @param value the <code>Any</code> object from which to create a new |
| * <code>DynAny</code> object |
| * @return the new <code>DynAny</code> object created from the given |
| * <code>Any</code> object |
| * @see <a href="package-summary.html#unimpl"><code>CORBA</code> package |
| * comments for unimplemented features</a> |
| * @deprecated Use the new <a href="../DynamicAny/DynAnyFactory.html">DynAnyFactory</a> API instead |
| */ |
| @Deprecated |
| public org.omg.CORBA.DynAny create_dyn_any(org.omg.CORBA.Any value) |
| { |
| throw new org.omg.CORBA.NO_IMPLEMENT(); |
| } |
| |
| /** |
| * Creates a basic <code>DynAny</code> object from the given |
| * <code>TypeCode</code> object. |
| * <P> |
| * @param type the <code>TypeCode</code> object from which to create a new |
| * <code>DynAny</code> object |
| * @return the new <code>DynAny</code> object created from the given |
| * <code>TypeCode</code> object |
| * @throws org.omg.CORBA.ORBPackage.InconsistentTypeCode if the given |
| * <code>TypeCode</code> object is not consistent with the operation. |
| * @see <a href="package-summary.html#unimpl"><code>CORBA</code> package |
| * comments for unimplemented features</a> |
| * @deprecated Use the new <a href="../DynamicAny/DynAnyFactory.html">DynAnyFactory</a> API instead |
| */ |
| @Deprecated |
| public org.omg.CORBA.DynAny create_basic_dyn_any(org.omg.CORBA.TypeCode type) throws org.omg.CORBA.ORBPackage.InconsistentTypeCode |
| { |
| throw new org.omg.CORBA.NO_IMPLEMENT(); |
| } |
| |
| /** |
| * Creates a new <code>DynStruct</code> object from the given |
| * <code>TypeCode</code> object. |
| * <P> |
| * @param type the <code>TypeCode</code> object from which to create a new |
| * <code>DynStruct</code> object |
| * @return the new <code>DynStruct</code> object created from the given |
| * <code>TypeCode</code> object |
| * @throws org.omg.CORBA.ORBPackage.InconsistentTypeCode if the given |
| * <code>TypeCode</code> object is not consistent with the operation. |
| * @see <a href="package-summary.html#unimpl"><code>CORBA</code> package |
| * comments for unimplemented features</a> |
| * @deprecated Use the new <a href="../DynamicAny/DynAnyFactory.html">DynAnyFactory</a> API instead |
| */ |
| @Deprecated |
| public org.omg.CORBA.DynStruct create_dyn_struct(org.omg.CORBA.TypeCode type) throws org.omg.CORBA.ORBPackage.InconsistentTypeCode |
| { |
| throw new org.omg.CORBA.NO_IMPLEMENT(); |
| } |
| |
| /** |
| * Creates a new <code>DynSequence</code> object from the given |
| * <code>TypeCode</code> object. |
| * <P> |
| * @param type the <code>TypeCode</code> object from which to create a new |
| * <code>DynSequence</code> object |
| * @return the new <code>DynSequence</code> object created from the given |
| * <code>TypeCode</code> object |
| * @throws org.omg.CORBA.ORBPackage.InconsistentTypeCode if the given |
| * <code>TypeCode</code> object is not consistent with the operation. |
| * @see <a href="package-summary.html#unimpl"><code>CORBA</code> package |
| * comments for unimplemented features</a> |
| * @deprecated Use the new <a href="../DynamicAny/DynAnyFactory.html">DynAnyFactory</a> API instead |
| */ |
| @Deprecated |
| public org.omg.CORBA.DynSequence create_dyn_sequence(org.omg.CORBA.TypeCode type) throws org.omg.CORBA.ORBPackage.InconsistentTypeCode |
| { |
| throw new org.omg.CORBA.NO_IMPLEMENT(); |
| } |
| |
| |
| /** |
| * Creates a new <code>DynArray</code> object from the given |
| * <code>TypeCode</code> object. |
| * <P> |
| * @param type the <code>TypeCode</code> object from which to create a new |
| * <code>DynArray</code> object |
| * @return the new <code>DynArray</code> object created from the given |
| * <code>TypeCode</code> object |
| * @throws org.omg.CORBA.ORBPackage.InconsistentTypeCode if the given |
| * <code>TypeCode</code> object is not consistent with the operation. |
| * @see <a href="package-summary.html#unimpl"><code>CORBA</code> package |
| * comments for unimplemented features</a> |
| * @deprecated Use the new <a href="../DynamicAny/DynAnyFactory.html">DynAnyFactory</a> API instead |
| */ |
| @Deprecated |
| public org.omg.CORBA.DynArray create_dyn_array(org.omg.CORBA.TypeCode type) throws org.omg.CORBA.ORBPackage.InconsistentTypeCode |
| { |
| throw new org.omg.CORBA.NO_IMPLEMENT(); |
| } |
| |
| /** |
| * Creates a new <code>DynUnion</code> object from the given |
| * <code>TypeCode</code> object. |
| * <P> |
| * @param type the <code>TypeCode</code> object from which to create a new |
| * <code>DynUnion</code> object |
| * @return the new <code>DynUnion</code> object created from the given |
| * <code>TypeCode</code> object |
| * @throws org.omg.CORBA.ORBPackage.InconsistentTypeCode if the given |
| * <code>TypeCode</code> object is not consistent with the operation. |
| * @see <a href="package-summary.html#unimpl"><code>CORBA</code> package |
| * comments for unimplemented features</a> |
| * @deprecated Use the new <a href="../DynamicAny/DynAnyFactory.html">DynAnyFactory</a> API instead |
| */ |
| @Deprecated |
| public org.omg.CORBA.DynUnion create_dyn_union(org.omg.CORBA.TypeCode type) throws org.omg.CORBA.ORBPackage.InconsistentTypeCode |
| { |
| throw new org.omg.CORBA.NO_IMPLEMENT(); |
| } |
| |
| /** |
| * Creates a new <code>DynEnum</code> object from the given |
| * <code>TypeCode</code> object. |
| * <P> |
| * @param type the <code>TypeCode</code> object from which to create a new |
| * <code>DynEnum</code> object |
| * @return the new <code>DynEnum</code> object created from the given |
| * <code>TypeCode</code> object |
| * @throws org.omg.CORBA.ORBPackage.InconsistentTypeCode if the given |
| * <code>TypeCode</code> object is not consistent with the operation. |
| * @see <a href="package-summary.html#unimpl"><code>CORBA</code> package |
| * comments for unimplemented features</a> |
| * @deprecated Use the new <a href="../DynamicAny/DynAnyFactory.html">DynAnyFactory</a> API instead |
| */ |
| @Deprecated |
| public org.omg.CORBA.DynEnum create_dyn_enum(org.omg.CORBA.TypeCode type) throws org.omg.CORBA.ORBPackage.InconsistentTypeCode |
| { |
| throw new org.omg.CORBA.NO_IMPLEMENT(); |
| } |
| |
| /** |
| * Can be invoked to create new instances of policy objects |
| * of a specific type with specified initial state. If |
| * <tt>create_policy</tt> fails to instantiate a new Policy |
| * object due to its inability to interpret the requested type |
| * and content of the policy, it raises the <tt>PolicyError</tt> |
| * exception with the appropriate reason. |
| * @param type the <tt>PolicyType</tt> of the policy object to |
| * be created |
| * @param val the value that will be used to set the initial |
| * state of the <tt>Policy</tt> object that is created |
| * @return Reference to a newly created <tt>Policy</tt> object |
| * of type specified by the <tt>type</tt> parameter and |
| * initialized to a state specified by the <tt>val</tt> |
| * parameter |
| * @throws <tt>org.omg.CORBA.PolicyError</tt> when the requested |
| * policy is not supported or a requested initial state |
| * for the policy is not supported. |
| */ |
| public org.omg.CORBA.Policy create_policy(int type, org.omg.CORBA.Any val) |
| throws org.omg.CORBA.PolicyError |
| { |
| // Currently not implemented until PIORB. |
| throw new org.omg.CORBA.NO_IMPLEMENT(); |
| } |
| } |
