4.1

1 files changed, 0 insertions, 889 deletions

diff --git a/shared/loki/Singleton.h b/shared/loki/Singleton.h
deleted file mode 100644
index 1e479032..00000000
--- a/shared/loki/Singleton.h
+++ /dev/null
@@ -1,889 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////
-// 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: Singleton.h 834 2007-08-02 19:36:10Z syntheticpp $
-
-
-#include "LokiExport.h"
-#include "Threads.h"
-#include <algorithm>
-#include <stdexcept>
-#include <cassert>
-#include <cstdlib>
-#include <new>
-#include <vector>
-#include <list>
-#include <memory>
-
-#ifdef _MSC_VER
-#define LOKI_C_CALLING_CONVENTION_QUALIFIER __cdecl
-#else
-#define LOKI_C_CALLING_CONVENTION_QUALIFIER
-#endif
-
-///  \defgroup  SingletonGroup Singleton
-///  \defgroup  CreationGroup Creation policies
-///  \ingroup   SingletonGroup
-///  \defgroup  LifetimeGroup Lifetime policies
-///  \ingroup   SingletonGroup
-///  The lifetimes of the singleton.
-///  \par Special lifetime for SmallObjects
-///  When the holded object is a Small(Value)Object or the holded object
-///  uses objects which are or inherit from Small(Value)Object
-///  then you can't use the default lifetime: you must use the lifetime
-///  \code Loki::LongevityLifetime::DieAsSmallObjectChild \endcode
-///  Be aware of this when you use Loki::Factory, Loki::Functor, or Loki::Function.
-
-
-
-namespace Loki
-{
-typedef void (LOKI_C_CALLING_CONVENTION_QUALIFIER* atexit_pfn_t)();
-
-namespace Private
-{
-
-#ifndef LOKI_MAKE_DLL
-void LOKI_C_CALLING_CONVENTION_QUALIFIER AtExitFn(); // declaration needed below
-#else
-void LOKI_EXPORT AtExitFn();
-#endif
-
-class LifetimeTracker;
-
-#define LOKI_ENABLE_NEW_SETLONGLIVITY_HELPER_DATA_IMPL
-#ifdef LOKI_ENABLE_NEW_SETLONGLIVITY_HELPER_DATA_IMPL
-
-// Helper data
-// std::list because of the inserts
-typedef std::list<LifetimeTracker*> TrackerArray;
-extern LOKI_EXPORT TrackerArray* pTrackerArray;
-#else
-// Helper data
-typedef LifetimeTracker** TrackerArray;
-extern TrackerArray pTrackerArray;
-extern unsigned int elements;
-#endif
-
-////////////////////////////////////////////////////////////////////////////////
-// 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 destroyer function
-template <typename T>
-struct Deleter
-{
-    typedef void (*Type)(T*);
-    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_;
-};
-
-} // namespace Private
-
-////////////////////////////////////////////////////////////////////////////////
-///  \ingroup LifetimeGroup
-///
-///  Assigns an object a longevity; ensures ordered destructions of objects
-///  registered thusly during the exit sequence of the application
-////////////////////////////////////////////////////////////////////////////////
-
-#ifdef LOKI_ENABLE_NEW_SETLONGLIVITY_HELPER_DATA_IMPL
-
-template <typename T, typename Destroyer>
-void SetLongevity(T* pDynObject, unsigned int longevity,
-                  Destroyer d)
-{
-    using namespace Private;
-
-    // manage lifetime of stack manually
-    if (pTrackerArray == 0)
-        pTrackerArray = new TrackerArray;
-
-    // automatically delete the ConcreteLifetimeTracker object when a exception is thrown
-    std::auto_ptr<LifetimeTracker>
-    p( new ConcreteLifetimeTracker<T, Destroyer>(pDynObject, longevity, d) );
-
-    // Find correct position
-    TrackerArray::iterator pos = std::upper_bound(
-                                     pTrackerArray->begin(),
-                                     pTrackerArray->end(),
-                                     p.get(),
-                                     LifetimeTracker::Compare);
-
-    // Insert the pointer to the ConcreteLifetimeTracker object into the queue
-    pTrackerArray->insert(pos, p.get());
-
-    // nothing has thrown: don't delete the ConcreteLifetimeTracker object
-    p.release();
-
-    // Register a call to AtExitFn
-    std::atexit(Private::AtExitFn);
-}
-
-#else
-
-template <typename T, typename Destroyer>
-void SetLongevity(T* pDynObject, unsigned int longevity,
-                  Destroyer d)
-{
-    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);
-}
-
-#endif
-
-template <typename T>
-void SetLongevity(T* pDynObject, unsigned int longevity,
-                  typename Private::Deleter<T>::Type d = Private::Deleter<T>::Delete)
-{
-    SetLongevity<T, typename Private::Deleter<T>::Type>(pDynObject, longevity, d);
-}
-
-////////////////////////////////////////////////////////////////////////////////
-///  \struct CreateUsingNew
-///
-///  \ingroup CreationGroup
-///  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; }
-};
-
-////////////////////////////////////////////////////////////////////////////////
-///  \struct CreateUsing
-///
-///  \ingroup CreationGroup
-///  Implementation of the CreationPolicy used by SingletonHolder
-///  Creates objects using a custom allocater.
-///  Usage: e.g. CreateUsing<std::allocator>::Allocator
-////////////////////////////////////////////////////////////////////////////////
-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);
-        }
-    };
-};
-
-////////////////////////////////////////////////////////////////////////////////
-///  \struct CreateUsingMalloc
-///
-///  \ingroup CreationGroup
-///  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);
-    }
-};
-
-
-////////////////////////////////////////////////////////////////////////////////
-///  \struct CreateStatic
-///
-///  \ingroup CreationGroup
-///  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
-{
-
-#ifdef _MSC_VER
-#pragma warning( push )
-#pragma warning( disable : 4121 )
-    // alignment of a member was sensitive to packing
-#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);
-    };
-
-#ifdef _MSC_VER
-#pragma warning( pop )
-#endif // _MSC_VER
-
-    static T* Create()
-    {
-        static MaxAlign staticMemory_;
-        return new(&staticMemory_) T;
-    }
-
-    static void Destroy(T* p)
-    {
-        p->~T();
-    }
-};
-
-////////////////////////////////////////////////////////////////////////////////
-///  \struct DefaultLifetime
-///
-///  \ingroup LifetimeGroup
-///  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*, atexit_pfn_t pFun)
-    { std::atexit(pFun); }
-
-    static void OnDeadReference()
-    { throw std::logic_error("Dead Reference Detected"); }
-};
-
-////////////////////////////////////////////////////////////////////////////////
-///  \struct  PhoenixSingleton
-///
-///  \ingroup LifetimeGroup
-///  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*, atexit_pfn_t 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
-
-////////////////////////////////////////////////////////////////////////////////
-// Copyright (c) 2004 by Curtis Krauskopf - curtis@decompile.com
-///
-///  \struct  DeletableSingleton
-///
-///  \ingroup LifetimeGroup
-///
-///  A DeletableSingleton allows the instantiated singleton to be
-///  destroyed at any time. The singleton can be reinstantiated at
-///  any time, even during program termination.
-///  If the singleton exists when the program terminates, it will
-///  be automatically deleted.
-///
-///  \par Usage:
-///  The singleton can be deleted manually:
-///
-///  DeletableSingleton<MyClass>::GracefulDelete();
-////////////////////////////////////////////////////////////////////////////////
-template <class T>
-class DeletableSingleton
-{
-public:
-
-    static void ScheduleDestruction(T*, atexit_pfn_t pFun)
-    {
-        static bool firstPass = true;
-        isDead = false;
-        deleter = pFun;
-        if (firstPass || needCallback)
-        {
-            std::atexit(atexitCallback);
-            firstPass = false;
-            needCallback = false;
-        }
-    }
-
-    static void OnDeadReference()
-    {
-    }
-    ///  delete singleton object manually
-    static void GracefulDelete()
-    {
-        if (isDead)
-            return;
-        isDead = true;
-        deleter();
-    }
-
-protected:
-    static atexit_pfn_t deleter;
-    static bool isDead;
-    static bool needCallback;
-
-    static void atexitCallback()
-    {
-#ifdef ATEXIT_FIXED
-        needCallback = true;
-#else
-        needCallback = false;
-#endif
-        GracefulDelete();
-    }
-};
-
-template <class T>
-atexit_pfn_t DeletableSingleton<T>::deleter = 0;
-
-template <class T>
-bool DeletableSingleton<T>::isDead = true;
-
-template <class T>
-bool DeletableSingleton<T>::needCallback = true;
-
-////////////////////////////////////////////////////////////////////////////////
-// class template Adapter
-// Helper for SingletonWithLongevity below
-////////////////////////////////////////////////////////////////////////////////
-
-namespace Private
-{
-template <class T>
-struct Adapter
-{
-    void operator()(T*) { return pFun_(); }
-    atexit_pfn_t pFun_;
-};
-}
-
-////////////////////////////////////////////////////////////////////////////////
-///  \struct SingletonWithLongevity
-///
-///  \ingroup LifetimeGroup
-///  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, atexit_pfn_t pFun)
-    {
-        Private::Adapter<T> adapter = { pFun };
-        SetLongevity(pObj, GetLongevity(pObj), adapter);
-    }
-
-    static void OnDeadReference()
-    { throw std::logic_error("Dead Reference Detected"); }
-};
-
-////////////////////////////////////////////////////////////////////////////////
-///  \struct NoDestroy
-///
-///  \ingroup LifetimeGroup
-///  Implementation of the LifetimePolicy used by SingletonHolder
-///  Never destroys the object
-////////////////////////////////////////////////////////////////////////////////
-template <class T>
-struct NoDestroy
-{
-    static void ScheduleDestruction(T*, atexit_pfn_t)
-    {}
-
-    static void OnDeadReference()
-    {}
-};
-
-
-////////////////////////////////////////////////////////////////////////////////
-///  \defgroup LongevityLifetimeGroup LongevityLifetime
-///  \ingroup LifetimeGroup
-///
-///  \namespace LongevityLifetime
-///
-///  \ingroup LongevityLifetimeGroup
-///  \brief  In this namespace are special lifetime policies to manage lifetime
-///  dependencies.
-////////////////////////////////////////////////////////////////////////////////
-namespace LongevityLifetime
-{
-////////////////////////////////////////////////////////////////////////////////
-///  \struct  SingletonFixedLongevity
-///
-///  \ingroup LongevityLifetimeGroup
-///  Add your own lifetimes into the namespace 'LongevityLifetime'
-///  with your prefered lifetime by adding a struct like this:
-///
-///  template<class T>
-///  struct MyLifetime  : SingletonFixedLongevity< MyLifetimeNumber ,T> {}
-////////////////////////////////////////////////////////////////////////////////
-template <unsigned int Longevity, class T>
-class SingletonFixedLongevity
-{
-public:
-    virtual ~SingletonFixedLongevity() {}
-
-    static void ScheduleDestruction(T* pObj, atexit_pfn_t pFun)
-    {
-        Private::Adapter<T> adapter = { pFun };
-        SetLongevity(pObj, Longevity , adapter);
-    }
-
-    static void OnDeadReference()
-    { throw std::logic_error("Dead Reference Detected"); }
-};
-
-///  \struct DieLast
-///  \ingroup LongevityLifetimeGroup
-///  \brief  Longest possible SingletonWithLongevity lifetime: 0xFFFFFFFF
-template <class T>
-struct DieLast  : SingletonFixedLongevity<0xFFFFFFFF , T>
-{};
-
-///  \struct DieDirectlyBeforeLast
-///  \ingroup LongevityLifetimeGroup
-///  \brief  Lifetime is a one less than DieLast: 0xFFFFFFFF-1
-template <class T>
-struct DieDirectlyBeforeLast  : SingletonFixedLongevity < 0xFFFFFFFF - 1 , T >
-{};
-
-///  \struct DieFirst
-///  \ingroup LongevityLifetimeGroup
-///  \brief  Shortest possible SingletonWithLongevity lifetime: 0
-template <class T>
-struct DieFirst : SingletonFixedLongevity<0, T>
-{};
-
-}//namespace LongevityLifetime
-
-////////////////////////////////////////////////////////////////////////////////
-///  \class FollowIntoDeath
-///
-///  \ingroup LifetimeGroup
-///
-///  Lifetime policyfor the SingletonHolder tempalte.
-///  Followers will die after the master dies Followers will not die, if
-///    - master never dies (NoDestroy policy)
-///    - master never created
-///    - master dies not in the function registered with atexit
-///    - master dies not by a call of a the atexit registerd function (DeletableSingleton::GracefulDelete)
-///
-///  \par Usage:
-///
-///  Lifetimes of the master and the follower singletons,  e.g. with a M and a F class:
-///   \code SingletonHolder< M , FollowIntoDeath::With<DefaultLifetime>::AsMasterLifetime > MasterSingleton; \endcode
-///   \code SingletonHolder< F , CreateUsingNew, FollowIntoDeath::AfterMaster< MasterSingleton >::IsDestroyed > FollowerSingleton \endcode
-////////////////////////////////////////////////////////////////////////////////
-class FollowIntoDeath
-{
-    template<class T>
-    class Followers
-    {
-        typedef std::vector<atexit_pfn_t> Container;
-        typedef typename Container::iterator iterator;
-        static Container* followers_;
-
-    public:
-        static void Init()
-        {
-            static bool done = false;
-            if (!done)
-            {
-                followers_ = new Container;
-                done = true;
-            }
-        }
-
-        static void AddFollower(atexit_pfn_t ae)
-        {
-            Init();
-            followers_->push_back(ae);
-        }
-
-        static void DestroyFollowers()
-        {
-            Init();
-            for (iterator it = followers_->begin(); it != followers_->end(); ++it)
-                (*it)();
-            delete followers_;
-        }
-    };
-
-public:
-
-    ///  \struct With
-    ///  Template for the master
-    ///  \param Lifetime Lifetime policy for the master
-    template<template <class> class Lifetime>
-    struct With
-    {
-        ///  \struct AsMasterLifetime
-        ///  Policy for master
-        template<class Master>
-        struct AsMasterLifetime
-        {
-            static void ScheduleDestruction(Master* pObj, atexit_pfn_t pFun)
-            {
-                Followers<Master>::Init();
-                Lifetime<Master>::ScheduleDestruction(pObj, pFun);
-
-                // use same policy for the followers and force a new
-                // template instantiation,  this adds a additional atexit entry
-                // does not work with SetLonlevity, but there you can control
-                // the lifetime with the GetLongevity function.
-                Lifetime<Followers<Master> >::ScheduleDestruction(0, Followers<Master>::DestroyFollowers);
-            }
-
-            static void OnDeadReference()
-            {
-                throw std::logic_error("Dead Reference Detected");
-            }
-        };
-    };
-
-    ///  \struct AfterMaster
-    ///  Template for the follower
-    ///  \param Master Master to follow into death
-    template<class Master>
-    struct AfterMaster
-    {
-        ///  \struct IsDestroyed
-        ///  Policy for followers
-        template<class F>
-        struct IsDestroyed
-        {
-            static void ScheduleDestruction(F*, atexit_pfn_t pFun)
-            {
-                Followers<Master>::AddFollower(pFun);
-            }
-
-            static void OnDeadReference()
-            {
-                throw std::logic_error("Dead Reference Detected");
-            }
-        };
-    };
-};
-
-template<class T>
-typename FollowIntoDeath::Followers<T>::Container*
-FollowIntoDeath::Followers<T>::followers_ = 0;
-
-
-
-////////////////////////////////////////////////////////////////////////////////
-///  \class  SingletonHolder
-///
-///  \ingroup SingletonGroup
-///
-///  Provides Singleton amenities for a type T
-///  To protect that type from spurious instantiations,
-///  you have to protect it yourself.
-///
-///  \param CreationPolicy Creation policy, default: CreateUsingNew
-///  \param LifetimePolicy Lifetime policy, default: DefaultLifetime,
-///  \param ThreadingModel Threading policy,
-///                         default: LOKI_DEFAULT_THREADING_NO_OBJ_LEVEL
-////////////////////////////////////////////////////////////////////////////////
-template
-<
-typename T,
-         template <class> class CreationPolicy = CreateUsingNew,
-         template <class> class LifetimePolicy = DefaultLifetime,
-         template <class, class> class ThreadingModel = LOKI_DEFAULT_THREADING_NO_OBJ_LEVEL,
-         class MutexPolicy = LOKI_DEFAULT_MUTEX
-         >
-class SingletonHolder
-{
-public:
-
-    ///  Type of the singleton object
-    typedef T ObjectType;
-
-    ///  Returns a reference to singleton object
-    static T& Instance();
-
-private:
-    // Helpers
-    static void MakeInstance();
-    static void LOKI_C_CALLING_CONVENTION_QUALIFIER DestroySingleton();
-
-    // Protection
-    SingletonHolder();
-
-    // Data
-    typedef typename ThreadingModel<T*, MutexPolicy>::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> class M,
-      class X
-      >
-typename SingletonHolder<T, C, L, M, X>::PtrInstanceType
-SingletonHolder<T, C, L, M, X>::pInstance_ = 0;
-
-template
-<
-class T,
-      template <class> class C,
-      template <class> class L,
-      template <class, class> class M,
-      class X
-      >
-bool SingletonHolder<T, C, L, M, X>::destroyed_ = false;
-
-////////////////////////////////////////////////////////////////////////////////
-// SingletonHolder::Instance
-////////////////////////////////////////////////////////////////////////////////
-
-template
-<
-class T,
-      template <class> class CreationPolicy,
-      template <class> class LifetimePolicy,
-      template <class, class> class ThreadingModel,
-      class MutexPolicy
-      >
-inline T& SingletonHolder < T, CreationPolicy,
-       LifetimePolicy, ThreadingModel, MutexPolicy >::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> class ThreadingModel,
-class MutexPolicy
->
-void SingletonHolder < T, CreationPolicy,
-     LifetimePolicy, ThreadingModel, MutexPolicy >::MakeInstance()
-{
-    typename ThreadingModel<SingletonHolder, MutexPolicy>::Lock guard;
-    (void)guard;
-
-    if (!pInstance_)
-    {
-        if (destroyed_)
-        {
-            destroyed_ = false;
-            LifetimePolicy<T>::OnDeadReference();
-        }
-        pInstance_ = CreationPolicy<T>::Create();
-        LifetimePolicy<T>::ScheduleDestruction(pInstance_,
-                                               &DestroySingleton);
-    }
-}
-
-template
-<
-class T,
-template <class> class CreationPolicy,
-template <class> class L,
-template <class, class> class M,
-class X
->
-void LOKI_C_CALLING_CONVENTION_QUALIFIER
-SingletonHolder<T, CreationPolicy, L, M, X>::DestroySingleton()
-{
-    assert(!destroyed_);
-    CreationPolicy<T>::Destroy(pInstance_);
-    pInstance_ = 0;
-    destroyed_ = true;
-}
-
-
-////////////////////////////////////////////////////////////////////////////////
-///  \class  Singleton
-///
-///  \ingroup SingletonGroup
-///
-///  Convenience template to implement a getter function for a singleton object.
-///  Often needed in a shared library which hosts singletons.
-///
-///  \par Usage
-///
-///  see test/SingletonDll
-///
-////////////////////////////////////////////////////////////////////////////////
-
-#ifndef LOKI_SINGLETON_EXPORT
-#define LOKI_SINGLETON_EXPORT
-#endif
-
-template<class T>
-class LOKI_SINGLETON_EXPORT Singleton
-{
-public:
-    static T& Instance();
-};
-
-} // namespace Loki
-
-
-/// \def LOKI_SINGLETON_INSTANCE_DEFINITION(SHOLDER)
-/// Convenience macro for the definition of the static Instance member function
-/// Put this macro called with a SingletonHolder typedef into your cpp file.
-
-#define LOKI_SINGLETON_INSTANCE_DEFINITION(SHOLDER)                     \
-    namespace Loki                                                          \
-    {                                                                        \
-    template<>                                                          \
-    SHOLDER::ObjectType&  Singleton<SHOLDER::ObjectType>::Instance()    \
-    {                                                                   \
-        return SHOLDER::Instance();                                     \
-    }                                                                    \
-    }
-
-
-#endif // end file guardian
-