TAO's default resource factory. More...

#include <default_resource.h>

Inheritance diagram for TAO_Default_Resource_Factory:

Collaboration diagram for TAO_Default_Resource_Factory:

Public Member Functions
	TAO_Default_Resource_Factory (void)
	Constructor.
virtual	~TAO_Default_Resource_Factory (void)
	Destructor.
Service Configurator Hooks

virtual int	init (int argc, ACE_TCHAR *argv[])
	Dynamic linking hook.
int	parse_args (int argc, ACE_TCHAR *argv[])
	Parse svc.conf arguments.
Protected Types
enum	Output_CDR_Allocator_Type { LOCAL_MEMORY_POOL, DEFAULT }
Protected Member Functions
virtual ACE_Reactor_Impl *	allocate_reactor_impl (void) const
	Obtain the reactor implementation.
int	add_to_ior_parser_names (const char *)
	Add a Parser name to the list of Parser names.
void	report_option_value_error (const ACE_TCHAR option_name, const ACE_TCHAR option_value)
virtual int	load_default_protocols (void)
Protected Attributes
int	use_locked_data_blocks_
	The type of data blocks that the ORB should use.
int	parser_names_count_
	The number of the different types of Parsers.
char **	parser_names_
	Array consisting of the names of the parsers.
int	index_
	Index of the current element in the parser_names_ array.
TAO_ProtocolFactorySet	protocol_factories_
	list of loaded protocol factories.
TAO_Resource_Factory::Purging_Strategy	connection_purging_type_
int	cache_maximum_
int	purge_percentage_
int	max_muxed_connections_
int	reactor_mask_signals_
	If <0> then we create reactors with signal handling disabled.
bool	dynamically_allocated_reactor_
int	options_processed_
int	factory_disabled_
Output_CDR_Allocator_Type	output_cdr_allocator_type_
	Type of allocator to use for output CDR buffers.
bool	use_local_memory_pool_
Private Types
enum	Lock_Type { TAO_NULL_LOCK, TAO_THREAD_LOCK }
enum	Flushing_Strategy_Type { TAO_LEADER_FOLLOWER_FLUSHING, TAO_REACTIVE_FLUSHING, TAO_BLOCKING_FLUSHING }
Private Attributes
Lock_Type	cached_connection_lock_type_
	Type of lock used by the cached connector.
Lock_Type	object_key_table_lock_type_
	Type of lock used by the corba object.
Lock_Type	corba_object_lock_type_
	Type of lock used by the corba object.
Flushing_Strategy_Type	flushing_strategy_type_
	Type of flushing strategy configured.
TAO_Codeset_Parameters	char_codeset_parameters_
TAO_Codeset_Parameters	wchar_codeset_parameters_
Resource_Usage	resource_usage_strategy_
	Resource usage strategy.
bool	drop_replies_
Member Accessors

enum	{ TAO_ALLOCATOR_THREAD_LOCK }
	Modify and get the source for the CDR allocators. More...
int	get_parser_names (char **&names, int &number_of_names)
	Modify and get the source for the CDR allocators.
int	cdr_allocator_source (void)
	Modify and get the source for the CDR allocators.
virtual int	use_locked_data_blocks (void) const
	Modify and get the source for the CDR allocators.
virtual ACE_Reactor *	get_reactor (void)
	Modify and get the source for the CDR allocators.
virtual void	reclaim_reactor (ACE_Reactor *)
	Modify and get the source for the CDR allocators.
virtual TAO_Acceptor_Registry *	get_acceptor_registry (void)
	Modify and get the source for the CDR allocators.
virtual TAO_Connector_Registry *	get_connector_registry (void)
	Modify and get the source for the CDR allocators.
virtual void	use_local_memory_pool (bool)
	Modify and get the source for the CDR allocators.
virtual ACE_Allocator *	input_cdr_dblock_allocator (void)
	Modify and get the source for the CDR allocators.
virtual ACE_Allocator *	input_cdr_buffer_allocator (void)
	Modify and get the source for the CDR allocators.
virtual ACE_Allocator *	input_cdr_msgblock_allocator (void)
	Modify and get the source for the CDR allocators.
virtual int	input_cdr_allocator_type_locked (void)
	Modify and get the source for the CDR allocators.
virtual ACE_Allocator *	output_cdr_dblock_allocator (void)
	Modify and get the source for the CDR allocators.
virtual ACE_Allocator *	output_cdr_buffer_allocator (void)
	Modify and get the source for the CDR allocators.
virtual ACE_Allocator *	output_cdr_msgblock_allocator (void)
	Modify and get the source for the CDR allocators.
virtual ACE_Allocator *	amh_response_handler_allocator (void)
	Modify and get the source for the CDR allocators.
virtual ACE_Allocator *	ami_response_handler_allocator (void)
	Modify and get the source for the CDR allocators.
virtual TAO_ProtocolFactorySet *	get_protocol_factories (void)
	Modify and get the source for the CDR allocators.
virtual int	init_protocol_factories (void)
	Modify and get the source for the CDR allocators.
virtual TAO_Codeset_Manager *	codeset_manager (void)
	Modify and get the source for the CDR allocators.
virtual int	cache_maximum (void) const
	Modify and get the source for the CDR allocators.
virtual int	purge_percentage (void) const
	Modify and get the source for the CDR allocators.
virtual int	max_muxed_connections (void) const
	Modify and get the source for the CDR allocators.
virtual ACE_Lock *	create_cached_connection_lock (void)
	Modify and get the source for the CDR allocators.
virtual ACE_Lock *	create_object_key_table_lock (void)
	Modify and get the source for the CDR allocators.
virtual TAO_Configurable_Refcount	create_corba_object_refcount (void)
	Modify and get the source for the CDR allocators.
virtual ACE_Lock *	create_corba_object_lock (void)
	Modify and get the source for the CDR allocators.
virtual int	locked_transport_cache (void)
	Modify and get the source for the CDR allocators.
virtual TAO_Flushing_Strategy *	create_flushing_strategy (void)
	Modify and get the source for the CDR allocators.
virtual TAO_Connection_Purging_Strategy *	create_purging_strategy (void)
	Modify and get the source for the CDR allocators.
TAO_Resource_Factory::Resource_Usage	resource_usage_strategy (void) const
	Modify and get the source for the CDR allocators.
virtual TAO_LF_Strategy *	create_lf_strategy (void)
	Modify and get the source for the CDR allocators.
virtual auto_ptr < TAO_GIOP_Fragmentation_Strategy >	create_fragmentation_strategy (TAO_Transport *transport, CORBA::ULong max_message_size) const
	Modify and get the source for the CDR allocators.
virtual void	disable_factory (void)
	Modify and get the source for the CDR allocators.
virtual bool	drop_replies_during_shutdown (void) const
	Modify and get the source for the CDR allocators.

Detailed Description

TAO's default resource factory.

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.

Note:: When using an ORB created by a dynamically loaded object, it is generally necessary to pre-load a "Resource_Factory" prior to initializing the ORB. In the case of the TAO_Default_Resource_Factory, this can be done by adding the following Service Configurator directive to your `svc.conf' file before your the directive that loads the object that initialized your ORB:

: static Resource_Factory ""

: Alternatively, explicitly pre-load the Resource_Factory using the following in your code:

: ACE_Service_Config::process_directive ( ACE_TEXT ("static Resource_Factory \""") );

: In both cases, place the appropriate resource factory arguments, if any, between the quotes immediately following "Resource_Factory."

Definition at line 116 of file default_resource.h.

Member Enumeration Documentation

anonymous enum

Modify and get the source for the CDR allocators.

Enumerator:

TAO_ALLOCATOR_THREAD_LOCK

Definition at line 145 of file default_resource.h.

  {
    TAO_ALLOCATOR_THREAD_LOCK
  };

enum TAO_Default_Resource_Factory::Flushing_Strategy_Type [private]

Enumerator:

TAO_LEADER_FOLLOWER_FLUSHING
TAO_REACTIVE_FLUSHING
TAO_BLOCKING_FLUSHING

Definition at line 299 of file default_resource.h.

  {
    TAO_LEADER_FOLLOWER_FLUSHING,
    TAO_REACTIVE_FLUSHING,
    TAO_BLOCKING_FLUSHING
  };

enum TAO_Default_Resource_Factory::Lock_Type [private]

Enumerator:

TAO_NULL_LOCK
TAO_THREAD_LOCK

Definition at line 284 of file default_resource.h.

  {
    TAO_NULL_LOCK,
    TAO_THREAD_LOCK
  };

enum TAO_Default_Resource_Factory::Output_CDR_Allocator_Type [protected]

Enumerator:

LOCAL_MEMORY_POOL
DEFAULT

Definition at line 267 of file default_resource.h.

    {
      LOCAL_MEMORY_POOL,
#if TAO_HAS_SENDFILE == 1
      MMAP_ALLOCATOR,
#endif  /* TAO_HAS_SENDFILE == 1*/
      DEFAULT
    };

Constructor & Destructor Documentation

TAO_Default_Resource_Factory::TAO_Default_Resource_Factory ( void )

Constructor.

Definition at line 101 of file default_resource.cpp.

  : use_locked_data_blocks_ (1)
  , parser_names_count_ (0)
  , parser_names_ (0)
  , protocol_factories_ ()
  , connection_purging_type_ (TAO_CONNECTION_PURGING_STRATEGY)
  , cache_maximum_ (TAO_CONNECTION_CACHE_MAXIMUM)
  , purge_percentage_ (TAO_PURGE_PERCENT)
  , max_muxed_connections_ (0)
  , reactor_mask_signals_ (1)
  , dynamically_allocated_reactor_ (false)
  , options_processed_ (0)
  , factory_disabled_ (0)
#if TAO_USE_OUTPUT_CDR_MMAP_MEMORY_POOL == 1
  , output_cdr_allocator_type_ (MMAP_ALLOCATOR)
#else
  , output_cdr_allocator_type_ (DEFAULT)
#endif
#if TAO_USE_LOCAL_MEMORY_POOL == 1
  , use_local_memory_pool_ (true)
#else
  , use_local_memory_pool_ (false)
#endif
  , cached_connection_lock_type_ (TAO_THREAD_LOCK)
  , object_key_table_lock_type_ (TAO_THREAD_LOCK)
  , corba_object_lock_type_ (TAO_THREAD_LOCK)
  , flushing_strategy_type_ (TAO_LEADER_FOLLOWER_FLUSHING)
  , char_codeset_parameters_ ()
  , wchar_codeset_parameters_ ()
  , resource_usage_strategy_ (TAO_Resource_Factory::TAO_EAGER)
  , drop_replies_ (true)
{
#if TAO_USE_LAZY_RESOURCE_USAGE_STRATEGY == 1
  this->resource_usage_strategy_ =
    TAO_Resource_Factory::TAO_LAZY;
#endif /*TAO_USE_LAZY_RESOURCE_USAGE_STRATEGY*/


}

TAO_Default_Resource_Factory::~TAO_Default_Resource_Factory ( void ) [virtual]

Destructor.

Definition at line 141 of file default_resource.cpp.

{
  const TAO_ProtocolFactorySetItor end = this->protocol_factories_.end ();

  for (TAO_ProtocolFactorySetItor iterator =
         this->protocol_factories_.begin ();
       iterator != end;
       ++iterator)
    {
      delete *iterator;
    }

  this->protocol_factories_.reset ();

  for (int i = 0; i < this->parser_names_count_; ++i)
    CORBA::string_free (this->parser_names_[i]);

  delete [] this->parser_names_;
}

Member Function Documentation

int TAO_Default_Resource_Factory::add_to_ior_parser_names ( const char * curarg ) [protected]

Add a Parser name to the list of Parser names.

Definition at line 666 of file default_resource.cpp.

{
  this->parser_names_[this->index_] = CORBA::string_dup (curarg);

  ++this->index_;

  return 0;
}

ACE_Reactor_Impl * TAO_Default_Resource_Factory::allocate_reactor_impl ( void ) const [protected, virtual]

Obtain the reactor implementation.

Reimplemented in TAO_Advanced_Resource_Factory.

Definition at line 790 of file default_resource.cpp.

{
  ACE_Reactor_Impl *impl = 0;
  /*
   * Hook to specialize TAO's reactor implementation.
   */
//@@ TAO_REACTOR_SPL_COMMENT_HOOK_START
  ACE_NEW_RETURN (impl,
                  ACE_TP_Reactor (ACE::max_handles (),
                                  1,
                                  (ACE_Sig_Handler*)0,
                                  (ACE_Timer_Queue*)0,
                                  this->reactor_mask_signals_,
                                  ACE_Select_Reactor_Token::LIFO),
                  0);
//@@ TAO_REACTOR_SPL_COMMENT_HOOK_END
  return impl;
}

ACE_Allocator * TAO_Default_Resource_Factory::amh_response_handler_allocator ( void ) [virtual]

Modify and get the source for the CDR allocators.

Reimplemented from TAO_Resource_Factory.

Reimplemented in TAO_Advanced_Resource_Factory.

Definition at line 991 of file default_resource.cpp.

{
  ACE_Allocator *allocator = 0;
  if (use_local_memory_pool_)
  {
    ACE_NEW_RETURN (allocator,
                    LOCKED_ALLOCATOR_POOL,
                    0);
  }
  else
  {
    ACE_NEW_RETURN (allocator,
                    LOCKED_ALLOCATOR_NO_POOL,
                    0);
  }

  return allocator;
}

ACE_Allocator * TAO_Default_Resource_Factory::ami_response_handler_allocator ( void ) [virtual]

Modify and get the source for the CDR allocators.

Reimplemented from TAO_Resource_Factory.

Reimplemented in TAO_Advanced_Resource_Factory.

Definition at line 1011 of file default_resource.cpp.

{
  ACE_Allocator *allocator = 0;
  if (use_local_memory_pool_)
  {
    ACE_NEW_RETURN (allocator,
                    LOCKED_ALLOCATOR_POOL,
                    0);
  }
  else
  {
    ACE_NEW_RETURN (allocator,
                    LOCKED_ALLOCATOR_NO_POOL,
                    0);
  }

  return allocator;
}

int TAO_Default_Resource_Factory::cache_maximum ( void ) const [virtual]

Modify and get the source for the CDR allocators.

Reimplemented from TAO_Resource_Factory.

Definition at line 1031 of file default_resource.cpp.

{
  return this->cache_maximum_;
}

int TAO_Default_Resource_Factory::cdr_allocator_source ( void )

Modify and get the source for the CDR allocators.

TAO_Codeset_Manager * TAO_Default_Resource_Factory::codeset_manager ( void ) [virtual]

Modify and get the source for the CDR allocators.

Reimplemented from TAO_Resource_Factory.

Definition at line 1251 of file default_resource.cpp.

{
  TAO_Codeset_Manager_Factory_Base *factory =
    ACE_Dynamic_Service<TAO_Codeset_Manager_Factory_Base>::instance ("TAO_Codeset");

  if (factory == 0)
    {
      if (TAO_debug_level >= 2)
        ACE_DEBUG ((LM_DEBUG,
                    ACE_TEXT ("TAO (%P|%t) - Default_Resource_Factory")
                    ACE_TEXT (" - unable to find codeset manager factory.\n")));
      return 0;
    }

  TAO_Codeset_Manager* mgr = factory->create ();

  if (mgr == 0)
    {
      if (TAO_debug_level >= 2)
        ACE_DEBUG ((LM_INFO,
                    ACE_TEXT ("TAO (%P|%t) - Default_Resource_Factory")
                    ACE_TEXT (" - unable to create codeset manager.\n")));
      return 0;
    }


  ACE_Auto_Ptr<TAO_Codeset_Manager> safemgr (mgr);

  if (TAO_debug_level >= 1)
    ACE_DEBUG ((LM_DEBUG,
                ACE_TEXT ("TAO (%P|%t) - Default_Resource_Factory - codeset manager=%@\n"),
                mgr));

  this->char_codeset_parameters_.apply_to (mgr->char_codeset_descriptor());
  this->wchar_codeset_parameters_.apply_to (mgr->wchar_codeset_descriptor());

  return safemgr.release ();

}

ACE_Lock * TAO_Default_Resource_Factory::create_cached_connection_lock ( void ) [virtual]

Modify and get the source for the CDR allocators.

Reimplemented from TAO_Resource_Factory.

Definition at line 1050 of file default_resource.cpp.

{
  ACE_Lock *the_lock = 0;

  if (this->cached_connection_lock_type_ == TAO_NULL_LOCK)
    ACE_NEW_RETURN (the_lock,
                    ACE_Lock_Adapter<ACE_SYNCH_NULL_MUTEX>,
                    0);
  else
    ACE_NEW_RETURN (the_lock,
                    ACE_Lock_Adapter<TAO_SYNCH_MUTEX>,
                    0);

  return the_lock;
}

ACE_Lock * TAO_Default_Resource_Factory::create_corba_object_lock ( void ) [virtual]

Modify and get the source for the CDR allocators.

Reimplemented from TAO_Resource_Factory.

Definition at line 1094 of file default_resource.cpp.

{
  ACE_Lock *the_lock = 0;

  if (this->corba_object_lock_type_ == TAO_NULL_LOCK)
    ACE_NEW_RETURN (the_lock,
                    ACE_Lock_Adapter<ACE_SYNCH_NULL_MUTEX>,
                    0);
  else
    ACE_NEW_RETURN (the_lock,
                    ACE_Lock_Adapter<TAO_SYNCH_MUTEX>,
                    0);

  return the_lock;
}

TAO_Configurable_Refcount TAO_Default_Resource_Factory::create_corba_object_refcount ( void ) [virtual]

Modify and get the source for the CDR allocators.

Reimplemented from TAO_Resource_Factory.

Definition at line 1111 of file default_resource.cpp.

{
  switch (this->corba_object_lock_type_)
    {
      case TAO_NULL_LOCK:
        return TAO_Configurable_Refcount (
                       TAO_Configurable_Refcount::TAO_NULL_LOCK);
      case TAO_THREAD_LOCK:
      default:
        return TAO_Configurable_Refcount (
                       TAO_Configurable_Refcount::TAO_THREAD_LOCK);
    }
}

TAO_Flushing_Strategy * TAO_Default_Resource_Factory::create_flushing_strategy ( void ) [virtual]

Modify and get the source for the CDR allocators.

Implements TAO_Resource_Factory.

Definition at line 1126 of file default_resource.cpp.

{
  TAO_Flushing_Strategy *strategy = 0;
  if (this->flushing_strategy_type_ == TAO_LEADER_FOLLOWER_FLUSHING)
    ACE_NEW_RETURN (strategy,
                    TAO_Leader_Follower_Flushing_Strategy,
                    0);
  else if (this->flushing_strategy_type_ == TAO_REACTIVE_FLUSHING)
    ACE_NEW_RETURN (strategy,
                    TAO_Reactive_Flushing_Strategy,
                    0);
  else
    ACE_NEW_RETURN (strategy,
                    TAO_Block_Flushing_Strategy,
                    0);
  return strategy;
}

auto_ptr< TAO_GIOP_Fragmentation_Strategy > TAO_Default_Resource_Factory::create_fragmentation_strategy	(	TAO_Transport *	transport,
		CORBA::ULong	max_message_size
	)			const `[virtual]`

Modify and get the source for the CDR allocators.

Implements TAO_Resource_Factory.

Definition at line 1180 of file default_resource.cpp.

{
  auto_ptr<TAO_GIOP_Fragmentation_Strategy> strategy (0);

  TAO_GIOP_Fragmentation_Strategy * tmp = 0;

  // Minimum GIOP message size is 24 (a multiple of 8):
  //   12   GIOP Message Header
  //    4   GIOP Fragment Header (request ID)
  // +  8   Smallest payload, including padding.
  //  ---
  //   24
  static CORBA::ULong const min_message_size = 24;

  // GIOP fragments are supported in GIOP 1.1 and better, but TAO only
  // supports them in 1.2 or better since GIOP 1.1 fragments do not
  // have a fragment message header.
  if (transport) // No transport.  Cannot fragment.
    {
      if (max_message_size < min_message_size
          || (TAO_DEF_GIOP_MAJOR == 1 && TAO_DEF_GIOP_MINOR < 2))
        {
          // No maximum was set by the user.
          ACE_NEW_RETURN (tmp,
                          TAO_Null_Fragmentation_Strategy,
                          strategy);

        }
      else
        {
          ACE_NEW_RETURN (tmp,
                          TAO_On_Demand_Fragmentation_Strategy (
                            transport,
                            max_message_size),
                          strategy);
        }
    }

  ACE_AUTO_PTR_RESET (strategy,
                      tmp,
                      TAO_GIOP_Fragmentation_Strategy);

  return strategy;
}

TAO_LF_Strategy * TAO_Default_Resource_Factory::create_lf_strategy ( void ) [virtual]

Modify and get the source for the CDR allocators.

Implements TAO_Resource_Factory.

Reimplemented in TAO_Advanced_Resource_Factory.

Definition at line 1168 of file default_resource.cpp.

{
  TAO_LF_Strategy *strategy = 0;

  ACE_NEW_RETURN (strategy,
                  TAO_LF_Strategy_Complete,
                  0);

  return strategy;
}

ACE_Lock * TAO_Default_Resource_Factory::create_object_key_table_lock ( void ) [virtual]

Modify and get the source for the CDR allocators.

Reimplemented from TAO_Resource_Factory.

Definition at line 1077 of file default_resource.cpp.

{
  ACE_Lock *the_lock = 0;

  if (this->object_key_table_lock_type_ == TAO_NULL_LOCK)
    ACE_NEW_RETURN (the_lock,
                    ACE_Lock_Adapter<ACE_SYNCH_NULL_MUTEX>,
                    0);
  else
    ACE_NEW_RETURN (the_lock,
                    ACE_Lock_Adapter<TAO_SYNCH_MUTEX>,
                    0);

  return the_lock;
}

TAO_Connection_Purging_Strategy * TAO_Default_Resource_Factory::create_purging_strategy ( void ) [virtual]

Modify and get the source for the CDR allocators.

Implements TAO_Resource_Factory.

Reimplemented in TAO_Advanced_Resource_Factory.

Definition at line 1145 of file default_resource.cpp.

{
  TAO_Connection_Purging_Strategy *strategy = 0;

  if (this->connection_purging_type_ == TAO_Resource_Factory::LRU)
    {
      ACE_NEW_RETURN (strategy,
                      TAO_LRU_Connection_Purging_Strategy (
                          this->cache_maximum ()),
                      0);
    }
  else
    {
      ACE_ERROR ((LM_ERROR,
                  ACE_TEXT ("TAO (%P|%t) - ")
                  ACE_TEXT ("no usable purging strategy ")
                  ACE_TEXT ("was found.\n")));
    }

  return strategy;
}

void TAO_Default_Resource_Factory::disable_factory ( void ) [virtual]

Modify and get the source for the CDR allocators.

Implements TAO_Resource_Factory.

Definition at line 1239 of file default_resource.cpp.

{
  this->factory_disabled_ = 1;
  if (this->options_processed_)
    {
      ACE_DEBUG ((LM_WARNING,
                  ACE_TEXT ("TAO (%P|%t) - Warning: Resource_Factory options ignored\n")
                  ACE_TEXT ("Default Resource Factory is disabled\n")));
    }
}

bool TAO_Default_Resource_Factory::drop_replies_during_shutdown ( void ) const [virtual]

Modify and get the source for the CDR allocators.

Implements TAO_Resource_Factory.

Definition at line 1298 of file default_resource.cpp.

{
  return this->drop_replies_;
}

TAO_Acceptor_Registry * TAO_Default_Resource_Factory::get_acceptor_registry ( void ) [virtual]

Modify and get the source for the CDR allocators.

Reimplemented from TAO_Resource_Factory.

Definition at line 766 of file default_resource.cpp.

{
  TAO_Acceptor_Registry *ar = 0;

  ACE_NEW_RETURN(ar,
                 TAO_Acceptor_Registry,
                 0);

  return ar;
}

TAO_Connector_Registry * TAO_Default_Resource_Factory::get_connector_registry ( void ) [virtual]

Modify and get the source for the CDR allocators.

Reimplemented from TAO_Resource_Factory.

Definition at line 778 of file default_resource.cpp.

{
  TAO_Connector_Registry *cr = 0;

  ACE_NEW_RETURN(cr,
                 TAO_Connector_Registry,
                 0);

  return cr;
}

int TAO_Default_Resource_Factory::get_parser_names	(	char **&	names,
		int &	number_of_names
	)			`[virtual]`

Modify and get the source for the CDR allocators.

Reimplemented from TAO_Resource_Factory.

Definition at line 591 of file default_resource.cpp.

{
  if (this->parser_names_count_ != 0)
    {
      // The user used some -ORBIORParser options, just return those.
      names = this->parser_names_;
      number_of_names = this->parser_names_count_;

      return 0;
    }

  this->parser_names_count_ = 0;
#if (TAO_HAS_DDL_PARSER == 1)
  ++this->parser_names_count_;
#endif
#if (TAO_HAS_FILE_PARSER == 1)
  ++this->parser_names_count_;
#endif
#if (TAO_HAS_CORBALOC_PARSER == 1)
  ++this->parser_names_count_;
#endif
#if (TAO_HAS_CORBANAME_PARSER == 1)
  ++this->parser_names_count_;
#endif
#if (TAO_HAS_HTTP_PARSER == 1)
  ++this->parser_names_count_;
#endif
#if (TAO_HAS_MCAST_PARSER == 1)
  ++this->parser_names_count_;
#endif
  ACE_NEW_RETURN (this->parser_names_,
                  char *[this->parser_names_count_],
                  -1);

  CORBA::ULong index = 0;

#if (TAO_HAS_DDL_PARSER == 1)
  this->parser_names_[index] = CORBA::string_dup ("DLL_Parser");
  ++index;
#endif

#if (TAO_HAS_FILE_PARSER == 1)
  this->parser_names_[index] = CORBA::string_dup ("FILE_Parser");
  ++index;
#endif

#if (TAO_HAS_CORBALOC_PARSER == 1)
  this->parser_names_[index] = CORBA::string_dup ("CORBALOC_Parser");
  ++index;
#endif

#if (TAO_HAS_CORBANAME_PARSER == 1)
  this->parser_names_[index] = CORBA::string_dup ("CORBANAME_Parser");
  ++index;
#endif

#if (TAO_HAS_MCAST_PARSER == 1)
  this->parser_names_[index] = CORBA::string_dup ("MCAST_Parser");
  ++index;
#endif

#if (TAO_HAS_HTTP_PARSER == 1)
  this->parser_names_[index] = CORBA::string_dup ("HTTP_Parser");
  ++index;
#endif

  names = this->parser_names_;

  number_of_names = index;

  return 0;
}

TAO_ProtocolFactorySet * TAO_Default_Resource_Factory::get_protocol_factories ( void ) [virtual]

Modify and get the source for the CDR allocators.

Reimplemented from TAO_Resource_Factory.

Reimplemented in TAO_Advanced_Resource_Factory.

Definition at line 760 of file default_resource.cpp.

{
  return &protocol_factories_;
}

ACE_Reactor * TAO_Default_Resource_Factory::get_reactor ( void ) [virtual]

Modify and get the source for the CDR allocators.

Reimplemented from TAO_Resource_Factory.

Definition at line 810 of file default_resource.cpp.

{
  ACE_Reactor *reactor = 0;
  ACE_NEW_RETURN (reactor,
                  ACE_Reactor (this->allocate_reactor_impl (), 1),
                  0);

  if (reactor->initialized () == 0)
    {
      delete reactor;
      reactor = 0;
    }
  else
    this->dynamically_allocated_reactor_ = true;

  return reactor;
}

int TAO_Default_Resource_Factory::init	(	int	argc,
		ACE_TCHAR *	argv[]
	)			`[virtual]`

Dynamic linking hook.

CodeSet Translators

Reimplemented from ACE_Shared_Object.

Reimplemented in TAO_Advanced_Resource_Factory.

Definition at line 163 of file default_resource.cpp.

{
  ACE_TRACE ("TAO_Default_Resource_Factory::init");

  // If this factory has already been disabled then
  // print a warning and exit because any options
  // are useless
  if (this->factory_disabled_) {
    ACE_DEBUG ((LM_WARNING,
                ACE_TEXT ("TAO (%P|%t) - Warning: Resource_Factory options ")
                ACE_TEXT ("ignored\n")
                ACE_TEXT ("Default Resource Factory is disabled\n")));
    return 0;
  }
  this->options_processed_ = 1;

  this->parser_names_count_ = 0;

  int curarg = 0;

  for (curarg = 0; curarg < argc; ++curarg)
    {
    // Parse thro' and find the number of Parsers to be loaded.
    if (ACE_OS::strcasecmp (argv[curarg],
                            ACE_TEXT("-ORBIORParser")) == 0)
      ++this->parser_names_count_;

    ++curarg;

    if (curarg == (argc-1) && this->parser_names_count_ != 0)
      {
        // This is the last loop..
        ACE_NEW_RETURN (this->parser_names_,
                        char *[this->parser_names_count_],
                        -1);

        for (int i = 0;
             i < this->parser_names_count_;
             ++i)
          this->parser_names_[i] = 0;

        this->index_ = 0;
      }
  }

  for (curarg = 0; curarg < argc; ++curarg)
    {
      if (ACE_OS::strcasecmp (argv[curarg],
                                 ACE_TEXT("-ORBReactorMaskSignals")) == 0)
      {
        ++curarg;
        if (curarg < argc)
          {
            ACE_TCHAR* name = argv[curarg];

            if (ACE_OS::strcasecmp (name, ACE_TEXT("0")) == 0)
              this->reactor_mask_signals_ = 0;
            else if (ACE_OS::strcasecmp (name, ACE_TEXT("1")) == 0)
              this->reactor_mask_signals_= 1;
            else
              this->report_option_value_error (ACE_TEXT("-ORBReactorMaskSignals"), name);
          }
      }

    else if (ACE_OS::strcasecmp (argv[curarg],
                                 ACE_TEXT("-ORBProtocolFactory")) == 0)
      {
        TAO_ProtocolFactorySet *pset = this->get_protocol_factories ();
        ++curarg;
        if (curarg < argc)
          {
            TAO_Protocol_Item *item = 0;
            ACE_NEW_RETURN (item,
                            TAO_Protocol_Item (ACE_TEXT_ALWAYS_CHAR(argv[curarg])),
                            -1);
            if (pset->insert (item) == -1)
              ACE_ERROR ((LM_ERROR,
                          ACE_TEXT ("(%P|%t) Unable to add protocol factories ")
                          ACE_TEXT ("for %s: %m\n"),
                          argv[curarg]));
          }
      }

    /// CodeSet Translators
    else if (ACE_OS::strcasecmp (argv[curarg],
                                 ACE_TEXT("-ORBNativeCharCodeSet")) == 0)
      {
        ++curarg;
        if (curarg < argc)
            this->char_codeset_parameters_.native (argv[curarg]);
      }

    else if (ACE_OS::strcasecmp (argv[curarg],
                                 ACE_TEXT("-ORBNativeWCharCodeSet")) == 0)
      {
        ++curarg;
        if (curarg < argc)
            this->wchar_codeset_parameters_.native (argv[curarg]);
      }

    else if (ACE_OS::strcasecmp (argv[curarg],
                                 ACE_TEXT("-ORBCharCodesetTranslator")) == 0)
      {
        ++curarg;
        if (curarg < argc)
            this->char_codeset_parameters_.add_translator (argv[curarg]);
      }

    /// CodeSet Translators
    else if (ACE_OS::strcasecmp (argv[curarg],
                                 ACE_TEXT("-ORBWCharCodesetTranslator")) == 0)
      {
        ++curarg;
        if (curarg < argc)
            this->wchar_codeset_parameters_.add_translator (argv[curarg]);
      }

    else if (ACE_OS::strcasecmp (argv[curarg],
                                 ACE_TEXT("-ORBConnectionCachingStrategy")) == 0)
      {
        ++curarg;

        // @todo: This needs to be removed after a few betas. The
        // note is being written during 1.2.3 timeframe.
        ACE_DEBUG ((LM_DEBUG,
                    ACE_TEXT ("(%P|%t) This option would be deprecated\n")
                    ACE_TEXT ("(%P|%t) Please use -ORBConnectionPurgingStrategy ")
                    ACE_TEXT ("instead\n")));

        if (curarg < argc)
          {
            ACE_TCHAR* name = argv[curarg];

            if (ACE_OS::strcasecmp (name,
                                    ACE_TEXT ("lru")) == 0)
              this->connection_purging_type_ =
                TAO_Resource_Factory::LRU;
            else if (ACE_OS::strcasecmp (name,
                                         ACE_TEXT ("lfu")) == 0)
              this->connection_purging_type_ =
                TAO_Resource_Factory::LFU;
            else if (ACE_OS::strcasecmp (name,
                                         ACE_TEXT ("fifo")) == 0)
              this->connection_purging_type_ =
                TAO_Resource_Factory::FIFO;
            else if (ACE_OS::strcasecmp (name,
                                         ACE_TEXT ("null")) == 0)
              this->connection_purging_type_ =
                  TAO_Resource_Factory::NOOP;
            else
              this->report_option_value_error (ACE_TEXT ("-ORBConnectionCachingStrategy"), name);
          }
      }
    else if (ACE_OS::strcasecmp (argv[curarg],
                                 ACE_TEXT("-ORBConnectionPurgingStrategy")) == 0)
      {
        ++curarg;

        if (curarg < argc)
          {
            ACE_TCHAR* name = argv[curarg];

            if (ACE_OS::strcasecmp (name,
                                    ACE_TEXT("lru")) == 0)
              this->connection_purging_type_ =
                TAO_Resource_Factory::LRU;
            else if (ACE_OS::strcasecmp (name,
                                         ACE_TEXT("lfu")) == 0)
              this->connection_purging_type_ =
                TAO_Resource_Factory::LFU;
            else if (ACE_OS::strcasecmp (name,
                                         ACE_TEXT("fifo")) == 0)
              this->connection_purging_type_ =
                TAO_Resource_Factory::FIFO;
            else if (ACE_OS::strcasecmp (name,
                                         ACE_TEXT("null")) == 0)
              this->connection_purging_type_ =
                  TAO_Resource_Factory::NOOP;
            else
              this->report_option_value_error (ACE_TEXT("-ORBConnectionPurgingStrategy"), name);
          }
      }
   else if (ACE_OS::strcasecmp (argv[curarg],
                                ACE_TEXT("-ORBConnectionCacheMax")) == 0)
      {
        ++curarg;
        if (curarg < argc)
            this->cache_maximum_ = ACE_OS::atoi (argv[curarg]);
        else
          this->report_option_value_error (ACE_TEXT("-ORBConnectionCacheMax"), argv[curarg]);
      }

   else if (ACE_OS::strcasecmp (argv[curarg],
                                ACE_TEXT("-ORBConnectionCachePurgePercentage")) == 0)
      {
        ++curarg;
        if (curarg < argc)
            this->purge_percentage_ = ACE_OS::atoi (argv[curarg]);
        else
          this->report_option_value_error (ACE_TEXT("-ORBConnectionCachePurgePercentage"),
                                           argv[curarg]);
      }
    else if (ACE_OS::strcasecmp (argv[curarg],
                                 ACE_TEXT("-ORBIORParser")) == 0)
      {
        ++curarg;

        if (curarg < argc)
          {
            this->add_to_ior_parser_names (ACE_TEXT_ALWAYS_CHAR(argv[curarg]));
          }
      }

    else if (ACE_OS::strcasecmp (argv[curarg],
                                 ACE_TEXT("-ORBConnectionCacheLock")) == 0)
      {
        ++curarg;
        if (curarg < argc)
          {
            ACE_TCHAR* name = argv[curarg];

            if (ACE_OS::strcasecmp (name,
                                    ACE_TEXT("thread")) == 0)
              this->cached_connection_lock_type_ = TAO_THREAD_LOCK;
            else if (ACE_OS::strcasecmp (name,
                                         ACE_TEXT("null")) == 0)
              {
                // @@ Bug 940 :This is a sort of hack now. We need to put
                // this in a common place once we get the common
                // switch that is documented in bug 940...
                this->use_locked_data_blocks_  = 0;
                this->cached_connection_lock_type_ = TAO_NULL_LOCK;
              }
            else
              this->report_option_value_error (ACE_TEXT("-ORBConnectionCacheLock"), name);
          }
      }
    else if (ACE_OS::strcasecmp (argv[curarg],
                                 ACE_TEXT("-ORBObjectKeyTableLock")) == 0)
      {
        ++curarg;
        if (curarg < argc)
          {
            ACE_TCHAR* name = argv[curarg];

            if (ACE_OS::strcasecmp (name,
                                    ACE_TEXT("thread")) == 0)
              this->object_key_table_lock_type_ = TAO_THREAD_LOCK;
            else if (ACE_OS::strcasecmp (name,
                                         ACE_TEXT("null")) == 0)
              {
                // @@ Bug 940 :This is a sort of hack now. We need to put
                // this in a common place once we get the common
                // switch that is documented in bug 940...
                this->object_key_table_lock_type_ = TAO_NULL_LOCK;
              }
            else
              this->report_option_value_error (ACE_TEXT("-ORBObjectKeyTableLock"), name);
          }
      }
    else if (ACE_OS::strcasecmp (argv[curarg],
                                 ACE_TEXT("-ORBCorbaObjectLock")) == 0)
      {
        ++curarg;
        if (curarg < argc)
          {
            ACE_TCHAR* name = argv[curarg];

            if (ACE_OS::strcasecmp (name,
                                    ACE_TEXT("thread")) == 0)
              this->corba_object_lock_type_ = TAO_THREAD_LOCK;
            else if (ACE_OS::strcasecmp (name,
                                         ACE_TEXT("null")) == 0)
              {
                // @@ Bug 940 :This is a sort of hack now. We need to put
                // this in a common place once we get the common
                // switch that is documented in bug 940...
                this->corba_object_lock_type_ = TAO_NULL_LOCK;
              }
            else
              this->report_option_value_error (ACE_TEXT("-ORBCorbaObjectLock"), name);
          }
      }
    else if (ACE_OS::strcasecmp (argv[curarg],
                                 ACE_TEXT("-ORBResourceUsage")) == 0)
      {
        ++curarg;
        if (curarg < argc)
          {
            ACE_TCHAR* name = argv[curarg];

            if (ACE_OS::strcasecmp (name,
                                    ACE_TEXT("eager")) == 0)
              this->resource_usage_strategy_ = TAO_EAGER;
            else if (ACE_OS::strcasecmp (name,
                                         ACE_TEXT("lazy")) == 0)
              {
                this->resource_usage_strategy_ = TAO_LAZY;
              }
            else
              this->report_option_value_error (ACE_TEXT("-ORBResourceUsage"), name);
          }
      }
    else if (ACE_OS::strcasecmp (argv[curarg],
                                 ACE_TEXT("-ORBFlushingStrategy")) == 0)
      {
        ++curarg;
        /*
         * Hook to specialize TAO's Flushing strategy implementations
         */
//@@ FLUSHING_STRATEGY_SPL_COMMENT_HOOK_START
        if (curarg < argc)
          {
            ACE_TCHAR* name = argv[curarg];

            if (ACE_OS::strcasecmp (name,
                                    ACE_TEXT("leader_follower")) == 0)
              this->flushing_strategy_type_ = TAO_LEADER_FOLLOWER_FLUSHING;
            else if (ACE_OS::strcasecmp (name,
                                         ACE_TEXT("reactive")) == 0)
              this->flushing_strategy_type_ = TAO_REACTIVE_FLUSHING;
            else if (ACE_OS::strcasecmp (name,
                                         ACE_TEXT("blocking")) == 0)
              this->flushing_strategy_type_ = TAO_BLOCKING_FLUSHING;
            else
              this->report_option_value_error (ACE_TEXT("-ORBFlushingStrategy"), name);
          }
//@@ FLUSHING_STRATEGY_SPL_COMMENT_HOOK_END
      }
    else if (ACE_OS::strcasecmp (argv[curarg],
                                 ACE_TEXT ("-ORBMuxedConnectionMax")) == 0)
      {
        ++curarg;
        if (curarg < argc)
            this->max_muxed_connections_ =
              ACE_OS::atoi (argv[curarg]);
        else
          this->report_option_value_error (ACE_TEXT("-ORBMuxedConnectionMax"),
                                           argv[curarg]);
      }
    else if (ACE_OS::strcasecmp (argv[curarg],
                                 ACE_TEXT("-ORBDropRepliesDuringShutdown")) == 0)
      {
        ++curarg;
        if (curarg < argc)
          {
            int tmp = ACE_OS::atoi (argv[curarg]);

            if (tmp == 0)
              this->drop_replies_ = false;
            else
              this->drop_replies_ = true;
          }
        else
          this->report_option_value_error (ACE_TEXT("-ORBDropRepliesDuringShutdown"),
                                           argv[curarg]);
      }
    else if (0 == ACE_OS::strcasecmp (argv[curarg],
                                      ACE_TEXT("-ORBOutputCDRAllocator")))
      {
        ++curarg;

        if (curarg < argc)
          {
            ACE_TCHAR const * const current_arg = argv[curarg];

            if (ACE_OS::strcasecmp (current_arg,
                                    ACE_TEXT("mmap")) == 0)
              {
#if TAO_HAS_SENDFILE == 1
                this->output_cdr_allocator_type_ = MMAP_ALLOCATOR;
#else
                ACE_DEBUG ((LM_WARNING,
                            ACE_TEXT ("MMAP allocator unsupport on this platform")));
#endif  /* TAO_HAS_SENDFILE==1 */
              }
            else if (ACE_OS::strcasecmp (current_arg,
                                         ACE_TEXT("local_memory_pool")) == 0
                     && this->output_cdr_allocator_type_ != DEFAULT)
              {
                this->output_cdr_allocator_type_ = LOCAL_MEMORY_POOL;
              }
            else if (ACE_OS::strcasecmp (current_arg,
                                         ACE_TEXT("default")) == 0)
              {
                this->output_cdr_allocator_type_ = DEFAULT;
              }
            else
              {
                this->report_option_value_error (
                  ACE_TEXT("-ORBOutputCDRAllocator"), current_arg);
              }
          }
      }
    else if (0 == ACE_OS::strcasecmp (argv[curarg],
                                      ACE_TEXT("-ORBZeroCopyWrite")))
      {
#if TAO_HAS_SENDFILE == 1
        this->output_cdr_allocator_type_ = MMAP_ALLOCATOR;
#else
        ACE_DEBUG ((LM_WARNING,
                    ACE_TEXT ("Zero copy writes unsupported on this platform\n")));
#endif  /* TAO_HAS_SENDFILE==1 */
      }
    else if (ACE_OS::strncmp (argv[curarg],
                              ACE_TEXT ("-ORB"),
                              4) == 0)
      {
        // Can we assume there is an argument after the option?
        // ++curarg;
        ACE_ERROR ((LM_ERROR,
                    ACE_TEXT ("TAO (%P|%t) - Default_Resource_Factory - ")
                    ACE_TEXT ("unknown option <%s>\n"),
                    argv[curarg]));
      }
    else
      {
        ACE_DEBUG ((LM_DEBUG,
                    ACE_TEXT ("TAO (%P|%t) - Default_Resource_Factory - ")
                    ACE_TEXT ("ignoring option <%s>\n"),
                    argv[curarg]));
      }
    }

  return 0;
}

int TAO_Default_Resource_Factory::init_protocol_factories ( void ) [virtual]

Modify and get the source for the CDR allocators.

Reimplemented from TAO_Resource_Factory.

Reimplemented in TAO_Advanced_Resource_Factory.

Definition at line 717 of file default_resource.cpp.

{
  const TAO_ProtocolFactorySetItor end = protocol_factories_.end ();
  TAO_ProtocolFactorySetItor factory = protocol_factories_.begin ();

  if (factory == end)
    {
      return this->load_default_protocols ();
    }

  for (; factory != end; ++factory)
    {
      const ACE_CString &name = (*factory)->protocol_name ();
      (*factory)->factory (
        ACE_Dynamic_Service<TAO_Protocol_Factory>::instance (name.c_str ()));
      if ((*factory)->factory () == 0)
        {
          ACE_ERROR_RETURN ((LM_ERROR,
                             ACE_TEXT ("TAO (%P|%t) - Unable to load ")
                             ACE_TEXT ("protocol <%C>, %p\n"),
                             name.c_str (),
                             ACE_TEXT ("")),
                            -1);
        }

      if (TAO_debug_level > 0)
        {
          ACE_DEBUG ((LM_DEBUG,
                      ACE_TEXT ("TAO (%P|%t) - Loaded protocol <%C>\n"),
                      name.c_str ()));
        }
    }

  return 0;
}

int TAO_Default_Resource_Factory::input_cdr_allocator_type_locked ( void ) [virtual]

Modify and get the source for the CDR allocators.

Reimplemented from TAO_Resource_Factory.

Reimplemented in TAO_Advanced_Resource_Factory.

Definition at line 910 of file default_resource.cpp.

{
  return 1;
}

ACE_Allocator * TAO_Default_Resource_Factory::input_cdr_buffer_allocator ( void ) [virtual]

Modify and get the source for the CDR allocators.

Reimplemented from TAO_Resource_Factory.

Reimplemented in TAO_Advanced_Resource_Factory.

Definition at line 870 of file default_resource.cpp.

{
  ACE_Allocator *allocator = 0;
  if (use_local_memory_pool_)
  {
    ACE_NEW_RETURN (allocator,
                    LOCKED_ALLOCATOR_POOL,
                    0);
  }
  else
  {
    ACE_NEW_RETURN (allocator,
                    LOCKED_ALLOCATOR_NO_POOL,
                    0);
  }

  return allocator;
}

ACE_Allocator * TAO_Default_Resource_Factory::input_cdr_dblock_allocator ( void ) [virtual]

Modify and get the source for the CDR allocators.

Reimplemented from TAO_Resource_Factory.

Reimplemented in TAO_Advanced_Resource_Factory.

Definition at line 850 of file default_resource.cpp.

{
  ACE_Allocator *allocator = 0;
  if (use_local_memory_pool_)
  {
    ACE_NEW_RETURN (allocator,
                    LOCKED_ALLOCATOR_POOL,
                    0);
  }
  else
  {
    ACE_NEW_RETURN (allocator,
                    LOCKED_ALLOCATOR_NO_POOL,
                    0);
  }

  return allocator;
}

ACE_Allocator * TAO_Default_Resource_Factory::input_cdr_msgblock_allocator ( void ) [virtual]

Modify and get the source for the CDR allocators.

Reimplemented from TAO_Resource_Factory.

Reimplemented in TAO_Advanced_Resource_Factory.

Definition at line 890 of file default_resource.cpp.

{
  ACE_Allocator *allocator = 0;
  if (use_local_memory_pool_)
  {
    ACE_NEW_RETURN (allocator,
                    LOCKED_ALLOCATOR_POOL,
                    0);
  }
  else
  {
    ACE_NEW_RETURN (allocator,
                    LOCKED_ALLOCATOR_NO_POOL,
                    0);
  }

  return allocator;
}

int TAO_Default_Resource_Factory::load_default_protocols ( void ) [protected, virtual]

Loads the default protocols. This method is used so that the advanced_resource.cpp can call the one in default_resource.cpp without calling unnecessary functions.

Reimplemented from TAO_Resource_Factory.

Reimplemented in TAO_Advanced_Resource_Factory.

Definition at line 678 of file default_resource.cpp.

{
#if defined (TAO_HAS_IIOP) && (TAO_HAS_IIOP != 0)
      // If the user did not list any protocols in her svc.conf file
      // then default to TAO's basic protocols.
      // You do *NOT* need modify this code to add your own protocol,
      // instead simply add the following to your svc.conf file:
      //
      // dynamic PP_Factory Service_Object * LIB:_make_PP_Protocol_Factory() ""
      // static Resource_Factory "-ORBProtocolFactory PP_Factory"
      //
      // where "PP_Factory" is the name of your protocol, i.e. the
      // second argument passed to the ACE_STATIC_SVC_DEFINE macro:
      //
      // ACE_STATIC_SVC_DEFINE (PP_Protocol_Factory,
      //                        ACE_TEXT ("PP_Factory"), ...)
      //
      // "PP_Protocol_Factory" is the name of your protocol factory
      // class.  A "_make_" is prepended to your protocol factory
      // class name by the ACE_FACTORY_DECLARE macro.  The resulting
      // factory function "_make_PP_Protocol_Factory()" is what should
      // be used in the "dynamic" line in your svc.conf file.
      //
      // LIB is the base name of the shared library that implements
      // the protocol.  The directory containing your library must be
      // in your library search path, typically defined by the
      // LD_LIBRARY_PATH environment variable on UNIX systems, and/or
      // the `/etc/ld.so.conf' file on some UNIX systems.  Remember to
      // run "ldconfig" if you modify `/etc/ld.so.conf'.

      if (TAO::details::load_protocol_factory <TAO_IIOP_Protocol_Factory> (
          this->protocol_factories_, "IIOP_Factory") == -1)
        return -1;
#endif /* TAO_HAS_IIOP && TAO_HAS_IIOP != 0 */

  return 0;
}

int TAO_Default_Resource_Factory::locked_transport_cache ( void ) [virtual]

Modify and get the source for the CDR allocators.

Reimplemented from TAO_Resource_Factory.

Definition at line 1067 of file default_resource.cpp.

{
  if (this->cached_connection_lock_type_ == TAO_NULL_LOCK)
    return 0;

  return 1;
}

int TAO_Default_Resource_Factory::max_muxed_connections ( void ) const [virtual]

Modify and get the source for the CDR allocators.

Reimplemented from TAO_Resource_Factory.

Definition at line 1043 of file default_resource.cpp.

{
  return this->max_muxed_connections_;
}

ACE_Allocator * TAO_Default_Resource_Factory::output_cdr_buffer_allocator ( void ) [virtual]

Modify and get the source for the CDR allocators.

Reimplemented from TAO_Resource_Factory.

Definition at line 936 of file default_resource.cpp.

{
  ACE_Allocator *allocator = 0;

  switch (this->output_cdr_allocator_type_)
    {
    case LOCAL_MEMORY_POOL:
      ACE_NEW_RETURN (allocator,
                      LOCKED_ALLOCATOR_POOL,
                      0);

      break;

#if TAO_HAS_SENDFILE == 1
    case MMAP_ALLOCATOR:
      ACE_NEW_RETURN (allocator,
                      TAO_MMAP_Allocator,
                      0);

      break;
#endif  /* TAO_HAS_SENDFILE==1 */

    case DEFAULT:
    default:
      ACE_NEW_RETURN (allocator,
                      LOCKED_ALLOCATOR_NO_POOL,
                      0);

      break;
    }

  return allocator;
}

ACE_Allocator * TAO_Default_Resource_Factory::output_cdr_dblock_allocator ( void ) [virtual]

Modify and get the source for the CDR allocators.

Reimplemented from TAO_Resource_Factory.

Definition at line 916 of file default_resource.cpp.

{
  ACE_Allocator *allocator = 0;
  if (use_local_memory_pool_)
  {
    ACE_NEW_RETURN (allocator,
                    LOCKED_ALLOCATOR_POOL,
                    0);
  }
  else
  {
    ACE_NEW_RETURN (allocator,
                    LOCKED_ALLOCATOR_NO_POOL,
                    0);
  }

  return allocator;
}

ACE_Allocator * TAO_Default_Resource_Factory::output_cdr_msgblock_allocator ( void ) [virtual]

Modify and get the source for the CDR allocators.

Reimplemented from TAO_Resource_Factory.

Definition at line 971 of file default_resource.cpp.

{
  ACE_Allocator *allocator = 0;
  if (use_local_memory_pool_)
  {
    ACE_NEW_RETURN (allocator,
                    LOCKED_ALLOCATOR_POOL,
                    0);
  }
  else
  {
    ACE_NEW_RETURN (allocator,
                    LOCKED_ALLOCATOR_NO_POOL,
                    0);
  }

  return allocator;
}

int TAO_Default_Resource_Factory::parse_args	(	int	argc,
		ACE_TCHAR *	argv[]
	)

Parse svc.conf arguments.

int TAO_Default_Resource_Factory::purge_percentage ( void ) const [virtual]

Modify and get the source for the CDR allocators.

Reimplemented from TAO_Resource_Factory.

Definition at line 1037 of file default_resource.cpp.

{
  return this->purge_percentage_;
}

void TAO_Default_Resource_Factory::reclaim_reactor ( ACE_Reactor * reactor ) [virtual]

Modify and get the source for the CDR allocators.

Reimplemented from TAO_Resource_Factory.

Definition at line 829 of file default_resource.cpp.

{
  if (this->dynamically_allocated_reactor_)
    delete reactor;
}

void TAO_Default_Resource_Factory::report_option_value_error	(	const ACE_TCHAR *	option_name,
		const ACE_TCHAR *	option_value
	)			`[protected]`

Reimplemented in TAO_Advanced_Resource_Factory.

Definition at line 1228 of file default_resource.cpp.

{
  ACE_DEBUG((LM_DEBUG,
             ACE_TEXT ("TAO (%P|%t) - Default_Resource_Factory - unknown ")
             ACE_TEXT ("argument <%s> for <%s>\n"),
             option_value, option_name));
}

TAO_Resource_Factory::Resource_Usage TAO_Default_Resource_Factory::resource_usage_strategy ( void ) const [virtual]

Modify and get the source for the CDR allocators.

Implements TAO_Resource_Factory.

Definition at line 1292 of file default_resource.cpp.

{
  return this->resource_usage_strategy_;
}

void TAO_Default_Resource_Factory::use_local_memory_pool ( bool flag ) [virtual]

Modify and get the source for the CDR allocators.

Reimplemented from TAO_Resource_Factory.

Definition at line 841 of file default_resource.cpp.

{
  this->use_local_memory_pool_ = flag;

  if (this->output_cdr_allocator_type_ == DEFAULT)
    this->output_cdr_allocator_type_ = LOCAL_MEMORY_POOL;
}

int TAO_Default_Resource_Factory::use_locked_data_blocks ( void ) const [virtual]

Modify and get the source for the CDR allocators.

Reimplemented from TAO_Resource_Factory.

Definition at line 754 of file default_resource.cpp.

{
  return this->use_locked_data_blocks_;
}

Member Data Documentation

int TAO_Default_Resource_Factory::cache_maximum_ [protected]

Specifies the maximum number of connections which should get cached in the ORB.

Definition at line 228 of file default_resource.h.

Lock_Type TAO_Default_Resource_Factory::cached_connection_lock_type_ [private]

Type of lock used by the cached connector.

Definition at line 291 of file default_resource.h.

TAO_Codeset_Parameters TAO_Default_Resource_Factory::char_codeset_parameters_ [private]

Definition at line 311 of file default_resource.h.

TAO_Resource_Factory::Purging_Strategy TAO_Default_Resource_Factory::connection_purging_type_ [protected]

Specifies the typeof purging strategy we should use for cleaning up unused connections

Definition at line 224 of file default_resource.h.

Lock_Type TAO_Default_Resource_Factory::corba_object_lock_type_ [private]

Type of lock used by the corba object.

Definition at line 297 of file default_resource.h.

bool TAO_Default_Resource_Factory::drop_replies_ [private]

Flag to indicate whether replies should be dropped during ORB shutdown.

Definition at line 319 of file default_resource.h.

bool TAO_Default_Resource_Factory::dynamically_allocated_reactor_ [protected]

Flag that is set to true if the reactor obtained from the get_reactor() method is dynamically allocated. If this flag is set to true, then the reclaim_reactor() method with call the delete operator on the given reactor. This flag is necessary to make sure that a reactor not allocated by the default resource factory is not reclaimed by the default resource factory. Such a situation can occur when a resource factory derived from the default one overrides the get_reactor() method but does not override the reclaim_reactor() method.

Definition at line 253 of file default_resource.h.

int TAO_Default_Resource_Factory::factory_disabled_ [protected]

This flag specifies whether the factory has been disabled. If it has been disabled we should print warnings if options were processed before (or later).

Definition at line 265 of file default_resource.h.

Flushing_Strategy_Type TAO_Default_Resource_Factory::flushing_strategy_type_ [private]

Type of flushing strategy configured.

Definition at line 307 of file default_resource.h.

int TAO_Default_Resource_Factory::index_ [protected]

Index of the current element in the parser_names_ array.

Definition at line 217 of file default_resource.h.

int TAO_Default_Resource_Factory::max_muxed_connections_ [protected]

Specifies the limit on the number of muxed connections allowed per-property for the ORB. A value of 0 indicates no limit

Definition at line 237 of file default_resource.h.

Lock_Type TAO_Default_Resource_Factory::object_key_table_lock_type_ [private]

Type of lock used by the corba object.

Definition at line 294 of file default_resource.h.

int TAO_Default_Resource_Factory::options_processed_ [protected]

This flag is used to determine whether options have been processed via the init() function. It is necessary to properly report errors when the default factory is replaced.

Definition at line 260 of file default_resource.h.

Output_CDR_Allocator_Type TAO_Default_Resource_Factory::output_cdr_allocator_type_ [protected]

Type of allocator to use for output CDR buffers.

Definition at line 277 of file default_resource.h.

char** TAO_Default_Resource_Factory::parser_names_ [protected]

Array consisting of the names of the parsers.

Definition at line 214 of file default_resource.h.

int TAO_Default_Resource_Factory::parser_names_count_ [protected]

The number of the different types of Parsers.

Definition at line 211 of file default_resource.h.

TAO_ProtocolFactorySet TAO_Default_Resource_Factory::protocol_factories_ [protected]

list of loaded protocol factories.