Source for org.omg.CORBA.ORB

   1: /* ORB.java --
   2:    Copyright (C) 2005, 2006 Free Software Foundation, Inc.
   3: 
   4: This file is part of GNU Classpath.
   5: 
   6: GNU Classpath is free software; you can redistribute it and/or modify
   7: it under the terms of the GNU General Public License as published by
   8: the Free Software Foundation; either version 2, or (at your option)
   9: any later version.
  10: 
  11: GNU Classpath is distributed in the hope that it will be useful, but
  12: WITHOUT ANY WARRANTY; without even the implied warranty of
  13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14: General Public License for more details.
  15: 
  16: You should have received a copy of the GNU General Public License
  17: along with GNU Classpath; see the file COPYING.  If not, write to the
  18: Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  19: 02110-1301 USA.
  20: 
  21: Linking this library statically or dynamically with other modules is
  22: making a combined work based on this library.  Thus, the terms and
  23: conditions of the GNU General Public License cover the whole
  24: combination.
  25: 
  26: As a special exception, the copyright holders of this library give you
  27: permission to link this library with independent modules to produce an
  28: executable, regardless of the license terms of these independent
  29: modules, and to copy and distribute the resulting executable under
  30: terms of your choice, provided that you also meet, for each linked
  31: independent module, the terms and conditions of the license of that
  32: module.  An independent module is a module which is not derived from
  33: or based on this library.  If you modify this library, you may extend
  34: this exception to your version of the library, but you are not
  35: obligated to do so.  If you do not wish to do so, delete this
  36: exception statement from your version. */
  37: 
  38: 
  39: package org.omg.CORBA;
  40: 
  41: import gnu.CORBA.OrbFocused;
  42: import gnu.CORBA.ObjectCreator;
  43: import gnu.CORBA.OrbRestricted;
  44: import gnu.CORBA.typecodes.FixedTypeCode;
  45: import gnu.CORBA.typecodes.GeneralTypeCode;
  46: import gnu.CORBA.typecodes.RecordTypeCode;
  47: import gnu.CORBA.typecodes.RecursiveTypeCode;
  48: 
  49: import org.omg.CORBA.ORBPackage.InconsistentTypeCode;
  50: import org.omg.PortableInterceptor.ObjectReferenceTemplate;
  51: 
  52: import java.applet.Applet;
  53: 
  54: import java.io.BufferedInputStream;
  55: import java.io.File;
  56: import java.io.FileInputStream;
  57: import java.io.IOException;
  58: 
  59: import java.util.Properties;
  60: 
  61: /**
  62:  * A central class in CORBA implementation, responsible for sending and handling
  63:  * remote invocations. ORB also works as a factory for creating instances of
  64:  * certain CORBA classes.
  65:  *
  66:  * Despite the core library contains the fully working CORBA implementation, it
  67:  * also provides a simple way to plug-in the alternative CORBA support. This is
  68:  * done by replacing the ORB. The alternative ORB can be specified via
  69:  * properties, passed to ORB.Init(...).
  70:  *
  71:  * When creating an ORB instance, the class name is searched in the following
  72:  * locations:
  73:  * <p>
  74:  * 1. Applet parameter or application string array, if any.<br>
  75:  * 2. The properties parameter, if any.<br>
  76:  * 3. The System properties.<br>
  77:  * 4. The orb.properties file located in the user.home directory (if any).<br>
  78:  * 5. The orb.properties file located in the java.home/lib directory (if any).
  79:  * </p>
  80:  *
  81:  * The supported properties are: <table border="1">
  82:  * <tr>
  83:  * <td> org.omg.CORBA.ORBClass</td>
  84:  * <td>The class, implementing the functional ORB, returned by
  85:  * {@link #init(Applet, Properties)} or {@link #init(String[], Properties)}
  86:  * </td>
  87:  * </tr>
  88:  * <tr>
  89:  * <td>org.omg.CORBA.ORBSingletonClass</td>
  90:  * <td>The class, implementing the restricted ORB, returned by {@link #init()}.
  91:  * </td>
  92:  * </tr>
  93:  * <tr>
  94:  * <td>org.omg.CORBA.ORBInitRef</td>
  95:  * <td>Specifies the initial reference, accessible by name with the method
  96:  * {@link #resolve_initial_references(String)}.</td>
  97:  * </tr>
  98:  * <tr>
  99:  * <td>org.omg.CORBA.ORBid</td>
 100:  * <td>Specifies the name (ORB Id) of this ORB. The ORB Id is later accessible
 101:  * by {@link ObjectReferenceTemplate#orb_id}. The default value includes the
 102:  * hashcode of the ORB instance that is normally different for each ORB.
 103:  * </td>
 104:  * </tr>
 105:  * <tr>
 106:  * <td>org.omg.CORBA.ServerId</td>
 107:  * <td>Specifies the name (Server Id) of this server. This property assigns
 108:  * value to the <i>static</i> field, ensuring that all ORB's on the same jre
 109:  * have the same Server Id. It is normally set as the system property. The
 110:  * server Id is later accessible as {@link ObjectReferenceTemplate#server_id}.
 111:  * </td>
 112:  * </tr>
 113:  * <tr>
 114:  * <td>gnu.CORBA.ListenerPort</td>
 115:  * <td>Specifies that this ORB should serve all its objects on a single port
 116:  * (for example, "1234") or on a specified port range (for example,
 117:  * "1100-1108"). The property is used when working with firewals and serves as a
 118:  * replacement for the proprietary properties like com.ibm.CORBA.ListenerPort
 119:  * or com.sun.CORBA.POA.ORBPersistentServerPort. The specified port or range
 120:  * should not overlap with the values, specified for other ORB's.
 121:  * </td>
 122:  * </tr>
 123:  * <tr>
 124:  * <td>gnu.Corba.SocketFactory</td>
 125:  * <td>Sets the user-defined server and client socket factory for the ORB being
 126:  * currently instantiated. Serves as a replacement of the proprietary
 127:  * property com.sun.CORBA.connection.ORBSocketFactoryClass. To have multiple
 128:  * types of sockets, instantiate several ORB's with this property each time
 129:  * set to the different value.
 130:  * The factory must implement gnu.CORBA.interfaces.SocketFactory.
 131:  * </td>
 132:  * </tr>
 133:  * </table>
 134:  * <p>The command line accepts the same properties as a keys. When
 135:  * specifying in the command line, the prefix org.omg.CORBA can be omitted, for
 136:  * instance<code> -ORBInitRef NameService=IOR:aabbccdd....</code>
 137:  * </p>
 138:  *
 139:  * @author Audrius Meskauskas (AudriusA@Bioinformatics.org)
 140:  */
 141: public abstract class ORB
 142: {
 143:   /**
 144:   * By default, {@link #init(String[], Properties)} and
 145:   * {@link #init(Applet, Properties)} return
 146:   * the built-in fully functional ORB is returned. If the
 147:   * <code>props</code> contains the property org.omg.CORBA.ORBClass,
 148:   * the value of this property is used as a class name to instantiate
 149:   * a user-defined ORB.
 150:   */
 151:   private static final String FUNCTIONAL_ORB = "org.omg.CORBA.ORBClass";
 152: 
 153:   /**
 154:    * The name of the restricted ORB property.
 155:    */
 156:   private static final String RESTRICTED_ORB =
 157:     "org.omg.CORBA.ORBSingletonClass";
 158: 
 159:   private static final String LISTENER_PORT =
 160:     OrbFocused.LISTENER_PORT;
 161: 
 162:   /**
 163:    * The class, implementing the default fully functional ORB.
 164:    */
 165:   private static final String DEFAULT_FUNCTIONAL_ORB =
 166:     gnu.CORBA.Poa.ORB_1_4.class.getName();
 167: 
 168:   private static final String DEFAULT_FOCUSED_ORB =
 169:     gnu.CORBA.OrbFocused.class.getName();
 170: 
 171:   // There is no need for name of the default restricted ORB as it is
 172:   // singleton and it is more effectively referred directly.
 173: 
 174:   /**
 175:    * Connect the given CORBA object to this ORB. After the object is
 176:    * connected, it starts receiving remote invocations via this ORB.
 177:    *
 178:    * The OMG group recommends to use Portable Object Adapter (POA) instead
 179:    * of calling this method.
 180:    *
 181:    * This method is implemented in the derived Gnu Classpah classes,
 182:    * returned by ORB.init(..). In this abstract class, the implementation
 183:    * just throws {@link NO_IMPLEMENT}.
 184:    *
 185:    * @param object the org.omg.CORBA.Object to connect.
 186:    */
 187:   public void connect(org.omg.CORBA.Object object)
 188:   {
 189:     throw new NO_IMPLEMENT();
 190:   }
 191: 
 192:   /**
 193:    * Disconnect the given CORBA object from this ORB. The object will be
 194:    * no longer receiving the remote invocations. In response to the
 195:    * remote invocation on this object, the ORB will send the
 196:    * exception {@link OBJECT_NOT_EXIST}. The object, however, is not
 197:    * destroyed and can receive the local invocations.
 198:    *
 199:    * This method is implemented in the derived Gnu Classpah classes,
 200:    * returned by ORB.init(..). In this abstract class, the implementation
 201:    * just throws {@link NO_IMPLEMENT}.
 202:    *
 203:    * @param object the object to disconnect.
 204:    */
 205:   public void disconnect(org.omg.CORBA.Object object)
 206:   {
 207:     throw new NO_IMPLEMENT();
 208:   }
 209: 
 210:   /**
 211:    * Create a typecode, representing a tree-like structure.
 212:    * This structure contains a member that is a sequence of the same type,
 213:    * as the structure itself. You can imagine as if the folder definition
 214:    * contains a variable-length array of the enclosed (nested) folder
 215:    * definitions. In this way, it is possible to have a tree like
 216:    * structure that can be transferred via CORBA CDR stream.
 217:    *
 218:    * @deprecated It is easier and clearler to use a combination of
 219:    * create_recursive_tc and create_sequence_tc instead.
 220:    *
 221:    * @param bound the maximal expected number of the nested components
 222:    * on each node; 0 if not limited.
 223:    *
 224:    * @param offset the position of the field in the returned structure
 225:    * that contains the sequence of the structures of the same field.
 226:    * The members before this field are intialised using parameterless
 227:    * StructMember constructor.
 228:    *
 229:    * @return a typecode, defining a stucture, where a member at the
 230:    * <code>offset</code> position defines an array of the identical
 231:    * structures.
 232:    *
 233:    * @see #create_recursive_tc(String)
 234:    * @see #create_sequence_tc(int, TypeCode)
 235:    */
 236:   public abstract TypeCode create_recursive_sequence_tc(int bound, int offset);
 237: 
 238:   /**
 239:    * Create alias typecode for the given typecode.
 240:    */
 241:   public abstract TypeCode create_alias_tc(String id, String name,
 242:                                            TypeCode typecode
 243:                                           );
 244: 
 245:   /**
 246:    * Create an instance of the CORBA {@link Any} with the type, intialised
 247:    * to {@link TCKind#tk_null}
 248:    */
 249:   public abstract Any create_any();
 250: 
 251:   /**
 252:    * Create a typecode, defining an array of the given elements.
 253:    *
 254:    * @param length the size of array
 255:    * @param element_type the array component type.
 256:    *
 257:    * @return the corresponding typecode.
 258:    */
 259:   public abstract TypeCode create_array_tc(int length, TypeCode element_type);
 260: 
 261:   /**
 262:    * Creates an empty CORBA <code>ContextList</code>.
 263:    *
 264:    * @return the newly created context list.
 265:    */
 266:   public abstract ContextList create_context_list();
 267: 
 268:   /**
 269:    * The support for {@link DynAny} and derived interfaces
 270:    * has never been implemented in Sun's java releases,
 271:    * at least till v1.4 inclusive.
 272:    *
 273:    * Since v1.4 this stil missing implementation was replaced
 274:    * by the new DynamicAny package.
 275:    *
 276:    * @deprecated Use {@link org.omg.DynamicAny.DynAnyFactory}
 277:    *
 278:    * @throws NO_IMPLEMENT, always.
 279:    */
 280:   public DynAny create_basic_dyn_any(org.omg.CORBA.TypeCode t)
 281:                               throws InconsistentTypeCode
 282:   {
 283:     throw new NO_IMPLEMENT();
 284:   }
 285: 
 286:   /**
 287:    * The support for {@link DynAny} and derived interfaces
 288:    * has never been implemented in Sun's java releases,
 289:    * at least till v1.4 inclusive.
 290:    *
 291:    * Since v1.4 this stil missing implementation was replaced
 292:    * by the new DynamicAny package.
 293:    *
 294:    * @deprecated Use {@link org.omg.DynamicAny.DynAnyFactory}
 295:    *
 296:    * @throws NO_IMPLEMENT, always.
 297:    */
 298:   public DynAny create_dyn_any(org.omg.CORBA.Any a)
 299:   {
 300:     throw new NO_IMPLEMENT();
 301:   }
 302: 
 303:   /**
 304:    * The support for {@link DynArray}
 305:    * has never been implemented in Sun's java releases,
 306:    * at least till v1.4 inclusive.
 307:    *
 308:    * Since v1.4 this stil missing implementation was replaced
 309:    * by the new DynamicAny package.
 310:    *
 311:    * @deprecated Use {@link org.omg.DynamicAny.DynAnyFactory}
 312:    *
 313:    * @throws NO_IMPLEMENT, always.
 314:    */
 315:   public DynArray create_dyn_array(org.omg.CORBA.TypeCode t)
 316:                             throws InconsistentTypeCode
 317:   {
 318:     throw new NO_IMPLEMENT();
 319:   }
 320: 
 321:   /**
 322:    * The support for {@link DynEnum}
 323:    * has never been implemented in Sun's java releases,
 324:    * at least till v1.4 inclusive.
 325:    *
 326:    * Since v1.4 this stil missing implementation was replaced
 327:    * by the new DynamicAny package.
 328:    *
 329:    * @deprecated Use {@link org.omg.DynamicAny.DynAnyFactory}
 330:    *
 331:    * @throws NO_IMPLEMENT, always.
 332:    */
 333:   public DynEnum create_dyn_enum(org.omg.CORBA.TypeCode t)
 334:                           throws InconsistentTypeCode
 335:   {
 336:     throw new NO_IMPLEMENT();
 337:   }
 338: 
 339:   /**
 340:    * The support for {@link DynSequence}
 341:    * has never been implemented in Sun's java releases,
 342:    * at least till v1.4 inclusive.
 343:    *
 344:    * Since v1.4 this stil missing implementation was replaced
 345:    * by the new DynamicAny package.
 346:    *
 347:    * @deprecated Use {@link org.omg.DynamicAny.DynAnyFactory}
 348:    *
 349:    * @throws NO_IMPLEMENT, always.
 350:    */
 351:   public DynSequence create_dyn_sequence(org.omg.CORBA.TypeCode t)
 352:                                   throws InconsistentTypeCode
 353:   {
 354:     throw new NO_IMPLEMENT();
 355:   }
 356: 
 357:   /**
 358:    * The support for {@link DynStruct} and derived interfaces
 359:    * has never been implemented in Sun's java releases,
 360:    * at least till v1.4 inclusive.
 361:    *
 362:    * Since v1.4 this stil missing implementation was replaced
 363:    * by the new DynamicAny package.
 364:    *
 365:    * @deprecated Use {@link org.omg.DynamicAny.DynAnyFactory}
 366:    *
 367:    * @throws NO_IMPLEMENT, always.
 368:    */
 369:   public DynStruct create_dyn_struct(org.omg.CORBA.TypeCode t)
 370:                               throws InconsistentTypeCode
 371:   {
 372:     throw new NO_IMPLEMENT();
 373:   }
 374: 
 375:   /**
 376:    * The support for {@link DynUnion} and derived interfaces
 377:    * has never been implemented in Sun's java releases,
 378:    * at least till v1.4 inclusive.
 379:    *
 380:    * Since v1.4 this stil missing implementation was replaced
 381:    * by the new DynamicAny package.
 382:    *
 383:    * @deprecated Use {@link org.omg.DynamicAny.DynAnyFactory}
 384:    *
 385:    * @throws NO_IMPLEMENT, always.
 386:    */
 387:   public DynUnion create_dyn_union(org.omg.CORBA.TypeCode t)
 388:                             throws InconsistentTypeCode
 389:   {
 390:     throw new NO_IMPLEMENT();
 391:   }
 392: 
 393:   /**
 394:    * Create a typecode, defining the given enumeration.
 395:    *
 396:    * @param id the id.
 397:    * @param name the name.
 398:    * @param members the memebers
 399:    * @return the created enumeration.
 400:    */
 401:   public abstract TypeCode create_enum_tc(String id, String name,
 402:                                           String[] members
 403:                                          );
 404: 
 405:   /**
 406:    * Create an environment (container for exceptions).
 407:    *
 408:    * @return the created container.
 409:    */
 410:   public abstract Environment create_environment();
 411: 
 412:   /**
 413:    * Creates an empty exception list.
 414:    *
 415:    * @return the newly created list.
 416:    */
 417:   public abstract ExceptionList create_exception_list();
 418: 
 419:   /**
 420:    * Create the exception typecode.
 421:    *
 422:    * @param id the id of exception.
 423:    * @param name the name of exception.
 424:    * @param members the members of exception.
 425:    */
 426:   public abstract TypeCode create_exception_tc(String id, String name,
 427:                                                StructMember[] members
 428:                                               );
 429: 
 430:   /**
 431:    * Creates a TypeCode object for CORBA <code>fixed</code> that is
 432:    * mapped to java {@link java.math.BigDecimal}.
 433:    *
 434:    * @param digits the number of digits in that <code>fixed</code>.
 435:    * @param scale the number of digits after the decimal point.
 436:    *
 437:    * @return the corresponding TypeCode.
 438:    */
 439:   public TypeCode create_fixed_tc(short digits, short scale)
 440:   {
 441:     FixedTypeCode r = new FixedTypeCode();
 442:     r.setDigits(digits);
 443:     r.setScale(scale);
 444:     return r;
 445:   }
 446: 
 447:   /**
 448:    * Creates a typecode, representing the IDL interface.
 449:    *
 450:    * @param id the interface repository id.
 451:    * @param name the interface name.
 452:    *
 453:    * @return the created typecode.
 454:    */
 455:   public abstract TypeCode create_interface_tc(String id, String name);
 456: 
 457:   /**
 458:    * Create an instance of a new {@link NVList}.
 459:    *
 460:    * @param count the initial size of the list. If more elements are added,
 461:    * the list automatically expands.
 462:    *
 463:    * @return the created list.
 464:    */
 465:   public abstract NVList create_list(int count);
 466: 
 467:   /**
 468:    * Create a new named value.
 469:    *
 470:    * @param name the name of the named value
 471:    * @param any the content of the named value.
 472:    * @param flags the flags of the named value
 473:    *
 474:    * @return the named value.
 475:    */
 476:   public abstract NamedValue create_named_value(String name, Any any, int flags);
 477: 
 478:   /**
 479:    * Send multiple prepared requests one way, do not caring about the answer.
 480:    * The messages, containing requests, will be marked, indicating that
 481:    * the sender is not expecting to get a reply.
 482:    *
 483:    * @param requests the prepared array of requests.
 484:    *
 485:    * @see Request#send_oneway()
 486:    */
 487:   public abstract void send_multiple_requests_oneway(Request[] requests);
 488: 
 489:   /**
 490:    * Send multiple prepared requests expecting to get a reply. All requests
 491:    * are send in parallel, each in its own separate thread. When the
 492:    * reply arrives, it is stored in the agreed fields of the corresponing
 493:    * request data structure. If this method is called repeatedly,
 494:    * the new requests are added to the set of the currently sent requests,
 495:    * but the old set is not discarded.
 496:    *
 497:    * @param requests the prepared array of requests.
 498:    *
 499:    * @see #poll_next_response()
 500:    * @see #get_next_response()
 501:    * @see Request#send_deferred()
 502:    */
 503:   public abstract void send_multiple_requests_deferred(Request[] requests);
 504: 
 505:   /**
 506:    * Find if any of the requests that have been previously sent with
 507:    * {@link #send_multiple_requests_deferred}, have a response yet.
 508:    *
 509:    * @return true if there is at least one response to the previously
 510:    * sent request, false otherwise.
 511:    */
 512:   public abstract boolean poll_next_response();
 513: 
 514:   /**
 515:    * Get the next instance with a response being received. If all currently
 516:    * sent responses not yet processed, this method pauses till at least one of
 517:    * them is complete. If there are no requests currently sent, the method
 518:    * pauses till some request is submitted and the response is received.
 519:    * This strategy is identical to the one accepted by Suns 1.4 ORB
 520:    * implementation.
 521:    *
 522:    * @return the previously sent request that now contains the received
 523:    * response.
 524:    *
 525:    * @throws WrongTransaction If the method was called from the transaction
 526:    * scope different than the one, used to send the request. The exception
 527:    * can be raised only if the request is implicitly associated with some
 528:    * particular transaction.
 529:    */
 530:   public abstract Request get_next_response()
 531:                                      throws WrongTransaction;
 532: 
 533:   /**
 534:    * Create a new CDR output stream, where the parameter values can be written
 535:    * during the method invocation.
 536:    *
 537:    * @return a stream to write values into.
 538:    */
 539:   public abstract org.omg.CORBA.portable.OutputStream create_output_stream();
 540: 
 541:   /**
 542:    * This should create the list, initialised with the argument descriptions
 543:    * for the given operation definition (CORBA <code>OperationDef</code>).
 544:    * The information should be obtained from the interface repository.
 545:    * However this method is oficially documented as not implemented at least
 546:    * till v1.4 inclusive.
 547:    *
 548:    * @param operation_definition the operation definition, must be
 549:    * CORBA <code>OperationDef</code>.
 550:    *
 551:    * @return never
 552:    *
 553:    * @throws NO_IMPLEMENT, always.
 554:    */
 555:   public NVList create_operation_list(Object operation_definition)
 556:   {
 557:     throw new NO_IMPLEMENT();
 558:   }
 559: 
 560:   /**
 561:    * <p>Creates the new policy of the specified type, having the given value.
 562:    * This method looks for the policy factory that was previously registered
 563:    * during ORB initialization by
 564:    * {@link org.omg.PortableInterceptor#ORBInitialiser}.
 565:    *
 566:    * If the suitable factory is found, this factory creates the requested policy,
 567:    * otherwise the PolicyError is thrown.
 568:    * </p><p>
 569:    * The POA policies should be created by POA, not by this method.
 570:    * </p>
 571:    * @param type the policy type.
 572:    * @param value the policy value, wrapped into Any.
 573:    *
 574:    * @throws PolicyError if the ORB fails to instantiate the policy object.
 575:    *
 576:    * @throws NO_IMPLEMENT always (in this class). Overridden in derived classes
 577:    * returned by ORB.init(..).
 578:    *
 579:    * @see org.omg.PortableInterceptor.ORBInitInfoOperations#register_policy_factory
 580:    * @see org.omg.PortableInterceptor.PolicyFactoryOperations
 581:    */
 582:   public Policy create_policy(int type, Any value)
 583:                        throws PolicyError
 584:   {
 585:     throw new NO_IMPLEMENT();
 586:   }
 587: 
 588:   /**
 589:    * Create typecode, defining the sequence of the elements, having
 590:    * the given type.
 591:    *
 592:    * @param bound the maximal length of the sequence, 0 if not restricted.
 593:    *
 594:    * @param element_type the sequence element type.
 595:    *
 596:    * @return the typecode.
 597:    */
 598:   public abstract TypeCode create_sequence_tc(int bound, TypeCode element_type);
 599: 
 600:   /**
 601:    * Create a TypeCode, representing the CORBA <code>string</code>.
 602:    *
 603:    * @param bound the maximal length of the string, 0 is unlimited.
 604:    *
 605:    * @return the corresponding string typecode.
 606:    */
 607:   public abstract TypeCode create_string_tc(int bound);
 608: 
 609:   /**
 610:    * Create the typecode, defining the given IDL structure.
 611:    *
 612:    * The TypeCode object is initialized with the given id, name, and members.
 613:    * @param id the Id of this type.
 614:    * @param name the name of this type.
 615:    * @param members the member list.
 616:    *
 617:    * @return the typecode.
 618:    */
 619:   public abstract TypeCode create_struct_tc(String id, String name,
 620:                                             StructMember[] members
 621:                                            );
 622: 
 623:   /**
 624:    * Create the typecode, defining the given IDL union.
 625:    *
 626:    * The TypeCode object is initialized with the given id, name, discriminator
 627:    * and members.
 628:    *
 629:    * @param id the Id of this type.
 630:    * @param name the name of this type.
 631:    * @param discriminator the union discriminator.
 632:    * @param members the member list.
 633:    *
 634:    * @return the typecode.
 635:    */
 636:   public abstract TypeCode create_union_tc(String id, String name,
 637:                                            TypeCode discriminator,
 638:                                            UnionMember[] members
 639:                                           );
 640: 
 641:   /**
 642:    * Create a TypeCode, representing the CORBA <code>wstring</code>.
 643:    *
 644:    * @param bound the maximal length of the string, 0 is unlimited.
 645:    *
 646:    * @return the corresponding string typecode.
 647:    */
 648:   public abstract TypeCode create_wstring_tc(int bound);
 649: 
 650:   /**
 651:    * Create a typecode for an abstract interface. The abstract interface
 652:    * can be either CORBA object or CORBA value type.
 653:    *
 654:    * @param id the id of the abstract interface.
 655:    * @param name the name of the abstract interface.
 656:    *
 657:    * @return the created typecode.
 658:    */
 659:   public TypeCode create_abstract_interface_tc(String id, String name)
 660:   {
 661:     GeneralTypeCode t = new GeneralTypeCode(TCKind.tk_abstract_interface);
 662:     t.setName(name);
 663:     t.setId(id);
 664:     return t;
 665:   }
 666: 
 667:   /**
 668:    * Create a typecode for a native interface.
 669:    *
 670:    * @param id the id of the native interface.
 671:    * @param name the name of the native interface.
 672:    *
 673:    * @return the created typecode.
 674:    */
 675:   public TypeCode create_native_tc(String id, String name)
 676:   {
 677:     GeneralTypeCode t = new GeneralTypeCode(TCKind.tk_native);
 678:     t.setName(name);
 679:     t.setId(id);
 680:     return t;
 681:   }
 682: 
 683: 
 684:   /**
 685:    * Create a typecode which serves as a placeholder for typcode, containing
 686:    * recursion.
 687:    *
 688:    * @param id the id of the recursive typecode, for that this typecode
 689:    * serves as a placeholder.
 690:    */
 691:   public TypeCode create_recursive_tc(String id)
 692:   {
 693:     return new RecursiveTypeCode(id);
 694:   }
 695: 
 696:   /**
 697:    * Create value box typecode.
 698:    */
 699:   public TypeCode create_value_box_tc(String id, String name,
 700:                                       TypeCode boxed_type
 701:                                      )
 702:   {
 703:     GeneralTypeCode t = new GeneralTypeCode(TCKind.tk_value_box);
 704:     t.setName(name);
 705:     t.setId(id);
 706:     t.setContentType(boxed_type);
 707:     return t;
 708:   }
 709: 
 710:   /**
 711:    * Create IDL value type code.
 712:    */
 713:   public TypeCode create_value_tc(String id, String name, short type_modifier,
 714:                                   TypeCode concrete_base, ValueMember[] members
 715:                                  )
 716:   {
 717:     RecordTypeCode r = new RecordTypeCode(TCKind.tk_value);
 718:     r.setId(id);
 719:     r.setName(name);
 720:     r.setTypeModifier(type_modifier);
 721:     r.setConcreteBase_type(concrete_base);
 722: 
 723:     for (int i = 0; i < members.length; i++)
 724:       {
 725:         r.add(members [ i ]);
 726:       }
 727: 
 728:     return r;
 729:   }
 730: 
 731:   /**
 732:    * This should return the information, related to the current thread.
 733:    * The information is needed, for instance, to get the current object
 734:    * from the code that serves several objects in parallel threads.
 735:    * The {@link Current} is very general interface, with no fields and
 736:    * operations defined. This method is not implemented in Suns
 737:    * releases at least till v1.5 inclusive. To obtain the
 738:    * {@link org.omg.PortableServer.Current}, use
 739:    * {@link #resolve_initial_references}, passing "POACurrent".
 740:    *
 741:    * @deprecated since 1.2, use {@link #resolve_initial_references}.
 742:    *
 743:    * @return never
 744:    *
 745:    * @throws NO_IMPLEMENT always.
 746:    */
 747:   public Current get_current()
 748:   {
 749:     throw new NO_IMPLEMENT();
 750:   }
 751: 
 752:   /**
 753:    * This should return the information about the CORBA facilities and
 754:    * services, available from this ORB. However this method is oficially
 755:    * documented as not implemented at least till v1.5 inclusive.
 756:    *
 757:    * @param service_type a type of the service being requested. The OMG
 758:    * specification currently defines only one value, 1, for security
 759:    * related services.
 760:    *
 761:    * @param service_info a holder, where the returned information should
 762:    * be stored.
 763:    *
 764:    * @return should return true if the service information is available
 765:    * from the ORB, but this method never returns.
 766:    *
 767:    * @throws NO_IMPLEMENT always.
 768:    */
 769:   public boolean get_service_information(short service_type,
 770:                                          ServiceInformationHolder service_info
 771:                                         )
 772:   {
 773:     throw new NO_IMPLEMENT();
 774:   }
 775: 
 776:   /**
 777:    * Get the default context of this ORB. This is an initial root of all
 778:    * contexts.
 779:    *
 780:    * The default method returns a new context with the empty name and
 781:    * no parent context.
 782:    *
 783:    * @return the default context of this ORB.
 784:    *
 785:    * @throws NO_IMPLEMENT for the Singleton ORB, returned by
 786:    * the parameterless {@link #init()}.
 787:    */
 788:   public abstract Context get_default_context();
 789: 
 790:   /**
 791:    * Return thg typecode, representing the given primitive object type.
 792:    *
 793:    * @param tcKind the kind of the primitive typecode.
 794:    *
 795:    * @return the typecode of the primitve typecode.
 796:    */
 797:   public abstract TypeCode get_primitive_tc(TCKind tcKind);
 798: 
 799:   /**
 800:    * Returns so-called Singleton ORB, a highly restricted version
 801:    * that cannot communicate over network. This ORB is provided
 802:    * for the potentially malicious applets with heavy security restrictions.
 803:    *
 804:    * The returned Singleton ORB can only create typecodes,
 805:    * {@link Any}, {@link ContextList}, {@link NVList} and
 806:    * {@link org.omg.CORBA.portable.OutputStream} that writes to an
 807:    * internal buffer.
 808:    *
 809:    * All other methods throw the {@link NO_IMPLEMENT} exception, additionally
 810:    * printing the error message about the potential attempt to violate
 811:    * the security rules.
 812:    *
 813:    * The implementing ORB class, used in this method, is found as described
 814:    * in the header.
 815:    *
 816:    * @return the working derivative of ORB, implementing the methods
 817:    * of this abstract class.
 818:    */
 819:   public static ORB init()
 820:   {
 821:     String orb_cn = getCumulatedProperty(null, RESTRICTED_ORB);
 822:     if (orb_cn == null)
 823:       return OrbRestricted.Singleton;
 824:     else
 825:       return createORB(null, orb_cn);
 826:   }
 827: 
 828:   /**
 829:    * Creates the working instance of ORB for an applet.
 830:    *
 831:    * By default the built-in fully functional ORB is returned. The ORB class
 832:    * is found as described in the header of this class.
 833:    *
 834:    * @param applet the applet. The property org.omg.CORBA.ORBClass,
 835:    * if present, defines the used ORB implementation class. If this
 836:    * property is not present, the ORB class is found as described in the
 837:    * class header.
 838:    *
 839:    * @param props the properties, may be <code>null</code>.
 840:    *
 841:    * @return a newly created functional derivative of this abstract class.
 842:    */
 843:   public static ORB init(Applet applet, Properties props)
 844:   {
 845:     String ocn = applet.getParameter(FUNCTIONAL_ORB);
 846:     String lp = applet.getParameter(LISTENER_PORT);
 847: 
 848:     if (ocn==null && lp!=null)
 849:       ocn = DEFAULT_FOCUSED_ORB;
 850: 
 851:     ORB orb = createORB(props, ocn);
 852:     orb.set_parameters(applet, props);
 853: 
 854:     return orb;
 855:   }
 856: 
 857:   /**
 858:    * Creates the working instance of ORB for a standalone application.
 859:    *
 860:    * By default the built-in fully functional ORB is returned. The ORB class is
 861:    * found as described in the header of this class.
 862:    *
 863:    * @param args the parameters, passed to the applications
 864:    * <code>main(String[] args)</code> method, may be <code>null</code>. The
 865:    * parameter -org.omg.CORBA.ORBClass <class name> if present, defines the used
 866:    * ORB implementation class. If this property is not present, the ORB class is
 867:    * found as described in the class header.
 868:    *
 869:    * @param props application specific properties, may be <code>null</code>.
 870:    *
 871:    * @return a newly created functional derivative of this abstract class.
 872:    */
 873:   public static ORB init(String[] args, Properties props)
 874:   {
 875:     String ocn = null;
 876:     String lp = null;
 877: 
 878:     String orbKey = "-" + FUNCTIONAL_ORB;
 879:     String lpKey = "-" + LISTENER_PORT;
 880: 
 881:     if (args != null)
 882:       if (args.length >= 2)
 883:         {
 884:           for (int i = 0; i < args.length - 1; i++)
 885:             {
 886:               if (args[i].equals(orbKey))
 887:                 ocn = args[i + 1];
 888:               if (args[i].equals(lpKey))
 889:                 lp = args[i + 1];
 890:             }
 891:         }
 892: 
 893:     if (lp != null && ocn == null)
 894:       ocn = DEFAULT_FOCUSED_ORB;
 895: 
 896:     ORB orb = createORB(props, ocn);
 897: 
 898:     orb.set_parameters(args, props);
 899:     return orb;
 900:   }
 901: 
 902:   /**
 903:    * List the initially available CORBA objects (services).
 904:    *
 905:    * @return a list of services.
 906:    *
 907:    * @see #resolve_initial_references(String)
 908:    */
 909:   public abstract String[] list_initial_services();
 910: 
 911:   /**
 912:    * Find and return the easily accessible CORBA object, addressed
 913:    * by name.  The returned object is typically casted to the more
 914:    * specific reference using the <code>narrow(Object)</code> method
 915:    * of its helper. The method resolves the following string values,
 916:    * returning the working objects:
 917:    * <table border="1"><tr><th>String</th><th>Object class</th>
 918:    * <th>Object use</th></tr>
 919:    *
 920:    * <tr><td>NameService</td><td>{@link org.omg.CosNaming.NamingContextExt}</td>
 921:    * <td>Finds (usually remote) object by its name.</td></tr>
 922:    *
 923:    * <tr><td>RootPOA</td><td>{@link org.omg.PortableServer.POA}</td>
 924:    * <td>Holds the POA tree for this ORB, where since 1.4 all servants
 925:    * should be connected.</td></tr>
 926:    *
 927:    * <tr><td>RootPOAManager</td><td>{@link org.omg.PortableServer.POAManager}
 928:    * </td><td>Regulates (suspends/resumes) the root POA
 929:    * activity</td></tr>
 930:    *
 931:    * <tr><td>POACurrent</td><td>{@link org.omg.PortableServer.Current}
 932:    * </td><td>Informs the current thread about the Id and POA of the
 933:    * object being currently served (the methods of
 934:    * <code>Current</code> return different values for
 935:    * different threads).
 936:    * </td></tr>
 937:    *
 938:    * <tr><td>CodecFactory</td><td>{@link org.omg.IOP.Codec}</td>
 939:    * <td>Encodes/decodes IDL data types into/from byte arrays.</td>
 940:    * </tr>
 941:    *
 942:    * <tr><td>DynAnyFactory</td><td>{@link org.omg.DynamicAny.DynAnyFactory}</td>
 943:    * <td>Creates DynAny's.</td>
 944:    * </tr>
 945:    *
 946:    * <tr><td>PICurrent</td><td>{@link org.omg.PortableInterceptor.Current}</td>
 947:    * <td>Contains multiple slots where an interceptor can rememeber the
 948:    * request - specific values between subsequent
 949:    * calls of the interceptor methods.</td>
 950:    * </tr>
 951:    *
 952:    * </table>
 953:    *
 954:    * @param name the object name.
 955:    * @return the object
 956:    * @throws org.omg.CORBA.ORBPackage.InvalidName if the given name
 957:    * is not associated with the known object.
 958:    */
 959:   public abstract Object resolve_initial_references(String name)
 960:     throws org.omg.CORBA.ORBPackage.InvalidName;
 961: 
 962:   /**
 963:    * Get the IOR reference string for the given object.
 964:    * IOR can be compared with the Internet address for a web page,
 965:    * it provides means to locate the CORBA service on the web.
 966:    * IOR contains the host address, port number, the object identifier
 967:    * (key) inside the server, the communication protocol version,
 968:    * supported charsets and so on.
 969:    *
 970:    * @param forObject the CORBA object
 971:    * @return the object IOR representation.
 972:    * @see #string_to_object(String)
 973:    */
 974:   public abstract String object_to_string(Object forObject);
 975: 
 976:   /**
 977:    * This should perform the implementation dependent unit of work in the
 978:    * main thread.
 979:    *
 980:    * This method is part of the support for the distribute use of the
 981:    * single execution thread.
 982:    *
 983:    * Same as in Suns releases at least till 1.4 inclusive,
 984:    * the distribute use of the single thread is not implemented.
 985:    * Use multiple threads, provided by jre.
 986:    *
 987:    * The method returns without action.
 988:    */
 989:   public void perform_work()
 990:   {
 991:   }
 992: 
 993:   /**
 994:   * Checks if the ORB needs the main thread to perform some work.
 995:   * The method should return true if the ORB needs the main thread,
 996:   * and false if it does not.
 997:   *
 998:   * This method is part of the support for the distribute use of the
 999:   * single execution thread.
1000:   *
1001:   * Same as in Suns releases at least till 1.4 inclusive,
1002:   * the distributed use of the single thread is not implemented.
1003:   * Use multiple threads, provided by jre.
1004:   *
1005:   * @return false, always.
1006:   */
1007:   public boolean work_pending()
1008:   {
1009:     return false;
1010:   }
1011: 
1012:   /**
1013:    * <p>Find and return the CORBA object, addressed by the given
1014:    * string representation. The object can be (an usually is)
1015:    * located on a remote computer, possibly running a different
1016:    * (not necessary java) CORBA implementation. The returned
1017:    * object is typically casted to the more specific reference
1018:    * using the <code>narrow(Object)</code> method of its helper.
1019:    * </p><p>
1020:    * This function supports the following input formats:<br>
1021:    * 1. IOR reference (<b>ior:</b>nnnnn ..), usually computer generated.<br>
1022:    * 2. <b>corbaloc:</b>[<b>iiop</b>][version.subversion<b>@</b>]<b>:</b>host[<b>:</b>port]<b>/</b><i>key</i>
1023:    * defines similar information as IOR reference, but is more human readable.
1024:    * This type of reference may also contain multiple addresses (see
1025:    * OMG documentation for complete format).<br>
1026:    * 3. <b>corbaloc:rir:/</b><i>name</i> defines internal reference on this
1027:    * ORB that is resolved using {@link #resolve_initial_references}, passing
1028:    * the given <i>name</i> as parameter.<br>
1029:    * 4. <b>corbaname:rir:#</b><i>name</i> states that the given <i>name</i>
1030:    * must be resolved using the naming service, default for this ORB.<br>
1031:    * 5. <b>corbaname:</b>[<b>iiop</b>][version.subversion<b>@</b>]<b>:</b>host[<b>:</b>port]<b>#</b><i>name</i>
1032:    * states that the <i>name</i> must be resolved using the naming service
1033:    * that runs on the given host at the given port. The ORB expects to find
1034:    * there the {@link org.omg.CosNaming.NamingContext} under the key
1035:    * "NameService.<br>
1036:    * 7. file://[file name] Read the object definition string from the
1037:    * file system<br>
1038:    * 8. http://[url] Read the object definition string from the provided
1039:    * url.<br>
1040:    * 9. ftp://[url] Read the object definition string from the provided
1041:    * url.<br>
1042:    *
1043:    * <p>The default port is always 2809. The default iiop version is 1.0
1044:    * that now may not always be supported, so we would recommend to specify
1045:    * the version explicitly.</p>
1046:    * <p>
1047:    * The examples of the corbaloc and corbaname addresses:<br>
1048:    * corbaname:rir:#xobj - ask local naming service for "xobj".<br>
1049:    * corbaname:rir:/NameService#xobj - same (long form).<br>
1050:    * corbaname:iiop:1.2@localhost:900#xobj - same, assuming that the naming
1051:    * service runs at port 900 on the local host and supports iiop 1.2.<br>
1052:    * corbaname:iiop:localhost#xobj - same, assuming that the naming
1053:    * service runs at port 2809 on the local host and supports iiop 1.0.<br>
1054:    * corbaloc::gnu.xxx.yy/Prod/TradingService - the object exists on the
1055:    * host gnu.xxx.yy, port 2809 having the key "Prod/TradingService". Its ORB
1056:    * supports iiop 1.0.<br>
1057:    * corbaloc::gnu.xxx.yy/Prod/TradingService:801 - the object exists on the
1058:    * host gnu.xxx.yy, port 801 having the key "Prod/TradingService". Its ORB
1059:    * supports iiop 1.0 (iiop keyword ommitted).<br>
1060:    * corbaloc:iiop:1.1@gnu.xxx.yy/Prod/TradingService - the object exists on the
1061:    * host gnu.xxx.yy, port 801 having the key "Prod/TradingService". Its ORB
1062:    * supports iiop 1.1.<br>
1063:    * corbaloc:rir:/NameService - the default naming service.
1064:    *
1065:    * @param IOR the object IOR representation string.
1066:    *
1067:    * @return the found CORBA object.
1068:    *
1069:    * @throws BAD_PARAM if the string being parsed is invalid.
1070:    * @throws DATA_CONVERSION if the string being parsed contains unsupported
1071:    * prefix or protocol.
1072:    *
1073:    * @see #object_to_string(org.omg.CORBA.Object)
1074:    */
1075:   public abstract Object string_to_object(String IOR);
1076: 
1077:   /**
1078:    * Start listening on the input socket. This method
1079:    * blocks the current thread until {@link #shutdown(boolean)}
1080:    * is called and shutdown process is completed.
1081:    */
1082:   public void run()
1083:   {
1084:   }
1085: 
1086:   /**
1087:    * Shutdown the ORB server.
1088:    *
1089:    * @param wait_for_completion if true, the current thread is
1090:    * suspended untile the shutdown process is complete.
1091:    */
1092:   public void shutdown(boolean wait_for_completion)
1093:   {
1094:   }
1095: 
1096:   /**
1097:    * Destroy this server, releasing the occupied resources.
1098:    * The default method returns without action.
1099:    */
1100:   public void destroy()
1101:   {
1102:   }
1103: 
1104:   /**
1105:    * Set the ORB parameters. This method is normally called from
1106:    * {@link #init(String[], Properties)}.
1107:    *
1108:    * @param para the parameters, that were passed as the parameters
1109:    * to the  <code>main(String[] args)</code> method of the current standalone
1110:    * application.
1111:    *
1112:    * @param props application specific properties that were passed
1113:    * as a second parameter in {@link #init(String[], Properties)}).
1114:    * Can be <code>null</code>.
1115:    */
1116:   protected abstract void set_parameters(String[] para, Properties props);
1117: 
1118:   /**
1119:    * Set the ORB parameters. This method is normally called from
1120:    * {@link #init(Applet, Properties)}.
1121:    *
1122:    * @param app the current applet.
1123:    *
1124:    * @param props application specific properties, passed as the second
1125:    * parameter in {@link #init(Applet, Properties)}.
1126:    * Can be <code>null</code>.
1127:    */
1128:   protected abstract void set_parameters(Applet app, Properties props);
1129: 
1130:   /**
1131:    * Get the property with the given name, searching in the standard
1132:    * places for the ORB properties.
1133:    */
1134:   private static String getCumulatedProperty(Properties props, String property)
1135:   {
1136:     String orb_cn = null;
1137: 
1138:     if (props != null)
1139:       orb_cn = props.getProperty(property, null);
1140: 
1141:     if (orb_cn == null)
1142:       orb_cn = System.getProperty(property, null);
1143: 
1144:     if (orb_cn == null)
1145:       orb_cn = checkFile(property, "user.home", null);
1146: 
1147:     if (orb_cn == null)
1148:       orb_cn = checkFile(property, "java.home", "lib");
1149: 
1150:     return orb_cn;
1151:   }
1152: 
1153:   /**
1154:    * Check if the property is defined in the existsting file orb.properties.
1155:    *
1156:    * @param property the property
1157:    * @param dir the system property, defining the folder where the
1158:    * file could be expected.
1159:    * @param subdir subfolder where to look for the file.
1160:    *
1161:    * @return the property value, null if not found or file does not exist.
1162:    */
1163:   private static String checkFile(String property, String dir, String subdir)
1164:   {
1165:     try
1166:       {
1167:         File f = new File(dir);
1168:         if (!f.exists())
1169:           return null;
1170: 
1171:         if (subdir != null)
1172:           f = new File(f, subdir);
1173: 
1174:         f = new File(f, "orb.properties");
1175: 
1176:         if (!f.exists())
1177:           return null;
1178: 
1179:         Properties p = new Properties();
1180:         p.load(new BufferedInputStream(new FileInputStream(f)));
1181: 
1182:         return p.getProperty(property, null);
1183:       }
1184:     catch (IOException ex)
1185:       {
1186:         return null;
1187:       }
1188:   }
1189: 
1190:   /**
1191:    * Create ORB when its name is possibly known.
1192:    *
1193:    * @param props properties, possibly containing the ORB name.
1194:    * @param orbClassName the direct ORB class name, overriding other possible
1195:    * locations, or null if not specified.
1196:    */
1197:   private static ORB createORB(Properties props, String orbClassName)
1198:   {
1199:     ORB orb = null;
1200: 
1201:     if (orbClassName == null)
1202:       {
1203:         orbClassName = getCumulatedProperty(props, FUNCTIONAL_ORB);
1204: 
1205:         if (orbClassName == null)
1206:           {
1207:             String lp = getCumulatedProperty(props, LISTENER_PORT);
1208:             if (lp != null)
1209:               orbClassName = DEFAULT_FOCUSED_ORB;
1210:             else
1211:               orbClassName = DEFAULT_FUNCTIONAL_ORB;
1212:           }
1213:       }
1214: 
1215:     try
1216:       {
1217:         orb = (ORB) ObjectCreator.forName(orbClassName).newInstance();
1218:       }
1219:     catch (ClassNotFoundException ex)
1220:       {
1221:         noORB(orbClassName, ex);
1222:       }
1223:     catch (IllegalAccessException ex)
1224:       {
1225:         noORB(orbClassName, ex);
1226:       }
1227:     catch (InstantiationException ex)
1228:       {
1229:         noORB(orbClassName, ex);
1230:       }
1231: 
1232:     return orb;
1233:   }
1234: 
1235:   /**
1236:    * Throw the runtime exception.
1237:    *
1238:    * @param orb_c the ORB class name.
1239:    * @param why the explaining chained exception.
1240:    */
1241:   private static void noORB(String orb_c, Throwable why)
1242:   {
1243:     throw new RuntimeException("The ORB " + orb_c + " cannot be instantiated.",
1244:                                why
1245:                               );
1246:   }
1247: }