poaoperations.java

linux下建立JAVA虚拟机的源码KAFFE

   * @return the associated servant manager or null if it has
   * been previously set.
   *
   * @throws WrongPolicy if the required USE_SERVANT_MANAGER policy does not
   * apply to this POA.
   */
  ServantManager get_servant_manager()
                              throws WrongPolicy;

  /**
   * Get the unique Id of the POA in the process in which it is created.
   * This Id is needed by portable interceptors. The id is unique
   * for the life span of the POA in the process. For persistent
   * POAs, if a POA is created in the same path with the same name as
   * another POA, these POAs are identical have the same id. All transient
   * POAs are assumed unique.
   */
  byte[] id();

  /**
   * Returns the reference to the active object with the given Id.
   *
   * @param the_Object_Id the object id.
   *
   * @throws ObjectNotActive if there is no active object with such Id.
   * @throws WrongPolicy if the required RETAIN policy does not apply to
   * this POA.
   */
  org.omg.CORBA.Object id_to_reference(byte[] the_Object_Id)
                                throws ObjectNotActive, WrongPolicy;

  /**
   * Returns the servant that serves the active object with the given Id.
   *
   * @param the_Object_Id the object id.
   *
   * @throws ObjectNotActive if there is no active object with such Id.
   * @throws WrongPolicy. This method requires either RETAIN or
   * USE_DEFAULT_SERVANT policies and reaises the WrongPolicy if none of them
   * apply to this POA.
   */
  Servant id_to_servant(byte[] the_Object_Id)
                 throws ObjectNotActive, WrongPolicy;

  /**
   * Returns the Object Id, encapsulated in the given object reference.
   *
   * @param the_Object the object that has been previously created with this
   * POA. It need not be active.
   *
   * @throws WrongAdapter if the passed object has not been previously created
   * with this POA.
   * @throws WrongPolicy never (declared for the future extensions only).
   */
  byte[] reference_to_id(org.omg.CORBA.Object the_Object)
                  throws WrongAdapter, WrongPolicy;

  /**
   * Returns the servant that is serving this object.
   *
   * @return if the RETAIN policy applies and the object is in the Active
   * Object Map, the method returns the servant, associated with this object.
   * Otherwise, if the USE_DEFAULT_SERVANT policy applies, the method returns
   * the default servant (if one was set).
   *
   * @throws ObjectNotActive if none of the conditions above are satisfied.
   * @throws WrongAdapter if the object reference was not created with this POA.
   * @throws WrongPolicy. This method requires either RETAIN or
   * USE_DEFAULT_SERVANT policies and reaises the WrongPolicy if none of them
   * apply to this POA.
   */
  Servant reference_to_servant(org.omg.CORBA.Object the_Object)
                        throws ObjectNotActive, WrongPolicy, WrongAdapter;

  /**
  * Returns the id of the object, served by the given servant. The id is found
  * in one of the following ways.
  * <ul>
  * <li>If the POA has both the RETAIN and the UNIQUE_ID policy and
  * the specified servant is active, the method return the Object Id associated
  * with that servant.
  * </li><li>
  * If the POA has both the RETAIN and the IMPLICIT_ACTIVATION policy and
  * either the POA has the MULTIPLE_ID policy or the specified servant is
  * inactive, the method activates the servant using a POA-generated Object Id
  * and the Interface Id associated with the servant, and returns that
  * Object Id.
  * </li>
  * <li>If the POA has the USE_DEFAULT_SERVANT policy, the servant specified
  * is the default servant, and the method is being invoked in the context o
  * f executing a request on the default servant, the method returns the
  * ObjectId associated with the current invocation.
  * </li>
  * </ul>
  * @throws ServantNotActive in all cases, not listed in the list above.
  * @throws WrongPolicy The method requres USE_DEFAULT_SERVANT policy or
  * a combination of the RETAIN policy and either the UNIQUE_ID or
  * IMPLICIT_ACTIVATION policies and throws the WrongPolicy if these conditions
  * are not satisfied.
  */
  byte[] servant_to_id(Servant the_Servant)
                throws ServantNotActive, WrongPolicy;

  /**
   * <p>Converts the given servant to the object reference.
   * The servant will serve all methods, invoked on the returned object.
   * The returned object reference can be passed to the remote client,
   * enabling remote invocations.
   * </p><p>
   * If the specified servant already serves some active object, that
   * object is returned. Otherwise,
   * if the POA has the IMPLICIT_ACTIVATION policy the method activates
   * the servant, creating an new object with the POA-generated Object Id.
   * In this case, if the servant activator is set, the
   * {@link ServantActivatorOperations#incarnate} method will be called.
   * </p>
   *
   * @throws ServantNotActive if the servant is inactive and no
   * IMPLICIT_ACTIVATION policy applies.
   * @throws WrongPolicy This method needs the RETAIN policy and either the
   * UNIQUE_ID or IMPLICIT_ACTIVATION policies.
   *
   * @return the object, exposing the given servant in the context of this POA.
   */
  org.omg.CORBA.Object servant_to_reference(Servant the_Servant)
                                     throws ServantNotActive, WrongPolicy;

  /**
   * Return the POA manager, associated with this POA.
   *
   * @return the associated POA manager (always available).
   */
  POAManager the_POAManager();

  /**
   * Returns the adapter activator, associated with this POA.
   * The newly created POA has no activator (null would be
   * returned). The ORB root POA also initially has no activator.
   *
   * @return tha adapter activator or null if this POA has no
   * associated adapter activator.
   */
  AdapterActivator the_activator();

  /**
  * Set the adapter activator for this POA.
  *
  * @param the activator being set.
  */
  void the_activator(AdapterActivator activator);

  /**
  * The children of this POA.
  *
  * @return the array of all childs for this POA.
  */
  POA[] the_children();

  /**
   * Return the name of this POA.
   *
   * @return the name of POA, relative to its parent.
   */
  String the_name();

  /**
   * Return the parent of this POA.
   *
   * @return the parent POA or <code>null</code> if this is a root POA.
   */
  POA the_parent();

  /**
   * <p> Destroy this POA and all descendant POAs. The destroyed POAs can be
   * later re-created via {@link AdapterActivator} or by invoking
   * {@link #create_POA}.
   * This differs from {@link PoaManagerOperations#deactivate} that does
   * not allow recreation of the deactivated POAs. After deactivation,
   * recreation is only possible if the POAs were later destroyed.
   * </p><p>
   * The remote invocation on the target, belonging to the POA that is
   * currently destroyed return the remote exception ({@link TRANSIENT},
   * minor code 4).
   * </p>
   * @param etherealize_objects if true, and POA has RETAIN policy, and the
   * servant manager is available, the servant manager method
   * {@link ServantActivatorOperations#etherealize} is called for each
   *  <i>active</i> object in the Active Object Map. This method should not
   * try to access POA being destroyed. If <code>destroy</code> is called
   * multiple times before the destruction completes,
   * the etherialization should be invoked only once.
   *
   * @param wait_for_completion if true, the method waits till the POA being
   * destroyed completes all current requests and etherialization. If false,
   * the method returns immediately.
   */
  void destroy(boolean etherealize_objects, boolean wait_for_completion);

  /**
   * Create the IdUniquenessPolicy policy.
   *
   * @param value states which one Id uniqueness policy will apply.
   *
   * @return the created policy.
   */
  IdUniquenessPolicy create_id_uniqueness_policy(IdUniquenessPolicyValue a_value);

  /**
   * Create the ImplicitActivationPolicy policy.
   *
   * @param value states which one activation policy will apply.
   *
   * @return the created policy.
   */
  ImplicitActivationPolicy create_implicit_activation_policy(ImplicitActivationPolicyValue a_value);

  /**
   * Create the LifespanPolicy policy.
   *
   * @param value states which one object lifespan policy will apply.
   *
   * @return the created policy.
   */
  LifespanPolicy create_lifespan_policy(LifespanPolicyValue a_value);

  /**
   * Create the RequestProcessingPolicy policy.
   *
   * @param value states which one request processing policy will apply.
   *
   * @return the created policy.
   */
  RequestProcessingPolicy create_request_processing_policy(RequestProcessingPolicyValue a_value);

  /**
   * Create the ServantRetentionPolicy policy.
   *
   * @param value states which one servant retention policy will apply.
   *
   * @return the created policy.
   */
  ServantRetentionPolicy create_servant_retention_policy(ServantRetentionPolicyValue a_value);

  /**
   * Create the ThreadPolicy policy.
   *
   * @param value states which one thread policy will apply.
   *
   * @return the created policy.
   */
  ThreadPolicy create_thread_policy(ThreadPolicyValue a_value);

  /**
  * Create the ID assignment policy with the given value.
  *
  * @param value states which one ID assignment policy will apply.
  *
  * @return the created policy.
  */
  IdAssignmentPolicy create_id_assignment_policy(IdAssignmentPolicyValue value);

}