*** empty log message ***

1 files changed, 426 insertions, 0 deletions

diff --git a/TAO/tao/ORB_Core.h b/TAO/tao/ORB_Core.h
new file mode 100644
index 00000000000..363e93df621
--- /dev/null
+++ b/TAO/tao/ORB_Core.h
@@ -0,0 +1,426 @@
+// This may look like C, but it's really -*- C++ -*-
+
+// ============================================================================
+//
+// = LIBRARY
+//     TAO
+//
+// = FILENAME
+//     orb_core.h
+//
+// = AUTHOR
+//     Chris Cleeland
+//
+// = VERSION
+//     $Id$
+// ============================================================================
+
+#if !defined (TAO_ORB_CORE_H)
+#  define TAO_ORB_CORE_H
+
+#  include "tao/corba.h"
+
+typedef ACE_Strategy_Connector<TAO_Client_Connection_Handler, ACE_SOCK_CONNECTOR>
+	TAO_CONNECTOR;
+
+typedef ACE_Cached_Connect_Strategy<TAO_Client_Connection_Handler,
+	                            ACE_SOCK_CONNECTOR,
+				    ACE_SYNCH_RW_MUTEX>
+        TAO_CACHED_CONNECT_STRATEGY;
+
+typedef ACE_NOOP_Creation_Strategy<TAO_Client_Connection_Handler>
+	TAO_NULL_CREATION_STRATEGY;
+
+typedef ACE_NOOP_Concurrency_Strategy<TAO_Client_Connection_Handler>
+        TAO_NULL_ACTIVATION_STRATEGY;
+
+// Forward decl.
+class TAO_Resource_Factory;
+
+class TAO_Export TAO_ORB_Core
+{
+  // = TITLE
+  //    Encapsulates the state of an ORB.
+  //
+  // = DESCRIPTION
+  //    This class encapsulates the state of an ORB.  The motivation for
+  //    this is so that the state can be accessed as a singleton.  The scope
+  //    of the state can be regulated by utilizing singletons of different
+  //    scope, e.g., <ACE_Singleton> will provide process-wide scope, while
+  //    <ACE_TSS_Singleton> will provide thread-specific scope (which
+  //    is useful for the "thread-per-rate" real-time concurrency
+  //    model).
+  friend class CORBA_ORB;
+  friend CORBA::ORB_ptr CORBA::ORB_init (int &,
+					 char * const*,
+					 const char *,
+					 CORBA::Environment &);
+public:
+  // = Initialization and termination methods.
+  TAO_ORB_Core (void);
+  // Constructor.
+
+  ~TAO_ORB_Core (void);
+  // Destructor
+
+  // = Accessors
+  CORBA_ORB_ptr orb (void);
+  // Should this be IIOP_ORB?
+
+  ACE_Reactor *reactor (void);
+  // Accessors for the <ACE_Reactor>.
+
+  ACE_Thread_Manager *thr_mgr (void);
+  // Accessor for the <ACE_Thread_Manager>.
+
+  TAO_POA *root_poa (void);
+  // Acceptor for the POA.
+
+  TAO_OA_Parameters *oa_params (void);
+  // Accessor for the Object Adapter parameters.
+
+  TAO_ORB_Parameters *orb_params (void);
+  // Accessor for the ORB parameters.
+
+  ACE_INET_Addr &addr (void);
+  // Accessors for the local address on which we're listening.
+
+  TAO_CONNECTOR *connector (void);
+  // Accessor which returns the connector.
+
+  TAO_ACCEPTOR *acceptor (void);
+  // Accessor which returns the acceptor.
+
+  TAO_POA_Current *poa_current (void);
+  // Accessor which returns a pointer to a structure containing
+  // context on the current POA upcall.
+
+  TAO_POA_Current *poa_current (TAO_POA_Current *new_current);
+  // Sets the thread-specific pointer to the new POA Current state,
+  // returning a pointer to the existing POA Current state.
+
+  // = Access to Factories.
+  //
+  // These factories are not thread-specific, and are presented here
+  // in order to have one place to get useful information.  Often, the
+  // instances to which the return pointers are stored in the Service
+  // Repository.
+
+  TAO_Resource_Factory *resource_factory (void);
+  // Returns pointer to the resource factory.
+  TAO_Client_Strategy_Factory *client_factory (void);
+  // Returns pointer to the client factory.
+  TAO_Server_Strategy_Factory *server_factory (void);
+  // Returns pointer to the server factory.
+
+private:
+  int init (int& argc, char ** argv);
+  // Initialize the guts of the ORB Core.  It is intended that this be
+  // called by <CORBA::ORB_init>.
+
+  int fini (void);
+  // Final termination hook, typically called by CORBA::ORB's DTOR.
+
+  int preconnect (const char *preconnections);
+  // Attempt to establish connections specified in <preconnections>.
+  // Returns -1 in case of error, or the number of connections
+  // actually established.
+
+  void orb (CORBA::ORB_ptr);
+  // Set pointer to the ORB.
+  CORBA::ORB_ptr orb_;
+
+  void reactor (ACE_Reactor *r);
+  ACE_Reactor* reactor_;
+  // Used for responding to I/O reactively
+
+  void thr_mgr (ACE_Thread_Manager *tm);
+  ACE_Thread_Manager* thr_mgr_;
+  // Used to manage threads within the ORB
+
+  void connector (TAO_CONNECTOR *c);
+  TAO_CONNECTOR *connector_;
+  // The connector actively initiating connection requests.
+
+  void root_poa (TAO_POA *np);
+  TAO_POA *root_poa_;
+  // Pointer to the root POA.  It will eventually be the pointer
+  // returned by calls to CORBA::ORB::resolve_initial_references
+  // ("RootPOA").
+
+  TAO_OA_Parameters *oa_params_;
+  // Parameters which should be used by OAs attached to this ORB.
+
+  TAO_ORB_Parameters *orb_params_;
+  // Parameters used by the ORB.
+
+  ACE_INET_Addr *addr_;
+  // The address of the endpoint on which we're listening for
+  // connections and requests.
+
+  void acceptor (TAO_ACCEPTOR *a);
+  TAO_ACCEPTOR *acceptor_;
+  // The acceptor passively listening for connection requests.
+
+#if defined (TAO_HAS_CLIENT_CONCURRENCY)
+  CONCURRENCY_STRATEGY *concurrency_strategy_;
+#endif /* TAO_HAS_CLIENT_CONCURRENCY */
+
+  TAO_POA_Current *poa_current_;
+  // Points to structure containing state for the current upcall
+  // context in this thread.  Note that it does not come from the
+  // resource factory because it must always be held in
+  // thread-specific storage.  For now, since TAO_ORB_Core instances
+  // are TSS singletons, we simply ride along and don't allocate
+  // occupy another TSS slot since there are some platforms where
+  // those are precious commodities (e.g., NT).
+
+  TAO_NULL_CREATION_STRATEGY null_creation_strategy_;
+  // This no-op creation strategy is necessary for using the
+  // <Strategy_Connector> with the <Cached_Connect_Strategy>.
+
+  TAO_CACHED_CONNECT_STRATEGY caching_connect_strategy_;
+  // This connection strategy maintain a cache of preconnected
+  // <TAO_Client_Connection_Handler>s.  The goal is to reduce latency
+  // and locking overhead.
+
+  TAO_NULL_ACTIVATION_STRATEGY null_activation_strategy_;
+  // This no-op activation strategy prevents the cached connector from
+  // calling the service handler's <open> method multiple times.
+
+  TAO_Resource_Factory *resource_factory_;
+  // Handle to the factory for resource information..
+
+  CORBA::Boolean resource_factory_from_service_config_;
+  // TRUE if <resource_factory_> was obtained from the Service
+  // Configurator.
+
+  TAO_Client_Strategy_Factory *client_factory_;
+  // Handle to the factory for Client-side strategies.
+
+  CORBA::Boolean client_factory_from_service_config_;
+  // TRUE if <client_factory_> was obtained from the Service
+  // Configurator.
+
+  TAO_Server_Strategy_Factory *server_factory_;
+  // Handle to the factory for Server-side strategies.
+
+  CORBA::Boolean server_factory_from_service_config_;
+  // TRUE if <server_factory_> was obtained from the Service
+  // Configurator.
+
+  char *preconnections_;
+  // A string of comma-separated <{host}>:<{port}> pairs used to
+  // pre-establish connections using <preconnect>.
+};
+
+class TAO_Default_Reactor : public ACE_Reactor
+{
+  // = TITLE
+  //   Force TAO to use Select Reactor.
+public:
+  // = Initialization and termination methods.
+  TAO_Default_Reactor (void);
+  ~TAO_Default_Reactor (void);
+
+private:
+  ACE_Reactor_Impl *reactor_impl_;
+};
+
+class TAO_Export TAO_Resource_Factory : public ACE_Service_Object
+{
+  // = TITLE
+  //   Factory which manufacturers resources for use by the ORB Core.
+  //
+  // = DESCRIPTION
+  //   This class is a factory/repository for critical ORB Core
+  //   resources.  Using a <{resource source specifier}> as a
+  //   discriminator, the factory can return resource instances which
+  //   are, e.g., global, stored in thread-specific storage, stored in
+  //   shared memory, etc.
+
+public:
+  // = Initialization and termination methods.
+  TAO_Resource_Factory (void);
+  virtual ~TAO_Resource_Factory (void);
+
+  // = Service Configurator hooks.
+  virtual int init (int argc, char *argv[]);
+
+  int parse_args (int argc, char *argv[]);
+  // Arguments are in the form of -ORBxxx.  Valid arguments are:
+  // <-ORBresources> <{which}> where <{which}> is one of <global> or
+  // <tss>.
+
+  // = Member Accessors
+  enum
+  {
+    TAO_GLOBAL,
+    TAO_TSS
+  };
+
+  // = Range of values for <{resource source specifier}>.
+  void resource_source (int which_source);
+  // Set the resource source specifier.
+  int resource_source (void);
+  // Get the resource source specifier.
+
+  void poa_source (int which_source);
+  // Set the POA source specifier.
+  int poa_source (void);
+  // Get the POA source specifier.
+
+  // = Resource Retrieval
+  //
+  // Methods in this category return pointers to resources.  Based on
+  // the resource source specifier value, these resources may be
+  // either global, i.e., the same resource is used across all threads
+  // throughout the process, or thread-specific, i.e., different
+  // resources are used in each thread.  Currently, all resources are
+  // either global or thread-specific; choosing on a per-resource
+  // basis is not supported.
+
+  ACE_Reactor *get_reactor (void);
+  // Return an <ACE_Reactor> to be utilized.
+
+  ACE_Thread_Manager *get_thr_mgr (void);
+  // Return an <ACE_Thread_Manager> to be utilized.
+
+  TAO_CONNECTOR *get_connector (void);
+  // Return an Connector to be utilized.
+
+  TAO_ACCEPTOR *get_acceptor (void);
+  // Return an Acceptor to be utilized.
+
+  TAO_ORB_Parameters *get_orb_params (void);
+  // Return ORB parameters to be utilized.
+
+  TAO_OA_Parameters *get_oa_params (void);
+  // Return ORB parameters to be utilized.
+
+  ACE_INET_Addr *get_addr (void);
+  // Return an address to be used for the endpoint for connections and
+  // requests.
+
+  CORBA::ORB_ptr get_orb (void);
+  // Return an ORB ptr to be utilized.
+
+  TAO_POA *get_root_poa (void);
+  // Return a root poa to be utilized.
+
+  ACE_Allocator *get_allocator (void);
+  // Return a pointer to an ACE_Allocator used for allocating memory
+  // within the ORB.
+
+  void set_allocator (ACE_Allocator *alloc);
+  // Set the allocator pointer which will be returned by
+  // <get_allocator()>.
+
+  void set_orb (CORBA::ORB_ptr op);
+  // Set the ORB pointer which will be returned by <get_orb()>.  This
+  // is necessary because the ORB is created in application space by
+  // <CORBA::ORB_init()>, but needs to be available to stubs and
+  // generated code.
+
+  void set_root_poa (TAO_POA *pp);
+  // Set the Root POA pointer which will be returned by
+  // <get_root_poa()>.  This is necessary because the Root POA is
+  // created in application space by <CORBA::ORB_init()>, but needs to
+  // be available to stubs and generated code.
+
+  // @@ I suspect that putting these structs inside of this class is
+  // going to break some compilers (e.g., HP/YUX) when you try to use
+  // this stuff with the ACE_Singletons below.  I suggest you move
+  // them out and rename them as TAO_Pre_Allocated, etc.
+  //
+  // Let's do this after we merge the poa branch and the main back
+  // together.
+  struct Pre_Allocated
+    // = TITLE
+    //   Structure containing resources which can be pre-allocated by
+    //   the ORB Core without intervention from the application.
+  {
+    TAO_Default_Reactor r_;
+    // The Reactor.
+
+    ACE_Thread_Manager tm_;
+    // The Thread Manager
+
+    TAO_CONNECTOR c_;
+    // The Connector
+
+    TAO_ACCEPTOR a_;
+    // The Acceptor
+
+    TAO_ORB_Parameters orbparams_;
+    // ORB Parameters
+
+    TAO_OA_Parameters oaparams_;
+    // OA Parameters (will go away with new POA impl)
+
+    ACE_INET_Addr addr_;
+    // Address for connection endpoint.
+  };
+
+  struct App_Allocated
+    // = TITLE
+    //   Structure containing resources which can only be allocated
+    //   after obtaining information from the application such as
+    //   arguments, etc.
+  {
+    App_Allocated (void): orb_(0), poa_(0), alloc_(0) { };
+    // Constructor necessary because we have pointers.  It's inlined
+    // here rather than in the .i file because it's easier than trying
+    // to re-order header files in corba.h to eliminate the "used
+    // before declared inline" warnings/errors on certain compilers.
+
+    // = Resources
+
+    // Note:  These should change to _var types when they are available.
+    CORBA::ORB_ptr orb_;
+    // Pointer to application-created ORB.
+
+    TAO_POA *poa_;
+    // Pointer to application-created POA.
+
+    ACE_Allocator *alloc_;
+    // Pointer to application-created ACE_Allocator.
+  };
+
+private:
+
+  int resource_source_;
+  // Flag indicating whether resources should be global or
+  // thread-specific.
+
+  int poa_source_;
+  // Flag indicating whether the POA should be global or
+  // thread-specific.  If not set specifically, this takes on the
+  // value of <resource_source_>.
+
+  // = Typedefs for the singleton types used to store our orb core
+  // information.
+  typedef ACE_Singleton<Pre_Allocated, ACE_SYNCH_MUTEX>
+          GLOBAL_PRE_ALLOCATED;
+  typedef ACE_TSS_Singleton<Pre_Allocated, ACE_SYNCH_MUTEX>
+          TSS_PRE_ALLOCATED;
+
+  typedef ACE_Singleton<App_Allocated, ACE_SYNCH_MUTEX>
+          GLOBAL_APP_ALLOCATED;
+  typedef ACE_TSS_Singleton<App_Allocated, ACE_SYNCH_MUTEX>
+          TSS_APP_ALLOCATED;
+};
+
+ACE_FACTORY_DECLARE (TAO, TAO_Resource_Factory)
+
+extern TAO_Export TAO_ORB_Core *TAO_ORB_Core_instance (void);
+
+// Declare that the following method should be specialized.
+
+#if defined (ACE_WIN32)
+#pragma warning(disable:4231)
+extern template size_t
+ACE_Hash_Addr<ACE_INET_Addr>::hash_i (const ACE_INET_Addr &addr) const;
+#endif /* ACE_WIN32 */
+
+#endif /* TAO_ORB_CORE_H */