Singletons.h

Go to the documentation of this file.

#ifndef __LDK_SINGLETONS_HH__
#define __LDK_SINGLETONS_HH__

//   Copyright (C) 2003-2006 Lorien Dunn.
//
//   Contact: loriendunn AT users DOT sourceforge DOT net
//
//   This software is provided 'as-is', without any express or implied warranty.
//   In no event will the authors be held liable for any damages arising from
//   the use of this software.
//
//   Permission is granted to anyone to use this software for any purpose,
//   including commercial applications, and to alter it and redistribute it
//   freely, subject to the following restrictions:
//
//   1. The origin of this software must not be misrepresented; you must not
//   claim that you wrote the original software. If you use this software in a
//   product, an acknowledgment in the product documentation would be
//   appreciated but is not required.
//
//   2. Altered source versions must be plainly marked as such, and must not be
//   misrepresented as being the original software.
//
//   3. This notice may not be removed or altered from any source distribution.
//


#include "LDK/ThreadLocalStorage.h"
#include "LDK/STLMallocAllocator.h"
#include <vector>
#include <assert.h>

namespace LDK
{

typedef void (*SingletonDtor) ();

#ifdef _MSC_VER
#pragma warning (disable : 4251)
#endif


class LDK_API SingletonCleanup
{
private:

    typedef std::vector<SingletonDtor,MallocAllocator<SingletonDtor> > CleanupVec;

    static  CleanupVec mToClean;
    static bool mInitialised;

    static void callDtors();

public:

    static void initialise();
    static void addInstance(SingletonDtor dtor);
};

class LDK_API ThreadLocalCleanup
{
private:

    struct Pair //can't use std::pair because of const issues
    {
        ThreadLocalDtor mDtor;
        void* mInstance;
        Pair(ThreadLocalDtor dtor=NULL, void* instance=NULL) :
            mDtor(dtor),
            mInstance(instance)
        {}
    };

    typedef std::vector<Pair,MallocAllocator<Pair> > CleanupVec;

    CleanupVec mToClean;
    static TLSKey mKey;
    static bool mInitialised;

    static void callThreadDtors(void* s);
    static void callDtors();

public:

    static void initialise();
    static void addInstance(ThreadLocalDtor dtor, void* instance);
};

template <class T>
class SingletonStorage
{
public:
    typedef T  Type;
    typedef T* PointerType;
    typedef T& ReferenceType;
protected:
    static bool mInitialised;
    static PointerType mInstance;
    static void destroy()
    {
        if(mInstance)
            delete mInstance;
    }
public:
    static void initialise()
    {
        if(!mInitialised)
        {
            SingletonCleanup::initialise();
            try
            {
                mInstance = new T();
                mInitialised = true;
            }
            catch(std::bad_alloc&)
            {
                throw LDK_BADALLOC_ERROR;
            }
            SingletonCleanup::addInstance(SingletonStorage::destroy);
        }
    }
    static ReferenceType instance()
    {
        assert(mInitialised);
        assert(mInstance);
        return *mInstance;
    }
};
template <class T>
bool SingletonStorage<T>::mInitialised = false;
template <class T>
T* SingletonStorage<T>::mInstance = NULL;



template <class T>
class TLSSingletonStorage
{
public:
    typedef T  Type;
    typedef T* PointerType;
    typedef T& ReferenceType;
protected:
    static bool mInitialised;
    static TLSKey mKey;
    static void destroy(void* obj)
    {
        if(obj)
            delete reinterpret_cast<T*>(obj);
    }
public:
    static void initialise()
    {
        if(!mInitialised)
        {
            ThreadLocalCleanup::initialise();
            mKey = threadLocalCreateKey();
            mInitialised = true;
        }
    }
    static ReferenceType instance()
    {
        assert(mInitialised);
        PointerType instance = reinterpret_cast<PointerType>(threadLocalGet(mKey));
        if(instance)
            return *instance;
        try
        {
            instance = new T();
        }
        catch(std::bad_alloc&)
        {
            throw LDK_BADALLOC_ERROR;
        }
        threadLocalSet(mKey, instance);
        ThreadLocalCleanup::addInstance(TLSSingletonStorage::destroy,instance);
        return *instance;
    }
};

template <class T>
bool TLSSingletonStorage<T>::mInitialised = false;
template <class T>
TLSKey TLSSingletonStorage<T>::mKey = 0;

#define DEFAULT_SINGLETON_STORAGE TLSSingletonStorage


template
<
    class T,
    template <class> class StoragePolicy=DEFAULT_SINGLETON_STORAGE
>
class Singleton : public StoragePolicy<T>
{
public:
    typedef StoragePolicy<T> SP;
    typedef typename SP::Type Type;
    typedef typename SP::PointerType PointerType;
    typedef typename SP::ReferenceType ReferenceType;
protected:
    inline Singleton () {}
    inline Singleton (const Singleton &) {}
    inline ~Singleton() {}
    inline void operator=(const Singleton&) {}
public:
    inline static void initialise()
    {
        SP::initialise();
    }
    inline static ReferenceType instance()
    {
        return SP::instance();
    }
};

} //namespace LDK

#ifdef _MSC_VER
#pragma warning (default : 4251)
#endif

#endif //__LDK_SINGLETONS_HH__

---