Loki Namespace Reference


Classes

class  LokiAllocator
class  SimplePointer
 No encaspulation : returns the pointer. More...
class  NeverCreate
 Never allows creation. Testing purposes only. More...
class  AlwaysCreate
 Always allows creation. More...
class  RateLimitedCreation
 Limit in rate. More...
class  AmountLimitedCreation
 Limit by number of objects. More...
class  EvictLRU
 Evicts least accessed objects first. More...
class  EvictAging
 LRU aware of the time span of use. More...
class  EvictRandom
 Evicts a random object. More...
class  NoStatisticPolicy
 Do nothing. More...
class  SimpleStatisticPolicy
 Simple statistics. More...
class  CachedFactory
 Factory with caching support. More...
class  CheckForNoThrow
class  CheckForNoChange
class  CheckForNoChangeOrThrow
class  CheckForEquality
class  CheckForNothing
class  ContractChecker
class  CheckStaticForNoThrow
class  CheckStaticForNothing
class  StaticChecker
class  CheckReturn
class  DontPropagateConst
class  PropagateConst
class  DefaultFactoryError
 Default policy that throws an exception. More...
class  Factory
class  CloneFactory
 Creates a copy from a polymorphic object. More...
class  Functor
class  BinderFirst
class  Chainer
class  Key
class  LevelMutexInfo
class  ThrowOnAnyMutexError
class  ThrowOnBadDesignMutexError
class  AssertAnyMutexError
class  AssertBadDesignMutexError
class  JustReturnMutexError
class  NoMutexWait
class  MutexSleepWaits
class  SpinLevelMutex
class  SleepLevelMutex
class  LevelMutex
class  MutexException
class  MutexLocker
class  MultiMutexLocker
class  LockingPtr
class  ConstPropPtr
class  Pimpl
class  RefToValue
class  RegisterOnCreateSet
class  UnRegisterOnDeleteSet
class  SafeBitConst
class  ScopeGuardImplBase
class  ScopeGuardImpl0
class  ScopeGuardImpl1
class  ScopeGuardImpl2
class  ScopeGuardImpl3
class  ScopeGuardImpl4
class  ScopeGuardImpl5
class  ObjScopeGuardImpl0
class  ObjScopeGuardImpl1
class  ObjScopeGuardImpl2
class  ObjScopeGuardImpl3
struct  CreateUsingNew
struct  CreateUsing
struct  CreateUsingMalloc
struct  CreateStatic
struct  DefaultLifetime
struct  PhoenixSingleton
struct  DeletableSingleton
struct  SingletonWithLongevity
struct  NoDestroy
class  FollowIntoDeath
class  SingletonHolder
class  Singleton
class  SmallObjAllocator
class  AllocatorSingleton
class  SmallObjectBase
class  SmallObject
class  SmallValueObject
class  HeapStorage
class  DefaultSPStorage
class  LockedStorage
class  ArrayStorage
class  RefCounted
class  COMRefCounted
struct  DeepCopy
class  RefLinked
class  DestructiveCopy
class  NoCopy
struct  AllowConversion
struct  DisallowConversion
struct  NoCheck
struct  AssertCheck
struct  AssertCheckStrict
struct  NullPointerException
struct  RejectNullStatic
struct  RejectNull
struct  RejectNullStrict
class  SmartPtr
class  FunctionStorage
 Implementation of the StoragePolicy used by SmartPtr. More...
class  SmartPointer
 Encapsulate the object in a SmartPtr with FunctionStorage policy. More...
class  DeleteUsingFree
class  DeleteNothing
class  DeleteSingle
class  DeleteArray
class  CantResetWithStrong
class  AllowReset
class  NeverReset
class  TwoRefCounts
class  TwoRefLinks
class  StrongPtr
class  Mutex
class  SingleThreaded
class  BaseVisitor
class  CyclicVisitor
struct  Chunk
class  FixedAllocator

Functions

template<typename Type >
bool operator== (const LokiAllocator< Type > &, const LokiAllocator< Type > &)
template<typename Type >
bool operator!= (const LokiAllocator< Type > &, const LokiAllocator< Type > &)
template<class Fctor >
Private::BinderFirstTraits
< Fctor >::BoundFunctorType 
BindFirst (const Fctor &fun, typename Fctor::Parm1 bound)
template<class Fun1 , class Fun2 >
Fun2 Chain (const Fun1 &fun1, const Fun2 &fun2)
unsigned int GetCurrentThreadsLevel (void)
unsigned int CountMutexesInCurrentThread (void)
unsigned int CountLocksInCurrentThread (void)
unsigned int CountMutexesAtCurrentLevel (void)
MutexErrors::Type DoMutexesMatchContainer (const LevelMutexInfo::MutexContainer &mutexes)
template<class T >
RefToValue< T > ByRef (T &t)
template<class t >
bool RegisterFunction ()
template<class t >
bool UnRegisterFunction ()
template<typename T , typename Destroyer >
void SetLongevity (T *pDynObject, unsigned int longevity, Destroyer d)
template<template< class, class > class T, std::size_t C, std::size_t M, std::size_t O, template< class > class L, class X >
unsigned int GetLongevity (AllocatorSingleton< T, C, M, O, L, X > *)
template<typename T , template< class > class OP, class CP , template< class > class KP, template< class > class SP, template< class > class CNP1, typename U >
bool operator== (const SmartPtr< T, OP, CP, KP, SP, CNP1 > &lhs, U *rhs)
template<typename T , template< class > class OP, class CP , template< class > class KP, template< class > class SP, template< class > class CNP1, typename U >
bool operator== (U *lhs, const SmartPtr< T, OP, CP, KP, SP, CNP1 > &rhs)
template<typename T , template< class > class OP, class CP , template< class > class KP, template< class > class SP, template< class > class CNP, typename U >
bool operator!= (const SmartPtr< T, OP, CP, KP, SP, CNP > &lhs, U *rhs)
template<typename T , template< class > class OP, class CP , template< class > class KP, template< class > class SP, template< class > class CNP, typename U >
bool operator!= (U *lhs, const SmartPtr< T, OP, CP, KP, SP, CNP > &rhs)
template<typename T , template< class > class OP, class CP , template< class > class KP, template< class > class SP, template< class > class CNP, typename U >
bool operator< (const SmartPtr< T, OP, CP, KP, SP, CNP > &lhs, U *rhs)
template<typename T , template< class > class OP, class CP , template< class > class KP, template< class > class SP, template< class > class CNP, typename U >
bool operator< (U *lhs, const SmartPtr< T, OP, CP, KP, SP, CNP > &rhs)
template<typename T , template< class > class OP, class CP , template< class > class KP, template< class > class SP, template< class > class CNP, typename U >
bool operator> (const SmartPtr< T, OP, CP, KP, SP, CNP > &lhs, U *rhs)
 /////////////////////////////////////////////////////////////////////////////
template<typename T , template< class > class OP, class CP , template< class > class KP, template< class > class SP, template< class > class CNP, typename U >
bool operator> (U *lhs, const SmartPtr< T, OP, CP, KP, SP, CNP > &rhs)
template<typename T , template< class > class OP, class CP , template< class > class KP, template< class > class SP, template< class > class CNP, typename U >
bool operator<= (const SmartPtr< T, OP, CP, KP, SP, CNP > &lhs, U *rhs)
template<typename T , template< class > class OP, class CP , template< class > class KP, template< class > class SP, template< class > class CNP, typename U >
bool operator<= (U *lhs, const SmartPtr< T, OP, CP, KP, SP, CNP > &rhs)
template<typename T , template< class > class OP, class CP , template< class > class KP, template< class > class SP, template< class > class CNP, typename U >
bool operator>= (const SmartPtr< T, OP, CP, KP, SP, CNP > &lhs, U *rhs)
template<typename T , template< class > class OP, class CP , template< class > class KP, template< class > class SP, template< class > class CNP, typename U >
bool operator>= (U *lhs, const SmartPtr< T, OP, CP, KP, SP, CNP > &rhs)
template<typename U , typename T , bool S, class OP , class CP , template< class > class KP, template< class > class RP, template< class > class DP, template< class > class CNP>
bool operator== (const StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > &lhs, U *rhs)
template<typename U , typename T , bool S, class OP , class CP , template< class > class KP, template< class > class RP, template< class > class DP, template< class > class CNP>
bool operator== (U *lhs, const StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > &rhs)
template<typename U , typename T , bool S, class OP , class CP , template< class > class KP, template< class > class RP, template< class > class DP, template< class > class CNP>
bool operator!= (const StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > &lhs, U *rhs)
template<typename U , typename T , bool S, class OP , class CP , template< class > class KP, template< class > class RP, template< class > class DP, template< class > class CNP>
bool operator!= (U *lhs, const StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > &rhs)
template<typename U , typename T , bool S, class OP , class CP , template< class > class KP, template< class > class RP, template< class > class DP, template< class > class CNP>
bool operator< (const StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > &lhs, U *rhs)
template<typename U , typename T , bool S, class OP , class CP , template< class > class KP, template< class > class RP, template< class > class DP, template< class > class CNP>
bool operator< (U *lhs, const StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > &rhs)
template<typename U , typename T , bool S, class OP , class CP , template< class > class KP, template< class > class RP, template< class > class DP, template< class > class CNP>
bool operator> (U *lhs, const StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > &rhs)
template<typename U , typename T , bool S, class OP , class CP , template< class > class KP, template< class > class RP, template< class > class DP, template< class > class CNP>
bool operator<= (const StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > &lhs, U *rhs)
template<typename U , typename T , bool S, class OP , class CP , template< class > class KP, template< class > class RP, template< class > class DP, template< class > class CNP>
bool operator<= (U *lhs, const StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > &rhs)
template<typename U , typename T , bool S, class OP , class CP , template< class > class KP, template< class > class RP, template< class > class DP, template< class > class CNP>
bool operator>= (const StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > &lhs, U *rhs)
template<typename U , typename T , bool S, class OP , class CP , template< class > class KP, template< class > class RP, template< class > class DP, template< class > class CNP>
bool operator>= (U *lhs, const StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > &rhs)
std::size_t GetOffset (std::size_t numBytes, std::size_t alignment)
void * DefaultAllocator (std::size_t numBytes, bool doThrow)
void DefaultDeallocator (void *p)

Detailed Description

All classes of Loki are in the Loki namespace

This file is intented to be used if you want a CachedFactory with a SmartPointer encapsulation policy. It as been defined in a separate file because of the many introduced dependencies (SmartPtr.h would depend on Functor.h and CachedFactory.h would depend on SmartPtr.h). By defining another header you pay for those extra dependencies only if you need it.

This file defines FunctionStorage a new SmartPointer storage policy and SmartPointer a new CachedFactory encapsulation policy.


Function Documentation

unsigned int Loki::CountLocksInCurrentThread ( void   ) 

Returns count of how mutexes the current thread locked. The lock count exceeds the number of mutexes locked by current thread if any mutex got locked more than once. Requires O(m) actions where m is the number of mutexes in the thread. Never throws exceptions.

References Loki::LevelMutexInfo::GetCurrentMutex(), Loki::LevelMutexInfo::GetLockCount(), and Loki::LevelMutexInfo::GetPrevious().

Here is the call graph for this function:

unsigned int Loki::CountMutexesAtCurrentLevel ( void   ) 

Returns count of mutexes locked by current thread which have the same level as GetCurrentThreadsLevel. Requires O(m) actions where m is the number of mutexes in the thread at current level. Never throws exceptions.

References Loki::LevelMutexInfo::GetCurrentMutex(), Loki::LevelMutexInfo::GetLevel(), and Loki::LevelMutexInfo::GetPrevious().

Referenced by DoMutexesMatchContainer().

Here is the call graph for this function:

unsigned int Loki::CountMutexesInCurrentThread ( void   ) 

Returns count of how mutexes the current thread locked. Requires O(m) actions where m is the number of mutexes in the thread. Never throws exceptions.

References Loki::LevelMutexInfo::GetCurrentMutex(), and Loki::LevelMutexInfo::GetPrevious().

Here is the call graph for this function:

MutexErrors::Type Loki::DoMutexesMatchContainer ( const LevelMutexInfo::MutexContainer &  mutexes  ) 

Determines if container of mutexes matches the recently locked mutexes. If they do match, it returns success, otherwise an error condition.

References CountMutexesAtCurrentLevel(), GetCurrentThreadsLevel(), Loki::LevelMutexInfo::GetLevel(), Loki::LevelMutexInfo::IsRecentLock(), and Loki::LevelMutexInfo::UnlockedLevel.

Referenced by Loki::LevelMutexInfo::MultiLock(), and Loki::LevelMutexInfo::MultiUnlock().

Here is the call graph for this function:

unsigned int Loki::GetCurrentThreadsLevel ( void   ) 

Returns level of most recently locked mutex by this thread, or UnlockedLevel if no mutexes are locked. Runs in constant time, and never throws exceptions.

References Loki::LevelMutexInfo::GetCurrentMutex(), Loki::LevelMutexInfo::GetLevel(), and Loki::LevelMutexInfo::UnlockedLevel.

Referenced by DoMutexesMatchContainer(), and Loki::LevelMutexInfo::MultiLock().

Here is the call graph for this function:

template<template< class, class > class T, std::size_t C, std::size_t M, std::size_t O, template< class > class L, class X >
unsigned int Loki::GetLongevity ( AllocatorSingleton< T, C, M, O, L, X > *   )  [inline]

This standalone function provides the longevity level for Small-Object Allocators which use the Loki::SingletonWithLongevity policy. The SingletonWithLongevity class can find this function through argument- dependent lookup.

Longevity Levels
No Small-Object Allocator depends on any other Small-Object allocator, so this does not need to calculate dependency levels among allocators, and it returns just a constant. All allocators must live longer than the objects which use the allocators, it must return a longevity level higher than any such object.

template<typename Type >
bool Loki::operator!= ( const LokiAllocator< Type > &  ,
const LokiAllocator< Type > &   
) [inline]

All inequality operators return false since LokiAllocator is basically a monostate design pattern, so all instances of it are identical.

template<typename Type >
bool Loki::operator== ( const LokiAllocator< Type > &  ,
const LokiAllocator< Type > &   
) [inline]

All equality operators return true since LokiAllocator is basically a monostate design pattern, so all instances of it are identical.


Generated on Thu Jan 29 18:51:42 2009 for Loki by  doxygen 1.5.8