Main Page   Namespace List   Class Hierarchy   Alphabetical List   Compound List   File List   Namespace Members   Compound Members   File Members   Related Pages  

TAO_Default_Resource_Factory Class Reference

TAO's default resource factory. More...

#include <default_resource.h>

Inheritance diagram for TAO_Default_Resource_Factory:

Inheritance graph
[legend]
Collaboration diagram for TAO_Default_Resource_Factory:

Collaboration graph
[legend]
List of all members.

Member Accessors

enum  { TAO_ALLOCATOR_THREAD_LOCK }
enum  TRANSLATOR_TYPE { CHAR_TRANSLATOR, WCHAR_TRANSLATOR }
int get_parser_names (char **&names, int &number_of_names)
int cdr_allocator_source (void)
 Modify and get the source for the CDR allocators. More...

virtual int use_locked_data_blocks (void) const
 Backwards compatibility, return 1 if the ORB core should use Locked_Data_Blocks. More...

virtual ACE_Reactorget_reactor (void)
 Return an <ACE_Reactor> to be utilized. More...

virtual void reclaim_reactor (ACE_Reactor *)
 Reclaim reactor resources (e.g. deallocate, etc). More...

virtual TAO_Acceptor_Registryget_acceptor_registry (void)
 Return a reference to the acceptor registry. More...

virtual TAO_Connector_Registryget_connector_registry (void)
 Return an Connector to be utilized. More...

virtual ACE_Allocatorinput_cdr_dblock_allocator (void)
 Access the input CDR allocators. More...

virtual ACE_Allocatorinput_cdr_buffer_allocator (void)
virtual ACE_Allocatorinput_cdr_msgblock_allocator (void)
virtual int input_cdr_allocator_type_locked (void)
virtual ACE_Allocatoroutput_cdr_dblock_allocator (void)
 Access the output CDR allocators. More...

virtual ACE_Allocatoroutput_cdr_buffer_allocator (void)
virtual ACE_Allocatoroutput_cdr_msgblock_allocator (void)
virtual TAO_ProtocolFactorySetget_protocol_factories (void)
virtual TAO_Codeset_Managerget_codeset_manager ()
virtual int init_protocol_factories (void)
virtual int cache_maximum (void) const
 This denotes the maximum number of connections that can be cached. More...

virtual int purge_percentage (void) const
 This denotes the amount of entries to remove from the connection cache. More...

virtual int max_muxed_connections (void) const
 Return the number of muxed connections that are allowed for a remote endpoint. More...

virtual ACE_Lockcreate_cached_connection_lock (void)
 Creates the lock for the lock needed in the Cache Map @todo: This method needs to go away as it doesnt make much sense now. More...

virtual int locked_transport_cache (void)
 Should the transport cache have a lock or not? Return 1 if the transport cache needs to be locked else return 0. More...

virtual TAO_Flushing_Strategycreate_flushing_strategy (void)
 Creates the flushing strategy. The new instance is owned by the caller. More...

virtual TAO_Connection_Purging_Strategycreate_purging_strategy (void)
 Creates the connection purging strategy. More...

virtual TAO_LF_Strategycreate_lf_strategy (void)
 Creates the leader followers strategy. The new instance is owned by the caller. More...

virtual void disable_factory (void)
 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. More...


Public Types


Public Methods

 TAO_Default_Resource_Factory (void)
 Constructor. More...

virtual ~TAO_Default_Resource_Factory (void)
 Destructor. More...

Service Configurator Hooks
virtual int init (int argc, ACE_TCHAR *argv[])
 Dynamic linking hook. More...

int parse_args (int argc, ACE_TCHAR *argv[])
 Parse svc.conf arguments. More...


Protected Methods

virtual ACE_Reactor_Implallocate_reactor_impl (void) const
 Obtain the reactor implementation. More...

int add_to_ior_parser_names (const char *)
 Add a Parser name to the list of Parser names. More...

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

int parser_names_count_
 The number of the different types of Parsers. More...

char ** parser_names_
 Array consisting of the names of the parsers. More...

int index_
 Index of the current element in the parser_names_ array. More...

TAO_ProtocolFactorySet protocol_factories_
 list of loaded protocol factories. More...

TAO_Resource_Factory::Purging_Strategy connection_purging_type_
 Specifies the typeof purging strategy we should use for cleaning up unused connections. More...

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

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

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

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

int dynamically_allocated_reactor_
int options_processed_
 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. More...

int factory_disabled_
 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). More...


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

int flushing_strategy_type_
 Type of flushing strategy configured. More...

TAO_Codeset_Managercodeset_manager_

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 62 of file default_resource.h.


Member Enumeration Documentation

anonymous enum
 

Enumeration values:
TAO_ALLOCATOR_THREAD_LOCK 

Definition at line 91 of file default_resource.h.

00092   {
00093     TAO_ALLOCATOR_THREAD_LOCK
00094   };

enum TAO_Default_Resource_Factory::Flushing_Strategy_Type [private]
 

Enumeration values:
TAO_LEADER_FOLLOWER_FLUSHING 
TAO_REACTIVE_FLUSHING 
TAO_BLOCKING_FLUSHING 

Definition at line 224 of file default_resource.h.

enum TAO_Default_Resource_Factory::Lock_Type [private]
 

Enumeration values:
TAO_NULL_LOCK 
TAO_THREAD_LOCK 

Definition at line 215 of file default_resource.h.

00216   {
00217     TAO_NULL_LOCK,
00218     TAO_THREAD_LOCK
00219   };

enum TAO_Default_Resource_Factory::TRANSLATOR_TYPE
 

Enumeration values:
CHAR_TRANSLATOR 
WCHAR_TRANSLATOR 

Definition at line 97 of file default_resource.h.

00098   {
00099     CHAR_TRANSLATOR,
00100     WCHAR_TRANSLATOR
00101   };


Constructor & Destructor Documentation

TAO_Default_Resource_Factory::TAO_Default_Resource_Factory void   
 

Constructor.

Definition at line 40 of file default_resource.cpp.

References TAO_CONNECTION_CACHE_MAXIMUM, TAO_CONNECTION_PURGING_STRATEGY, and TAO_PURGE_PERCENT.

TAO_Default_Resource_Factory::~TAO_Default_Resource_Factory void    [virtual]
 

Destructor.

Definition at line 59 of file default_resource.cpp.

References ACE_Unbounded_Set< TAO_Protocol_Item * >::begin, codeset_manager_, ACE_Unbounded_Set< TAO_Protocol_Item * >::end, parser_names_, parser_names_count_, protocol_factories_, ACE_Unbounded_Set< TAO_Protocol_Item * >::reset, and CORBA::string_free.

00060 {
00061   TAO_ProtocolFactorySetItor end = this->protocol_factories_.end ();
00062 
00063   for (TAO_ProtocolFactorySetItor iterator =
00064          this->protocol_factories_.begin ();
00065        iterator != end;
00066        ++iterator)
00067     delete *iterator;
00068 
00069   this->protocol_factories_.reset ();
00070 
00071   for (int i = 0;
00072        i < this->parser_names_count_;
00073        ++i)
00074     CORBA::string_free (this->parser_names_[i]);
00075 
00076   delete [] this->parser_names_;
00077 
00078   delete this->codeset_manager_;
00079 }


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 472 of file default_resource.cpp.

References index_, parser_names_, and CORBA::string_dup.

Referenced by init.

00473 {
00474   this->parser_names_[this->index_] = CORBA::string_dup (curarg);
00475 
00476   ++this->index_;
00477 
00478   return 0;
00479 }

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

Obtain the reactor implementation.

Reimplemented in TAO_QtResource_Factory.

Definition at line 673 of file default_resource.cpp.

References ACE_NEW_RETURN, and ACE_Timer_Queue.

00674 {
00675   ACE_Reactor_Impl *impl = 0;
00676 
00677   ACE_NEW_RETURN (impl, ACE_TP_Reactor ((ACE_Sig_Handler*)0,
00678                                         (ACE_Timer_Queue*)0,
00679                                         this->reactor_mask_signals_,
00680                                         ACE_Select_Reactor_Token::LIFO),
00681                   0);
00682   return impl;
00683 }

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 784 of file default_resource.cpp.

References cache_maximum_.

00785 {
00786   return this->cache_maximum_;
00787 }

int TAO_Default_Resource_Factory::cdr_allocator_source void   
 

Modify and get the source for the CDR allocators.

ACE_Lock * TAO_Default_Resource_Factory::create_cached_connection_lock void    [virtual]
 

Creates the lock for the lock needed in the Cache Map @todo: This method needs to go away as it doesnt make much sense now.

Reimplemented from TAO_Resource_Factory.

Definition at line 803 of file default_resource.cpp.

References ACE_NEW_RETURN, cached_connection_lock_type_, and TAO_NULL_LOCK.

00804 {
00805   ACE_Lock *the_lock = 0;
00806 
00807   if (this->cached_connection_lock_type_ == TAO_NULL_LOCK)
00808     ACE_NEW_RETURN (the_lock,
00809                     ACE_Lock_Adapter<ACE_SYNCH_NULL_MUTEX>,
00810                     0);
00811   else
00812     ACE_NEW_RETURN (the_lock,
00813                     ACE_Lock_Adapter<TAO_SYNCH_MUTEX>,
00814                     0);
00815 
00816   return the_lock;
00817 }

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 830 of file default_resource.cpp.

References ACE_NEW_RETURN, flushing_strategy_type_, TAO_LEADER_FOLLOWER_FLUSHING, and TAO_REACTIVE_FLUSHING.

00831 {
00832   TAO_Flushing_Strategy *strategy = 0;
00833   if (this->flushing_strategy_type_ == TAO_LEADER_FOLLOWER_FLUSHING)
00834     ACE_NEW_RETURN (strategy,
00835                     TAO_Leader_Follower_Flushing_Strategy,
00836                     0);
00837   else if (this->flushing_strategy_type_ == TAO_REACTIVE_FLUSHING)
00838     ACE_NEW_RETURN (strategy,
00839                     TAO_Reactive_Flushing_Strategy,
00840                     0);
00841   else
00842     ACE_NEW_RETURN (strategy,
00843                     TAO_Block_Flushing_Strategy,
00844                     0);
00845   return strategy;
00846 }

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 872 of file default_resource.cpp.

References ACE_NEW_RETURN.

00873 {
00874   TAO_LF_Strategy *strategy = 0;
00875 
00876   ACE_NEW_RETURN (strategy,
00877                   TAO_LF_Strategy_Complete,
00878                   0);
00879 
00880   return strategy;
00881 }

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 849 of file default_resource.cpp.

References ACE_ERROR, ACE_LIB_TEXT, ACE_NEW_RETURN, connection_purging_type_, LM_ERROR, and TAO_Resource_Factory::LRU.

00850 {
00851   TAO_Connection_Purging_Strategy *strategy = 0;
00852 
00853   if (this->connection_purging_type_ == TAO_Resource_Factory::LRU)
00854     {
00855       ACE_NEW_RETURN (strategy,
00856                       TAO_LRU_Connection_Purging_Strategy (
00857                                            this->cache_maximum ()),
00858                       0);
00859     }
00860   else
00861     {
00862       ACE_ERROR ((LM_ERROR,
00863                   ACE_LIB_TEXT ("TAO (%P|%t) - ")
00864                   ACE_LIB_TEXT ("no usable purging strategy ")
00865                   ACE_LIB_TEXT ("was found.\n")));
00866     }
00867 
00868   return strategy;
00869 }

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 895 of file default_resource.cpp.

References ACE_DEBUG, ACE_LIB_TEXT, factory_disabled_, LM_DEBUG, and options_processed_.

00896 {
00897   this->factory_disabled_ = 1;
00898   if (this->options_processed_)
00899     {
00900       ACE_DEBUG ((LM_DEBUG,
00901                   ACE_LIB_TEXT ("TAO (%P|%t) Warning: Resource_Factory options ignored\n")
00902                   ACE_LIB_TEXT ("Default Resource Factory is disabled\n")));
00903     }
00904 }

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 649 of file default_resource.cpp.

References ACE_NEW_RETURN.

00650 {
00651   TAO_Acceptor_Registry *ar = 0;
00652 
00653   ACE_NEW_RETURN(ar,
00654                  TAO_Acceptor_Registry,
00655                  0);
00656 
00657   return ar;
00658 }

TAO_Codeset_Manager * TAO_Default_Resource_Factory::get_codeset_manager   [virtual]
 

Reimplemented from TAO_Resource_Factory.

Definition at line 907 of file default_resource.cpp.

References ACE_NEW_RETURN, and codeset_manager_.

Referenced by init.

00908 {
00909   if (this->codeset_manager_ == 0)
00910     {
00911       ACE_NEW_RETURN (this->codeset_manager_, TAO_Codeset_Manager, 0);
00912     }
00913   return this->codeset_manager_;
00914 }

TAO_Connector_Registry * TAO_Default_Resource_Factory::get_connector_registry void    [virtual]
 

Return an Connector to be utilized.

Reimplemented from TAO_Resource_Factory.

Definition at line 661 of file default_resource.cpp.

References ACE_NEW_RETURN.

00662 {
00663   TAO_Connector_Registry *cr = 0;
00664 
00665   ACE_NEW_RETURN(cr,
00666                  TAO_Connector_Registry,
00667                  0);
00668 
00669   return cr;
00670 }

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

Reimplemented from TAO_Resource_Factory.

Definition at line 430 of file default_resource.cpp.

References names, parser_names_, parser_names_count_, and CORBA::string_dup.

00432 {
00433   if (this->parser_names_count_ != 0)
00434     {
00435       // The user used some -ORBIORParser options, just return those.
00436       names = this->parser_names_;
00437       number_of_names = this->parser_names_count_;
00438 
00439       return 0;
00440     }
00441 
00442   // OK fallback on the hardcoded ones....
00443   this->parser_names_count_ = 5; // HOW MANY DO WE HAVE?
00444   this->parser_names_ =
00445     new char *[this->parser_names_count_];
00446 
00447   CORBA::ULong index = 0;
00448 
00449   this->parser_names_[index] = CORBA::string_dup ("DLL_Parser");
00450   index++;
00451 
00452   this->parser_names_[index] = CORBA::string_dup ("FILE_Parser");
00453   index++;
00454 
00455   this->parser_names_[index] = CORBA::string_dup ("CORBALOC_Parser");
00456   index++;
00457 
00458   this->parser_names_[index] = CORBA::string_dup ("CORBANAME_Parser");
00459   index++;
00460 
00461   this->parser_names_[index] = CORBA::string_dup ("MCAST_Parser");
00462   index++;
00463 
00464   names = this->parser_names_;
00465 
00466   number_of_names = index;
00467 
00468   return 0;
00469 }

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 643 of file default_resource.cpp.

References protocol_factories_.

Referenced by init.

00644 {
00645   return &protocol_factories_;
00646 }

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 686 of file default_resource.cpp.

References ACE_LOG_MSG, ACE_NEW_RETURN, dynamically_allocated_reactor_, and ACE_Event_Handler::reactor.

00687 {
00688   ACE_LOG_MSG->errnum (0);
00689 
00690   ACE_Reactor *reactor = 0;
00691   ACE_NEW_RETURN (reactor,
00692                   ACE_Reactor (this->allocate_reactor_impl (), 1),
00693                   0);
00694 
00695   if (ACE_LOG_MSG->errnum () != 0)
00696     {
00697       delete reactor;
00698       reactor = 0;
00699     }
00700   else
00701     this->dynamically_allocated_reactor_ = 1;
00702 
00703   return reactor;
00704 }

int TAO_Default_Resource_Factory::init int    argc,
ACE_TCHAR   argv[]
[virtual]
 

Dynamic linking hook.

Reimplemented from ACE_Shared_Object.

Definition at line 82 of file default_resource.cpp.

References ACE_DEBUG, ACE_ERROR, ACE_LIB_TEXT, ACE_NEW_RETURN, ACE_TCHAR, ACE_TEXT, ACE_TEXT_ALWAYS_CHAR, ACE_TRACE, TAO_Codeset_Manager::add_char_translator, add_to_ior_parser_names, TAO_Codeset_Manager::add_wchar_translator, ACE_OS::atoi, cache_maximum_, cached_connection_lock_type_, TAO_Codeset_Manager::configure_codeset_factories, connection_purging_type_, factory_disabled_, TAO_Resource_Factory::FIFO, flushing_strategy_type_, get_codeset_manager, ACE_Codeset_Registry::get_max_bytes, get_protocol_factories, index_, ACE_Unbounded_Set< TAO_Protocol_Item * >::insert, TAO_Resource_Factory::LFU, LM_DEBUG, LM_ERROR, ACE_Codeset_Registry::locale_to_registry, TAO_Resource_Factory::LRU, max_muxed_connections_, TAO_Resource_Factory::NOOP, options_processed_, parser_names_, parser_names_count_, purge_percentage_, reactor_mask_signals_, report_option_value_error, TAO_Codeset_Manager::set_ncs_c, TAO_Codeset_Manager::set_ncs_w, ACE_OS_String::strcasecmp, ACE_OS_String::strncmp, ACE_OS_String::strtoul, TAO_BLOCKING_FLUSHING, TAO_LEADER_FOLLOWER_FLUSHING, TAO_NULL_LOCK, TAO_REACTIVE_FLUSHING, TAO_THREAD_LOCK, and use_locked_data_blocks_.

00083 {
00084   ACE_TRACE ("TAO_Default_Resource_Factory::init");
00085 
00086   // If this factory has already been disabled then
00087   // print a warning and exit because any options
00088   // are useless
00089   if (this->factory_disabled_) {
00090     ACE_DEBUG ((LM_DEBUG,
00091                 ACE_LIB_TEXT ("TAO (%P|%t) Warning: Resource_Factory options ignored\n")
00092                 ACE_LIB_TEXT ("Default Resource Factory is disabled\n")));
00093     return 0;
00094   }
00095   this->options_processed_ = 1;
00096 
00097   this->parser_names_count_ = 0;
00098 
00099   int curarg = 0;
00100 
00101   for (curarg = 0; curarg < argc; ++curarg)
00102   {
00103     // Parse thro' and find the number of Parsers to be loaded.
00104     if (ACE_OS::strcasecmp (argv[curarg],
00105                             ACE_LIB_TEXT("-ORBIORParser")) == 0)
00106       ++this->parser_names_count_;
00107 
00108     ++curarg;
00109 
00110     if (curarg == (argc-1) && this->parser_names_count_ != 0)
00111       {
00112         // This is the last loop..
00113         ACE_NEW_RETURN (this->parser_names_,
00114                         char *[this->parser_names_count_],
00115                         -1);
00116 
00117         for (int i = 0;
00118              i < this->parser_names_count_;
00119              ++i)
00120           this->parser_names_[i] = 0;
00121 
00122         this->index_ = 0;
00123       }
00124   }
00125 
00126   for (curarg = 0; curarg < argc; ++curarg)
00127     if (ACE_OS::strcasecmp (argv[curarg],
00128                             ACE_LIB_TEXT("-ORBResources")) == 0)
00129       {
00130         curarg++;
00131 
00132         ACE_DEBUG ((LM_DEBUG,
00133                     ACE_LIB_TEXT ("(%P|%t) This option has been deprecated \n")));
00134       }
00135 
00136     else if (ACE_OS::strcasecmp (argv[curarg],
00137                                  ACE_LIB_TEXT("-ORBReactorMaskSignals")) == 0)
00138       {
00139         curarg++;
00140         if (curarg < argc)
00141           {
00142             ACE_TCHAR* name = argv[curarg];
00143 
00144             if (ACE_OS::strcasecmp (name, ACE_LIB_TEXT("0")) == 0)
00145               this->reactor_mask_signals_ = 0;
00146             else if (ACE_OS::strcasecmp (name, ACE_LIB_TEXT("1")) == 0)
00147               this->reactor_mask_signals_= 1;
00148             else
00149               this->report_option_value_error (ACE_LIB_TEXT("-ORBReactorMaskSignals"), name);
00150           }
00151       }
00152 
00153     else if (ACE_OS::strcasecmp (argv[curarg],
00154                                  ACE_LIB_TEXT("-ORBProtocolFactory")) == 0)
00155       {
00156         TAO_ProtocolFactorySet *pset = this->get_protocol_factories ();
00157         curarg++;
00158         if (curarg < argc)
00159           {
00160             TAO_Protocol_Item *item = 0;
00161             ACE_NEW_RETURN (item,
00162                             TAO_Protocol_Item (ACE_TEXT_ALWAYS_CHAR(argv[curarg])),
00163                             -1);
00164             if (pset->insert (item) == -1)
00165               ACE_ERROR ((LM_ERROR,
00166                           ACE_LIB_TEXT ("(%P|%t) Unable to add protocol factories for %s: %p\n"),
00167                           argv[curarg]));
00168           }
00169       }
00170 
00171     /// CodeSet Translators
00172     else if (ACE_OS::strcasecmp (argv[curarg],
00173                                  ACE_LIB_TEXT("-ORBNativeCharCodeSet")) == 0)
00174     {
00175         curarg++;
00176         CONV_FRAME::CodeSetId ncs;
00177         if (ACE_Codeset_Registry::locale_to_registry (argv[curarg],
00178                                                       ncs) == 0)
00179           {
00180             char **endPtr =0;
00181             ncs = ACE_OS_String::strtoul(ACE_TEXT_ALWAYS_CHAR(argv[curarg]),
00182                                          endPtr, 0);
00183   }
00184         // Validate the CodesetId
00185         if (ACE_Codeset_Registry::get_max_bytes(ncs) == 0)
00186           {
00187             if (TAO_debug_level > 0)
00188               ACE_ERROR((LM_ERROR,
00189                          ACE_TEXT("(%P|%t) Invalid NativeCharCodeSet, %x\n"),
00190                          ncs));
00191             return -1;
00192           }
00193         TAO_Codeset_Manager *csm = this->get_codeset_manager();
00194         if (csm)
00195           csm->set_ncs_c(ncs);
00196     }
00197 
00198     else if (ACE_OS::strcasecmp (argv[curarg],
00199                                  ACE_LIB_TEXT("-ORBNativeWCharCodeSet")) == 0)
00200       {
00201         curarg++;
00202         CONV_FRAME::CodeSetId ncs;
00203         if (ACE_Codeset_Registry::locale_to_registry( argv[curarg],
00204                                                       ncs) == 0)
00205           {
00206             char **endPtr = 0;
00207             ncs = ACE_OS_String::strtoul(ACE_TEXT_ALWAYS_CHAR(argv[curarg]),
00208                                          endPtr, 0);
00209           }
00210         // Validate the CodesetId
00211         int mb = ACE_Codeset_Registry::get_max_bytes(ncs);
00212         if (mb == 0 || ACE_static_cast(size_t,mb) > sizeof (ACE_CDR::WChar))
00213           {
00214             if (TAO_debug_level > 0)
00215               ACE_ERROR((LM_ERROR,
00216                          ACE_TEXT("(%P|%t) Invalid NativeWCharCodeSet, %x\n"),
00217                          ncs));
00218             return -1;
00219           }
00220         TAO_Codeset_Manager *csm = this->get_codeset_manager();
00221         if (csm)
00222           csm->set_ncs_w(ncs,mb);
00223       }
00224 
00225     else if (ACE_OS::strcasecmp (argv[curarg],
00226                                  ACE_LIB_TEXT("-ORBCharCodesetTranslator")) == 0)
00227       {
00228         curarg++;
00229         if (curarg < argc)
00230           {
00231             TAO_Codeset_Manager *csm = this->get_codeset_manager();
00232             if (csm)
00233               if (csm->add_char_translator(argv[curarg]) == -1)
00234                 return -1;
00235           }
00236       }
00237 
00238   /// CodeSet Translators
00239     else if (ACE_OS::strcasecmp (argv[curarg],
00240                                  ACE_LIB_TEXT("-ORBWCharCodesetTranslator")) == 0)
00241       {
00242         curarg++;
00243         if (curarg < argc)
00244           {
00245             TAO_Codeset_Manager *csm = this->get_codeset_manager();
00246             if (csm)
00247               if (csm->add_wchar_translator(argv[curarg]) == -1)
00248                 return -1;
00249           }
00250       }
00251 
00252     else if (ACE_OS::strcasecmp (argv[curarg],
00253                                  ACE_LIB_TEXT("-ORBConnectionCachingStrategy")) == 0)
00254       {
00255         curarg++;
00256 
00257         // @@todo: This needs to be removed after a few betas. The
00258         // note is being written during 1.2.3 timeframe.
00259         ACE_DEBUG ((LM_DEBUG,
00260                     ACE_LIB_TEXT ("(%P|%t) This option would be deprecated \n")
00261                     ACE_LIB_TEXT ("(%P|%t) Please use -ORBConnectionPurgingStrategy instead \n")));
00262 
00263         if (curarg < argc)
00264           {
00265             ACE_TCHAR* name = argv[curarg];
00266 
00267             if (ACE_OS::strcasecmp (name,
00268                                     ACE_LIB_TEXT("lru")) == 0)
00269               this->connection_purging_type_ =
00270                 TAO_Resource_Factory::LRU;
00271             else if (ACE_OS::strcasecmp (name,
00272                                          ACE_LIB_TEXT("lfu")) == 0)
00273               this->connection_purging_type_ =
00274                 TAO_Resource_Factory::LFU;
00275             else if (ACE_OS::strcasecmp (name,
00276                                          ACE_LIB_TEXT("fifo")) == 0)
00277               this->connection_purging_type_ =
00278                 TAO_Resource_Factory::FIFO;
00279             else if (ACE_OS::strcasecmp (name,
00280                                          ACE_LIB_TEXT("null")) == 0)
00281               this->connection_purging_type_ =
00282                   TAO_Resource_Factory::NOOP;
00283             else
00284               this->report_option_value_error (ACE_LIB_TEXT("-ORBConnectionCachingStrategy"), name);
00285           }
00286       }
00287     else if (ACE_OS::strcasecmp (argv[curarg],
00288                                  ACE_LIB_TEXT("-ORBConnectionPurgingStrategy")) == 0)
00289       {
00290         curarg++;
00291 
00292         if (curarg < argc)
00293           {
00294             ACE_TCHAR* name = argv[curarg];
00295 
00296             if (ACE_OS::strcasecmp (name,
00297                                     ACE_LIB_TEXT("lru")) == 0)
00298               this->connection_purging_type_ =
00299                 TAO_Resource_Factory::LRU;
00300             else if (ACE_OS::strcasecmp (name,
00301                                          ACE_LIB_TEXT("lfu")) == 0)
00302               this->connection_purging_type_ =
00303                 TAO_Resource_Factory::LFU;
00304             else if (ACE_OS::strcasecmp (name,
00305                                          ACE_LIB_TEXT("fifo")) == 0)
00306               this->connection_purging_type_ =
00307                 TAO_Resource_Factory::FIFO;
00308             else if (ACE_OS::strcasecmp (name,
00309                                          ACE_LIB_TEXT("null")) == 0)
00310               this->connection_purging_type_ =
00311                   TAO_Resource_Factory::NOOP;
00312             else
00313               this->report_option_value_error (ACE_LIB_TEXT("-ORBConnectionPurgingStrategy"), name);
00314           }
00315       }
00316    else if (ACE_OS::strcasecmp (argv[curarg],
00317                                 ACE_LIB_TEXT("-ORBConnectionCacheMax")) == 0)
00318       {
00319         curarg++;
00320         if (curarg < argc)
00321             this->cache_maximum_ = ACE_OS::atoi (argv[curarg]);
00322         else
00323           this->report_option_value_error (ACE_LIB_TEXT("-ORBConnectionCacheMax"), argv[curarg]);
00324       }
00325 
00326    else if (ACE_OS::strcasecmp (argv[curarg],
00327                                 ACE_LIB_TEXT("-ORBConnectionCachePurgePercentage")) == 0)
00328       {
00329         curarg++;
00330         if (curarg < argc)
00331             this->purge_percentage_ = ACE_OS::atoi (argv[curarg]);
00332         else
00333           this->report_option_value_error (ACE_LIB_TEXT("-ORBConnectionCachePurgePercentage"),
00334                                            argv[curarg]);
00335       }
00336     else if (ACE_OS::strcasecmp (argv[curarg],
00337                                  ACE_LIB_TEXT("-ORBIORParser")) == 0)
00338       {
00339         curarg++;
00340 
00341         if (curarg < argc)
00342           {
00343             this->add_to_ior_parser_names (ACE_TEXT_ALWAYS_CHAR(argv[curarg]));
00344           }
00345       }
00346 
00347     else if (ACE_OS::strcasecmp (argv[curarg],
00348                                  ACE_LIB_TEXT("-ORBConnectionCacheLock")) == 0)
00349       {
00350         curarg++;
00351         if (curarg < argc)
00352           {
00353             ACE_TCHAR* name = argv[curarg];
00354 
00355             if (ACE_OS::strcasecmp (name,
00356                                     ACE_LIB_TEXT("thread")) == 0)
00357               this->cached_connection_lock_type_ = TAO_THREAD_LOCK;
00358             else if (ACE_OS::strcasecmp (name,
00359                                          ACE_LIB_TEXT("null")) == 0)
00360               {
00361                 // @@ Bug 940 :This is a sort of hack now. We need to put
00362                 // this in a common place once we get the common
00363                 // switch that is documented in bug 940...
00364                 this->use_locked_data_blocks_  = 0;
00365                 this->cached_connection_lock_type_ = TAO_NULL_LOCK;
00366               }
00367             else
00368               this->report_option_value_error (ACE_LIB_TEXT("-ORBConnectionCacheLock"), name);
00369           }
00370       }
00371     else if (ACE_OS::strcasecmp (argv[curarg],
00372                                  ACE_LIB_TEXT("-ORBFlushingStrategy")) == 0)
00373       {
00374         curarg++;
00375         if (curarg < argc)
00376           {
00377             ACE_TCHAR* name = argv[curarg];
00378 
00379             if (ACE_OS::strcasecmp (name,
00380                                     ACE_LIB_TEXT("leader_follower")) == 0)
00381               this->flushing_strategy_type_ = TAO_LEADER_FOLLOWER_FLUSHING;
00382             else if (ACE_OS::strcasecmp (name,
00383                                          ACE_LIB_TEXT("reactive")) == 0)
00384               this->flushing_strategy_type_ = TAO_REACTIVE_FLUSHING;
00385             else if (ACE_OS::strcasecmp (name,
00386                                          ACE_LIB_TEXT("blocking")) == 0)
00387               this->flushing_strategy_type_ = TAO_BLOCKING_FLUSHING;
00388             else
00389               this->report_option_value_error (ACE_LIB_TEXT("-ORBFlushingStrategy"), name);
00390           }
00391       }
00392     else if (ACE_OS::strcasecmp (argv[curarg],
00393                                  ACE_LIB_TEXT ("-ORBMuxedConnectionMax")) == 0)
00394       {
00395         curarg++;
00396         if (curarg < argc)
00397             this->max_muxed_connections_ =
00398               ACE_OS::atoi (argv[curarg]);
00399         else
00400           this->report_option_value_error ("-ORBMuxedConnectionMax",
00401                                            argv[curarg]);
00402       }
00403     else if (ACE_OS::strncmp (argv[curarg],
00404                               ACE_LIB_TEXT ("-ORB"),
00405                               4) == 0)
00406       {
00407         // Can we assume there is an argument after the option?
00408         // curarg++;
00409         ACE_ERROR ((LM_ERROR,
00410                     ACE_LIB_TEXT ("Default_Resource_Factory - ")
00411                     ACE_LIB_TEXT ("unknown option <%s>\n"),
00412                     argv[curarg]));
00413       }
00414     else
00415       {
00416         ACE_DEBUG ((LM_DEBUG,
00417                     ACE_LIB_TEXT ("Default_Resource_Factory - ")
00418                     ACE_LIB_TEXT ("ignoring option <%s>\n"),
00419                     argv[curarg]));
00420       }
00421 
00422   TAO_Codeset_Manager *csm = this->get_codeset_manager();
00423   if (csm)
00424     csm->configure_codeset_factories();
00425 
00426   return 0;
00427 }

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 591 of file default_resource.cpp.

References ACE_CString, ACE_DEBUG, ACE_ERROR_RETURN, ACE_LIB_TEXT, ACE_TEXT_CHAR_TO_TCHAR, ACE_Unbounded_Set< TAO_Protocol_Item * >::begin, ACE_Unbounded_Set< TAO_Protocol_Item * >::end, LM_DEBUG, LM_ERROR, load_default_protocols, and protocol_factories_.

00592 {
00593   TAO_ProtocolFactorySetItor end = protocol_factories_.end ();
00594   TAO_ProtocolFactorySetItor factory = protocol_factories_.begin ();
00595 
00596   if (factory == end)
00597     {
00598       return this->load_default_protocols ();
00599     }
00600 
00601   for (; factory != end; factory++)
00602     {
00603       const ACE_CString &name = (*factory)->protocol_name ();
00604       (*factory)->factory (
00605         ACE_Dynamic_Service<TAO_Protocol_Factory>::instance (name.c_str ()));
00606       if ((*factory)->factory () == 0)
00607         {
00608           ACE_ERROR_RETURN ((LM_ERROR,
00609                              ACE_LIB_TEXT ("TAO (%P|%t) Unable to load ")
00610                              ACE_LIB_TEXT ("protocol <%s>, %p\n"),
00611                              ACE_TEXT_CHAR_TO_TCHAR(name.c_str ()),
00612                              ACE_LIB_TEXT ("")),
00613                             -1);
00614         }
00615 
00616       if (TAO_debug_level > 0)
00617         {
00618           ACE_DEBUG ((LM_DEBUG,
00619                       ACE_LIB_TEXT ("TAO (%P|%t) Loaded protocol <%s>\n"),
00620                       ACE_TEXT_CHAR_TO_TCHAR(name.c_str ())));
00621         }
00622     }
00623 
00624   return 0;
00625 }

int TAO_Default_Resource_Factory::input_cdr_allocator_type_locked void    [virtual]
 

Reimplemented from TAO_Resource_Factory.

Definition at line 754 of file default_resource.cpp.

00755 {
00756   return 1;
00757 }

ACE_Allocator * TAO_Default_Resource_Factory::input_cdr_buffer_allocator void    [virtual]
 

Reimplemented from TAO_Resource_Factory.

Definition at line 732 of file default_resource.cpp.

References ACE_NEW_RETURN.

00733 {
00734   ACE_Allocator *allocator = 0;
00735   ACE_NEW_RETURN (allocator,
00736                   LOCKED_ALLOCATOR,
00737                   0);
00738 
00739   return allocator;
00740 }

ACE_Allocator * TAO_Default_Resource_Factory::input_cdr_dblock_allocator void    [virtual]
 

Access the input CDR allocators.

Reimplemented from TAO_Resource_Factory.

Definition at line 721 of file default_resource.cpp.

References ACE_NEW_RETURN.

00722 {
00723   ACE_Allocator *allocator = 0;
00724   ACE_NEW_RETURN (allocator,
00725                   LOCKED_ALLOCATOR,
00726                   0);
00727 
00728   return allocator;
00729 }

ACE_Allocator * TAO_Default_Resource_Factory::input_cdr_msgblock_allocator void    [virtual]
 

Reimplemented from TAO_Resource_Factory.

Definition at line 743 of file default_resource.cpp.

References ACE_NEW_RETURN.

00744 {
00745   ACE_Allocator *allocator = 0;
00746   ACE_NEW_RETURN (allocator,
00747                   LOCKED_ALLOCATOR,
00748                   0);
00749 
00750   return allocator;
00751 }

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 483 of file default_resource.cpp.

References ACE_AUTO_PTR_RESET, ACE_DEBUG, ACE_ERROR, ACE_LIB_TEXT, ACE_NEW_RETURN, ACE_TEXT_CHAR_TO_TCHAR, TAO_Protocol_Item::factory, ACE_Unbounded_Set< TAO_Protocol_Item * >::insert, ACE_Dynamic_Service::instance, LM_DEBUG, LM_ERROR, LM_WARNING, protocol_factories_, and TAO_Protocol_Item::protocol_name.

Referenced by init_protocol_factories.

00484 {
00485       // If the user did not list any protocols in her svc.conf file
00486       // then default to TAO's basic protocols.
00487       // You do *NOT* need modify this code to add your own protocol,
00488       // instead simply add the following to your svc.conf file:
00489       //
00490       // dynamic PP_Factory Service_Object * LIB:_make_PP_Protocol_Factory() ""
00491       // static Resource_Factory "-ORBProtocolFactory PP_Factory"
00492       //
00493       // where "PP_Factory" is the name of your protocol, i.e. the
00494       // second argument passed to the ACE_STATIC_SVC_DEFINE macro:
00495       //
00496       // ACE_STATIC_SVC_DEFINE (PP_Protocol_Factory,
00497       //                        ACE_LIB_TEXT ("PP_Factory"), ...)
00498       //
00499       // "PP_Protocol_Factory" is the name of your protocol factory
00500       // class.  A "_make_" is prepended to your protocol factory
00501       // class name by the ACE_FACTORY_DECLARE macro.  The resulting
00502       // factory function "_make_PP_Protocol_Factory()" is what should
00503       // be used in the "dynamic" line in your svc.conf file.
00504       //
00505       // LIB is the base name of the shared library that implements
00506       // the protocol.  The directory containing your library must be
00507       // in your library search path, typically defined by the
00508       // LD_LIBRARY_PATH environment variable on UNIX systems, and/or
00509       // the `/etc/ld.so.conf' file on some UNIX systems.  Remember to
00510       // run "ldconfig" if you modify `/etc/ld.so.conf'.
00511 
00512       TAO_Protocol_Factory *protocol_factory = 0;
00513       auto_ptr<TAO_Protocol_Factory> safe_protocol_factory;
00514 
00515       TAO_Protocol_Item *item = 0;
00516 
00517       // If a protocol factory is obtained from the Service
00518       // Configurator then do not transfer ownership to the
00519       // TAO_Protocol_Item.
00520       int transfer_ownership = 0;
00521 
00522       protocol_factory =
00523         ACE_Dynamic_Service<TAO_Protocol_Factory>::instance ("IIOP_Factory");
00524 
00525       if (protocol_factory == 0)
00526         {
00527           if (TAO_debug_level > 0)
00528             ACE_ERROR ((LM_WARNING,
00529                         ACE_LIB_TEXT ("TAO (%P|%t) No %s found in ")
00530                         ACE_LIB_TEXT ("Service Repository. ")
00531                         ACE_LIB_TEXT ("Using default instance IIOP ")
00532                         ACE_LIB_TEXT ("Protocol Factory.\n"),
00533                         ACE_LIB_TEXT ("IIOP Protocol Factory")));
00534 
00535           ACE_NEW_RETURN (protocol_factory,
00536                           TAO_IIOP_Protocol_Factory,
00537                           -1);
00538 
00539           ACE_AUTO_PTR_RESET (safe_protocol_factory,
00540                               protocol_factory,
00541                               TAO_Protocol_Factory);
00542 
00543           transfer_ownership = 1;
00544         }
00545       else
00546         {
00547           transfer_ownership = 0;
00548         }
00549 
00550       ACE_NEW_RETURN (item,
00551                       TAO_Protocol_Item ("IIOP_Factory"),
00552                       -1);
00553       // If the TAO_Protocol_Item retains ownership of the
00554       // TAO_Protocol_Factory then we used an auto_ptr<> above, so
00555       // release the TAO_Protocol_Factory from it.  Otherwise, we
00556       // obtained the TAO_Protocol_Factory from the Service
00557       // Configurator so an auto_ptr<> wasn't used since the Service
00558       // Configurator retains ownership, hence there was no need to
00559       // use an auto_ptr<> in this method.
00560       item->factory ((transfer_ownership ?
00561                       safe_protocol_factory.release () :
00562                       protocol_factory),
00563                      transfer_ownership);
00564 
00565       if (this->protocol_factories_.insert (item) == -1)
00566         {
00567           ACE_ERROR ((LM_ERROR,
00568                       ACE_LIB_TEXT ("TAO (%P|%t) Unable to add ")
00569                       ACE_LIB_TEXT ("<%s> to protocol factory set.\n"),
00570                       ACE_TEXT_CHAR_TO_TCHAR (item->protocol_name ().c_str ())));
00571 
00572           delete item;
00573 
00574           if (transfer_ownership == 0)
00575             delete protocol_factory;
00576 
00577           return -1;
00578         }
00579 
00580       if (TAO_debug_level > 0)
00581         {
00582           ACE_DEBUG ((LM_DEBUG,
00583                       ACE_LIB_TEXT ("TAO (%P|%t) Loaded default ")
00584                       ACE_LIB_TEXT ("protocol <IIOP_Factory>\n")));
00585         }
00586 
00587   return 0;
00588 }

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 820 of file default_resource.cpp.

References cached_connection_lock_type_, and TAO_NULL_LOCK.

00821 {
00822   if (this->cached_connection_lock_type_ == TAO_NULL_LOCK)
00823     return 0;
00824 
00825   return 1;
00826 }

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 796 of file default_resource.cpp.

References max_muxed_connections_.

00797 {
00798   return this->max_muxed_connections_;
00799 }

ACE_Allocator * TAO_Default_Resource_Factory::output_cdr_buffer_allocator void    [virtual]
 

Reimplemented from TAO_Resource_Factory.

Definition at line 768 of file default_resource.cpp.

References ACE_NEW_RETURN.

00769 {
00770   ACE_Allocator *allocator = 0;
00771   ACE_NEW_RETURN (allocator, NULL_LOCK_ALLOCATOR, 0);
00772   return allocator;
00773 }

ACE_Allocator * TAO_Default_Resource_Factory::output_cdr_dblock_allocator void    [virtual]
 

Access the output CDR allocators.

Reimplemented from TAO_Resource_Factory.

Definition at line 760 of file default_resource.cpp.

References ACE_NEW_RETURN.

00761 {
00762   ACE_Allocator *allocator = 0;
00763   ACE_NEW_RETURN (allocator, NULL_LOCK_ALLOCATOR, 0);
00764   return allocator;
00765 }

ACE_Allocator * TAO_Default_Resource_Factory::output_cdr_msgblock_allocator void    [virtual]
 

Reimplemented from TAO_Resource_Factory.

Definition at line 776 of file default_resource.cpp.

References ACE_NEW_RETURN.

00777 {
00778   ACE_Allocator *allocator = 0;
00779   ACE_NEW_RETURN (allocator, NULL_LOCK_ALLOCATOR, 0);
00780   return allocator;
00781 }

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 790 of file default_resource.cpp.

References purge_percentage_.

00791 {
00792   return this->purge_percentage_;
00793 }

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 707 of file default_resource.cpp.

References dynamically_allocated_reactor_.

00708 {
00709   if (this->dynamically_allocated_reactor_ == 1)
00710     delete reactor;
00711 }

void TAO_Default_Resource_Factory::report_option_value_error const ACE_TCHAR   option_name,
const ACE_TCHAR   option_value
[protected]
 

Definition at line 884 of file default_resource.cpp.

References ACE_DEBUG, ACE_LIB_TEXT, ACE_TCHAR, and LM_DEBUG.

Referenced by init.

00887 {
00888   ACE_DEBUG((LM_DEBUG,
00889              ACE_LIB_TEXT ("Default_Resource_Factory - unknown argument")
00890              ACE_LIB_TEXT (" <%s> for <%s>\n"),
00891              option_value, option_name));
00892 }

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 637 of file default_resource.cpp.

References use_locked_data_blocks_.

00638 {
00639   return this->use_locked_data_blocks_;
00640 }


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 175 of file default_resource.h.

Referenced by cache_maximum, and init.

Lock_Type TAO_Default_Resource_Factory::cached_connection_lock_type_ [private]
 

Type of lock used by the cached connector.

Definition at line 222 of file default_resource.h.

Referenced by create_cached_connection_lock, init, and locked_transport_cache.

TAO_Codeset_Manager* TAO_Default_Resource_Factory::codeset_manager_ [private]
 

Definition at line 234 of file default_resource.h.

Referenced by get_codeset_manager, and ~TAO_Default_Resource_Factory.

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 171 of file default_resource.h.

Referenced by create_purging_strategy, and init.

int TAO_Default_Resource_Factory::dynamically_allocated_reactor_ [protected]
 

Flag that is set to 1 if the reactor obtained from the get_reactor() method is dynamically allocated. If this flag is set to 1, 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 200 of file default_resource.h.

Referenced by get_reactor, and reclaim_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 212 of file default_resource.h.

Referenced by disable_factory, and init.

int TAO_Default_Resource_Factory::flushing_strategy_type_ [private]
 

Type of flushing strategy configured.

Definition at line 232 of file default_resource.h.

Referenced by create_flushing_strategy, and init.

int TAO_Default_Resource_Factory::index_ [protected]
 

Index of the current element in the parser_names_ array.

Definition at line 164 of file default_resource.h.

Referenced by add_to_ior_parser_names, and init.

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 184 of file default_resource.h.

Referenced by init, and max_muxed_connections.

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 207 of file default_resource.h.

Referenced by disable_factory, and init.

char** TAO_Default_Resource_Factory::parser_names_ [protected]
 

Array consisting of the names of the parsers.

Definition at line 161 of file default_resource.h.

Referenced by add_to_ior_parser_names, get_parser_names, init, and ~TAO_Default_Resource_Factory.

int TAO_Default_Resource_Factory::parser_names_count_ [protected]
 

The number of the different types of Parsers.

Definition at line 158 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 167 of file default_resource.h.

Referenced by get_protocol_factories, init_protocol_factories, load_default_protocols, 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 179 of file default_resource.h.

Referenced by init, and purge_percentage.

int TAO_Default_Resource_Factory::reactor_mask_signals_ [protected]
 

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

Definition at line 187 of file default_resource.h.

Referenced by init.

int TAO_Default_Resource_Factory::use_locked_data_blocks_ [protected]
 

The type of data blocks that the ORB should use.

Definition at line 155 of file default_resource.h.

Referenced by init, and use_locked_data_blocks.


The documentation for this class was generated from the following files:
Generated on Mon Jun 16 15:13:48 2003 for TAO by doxygen1.2.14 written by Dimitri van Heesch, © 1997-2002