This class uses the Adapter pattern to turn ordinary classes into Thread-specific 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 | dump (void) |
| Dump the state of the object. | |
Protected Member Functions | |
| ACE_TSS_Singleton (void) | |
| Default constructor. | |
| ACE_TSS_TYPE (TYPE) instance_ | |
| Contained instance. | |
| void | operator= (const ACE_TSS_Singleton< TYPE, ACE_LOCK > &) |
| ACE_TSS_Singleton (const ACE_TSS_Singleton< TYPE, ACE_LOCK > &) | |
Static Protected Member Functions | |
| static ACE_TSS_Singleton< TYPE, ACE_LOCK > *& | instance_i (void) |
| Get pointer to the TSS Singleton instance. | |
Static Protected Attributes | |
| static ACE_TSS_Singleton< TYPE, ACE_LOCK > * | singleton_ = 0 |
| Pointer to the Singleton (ACE_Cleanup) instance. | |
This class uses the Adapter pattern to turn ordinary classes into Thread-specific Singletons optimized with the Double-Checked Locking optimization pattern.
This implementation is another variation on the GoF Singleton pattern. In this case, a single <ACE_TSS_Singleton<TYPE, LOCK> > instance is allocated here, not a <TYPE> instance. Each call to the <instance> static method returns a Singleton whose pointer resides in thread-specific storage. As with ACE_Singleton, we use 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.
Definition at line 173 of file Singleton.h.
| ACE_TSS_Singleton< TYPE, ACE_LOCK >::ACE_TSS_Singleton | ( | void | ) | [protected] |
| ACE_TSS_Singleton< TYPE, ACE_LOCK >::ACE_TSS_Singleton | ( | const ACE_TSS_Singleton< TYPE, ACE_LOCK > & | ) | [protected] |
| ACE_TSS_Singleton< TYPE, ACE_LOCK >::ACE_TSS_TYPE | ( | TYPE | ) | [protected] |
Contained instance.
| void ACE_TSS_Singleton< TYPE, ACE_LOCK >::cleanup | ( | void * | param = 0 |
) | [virtual] |
Cleanup method, used by <ace_cleanup_destroyer> to destroy the singleton.
Reimplemented from ACE_Cleanup.
Definition at line 310 of file Singleton.cpp.
{
delete this;
ACE_TSS_Singleton<TYPE, ACE_LOCK>::instance_i () = 0;
}
| void ACE_TSS_Singleton< TYPE, ACE_LOCK >::dump | ( | void | ) | [static] |
Dump the state of the object.
Reimplemented in ACE_Unmanaged_TSS_Singleton< TYPE, ACE_LOCK >.
Definition at line 229 of file Singleton.cpp.
{
#if defined (ACE_HAS_DUMP)
ACE_TRACE ("ACE_TSS_Singleton<TYPE, ACE_LOCK>::dump");
#if !defined (ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES)
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("instance_ = %x"),
ACE_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_TSS_Singleton< TYPE, ACE_LOCK >::instance | ( | void | ) | [static] |
Global access point to the singleton.
Reimplemented in ACE_Unmanaged_TSS_Singleton< TYPE, ACE_LOCK >.
Definition at line 257 of file Singleton.cpp.
{
ACE_TRACE ("ACE_TSS_Singleton<TYPE, ACE_LOCK>::instance");
ACE_TSS_Singleton<TYPE, ACE_LOCK> *&singleton =
ACE_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_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_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_TSS_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 ACE_TSS_GET (&singleton->instance_, TYPE);
}
| ACE_TSS_Singleton< TYPE, ACE_LOCK > *& ACE_TSS_Singleton< TYPE, ACE_LOCK >::instance_i | ( | void | ) | [static, protected] |
Get pointer to the TSS Singleton instance.
Reimplemented in ACE_Unmanaged_TSS_Singleton< TYPE, ACE_LOCK >.
Definition at line 243 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_TSS_Singleton<TYPE, ACE_LOCK> *singleton_ = 0;
return singleton_;
#else
return ACE_TSS_Singleton<TYPE, ACE_LOCK>::singleton_;
#endif /* ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES */
}
| void ACE_TSS_Singleton< TYPE, ACE_LOCK >::operator= | ( | const ACE_TSS_Singleton< TYPE, ACE_LOCK > & | ) | [protected] |
ACE_TSS_Singleton< TYPE, ACE_LOCK > * ACE_TSS_Singleton< TYPE, ACE_LOCK >::singleton_ = 0 [static, protected] |
Pointer to the Singleton (ACE_Cleanup) instance.
Reimplemented in ACE_Unmanaged_TSS_Singleton< TYPE, ACE_LOCK >.
Definition at line 198 of file Singleton.h.
1.7.0