SingletonHolder.h

// The Loki Library
// Copyright (c) 2001 by Andrei Alexandrescu
// This code accompanies the book:
// Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design
//     Patterns Applied". Copyright (c) 2001. Addison-Wesley.
// Permission to use, copy, modify, distribute and sell this software for any
//     purpose is hereby granted without fee, provided that the above copyright
//     notice appear in all copies and that both that copyright notice and this
//     permission notice appear in supporting documentation.
// The author or Addison-Wesley Longman make no representations about the
//     suitability of this software for any purpose. It is provided "as is"
//     without express or implied warranty.
#ifndef LOKI_SINGLETON_INC_
#define LOKI_SINGLETON_INC_

// $Id$

#include <algorithm>
#include <stdexcept>
#include <cassert>
#include <cstdlib>
#include <new>
#include <vector>
#include <list>
#include <memory>




namespace Loki
{


    template <class T> struct CreateUsingNew
    {
        static T* Create()
        { return new T; }

        static void Destroy(T* p)
        { delete p; }
    };


    template<template<class> class Alloc>
    struct CreateUsing
    {
        template <class T>
        struct Allocator
        {
            static Alloc<T> allocator;  

            static T* Create()
            {
                return new (allocator.allocate(1)) T;
            }

            static void Destroy(T* p)
            {
                //allocator.destroy(p);
                p->~T();
                allocator.deallocate(p,1);
            }
        };
    };


    template <class T> struct CreateUsingMalloc
    {
        static T* Create()
        {
            void* p = std::malloc(sizeof(T));
            if (!p) return 0;
            return new(p) T;
        }

        static void Destroy(T* p)
        {
            p->~T();
            std::free(p);
        }
    };



    template <class T> struct CreateStatic
    {
        union MaxAlign
        {
            char t_[sizeof(T)];             
            short int shortInt_;            
            int int_;                       
            long int longInt_;              
            float float_;                   
            double double_;                 
            long double longDouble_;        
            struct Test;
            int Test::* pMember_;           
            int (Test::*pMemberFn_)(int);   
        };

        static T* Create()
        {
            static MaxAlign staticMemory_;
            return new(&staticMemory_) T;
        }

        static void Destroy(T* p)
        {
            p->~T();
        }
    };



    template
    <
        typename T,
        template <class> class CreationPolicy = CreateUsingNew
    >
    class SingletonHolder
    {
    public:

        typedef T ObjectType;

        static T& Instance();

    private:
        // Helpers
        static void MakeInstance();         
        static void DestroySingleton();     

        // Protection
        SingletonHolder();

        // Data
        typedef T* PtrInstanceType;         
        static PtrInstanceType pInstance_;  
        static bool destroyed_;             
    };

    // SingletonHolder's data

    template
    <
        class T,
        template <class> class C
    >
    typename SingletonHolder<T, C>::PtrInstanceType
        SingletonHolder<T, C>::pInstance_ = 0;

    template
    <
        class T,
        template <class> class C
    >
    bool SingletonHolder<T, C>::destroyed_ = false;

    // SingletonHolder::Instance

    template
    <
        class T,
        template <class> class CreationPolicy
    >
    inline T& SingletonHolder<T, CreationPolicy>::Instance()
    {
        if (!pInstance_)
        {
            MakeInstance();
        }
        return *pInstance_;
    }

    // SingletonHolder::MakeInstance (helper for Instance)

    template
    <
        class T,
        template <class> class CreationPolicy
    >
    void SingletonHolder<T, CreationPolicy>::MakeInstance()
    {
        if (!pInstance_)
        {
            if (destroyed_)
            {
                destroyed_ = false;
            }
            pInstance_ = CreationPolicy<T>::Create();
        }
    }

    template
    <
        class T,
        template <class> class CreationPolicy
    >
    void
    SingletonHolder<T, CreationPolicy>::DestroySingleton()
    {
        assert(!destroyed_);
        CreationPolicy<T>::Destroy(pInstance_);
        pInstance_ = 0;
        destroyed_ = true;
    }



#ifndef LOKI_SINGLETON_EXPORT
#define LOKI_SINGLETON_EXPORT
#endif

    template<class T>
    class LOKI_SINGLETON_EXPORT Singleton
    {
    public:
        static T& Instance();   
    };

} // namespace Loki



#define LOKI_SINGLETON_INSTANCE_DEFINITION(SHOLDER)                     \
namespace Loki                                                          \
{                                                                        \
    template<>                                                          \
    SHOLDER::ObjectType&  Singleton<SHOLDER::ObjectType>::Instance()    \
    {                                                                   \
        return SHOLDER::Instance();                                     \
    }                                                                    \
}


#endif // end file guardian