orb.java

gcc的组建

   *
   * @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.