Main Page | Class Hierarchy | Alphabetical List | Class List | File List | Class Members | File Members | Search for 

TAO::ORBInitializer_Registry Class Reference

Global list that contains all portable interceptor ORB initializers. More...

#include <ORBInitializer_Registry_Impl.h>

Inheritance diagram for TAO::ORBInitializer_Registry:

Inheritance graph
[legend]
Collaboration diagram for TAO::ORBInitializer_Registry:

Collaboration graph
[legend]
List of all members.

Public Member Functions

 ORBInitializer_Registry (void)
virtual int init (int, ACE_TCHAR *[])
virtual int fini (void)
virtual void register_orb_initializer (PortableInterceptor::ORBInitializer_ptr init)
virtual size_t pre_init (TAO_ORB_Core *orb_core, int argc, char *argv[], PortableInterceptor::SlotId &slotid)
virtual void post_init (size_t pre_init_count, TAO_ORB_Core *orb_core, int argc, char *argv[], PortableInterceptor::SlotId slotid)

Private Member Functions

 ORBInitializer_Registry (const ORBInitializer_Registry &)
void operator= (const ORBInitializer_Registry &)

Private Attributes

TAO_SYNCH_RECURSIVE_MUTEX lock_
ACE_Array_Base< PortableInterceptor::ORBInitializer_var > initializers_
 Dynamic array containing registered ORBInitializers.

Detailed Description

Global list that contains all portable interceptor ORB initializers.

Definition at line 44 of file ORBInitializer_Registry_Impl.h.

Constructor & Destructor Documentation

TAO_BEGIN_VERSIONED_NAMESPACE_DECL TAO::ORBInitializer_Registry::ORBInitializer_Registry (  void   ) 
 

Definition at line 24 of file ORBInitializer_Registry_Impl.cpp. 

00025   : lock_ (),
00026     initializers_ ()
00027 {
00028 }

TAO::ORBInitializer_Registry::ORBInitializer_Registry (  const ORBInitializer_Registry &   )  [private]
 

Member Function Documentation

int TAO::ORBInitializer_Registry::fini (  void   )  [virtual]
 

Service config fini method, release all ORBInitializers at this moment

Reimplemented from ACE_Shared_Object.

Definition at line 80 of file ORBInitializer_Registry_Impl.cpp.

References ACE_GUARD_RETURN, initializers_, and TAO_SYNCH_RECURSIVE_MUTEX. 

00081 {
00082   ACE_GUARD_RETURN (TAO_SYNCH_RECURSIVE_MUTEX,
00083                     guard,
00084                     this->lock_,
00085                     -1);
00086 
00087   // Release all initializers in the array
00088   size_t const initializer_count (this->initializers_.size ());
00089   for (size_t i = 0; i < initializer_count; ++i)
00090     {
00091       this->initializers_[i] = PortableInterceptor::ORBInitializer::_nil();
00092     }
00093 
00094   return 0;
00095 }

int TAO::ORBInitializer_Registry::init (  int  ,
ACE_TCHAR *  []
)  [virtual]
 

Added to provide registration for the several static service objects, brought in with this ORBInitializer_Registry implementation. Note that this is more reliable than using static initializers, since multiple copies of the dynamic service object will require their own (multiple) copies of the dependent static service objects. That is just impossible without registering those static services in the same repo, the dynamic SO is registered with.

Reimplemented from ACE_Shared_Object.

Definition at line 31 of file ORBInitializer_Registry_Impl.cpp.

References ACE_ANY_EXCEPTION, ACE_CATCHANY, ACE_DECLARE_NEW_CORBA_ENV, ACE_ENDTRY, ACE_ENV_ARG_PARAMETER, ACE_NEW_THROW_EX, ACE_PRINT_EXCEPTION, ACE_TRY, ACE_TRY_CHECK, register_orb_initializer(), and TAO_debug_level. 

00032 {
00033 #if !defined (TAO_AS_STATIC_LIBS) && (TAO_HAS_INTERCEPTORS == 1)
00034   ACE_Service_Config::process_directive
00035     (ace_svc_desc_TAO_ClientRequestInterceptor_Adapter_Factory_Impl);
00036 
00037   ACE_Service_Config::process_directive
00038     (ace_svc_desc_TAO_PICurrent_Loader);
00039 
00040   PortableInterceptor::ORBInitializer_ptr temp_orb_initializer =
00041     PortableInterceptor::ORBInitializer::_nil ();
00042 
00043   PortableInterceptor::ORBInitializer_var orb_initializer;
00044 
00045   ACE_DECLARE_NEW_CORBA_ENV;
00046   ACE_TRY
00047     {
00048       /// Register the PI ORBInitializer.
00049 
00050       ACE_NEW_THROW_EX (temp_orb_initializer,
00051                         TAO_PI_ORBInitializer,
00052                         CORBA::NO_MEMORY (
00053                           CORBA::SystemException::_tao_minor_code (
00054                             TAO::VMCID,
00055                             ENOMEM),
00056                           CORBA::COMPLETED_NO));
00057       ACE_TRY_CHECK;
00058 
00059       orb_initializer = temp_orb_initializer;
00060 
00061       this->register_orb_initializer (orb_initializer.in ()
00062                                                      ACE_ENV_ARG_PARAMETER);
00063       ACE_TRY_CHECK;
00064     }
00065   ACE_CATCHANY
00066     {
00067       if (TAO_debug_level > 0)
00068         {
00069           ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION,
00070                                "(%P|%t) Caught exception:");
00071         }
00072       return -1;
00073     }
00074   ACE_ENDTRY;
00075 #endif /* !TAO_AS_STATIC_LIBS  && TAO_HAS_INTERCEPTORS == 1 */
00076   return 0;
00077 }

void TAO::ORBInitializer_Registry::operator= (  const ORBInitializer_Registry &   )  [private]
 

void TAO::ORBInitializer_Registry::post_init (  size_t  pre_init_count,
TAO_ORB_Core *  orb_core,
int  argc,
char *  argv[],
PortableInterceptor::SlotId  slotid
)  [virtual]
 

Complete initialization of all registered ORBInitializers after the ORB has been initialized.

Implements TAO::ORBInitializer_Registry_Adapter.

Definition at line 178 of file ORBInitializer_Registry_Impl.cpp.

References ACE_CHECK, ACE_ENV_ARG_PARAMETER, ACE_GUARD, ACE_NEW_THROW_EX, TAO_Objref_Var_T< T >::in(), TAO::PICurrent::initialize(), initializers_, CORBA::is_nil(), TAO_ORBInitInfo_var, and TAO_SYNCH_RECURSIVE_MUTEX. 

00185 {
00186   if (pre_init_count > 0)
00187     {
00188       ACE_GUARD (TAO_SYNCH_RECURSIVE_MUTEX,
00189                  guard,
00190                  this->lock_);
00191 
00192       TAO_ORBInitInfo * orb_init_info_temp = 0;
00193 
00194       ACE_NEW_THROW_EX (orb_init_info_temp,
00195                         TAO_ORBInitInfo (orb_core,
00196                                          argc,
00197                                          argv,
00198                                          slotid),
00199                         CORBA::NO_MEMORY (
00200                           CORBA::SystemException::_tao_minor_code (
00201                             0,
00202                             ENOMEM),
00203                           CORBA::COMPLETED_NO));
00204       ACE_CHECK;
00205 
00206       TAO_ORBInitInfo_var orb_init_info_ = orb_init_info_temp;
00207 
00208       for (size_t i = 0; i < pre_init_count; ++i)
00209         {
00210           this->initializers_[i]->post_init (orb_init_info_.in ()
00211                                              ACE_ENV_ARG_PARAMETER);
00212           ACE_CHECK;
00213         }
00214 
00215 #if TAO_HAS_INTERCEPTORS == 1
00216       CORBA::Object_ptr picurrent_ptr = orb_core->pi_current ();
00217       PortableInterceptor::SlotId slot_count = orb_init_info_->slot_count ();
00218 
00219       if (CORBA::is_nil (picurrent_ptr) && slot_count != 0)
00220         {
00221           // Force instantiation of the PICurrent object. If we do not do it
00222           // now, the slot count will be lost.
00223           CORBA::Object_var tmp = orb_core->resolve_picurrent ();
00224           picurrent_ptr = orb_core->pi_current ();
00225         }
00226 
00227       if (!CORBA::is_nil (picurrent_ptr))
00228         {
00229           TAO::PICurrent *pi = dynamic_cast <TAO::PICurrent*> (picurrent_ptr);
00230 
00231           if (pi)
00232             {
00233               pi->initialize (slot_count ACE_ENV_ARG_PARAMETER);
00234               ACE_CHECK;
00235             }
00236         }
00237 #endif /* TAO_HAS_INTERCEPTORS == 1 */
00238 
00239       // Invalidate the ORBInitInfo instance to prevent future
00240       // modifications to the ORB.  This behavior complies with the
00241       // PortableInterceptor specification.
00242       orb_init_info_temp->invalidate ();
00243     }
00244 }

size_t TAO::ORBInitializer_Registry::pre_init (  TAO_ORB_Core *  orb_core,
int  argc,
char *  argv[],
PortableInterceptor::SlotId &  slotid
)  [virtual]
 

Begin initialization of all registered ORBInitializers before the ORB itself is initialized.

Implements TAO::ORBInitializer_Registry_Adapter.

Definition at line 127 of file ORBInitializer_Registry_Impl.cpp.

References ACE_CHECK_RETURN, ACE_ENV_ARG_PARAMETER, ACE_GUARD_RETURN, ACE_NEW_THROW_EX, TAO_Objref_Var_T< T >::in(), initializers_, TAO_ORBInitInfo_var, and TAO_SYNCH_RECURSIVE_MUTEX. 

00133 {
00134   ACE_GUARD_RETURN (TAO_SYNCH_RECURSIVE_MUTEX,
00135                     guard,
00136                     this->lock_,
00137                     0);
00138 
00139   size_t const initializer_count (this->initializers_.size ());
00140 
00141   if (initializer_count > 0)
00142     {
00143       TAO_ORBInitInfo * orb_init_info_temp = 0;
00144 
00145       ACE_NEW_THROW_EX (orb_init_info_temp,
00146                         TAO_ORBInitInfo (orb_core,
00147                                          argc,
00148                                          argv,
00149                                          slotid),
00150                         CORBA::NO_MEMORY (
00151                           CORBA::SystemException::_tao_minor_code (
00152                             0,
00153                             ENOMEM),
00154                           CORBA::COMPLETED_NO));
00155       ACE_CHECK_RETURN (0);
00156 
00157       TAO_ORBInitInfo_var orb_init_info_ = orb_init_info_temp;
00158 
00159       for (size_t i = 0; i < initializer_count; ++i)
00160         {
00161           this->initializers_[i]->pre_init (orb_init_info_.in ()
00162                                             ACE_ENV_ARG_PARAMETER);
00163           ACE_CHECK_RETURN (0);
00164         }
00165 
00166       slotid = orb_init_info_temp->slot_count ();
00167 
00168       // Invalidate the ORBInitInfo instance to prevent future
00169       // modifications to the ORB.  This behavior complies with the
00170       // PortableInterceptor specification.
00171       orb_init_info_temp->invalidate ();
00172     }
00173 
00174   return initializer_count;
00175 }

void TAO::ORBInitializer_Registry::register_orb_initializer (  PortableInterceptor::ORBInitializer_ptr  init  )  [virtual]
 

Register an ORBInitializer with the underlying ORBInitializer array.

Implements TAO::ORBInitializer_Registry_Adapter.

Definition at line 98 of file ORBInitializer_Registry_Impl.cpp.

References ACE_GUARD, ACE_THROW, initializers_, CORBA::is_nil(), and TAO_SYNCH_RECURSIVE_MUTEX.

Referenced by init(). 

00101 {
00102   if (!CORBA::is_nil (init))
00103     {
00104       ACE_GUARD (TAO_SYNCH_RECURSIVE_MUTEX,
00105                  guard,
00106                  this->lock_);
00107 
00108       // Increase the length of the ORBInitializer array by one.
00109       size_t const cur_len = this->initializers_.size ();
00110       size_t const new_len = cur_len + 1;
00111       if (this->initializers_.size (new_len) != 0)
00112         ACE_THROW (CORBA::INTERNAL ());
00113 
00114       // Add the given ORBInitializer to the sequence.
00115       this->initializers_[cur_len] =
00116         PortableInterceptor::ORBInitializer::_duplicate (init);
00117     }
00118   else
00119     ACE_THROW (CORBA::INV_OBJREF (
00120                  CORBA::SystemException::_tao_minor_code (
00121                    0,
00122                    EINVAL),
00123                  CORBA::COMPLETED_NO));
00124 }

Member Data Documentation

ACE_Array_Base<PortableInterceptor::ORBInitializer_var> TAO::ORBInitializer_Registry::initializers_ [private]
 

Dynamic array containing registered ORBInitializers.

Definition at line 98 of file ORBInitializer_Registry_Impl.h.

Referenced by fini(), post_init(), pre_init(), and register_orb_initializer().

TAO_SYNCH_RECURSIVE_MUTEX TAO::ORBInitializer_Registry::lock_ [private]
 

Definition at line 95 of file ORBInitializer_Registry_Impl.h.

The documentation for this class was generated from the following files:
Generated on Thu Nov 9 12:52:51 2006 for TAO_PI by doxygen 1.3.6