TAO_Singleton_Manager Class Reference

Manager for TAO library services and singleton cleanup. More...

#include <TAO_Singleton_Manager.h>

Inheritance diagram for TAO_Singleton_Manager:

[legend]Collaboration diagram for TAO_Singleton_Manager:

[legend]List of all members.

Public Member Functions
virtual int	init (void)
	Explicitly initialize.
int	init (int register_with_object_manager)
virtual int	fini (void)
	Explicitly destroy.
void	_set_unexpected (TAO_unexpected_handler u)
	Set a new unexpected exception handler.
Static Public Member Functions
int	starting_up (void)
int	shutting_down (void)
sigset_t *	default_mask (void)
ACE_Thread_Hook *	thread_hook (void)
	Returns the current thread hook for the process.
ACE_Thread_Hook *	thread_hook (ACE_Thread_Hook *new_thread_hook)
	Returns the existing thread hook and assign a new_thread_hook.
TAO_Singleton_Manager *	instance (void)
	Accessor to singleton instance.
int	at_exit (ACE_Cleanup *object, void *param=0)
int	at_exit (void *object, ACE_CLEANUP_FUNC cleanup_hook, void *param)
Protected Member Functions
	TAO_Singleton_Manager (void)
	~TAO_Singleton_Manager (void)
Private Member Functions
int	at_exit_i (void *object, ACE_CLEANUP_FUNC cleanup_hook, void *param)
	TAO_Singleton_Manager (const TAO_Singleton_Manager &)
TAO_Singleton_Manager &	operator= (const TAO_Singleton_Manager &)
Private Attributes
sigset_t *	default_mask_
	Default signal set used, for example, in ACE_Sig_Guard.
ACE_Thread_Hook *	thread_hook_
	Thread hook that's used by this process.
ACE_OS_Exit_Info	exit_info_
	For at_exit support.
int	registered_with_object_manager_
TAO_unexpected_handler	old_unexpected_
	The old unexpected exception handler.

---

Detailed Description

Manager for TAO library services and singleton cleanup.

The TAO_Singleton_Manager is basically simplified version of the ACE_Object_Manager. It is designed specifically to manage singletons created by TAO. For example, singleton instances created by TAO will be automatically registered with the singleton instance of this Singleton Manager.

This class is necessary to ensure that TAO-specific singletons are isolated to TAO itself, not ACE, for example. The idea is that destruction of the instance of the TAO_Singleton_Manager triggers destruction of all objects/services registered with it.

Definition at line 54 of file TAO_Singleton_Manager.h.

---

Constructor & Destructor Documentation

TAO_Singleton_Manager::TAO_Singleton_Manager (  void   )  [protected]

TAO_Singleton_Manager::~TAO_Singleton_Manager (  void   )  [protected]

Definition at line 86 of file TAO_Singleton_Manager.cpp. References fini(). { this->dynamically_allocated_ = 0; // Don't delete this again in fini() (void) this->fini (); }

TAO_Singleton_Manager::TAO_Singleton_Manager (  const TAO_Singleton_Manager &   )  [private]

---

Member Function Documentation

void TAO_Singleton_Manager::_set_unexpected (  TAO_unexpected_handler  u  )

Set a new unexpected exception handler. The old one will be stored for restoration later on. Note: Calling this method multiple times will cause the stored old unexpected exception handler pointer to be lost. Definition at line 315 of file TAO_Singleton_Manager.cpp. References old_unexpected_. Referenced by TAO::ORB::init_orb_globals(). { // This must be done after the system TypeCodes and Exceptions have // been initialized. An unexpected exception will cause TAO's // unexpected exception handler to be called. That handler // transforms all unexpected exceptions to CORBA::UNKNOWN, which of // course requires the TypeCode constants and system exceptions to // have been initialized. # if (!defined (_MSC_VER) \ && defined (ACE_USES_STD_NAMESPACE_FOR_STDCPP_LIB) \ && (ACE_USES_STD_NAMESPACE_FOR_STDCPP_LIB != 0)) || defined (ghs) this->old_unexpected_ = std::set_unexpected (u); # else this->old_unexpected_ = set_unexpected (u); # endif /* ACE_USES_STD_NAMESPACE_FOR_STDCPP_LIB */ }

ACE_INLINE int TAO_Singleton_Manager::at_exit (  void *  object, ACE_CLEANUP_FUNC  cleanup_hook, void *  param )  [static]

cleanup_hook points to a (global, or static member) function that is called for the object or array when it to be destroyed. It may perform any necessary cleanup specific for that object or its class. param is passed as the second parameter to the cleanup_hook function; the first parameter is the object (or array) to be destroyed. cleanup_hook, for example, may delete the object (or array). For OS's that do not have processes, this function is the same as . Returns 0 on success. On failure, returns -1 and sets errno to: EAGAIN if shutting down, ENOMEM if insufficient virtual memory, or EEXIST if the object (or array) had already been registered. Definition at line 20 of file TAO_Singleton_Manager.inl. References at_exit_i(), and instance(). { return TAO_Singleton_Manager::instance ()->at_exit_i ( object, cleanup_hook, param); }

TAO_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE int TAO_Singleton_Manager::at_exit (  ACE_Cleanup *  object, void *  param = 0 )  [static]

The object is deleted via the ace_cleanup_destroyer. If you need more flexiblity, see the other at_exit method below. For OS's that do not have processes, cleanup takes place at the end of main. Returns 0 on success. On failure, returns -1 and sets errno to: EAGAIN if shutting down, ENOMEM if insufficient virtual memory, or EEXIST if the object (or array) had already been registered. Definition at line 9 of file TAO_Singleton_Manager.inl. References ACE_CLEANUP_DESTROYER_NAME(), ACE_CLEANUP_FUNC, at_exit_i(), and instance(). Referenced by TAO_TSS_Singleton< TYPE, ACE_LOCK >::instance(), and TAO_Singleton< TYPE, ACE_LOCK >::instance(). { return TAO_Singleton_Manager::instance ()->at_exit_i ( object, (ACE_CLEANUP_FUNC) ACE_CLEANUP_DESTROYER_NAME, param); }

int TAO_Singleton_Manager::at_exit_i (  void *  object, ACE_CLEANUP_FUNC  cleanup_hook, void *  param )  [private]

Register an object or array for deletion at program termination. See description of static version above for return values. Definition at line 334 of file TAO_Singleton_Manager.cpp. References ACE_GUARD_RETURN, ACE_OS_Exit_Info::at_exit_i(), ACE_OS_Exit_Info::find(), ACE_Object_Manager_Base::shutting_down_i(), TAO_SYNCH_RECURSIVE_MUTEX, and the_instance. Referenced by at_exit(). { ACE_MT (ACE_GUARD_RETURN (TAO_SYNCH_RECURSIVE_MUTEX, ace_mon, *the_instance->internal_lock_, -1)); if (this->shutting_down_i ()) { errno = EAGAIN; return -1; } if (this->exit_info_.find (object)) { // The object has already been registered. errno = EEXIST; return -1; } return this->exit_info_.at_exit_i (object, cleanup_hook, param); }

sigset_t * TAO_Singleton_Manager::default_mask (  void   )  [static]

Accesses a default signal set used, for example, in ACE_Sig_Guard methods. Definition at line 93 of file TAO_Singleton_Manager.cpp. References default_mask_, and instance(). { return TAO_Singleton_Manager::instance ()->default_mask_; }

int TAO_Singleton_Manager::fini (  void   )  [virtual]

Explicitly destroy. Implements ACE_Object_Manager_Base. Definition at line 221 of file TAO_Singleton_Manager.cpp. References ACE_OS_Exit_Info::call_hooks(), ACE_Object_Manager_Base::fini(), ACE_Object_Manager_Base::shutting_down_i(), and the_instance. Referenced by ~TAO_Singleton_Manager(). { if (the_instance == 0 || this->shutting_down_i ()) // Too late. Or, maybe too early. Either fini () has already // been called, or init () was never called. return this->object_manager_state_ == OBJ_MAN_SHUT_DOWN ? 1 : -1; // No mutex here. Only the main thread should destroy the singleton // TAO_Singleton_Manager instance. // Indicate that the TAO_Singleton_Manager instance is being shut // down. This object manager should be the last one to be shut // down. this->object_manager_state_ = OBJ_MAN_SHUTTING_DOWN; // If another Object_Manager has registered for termination, do it. if (this->next_) { this->next_->fini (); this->next_ = 0; // Protect against recursive calls. } // Call all registered cleanup hooks, in reverse order of // registration. this->exit_info_.call_hooks (); // // Only clean up preallocated objects when the singleton Instance is being // // destroyed. // if (this == the_instance) // { // #if ! defined (ACE_HAS_STATIC_PREALLOCATION) // // Cleanup the dynamically preallocated objects. // # if defined (ACE_MT_SAFE) && (ACE_MT_SAFE != 0) // // @@ No MT-specific preallocated objects yet. // # endif /* ACE_MT_SAFE */ // // @@ No preallocated objects yet. // #endif /* ! ACE_HAS_STATIC_PREALLOCATION */ // } delete this-> default_mask_; this->default_mask_ = 0; #if defined (ACE_MT_SAFE) && (ACE_MT_SAFE != 0) delete this->internal_lock_; this->internal_lock_ = 0; #endif /* ACE_MT_SAFE */ #if defined (ACE_HAS_EXCEPTIONS) // Restore the old unexpected exception handler since TAO will no // longer be handling exceptions. Allow the application to once // again handle unexpected exceptions. # if (!defined (_MSC_VER) \ && defined (ACE_USES_STD_NAMESPACE_FOR_STDCPP_LIB) \ && (ACE_USES_STD_NAMESPACE_FOR_STDCPP_LIB != 0)) || defined (ghs) (void) std::set_unexpected (this->old_unexpected_); # else (void) set_unexpected (this->old_unexpected_); # endif /* ACE_USES_STD_NAMESPACE_FOR_STDCPP_LIB */ #endif /* ACE_HAS_EXCEPTIONS */ // Indicate that this TAO_Singleton_Manager instance has been shut down. this->object_manager_state_ = OBJ_MAN_SHUT_DOWN; if (this == the_instance) the_instance = 0; if (this->dynamically_allocated_) { delete this; } return 0; }

int TAO_Singleton_Manager::init (  int  register_with_object_manager  )

Explicitly initialize the TAO_Singleton_Manager, in addition to explicitly registering (or not registering) with the ACE_Object_Manager. Definition at line 155 of file TAO_Singleton_Manager.cpp. References ACE_CLEANUP_FUNC, ACE_NEW_RETURN, ACE_Object_Manager::at_exit(), registered_with_object_manager_, ACE_OS::sigfillset(), ACE_Object_Manager_Base::starting_up_i(), and the_instance. { if (this->starting_up_i ()) { // First, indicate that this TAO_Singleton_Manager instance is being // initialized. this->object_manager_state_ = OBJ_MAN_INITIALIZING; if (this == the_instance) { # if defined (ACE_MT_SAFE) && (ACE_MT_SAFE != 0) // @@ No MT-specific pre-allocated objects. # endif /* ACE_MT_SAFE */ } ACE_NEW_RETURN (this->default_mask_, sigset_t, -1); ACE_OS::sigfillset (this->default_mask_); // Finally, indicate that the TAO_Singleton_Manager instance has // been initialized. this->object_manager_state_ = OBJ_MAN_INITIALIZED; return 0; } // @@ This strange looking code is what provides the "register on // explicit call to init()" semantics. This was needed since the // TAO_Singleton_Manager constructor invokes init(). // Unfortunately, I couldn't get rid of that init() call without // breaking things. The fact things broke needs to be // investigated further. if (this->registered_with_object_manager_ != -1 && register_with_object_manager != this->registered_with_object_manager_) { // An attempt was made to register the TAO_Singleton_Manager // with a manager of a different type from the one it is // currently registered with. This indicates a problem with the // caller's logic. errno = EINVAL; return -1; } if (this->registered_with_object_manager_ == -1) { if (register_with_object_manager == 1 && ACE_Object_Manager::at_exit ( this, (ACE_CLEANUP_FUNC) TAO_SINGLETON_MANAGER_CLEANUP_DESTROYER_NAME, 0) != 0) return -1; this->registered_with_object_manager_ = register_with_object_manager; } // Had already initialized. return 1; }

int TAO_Singleton_Manager::init (  void   )  [virtual]

Explicitly initialize. Implements ACE_Object_Manager_Base. Definition at line 140 of file TAO_Singleton_Manager.cpp. References registered_with_object_manager_. Referenced by CORBA::ORB_init(), and PortableInterceptor::register_orb_initializer(). { if (this->registered_with_object_manager_ == -1) { // Register the TAO_Singleton_Manager with the // ACE_Object_Manager. int register_with_object_manager = 1; return this->init (register_with_object_manager); } return 1; // Already initialized. }

TAO_Singleton_Manager * TAO_Singleton_Manager::instance (  void   )  [static]

Accessor to singleton instance. Definition at line 114 of file TAO_Singleton_Manager.cpp. References ACE_ASSERT, ACE_NEW_RETURN, ACE_Object_Manager_Base::dynamically_allocated_, and the_instance. Referenced by at_exit(), default_mask(), TAO::ORB::init_orb_globals(), CORBA::ORB_init(), PortableInterceptor::register_orb_initializer(), and thread_hook(). { // This function should be called during construction of static // instances, or before any other threads have been created in the // process. So, it's not thread safe. if (the_instance == 0) { TAO_Singleton_Manager *instance_pointer; ACE_NEW_RETURN (instance_pointer, TAO_Singleton_Manager, 0); ACE_ASSERT (instance_pointer == the_instance); instance_pointer->dynamically_allocated_ = 1; return instance_pointer; } else { return the_instance; } }

TAO_Singleton_Manager& TAO_Singleton_Manager::operator= (  const TAO_Singleton_Manager &   )  [private]

int TAO_Singleton_Manager::shutting_down (  void   )  [static]

Returns 1 after the TAO_Singleton_Manager has been destroyed. See ACE_Object_Manager::shutting_down for more information. Definition at line 305 of file TAO_Singleton_Manager.cpp. References ACE_Object_Manager_Base::shutting_down_i(), and the_instance. Referenced by TAO_TSS_Singleton< TYPE, ACE_LOCK >::instance(), and TAO_Singleton< TYPE, ACE_LOCK >::instance(). { return the_instance ? the_instance->shutting_down_i () : 1; }

int TAO_Singleton_Manager::starting_up (  void   )  [static]

Returns 1 before the TAO_Singleton_Manager has been constructed. See ACE_Object_Manager::starting_up for more information. Definition at line 296 of file TAO_Singleton_Manager.cpp. References ACE_Object_Manager_Base::starting_up_i(), and the_instance. Referenced by TAO_TSS_Singleton< TYPE, ACE_LOCK >::instance(), and TAO_Singleton< TYPE, ACE_LOCK >::instance(). { return the_instance ? the_instance->starting_up_i () : 1; }

ACE_Thread_Hook * TAO_Singleton_Manager::thread_hook (  ACE_Thread_Hook *  new_thread_hook  )  [static]

Returns the existing thread hook and assign a new_thread_hook. Definition at line 105 of file TAO_Singleton_Manager.cpp. References instance(), and thread_hook_. { TAO_Singleton_Manager *tao_om = TAO_Singleton_Manager::instance (); ACE_Thread_Hook *old_hook = tao_om->thread_hook_; tao_om->thread_hook_ = new_thread_hook; return old_hook; }

ACE_Thread_Hook * TAO_Singleton_Manager::thread_hook (  void   )  [static]

Returns the current thread hook for the process. Definition at line 99 of file TAO_Singleton_Manager.cpp. References instance(), and thread_hook_. { return TAO_Singleton_Manager::instance ()->thread_hook_; }

---

Member Data Documentation

sigset_t* TAO_Singleton_Manager::default_mask_ [private]

Default signal set used, for example, in ACE_Sig_Guard. Definition at line 159 of file TAO_Singleton_Manager.h. Referenced by default_mask().

ACE_OS_Exit_Info TAO_Singleton_Manager::exit_info_ [private]

For at_exit support. Definition at line 165 of file TAO_Singleton_Manager.h.

TAO_unexpected_handler TAO_Singleton_Manager::old_unexpected_ [private]

The old unexpected exception handler. A pointer to the old unexpected exception handler is stored so that it can be restored when TAO is unloaded, for example. Otherwise, any unexpected exceptions will result in a call to TAO's unexpected exception handler which may no longer exist if TAO was unloaded. Definition at line 185 of file TAO_Singleton_Manager.h. Referenced by _set_unexpected().

int TAO_Singleton_Manager::registered_with_object_manager_ [private]

Indicates if TAO_Singleton_Manager is registered with the ACE_Object_Manager. Definition at line 169 of file TAO_Singleton_Manager.h. Referenced by init().

ACE_Thread_Hook* TAO_Singleton_Manager::thread_hook_ [private]

Thread hook that's used by this process. Definition at line 162 of file TAO_Singleton_Manager.h. Referenced by thread_hook().

---

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

• TAO_Singleton_Manager.h
• TAO_Singleton_Manager.cpp
• TAO_Singleton_Manager.inl

---