OBT::Singleton< T > Class Template Reference

#include <OBTSingleton.h>

Collaboration diagram for OBT::Singleton< T >:

[legend]

List of all members.

Static Public Member Functions
static T &	getInstance ()
Private Member Functions
	Singleton ()
	constructor
virtual	~Singleton ()
	destructor
	Singleton (const Singleton &)
	copy constructor
Singleton &	operator= (const Singleton &)
	assignment operator
Static Private Member Functions
static void	create ()
	creates a new instance of T and store a pointer to it in instance_
static void	onDeadReference ()
	called on a dead reference detection, re-creates an instance and throws an exception
static void	destroy ()
	flag the Singleton as destroyed
Static Private Attributes
static T *	_instance = 0
	pointer to the unique instance of T in the application
static bool	_destroyed = false
	indicates if the OBTSingleton.has been destroyed
static bool	_explicitDestruction = false
	indicates if the OBTSingleton.has been destroyed once

---

Detailed Description

template<class T>
class OBT::Singleton< T >

Singleton template class

Author:

Michaël Rouillé <michael.rouille@gmail.com> In order to be a singleton, a class constructor should be private and give friendship to Singleton. The unique instance of the class is obtained by a call to getInstance.

This Singleton implementation :

• avoid resources leaks
• detect dead-references
• implements the phoenix policy described in Modern C++ Design by A. Alexandrescu

Definition at line 25 of file OBTSingleton.h.

---

Constructor & Destructor Documentation

template<class T>

OBT::Singleton< T >::Singleton

(

)

[private]

constructor

template<class T>

OBT::Singleton< T >::~Singleton

(

)

[inline, private, virtual]

destructor

Definition at line 85 of file OBTSingleton.h.

        {
        }

template<class T>

OBT::Singleton< T >::Singleton

(

const Singleton< T > &

)

[private]

copy constructor

---

Member Function Documentation

template<class T>

T & OBT::Singleton< T >::getInstance

(

)

[inline, static]

access to the unique instance of T getInstance purposely does not catch the exception thrown when a dead reference is detected, in order to help you resolve potential design problems which lead to this situation. If you really need to access the destroyed singleton, just catch the exception thrown and call getInstance again.

Returns:

a reference to the unique instance of T in the application

Definition at line 94 of file OBTSingleton.h.

References OBT::Singleton< T >::_destroyed, OBT::Singleton< T >::_instance, OBT::Singleton< T >::create(), OBT::Singleton< T >::destroy(), and OBT::Singleton< T >::onDeadReference().

        {
                if ( _instance == NULL )
                {
                        // checks for dead reference
                        if ( _destroyed == true )
                        {
                                onDeadReference() ;
                        }

                        // create the instance
                        create() ;

                        // the destroy method will be called at the application exit 
                        std::atexit( destroy ) ;
                }
                return *_instance ;
        }

template<class T>

void OBT::Singleton< T >::create

(

)

[inline, static, private]

creates a new instance of T and store a pointer to it in instance_

Definition at line 118 of file OBTSingleton.h.

References OBT::Singleton< T >::_instance.

Referenced by OBT::Singleton< T >::getInstance(), and OBT::Singleton< T >::onDeadReference().

        {
                // initialise _instance
                static T theInstance ;
                _instance = &theInstance ;
        }

template<class T>

void OBT::Singleton< T >::onDeadReference

(

)

[inline, static, private]

called on a dead reference detection, re-creates an instance and throws an exception

Definition at line 130 of file OBTSingleton.h.

References OBT::Singleton< T >::_destroyed, OBT::Singleton< T >::_explicitDestruction, OBT::Singleton< T >::_instance, OBT::Singleton< T >::create(), and OBT::Singleton< T >::destroy().

Referenced by OBT::Singleton< T >::getInstance().

        {
                // obtains the shell of the destroyed singleton
                create() ;
                // now _instance points to the "ashes" of the singleton
                // - the raw memory that the singleton was seated in.
                // creates a new singleton at that address
                new( _instance ) T ;
                // reset _destroyed because we're back in business
                _destroyed = false ;
                // set _explicitDestruction because the business must be destroyed
                // at the application exit
                _explicitDestruction = true ;
                // the destroy method will be called at the application exit 
                std::atexit( destroy ) ;

                throw std::runtime_error( "Detection of a Singleton Dead Reference" ) ;
        }

template<class T>

void OBT::Singleton< T >::destroy

(

)

[inline, static, private]

flag the Singleton as destroyed

Definition at line 154 of file OBTSingleton.h.

References OBT::Singleton< T >::_destroyed, OBT::Singleton< T >::_explicitDestruction, and OBT::Singleton< T >::_instance.

Referenced by OBT::Singleton< T >::getInstance(), and OBT::Singleton< T >::onDeadReference().

        {
                if ( _explicitDestruction )
                {
                        _instance->~T() ;
                }
                _instance = NULL ;
                _destroyed = true ;
        }

template<class T>

Singleton& OBT::Singleton< T >::operator=

(

const Singleton< T > &

)

[private]

assignment operator

---

Member Data Documentation

template<class T>

T * OBT::Singleton< T >::_instance = 0 [inline, static, private]

pointer to the unique instance of T in the application

Definition at line 53 of file OBTSingleton.h.

Referenced by OBT::Singleton< T >::create(), OBT::Singleton< T >::destroy(), OBT::Singleton< T >::getInstance(), and OBT::Singleton< T >::onDeadReference().

template<class T>

bool OBT::Singleton< T >::_destroyed = false [inline, static, private]

indicates if the OBTSingleton.has been destroyed

Definition at line 56 of file OBTSingleton.h.

Referenced by OBT::Singleton< T >::destroy(), OBT::Singleton< T >::getInstance(), and OBT::Singleton< T >::onDeadReference().

template<class T>

bool OBT::Singleton< T >::_explicitDestruction = false [inline, static, private]

indicates if the OBTSingleton.has been destroyed once

Definition at line 59 of file OBTSingleton.h.

Referenced by OBT::Singleton< T >::destroy(), and OBT::Singleton< T >::onDeadReference().

---