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