#include <exception>
#include <assert.h>
This file provides Loki's Checker facility.
T & ReferenceType
type returned by operator->
Definition: SmartPtr.h:288
AllocatorSingleton< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy > ObjAllocatorSingleton
Definition: SmallObj.h:445
bool operator!=(const SmartPtr< T, OP, CP, KP, SP, CNP > &lhs, U *rhs)
Definition: SmartPtr.h:1570
Definition: LevelMutex.h:148
Definition: Functor.h:1220
T & ReferenceType
type returned by operator*
Definition: SPCachedFactory.h:72
Definition: ScopeGuard.h:109
Definition: LevelMutex.h:469
MutexException & operator=(const MutexException &that)
Copy-assignment operator performs a member-by-member copy of an exception.
Definition: LevelMutex.cpp:974
Implementation of the StoragePolicy used by SmartPtr.
Definition: SPCachedFactory.h:63
T & ReferenceType
type returned by operator->
Definition: SmartPtr.h:77
Definition: SmartPtr.h:361
Limit in rate.
Definition: CachedFactory.h:163
Definition: Singleton.h:497
~ContractChecker(void)
Definition: Checker.h:311
bool GreaterThan(const T1 *p) const
Helper function which can be called to avoid exposing GetPointer function.
Definition: StrongPtr.h:1180
const Chunk * HasBlock(void *p) const
Definition: SmallObj.cpp:722
unsigned int GetLevel(void) const
Returns level of mutex(es) used when problem occurred.
Definition: LevelMutex.h:1036
Evicts a random object.
Definition: CachedFactory.h:486
Creates a copy from a polymorphic object.
Definition: Factory.h:1041
const SafeBitConst operator<<(unsigned int s) const
Definition: SafeBits.h:225
Definition: LevelMutex.h:415
SafeBitField(const const_t &rhs)
Copy constructor and assignment operators from constant bit fields.
Definition: SafeBits.h:312
std::size_t GetOffset(std::size_t numBytes, std::size_t alignment)
Definition: SmallObj.cpp:1013
Definition: Checker.h:373
T * PointerType
type used to declare OwnershipPolicy type.
Definition: SmartPtr.h:76
static const unsigned int UnlockedLevel
Definition: LevelMutex.h:154
Never allows creation. Testing purposes only.
Definition: CachedFactory.h:109
Definition: ScopeGuard.h:303
MutexErrors::Type GetReason(void) const
Returns an error status for why operation failed.
Definition: LevelMutex.h:1039
Definition: StrongPtr.h:128
Definition: SmartPtr.h:576
Lifetime is a one less than DieLast: 0xFFFFFFFF-1.
Definition: Singleton.h:577
bool LessThan(const T1 *p) const
Helper function which can be called to avoid exposing GetPointer function.
Definition: StrongPtr.h:1173
const volatile MutexPolicy & GetMutexPolicy(void) const volatile
Definition: LevelMutex.h:778
bool Check(void) const
Definition: Checker.h:481
Functor< void, Seq< void * > > FunctorType
type of the Functor to set
Definition: SPCachedFactory.h:74
bool IsLockedByCurrentThread(void) const volatile
Returns true if this was locked by current thread.
Definition: LevelMutex.cpp:575
bool operator>=(const SmartPtr< T, OP, CP, KP, SP, CNP > &lhs, U *rhs)
Definition: SmartPtr.h:1726
static size_t size()
Word size is also the maximum number of different bit fields for a given word type.
Definition: SafeBits.h:229
Definition: SmallObj.cpp:171
StaticChecker(Validator validator, Validator pre=0, Validator post=0)
Definition: Checker.h:449
SafeBitField operator|(const SafeBitField &rhs) const
Bitwise operations that use bit-fields.
Definition: SafeBits.h:332
bool Unlock(void)
Definition: LevelMutex.cpp:1138
SafeBitField()
Default constructor allows client code to construct bit fields on the stack.
Definition: SafeBits.h:305
Definition: ConstPolicy.h:37
LRU aware of the time span of use.
Definition: CachedFactory.h:410
Definition: SafeBits.h:117
Definition: LevelMutex.h:299
In this namespace are special lifetime policies to manage lifetime dependencies.
Definition: Threads.h:361
Definition: Checker.h:220
Definition: SmallObj.h:632
bool IsValid(void) const volatile
Definition: LevelMutex.cpp:545
Definition: ScopeGuard.h:204
Definition: LockingPtr.h:42
void ReleaseObject(ProductReturn &object)
Use this function to release the object.
Definition: CachedFactory.h:1140
Definition: Checker.h:117
Convert an allocator<Type> to an allocator <Type1>.
Definition: Allocator.h:69
Definition: Singleton.h:551
ScopeGuardImplBase(const ScopeGuardImplBase &other)
Copy-constructor takes over responsibility from other ScopeGuard.
Definition: ScopeGuard.h:54
Definition: ScopeGuard.h:44
Definition: SmartPtr.h:941
Definition: SmallObj.h:87
Definition: Singleton.h:249
Definition: LevelMutex.h:1015
Definition: Threads.h:523
Definition: SmartPtr.h:282
bool IsLocked(void) const
Returns true if the mutex is locked by this object.
Definition: LevelMutex.h:1108
Definition: RefToValue.h:32
~AllocatorSingleton(void)
The destructor is not meant to be called directly.
Definition: SmallObj.h:249
Definition: StrongPtr.h:778
Definition: Visitor.h:327
Definition: SmartPtr.h:851
Definition: Singleton.h:865
virtual MutexErrors::Type Lock(void) volatile
Definition: LevelMutex.cpp:935
static void ClearExtraMemory(void)
Definition: SmallObj.h:287
word_t bit_word_t
Type of the bit field is available if needed.
Definition: SafeBits.h:152
T ObjectType
Type of the singleton object.
Definition: Singleton.h:730
void deallocate(pointer p, size_type size)
Ask allocator to release memory at pointer with size bytes.
Definition: Allocator.h:95
Definition: Visitor.h:126
bool operator==(const StrongPtr< T1, S1, OP1, CP1, KP1, RP1, DP1, CNP1 > &rhs) const
Equality comparison operator is templated to handle ambiguity.
Definition: StrongPtr.h:1197
static P * Default(void)
Provides default value to initialize the pointer.
Definition: StrongPtr.h:140
void destroy(pointer p)
Destruct the object at pointer.
Definition: Allocator.h:118
~Lock()
Unlock class.
Definition: Threads.h:575
Definition: SafeBits.h:148
Definition: LevelMutex.h:579
Definition: Threads.h:456
SafeBitConst()
Default constructor allows client code to construct bit fields on the stack.
Definition: SafeBits.h:190
Definition: SmartPtr.h:154
Definition: Singleton.h:371
SleepLevelMutex(unsigned int level)
Definition: StrongPtr.h:319
Definition: Register.h:98
Definition: SmartPtr.h:796
Definition: Singleton.h:683
bool operator==(const SafeBitField &rhs) const
These comparison operators act on bit-fields of the same type.
Definition: SafeBits.h:316
Definition: Threads.h:325
T * PointerType
type used to declare OwnershipPolicy type.
Definition: SmartPtr.h:158
Definition: SmartPtr.h:1063
~StaticChecker(void)
Definition: Checker.h:465
Definition: SmallObj.h:596
Definition: Singleton.h:305
~FixedAllocator()
Destroy the FixedAllocator and release all its Chunks.
Definition: SmallObj.cpp:558
Definition: StrongPtr.h:247
Definition: SmartPtr.h:708
Definition: Singleton.h:648
Definition: ScopeGuard.h:536
bool IsLocked(void) const
Returns true if the mutexes are locked by this object.
Definition: LevelMutex.h:1186
bool TrimChunkList(void)
Definition: SmallObj.cpp:781
HeapStorage()
type returned by operator*
Definition: SmartPtr.h:79
bool operator==(const LokiAllocator< Type > &, const LokiAllocator< Type > &)
Definition: Allocator.h:135
void SetLongevity(T *pDynObject, unsigned int longevity, Destroyer d)
Definition: Singleton.h:148
virtual MutexErrors::Type TryLock(void) volatile=0
~LokiAllocator()
Destructor does nothing.
Definition: Allocator.h:64
std::size_t CountEmptyChunks(void) const
Definition: SmallObj.cpp:586
void DecrementCount(void) volatile
Called to unlock a mutex locked multiple times by the current thread.
Definition: LevelMutex.cpp:566
Definition: Checker.h:434
Always allows creation.
Definition: CachedFactory.h:134
Definition: Factory.h:753
virtual MutexErrors::Type Lock(unsigned int milliSeconds) volatile
Definition: LevelMutex.h:825
Lock(const ClassLevelLockable *)
Lock class.
Definition: Threads.h:568
Definition: StrongPtr.h:184
unsigned int GetLongevity(AllocatorSingleton< T, C, M, O, L, X > *)
Definition: SmallObj.h:331
Definition: Singleton.h:607
bool Unlock(void)
Definition: LevelMutex.cpp:1059
Definition: ScopeGuard.h:411
::std::vector< volatile LevelMutexInfo * > MutexContainer
Container for locking multiple mutexes at once.
Definition: LevelMutex.h:157
~LevelMutex(void)
The destructor.
Definition: LevelMutex.h:767
bool IsCorrupt(void) const
Definition: SmallObj.cpp:607
RefToValue< T > ByRef(T &t)
Definition: RefToValue.h:61
const volatile LevelMutexInfo * GetPrevious(void) const volatile
Returns pointer to mutex previously locked by the thread which locked this.
Definition: LevelMutex.h:217
T * InitPointerType
the type of the pointee_ object
Definition: SmartPtr.h:75
const_pointer address(const_reference elem) const
Return address of reference to const element.
Definition: Allocator.h:77
void * DefaultAllocator(std::size_t numBytes, bool doThrow)
Definition: SmallObj.cpp:1028
Definition: SmartPtr.h:1757
std::vector< IdentifierType > & RegisteredIds()
Return the registered ID in this Factory.
Definition: CachedFactory.h:860
~SmallObjAllocator(void)
Definition: SmallObj.cpp:1078
bool operator<=(const SmartPtr< T, OP, CP, KP, SP, CNP > &lhs, U *rhs)
Definition: SmartPtr.h:1688
LevelMutexInfo(unsigned int level)
Definition: LevelMutex.cpp:526
Definition: Checker.h:187
static MutexErrors::Type MultiUnlock(MutexContainer &mutexes)
Definition: LevelMutex.cpp:479
bool Merge(StrongPtr< T1, S1, OP1, CP1, KP1, RP1, DP1, CNP1 > &rhs)
Definition: StrongPtr.h:1115
bool TrimExcessMemory(void)
Definition: SmallObj.cpp:1088
Definition: LevelMutex.h:1140
~LockingPtr()
Destructor unlocks the mutex.
Definition: LockingPtr.h:71
static bool IsValidList(void)
Definition: LevelMutex.cpp:275
LockedStorage()
type returned by operator*
Definition: SmartPtr.h:290
virtual MutexErrors::Type Unlock(void) volatile
Definition: LevelMutex.h:861
Definition: Function.h:45
Definition: SmartPtr.h:924
bool(Host::* Validator)(void) const
Signature for the validation function.
Definition: Checker.h:285
Definition: SmallObj.h:74
void IncrementCount(void) volatile
Called to relock a mutex already locked by the current thread.
Definition: LevelMutex.cpp:557
Definition: Singleton.h:231
bool IsRecentLock(void) const volatile
Definition: LevelMutex.cpp:594
LokiAllocator(const LokiAllocator< Type1 > &)
Type converting allocator constructor does nothing.
Definition: Allocator.h:61
Definition: Checker.h:393
bool operator<(const SmartPtr< T, OP, CP, KP, SP, CNP > &lhs, U *rhs)
Definition: SmartPtr.h:1608
~CheckReturn(void)
Destructor checks if return value was used.
Definition: CheckReturn.h:129
virtual ~MutexException(void)
Destroys the exception.
Definition: LevelMutex.cpp:984
Definition: AbstractFactory.h:42
void Lock(void)
Definition: StrongPtr.h:1127
AllocatorSingleton()
The default constructor is not meant to be called directly.
Definition: SmallObj.h:244
AllocatorSingleton< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy > MyAllocator
Defines type of allocator.
Definition: SmallObj.h:228
void Initialize(std::size_t blockSize, std::size_t pageSize)
Initializes a FixedAllocator by calculating # of blocks per Chunk.
Definition: SmallObj.cpp:570
bool operator!=(const StrongPtr< T1, S1, OP1, CP1, KP1, RP1, DP1, CNP1 > &rhs) const
Inequality comparison operator is templated to handle ambiguity.
Definition: StrongPtr.h:1215
static T & Instance()
Returns a reference to singleton object.
Definition: Singleton.h:787
static void GracefulDelete()
delete singleton object manually
Definition: Singleton.h:438
virtual MutexErrors::Type Lock(void) volatile=0
bool IsLocked(void) const volatile
Returns true if this mutex was locked at least once.
Definition: LevelMutex.h:211
Lock(const ObjectLevelLockable &host)
Lock object.
Definition: Threads.h:476
LockingPtr(volatile ConstOrNotType &object, LockingPolicy &mutex)
Definition: LockingPtr.h:51
~MutexLocker(void)
Destructs the locker, and determines if it needs to unlock the mutex.
Definition: LevelMutex.cpp:1028
Factory with caching support.
Definition: CachedFactory.h:663
Definition: LevelMutex.h:486
Definition: Checker.h:278
No encaspulation : returns the pointer.
Definition: CachedFactory.h:73
bool Check(void) const
Definition: Checker.h:328
Definition: StrongPtr.h:290
void DefaultDeallocator(void *p)
Definition: SmallObj.cpp:1049
pointer address(reference elem) const
Return address of reference to mutable element.
Definition: Allocator.h:74
Definition: SmartPtr.h:779
Definition: Singleton.h:678
virtual ~SpinLevelMutex(void)
Destructs the mutex.
Definition: LevelMutex.cpp:811
unsigned int GetLevel(void) const volatile
Returns the level of this mutex.
Definition: LevelMutex.h:208
bool operator<=(const StrongPtr< T1, S1, OP1, CP1, KP1, RP1, DP1, CNP1 > &rhs) const
Less-than-or-equal-to operator is templated to handle ambiguity.
Definition: StrongPtr.h:1269
Definition: Checker.h:152
unsigned int GetLockCount(void) const volatile
Returns count of how many times this mutex got locked.
Definition: LevelMutex.h:214
~MultiMutexLocker(void)
Destructs the locker, and determines if it needs to unlock the mutexes.
Definition: LevelMutex.cpp:1107
Definition: SmartPtr.h:989
bool operator>=(const StrongPtr< T1, S1, OP1, CP1, KP1, RP1, DP1, CNP1 > &rhs) const
Greater-than-or-equal-to operator is templated to handle ambiguity.
Definition: StrongPtr.h:1287
Definition: SmallObj.h:223
bool Equals(const T1 *p) const
Helper function which can be called to avoid exposing GetPointer function.
Definition: StrongPtr.h:1166
T * StoredType
the type of the pointee_ object
Definition: SPCachedFactory.h:66
Definition: LevelMutex.h:1065
std::size_t GetMaxObjectSize() const
Returns max # of bytes which this can allocate.
Definition: SmallObj.h:153
T * PointerType
type used to declare OwnershipPolicy type.
Definition: SmartPtr.h:365
unsigned int CountLocksInCurrentThread(void)
Definition: LevelMutex.cpp:151
bool operator>(const StrongPtr< T1, S1, OP1, CP1, KP1, RP1, DP1, CNP1 > &rhs) const
Greater-than comparison operator is templated to handle ambiguity.
Definition: StrongPtr.h:1251
Definition: StrongPtr.h:868
Definition: SmartPtr.h:887
Definition: SmallObj.h:65
void Deallocate(void *p, std::size_t size)
Definition: SmallObj.cpp:1144
T * PointerType
type returned by operator->
Definition: SPCachedFactory.h:70
ThreadingModel< MyAllocator, MutexPolicy > MyThreadingModel
Defines type for thread-safety locking mechanism.
Definition: SmallObj.h:231
Simple statistics.
Definition: CachedFactory.h:568
Definition: LevelMutex.h:449
Definition: Functor.h:1632
void * Allocate(void)
Definition: SmallObj.cpp:831
const SafeBitConst operator|(const SafeBitConst &rhs) const
Definition: SafeBits.h:213
bool IsLockedByAnotherThread(void) const volatile
Returns true if this was locked by another thread.
Definition: LevelMutex.cpp:637
static bool IsCorrupted(void)
Definition: SmallObj.h:303
Locker< T > PointerType
type used to declare OwnershipPolicy type.
Definition: SmartPtr.h:287
Definition: ConstPolicy.h:50
LokiAllocator(void)
Default constructor does nothing.
Definition: Allocator.h:54
Definition: LevelMutex.h:401
bool operator<(const StrongPtr< T1, S1, OP1, CP1, KP1, RP1, DP1, CNP1 > &rhs) const
Less-than comparison operator is templated to handle ambiguity.
Definition: StrongPtr.h:1233
Definition: Allocator.h:42
bool operator==(const SafeBitConst &rhs) const
Comparison operators which take a constant bit value.
Definition: SafeBits.h:196
CheckReturn(const CheckReturn &that)
Definition: CheckReturn.h:124
CheckReturn(const Value &value)
Conversion constructor changes Value type to CheckReturn type.
Definition: CheckReturn.h:118
Definition: LevelMutex.h:747
Definition: ScopeGuard.h:253
bool operator!=(const LokiAllocator< Type > &, const LokiAllocator< Type > &)
Definition: Allocator.h:144
Longest possible SingletonWithLongevity lifetime: 0xFFFFFFFF.
Definition: Singleton.h:570
unsigned int GetCurrentThreadsLevel(void)
Definition: LevelMutex.cpp:129
Definition: StrongPtr.h:554
Definition: SmartPtr.h:819
Definition: Singleton.h:726
T * InitPointerType
type used to declare OwnershipPolicy type.
Definition: SPCachedFactory.h:68
Loki::SingletonHolder< MyAllocator, Loki::CreateStatic, LifetimePolicy, ThreadingModel > MyAllocatorSingleton
Defines singleton made from allocator.
Definition: SmallObj.h:235
Fun2 Chain(const Fun1 &fun1, const Fun2 &fun2)
Definition: Functor.h:1777
Definition: StrongPtr.h:269
Definition: SmartPtr.h:744
SafeBitConst(const SafeBitConst &rhs)
Copy constructor.
Definition: SafeBits.h:193
Definition: Singleton.h:653
Definition: ScopeGuard.h:600
LokiAllocator(const LokiAllocator &)
Copy constructor does nothing.
Definition: Allocator.h:57
Definition: SmallObj.cpp:71
bool(* Validator)(void)
Signature for the validation function.
Definition: Checker.h:441
std::size_t GetAlignment() const
Returns # of bytes between allocation boundaries.
Definition: SmallObj.h:157
void construct(pointer p, const Type &value)
Construct an element at the pointer.
Definition: Allocator.h:111
Definition: CheckReturn.h:114
Evicts least accessed objects first.
Definition: CachedFactory.h:352
static MutexErrors::Type MultiLock(MutexContainer &mutexes)
Definition: LevelMutex.cpp:316
Definition: LevelMutex.h:280
bool TrimEmptyChunk(void)
Definition: SmallObj.cpp:736
virtual ~SleepLevelMutex(void)
Destructs the mutex.
Definition: LevelMutex.cpp:929
static void Delete(const P *p)
Definition: StrongPtr.h:217
Lock(const ClassLevelLockable &)
Lock class.
Definition: Threads.h:561
Limit by number of objects.
Definition: CachedFactory.h:254
Definition: ScopeGuard.h:156
bool Deallocate(void *p, Chunk *hint)
Definition: SmallObj.cpp:888
Definition: Threads.h:550
Encapsulate the object in a SmartPtr with FunctionStorage policy.
Definition: SPCachedFactory.h:166
bool UnRegisterFunction()
Definition: SmartPtr.h:437
SafeBitField(const SafeBitField &rhs)
Copy constructor and assignment operators.
Definition: SafeBits.h:308
Definition: Singleton.h:518
ContractChecker(const Host *host, Validator validator, Validator pre=0, Validator post=0)
Definition: Checker.h:294
LockingPtr(Pair lockpair)
Definition: LockingPtr.h:63
const LevelMutexInfo::MutexContainer & GetMutexes(void) const
Provides access to the collection of mutexes controlled by this.
Definition: LevelMutex.h:1189
virtual MutexErrors::Type Lock(void) volatile
Definition: LevelMutex.h:805
#define LOKI_THREAD_LOCAL
Definition: LevelMutex.h:64
Definition: Threads.h:472
Definition: Singleton.h:418
Definition: StrongPtr.h:215
Definition: SmartPtr.h:675
Definition: ScopeGuard.h:473
word_t bit_word_t
Type of the bit field is available if needed.
Definition: SafeBits.h:298
const volatile LevelMutexInfo & GetMutex(void) const
Provides access to mutex controlled by this.
Definition: LevelMutex.h:1111
virtual const char * what(void) const
Returns a simple message about which operation failed.
Definition: LevelMutex.cpp:990
T * InitPointerType
the type of the pointee_ object
Definition: SmartPtr.h:286
static AllocatorSingleton & Instance(void)
Returns reference to the singleton.
Definition: SmallObj.h:238
unsigned int CountMutexesAtCurrentLevel(void)
Definition: LevelMutex.cpp:165
static void Delete(const P *p)
Definition: StrongPtr.h:186
Default policy that throws an exception
Definition: Factory.h:92
Definition: LevelMutex.h:516
MutexErrors::Type DoMutexesMatchContainer(const LevelMutexInfo::MutexContainer &mutexes)
Definition: LevelMutex.cpp:184
SafeBitField< unique_index, word_t > field_t
Corresponding field type.
Definition: SafeBits.h:154
void SetCallBackFunction(const FunctorType &functor)
Definition: SPCachedFactory.h:102
Forward declaration of the field type.
Definition: SafeBits.h:123
Definition: Threads.h:366
void PostLock(void) volatile
Definition: LevelMutex.cpp:653
void * Allocate(std::size_t size, bool doThrow)
Definition: SmallObj.cpp:1109
SpinLevelMutex(unsigned int level)
Constructs a spin-level mutex.
Definition: LevelMutex.cpp:783
pointer allocate(size_type count, const void *hint=0)
Definition: Allocator.h:87
Definition: SmartPtr.h:72
bool Lock(void)
Definition: LevelMutex.cpp:1045
Definition: Singleton.h:353
ConstOrNotType * operator->()
Point-operator returns pointer to object.
Definition: LockingPtr.h:83
FixedAllocator()
Create a FixedAllocator which manages blocks of 'blockSize' size.
Definition: SmallObj.cpp:546
Lock()
Lock class.
Definition: Threads.h:554
size_type max_size(void) const
Calculate max # of elements allocator can handle.
Definition: Allocator.h:101
Definition: Register.h:84
LevelMutex(unsigned int level=DefaultLevel)
Definition: LevelMutex.h:759
unsigned int CountMutexesInCurrentThread(void)
Definition: LevelMutex.cpp:137
Definition: SmartPtr.h:1023
Definition: SmallObj.h:437
Definition: Singleton.h:278
static const volatile LevelMutexInfo * GetCurrentMutex(void)
Definition: LevelMutex.cpp:267
virtual MutexErrors::Type Unlock(void) volatile=0
SafeBitConst< unique_index, word_t > const_t
Corresponding field type.
Definition: SafeBits.h:300
~TwoRefCounts(void)
Definition: StrongPtr.h:571
ConstOrNotType & operator*()
Star-operator dereferences pointer.
Definition: LockingPtr.h:77
~Lock()
Unlock object.
Definition: Threads.h:488
Do nothing.
Definition: CachedFactory.h:542
Definition: LevelMutex.h:429
Definition: Functor.h:1489
void PreUnlock(void) volatile
Gets called just before an attempt to unlock a mutex.
Definition: LevelMutex.cpp:669
void Unlock(void)
Definition: StrongPtr.h:1135
void displayCacheType()
display the cache configuration
Definition: CachedFactory.h:1152
virtual MutexErrors::Type TryLock(void) volatile
Definition: LevelMutex.h:783
Definition: ScopeGuard.h:356
Lock(const ObjectLevelLockable *host)
Lock object.
Definition: Threads.h:482
Private::BinderFirstTraits< Fctor >::BoundFunctorType BindFirst(const Fctor &fun, typename Fctor::Parm1 bound)
Definition: Functor.h:1612
Definition: StrongPtr.h:159
Definition: SmartPtr.h:616
Shortest possible SingletonWithLongevity lifetime: 0
Definition: Singleton.h:584
virtual ~LevelMutexInfo(void)
The destructor only gets called by the derived class.
Definition: LevelMutex.cpp:536
virtual MutexErrors::Type Lock(unsigned int milliSeconds) volatile=0
bool Lock(void)
Definition: LevelMutex.cpp:1124
Definition: LevelMutex.h:498
std::size_t BlockSize() const
Returns block size with which the FixedAllocator was initialized.
Definition: SmallObj.cpp:256
bool Merge(TwoRefLinks &rhs)
Definition: StrongPtr.cpp:455
bool IsCorrupt(void) const
Definition: SmallObj.cpp:1199