ACE  6.2.5
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
Public Member Functions | Static Public Member Functions | Protected Member Functions | Static Protected Member Functions | Protected Attributes | Static Protected Attributes | List of all members
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]

Public Member Functions

virtual void cleanup (void *param=0)
 
- Public Member Functions inherited from ACE_Cleanup
 ACE_Cleanup (void)
 No-op constructor. More...
 
virtual ~ACE_Cleanup (void)
 Destructor. More...
 

Static Public Member Functions

static TYPE * instance (void)
 Global access point to the Singleton. More...
 
static void close (void)
 Explicitly delete the Singleton instance. More...
 
static void dump (void)
 Dump the state of the object. More...
 

Protected Member Functions

 ACE_Singleton (void)
 Default constructor. More...
 

Static Protected Member Functions

static ACE_Singleton< TYPE,
ACE_LOCK > *& 
instance_i (void)
 Get pointer to the Singleton instance. More...
 

Protected Attributes

TYPE instance_
 Contained instance. More...
 

Static Protected Attributes

static ACE_Singleton< TYPE,
ACE_LOCK > * 
singleton_ = 0
 Pointer to the Singleton (ACE_Cleanup) instance. More...
 

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  )
inlineprotected

Default constructor.

Member Function Documentation

template<class TYPE , class ACE_LOCK >
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 >
void ACE_Singleton< TYPE, ACE_LOCK >::close ( void  )
static

Explicitly delete the Singleton instance.

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

Dump the state of the object.

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

Global access point to the Singleton.

template<class TYPE , class ACE_LOCK >
ACE_Singleton< TYPE, ACE_LOCK > *& ACE_Singleton< TYPE, ACE_LOCK >::instance_i ( void  )
staticprotected

Get pointer to the Singleton instance.

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_ = 0
staticprotected

Pointer to the Singleton (ACE_Cleanup) instance.


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