vsingleton.h

/*
Copyright c1997-2014 Trygve Isaacson. All rights reserved.
This file is part of the Code Vault version 3.3
http://www.bombaydigital.com/
License: MIT. See LICENSE.md in the Vault top level directory.
*/

#ifndef vsingleton_h
#define vsingleton_h

#include "vshutdownregistry.h"
#include "vmutexlocker.h"
#include "vexception.h"

template <class T>
class VSingleton : public IVShutdownHandler {
    public:

        enum HolderDeletionPolicy { kDeleteHolderAtShutdown, kDontDeleteHolderAtShutdown };
        enum ThreadSafetyPolicy { kThreadSafeAccess, kSimpleAccess };
        enum ShutdownPolicy { kRegisterForShutdown, kDontRegisterForShutdown };
        enum ResurrectionPolicy { kDontAllowResurrection, kAllowResurrection };

        VSingleton(HolderDeletionPolicy holderDeletionPolicy,
                   ThreadSafetyPolicy threadSafetyPolicy,
                   ShutdownPolicy shutdownPolicy,
                   ResurrectionPolicy resurrectionPolicy = kDontAllowResurrection)
            : IVShutdownHandler(holderDeletionPolicy == kDeleteHolderAtShutdown)
            , mThreadSafe(threadSafetyPolicy == kThreadSafeAccess)
            , mWantShutdown(shutdownPolicy == kRegisterForShutdown)
            , mAllowResurrection(resurrectionPolicy == kAllowResurrection)
            {
        }

        ~VSingleton() {}

        T* instance() {
            VMutexLocker locker(&gMutex, "VSingleton::instance()", mThreadSafe);

            if (gInstance == NULL) {
                if (gInstanceDeleted && !mAllowResurrection) {
                    throw VStackTraceException("VSingleton called with invalid attempt to get instance of deleted singleton.");
                }

                gInstance = new T();

                if (mWantShutdown) {
                    VShutdownRegistry::instance()->registerHandler(this);
                }
            }

            return gInstance;
        }

        void deleteInstance() {
            VMutexLocker locker(&gMutex, "VSingleton::deleteInstance()", mThreadSafe);
            delete gInstance;
            gInstance = NULL;
            gInstanceDeleted = true;
        }

    protected:

        virtual void _shutdown() {
            this->deleteInstance();
        }

    private:

        static VMutex   gMutex;             
        static T*       gInstance;          
        static bool     gInstanceDeleted;   

        bool mThreadSafe;           
        bool mWantShutdown;         
        bool mAllowResurrection;    

};

template <class T> VMutex VSingleton<T>::gMutex("VSingleton::gMutex");
template <class T> T* VSingleton<T>::gInstance = NULL;
template <class T> bool VSingleton<T>::gInstanceDeleted = false;

#endif /* vsingleton_h */