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

#include <ORBInitializer_Registry_Impl.h>

Inheritance diagram for TAO::ORBInitializer_Registry:

Collaboration diagram for TAO::ORBInitializer_Registry:

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::ORBInitializer_Registry::ORBInitializer_Registry ( void )

Definition at line 24 of file ORBInitializer_Registry_Impl.cpp.

  : lock_ (),
    initializers_ ()
{
}

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 74 of file ORBInitializer_Registry_Impl.cpp.

{
  ACE_GUARD_RETURN (TAO_SYNCH_RECURSIVE_MUTEX,
                    guard,
                    this->lock_,
                    -1);

  // Release all initializers in the array
  size_t const initializer_count (this->initializers_.size ());
  for (size_t i = initializer_count; i > 0;)
    {
      --i;
      if (TAO_debug_level > 8)
        {
          ACE_DEBUG((LM_DEBUG, ACE_TEXT("TAO (%P|%t) - ORBInitializer_Registry::fini clearing %d @%@\n"),
            i, this->initializers_[i].operator->()
            ));
        }
      this->initializers_[i] = PortableInterceptor::ORBInitializer::_nil();
    }

  return 0;
}

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.

Register the PI ORBInitializer.

Reimplemented from ACE_Shared_Object.

Definition at line 31 of file ORBInitializer_Registry_Impl.cpp.

{
#if !defined (TAO_AS_STATIC_LIBS) && (TAO_HAS_INTERCEPTORS == 1)
  ACE_Service_Config::process_directive
    (ace_svc_desc_TAO_ClientRequestInterceptor_Adapter_Factory_Impl);

  ACE_Service_Config::process_directive
    (ace_svc_desc_TAO_PICurrent_Loader);

  PortableInterceptor::ORBInitializer_ptr temp_orb_initializer =
    PortableInterceptor::ORBInitializer::_nil ();

  PortableInterceptor::ORBInitializer_var orb_initializer;

  try
    {
      /// Register the PI ORBInitializer.

      ACE_NEW_THROW_EX (temp_orb_initializer,
                        TAO_PI_ORBInitializer,
                        CORBA::NO_MEMORY (
                          CORBA::SystemException::_tao_minor_code (
                            TAO::VMCID,
                            ENOMEM),
                          CORBA::COMPLETED_NO));

      orb_initializer = temp_orb_initializer;

      this->register_orb_initializer (orb_initializer.in ());
    }
  catch (const ::CORBA::Exception& ex)
    {
      if (TAO_debug_level > 0)
        {
          ex._tao_print_exception ("(%P|%t) Caught exception:");
        }
      return -1;
    }
#endif /* !TAO_AS_STATIC_LIBS  && TAO_HAS_INTERCEPTORS == 1 */
  return 0;
}

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 181 of file ORBInitializer_Registry_Impl.cpp.

{
  if (pre_init_count > 0)
    {
      ACE_GUARD (TAO_SYNCH_RECURSIVE_MUTEX,
                 guard,
                 this->lock_);

      TAO_ORBInitInfo * orb_init_info_temp = 0;

      ACE_NEW_THROW_EX (orb_init_info_temp,
                        TAO_ORBInitInfo (orb_core,
                                         argc,
                                         argv,
                                         slotid),
                        CORBA::NO_MEMORY (
                          CORBA::SystemException::_tao_minor_code (
                            0,
                            ENOMEM),
                          CORBA::COMPLETED_NO));

      TAO_ORBInitInfo_var orb_init_info_ = orb_init_info_temp;

      for (size_t i = 0; i < pre_init_count; ++i)
        {
          this->initializers_[i]->post_init (orb_init_info_.in ());
        }

#if TAO_HAS_INTERCEPTORS == 1
      CORBA::Object_ptr picurrent_ptr = orb_core->pi_current ();
      PortableInterceptor::SlotId slot_count = orb_init_info_->slot_count ();

      if (CORBA::is_nil (picurrent_ptr) && slot_count != 0)
        {
          // Force instantiation of the PICurrent object. If we do not do it
          // now, the slot count will be lost.
          CORBA::Object_var tmp = orb_core->resolve_picurrent ();
          picurrent_ptr = orb_core->pi_current ();
        }

      if (!CORBA::is_nil (picurrent_ptr))
        {
          TAO::PICurrent *pi = dynamic_cast <TAO::PICurrent*> (picurrent_ptr);

          if (pi)
            {
              pi->initialize (slot_count);
            }
        }
#endif /* TAO_HAS_INTERCEPTORS == 1 */

      // Invalidate the ORBInitInfo instance to prevent future
      // modifications to the ORB.  This behavior complies with the
      // PortableInterceptor specification.
      orb_init_info_temp->invalidate ();
    }
}

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 134 of file ORBInitializer_Registry_Impl.cpp.

{
  ACE_GUARD_RETURN (TAO_SYNCH_RECURSIVE_MUTEX,
                    guard,
                    this->lock_,
                    0);

  size_t const initializer_count (this->initializers_.size ());

  if (initializer_count > 0)
    {
      TAO_ORBInitInfo * orb_init_info_temp = 0;

      ACE_NEW_THROW_EX (orb_init_info_temp,
                        TAO_ORBInitInfo (orb_core,
                                         argc,
                                         argv,
                                         slotid),
                        CORBA::NO_MEMORY (
                          CORBA::SystemException::_tao_minor_code (
                            0,
                            ENOMEM),
                          CORBA::COMPLETED_NO));

      TAO_ORBInitInfo_var orb_init_info_ = orb_init_info_temp;

      for (size_t i = 0; i < initializer_count; ++i)
        {
          this->initializers_[i]->pre_init (orb_init_info_.in ());
        }

      slotid = orb_init_info_temp->slot_count ();

      // Invalidate the ORBInitInfo instance to prevent future
      // modifications to the ORB.  This behavior complies with the
      // PortableInterceptor specification.
      orb_init_info_temp->invalidate ();
    }

  return initializer_count;
}

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 99 of file ORBInitializer_Registry_Impl.cpp.

{
  if (!CORBA::is_nil (init))
    {
      ACE_GUARD (TAO_SYNCH_RECURSIVE_MUTEX,
                 guard,
                 this->lock_);

      // Increase the length of the ORBInitializer array by one.
      size_t const cur_len = this->initializers_.size ();
      size_t const new_len = cur_len + 1;
      if (this->initializers_.size (new_len) != 0)
        throw ::CORBA::INTERNAL ();

      // Add the given ORBInitializer to the sequence.
      if (TAO_debug_level > 8)
        {
          ACE_DEBUG((LM_DEBUG, ACE_TEXT("TAO (%P|%t) - ORBInitializer_Registry::register_orb_initializer %d @%@\n"),
            cur_len, init
            ));
        }

      this->initializers_[cur_len] =
        PortableInterceptor::ORBInitializer::_duplicate (init);
    }
  else
    throw ::CORBA::INV_OBJREF (
                 CORBA::SystemException::_tao_minor_code (
                   0,
                   EINVAL),
                 CORBA::COMPLETED_NO);
}

Member Data Documentation

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

Dynamic array containing registered ORBInitializers.

Definition at line 93 of file ORBInitializer_Registry_Impl.h.

TAO_SYNCH_RECURSIVE_MUTEX TAO::ORBInitializer_Registry::lock_ [private]

Definition at line 90 of file ORBInitializer_Registry_Impl.h.

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

TAO::ORBInitializer_Registry Class Reference

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation