Menu
▾
▴
[Loki-lib-cvs] SF.net SVN: loki-lib:[1085] trunk/include/loki/Singleton.h
|
From: <ric...@us...> - 2011-06-21 03:29:56
|
Revision: 1085
http://loki-lib.svn.sourceforge.net/loki-lib/?rev=1085&view=rev
Author: rich_sposato
Date: 2011-06-21 03:29:50 +0000 (Tue, 21 Jun 2011)
Log Message:
-----------
Removed trailing whitespaces.
Modified Paths:
--------------
trunk/include/loki/Singleton.h
Modified: trunk/include/loki/Singleton.h
===================================================================
--- trunk/include/loki/Singleton.h 2011-06-21 01:16:29 UTC (rev 1084)
+++ trunk/include/loki/Singleton.h 2011-06-21 03:29:50 UTC (rev 1085)
@@ -2,14 +2,14 @@
// The Loki Library
// Copyright (c) 2001 by Andrei Alexandrescu
// This code accompanies the book:
-// Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design
+// 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 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"
+// 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_
@@ -30,9 +30,9 @@
#include <memory>
#ifdef _MSC_VER
-#define LOKI_C_CALLING_CONVENTION_QUALIFIER __cdecl
+#define LOKI_C_CALLING_CONVENTION_QUALIFIER __cdecl
#else
-#define LOKI_C_CALLING_CONVENTION_QUALIFIER
+#define LOKI_C_CALLING_CONVENTION_QUALIFIER
#endif
/// \defgroup SingletonGroup Singleton
@@ -42,7 +42,7 @@
/// \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
+/// 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
@@ -58,14 +58,14 @@
{
#ifndef LOKI_MAKE_DLL
- void LOKI_C_CALLING_CONVENTION_QUALIFIER AtExitFn(); // declaration needed below
+ 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
+#define LOKI_ENABLE_NEW_SETLONGLIVITY_HELPER_DATA_IMPL
#ifdef LOKI_ENABLE_NEW_SETLONGLIVITY_HELPER_DATA_IMPL
// Helper data
@@ -87,23 +87,23 @@
class LifetimeTracker
{
public:
- LifetimeTracker(unsigned int x) : longevity_(x)
+ 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() {}
+ inline LifetimeTracker::~LifetimeTracker() {}
// Helper destroyer function
template <typename T>
@@ -124,11 +124,13 @@
, pTracked_(p)
, destroyer_(d)
{}
-
+
~ConcreteLifetimeTracker()
{ destroyer_(pTracked_); }
-
+
private:
+ /// Copy constructor is not implemented.
+ ConcreteLifetimeTracker( const ConcreteLifetimeTracker & );
T* pTracked_;
Destroyer destroyer_;
};
@@ -137,8 +139,8 @@
////////////////////////////////////////////////////////////////////////////////
/// \ingroup LifetimeGroup
- ///
- /// Assigns an object a longevity; ensures ordered destructions of objects
+ ///
+ /// Assigns an object a longevity; ensures ordered destructions of objects
/// registered thusly during the exit sequence of the application
////////////////////////////////////////////////////////////////////////////////
@@ -155,58 +157,58 @@
pTrackerArray = new TrackerArray;
// automatically delete the ConcreteLifetimeTracker object when a exception is thrown
- std::auto_ptr<LifetimeTracker>
+ 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(),
+ 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,
+ 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,
+ pTrackerArray,
+ pTrackerArray + elements,
+ p,
LifetimeTracker::Compare);
std::copy_backward(
- pos,
+ pos,
pTrackerArray + elements,
pTrackerArray + elements + 1);
*pos = p;
++elements;
-
+
// Register a call to AtExitFn
std::atexit(Private::AtExitFn);
}
@@ -221,21 +223,21 @@
}
////////////////////////////////////////////////////////////////////////////////
- /// \struct CreateUsingNew
+ /// \struct CreateUsingNew
///
/// \ingroup CreationGroup
/// Implementation of the CreationPolicy used by SingletonHolder
- /// Creates objects using a straight call to the new operator
+ /// 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
///
@@ -265,13 +267,13 @@
}
};
};
-
+
////////////////////////////////////////////////////////////////////////////////
/// \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
+ /// Creates objects using a call to std::malloc, followed by a call to the
/// placement new operator
////////////////////////////////////////////////////////////////////////////////
template <class T> struct CreateUsingMalloc
@@ -282,30 +284,30 @@
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
+ /// 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( push )
#pragma warning( disable : 4121 )
// alignment of a member was sensitive to packing
#endif // _MSC_VER
@@ -323,17 +325,17 @@
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();
@@ -353,7 +355,7 @@
{
static void ScheduleDestruction(T*, atexit_pfn_t pFun)
{ std::atexit(pFun); }
-
+
static void OnDeadReference()
{ throw std::logic_error("Dead Reference Detected"); }
};
@@ -363,7 +365,7 @@
///
/// \ingroup LifetimeGroup
/// Implementation of the LifetimePolicy used by SingletonHolder
- /// Schedules an object's destruction as per C++ rules, and it allows object
+ /// Schedules an object's destruction as per C++ rules, and it allows object
/// recreation by not throwing an exception from OnDeadReference
////////////////////////////////////////////////////////////////////////////////
template <class T>
@@ -377,20 +379,20 @@
#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
@@ -402,13 +404,13 @@
///
/// \ingroup LifetimeGroup
///
- /// A DeletableSingleton allows the instantiated singleton to be
- /// destroyed at any time. The singleton can be reinstantiated at
+ /// 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
+ /// If the singleton exists when the program terminates, it will
/// be automatically deleted.
///
- /// \par Usage:
+ /// \par Usage:
/// The singleton can be deleted manually:
///
/// DeletableSingleton<MyClass>::GracefulDelete();
@@ -430,9 +432,9 @@
needCallback = false;
}
}
-
+
static void OnDeadReference()
- {
+ {
}
/// delete singleton object manually
static void GracefulDelete()
@@ -442,12 +444,12 @@
isDead = true;
deleter();
}
-
+
protected:
static atexit_pfn_t deleter;
static bool isDead;
static bool needCallback;
-
+
static void atexitCallback()
{
#ifdef ATEXIT_FIXED
@@ -458,13 +460,13 @@
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;
@@ -501,7 +503,7 @@
Private::Adapter<T> adapter = { pFun };
SetLongevity(pObj, GetLongevity(pObj), adapter);
}
-
+
static void OnDeadReference()
{ throw std::logic_error("Dead Reference Detected"); }
};
@@ -518,12 +520,12 @@
{
static void ScheduleDestruction(T*, atexit_pfn_t)
{}
-
+
static void OnDeadReference()
{}
};
-
+
////////////////////////////////////////////////////////////////////////////////
/// \defgroup LongevityLifetimeGroup LongevityLifetime
/// \ingroup LifetimeGroup
@@ -537,7 +539,7 @@
namespace LongevityLifetime
{
////////////////////////////////////////////////////////////////////////////////
- /// \struct SingletonFixedLongevity
+ /// \struct SingletonFixedLongevity
///
/// \ingroup LongevityLifetimeGroup
/// Add your own lifetimes into the namespace 'LongevityLifetime'
@@ -551,13 +553,13 @@
{
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"); }
};
@@ -578,11 +580,11 @@
/// \struct DieFirst
/// \ingroup LongevityLifetimeGroup
- /// \brief Shortest possible SingletonWithLongevity lifetime: 0
+ /// \brief Shortest possible SingletonWithLongevity lifetime: 0
template <class T>
struct DieFirst : SingletonFixedLongevity<0,T>
{};
-
+
}//namespace LongevityLifetime
////////////////////////////////////////////////////////////////////////////////
@@ -590,12 +592,12 @@
///
/// \ingroup LifetimeGroup
///
- /// Lifetime policyfor the SingletonHolder tempalte.
+ /// 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)
+ /// - master dies not by a call of a the atexit registerd function (DeletableSingleton::GracefulDelete)
///
/// \par Usage:
///
@@ -611,7 +613,7 @@
typedef std::vector<atexit_pfn_t> Container;
typedef typename Container::iterator iterator;
static Container* followers_;
-
+
public:
static void Init()
{
@@ -633,7 +635,7 @@
{
Init();
for(iterator it = followers_->begin();it != followers_->end();++it)
- (*it)();
+ (*it)();
delete followers_;
}
};
@@ -641,7 +643,7 @@
public:
/// \struct With
- /// Template for the master
+ /// Template for the master
/// \param Lifetime Lifetime policy for the master
template<template <class> class Lifetime>
struct With
@@ -656,7 +658,7 @@
Followers<Master>::Init();
Lifetime<Master>::ScheduleDestruction(pObj, pFun);
- // use same policy for the followers and force a new
+ // 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.
@@ -664,8 +666,8 @@
}
static void OnDeadReference()
- {
- throw std::logic_error("Dead Reference Detected");
+ {
+ throw std::logic_error("Dead Reference Detected");
}
};
};
@@ -677,7 +679,7 @@
struct AfterMaster
{
/// \struct IsDestroyed
- /// Policy for followers
+ /// Policy for followers
template<class F>
struct IsDestroyed
{
@@ -685,33 +687,33 @@
{
Followers<Master>::AddFollower(pFun);
}
-
+
static void OnDeadReference()
- {
- throw std::logic_error("Dead Reference Detected");
+ {
+ throw std::logic_error("Dead Reference Detected");
}
};
};
};
template<class T>
- typename FollowIntoDeath::Followers<T>::Container*
+ 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,
+ /// 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,
+ /// \param ThreadingModel Threading policy,
/// default: LOKI_DEFAULT_THREADING_NO_OBJ_LEVEL
////////////////////////////////////////////////////////////////////////////////
template
@@ -731,21 +733,21 @@
/// 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
////////////////////////////////////////////////////////////////////////////////
@@ -783,7 +785,7 @@
template <class, class> class ThreadingModel,
class MutexPolicy
>
- inline T& SingletonHolder<T, CreationPolicy,
+ inline T& SingletonHolder<T, CreationPolicy,
LifetimePolicy, ThreadingModel, MutexPolicy>::Instance()
{
if (!pInstance_)
@@ -805,12 +807,12 @@
template <class, class> class ThreadingModel,
class MutexPolicy
>
- void SingletonHolder<T, CreationPolicy,
+ void SingletonHolder<T, CreationPolicy,
LifetimePolicy, ThreadingModel, MutexPolicy>::MakeInstance()
{
typename ThreadingModel<SingletonHolder,MutexPolicy>::Lock guard;
(void)guard;
-
+
if (!pInstance_)
{
if (destroyed_)
@@ -819,7 +821,7 @@
destroyed_ = false;
}
pInstance_ = CreationPolicy<T>::Create();
- LifetimePolicy<T>::ScheduleDestruction(pInstance_,
+ LifetimePolicy<T>::ScheduleDestruction(pInstance_,
&DestroySingleton);
}
}
@@ -832,7 +834,7 @@
template <class, class> class M,
class X
>
- void LOKI_C_CALLING_CONVENTION_QUALIFIER
+ void LOKI_C_CALLING_CONVENTION_QUALIFIER
SingletonHolder<T, CreationPolicy, L, M, X>::DestroySingleton()
{
assert(!destroyed_);
@@ -849,7 +851,7 @@
///
/// 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
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
