Singleton.h

Go to the documentation of this file.

#ifndef Protium_Singleton_h_
#define Protium_Singleton_h_

#include "Protium/Singleton/CreationPolicies.h"
#include "Protium/Singleton/DeletionPolicies.h"
#include "Protium/Threads/ThreadingPolicy.h"
#include "Protium/Threads/Mutex.h"

namespace Protium{

    namespace Singleton{

        template<   class Host,
                    template <class> class CreationPolicy = CreateNew,
                    template <class> class DeletionPolicy = DeleteNever,
                    template <class, class> class ThreadingPolicy = Protium::Threads::InstanceLocked,
                    class MutexPolicy = Protium::Threads::Mutex>
        class Singleton{
        public:
            typedef Host ObjectType;
            static Host& Instance();
            
        private:
            static void MakeInstance();
            static void DestroySingleton();
            
            Singleton();
            Singleton(const Singleton&) {}
            Singleton& operator=(const Singleton& ) {} 
            
            typedef typename ThreadingPolicy<ObjectType*,MutexPolicy>::VolatileType PtrInstanceType;
            static PtrInstanceType fInstance;
            static bool fDestroyed;
        };





        template<   class Host,
                    template <class> class CreationPolicy,
                    template <class> class DeletionPolicy,
                    template <class, class> class ThreadingPolicy,
                    class MutexPolicy >
        typename Singleton<Host, CreationPolicy, DeletionPolicy, ThreadingPolicy, MutexPolicy>::PtrInstanceType
            Singleton<Host, CreationPolicy, DeletionPolicy, ThreadingPolicy, MutexPolicy>::fInstance = 0;

        template<   class Host,
                    template <class> class CreationPolicy,
                    template <class> class DeletionPolicy,
                    template <class, class> class ThreadingPolicy,
                    class MutexPolicy >
       bool Singleton<Host, CreationPolicy, DeletionPolicy, ThreadingPolicy, MutexPolicy>::fDestroyed = false;

    // Singleton::Instance

        template<   class Host,
                    template <class> class CreationPolicy,
                    template <class> class DeletionPolicy,
                    template <class, class> class ThreadingPolicy,
                    class MutexPolicy >
        inline Host& Singleton<Host, CreationPolicy, DeletionPolicy, ThreadingPolicy, MutexPolicy>::Instance(){
            if (!fInstance)
                MakeInstance();
            return *fInstance;
        }

    // Singleton::MakeInstance (helper for Instance)

        template<   class Host,
                    template <class> class CreationPolicy,
                    template <class> class DeletionPolicy,
                    template <class, class> class ThreadingPolicy,
                    class MutexPolicy >
        void Singleton<Host, CreationPolicy, DeletionPolicy, ThreadingPolicy, MutexPolicy>::MakeInstance(){
        
            typename ThreadingPolicy<Singleton,MutexPolicy>::Lock lock;
        
            (void)lock;
        
            if (!fInstance){
                if (fDestroyed){
                    fDestroyed = false;
                    DeletionPolicy<Host>::OnDeadReference();
                }
                fInstance = CreationPolicy<Host>::Create();
                DeletionPolicy<Host>::ScheduleDestruction(fInstance, &DestroySingleton);
            }
        }

        template<   class Host,
                    template <class> class CreationPolicy,
                    template <class> class DeletionPolicy,
                    template <class, class> class ThreadingPolicy,
                    class MutexPolicy >
        void Singleton<Host, CreationPolicy, DeletionPolicy, ThreadingPolicy, MutexPolicy>::DestroySingleton() {
            assert(!fDestroyed);
            CreationPolicy<Host>::Destroy(fInstance);
            fInstance = NULL;
            fDestroyed = true;
        }
    }
}


#endif //File Guardian