OBTSingleton.h

Go to the documentation of this file.

#ifndef OBTSingleton_H_
#define OBTSingleton_H_

#include <cstdlib>
#include <stdexcept>
#include "OBT.h"

namespace OBT
{
        template< class T >
        class Singleton
        {
        public:

                static T& getInstance() ;

        private:

                static void create() ;

                static void onDeadReference() ;
                
                static void destroy() ;
                
                static T* _instance ;

                static bool _destroyed ;

                static bool _explicitDestruction ;

                Singleton() ;

                virtual ~Singleton() ;

                Singleton( const Singleton& ) ;

                Singleton& operator=( const Singleton& ) ;
        } ;

        //-------------------------------------------------------------------------
        // static member variables initialization.
        //-------------------------------------------------------------------------
        template< class T > T* Singleton<T>::_instance = 0 ;
        template< class T > bool Singleton<T>::_destroyed = false ;
        template< class T > bool Singleton<T>::_explicitDestruction = false ;

        //-------------------------------------------------------------------------
        // destructor
        //-------------------------------------------------------------------------
        template< class T >
        Singleton<T>::~Singleton()
        {
        }

        //-------------------------------------------------------------------------
        // getInstance
        //-------------------------------------------------------------------------
        template< class T >
        T& 
        Singleton<T>::getInstance()
        {
                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 ;
        }

        //-------------------------------------------------------------------------
        // create
        //-------------------------------------------------------------------------
        template< class T >
        void 
        Singleton<T>::create()
        {
                // initialise _instance
                static T theInstance ;
                _instance = &theInstance ;
        }

        //-------------------------------------------------------------------------
        // onDeadReference
        //-------------------------------------------------------------------------
        template< class T >
        void 
        Singleton<T>::onDeadReference()
        {
                // 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" ) ;
        }

        //-------------------------------------------------------------------------
        // destroy
        //-------------------------------------------------------------------------
        template< class T >
        void 
        Singleton<T>::destroy()
        {
                if ( _explicitDestruction )
                {
                        _instance->~T() ;
                }
                _instance = NULL ;
                _destroyed = true ;
        }
}
#endif //OBTSingleton_H_

---