// File: PortableServer.idl
// CORBA 3.0, Chapter 11

#ifndef _PORTABLE_SERVER_IDL_
#define _PORTABLE_SERVER_IDL_

#ifdef _PRE_3_0_COMPILER_ 
#pragma prefix "omg.org"

#include <orb.idl>
#else
import ::CORBA;
#endif // _PRE_3_0_COMPILER_

// Most IDL compilers don't accept the "native" keyword in application IDL 
//    files. In order to compile an IDL (really PIDL) file that has it, the 
//    following trick can be used: change what the compiler sees. Instead
//    of letting the compiler see the keyword "native", use a preprocessor
//    definition that results in valid IDL, even if it doesn't yield
//    useful stubs and skeletons. Of course, PIDL never results in
//    the standard stubs so that's not a problem.
//
// Set the variable _MASK_NATIVE_ in the IDL compiler to enable it to
// parse this file.

#ifdef _MASK_NATIVE_
#define native typedef long
#endif // _MASK_NATIVE_

module PortableServer {

#ifndef _PRE_3_0_COMPILER_ 
    typeprefix PortableServer "omg.org";
#endif // _PRE_3_0_COMPILER_

    local interface POA;                          // forward declaration
    typedef sequence<POA> POAList; 
    native Servant;
    typedef CORBA::OctetSeq ObjectId;
    exception ForwardRequest {
        CORBA::Object forward_reference;
    };
    
    // 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,
	MAIN_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();
        string get_id();
    };
    
    // PoaManagerFactory
    local interface POAManagerFactory {
        typedef sequence<POAManager> POAManagerSeq;
        exception ManagerAlreadyExists {};
        POAManager create_POAManager(
	    in string id,
	    in CORBA::PolicyList policies
	) raises(ManagerAlreadyExists, CORBA::PolicyError);
        POAManagerSeq list();
        POAManager find( in string id);
    };

    // AdapterActivator interface
    local interface AdapterActivator {
        boolean unknown_adapter(in POA parent, 
                                in string name);
    };
    
    // ServantManager interface
    local interface ServantManager{ };
    
    local interface ServantActivator : ServantManager {
        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 {
        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 {
        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
        CORBA::Object create_reference (    in CORBA::RepositoryId intf)
	  raises (WrongPolicy);
        CORBA::Object create_reference_with_id (
                                    in ObjectId             oid,
                                    in CORBA::RepositoryId  intf);
        
        // Identity mapping operations:
        ObjectId servant_to_id(     in Servant              p_servant) 
	  raises (ServantNotActive, WrongPolicy);
        CORBA::Object servant_to_reference(in Servant              p_servant) 
	  raises (ServantNotActive, WrongPolicy);
        Servant reference_to_servant(in CORBA::Object              reference)
	  raises(ObjectNotActive, WrongAdapter, WrongPolicy);
        ObjectId reference_to_id(   in CORBA::Object               reference)
	  raises (WrongAdapter, WrongPolicy);
        Servant id_to_servant(      in ObjectId             oid)
	  raises (ObjectNotActive, WrongPolicy);
        CORBA::Object id_to_reference(     in ObjectId             oid)
	  raises (ObjectNotActive, WrongPolicy);

        readonly attribute CORBA::OctetSeq id;
        readonly attribute POAManagerFactory the_POAManagerFactory;
    };
    
    // Current interface
    local interface Current : CORBA::Current {
        exception   NoContext { };
        POA         get_POA()       raises (NoContext);
        ObjectId    get_object_id() raises (NoContext);
        CORBA::Object      get_reference() raises (NoContext);
        Servant     get_servant()   raises (NoContext);
    };
};
#endif // _PORTABLE_SERVER_IDL_
