path: root/TAO/tao/PortableServer/PortableServer.pidl

/**
 * @file PortableServer.pidl
 *
 * $Id$
 *
 * @brief Pre-compiled IDL source for the PortableServer module.
 *
 * This file was used to generate the code in
 * PortableServerC.{h,i,cpp}, using the following command:
 *
 * tao_idl.exe \
 *     -o orig -Gp -Gd -Ge 1 -GT -Sc -GA -I$(TAO_ROOT)
 *          -Wb,export_macro=TAO_PortableServer_Export \
 *          -Wb,export_include="portableserver_export.h" \
 *          -Wb,pre_include="ace/pre.h" \
 *          -Wb,post_include="ace/post.h" \
 *          PortableServer.pidl
 *
 * After the file is generated a patch from the diffs directory must
 * be applied.  The patch:
 *
 *   - Disables parts of the code under certain configurations.
 *
 *   - Eliminates cycles in the include dependencies.
 *
 *   - Adds non-idl components of PortableServer to the namespace.
 *     This includes (a) Servant (b) ServantBase (c) RefCountServantBase
 *     (d) Cookie (e) ObjectId_to_string (f) string_to_ObjectId (g)
 *     ObjectId_to_wstring (h) wstring_to_ObjectId (i) ServantBase_var
 *     (j) DynamicImplementation (k) LocalServantBase
 *
 * Apply patches using the following command:
 *
 *   patch < diffs/PortableServer.diff
 *
 * Note: The diffs were generated using:
 *
 *   rm diffs/PortableServer.diff
 *   for i in PortableServerC.{h,i,cpp}; do
 *     diff -wub orig/$i $i >> diffs/PortableServer.diff
 *   done
 */

#ifndef _PORTABLESERVER_IDL_
#define _PORTABLESERVER_IDL_

#include <orb.idl>
#include <Current.pidl>
#include <OctetSeq.pidl>

#pragma prefix "omg.org"

module PortableServer
{
# pragma version PortableServer 2.3

  local interface POA;	    // forward declaration
  typedef sequence<POA> POAList;
  native Servant;
  typedef CORBA::OctetSeq ObjectId;

  exception ForwardRequest
  {
    Object forward_reference;
  };

  // @@ Frank - MIOP specific types

  exception NotAGroupObject {};
  typedef sequence <ObjectId> IDs;

  // @@ Frank - End MIOP

  // Policy interfaces.

  const CORBA::PolicyType THREAD_POLICY_ID                = 16;
  const CORBA::PolicyType LIFESPAN_POLICY_ID              = 17;
  const CORBA::PolicyType ID_UNIQUENESS_POLICY_ID         = 18;
  const CORBA::PolicyType ID_ASSIGNMENT_POLICY_ID         = 19;
  const CORBA::PolicyType IMPLICIT_ACTIVATION_POLICY_ID   = 20;
  const CORBA::PolicyType SERVANT_RETENTION_POLICY_ID     = 21;
  const CORBA::PolicyType REQUEST_PROCESSING_POLICY_ID    = 22;

  enum ThreadPolicyValue
  {
    ORB_CTRL_MODEL,
    SINGLE_THREAD_MODEL
  };

  local interface ThreadPolicy : CORBA::Policy
  {
    readonly attribute ThreadPolicyValue value;
  };

  enum LifespanPolicyValue
  {
    TRANSIENT,
    PERSISTENT
  };

  local interface LifespanPolicy : CORBA::Policy
  {
    readonly attribute LifespanPolicyValue value;
  };

  enum IdUniquenessPolicyValue
  {
    UNIQUE_ID,
    MULTIPLE_ID
  };

  local interface IdUniquenessPolicy : CORBA::Policy
  {
    readonly attribute IdUniquenessPolicyValue value;
  };

  enum IdAssignmentPolicyValue
  {
    USER_ID,
    SYSTEM_ID
  };

  local interface IdAssignmentPolicy : CORBA::Policy
  {
    readonly attribute IdAssignmentPolicyValue value;
  };

  enum ImplicitActivationPolicyValue
  {
    IMPLICIT_ACTIVATION,
    NO_IMPLICIT_ACTIVATION
  };

  local interface ImplicitActivationPolicy : CORBA::Policy
  {
    readonly attribute ImplicitActivationPolicyValue value;
  };

  enum ServantRetentionPolicyValue
  {
    RETAIN,
    NON_RETAIN
  };

  local interface ServantRetentionPolicy : CORBA::Policy
  {
    readonly attribute ServantRetentionPolicyValue value;
  };

  enum RequestProcessingPolicyValue
  {
    USE_ACTIVE_OBJECT_MAP_ONLY,
    USE_DEFAULT_SERVANT,
    USE_SERVANT_MANAGER
  };

  local interface RequestProcessingPolicy : CORBA::Policy
  {
    readonly attribute RequestProcessingPolicyValue value;
  };

  // POAManager interface
  local interface POAManager
  {
    exception AdapterInactive {};

    enum State
    {
      HOLDING,
      ACTIVE,
      DISCARDING,
      INACTIVE
    };

    void activate ()
      raises(AdapterInactive);

    void hold_requests (in boolean wait_for_completion)
      raises(AdapterInactive);

    void discard_requests (in boolean wait_for_completion)
      raises(AdapterInactive);

    void deactivate (in boolean etherealize_objects,
                     in boolean wait_for_completion)
      raises(AdapterInactive);

    State get_state ();
  };

  // AdapterActivator interface.
  local interface AdapterActivator
  {
#   pragma version AdapterActivator 2.3

    boolean unknown_adapter (in POA parent,
                             in string name);
  };

  // ServantManager interface.
  local interface ServantManager {};

  local interface ServantActivator : ServantManager
  {
#   pragma version ServantActivator 2.3

    Servant incarnate (in ObjectId oid,
                       in POA adapter)
      raises (ForwardRequest);

    void etherealize (in ObjectId oid,
                      in POA adapter,
                      in Servant serv,
                      in boolean cleanup_in_progress,
                      in boolean remaining_activations);
  };

  local interface ServantLocator : ServantManager
  {
#   pragma version ServantLocator 2.3

    native Cookie;

    Servant preinvoke (in ObjectId oid,
                       in POA adapter,
                       in CORBA::Identifier operation,
                       out Cookie the_cookie)
      raises (ForwardRequest);

    void postinvoke (in ObjectId oid,
                     in POA adapter,
                     in CORBA::Identifier operation,
                     in Cookie  the_cookie,
                     in Servant the_servant);
  };

  local interface POA
  {
#   pragma version POA 2.3

    exception AdapterAlreadyExists {};
    exception AdapterNonExistent {};
    exception InvalidPolicy {unsigned short index;};
    exception NoServant {};
    exception ObjectAlreadyActive {};
    exception ObjectNotActive {};
    exception ServantAlreadyActive {};
    exception ServantNotActive {};
    exception WrongAdapter {};
    exception WrongPolicy {};

    // POA creation and destruction.

    POA create_POA (in string adapter_name,
                    in POAManager a_POAManager,
                    in CORBA::PolicyList policies)
      raises (AdapterAlreadyExists,
	      InvalidPolicy);

    POA find_POA (in string adapter_name,
                  in boolean activate_it)
      raises (AdapterNonExistent);

    void destroy (in boolean etherealize_objects,
                  in boolean wait_for_completion);

    // Factories for Policy objects.

    ThreadPolicy create_thread_policy (in ThreadPolicyValue value);

    LifespanPolicy create_lifespan_policy (
	in LifespanPolicyValue value
      );

    IdUniquenessPolicy  create_id_uniqueness_policy (
        in IdUniquenessPolicyValue value
      );

    IdAssignmentPolicy  create_id_assignment_policy (
        in IdAssignmentPolicyValue value
      );

    ImplicitActivationPolicy create_implicit_activation_policy (
        in ImplicitActivationPolicyValue value\
      );

    ServantRetentionPolicy create_servant_retention_policy (
        in ServantRetentionPolicyValue value
      );

    RequestProcessingPolicy create_request_processing_policy (
	in RequestProcessingPolicyValue value
      );

    // POA attributes
    readonly attribute string       the_name;
    readonly attribute POA          the_parent;
    readonly attribute POAList      the_children;
    readonly attribute POAManager   the_POAManager;
    attribute AdapterActivator      the_activator;

    // Servant Manager registration:

    ServantManager get_servant_manager ()
      raises (WrongPolicy);

    void set_servant_manager (in ServantManager imgr)
      raises (WrongPolicy);

    // Operations for the USE_DEFAULT_SERVANT policy.

    Servant get_servant ()
      raises (NoServant,
	      WrongPolicy);

    void set_servant (in Servant p_servant)
      raises (WrongPolicy);

    // Object activation and deactivation.

    ObjectId  activate_object (in Servant p_servant)
      raises (ServantAlreadyActive,
	      WrongPolicy);

    void activate_object_with_id (in ObjectId id,
                                  in Servant p_servant)
      raises (ServantAlreadyActive,
	      ObjectAlreadyActive,
	      WrongPolicy);

    void deactivate_object (in ObjectId oid)
      raises (ObjectNotActive, WrongPolicy);

    // Reference creation operations.

    Object create_reference (in CORBA::RepositoryId intf)
      raises (WrongPolicy);

    Object create_reference_with_id (in ObjectId oid,
				     in CORBA::RepositoryId intf)
      raises (WrongPolicy);

    // Identity mapping operations:.
    ObjectId servant_to_id (in Servant p_servant)
      raises (ServantNotActive,
	      WrongPolicy);

    Object servant_to_reference (in Servant p_servant)
      raises (ServantNotActive, WrongPolicy);

    Servant reference_to_servant (in Object reference)
      raises (ObjectNotActive,
	      WrongAdapter,
	      WrongPolicy);

    ObjectId reference_to_id (in Object reference)
      raises (WrongAdapter,
	      WrongPolicy);

    Servant id_to_servant (in ObjectId oid)
      raises (ObjectNotActive, WrongPolicy);

    Object id_to_reference (in ObjectId oid)
      raises (ObjectNotActive,
	      WrongPolicy);

    readonly attribute CORBA::OctetSeq id;

    // @@ Frank - MIOP specific methods

    ObjectId create_id_for_reference(in Object the_ref)
      raises (NotAGroupObject);

    IDs reference_to_ids(in Object the_ref)
      raises (NotAGroupObject);

    void associate_reference_with_id (in Object ref,
                                      in ObjectId oid)
      raises (NotAGroupObject);

    void disassociate_reference_with_id (in Object ref,
                                         in ObjectId oid)
      raises (NotAGroupObject);

    // @@ Frank - End MIOP
  };

  // Current interface.
  local interface Current : CORBA::Current
  {
#   pragma version Current 2.3

    exception NoContext {};

    POA get_POA ()
      raises (NoContext);

    ObjectId get_object_id ()
      raises (NoContext);
  };
};

#endif // _PORTABLESERVER_IDL_