ACE_Singleton< TYPE, ACE_LOCK > Class Template Reference

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>

Inheritance diagram for ACE_Singleton< TYPE, ACE_LOCK >:

Inheritance graph
[legend]
Collaboration diagram for ACE_Singleton< TYPE, ACE_LOCK >:

Collaboration graph
[legend]

List of all members.

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_
 Pointer to the Singleton (ACE_Cleanup) instance.


Detailed Description

template<class TYPE, class ACE_LOCK>
class ACE_Singleton< TYPE, ACE_LOCK >

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;
 * 

Note:
The best types to use for ACE_LOCK are ACE_Recursive_Thread_Mutex and ACE_Null_Mutex. ACE_Recursive_Thread_Mutex should be used in multi-threaded programs in which it is possible for more than one thread to access the <ACE_Singleton<TYPE, ACE_LOCK>> instance. ACE_Null_Mutex can be used otherwise. The reason that these types of locks are best has to do with their allocation by the ACE_Object_Manager. Single ACE_Recursive_Thread_Mutex and ACE_Null_Mutex instances are used for all ACE_Singleton instantiations. However, other types of locks are allocated per ACE_Singleton instantiation.

Constructor & Destructor Documentation

template<class TYPE, class ACE_LOCK>
ACE_Singleton< TYPE, ACE_LOCK >::ACE_Singleton ( void   )  [protected]

Default constructor.


Member Function Documentation

template<class TYPE, class ACE_LOCK>
virtual 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.

template<class TYPE, class ACE_LOCK>
static void ACE_Singleton< TYPE, ACE_LOCK >::close ( void   )  [static]

Explicitly delete the Singleton instance.

Reimplemented in ACE_Unmanaged_Singleton< TYPE, ACE_LOCK >.

template<class TYPE, class ACE_LOCK>
static void ACE_Singleton< TYPE, ACE_LOCK >::dump ( void   )  [static]

Dump the state of the object.

Reimplemented in ACE_Unmanaged_Singleton< TYPE, ACE_LOCK >.

template<class TYPE, class ACE_LOCK>
static TYPE* ACE_Singleton< TYPE, ACE_LOCK >::instance ( void   )  [static]

Global access point to the Singleton.

Reimplemented in ACE_Unmanaged_Singleton< TYPE, ACE_LOCK >.

template<class TYPE, class ACE_LOCK>
static 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 >.


Member Data Documentation

template<class TYPE, class ACE_LOCK>
TYPE ACE_Singleton< TYPE, ACE_LOCK >::instance_ [protected]

Contained instance.

template<class TYPE, class ACE_LOCK>
ACE_Singleton<TYPE, ACE_LOCK>* ACE_Singleton< TYPE, ACE_LOCK >::singleton_ [static, protected]

Pointer to the Singleton (ACE_Cleanup) instance.

Reimplemented in ACE_Unmanaged_Singleton< TYPE, ACE_LOCK >.


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

Generated on Mon Jul 13 16:13:03 2009 for ACE by  doxygen 1.5.8