*   * @return the created typecode.   */  public abstract TypeCode create_interface_tc(String id, String name);  /**   * Create an instance of a new {@link NVList}.   *   * @param count the initial size of the list. If more elements are added,   * the list automatically expands.   *   * @return the created list.   */  public abstract NVList create_list(int count);  /**   * Create a new named value.   *   * @param name the name of the named value   * @param any the content of the named value.   * @param flags the flags of the named value   *   * @return the named value.   */  public abstract NamedValue create_named_value(String name, Any any, int flags);  /**   * Send multiple prepared requests one way, do not caring about the answer.   * The messages, containing requests, will be marked, indicating that   * the sender is not expecting to get a reply.   *   * @param requests the prepared array of requests.   *   * @see Request#send_oneway()   */  public abstract void send_multiple_requests_oneway(Request[] requests);  /**   * Send multiple prepared requests expecting to get a reply. All requests   * are send in parallel, each in its own separate thread. When the   * reply arrives, it is stored in the agreed fields of the corresponing   * request data structure. If this method is called repeatedly,   * the new requests are added to the set of the currently sent requests,   * but the old set is not discarded.   *   * @param requests the prepared array of requests.   *   * @see #poll_next_response()   * @see #get_next_response()   * @see Request#send_deferred()   */  public abstract void send_multiple_requests_deferred(Request[] requests);  /**   * Find if any of the requests that have been previously sent with   * {@link #send_multiple_requests_deferred}, have a response yet.   *   * @return true if there is at least one response to the previously   * sent request, false otherwise.   */  public abstract boolean poll_next_response();  /**   * Get the next instance with a response being received. If all currently   * sent responses not yet processed, this method pauses till at least one of   * them is complete. If there are no requests currently sent, the method   * pauses till some request is submitted and the response is received.   * This strategy is identical to the one accepted by Suns 1.4 ORB   * implementation.   *   * @return the previously sent request that now contains the received   * response.   *   * @throws WrongTransaction If the method was called from the transaction   * scope different than the one, used to send the request. The exception   * can be raised only if the request is implicitly associated with some   * particular transaction.   */  public abstract Request get_next_response()                                     throws WrongTransaction;  /**   * Create a new CDR output stream, where the parameter values can be written   * during the method invocation.   *   * @return a stream to write values into.   */  public abstract org.omg.CORBA.portable.OutputStream create_output_stream();  /**   * This should create the list, initialised with the argument descriptions   * for the given operation definition (CORBA <code>OperationDef</code>).   * The information should be obtained from the interface repository.   * However this method is oficially documented as not implemented at least   * till v1.4 inclusive.   *   * @param operation_definition the operation definition, must be   * CORBA <code>OperationDef</code>.   *   * @return never   *   * @throws NO_IMPLEMENT, always.   */  public NVList create_operation_list(Object operation_definition)  {    throw new NO_IMPLEMENT();  }  /**   * <p>Creates the new policy of the specified type, having the given value.   * This method looks for the policy factory that was previously registered   * during ORB initialization by   * {@link org.omg.PortableInterceptor#ORBInitialiser}.   *   * If the suitable factory is found, this factory creates the requested policy,   * otherwise the PolicyError is thrown.   * </p><p>   * The POA policies should be created by POA, not by this method.   * </p>   * @param type the policy type.   * @param value the policy value, wrapped into Any.   *   * @throws PolicyError if the ORB fails to instantiate the policy object.   *   * @throws NO_IMPLEMENT always (in this class). Overridden in derived classes   * returned by ORB.init(..).   *   * @see org.omg.PortableInterceptor.ORBInitInfoOperations#register_policy_factory   * @see org.omg.PortableInterceptor.PolicyFactoryOperations   */  public Policy create_policy(int type, Any value)                       throws PolicyError  {    throw new NO_IMPLEMENT();  }  /**   * Create typecode, defining the sequence of the elements, having   * the given type.   *   * @param bound the maximal length of the sequence, 0 if not restricted.   *   * @param element_type the sequence element type.   *   * @return the typecode.   */  public abstract TypeCode create_sequence_tc(int bound, TypeCode element_type);  /**   * Create a TypeCode, representing the CORBA <code>string</code>.   *   * @param bound the maximal length of the string, 0 is unlimited.   *   * @return the corresponding string typecode.   */  public abstract TypeCode create_string_tc(int bound);  /**   * Create the typecode, defining the given IDL structure.   *   * The TypeCode object is initialized with the given id, name, and members.   * @param id the Id of this type.   * @param name the name of this type.   * @param members the member list.   *   * @return the typecode.   */  public abstract TypeCode create_struct_tc(String id, String name,                                            StructMember[] members                                           );  /**   * Create the typecode, defining the given IDL union.   *   * The TypeCode object is initialized with the given id, name, discriminator   * and members.   *   * @param id the Id of this type.   * @param name the name of this type.   * @param discriminator the union discriminator.   * @param members the member list.   *   * @return the typecode.   */  public abstract TypeCode create_union_tc(String id, String name,                                           TypeCode discriminator,                                           UnionMember[] members                                          );  /**   * Create a TypeCode, representing the CORBA <code>wstring</code>.   *   * @param bound the maximal length of the string, 0 is unlimited.   *   * @return the corresponding string typecode.   */  public abstract TypeCode create_wstring_tc(int bound);  /**   * Create a typecode for an abstract interface. The abstract interface   * can be either CORBA object or CORBA value type.   *   * @param id the id of the abstract interface.   * @param name the name of the abstract interface.   *   * @return the created typecode.   */  public TypeCode create_abstract_interface_tc(String id, String name)  {    GeneralTypeCode t = new GeneralTypeCode(TCKind.tk_abstract_interface);    t.setName(name);    t.setId(id);    return t;  }  /**   * Create a typecode for a native interface.   *   * @param id the id of the native interface.   * @param name the name of the native interface.   *   * @return the created typecode.   */  public TypeCode create_native_tc(String id, String name)  {    GeneralTypeCode t = new GeneralTypeCode(TCKind.tk_native);    t.setName(name);    t.setId(id);    return t;  }  /**   * Create a typecode, representing a tree-like structure.   * This structure contains a member that is a sequence of the same type,   * as the structure itself. You can imagine as if the folder definition   * contains a variable-length array of the enclosed (nested) folder   * definitions. In this way, it is possible to have a tree like   * structure that can be transferred via CORBA CDR stream.   *   * @deprecated It is easier and clearler to use a combination of   * create_recursive_tc and create_sequence_tc instead.   *   * @param bound the maximal expected number of the nested components   * on each node; 0 if not limited.   *   * @param offset the position of the field in the returned structure   * that contains the sequence of the structures of the same field.   * The members before this field are intialised using parameterless   * StructMember constructor.   *   * @return a typecode, defining a stucture, where a member at the   * <code>offset</code> position defines an array of the identical   * structures.   *   * @see #create_recursive_tc(String)   * @see #create_sequence_tc(int, TypeCode)   */  public TypeCode create_recursive_sequence_tc(int bound, int offset)  {    RecordTypeCode r = new RecordTypeCode(TCKind.tk_struct);    for (int i = 0; i < offset; i++)      r.add(new StructMember());    TypeCode recurs = new PrimitiveTypeCode(TCKind.tk_sequence);    r.add(new StructMember("", recurs, null));    return r;  }  /**   * Create a typecode which serves as a placeholder for typcode, containing   * recursion.   *   * @param id the id of the recursive typecode, for that this typecode   * serves as a placeholder.   */  public TypeCode create_recursive_tc(String id)  {    return new RecursiveTypeCode(id);  }  /**   * Create value box typecode.   */  public TypeCode create_value_box_tc(String id, String name,                                      TypeCode boxed_type                                     )  {    GeneralTypeCode t = new GeneralTypeCode(TCKind.tk_value_box);    t.setName(name);    t.setId(id);    t.setContentType(boxed_type);    return t;  }  /**   * Create IDL value type code.   */  public TypeCode create_value_tc(String id, String name, short type_modifier,                                  TypeCode concrete_base, ValueMember[] members                                 )  {    RecordTypeCode r = new RecordTypeCode(TCKind.tk_value);    r.setId(id);    r.setName(name);    r.setTypeModifier(type_modifier);    r.setConcreteBase_type(concrete_base);    for (int i = 0; i < members.length; i++)      {        r.add(members [ i ]);      }    return r;  }  /**   * This should return the information, related to the current thread.   * The information is needed, for instance, to get the current object   * from the code that serves several objects in parallel threads.   * The {@link Current} is very general interface, with no fields and   * operations defined. This method is not implemented in Suns   * releases at least till v1.5 inclusive. To obtain the   * {@link org.omg.PortableServer.Current}, use   * {@link #resolve_initial_references}, passing "POACurrent".   *   * @deprecated since 1.2, use {@link #resolve_initial_references}.   *   * @return never   *   * @throws NO_IMPLEMENT always.   */  public Current get_current()  {    throw new NO_IMPLEMENT();  }  /**   * This should return the information about the CORBA facilities and   * services, available from this ORB. However this method is oficially   * documented as not implemented at least till v1.5 inclusive.   *   * @param service_type a type of the service being requested. The OMG   * specification currently defines only one value, 1, for security   * related services.   *   * @param service_info a holder, where the returned information should   * be stored.   *   * @return should return true if the service information is available   * from the ORB, but this method never returns.   *   * @throws NO_IMPLEMENT always.   */  public boolean get_service_information(short service_type,                                         ServiceInformationHolder service_info                                        )  {    throw new NO_IMPLEMENT();  }  /**   * Get the default context of this ORB. This is an initial root of all   * contexts.   *   * The default method returns a new context with the empty name and   * no parent context.   *   * @return the default context of this ORB.   *   * @throws NO_IMPLEMENT for the Singleton ORB, returned by   * the parameterless {@link #init()}.   */  public Context get_default_context()  {    return new gnuContext("", null);  }  /**   * Return thg typecode, representing the given primitive object type.   *   * @param tcKind the kind of the primitive typecode.   *   * @return the typecode of the primitve typecode.   */  public abstract TypeCode get_primitive_tc(TCKind tcKind);  /**   * Returns so-called Singleton ORB, a highly restricted version   * that cannot communicate over network. This ORB is provided   * for the potentially malicious applets with heavy security restrictions.   *   * The returned Singleton ORB can only create typecodes,   * {@link Any}, {@link ContextList}, {@link NVList} and   * {@link org.omg.CORBA.portable.OutputStream} that writes to an   * internal buffer.   *   * All other methods throw the {@link NO_IMPLEMENT} exception, additionally   * printing the error message about the potential attempt to violate   * the security rules.   *   * The implementing ORB class, used in this method, is found as described   * in the header.   *   * @return the working derivative of ORB, implementing the methods   * of this abstract class.   */  public static ORB init()  {    String orb_cn = getCumulatedProperty(null, RESTRICTED_ORB);    if (orb_cn == null)      return OrbRestricted.Singleton;    else      return createORB(null, orb_cn);  }  /**   * Creates the working instance of ORB for an applet.