Same as ACE_TSS_Singleton, except does _not_ register with ACE_Object_Manager for destruction. More...
#include <Singleton.h>
Static Public Member Functions | |
static TYPE * | instance (void) |
Global access point to the singleton. | |
static void | close (void) |
Explicitly delete the singleton instance. | |
static void | dump (void) |
Dump the state of the object. | |
Protected Member Functions | |
ACE_Unmanaged_TSS_Singleton (void) | |
Default constructor. | |
Static Protected Member Functions | |
static ACE_Unmanaged_TSS_Singleton < TYPE, ACE_LOCK > *& | instance_i (void) |
Get pointer to the Singleton instance. | |
Static Protected Attributes | |
static ACE_Unmanaged_TSS_Singleton < TYPE, ACE_LOCK > * | singleton_ = 0 |
Pointer to the Singleton (ACE_Cleanup) instance. |
Same as ACE_TSS_Singleton, except does _not_ register with ACE_Object_Manager for destruction.
This version of ACE_TSS_Singleton can be used if, for example, its DLL will be unloaded before the ACE_Object_Manager destroys the instance. Unlike with ACE_Singleton, the application is responsible for explicitly destroying the instance after it is no longer needed (if it wants to avoid memory leaks, at least). The close() static member function must be used to explicitly destroy the Singleton.
Definition at line 219 of file Singleton.h.
ACE_Unmanaged_TSS_Singleton< TYPE, ACE_LOCK >::ACE_Unmanaged_TSS_Singleton | ( | void | ) | [protected] |
void ACE_Unmanaged_TSS_Singleton< TYPE, ACE_LOCK >::close | ( | void | ) | [static] |
Explicitly delete the singleton instance.
Definition at line 395 of file Singleton.cpp.
{ ACE_Unmanaged_TSS_Singleton<TYPE, ACE_LOCK> *&singleton = ACE_Unmanaged_TSS_Singleton<TYPE, ACE_LOCK>::instance_i (); if (singleton) singleton->cleanup (); }
void ACE_Unmanaged_TSS_Singleton< TYPE, ACE_LOCK >::dump | ( | void | ) | [static] |
Dump the state of the object.
Reimplemented from ACE_TSS_Singleton< TYPE, ACE_LOCK >.
Definition at line 317 of file Singleton.cpp.
{ #if defined (ACE_HAS_DUMP) ACE_TRACE ("ACE_Unmanaged_TSS_Singleton<TYPE, ACE_LOCK>::dump"); #if !defined (ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES) ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("instance_ = %x"), ACE_Unmanaged_TSS_Singleton<TYPE, ACE_LOCK>::instance_i ())); ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP)); #endif /* ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES */ #endif /* ACE_HAS_DUMP */ }
TYPE * ACE_Unmanaged_TSS_Singleton< TYPE, ACE_LOCK >::instance | ( | void | ) | [static] |
Global access point to the singleton.
Reimplemented from ACE_TSS_Singleton< TYPE, ACE_LOCK >.
Definition at line 346 of file Singleton.cpp.
{ ACE_TRACE ("ACE_Unmanaged_TSS_Singleton<TYPE, ACE_LOCK>::instance"); ACE_Unmanaged_TSS_Singleton<TYPE, ACE_LOCK> *&singleton = ACE_Unmanaged_TSS_Singleton<TYPE, ACE_LOCK>::instance_i (); // Perform the Double-Check pattern... if (singleton == 0) { if (ACE_Object_Manager::starting_up () || ACE_Object_Manager::shutting_down ()) { // The program is still starting up, and therefore assumed // to be single threaded. There's no need to double-check. // Or, the ACE_Object_Manager instance has been destroyed, // so the preallocated lock is not available. Either way, // don't register for destruction with the // ACE_Object_Manager: we'll have to leak this instance. ACE_NEW_RETURN (singleton, (ACE_Unmanaged_TSS_Singleton<TYPE, ACE_LOCK>), 0); } else { #if defined (ACE_MT_SAFE) && (ACE_MT_SAFE != 0) // Obtain a lock from the ACE_Object_Manager. The pointer // is static, so we only obtain one per // ACE_Unmanaged_Singleton instantiation. static ACE_LOCK *lock = 0; if (ACE_Object_Manager::get_singleton_lock (lock) != 0) // Failed to acquire the lock! return 0; ACE_GUARD_RETURN (ACE_LOCK, ace_mon, *lock, 0); #endif /* ACE_MT_SAFE */ if (singleton == 0) ACE_NEW_RETURN (singleton, (ACE_Unmanaged_TSS_Singleton<TYPE, ACE_LOCK>), 0); } } return ACE_TSS_GET (&singleton->instance_, TYPE); }
ACE_Unmanaged_TSS_Singleton< TYPE, ACE_LOCK > *& ACE_Unmanaged_TSS_Singleton< TYPE, ACE_LOCK >::instance_i | ( | void | ) | [static, protected] |
Get pointer to the Singleton instance.
Reimplemented from ACE_TSS_Singleton< TYPE, ACE_LOCK >.
Definition at line 332 of file Singleton.cpp.
{ #if defined (ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES) // Pointer to the Singleton instance. This works around a bug with // G++ and it's (mis-)handling of templates and statics... static ACE_Unmanaged_TSS_Singleton<TYPE, ACE_LOCK> *singleton_ = 0; return singleton_; #else return ACE_Unmanaged_TSS_Singleton<TYPE, ACE_LOCK>::singleton_; #endif /* ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES */ }
ACE_Unmanaged_TSS_Singleton< TYPE, ACE_LOCK > * ACE_Unmanaged_TSS_Singleton< TYPE, ACE_LOCK >::singleton_ = 0 [static, protected] |
Pointer to the Singleton (ACE_Cleanup) instance.
Reimplemented from ACE_TSS_Singleton< TYPE, ACE_LOCK >.
Definition at line 237 of file Singleton.h.