Singleton.h

Go to the documentation of this file.

#ifndef CARMA_UTIL_SINGLETON_H
#define CARMA_UTIL_SINGLETON_H

#include <stdexcept>
#include <typeinfo>

#include "carma/util/demangle.h"
#include "carma/util/PthreadMutex.h"
#include "carma/util/ScopedPthreadMutexLock.h"


namespace carma {
namespace util {

    template <class TYPE, template <class> class InstantiationPolicy>
    class Singleton;

    template <class TYPE>
    class CreateWithNewPolicy;

    template <class TYPE>
    class CreateStaticPolicy;

    template <class TYPE>
    class CreateWithNewUnmanagedPolicy;

// -----------------------------------------------------------------------------
    template <class TYPE, template<class> class InstantiationPolicy>
    class Singleton {
    public:

        static TYPE& instance();

    protected:
        
        typedef enum INSTANCE_STATE {
                NO_INSTANCE,  // Make sure this stays first... 
                INSTANCE_CREATED,
                INSTANCE_DESTROYED,
                NUM_INSTANCE_STATES
        } InstanceStateType;
    
        explicit Singleton(); // Allow subclassing...
        virtual ~Singleton();  

        // Let instantiation policies have access to destroyInstance().
        // This allows the policies to have finer grained control over their
        // lifetime and destruction. Prior solution used a single lifetime. 
        friend class InstantiationPolicy<TYPE>;

        static void destroyInstance();

        static TYPE* instancePtr_; // Guaranteed init to 0 (thanks Tom).
        static InstanceStateType state_; // Initializes to NO_INSTANCE
        
    private:

    };

    template <class TYPE, template<class> class InstantiationPolicy>
    TYPE& Singleton<TYPE, InstantiationPolicy>::instance() 
    {
        static carma::util::PthreadMutex lock;

        // Use Double-Checked Locking - See  'Double-Checked Locking - An 
        // Optimization Pattern for Efficiently Initializing and Accessing 
        // Thread-safe Objects' 
        // http://www.cs.wustl.edu/~schmidt/PDF/DC-Locking.pdf
        if (!instancePtr_) {
             ScopedPthreadMutexLock guard(lock);
             if (!instancePtr_) {
                
                if (state_ != NO_INSTANCE)
                    throw std::logic_error(carma::util::demangleTypeName(
                        typeid(Singleton<TYPE, InstantiationPolicy>)) 
                        + "::instance() - Invalid Singleton state.");
                
                instancePtr_ = InstantiationPolicy<TYPE>::createInstance();
                state_ = INSTANCE_CREATED;
             }
         }

         if (state_ != INSTANCE_CREATED)
            throw std::logic_error(carma::util::demangleTypeName(
                typeid(Singleton<TYPE, InstantiationPolicy>)) 
                + "::instance() - Invalid Singleton state.");

         return *instancePtr_;
    }

    template <class TYPE, template<class> class InstantiationPolicy>
    void Singleton<TYPE, InstantiationPolicy>::destroyInstance()
    {
        if (state_ != INSTANCE_CREATED)
            throw std::logic_error(carma::util::demangleTypeName(
                typeid(Singleton<TYPE, InstantiationPolicy>)) 
                + "::instance() - Invalid Singleton state.");
        InstantiationPolicy<TYPE>::deleteInstance(instancePtr_);
        instancePtr_ = 0;
        state_ = INSTANCE_DESTROYED;
    }

    template <class TYPE, template<class> class InstantiationPolicy>
    Singleton<TYPE, InstantiationPolicy>::Singleton() {};

    template <class TYPE, template<class> class InstantiationPolicy>
    Singleton<TYPE, InstantiationPolicy>::~Singleton() {}; 

    template <class TYPE, template<class> class InstantiationPolicy>
    TYPE* Singleton<TYPE, InstantiationPolicy>::instancePtr_; 
    
    template <class TYPE, template<class> class InstantiationPolicy>
    typename Singleton<TYPE, InstantiationPolicy>::InstanceStateType 
        Singleton<TYPE, InstantiationPolicy>::state_; 
    
// -----------------------------------------------------------------------------
// Create With New Instantiation Policy.
// -----------------------------------------------------------------------------
    template <class TYPE>
    class CreateWithNewPolicy {
    public:
        static TYPE* createInstance();
        static void deleteInstance(TYPE * ptr);
    private:

        CreateWithNewPolicy();
        ~CreateWithNewPolicy();
    };

    template <class TYPE>
    CreateWithNewPolicy<TYPE>::CreateWithNewPolicy() {}

    template <class TYPE>
    CreateWithNewPolicy<TYPE>::~CreateWithNewPolicy() {
        Singleton<TYPE, carma::util::CreateWithNewPolicy>::destroyInstance(); 
    }
        
    template <class TYPE>
    TYPE* CreateWithNewPolicy<TYPE>::createInstance()
    {
        static CreateWithNewPolicy doomed;  // Use self instance to bound life.
        return new TYPE; // Create instance
    } 
        
    template <class TYPE>
    void CreateWithNewPolicy<TYPE>::deleteInstance(TYPE * ptr)
    {
        delete ptr; // Delete instance
    }

// -----------------------------------------------------------------------------
// Create Static Instantiation Policy.
// -----------------------------------------------------------------------------
    template <class TYPE>
    class CreateStaticPolicy { 
    public:
        static TYPE* createInstance();
        static void deleteInstance(TYPE * ptr);
    private:
        
        CreateStaticPolicy();
        ~CreateStaticPolicy();
        
    };
    
    template <class TYPE>
    CreateStaticPolicy<TYPE>::CreateStaticPolicy() {}

    template <class TYPE>
    CreateStaticPolicy<TYPE>::~CreateStaticPolicy() {
        Singleton<TYPE, carma::util::CreateStaticPolicy>::destroyInstance(); 
    }
        
    template <class TYPE>
    TYPE* CreateStaticPolicy<TYPE>::createInstance()
    {
        static CreateStaticPolicy doomed; // Use self instance to bound life.
        static TYPE instance; // Create instance as a static variable
        return &instance;
    }

    template <class TYPE>
    void CreateStaticPolicy<TYPE>::deleteInstance(TYPE * ptr)
    {
        // Nothing - let the system cleanup. 
    }

// -----------------------------------------------------------------------------
// Create With New Unmanaged Instantiation Policy.
// -----------------------------------------------------------------------------
    template <class TYPE>
    class CreateWithNewUnmanagedPolicy {
    public:
        static TYPE* createInstance();
        static void deleteInstance(TYPE * ptr);
    };

    template <class TYPE>
    TYPE* CreateWithNewUnmanagedPolicy<TYPE>::createInstance()
    {
        return new TYPE;
    }

    template <class TYPE>
    void CreateWithNewUnmanagedPolicy<TYPE>::deleteInstance(TYPE * ptr)
    {
        // Nothing - User is responsible for their own deletion scheme.
    }
        
}} // End namespace carma::util
#endif