Sie sind auf Seite 1von 4

ACE_Singleton Class 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:

[legend]

Collaboration diagram for ACE_Singleton:

[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
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 shoul d 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 theACE_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

ACE_Singleton::ACE_Singleton ( void
Default constructor.

) [protected]

Member Function Documentation

virtual void ACE_Singleton::cleanup ( void * param = 0 ) [virtual]


Cleanup method, used by ace_cleanup_destroyer to destroy the ACE_Singleton. Reimplemented from ACE_Cleanup.

static void ACE_Singleton::close ( void


Explicitly delete the Singleton instance.

) [static]

Reimplemented in ACE_Unmanaged_Singleton.

static void ACE_Singleton::dump


Dump the state of the object.

( void

) [static]

Reimplemented in ACE_Unmanaged_Singleton.

static TYPE* ACE_Singleton::instance ( void


Global access point to the Singleton. Reimplemented in ACE_Unmanaged_Singleton.

) [static]

static ACE_Singleton<TYPE, ACE_LOCK>*& ACE_Singleton::instance_i


Get pointer to the Singleton instance.

( void

[static, ) protected]

Reimplemented in ACE_Unmanaged_Singleton.

Member Data Documentation

TYPE ACE_Singleton::instance_ [protected]


Contained instance.

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


Pointer to the Singleton (ACE_Cleanup) instance. Reimplemented in ACE_Unmanaged_Singleton.