diff options
Diffstat (limited to 'TAO/tao/poa.h')
| -rw-r--r-- | TAO/tao/poa.h | 923 |
1 files changed, 923 insertions, 0 deletions
diff --git a/TAO/tao/poa.h b/TAO/tao/poa.h new file mode 100644 index 00000000000..7feb78a5fff --- /dev/null +++ b/TAO/tao/poa.h @@ -0,0 +1,923 @@ +// -*- C++ -*- +// $Id$ + +// ============================================================================ +// +// = LIBRARY +// TAO +// +// = FILENAME +// poa.h +// +// = DESCRIPTION +// POA +// +// = AUTHOR +// Irfan Pyarali +// +// ============================================================================ + +#if !defined (POA_H) +#define POA_H + +// CORBA +#include "tao/corba.h" + +// Stubs +#include "tao/poaC.h" + +// Servant +#include "tao/servant_base.h" + +// Skeletons +#include "tao/poaS.h" + +// String +#include "ace/SString.h" +//#include "string" + +// Map +//#include "map" +#include "ace/Map_Manager.h" + +// Vector +//#include "vector" +#include "ace/Containers.h" + +// Locking +#include "ace/Synch.h" + +// Active Object Table +#include "tao/objtable.h" + +class TAO_POA; +class TAO_POA_Manager; + +class TAO_Export TAO_Thread_Policy : public POA_PortableServer::ThreadPolicy +{ +public: + TAO_Thread_Policy (PortableServer::ThreadPolicyValue value, + PortableServer::POA_ptr poa); + + TAO_Thread_Policy (const TAO_Thread_Policy &new_policy); + + virtual PortableServer::ThreadPolicyValue value (CORBA::Environment &env); + + virtual PortableServer::Policy_ptr copy (CORBA::Environment &env); + + virtual void destroy (CORBA::Environment &env); + + virtual PortableServer::POA_ptr _default_POA (CORBA::Environment &env); + +protected: + PortableServer::ThreadPolicyValue value_; + + PortableServer::POA_var poa_; +}; + +class TAO_Export TAO_Lifespan_Policy : public POA_PortableServer::LifespanPolicy +{ +public: + TAO_Lifespan_Policy (PortableServer::LifespanPolicyValue value, + PortableServer::POA_ptr poa); + + TAO_Lifespan_Policy (const TAO_Lifespan_Policy &rhs); + + virtual PortableServer::LifespanPolicyValue value (CORBA::Environment &env); + + virtual PortableServer::Policy_ptr copy (CORBA::Environment &env); + + virtual void destroy (CORBA::Environment &env); + + virtual PortableServer::POA_ptr _default_POA (CORBA::Environment &env); + +protected: + PortableServer::LifespanPolicyValue value_; + + PortableServer::POA_var poa_; +}; + +class TAO_Export TAO_Id_Uniqueness_Policy : public POA_PortableServer::IdUniquenessPolicy +{ +public: + TAO_Id_Uniqueness_Policy (PortableServer::IdUniquenessPolicyValue value, + PortableServer::POA_ptr poa); + + TAO_Id_Uniqueness_Policy (const TAO_Id_Uniqueness_Policy &rhs); + + virtual PortableServer::IdUniquenessPolicyValue value (CORBA::Environment &env); + + virtual PortableServer::Policy_ptr copy (CORBA::Environment &env); + + virtual void destroy (CORBA::Environment &env); + + virtual PortableServer::POA_ptr _default_POA (CORBA::Environment &env); + +protected: + PortableServer::IdUniquenessPolicyValue value_; + + PortableServer::POA_var poa_; +}; + +class TAO_Export TAO_Id_Assignment_Policy : public POA_PortableServer::IdAssignmentPolicy +{ +public: + TAO_Id_Assignment_Policy (PortableServer::IdAssignmentPolicyValue value, + PortableServer::POA_ptr poa); + + TAO_Id_Assignment_Policy (const TAO_Id_Assignment_Policy &rhs); + + virtual PortableServer::IdAssignmentPolicyValue value (CORBA::Environment &env); + + virtual PortableServer::Policy_ptr copy (CORBA::Environment &env); + + virtual void destroy (CORBA::Environment &env); + + virtual PortableServer::POA_ptr _default_POA (CORBA::Environment &env); + +protected: + PortableServer::IdAssignmentPolicyValue value_; + + PortableServer::POA_var poa_; +}; + +class TAO_Export TAO_Implicit_Activation_Policy : public POA_PortableServer::ImplicitActivationPolicy +{ +public: + TAO_Implicit_Activation_Policy (PortableServer::ImplicitActivationPolicyValue value, + PortableServer::POA_ptr poa); + + TAO_Implicit_Activation_Policy (const TAO_Implicit_Activation_Policy &rhs); + + virtual PortableServer::ImplicitActivationPolicyValue value (CORBA::Environment &env); + + virtual PortableServer::Policy_ptr copy (CORBA::Environment &env); + + virtual void destroy (CORBA::Environment &env); + + virtual PortableServer::POA_ptr _default_POA (CORBA::Environment &env); + +protected: + PortableServer::ImplicitActivationPolicyValue value_; + + PortableServer::POA_var poa_; +}; + +class TAO_Export TAO_Servant_Retention_Policy : public POA_PortableServer::ServantRetentionPolicy +{ +public: + TAO_Servant_Retention_Policy (PortableServer::ServantRetentionPolicyValue value, + PortableServer::POA_ptr poa); + + TAO_Servant_Retention_Policy (const TAO_Servant_Retention_Policy &rhs); + + virtual PortableServer::ServantRetentionPolicyValue value (CORBA::Environment &env); + + virtual PortableServer::Policy_ptr copy (CORBA::Environment &env); + + virtual void destroy (CORBA::Environment &env); + + virtual PortableServer::POA_ptr _default_POA (CORBA::Environment &env); + +protected: + PortableServer::ServantRetentionPolicyValue value_; + + PortableServer::POA_var poa_; +}; + +class TAO_Export TAO_Request_Processing_Policy : public POA_PortableServer::RequestProcessingPolicy +{ +public: + TAO_Request_Processing_Policy (PortableServer::RequestProcessingPolicyValue value, + PortableServer::POA_ptr poa); + + TAO_Request_Processing_Policy (const TAO_Request_Processing_Policy &rhs); + + virtual PortableServer::RequestProcessingPolicyValue value (CORBA::Environment &env); + + virtual PortableServer::Policy_ptr copy (CORBA::Environment &env); + + virtual void destroy (CORBA::Environment &env); + + virtual PortableServer::POA_ptr _default_POA (CORBA::Environment &env); + +protected: + PortableServer::RequestProcessingPolicyValue value_; + + PortableServer::POA_var poa_; +}; + +class TAO_Export TAO_POA_Policies +{ +public: + + TAO_POA_Policies (void); + + virtual PortableServer::ThreadPolicyValue thread (void) const; + virtual void thread (PortableServer::ThreadPolicyValue value); + + virtual PortableServer::LifespanPolicyValue lifespan (void) const; + virtual void lifespan (PortableServer::LifespanPolicyValue value); + + virtual PortableServer::IdUniquenessPolicyValue id_uniqueness (void) const; + virtual void id_uniqueness (PortableServer::IdUniquenessPolicyValue value); + + virtual PortableServer::IdAssignmentPolicyValue id_assignment (void) const; + virtual void id_assignment (PortableServer::IdAssignmentPolicyValue value); + + virtual PortableServer::ImplicitActivationPolicyValue implicit_activation (void) const; + virtual void implicit_activation (PortableServer::ImplicitActivationPolicyValue value); + + virtual PortableServer::ServantRetentionPolicyValue servant_retention (void) const; + virtual void servant_retention (PortableServer::ServantRetentionPolicyValue value); + + virtual PortableServer::RequestProcessingPolicyValue request_processing (void) const; + virtual void request_processing (PortableServer::RequestProcessingPolicyValue value); + + virtual void parse_policies (const PortableServer::PolicyList &policies, + CORBA::Environment &env); + +protected: + + virtual void parse_policy (const PortableServer::Policy_ptr policy, + CORBA::Environment &env); + + virtual int validity_check (void); + + PortableServer::ThreadPolicyValue thread_; + + PortableServer::LifespanPolicyValue lifespan_; + + PortableServer::IdUniquenessPolicyValue id_uniqueness_; + + PortableServer::IdAssignmentPolicyValue id_assignment_; + + PortableServer::ImplicitActivationPolicyValue implicit_activation_; + + PortableServer::ServantRetentionPolicyValue servant_retention_; + + PortableServer::RequestProcessingPolicyValue request_processing_; +}; + +class TAO_Temporary_Creation_Time; + +class TAO_Creation_Time +{ +public: + + TAO_Creation_Time (const ACE_Time_Value &creation_time); + + TAO_Creation_Time (void); + + virtual void creation_time (const void *creation_time); + + virtual const void *creation_time (void) const; + + static int creation_time_length (void); + + int operator== (const TAO_Creation_Time &rhs) const; + + int operator!= (const TAO_Creation_Time &rhs) const; + + int operator== (const TAO_Temporary_Creation_Time &rhs) const; + + int operator!= (const TAO_Temporary_Creation_Time &rhs) const; + +private: + + // 32 bit ulong requires 8 octets + static const int max_space_required_for_two_ulong_to_hex; + + // Timestamp buffer + char time_stamp_[(8 * 2) + 1]; + +}; + +// Special creation time only useful in the lifetime of the upcall +class TAO_Temporary_Creation_Time +{ +public: + + TAO_Temporary_Creation_Time (void); + + virtual void creation_time (const void *creation_time); + + int operator== (const TAO_Creation_Time &rhs) const; + + int operator!= (const TAO_Creation_Time &rhs) const; + +private: + + void *time_stamp_; +}; + +class TAO_POA_Current; + +class TAO_Export TAO_POA : public POA_PortableServer::POA +{ +public: + + typedef ACE_CString String; + //typedef std::string String; + + virtual PortableServer::POA_ptr create_POA (const char *adapter_name, + PortableServer::POAManager_ptr poa_manager, + const PortableServer::PolicyList &policies, + CORBA::Environment &env); + + virtual PortableServer::POA_ptr find_POA (const char *adapter_name, + CORBA::Boolean activate_it, + CORBA::Environment &env); + + virtual void destroy (CORBA::Boolean etherealize_objects, + CORBA::Boolean wait_for_completion, + CORBA::Environment &env); + + virtual PortableServer::ThreadPolicy_ptr create_thread_policy (PortableServer::ThreadPolicyValue value, + CORBA::Environment &env); + + virtual PortableServer::LifespanPolicy_ptr create_lifespan_policy (PortableServer::LifespanPolicyValue value, + CORBA::Environment &env); + + virtual PortableServer::IdUniquenessPolicy_ptr create_id_uniqueness_policy (PortableServer::IdUniquenessPolicyValue value, + CORBA::Environment &env); + + virtual PortableServer::IdAssignmentPolicy_ptr create_id_assignment_policy (PortableServer::IdAssignmentPolicyValue value, + CORBA::Environment &env); + + virtual PortableServer::ImplicitActivationPolicy_ptr create_implicit_activation_policy (PortableServer::ImplicitActivationPolicyValue value, + CORBA::Environment &env); + + virtual PortableServer::ServantRetentionPolicy_ptr create_servant_retention_policy (PortableServer::ServantRetentionPolicyValue value, + CORBA::Environment &env); + + virtual PortableServer::RequestProcessingPolicy_ptr create_request_processing_policy (PortableServer::RequestProcessingPolicyValue value, + CORBA::Environment &env); + + virtual CORBA::String the_name (CORBA::Environment &env); + + virtual PortableServer::POA_ptr the_parent (CORBA::Environment &env); + + virtual PortableServer::POAManager_ptr the_POAManager (CORBA::Environment &env); + + virtual PortableServer::AdapterActivator_ptr the_activator (CORBA::Environment &env); + + virtual void the_activator (PortableServer::AdapterActivator_ptr adapter_activator, + CORBA::Environment &env); + + virtual PortableServer::ServantManager_ptr get_servant_manager (CORBA::Environment &env); + + virtual void set_servant_manager (PortableServer::ServantManager_ptr imgr, + CORBA::Environment &env); + + virtual PortableServer::Servant get_servant (CORBA::Environment &env); + + virtual void set_servant (PortableServer::Servant servant, + CORBA::Environment &env); + + virtual PortableServer::ObjectId *activate_object (PortableServer::Servant p_servant, + CORBA::Environment &env); + + virtual void activate_object_with_id (const PortableServer::ObjectId &id, + PortableServer::Servant p_servant, + CORBA::Environment &env); + + virtual void deactivate_object (const PortableServer::ObjectId &oid, + CORBA::Environment &env); + + virtual CORBA::Object_ptr create_reference (const char *intf, + CORBA::Environment &env); + + virtual CORBA::Object_ptr create_reference_with_id (const PortableServer::ObjectId &oid, + const char *intf, + CORBA::Environment &env); + virtual PortableServer::ObjectId *servant_to_id (PortableServer::Servant p_servant, + CORBA::Environment &env); + + virtual CORBA::Object_ptr servant_to_reference (PortableServer::Servant p_servant, + CORBA::Environment &env); + + virtual PortableServer::Servant reference_to_servant (CORBA::Object_ptr reference, + CORBA::Environment &env); + + virtual PortableServer::ObjectId *reference_to_id (CORBA::Object_ptr reference, + CORBA::Environment &env); + + virtual PortableServer::Servant id_to_servant (const PortableServer::ObjectId &oid, + CORBA::Environment &env); + + virtual CORBA::Object_ptr id_to_reference (const PortableServer::ObjectId &oid, + CORBA::Environment &env); + + + // Utility functions for the other + static void encode_sequence_to_string (CORBA::String &str, + const TAO_Unbounded_Sequence<CORBA::Octet> &seq); + static void decode_string_to_sequence (TAO_Unbounded_Sequence<CORBA::Octet> &seq, + CORBA::String str); + + static CORBA::String ObjectId_to_string (const PortableServer::ObjectId &id); + + static CORBA::WString ObjectId_to_wstring (const PortableServer::ObjectId &id); + + static PortableServer::ObjectId *string_to_ObjectId (const char *id); + + static PortableServer::ObjectId *string_to_ObjectId (const char *string, + int size); + + static PortableServer::ObjectId *wstring_to_ObjectId (const CORBA::WChar *id); + + TAO_POA (const String &adapter_name, + TAO_POA_Manager &poa_manager, + const TAO_POA_Policies &policies, + TAO_POA *parent, + CORBA::Environment &env); + + TAO_POA (const String &adapter_name, + TAO_POA_Manager &poa_manager, + const TAO_POA_Policies &policies, + TAO_POA *parent, + TAO_Object_Table &active_object_map, + CORBA::Environment &env); + + virtual TAO_POA *clone (const String &adapter_name, + TAO_POA_Manager &poa_manager, + const TAO_POA_Policies &policies, + TAO_POA *parent, + CORBA::Environment &env); + + virtual TAO_POA *clone (const String &adapter_name, + TAO_POA_Manager &poa_manager, + const TAO_POA_Policies &policies, + TAO_POA *parent, + TAO_Object_Table &active_object_map, + CORBA::Environment &env); + + virtual ~TAO_POA (void); + + virtual void dispatch_servant (const TAO_ObjectKey &key, + CORBA::ServerRequest &req, + void *context, + CORBA::Environment &env); + + virtual int locate_servant (const TAO_ObjectKey &key, + CORBA::Environment &env); + + virtual PortableServer::Servant find_servant (const TAO_ObjectKey &key, + CORBA::Environment &env); + + static char name_separator (void); + + static char id_separator (void); + + static CORBA::ULong name_separator_length (void); + + static CORBA::ULong id_separator_length (void); + +protected: + + virtual TAO_POA *create_POA (const String &adapter_name, + TAO_POA_Manager &poa_manager, + const TAO_POA_Policies &policies, + CORBA::Environment &env); + + virtual TAO_POA *create_POA_i (const String &adapter_name, + TAO_POA_Manager &poa_manager, + const TAO_POA_Policies &policies, + CORBA::Environment &env); + + virtual TAO_POA *find_POA (const String &adapter_name, + CORBA::Boolean activate_it, + CORBA::Environment &env); + + virtual TAO_POA *find_POA_i (const String &adapter_name, + CORBA::Boolean activate_it, + CORBA::Environment &env); + + virtual TAO_POA *find_POA_i_optimized (const String &adapter_name, + CORBA::Boolean activate_it, + CORBA::Environment &env); + + virtual void destroy_i (CORBA::Boolean etherealize_objects, + CORBA::Boolean wait_for_completion, + CORBA::Environment &env); + + virtual PortableServer::ServantManager_ptr get_servant_manager_i (CORBA::Environment &env); + + virtual void set_servant_manager_i (PortableServer::ServantManager_ptr imgr, + CORBA::Environment &env); + + virtual PortableServer::Servant get_servant_i (CORBA::Environment &env); + + virtual void set_servant_i (PortableServer::Servant servant, + CORBA::Environment &env); + + virtual PortableServer::ObjectId *activate_object_i (PortableServer::Servant p_servant, + CORBA::Environment &env); + + virtual void activate_object_with_id_i (const PortableServer::ObjectId &id, + PortableServer::Servant p_servant, + CORBA::Environment &env); + + virtual void deactivate_object_i (const PortableServer::ObjectId &oid, + CORBA::Environment &env); + + virtual CORBA::Object_ptr create_reference_i (const char *intf, + CORBA::Environment &env); + + virtual PortableServer::ObjectId *servant_to_id_i (PortableServer::Servant servant, + CORBA::Environment &env); + + virtual PortableServer::Servant id_to_servant_i (const PortableServer::ObjectId &oid, + CORBA::Environment &env); + + virtual CORBA::Object_ptr id_to_reference_i (const PortableServer::ObjectId &oid, + CORBA::Environment &env); + + virtual ACE_Lock &lock (void); + + virtual TAO_POA_Policies &policies (void); + + virtual TAO_Object_Table &active_object_map (void); + + virtual void delete_child (const String &child, + CORBA::Environment &env); + + virtual void delete_child_i (const String &child, + CORBA::Environment &env); + + virtual String complete_name (void); + + virtual void set_complete_name (void); + + virtual int leaf_poa_name (const String &adapter_name, + CORBA::Environment &env); + + virtual void parse_poa_name (const TAO_POA::String &adapter_name, + TAO_POA::String &topmost_poa_name, + TAO_POA::String &tail_poa_name, + CORBA::Environment &env); + + virtual PortableServer::ObjectId *create_object_id (void); + + virtual TAO_ObjectKey *create_object_key (const PortableServer::ObjectId &id); + + virtual int is_poa_generated_id (const PortableServer::ObjectId &id); + + virtual int is_poa_generated_key (const TAO_ObjectKey &key); + + virtual int parse_key_permanent_id (const TAO_ObjectKey &key, + String &poa_name, + PortableServer::ObjectId_out id, + CORBA::Boolean &persistent, + TAO_Temporary_Creation_Time &poa_creation_time); + + virtual int parse_key_temporary_id (const TAO_ObjectKey &key, + String &poa_name, + PortableServer::ObjectId_out id, + CORBA::Boolean &persistent, + TAO_Temporary_Creation_Time &poa_creation_time); + + virtual int parse_key (const TAO_ObjectKey &key, + String &poa_name, + PortableServer::ObjectId_out id, + CORBA::Boolean &persistent, + TAO_Temporary_Creation_Time &poa_creation_time, + int temporary_id); + + virtual int rfind (const TAO_ObjectKey &key, + char c, + int pos = TAO_POA::String::npos) const; + +// Should really be protected, but some compilers complain +public: + enum LOCATION_RESULT + { + FOUND, + DEFAULT_SERVANT, + SERVANT_MANAGER, + NOT_FOUND + }; + +protected: + virtual LOCATION_RESULT locate_servant_i (const TAO_ObjectKey &key, + PortableServer::Servant &servant, + CORBA::Environment &env); + + virtual PortableServer::Servant locate_poa_and_servant_i (const TAO_ObjectKey &key, + const char *operation, + PortableServer::ObjectId_out id, + TAO_POA *&poa_impl, + CORBA::Environment &env); + + virtual TAO_POA *locate_poa_i (const TAO_ObjectKey &key, + PortableServer::ObjectId_out id, + CORBA::Environment &env); + + virtual void dispatch_servant_i (const TAO_ObjectKey &key, + CORBA::ServerRequest &req, + void *context, + CORBA::Environment &env); + + virtual void pre_invoke (const TAO_ObjectKey &key, + const PortableServer::ObjectId &id, + PortableServer::Servant servant, + TAO_POA_Current *poa_current, + CORBA::Environment &env); + + virtual void post_invoke (PortableServer::Servant servant, + const char *operation, + TAO_POA_Current *poa_current, + CORBA::Environment &env); + + virtual CORBA::Boolean persistent (void); + + virtual const TAO_Creation_Time &creation_time (void); + + virtual char object_key_type (void); + + static char persistent_key_type (void); + + static char transient_key_type (void); + + static CORBA::ULong object_key_type_length (void); + + String name_; + + String complete_name_; + + TAO_POA_Manager &poa_manager_; + + TAO_POA_Policies policies_; + + TAO_POA *parent_; + + TAO_Object_Table *active_object_map_; + + int delete_active_object_map_; + + PortableServer::AdapterActivator_var adapter_activator_; + + PortableServer::ServantActivator_var servant_activator_; + + PortableServer::ServantLocator_var servant_locator_; + + PortableServer::Servant default_servant_; + + typedef ACE_Map_Manager<String, TAO_POA *, ACE_Null_Mutex> CHILDREN; + + CHILDREN children_; + + ACE_Lock_Adapter<ACE_Null_Mutex> lock_; + + int closing_down_; + + CORBA::ULong counter_; + + TAO_Creation_Time creation_time_; + + static const int max_space_required_for_ulong; +}; + +class TAO_Export TAO_POA_Manager : public POA_PortableServer::POAManager +{ + friend class TAO_POA; + +public: + enum Processing_State + { + ACTIVE, + DISCARDING, + HOLDING, + INACTIVE, + UNKNOWN + }; + + virtual void activate (CORBA::Environment &env); + + virtual void hold_requests (CORBA::Boolean wait_for_completion, + CORBA::Environment &env); + + virtual void discard_requests (CORBA::Boolean wait_for_completion, + CORBA::Environment &env); + + virtual void deactivate (CORBA::Boolean etherealize_objects, + CORBA::Boolean wait_for_completion, + CORBA::Environment &env); + + TAO_POA_Manager (void); + + virtual TAO_POA_Manager *clone (void); + + virtual ~TAO_POA_Manager (void); + + virtual Processing_State state (CORBA::Environment &env); + +protected: + + virtual ACE_Lock &lock (void); + + virtual void remove_poa (TAO_POA *poa, + CORBA::Environment &env); + + virtual void remove_poa_i (TAO_POA *poa, + CORBA::Environment &env); + + virtual void register_poa (TAO_POA *poa, + CORBA::Environment &env); + + virtual void register_poa_i (TAO_POA *poa, + CORBA::Environment &env); + + Processing_State state_; + + int closing_down_; + + ACE_Lock_Adapter<ACE_Null_Mutex> lock_; + + typedef ACE_Unbounded_Set<TAO_POA *> POA_COLLECTION; + + POA_COLLECTION poa_collection_; +}; + +class TAO_Export TAO_Adapter_Activator : public POA_PortableServer::AdapterActivator +{ +public: + + virtual CORBA::Boolean unknown_adapter (PortableServer::POA_ptr parent, + const char *name, + CORBA::Environment &env); +}; + +class TAO_Export TAO_Strategy_POA : public TAO_POA +{ +public: + + TAO_Strategy_POA (const String &adapter_name, + TAO_POA_Manager &poa_manager, + const TAO_POA_Policies &policies, + TAO_POA *parent, + CORBA::Environment &env); + + TAO_Strategy_POA (const String &adapter_name, + TAO_POA_Manager &poa_manager, + const TAO_POA_Policies &policies, + TAO_POA *parent, + TAO_Object_Table &active_object_map, + CORBA::Environment &env); + + virtual TAO_POA *clone (const String &adapter_name, + TAO_POA_Manager &poa_manager, + const TAO_POA_Policies &policies, + TAO_POA *parent, + CORBA::Environment &env); + + virtual TAO_POA *clone (const String &adapter_name, + TAO_POA_Manager &poa_manager, + const TAO_POA_Policies &policies, + TAO_POA *parent, + TAO_Object_Table &active_object_map, + CORBA::Environment &env); + + virtual ~TAO_Strategy_POA (void); + +protected: + + virtual ACE_Lock &lock (void); + + ACE_Lock *lock_; + + typedef TAO_Strategy_POA SELF; +}; + +class TAO_Export TAO_Strategy_POA_Manager : public TAO_POA_Manager +{ +public: + + TAO_Strategy_POA_Manager (void); + + virtual TAO_POA_Manager *clone (void); + + virtual ~TAO_Strategy_POA_Manager (void); + +protected: + + virtual ACE_Lock &lock (void); + + ACE_Lock *lock_; + + typedef TAO_Strategy_POA_Manager SELF; +}; + +class TAO_Export TAO_POA_Current : public POA_PortableServer::Current +{ + // = TITLE + // + // Implementation of the PortableServer::Current object. + // + // = DESCRIPTION + // + // Objects of this class hold state information regarding the + // current POA invocation. Savvy readers will notice that this + // contains substantially more methods than the POA spec shows; they + // exist because the ORB either (a) needs them or (b) finds them + // useful for implementing a more efficient ORB. + // + // The intent is that instances of this class are held in + // Thread-Specific Storage so that upcalls can get context + // information regarding their invocation. The POA itself must + // insure that all <set_*> operations are performed in the execution + // thread so that the proper <TAO_POA_Current> pointer is obtained + // from TSS. + +public: + // = Specification-mandated methods + + virtual PortableServer::POA_ptr get_POA (CORBA::Environment &env); + // Return pointer to the invoking POA. Raises the + // <CORBA::NoContext> exception. + + virtual PortableServer::ObjectId *get_object_id (CORBA::Environment &env); + // Return pointer to the object id through which this was invoked. + // This may be necessary in cases where a <Servant> is serving under + // the guise of multiple object ids. This has _out semantics Raises + // the <CORBA::NoContext> exception. + + // = TAO Extensions + + virtual void clear (void); + // Clear any prior settings made. This will make things which can + // throw the <CORBA::NoContext> exception raise it if invoked + // without a corresponding <set_*> operation. + + virtual int context_is_valid (void); + // Returns non-zero if the context is valid, i.e., if it would be + // impossible for a <CORBA::NoContext> exception to be raised. + + virtual void POA_impl (TAO_POA *impl); + // Set the POA implementation. + + virtual TAO_POA *POA_impl (void) const; + // Get the POA imeplemantation + + virtual void object_id (const PortableServer::ObjectId &id); + // Set the object ID. + + virtual const PortableServer::ObjectId &object_id (void) const; + // Get the object ID. + + virtual void object_key (const TAO_ObjectKey &key); + // Set the object key. + + virtual const TAO_ObjectKey &object_key (void) const; + // Get the object key. + + virtual void servant (PortableServer::Servant servant); + // Set the servant for the current upcall. + + virtual PortableServer::Servant servant (void) const; + // Get the servant for the current upcall. + + virtual int in_upcall (void) const; + // Get whether we're in an upcall (non-zero is yes). + + virtual PortableServer::ServantLocator::Cookie locator_cookie (void) const; + // Get the Servant Locator's cookie + + virtual void locator_cookie (PortableServer::ServantLocator::Cookie cookie); + // Set the Servant Locator's cookie + + TAO_POA_Current (void); + // Constructor + + TAO_POA_Current (TAO_POA *impl, + const TAO_ObjectKey &key, + const PortableServer::ObjectId &id, + PortableServer::Servant servant); + // Convenience constructor combining construction & initialization. + + virtual ~TAO_POA_Current (void); + // Destructor + +private: + TAO_POA *poa_impl_; + // The POA implementation invoking an upcall + + const PortableServer::ObjectId *object_id_; + // The object ID of the current context. + + const TAO_ObjectKey *object_key_; + // The object key of the current context. + + PortableServer::ServantLocator::Cookie cookie_; + // Servant Locator's cookie + + PortableServer::Servant servant_; + // The servant for the current upcall. + + // = Hidden because we don't allow these + TAO_POA_Current (const TAO_POA_Current &); + void operator= (const TAO_POA_Current &); +}; + +#endif /* POA_H */ |