TAO/tao/Resource_Factory.h

   1 // -*- C++ -*-
   2
   3 //=============================================================================
   4 /**
   5  *  @file   Resource_Factory.h
   6  *
   7  *  @author Chris Cleeland
   8  *  @author Carlos O'Ryan
   9  */
  10 //=============================================================================
  11
  12 #ifndef TAO_RESOURCE_FACTORY_H
  13 #define TAO_RESOURCE_FACTORY_H
  14
  15 #include /**/ "ace/pre.h"
  16
  17 #include /**/ "tao/TAO_Export.h"
  18
  19 #if !defined (ACE_LACKS_PRAGMA_ONCE)
  20 # pragma once
  21 #endif /* ACE_LACKS_PRAGMA_ONCE */
  22
  23 #include /**/ "tao/Versioned_Namespace.h"
  24 #include "tao/Basic_Types.h"
  25
  26 #include <memory>
  27 #include "ace/Service_Object.h"
  28 #include "ace/Unbounded_Set.h"
  29 #include "ace/SString.h"
  30 #include "ace/CDR_Base.h"
  31
  32
  33 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  34 class ACE_Lock;
  35 ACE_END_VERSIONED_NAMESPACE_DECL
  36
  37 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
  38
  39 class TAO_Protocol_Factory;
  40 class TAO_Acceptor_Registry;
  41 class TAO_Connector_Registry;
  42
  43 class TAO_Flushing_Strategy;
  44 class TAO_Connection_Purging_Strategy;
  45 class TAO_LF_Strategy;
  46 class TAO_Codeset_Manager;
  47 class TAO_GIOP_Fragmentation_Strategy;
  48 class TAO_Transport;
  49
  50 // ****************************************************************
  51
  52 class TAO_Export TAO_Protocol_Item
  53 {
  54 public:
  55   /// Creator method, the protocol name can only be set when the
  56   /// object is created.
  57   TAO_Protocol_Item (const ACE_CString &name);
  58
  59   /// Destructor that deallocates the factory object if the
  60   /// Protocol_Item retains ownership.
  61   ~TAO_Protocol_Item ();
  62
  63   /// Return a reference to the character representation of the protocol
  64   /// factories name.
  65   const ACE_CString &protocol_name ();
  66
  67   /// Return a pointer to the protocol factory.
  68   TAO_Protocol_Factory *factory ();
  69
  70   /// Set the factory pointer's value.
  71   void factory (TAO_Protocol_Factory *factory, int owner = 0);
  72
  73 private:
  74   TAO_Protocol_Item (const TAO_Protocol_Item&) = delete;
  75   void operator= (const TAO_Protocol_Item&) = delete;
  76   TAO_Protocol_Item (TAO_Protocol_Item&&) = delete;
  77   void operator= (TAO_Protocol_Item&&) = delete;
  78
  79 private:
  80   /// Protocol factory name.
  81   ACE_CString name_;
  82
  83   /// Pointer to factory object.
  84   TAO_Protocol_Factory *factory_;
  85
  86   /// Whether we own (and therefore have to delete) the factory object.
  87   int factory_owner_;
  88 };
  89
  90 // typedefs for containers containing the list of loaded protocol
  91 // factories.
  92 typedef ACE_Unbounded_Set<TAO_Protocol_Item*>
  93         TAO_ProtocolFactorySet;
  94
  95 typedef ACE_Unbounded_Set_Iterator<TAO_Protocol_Item*>
  96         TAO_ProtocolFactorySetItor;
  97
  98 // ****************************************************************
  99
 100 /**
 101  * @class TAO_Resource_Factory
 102  *
 103  * @brief Factory which manufacturers resources for use by the ORB Core.
 104  *
 105  * This class is a factory/repository for critical ORB Core
 106  * resources.
 107  */
 108 class TAO_Export TAO_Resource_Factory : public ACE_Service_Object
 109 {
 110 public:
 111   enum Purging_Strategy
 112   {
 113     /// Least Recently Used
 114     LRU,
 115
 116     /// Least Frequently Used
 117     LFU,
 118
 119     /// First In First Out
 120     FIFO,
 121
 122     /// Dont use any strategy.
 123     NOOP
 124   };
 125
 126   enum Resource_Usage
 127     {
 128       /// Use resources in an eager fashion
 129       TAO_EAGER,
 130
 131       /// Use resources in a lazy manner
 132       TAO_LAZY
 133     };
 134
 135   TAO_Resource_Factory ();
 136   virtual ~TAO_Resource_Factory ();
 137
 138   // = Resource Retrieval
 139
 140   /// @@ Backwards compatibility, return 1 if the ORB core should use
 141   ///    Locked_Data_Blocks
 142   virtual int use_locked_data_blocks () const;
 143
 144   /// Return an ACE_Reactor to be utilized.
 145   virtual ACE_Reactor *get_reactor ();
 146
 147   /// Reclaim reactor resources (e.g. deallocate, etc).
 148   virtual void reclaim_reactor (ACE_Reactor *reactor);
 149
 150   /// Return a reference to the acceptor registry.
 151   virtual TAO_Acceptor_Registry *get_acceptor_registry ();
 152
 153   /// Return a connector to be utilized.
 154   virtual TAO_Connector_Registry *get_connector_registry ();
 155
 156   /// Return the Allocator's memory pool type
 157   virtual void use_local_memory_pool (bool);
 158
 159   /// @name Access the input CDR allocators.
 160   //@{
 161   virtual ACE_Allocator* input_cdr_dblock_allocator ();
 162   virtual ACE_Allocator* input_cdr_buffer_allocator ();
 163   virtual ACE_Allocator* input_cdr_msgblock_allocator ();
 164   //@}
 165
 166   // Return 1 when the input CDR allocator uses a lock else 0.
 167   virtual int input_cdr_allocator_type_locked ();
 168
 169   /// @name Access the output CDR allocators.
 170   //@{
 171   virtual ACE_Allocator* output_cdr_dblock_allocator ();
 172   virtual ACE_Allocator* output_cdr_buffer_allocator ();
 173   virtual ACE_Allocator* output_cdr_msgblock_allocator ();
 174   //@}
 175
 176   /// Access the AMH response handler allocator
 177   virtual ACE_Allocator* amh_response_handler_allocator ();
 178
 179   /// Access the AMI response handler allocator
 180   virtual ACE_Allocator* ami_response_handler_allocator ();
 181
 182   /**
 183    * The protocol factory list is implemented in this class since
 184    * a) it will be a global resource and
 185    * b) it is initialized at start up and then not altered.
 186    * Returns a container holding the list of loaded protocols.
 187    */
 188   virtual TAO_ProtocolFactorySet *get_protocol_factories ();
 189
 190   /**
 191    * This method will loop through the protocol list and
 192    * using the protocol name field this method will
 193    * retrieve a pointer to the associated protocol factory
 194    * from the service configurator.  It is assumed
 195    * that only one thread will call this method at ORB initialization.
 196    * NON-THREAD-SAFE
 197    */
 198   virtual int init_protocol_factories ();
 199
 200   /// Gets the codeset manager.
 201   virtual TAO_Codeset_Manager* codeset_manager ();
 202
 203   /// This denotes the maximum number of connections that can be cached.
 204   virtual int cache_maximum () const;
 205
 206   /// This denotes the amount of entries to remove from the connection
 207   /// cache.
 208   virtual int purge_percentage () const;
 209
 210   /// Return the number of muxed connections that are allowed for a
 211   /// remote endpoint
 212   virtual int max_muxed_connections () const;
 213
 214   virtual int get_parser_names (char **&names,
 215                                 int &number_of_names);
 216
 217   /// Creates the lock for the lock needed in the Cache Map
 218   /// @deprecated
 219   virtual ACE_Lock *create_cached_connection_lock ();
 220
 221   /// Should the transport cache have a lock or not? Return 1 if the
 222   /// transport cache needs to be locked  else return 0
 223   virtual int locked_transport_cache ();
 224
 225   /// Creates the flushing strategy.  The new instance is owned by the
 226   /// caller.
 227   virtual TAO_Flushing_Strategy *create_flushing_strategy () = 0;
 228
 229   /// Creates the connection purging strategy.
 230   virtual TAO_Connection_Purging_Strategy *create_purging_strategy () = 0;
 231
 232   /// Creates the leader followers strategy.  The new instance is owned by the
 233   /// caller.
 234   virtual TAO_LF_Strategy *create_lf_strategy () = 0;
 235
 236   /// Outgoing fragment creation strategy.
 237   virtual TAO_GIOP_Fragmentation_Strategy*
 238     create_fragmentation_strategy (TAO_Transport * transport,
 239                                    CORBA::ULong max_message_size) const = 0;
 240
 241   /// Disables the factory.  When a new factory is installed and used,
 242   /// this function should be called on the previously used (default)
 243   /// factory.  This should result in proper error reporting if the
 244   /// user attempts to set options on an unused factory.
 245   virtual void disable_factory () = 0;
 246
 247   /// Return the resource usage strategy.
 248   virtual
 249   TAO_Resource_Factory::Resource_Usage
 250   resource_usage_strategy () const = 0;
 251
 252   /// Return the value of the strategy that indicates whether
 253   /// the ORB should wait for the replies during shutdown or drop
 254   /// replies during shutdown.
 255   virtual bool drop_replies_during_shutdown () const = 0;
 256
 257 protected:
 258   /**
 259    * Loads the default protocols. This method is used so that the
 260    * advanced_resource.cpp can call the one in default_resource.cpp
 261    * without calling unnecessary functions.
 262    */
 263   virtual int load_default_protocols ();
 264 };
 265
 266 TAO_END_VERSIONED_NAMESPACE_DECL
 267
 268 #include /**/ "ace/post.h"
 269
 270 #endif /* TAO_RESOURCE_FACTORY_H */