TAO_Default_Resource_Factory Class Reference

TAO's default resource factory. More...

#include <default_resource.h>

Inheritance diagram for TAO_Default_Resource_Factory:

[legend]Collaboration diagram for TAO_Default_Resource_Factory:

[legend]List of all members.

Member Accessors
enum	{ TAO_ALLOCATOR_THREAD_LOCK }
int	get_parser_names (char **&names, int &number_of_names)
int	cdr_allocator_source (void)
	Modify and get the source for the CDR allocators.
virtual int	use_locked_data_blocks (void) const
virtual ACE_Reactor *	get_reactor (void)
	Return an ACE_Reactor to be utilized.
virtual void	reclaim_reactor (ACE_Reactor *)
	Reclaim reactor resources (e.g. deallocate, etc).
virtual TAO_Acceptor_Registry *	get_acceptor_registry (void)
	Return a reference to the acceptor registry.
virtual TAO_Connector_Registry *	get_connector_registry (void)
	Return a connector to be utilized.
virtual void	use_local_memory_pool (bool)
	Return the Allocator's memory pool type.
virtual ACE_Allocator *	input_cdr_dblock_allocator (void)
virtual ACE_Allocator *	input_cdr_buffer_allocator (void)
virtual ACE_Allocator *	input_cdr_msgblock_allocator (void)
virtual int	input_cdr_allocator_type_locked (void)
virtual ACE_Allocator *	output_cdr_dblock_allocator (void)
virtual ACE_Allocator *	output_cdr_buffer_allocator (void)
virtual ACE_Allocator *	output_cdr_msgblock_allocator (void)
virtual ACE_Allocator *	amh_response_handler_allocator (void)
	Access the AMH response handler allocator.
virtual ACE_Allocator *	ami_response_handler_allocator (void)
	Access the AMI response handler allocator.
virtual TAO_ProtocolFactorySet *	get_protocol_factories (void)
virtual int	init_protocol_factories (void)
virtual TAO_Codeset_Manager *	codeset_manager (void)
	Gets the codeset manager.
virtual int	cache_maximum (void) const
	This denotes the maximum number of connections that can be cached.
virtual int	purge_percentage (void) const
virtual int	max_muxed_connections (void) const
virtual ACE_Lock *	create_cached_connection_lock (void)
virtual ACE_Lock *	create_object_key_table_lock (void)
	Creates a lock needed for the table that stores the object keys.
virtual TAO_Configurable_Refcount	create_corba_object_refcount (void)
	Creates the configurable refcount for the CORBA Object.
virtual ACE_Lock *	create_corba_object_lock (void)
	Creates the lock for the CORBA Object.
virtual int	locked_transport_cache (void)
virtual TAO_Flushing_Strategy *	create_flushing_strategy (void)
virtual TAO_Connection_Purging_Strategy *	create_purging_strategy (void)
	Creates the connection purging strategy.
TAO_Resource_Factory::Resource_Usage	resource_usage_strategy (void) const
	Return the resource usage strategy.
virtual TAO_LF_Strategy *	create_lf_strategy (void)
virtual auto_ptr< TAO_GIOP_Fragmentation_Strategy >	create_fragmentation_strategy (TAO_Transport *transport, CORBA::ULong max_message_size) const
	Outgoing fragment creation strategy.
virtual void	disable_factory (void)
virtual bool	drop_replies_during_shutdown (void) const
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
	LOCAL_MEMORY_POOL
	DEFAULT
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
	TAO_NULL_LOCK
	TAO_THREAD_LOCK
	TAO_LEADER_FOLLOWER_FLUSHING
	TAO_REACTIVE_FLUSHING
	TAO_BLOCKING_FLUSHING
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_

---

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

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.

References resource_usage_strategy_, and TAO_Resource_Factory::TAO_LAZY.

  : 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.

References ACE_Unbounded_Set_Ex< T, C >::end(), parser_names_count_, protocol_factories_, ACE_Unbounded_Set_Ex< T, C >::reset(), and CORBA::string_free().

{
  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 *

)

[protected]

Add a Parser name to the list of Parser names.

Definition at line 666 of file default_resource.cpp.

References index_, parser_names_, and CORBA::string_dup().

{
  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.

Definition at line 790 of file default_resource.cpp.

References ACE_NEW_RETURN, and ACE::max_handles().

{
  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]

Access the AMH response handler allocator.

Reimplemented from TAO_Resource_Factory.

Definition at line 991 of file default_resource.cpp.

References ACE_NEW_RETURN, and use_local_memory_pool_.

{
  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]

Access the AMI response handler allocator.

Reimplemented from TAO_Resource_Factory.

Definition at line 1011 of file default_resource.cpp.

References ACE_NEW_RETURN, and use_local_memory_pool_.

{
  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]

This denotes the maximum number of connections that can be cached.

Reimplemented from TAO_Resource_Factory.

Definition at line 1031 of file default_resource.cpp.

References cache_maximum_.

{
  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]

Gets the codeset manager.

Reimplemented from TAO_Resource_Factory.

Definition at line 1251 of file default_resource.cpp.

References ACE_DEBUG, TAO_Codeset_Parameters::apply_to(), TAO_Codeset_Manager::char_codeset_descriptor(), char_codeset_parameters_, TAO_Codeset_Manager_Factory_Base::create(), ACE_Dynamic_Service< TYPE >::instance(), LM_DEBUG, LM_INFO, ACE_Auto_Basic_Ptr< X >::release(), TAO_debug_level, TAO_Codeset_Manager::wchar_codeset_descriptor(), and wchar_codeset_parameters_.

{
  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]

Creates the lock for the lock needed in the Cache Map

Deprecated:

Reimplemented from TAO_Resource_Factory.

Definition at line 1050 of file default_resource.cpp.

References ACE_NEW_RETURN, and TAO_NULL_LOCK.

{
  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]

Creates the lock for the CORBA Object.

Reimplemented from TAO_Resource_Factory.

Definition at line 1094 of file default_resource.cpp.

References ACE_NEW_RETURN, and TAO_NULL_LOCK.

{
  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]

Creates the configurable refcount for the CORBA Object.

Reimplemented from TAO_Resource_Factory.

Definition at line 1111 of file default_resource.cpp.

References TAO_Configurable_Refcount::TAO_NULL_LOCK, TAO_NULL_LOCK, TAO_Configurable_Refcount::TAO_THREAD_LOCK, and TAO_THREAD_LOCK.

{
  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]

Creates the flushing strategy. The new instance is owned by the caller.

Implements TAO_Resource_Factory.

Definition at line 1126 of file default_resource.cpp.

References ACE_NEW_RETURN, TAO_LEADER_FOLLOWER_FLUSHING, and TAO_REACTIVE_FLUSHING.

{
  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]

Outgoing fragment creation strategy.

Implements TAO_Resource_Factory.

Definition at line 1180 of file default_resource.cpp.

References ACE_AUTO_PTR_RESET, ACE_NEW_RETURN, TAO_DEF_GIOP_MAJOR, and TAO_DEF_GIOP_MINOR.

{
  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]

Creates the leader followers strategy. The new instance is owned by the caller.

Implements TAO_Resource_Factory.

Definition at line 1168 of file default_resource.cpp.

References ACE_NEW_RETURN.

{
  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]

Creates a lock needed for the table that stores the object keys.

Reimplemented from TAO_Resource_Factory.

Definition at line 1077 of file default_resource.cpp.

References ACE_NEW_RETURN, and TAO_NULL_LOCK.

{
  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]

Creates the connection purging strategy.

Implements TAO_Resource_Factory.

Definition at line 1145 of file default_resource.cpp.

References ACE_ERROR, ACE_NEW_RETURN, and TAO_Resource_Factory::LRU.

{
  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]

Disables the factory. When a new factory is installed and used, this function should be called on the previously used (default) factory. This should result in proper error reporting if the user attempts to set options on an unused factory.

Implements TAO_Resource_Factory.

Definition at line 1239 of file default_resource.cpp.

References ACE_DEBUG, factory_disabled_, and LM_WARNING.

{
  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]

Return the value of the strategy that indicates whether the ORB should wait for the replies during shutdown or drop replies during shutdown.

Implements TAO_Resource_Factory.

Definition at line 1298 of file default_resource.cpp.

References drop_replies_.

{
  return this->drop_replies_;
}

TAO_Acceptor_Registry * TAO_Default_Resource_Factory::get_acceptor_registry

(

void

)

[virtual]

Return a reference to the acceptor registry.

Reimplemented from TAO_Resource_Factory.

Definition at line 766 of file default_resource.cpp.

References ACE_NEW_RETURN.

{
  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]

Return a connector to be utilized.

Reimplemented from TAO_Resource_Factory.

Definition at line 778 of file default_resource.cpp.

References ACE_NEW_RETURN.

{
  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]

Reimplemented from TAO_Resource_Factory.

Definition at line 591 of file default_resource.cpp.

References ACE_NEW_RETURN, parser_names_, parser_names_count_, and CORBA::string_dup().

{
  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]

The protocol factory list is implemented in this class since a) it will be a global resource and b) it is initialized at start up and then not altered. Returns a container holding the list of loaded protocols.

Reimplemented from TAO_Resource_Factory.

Definition at line 760 of file default_resource.cpp.

References protocol_factories_.

{
  return &protocol_factories_;
}

ACE_Reactor * TAO_Default_Resource_Factory::get_reactor

(

void

)

[virtual]

Return an ACE_Reactor to be utilized.

Reimplemented from TAO_Resource_Factory.

Definition at line 810 of file default_resource.cpp.

References ACE_NEW_RETURN, dynamically_allocated_reactor_, ACE_Reactor::initialized(), and ACE_Event_Handler::reactor().

{
  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

CodeSet Translators

Reimplemented from ACE_Shared_Object.

Definition at line 163 of file default_resource.cpp.

References ACE_DEBUG, ACE_NEW_RETURN, ACE_TEXT, ACE_TRACE, LM_WARNING, options_processed_, parser_names_count_, and ACE_OS::strcasecmp().

{
  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 ("Default_Resource_Factory - ")
                    ACE_TEXT ("unknown option <%s>\n"),
                    argv[curarg]));
      }
    else
      {
        ACE_DEBUG ((LM_DEBUG,
                    ACE_TEXT ("Default_Resource_Factory - ")
                    ACE_TEXT ("ignoring option <%s>\n"),
                    argv[curarg]));
      }
    }

  return 0;
}

int TAO_Default_Resource_Factory::init_protocol_factories

(

void

)

[virtual]

This method will loop through the protocol list and using the protocol name field this method will retrieve a pointer to the associated protocol factory from the service configurator. It is assumed that only one thread will call this method at ORB initialization. NON-THREAD-SAFE

Reimplemented from TAO_Resource_Factory.

Definition at line 717 of file default_resource.cpp.

References ACE_DEBUG, ACE_ERROR_RETURN, ACE_TEXT_CHAR_TO_TCHAR, ACE_Unbounded_Set_Ex< T, C >::begin(), ACE_Unbounded_Set_Ex< T, C >::end(), LM_DEBUG, load_default_protocols(), protocol_factories_, and TAO_debug_level.

{
  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 <%s>, %p\n"),
                             ACE_TEXT_CHAR_TO_TCHAR(name.c_str ()),
                             ACE_TEXT ("")),
                            -1);
        }

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

  return 0;
}

int TAO_Default_Resource_Factory::input_cdr_allocator_type_locked

(

void

)

[virtual]

Reimplemented from TAO_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]

Reimplemented from TAO_Resource_Factory.

Definition at line 870 of file default_resource.cpp.

References ACE_NEW_RETURN, and use_local_memory_pool_.

{
  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]

Reimplemented from TAO_Resource_Factory.

Definition at line 850 of file default_resource.cpp.

References ACE_NEW_RETURN, and use_local_memory_pool_.

{
  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]

Reimplemented from TAO_Resource_Factory.

Definition at line 890 of file default_resource.cpp.

References ACE_NEW_RETURN, and use_local_memory_pool_.

{
  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.

Definition at line 678 of file default_resource.cpp.

Referenced by init_protocol_factories().

{
#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]

Should the transport cache have a lock or not? Return 1 if the transport cache needs to be locked else return 0

Reimplemented from TAO_Resource_Factory.

Definition at line 1067 of file default_resource.cpp.

References TAO_NULL_LOCK.

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

  return 1;
}

int TAO_Default_Resource_Factory::max_muxed_connections

(

void

)

const [virtual]

Return the number of muxed connections that are allowed for a remote endpoint

Reimplemented from TAO_Resource_Factory.

Definition at line 1043 of file default_resource.cpp.

References max_muxed_connections_.

{
  return this->max_muxed_connections_;
}

ACE_Allocator * TAO_Default_Resource_Factory::output_cdr_buffer_allocator

(

void

)

[virtual]

Reimplemented from TAO_Resource_Factory.

Definition at line 936 of file default_resource.cpp.

References ACE_NEW_RETURN, DEFAULT, and LOCAL_MEMORY_POOL.

{
  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]

Reimplemented from TAO_Resource_Factory.

Definition at line 916 of file default_resource.cpp.

References ACE_NEW_RETURN, and use_local_memory_pool_.

{
  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]

Reimplemented from TAO_Resource_Factory.

Definition at line 971 of file default_resource.cpp.

References ACE_NEW_RETURN, and use_local_memory_pool_.

{
  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]

This denotes the amount of entries to remove from the connection cache.

Reimplemented from TAO_Resource_Factory.

Definition at line 1037 of file default_resource.cpp.

References purge_percentage_.

{
  return this->purge_percentage_;
}

void TAO_Default_Resource_Factory::reclaim_reactor

(

ACE_Reactor *

)

[virtual]

Reclaim reactor resources (e.g. deallocate, etc).

Reimplemented from TAO_Resource_Factory.

Definition at line 829 of file default_resource.cpp.

References ACE_Event_Handler::reactor().

{
  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]

Definition at line 1228 of file default_resource.cpp.

References ACE_DEBUG, and LM_DEBUG.

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

TAO_Resource_Factory::Resource_Usage TAO_Default_Resource_Factory::resource_usage_strategy

(

void

)

const [virtual]

Return the resource usage strategy.

Implements TAO_Resource_Factory.

Definition at line 1292 of file default_resource.cpp.

References resource_usage_strategy_.

{
  return this->resource_usage_strategy_;
}

void TAO_Default_Resource_Factory::use_local_memory_pool

(

bool

)

[virtual]

Return the Allocator's memory pool type.

Reimplemented from TAO_Resource_Factory.

Definition at line 841 of file default_resource.cpp.

References DEFAULT, LOCAL_MEMORY_POOL, output_cdr_allocator_type_, and use_local_memory_pool_.

{
  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]

@ Backwards compatibility, return 1 if the ORB core should use Locked_Data_Blocks

Reimplemented from TAO_Resource_Factory.

Definition at line 754 of file default_resource.cpp.

References use_locked_data_blocks_.

{
  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.

Referenced by cache_maximum().

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.

Referenced by codeset_manager().

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.

Referenced by drop_replies_during_shutdown().

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.

Referenced by get_reactor().

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.

Referenced by disable_factory().

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.

Referenced by add_to_ior_parser_names().

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.

Referenced by max_muxed_connections().

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.

Referenced by init().

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.

Referenced by use_local_memory_pool().

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.

Referenced by add_to_ior_parser_names(), and get_parser_names().

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.

Referenced by get_parser_names(), init(), and ~TAO_Default_Resource_Factory().

TAO_ProtocolFactorySet TAO_Default_Resource_Factory::protocol_factories_ [protected]

list of loaded protocol factories.

Definition at line 220 of file default_resource.h.

Referenced by get_protocol_factories(), init_protocol_factories(), and ~TAO_Default_Resource_Factory().

int TAO_Default_Resource_Factory::purge_percentage_ [protected]

Specifies the percentage of entries which should get purged on demand.

Definition at line 232 of file default_resource.h.

Referenced by purge_percentage().

int TAO_Default_Resource_Factory::reactor_mask_signals_ [protected]

If <0> then we create reactors with signal handling disabled.

Definition at line 240 of file default_resource.h.

Resource_Usage TAO_Default_Resource_Factory::resource_usage_strategy_ [private]

Resource usage strategy.

Definition at line 315 of file default_resource.h.

Referenced by resource_usage_strategy(), and TAO_Default_Resource_Factory().

bool TAO_Default_Resource_Factory::use_local_memory_pool_ [protected]

This flag is used to determine whether the CDR allocators should use the local memory pool or not.

Definition at line 281 of file default_resource.h.

Referenced by amh_response_handler_allocator(), ami_response_handler_allocator(), input_cdr_buffer_allocator(), input_cdr_dblock_allocator(), input_cdr_msgblock_allocator(), output_cdr_dblock_allocator(), output_cdr_msgblock_allocator(), and use_local_memory_pool().

int TAO_Default_Resource_Factory::use_locked_data_blocks_ [protected]

The type of data blocks that the ORB should use.

Definition at line 208 of file default_resource.h.

Referenced by use_locked_data_blocks().

TAO_Codeset_Parameters TAO_Default_Resource_Factory::wchar_codeset_parameters_ [private]

Definition at line 312 of file default_resource.h.

Referenced by codeset_manager().

---

The documentation for this class was generated from the following files:

• default_resource.h
• default_resource.cpp

---