A Singleton Adapter uses the Adapter pattern to turn ordinary classes into Singletons optimized with the Double-Checked Locking optimization pattern. More...
#include <Singleton.h>
Public Member Functions | |
virtual void | cleanup (void *param=0) |
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_Singleton (void) | |
Default constructor. | |
Static Protected Member Functions | |
static ACE_Singleton< TYPE, ACE_LOCK > *& | instance_i (void) |
Get pointer to the Singleton instance. | |
Protected Attributes | |
TYPE | instance_ |
Contained instance. | |
Static Protected Attributes | |
static ACE_Singleton< TYPE, ACE_LOCK > * | singleton_ = 0 |
Pointer to the Singleton (ACE_Cleanup) instance. |
A Singleton Adapter uses the Adapter pattern to turn ordinary classes into Singletons optimized with the Double-Checked Locking optimization pattern.
This implementation is a slight variation on the GoF Singleton pattern. In particular, a single <ACE_Singleton<TYPE, ACE_LOCK> > instance is allocated here, not a <TYPE> instance. The reason for this is to allow registration with the ACE_Object_Manager, so that the Singleton can be cleaned up when the process exits. For this scheme to work, a (static) cleanup() function must be provided. ACE_Singleton provides one so that TYPE doesn't need to. If you want to make sure that only the singleton instance of <T> is created, and that users cannot create their own instances of <T>, do the following to class <T>: (a) Make the constructor of <T> private (or protected) (b) Make Singleton a friend of <T> Here is an example:
* class foo * { * friend class ACE_Singleton<foo, ACE_Null_Mutex>; * private: * foo () { cout << "foo constructed" << endl; } * ~foo () { cout << "foo destroyed" << endl; } * }; * typedef ACE_Singleton<foo, ACE_Null_Mutex> FOO; *
Definition at line 79 of file Singleton.h.
ACE_Singleton< TYPE, ACE_LOCK >::ACE_Singleton | ( | void | ) | [protected] |
void ACE_Singleton< TYPE, ACE_LOCK >::cleanup | ( | void * | param = 0 |
) | [virtual] |
Cleanup method, used by ace_cleanup_destroyer
to destroy the ACE_Singleton.
Reimplemented from ACE_Cleanup.
Definition at line 109 of file Singleton.cpp.
{ ACE_Object_Manager::remove_at_exit (this); delete this; ACE_Singleton<TYPE, ACE_LOCK>::instance_i () = 0; }
void ACE_Singleton< TYPE, ACE_LOCK >::close | ( | void | ) | [static] |
Explicitly delete the Singleton instance.
Reimplemented in ACE_Unmanaged_Singleton< TYPE, ACE_LOCK >.
Definition at line 117 of file Singleton.cpp.
{ ACE_Singleton<TYPE, ACE_LOCK> *&singleton = ACE_Singleton<TYPE, ACE_LOCK>::instance_i (); if (singleton) { singleton->cleanup (); ACE_Singleton<TYPE, ACE_LOCK>::instance_i () = 0; } }
class ACE_LOCK void ACE_Singleton< TYPE, ACE_LOCK >::dump | ( | void | ) | [static] |
Dump the state of the object.
Reimplemented in ACE_Unmanaged_Singleton< TYPE, ACE_LOCK >.
Definition at line 29 of file Singleton.cpp.
{ #if defined (ACE_HAS_DUMP) ACE_TRACE ("ACE_Singleton<TYPE, ACE_LOCK>::dump"); #if !defined (ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES) ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("instance_ = %x"), ACE_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_Singleton< TYPE, ACE_LOCK >::instance | ( | void | ) | [static] |
Global access point to the Singleton.
Reimplemented in ACE_Unmanaged_Singleton< TYPE, ACE_LOCK >.
Definition at line 57 of file Singleton.cpp.
{ ACE_TRACE ("ACE_Singleton<TYPE, ACE_LOCK>::instance"); ACE_Singleton<TYPE, ACE_LOCK> *&singleton = ACE_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_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_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); if (singleton == 0) { #endif /* ACE_MT_SAFE */ ACE_NEW_RETURN (singleton, (ACE_Singleton<TYPE, ACE_LOCK>), 0); // Register for destruction with ACE_Object_Manager. ACE_Object_Manager::at_exit (singleton, 0, typeid (TYPE).name ()); #if defined (ACE_MT_SAFE) && (ACE_MT_SAFE != 0) } #endif /* ACE_MT_SAFE */ } } return &singleton->instance_; }
ACE_Singleton< TYPE, ACE_LOCK > *& ACE_Singleton< TYPE, ACE_LOCK >::instance_i | ( | void | ) | [static, protected] |
Get pointer to the Singleton instance.
Reimplemented in ACE_Unmanaged_Singleton< TYPE, ACE_LOCK >.
Definition at line 43 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_Singleton<TYPE, ACE_LOCK> *singleton_ = 0; return singleton_; #else return ACE_Singleton<TYPE, ACE_LOCK>::singleton_; #endif /* ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES */ }
TYPE ACE_Singleton< TYPE, ACE_LOCK >::instance_ [protected] |
Contained instance.
Definition at line 100 of file Singleton.h.
ACE_Singleton< TYPE, ACE_LOCK > * ACE_Singleton< TYPE, ACE_LOCK >::singleton_ = 0 [static, protected] |
Pointer to the Singleton (ACE_Cleanup) instance.
Reimplemented in ACE_Unmanaged_Singleton< TYPE, ACE_LOCK >.
Definition at line 104 of file Singleton.h.