Loki/Loki/Singleton.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 SINGLETON_INC_
#define SINGLETON_INC_

#include "Threads.h"
#include <algorithm>
#include <stdexcept>
#include <cassert>
#include <cstdlib>
#include <new>

namespace Loki
{
    namespace Private
    {
////////////////////////////////////////////////////////////////////////////////
// class LifetimeTracker
// Helper class for SetLongevity
////////////////////////////////////////////////////////////////////////////////

        class LifetimeTracker
        {
        public:
            LifetimeTracker(unsigned int x) : longevity_(x) 
            {}
            
            virtual ~LifetimeTracker() = 0;
            
            static bool Compare(const LifetimeTracker* lhs,
                const LifetimeTracker* rhs)
            {
                return lhs->longevity_ > rhs->longevity_;
            }
            
        private:
            unsigned int longevity_;
        };
        
        // Definition required
        inline LifetimeTracker::~LifetimeTracker() {} 
        
        // Helper data
        typedef LifetimeTracker** TrackerArray;
        extern TrackerArray pTrackerArray;
        extern unsigned int elements;

        // Helper destroyer function
        template <typename T>
        struct Deleter
        {
            static void Delete(T* pObj)
            { delete pObj; }
        };

        // Concrete lifetime tracker for objects of type T
        template <typename T, typename Destroyer>
        class ConcreteLifetimeTracker : public LifetimeTracker
        {
        public:
            ConcreteLifetimeTracker(T* p,unsigned int longevity, Destroyer d)
                : LifetimeTracker(longevity)
                , pTracked_(p)
                , destroyer_(d)
            {}
            
            ~ConcreteLifetimeTracker()
            { destroyer_(pTracked_); }
            
        private:
            T* pTracked_;
            Destroyer destroyer_;
        };

        void AtExitFn(); // declaration needed below
    
    } // namespace Private

////////////////////////////////////////////////////////////////////////////////
// function template SetLongevity
// Assigns an object a longevity; ensures ordered destructions of objects 
//     registered thusly during the exit sequence of the application
////////////////////////////////////////////////////////////////////////////////

    template <typename T, typename Destroyer>
    void SetLongevity(T* pDynObject, unsigned int longevity,
        Destroyer d = Private::Deleter<T>::Delete)
    {
        using namespace Private;
        
        TrackerArray pNewArray = static_cast<TrackerArray>(
                std::realloc(pTrackerArray, 
                    sizeof(*pTrackerArray) * (elements + 1)));
        if (!pNewArray) throw std::bad_alloc();
        
        // Delayed assignment for exception safety
        pTrackerArray = pNewArray;
        
        LifetimeTracker* p = new ConcreteLifetimeTracker<T, Destroyer>(
            pDynObject, longevity, d);
        
        // Insert a pointer to the object into the queue
        TrackerArray pos = std::upper_bound(
            pTrackerArray, 
            pTrackerArray + elements, 
            p, 
            LifetimeTracker::Compare);
        std::copy_backward(
            pos, 
            pTrackerArray + elements,
            pTrackerArray + elements + 1);
        *pos = p;
        ++elements;
        
        // Register a call to AtExitFn
        std::atexit(Private::AtExitFn);
    }

////////////////////////////////////////////////////////////////////////////////
// class template CreateUsingNew
// Implementation of the CreationPolicy used by SingletonHolder
// Creates objects using a straight call to the new operator 
////////////////////////////////////////////////////////////////////////////////

    template <class T> struct CreateUsingNew
    {
        static T* Create()
        { return new T; }
        
        static void Destroy(T* p)
        { delete p; }
    };
    
////////////////////////////////////////////////////////////////////////////////
// class template CreateUsingNew
// Implementation of the CreationPolicy used by SingletonHolder
// Creates objects using a call to std::malloc, followed by a call to the 
//     placement new operator
////////////////////////////////////////////////////////////////////////////////

    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);
        }
    };
    
////////////////////////////////////////////////////////////////////////////////
// class template CreateStatic
// Implementation of the CreationPolicy used by SingletonHolder
// Creates an object in static memory
// Implementation is slightly nonportable because it uses the MaxAlign trick 
//     (an union of all types to ensure proper memory alignment). This trick is 
//     nonportable in theory but highly portable in practice.
////////////////////////////////////////////////////////////////////////////////

    template <class T> struct CreateStatic
    {
#if defined(_MSC_VER) && _MSC_VER >= 1300
#pragma warning( push ) 
 // alignment of a member was sensitive to packing
#pragma warning( disable : 4121 )
#endif // _MSC_VER
        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);
        };
#if defined(_MSC_VER) && _MSC_VER >= 1300
#pragma warning( pop )
#endif // _MSC_VER
        
        static T* Create()
        {
            static MaxAlign staticMemory_;
            return new(&staticMemory_) T;
        }
        
        static void Destroy(T* p)
        {
            p->~T();
        }
    };
    
////////////////////////////////////////////////////////////////////////////////
// class template DefaultLifetime
// Implementation of the LifetimePolicy used by SingletonHolder
// Schedules an object's destruction as per C++ rules
// Forwards to std::atexit
////////////////////////////////////////////////////////////////////////////////

    template <class T>
    struct DefaultLifetime
    {
        static void ScheduleDestruction(T*, void (*pFun)())
        { std::atexit(pFun); }
        
        static void OnDeadReference()
        { throw std::logic_error("Dead Reference Detected"); }
    };

////////////////////////////////////////////////////////////////////////////////
// class template PhoenixSingleton
// Implementation of the LifetimePolicy used by SingletonHolder
// Schedules an object's destruction as per C++ rules, and it allows object 
//    recreation by not throwing an exception from OnDeadReference
////////////////////////////////////////////////////////////////////////////////

    template <class T>
    class PhoenixSingleton
    {
    public:
        static void ScheduleDestruction(T*, void (*pFun)())
        {
#ifndef ATEXIT_FIXED
            if (!destroyedOnce_)
#endif
                std::atexit(pFun);
        }
        
        static void OnDeadReference()
        {
#ifndef ATEXIT_FIXED
            destroyedOnce_ = true;
#endif
        }
        
    private:
#ifndef ATEXIT_FIXED
        static bool destroyedOnce_;
#endif
    };
    
#ifndef ATEXIT_FIXED
    template <class T> bool PhoenixSingleton<T>::destroyedOnce_ = false;
#endif
        
////////////////////////////////////////////////////////////////////////////////
// class template Adapter
// Helper for SingletonWithLongevity below
////////////////////////////////////////////////////////////////////////////////

    namespace Private
    {
        template <class T>
        struct Adapter
        {
            void operator()(T*) { return pFun_(); }
            void (*pFun_)();
        };
    }

////////////////////////////////////////////////////////////////////////////////
// class template SingletonWithLongevity
// Implementation of the LifetimePolicy used by SingletonHolder
// Schedules an object's destruction in order of their longevities
// Assumes a visible function GetLongevity(T*) that returns the longevity of the
//     object
////////////////////////////////////////////////////////////////////////////////

    template <class T>
    class SingletonWithLongevity
    {
    public:
        static void ScheduleDestruction(T* pObj, void (*pFun)())
        {
            Private::Adapter<T> adapter = { pFun };
            SetLongevity(pObj, GetLongevity(pObj), adapter);
        }
        
        static void OnDeadReference()
        { throw std::logic_error("Dead Reference Detected"); }
    };

////////////////////////////////////////////////////////////////////////////////
// class template NoDestroy
// Implementation of the LifetimePolicy used by SingletonHolder
// Never destroys the object
////////////////////////////////////////////////////////////////////////////////

    template <class T>
    struct NoDestroy
    {
        static void ScheduleDestruction(T*, void (*)())
        {}
        
        static void OnDeadReference()
        {}
    };

////////////////////////////////////////////////////////////////////////////////
// class template SingletonHolder
// Provides Singleton amenities for a type T
// To protect that type from spurious instantiations, you have to protect it
//     yourself.
////////////////////////////////////////////////////////////////////////////////

    template
    <
        typename T,
        template <class> class CreationPolicy = CreateUsingNew,
        template <class> class LifetimePolicy = DefaultLifetime,
        template <class> class ThreadingModel = SingleThreaded
    >
    class SingletonHolder
    {
    public:
        static T& Instance();
        
    private:
        // Helpers
        static void MakeInstance();
        static void DestroySingleton();
        
        // Protection
        SingletonHolder();
        
        // Data
        typedef typename ThreadingModel<T*>::VolatileType PtrInstanceType;
        static PtrInstanceType pInstance_;
        static bool destroyed_;
    };
    
////////////////////////////////////////////////////////////////////////////////
// SingletonHolder's data
////////////////////////////////////////////////////////////////////////////////

    template
    <
        class T,
        template <class> class C,
        template <class> class L,
        template <class> class M
    >
    typename SingletonHolder<T, C, L, M>::PtrInstanceType
        SingletonHolder<T, C, L, M>::pInstance_;

    template
    <
        class T,
        template <class> class C,
        template <class> class L,
        template <class> class M
    >
    bool SingletonHolder<T, C, L, M>::destroyed_;

////////////////////////////////////////////////////////////////////////////////
// SingletonHolder::Instance
////////////////////////////////////////////////////////////////////////////////

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

////////////////////////////////////////////////////////////////////////////////
// SingletonHolder::MakeInstance (helper for Instance)
////////////////////////////////////////////////////////////////////////////////

    template
    <
        class T,
        template <class> class CreationPolicy,
        template <class> class LifetimePolicy,
        template <class> class ThreadingModel
    >
    void SingletonHolder<T, CreationPolicy, 
        LifetimePolicy, ThreadingModel>::MakeInstance()
    {
        typename ThreadingModel<T>::Lock guard;
        (void)guard;
        
        if (!pInstance_)
        {
            if (destroyed_)
            {
                LifetimePolicy<T>::OnDeadReference();
                destroyed_ = false;
            }
            pInstance_ = CreationPolicy<T>::Create();
            LifetimePolicy<T>::ScheduleDestruction(pInstance_, 
                &DestroySingleton);
        }
    }

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

////////////////////////////////////////////////////////////////////////////////
// Change log:
// May 21, 2001: Correct the volatile qualifier - credit due to Darin Adler
// June 20, 2001: ported by Nick Thurn to gcc 2.95.3. Kudos, Nick!!!
// January 08, 2002: Fixed bug in call to realloc - credit due to Nigel Gent and
//      Eike Petersen
// March 08, 2002: moved the assignment to pTrackerArray in SetLongevity to fix
//      exception safety issue. Credit due to Kari Hoijarvi
// May 09, 2002: Fixed bug in Compare that caused longevities to act backwards.
//      Credit due to Scott McDonald.
////////////////////////////////////////////////////////////////////////////////

#endif // SINGLETON_INC_
Revision:	4
Committed:	Tue Jun 12 19:51:29 2007 UTC (18 years, 2 months ago)
Content type:	text/plain
File size:	15018 byte(s)
Log Message:
#	Content
1	////////////////////////////////////////////////////////////////////////////////
2	// The Loki Library
3	// Copyright (c) 2001 by Andrei Alexandrescu
4	// This code accompanies the book:
5	// Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design
6	// Patterns Applied". Copyright (c) 2001. Addison-Wesley.
7	// Permission to use, copy, modify, distribute and sell this software for any
8	// purpose is hereby granted without fee, provided that the above copyright
9	// notice appear in all copies and that both that copyright notice and this
10	// permission notice appear in supporting documentation.
11	// The author or Addison-Wesley Longman make no representations about the
12	// suitability of this software for any purpose. It is provided "as is"
13	// without express or implied warranty.
14	////////////////////////////////////////////////////////////////////////////////
15
16	#ifndef SINGLETON_INC_
17	#define SINGLETON_INC_
18
19	#include "Threads.h"
20	#include <algorithm>
21	#include <stdexcept>
22	#include <cassert>
23	#include <cstdlib>
24	#include <new>
25
26	namespace Loki
27	{
28	namespace Private
29	{
30	////////////////////////////////////////////////////////////////////////////////
31	// class LifetimeTracker
32	// Helper class for SetLongevity
33	////////////////////////////////////////////////////////////////////////////////
34
35	class LifetimeTracker
36	{
37	public:
38	LifetimeTracker(unsigned int x) : longevity_(x)
39	{}
40
41	virtual ~LifetimeTracker() = 0;
42
43	static bool Compare(const LifetimeTracker* lhs,
44	const LifetimeTracker* rhs)
45	{
46	return lhs->longevity_ > rhs->longevity_;
47	}
48
49	private:
50	unsigned int longevity_;
51	};
52
53	// Definition required
54	inline LifetimeTracker::~LifetimeTracker() {}
55
56	// Helper data
57	typedef LifetimeTracker** TrackerArray;
58	extern TrackerArray pTrackerArray;
59	extern unsigned int elements;
60
61	// Helper destroyer function
62	template <typename T>
63	struct Deleter
64	{
65	static void Delete(T* pObj)
66	{ delete pObj; }
67	};
68
69	// Concrete lifetime tracker for objects of type T
70	template <typename T, typename Destroyer>
71	class ConcreteLifetimeTracker : public LifetimeTracker
72	{
73	public:
74	ConcreteLifetimeTracker(T* p,unsigned int longevity, Destroyer d)
75	: LifetimeTracker(longevity)
76	, pTracked_(p)
77	, destroyer_(d)
78	{}
79
80	~ConcreteLifetimeTracker()
81	{ destroyer_(pTracked_); }
82
83	private:
84	T* pTracked_;
85	Destroyer destroyer_;
86	};
87
88	void AtExitFn(); // declaration needed below
89
90	} // namespace Private
91
92	////////////////////////////////////////////////////////////////////////////////
93	// function template SetLongevity
94	// Assigns an object a longevity; ensures ordered destructions of objects
95	// registered thusly during the exit sequence of the application
96	////////////////////////////////////////////////////////////////////////////////
97
98	template <typename T, typename Destroyer>
99	void SetLongevity(T* pDynObject, unsigned int longevity,
100	Destroyer d = Private::Deleter<T>::Delete)
101	{
102	using namespace Private;
103
104	TrackerArray pNewArray = static_cast<TrackerArray>(
105	std::realloc(pTrackerArray,
106	sizeof(pTrackerArray) (elements + 1)));
107	if (!pNewArray) throw std::bad_alloc();
108
109	// Delayed assignment for exception safety
110	pTrackerArray = pNewArray;
111
112	LifetimeTracker* p = new ConcreteLifetimeTracker<T, Destroyer>(
113	pDynObject, longevity, d);
114
115	// Insert a pointer to the object into the queue
116	TrackerArray pos = std::upper_bound(
117	pTrackerArray,
118	pTrackerArray + elements,
119	p,
120	LifetimeTracker::Compare);
121	std::copy_backward(
122	pos,
123	pTrackerArray + elements,
124	pTrackerArray + elements + 1);
125	*pos = p;
126	++elements;
127
128	// Register a call to AtExitFn
129	std::atexit(Private::AtExitFn);
130	}
131
132	////////////////////////////////////////////////////////////////////////////////
133	// class template CreateUsingNew
134	// Implementation of the CreationPolicy used by SingletonHolder
135	// Creates objects using a straight call to the new operator
136	////////////////////////////////////////////////////////////////////////////////
137
138	template <class T> struct CreateUsingNew
139	{
140	static T* Create()
141	{ return new T; }
142
143	static void Destroy(T* p)
144	{ delete p; }
145	};
146
147	////////////////////////////////////////////////////////////////////////////////
148	// class template CreateUsingNew
149	// Implementation of the CreationPolicy used by SingletonHolder
150	// Creates objects using a call to std::malloc, followed by a call to the
151	// placement new operator
152	////////////////////////////////////////////////////////////////////////////////
153
154	template <class T> struct CreateUsingMalloc
155	{
156	static T* Create()
157	{
158	void* p = std::malloc(sizeof(T));
159	if (!p) return 0;
160	return new(p) T;
161	}
162
163	static void Destroy(T* p)
164	{
165	p->~T();
166	std::free(p);
167	}
168	};
169
170	////////////////////////////////////////////////////////////////////////////////
171	// class template CreateStatic
172	// Implementation of the CreationPolicy used by SingletonHolder
173	// Creates an object in static memory
174	// Implementation is slightly nonportable because it uses the MaxAlign trick
175	// (an union of all types to ensure proper memory alignment). This trick is
176	// nonportable in theory but highly portable in practice.
177	////////////////////////////////////////////////////////////////////////////////
178
179	template <class T> struct CreateStatic
180	{
181	#if defined(_MSC_VER) && _MSC_VER >= 1300
182	#pragma warning( push )
183	// alignment of a member was sensitive to packing
184	#pragma warning( disable : 4121 )
185	#endif // _MSC_VER
186	union MaxAlign
187	{
188	char t_[sizeof(T)];
189	short int shortInt_;
190	int int_;
191	long int longInt_;
192	float float_;
193	double double_;
194	long double longDouble_;
195	struct Test;
196	int Test::* pMember_;
197	int (Test::*pMemberFn_)(int);
198	};
199	#if defined(_MSC_VER) && _MSC_VER >= 1300
200	#pragma warning( pop )
201	#endif // _MSC_VER
202
203	static T* Create()
204	{
205	static MaxAlign staticMemory_;
206	return new(&staticMemory_) T;
207	}
208
209	static void Destroy(T* p)
210	{
211	p->~T();
212	}
213	};
214
215	////////////////////////////////////////////////////////////////////////////////
216	// class template DefaultLifetime
217	// Implementation of the LifetimePolicy used by SingletonHolder
218	// Schedules an object's destruction as per C++ rules
219	// Forwards to std::atexit
220	////////////////////////////////////////////////////////////////////////////////
221
222	template <class T>
223	struct DefaultLifetime
224	{
225	static void ScheduleDestruction(T, void (pFun)())
226	{ std::atexit(pFun); }
227
228	static void OnDeadReference()
229	{ throw std::logic_error("Dead Reference Detected"); }
230	};
231
232	////////////////////////////////////////////////////////////////////////////////
233	// class template PhoenixSingleton
234	// Implementation of the LifetimePolicy used by SingletonHolder
235	// Schedules an object's destruction as per C++ rules, and it allows object
236	// recreation by not throwing an exception from OnDeadReference
237	////////////////////////////////////////////////////////////////////////////////
238
239	template <class T>
240	class PhoenixSingleton
241	{
242	public:
243	static void ScheduleDestruction(T, void (pFun)())
244	{
245	#ifndef ATEXIT_FIXED
246	if (!destroyedOnce_)
247	#endif
248	std::atexit(pFun);
249	}
250
251	static void OnDeadReference()
252	{
253	#ifndef ATEXIT_FIXED
254	destroyedOnce_ = true;
255	#endif
256	}
257
258	private:
259	#ifndef ATEXIT_FIXED
260	static bool destroyedOnce_;
261	#endif
262	};
263
264	#ifndef ATEXIT_FIXED
265	template <class T> bool PhoenixSingleton<T>::destroyedOnce_ = false;
266	#endif
267
268	////////////////////////////////////////////////////////////////////////////////
269	// class template Adapter
270	// Helper for SingletonWithLongevity below
271	////////////////////////////////////////////////////////////////////////////////
272
273	namespace Private
274	{
275	template <class T>
276	struct Adapter
277	{
278	void operator()(T*) { return pFun_(); }
279	void (*pFun_)();
280	};
281	}
282
283	////////////////////////////////////////////////////////////////////////////////
284	// class template SingletonWithLongevity
285	// Implementation of the LifetimePolicy used by SingletonHolder
286	// Schedules an object's destruction in order of their longevities
287	// Assumes a visible function GetLongevity(T*) that returns the longevity of the
288	// object
289	////////////////////////////////////////////////////////////////////////////////
290
291	template <class T>
292	class SingletonWithLongevity
293	{
294	public:
295	static void ScheduleDestruction(T* pObj, void (*pFun)())
296	{
297	Private::Adapter<T> adapter = { pFun };
298	SetLongevity(pObj, GetLongevity(pObj), adapter);
299	}
300
301	static void OnDeadReference()
302	{ throw std::logic_error("Dead Reference Detected"); }
303	};
304
305	////////////////////////////////////////////////////////////////////////////////
306	// class template NoDestroy
307	// Implementation of the LifetimePolicy used by SingletonHolder
308	// Never destroys the object
309	////////////////////////////////////////////////////////////////////////////////
310
311	template <class T>
312	struct NoDestroy
313	{
314	static void ScheduleDestruction(T, void ()())
315	{}
316
317	static void OnDeadReference()
318	{}
319	};
320
321	////////////////////////////////////////////////////////////////////////////////
322	// class template SingletonHolder
323	// Provides Singleton amenities for a type T
324	// To protect that type from spurious instantiations, you have to protect it
325	// yourself.
326	////////////////////////////////////////////////////////////////////////////////
327
328	template
329	<
330	typename T,
331	template <class> class CreationPolicy = CreateUsingNew,
332	template <class> class LifetimePolicy = DefaultLifetime,
333	template <class> class ThreadingModel = SingleThreaded
334	>
335	class SingletonHolder
336	{
337	public:
338	static T& Instance();
339
340	private:
341	// Helpers
342	static void MakeInstance();
343	static void DestroySingleton();
344
345	// Protection
346	SingletonHolder();
347
348	// Data
349	typedef typename ThreadingModel<T*>::VolatileType PtrInstanceType;
350	static PtrInstanceType pInstance_;
351	static bool destroyed_;
352	};
353
354	////////////////////////////////////////////////////////////////////////////////
355	// SingletonHolder's data
356	////////////////////////////////////////////////////////////////////////////////
357
358	template
359	<
360	class T,
361	template <class> class C,
362	template <class> class L,
363	template <class> class M
364	>
365	typename SingletonHolder<T, C, L, M>::PtrInstanceType
366	SingletonHolder<T, C, L, M>::pInstance_;
367
368	template
369	<
370	class T,
371	template <class> class C,
372	template <class> class L,
373	template <class> class M
374	>
375	bool SingletonHolder<T, C, L, M>::destroyed_;
376
377	////////////////////////////////////////////////////////////////////////////////
378	// SingletonHolder::Instance
379	////////////////////////////////////////////////////////////////////////////////
380
381	template
382	<
383	class T,
384	template <class> class CreationPolicy,
385	template <class> class LifetimePolicy,
386	template <class> class ThreadingModel
387	>
388	inline T& SingletonHolder<T, CreationPolicy,
389	LifetimePolicy, ThreadingModel>::Instance()
390	{
391	if (!pInstance_)
392	{
393	MakeInstance();
394	}
395	return *pInstance_;
396	}
397
398	////////////////////////////////////////////////////////////////////////////////
399	// SingletonHolder::MakeInstance (helper for Instance)
400	////////////////////////////////////////////////////////////////////////////////
401
402	template
403	<
404	class T,
405	template <class> class CreationPolicy,
406	template <class> class LifetimePolicy,
407	template <class> class ThreadingModel
408	>
409	void SingletonHolder<T, CreationPolicy,
410	LifetimePolicy, ThreadingModel>::MakeInstance()
411	{
412	typename ThreadingModel<T>::Lock guard;
413	(void)guard;
414
415	if (!pInstance_)
416	{
417	if (destroyed_)
418	{
419	LifetimePolicy<T>::OnDeadReference();
420	destroyed_ = false;
421	}
422	pInstance_ = CreationPolicy<T>::Create();
423	LifetimePolicy<T>::ScheduleDestruction(pInstance_,
424	&DestroySingleton);
425	}
426	}
427
428	template
429	<
430	class T,
431	template <class> class CreationPolicy,
432	template <class> class L,
433	template <class> class M
434	>
435	void SingletonHolder<T, CreationPolicy, L, M>::DestroySingleton()
436	{
437	assert(!destroyed_);
438	CreationPolicy<T>::Destroy(pInstance_);
439	pInstance_ = 0;
440	destroyed_ = true;
441	}
442	} // namespace Loki
443
444	////////////////////////////////////////////////////////////////////////////////
445	// Change log:
446	// May 21, 2001: Correct the volatile qualifier - credit due to Darin Adler
447	// June 20, 2001: ported by Nick Thurn to gcc 2.95.3. Kudos, Nick!!!
448	// January 08, 2002: Fixed bug in call to realloc - credit due to Nigel Gent and
449	// Eike Petersen
450	// March 08, 2002: moved the assignment to pTrackerArray in SetLongevity to fix
451	// exception safety issue. Credit due to Kari Hoijarvi
452	// May 09, 2002: Fixed bug in Compare that caused longevities to act backwards.
453	// Credit due to Scott McDonald.
454	////////////////////////////////////////////////////////////////////////////////
455
456	#endif // SINGLETON_INC_