cSingleton.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cSingleton_H
#define _INC_cSingleton_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cNonCopyable.h"
#include "cThreadLock.h"
#include "cUnitTestDecl.h"
#include "cTypeInfo.h"
#include "cHeapObject.h"
#include "cObject.h"
#include "cDebugAssert.h"
 
namespace Gray
{
#ifdef _MSC_VER 
#pragma warning(disable:4355)   // disable the warning regarding 'this' pointers being used in base member initializer list. Singletons rely on this action
#endif
 
        template <class TYPE>
        class cSingletonStatic 
        {
 
        protected:
                static TYPE* sm_pThe;   
        private:
                NonCopyable_IMPL(cSingletonStatic);
 
        protected:
                cSingletonStatic(TYPE* pObject) noexcept
                {
                        DEBUG_ASSERT(pObject != nullptr, "cSingletonStatic");
                        if (sm_pThe != nullptr)
                        {
                                // THIS SHOULD NOT HAPPEN! Find who else is creating this singleton!
                                DEBUG_ASSERT(sm_pThe == nullptr, "cSingletonStatic");
                                return;
                        }
                        sm_pThe = pObject;
                        DEBUG_ASSERT(sm_pThe == this, "cSingletonStatic");
                }
                virtual ~cSingletonStatic() noexcept
                {
                        if (sm_pThe != nullptr)
                        {
                                DEBUG_ASSERT(sm_pThe == this, "~cSingletonStatic");
                                sm_pThe = nullptr;
                        }
                }
 
        public:
                // the singleton accessor
                static inline bool isSingleCreated() noexcept
                {
                        return sm_pThe != nullptr;
                }
                static inline TYPE* get_SingleU() noexcept
                {
                        return sm_pThe;
                }
                static inline TYPE* get_Single()
                {
                        ASSERT(isSingleCreated());
                        return sm_pThe; // get_SingleU()
                }
                template <class TYPE2>
                static TYPE2* GRAYCALL get_SingleCast() // ASSUME TYPE2 derived from TYPE?
                {
                        // DYNPTR_CAST or CHECKPTR_CAST for up-cast to some other type.
                        return CHECKPTR_CAST(TYPE2, get_Single());
                }
                static inline TYPE& I() noexcept
                {
                        return *get_Single();
                }
        };
 
        template <class TYPE> TYPE* cSingletonStatic<TYPE>::sm_pThe = nullptr; // assume this is always set before any usage.
 
        class GRAYCORE_LINK cSingletonRegister : public CObject, public cHeapObject // IHeapObject
        {
 
                friend class cSingletonManager;
 
        protected:
#ifndef UNDER_CE
                HMODULE m_hModuleLoaded;        
#endif
        public:
                static cThreadLockFast sm_LockSingle; 
        protected:
                cSingletonRegister(const TYPEINFO_t& rAddrCode) noexcept;
                virtual ~cSingletonRegister();
                void RegisterSingleton();
        public:
                static void GRAYCALL ReleaseModule(HMODULE hMod);
                UNITTEST_FRIEND(cSingleton);
        };
 
        template <class TYPE>
        class cSingleton : public cSingletonStatic<TYPE>, public cSingletonRegister
        {
 
                typedef cSingletonStatic<TYPE> SUPER_t;
 
        protected:
                cSingleton(TYPE* pObject, const TYPEINFO_t& rAddrCode = typeid(TYPE)) noexcept
                        : cSingletonStatic<TYPE>(pObject)
                        , cSingletonRegister(rAddrCode) // track the module for the codes implementation.
                {
                }
                virtual ~cSingleton()
                {
                }
 
        public:
                static TYPE* GRAYCALL get_Single()
                {
 
                        if (!SUPER_t::isSingleCreated())
                        {
                                // Double Check Lock for multi threaded
                                cThreadGuardFast threadguard(cSingletonRegister::sm_LockSingle);        // thread sync critical section.
                                if (!SUPER_t::isSingleCreated())
                                {
                                        DEBUG_CHECK(!TYPE::isSingleCreated());  // SUPER_t::sm_pThe
                                        new TYPE(); // assume it calls its constructor properly and sets sm_pThe
                                        DEBUG_CHECK(TYPE::isSingleCreated());   // SUPER_t::sm_pThe
                                        SUPER_t::sm_pThe->RegisterSingleton();  // Register only if i know it is dynamic. Not static.
                                }
                        }
                        return SUPER_t::sm_pThe;
                }
 
                template <class TYPE2>
                static TYPE2* GRAYCALL get_SingleT()    // ASSUME TYPE2 derived from TYPE
                {
 
                        if (!SUPER_t::isSingleCreated())
                        {
                                // Double Check Lock for multi threaded
                                cThreadGuardFast threadguard(cSingletonRegister::sm_LockSingle);        // thread sync critical section.
                                if (!SUPER_t::isSingleCreated())
                                {
                                        ASSERT(!TYPE2::isSingleCreated());      // SUPER_t::sm_pThe
                                        TYPE2* p = new TYPE2();
                                        ASSERT(p == SUPER_t::sm_pThe);
                                        ASSERT(TYPE2::isSingleCreated());       // SUPER_t::sm_pThe
                                        SUPER_t::sm_pThe->RegisterSingleton();  // Register only if i know it is dynamic. Not static.
                                }
                        }
                        return CHECKPTR_CAST(TYPE2, SUPER_t::sm_pThe);
                }
 
                static TYPE& GRAYCALL I()
                {
                        return *get_Single();
                }
        };
}
 
#endif  // _INC_cSingleton_H