diff options
Diffstat (limited to 'shared/loki/Singleton.h')
| -rw-r--r-- | shared/loki/Singleton.h | 889 |
1 files changed, 889 insertions, 0 deletions
diff --git a/shared/loki/Singleton.h b/shared/loki/Singleton.h new file mode 100644 index 00000000..42d6eb0d --- /dev/null +++ b/shared/loki/Singleton.h @@ -0,0 +1,889 @@ +//////////////////////////////////////////////////////////////////////////////// +// 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 + |