libloki-0.1.7.orig/0000755000175000017500000000000011140365376012565 5ustar ivanivanlibloki-0.1.7.orig/doc/0000755000175000017500000000000011140366263013326 5ustar ivanivanlibloki-0.1.7.orig/doc/flex/0000755000175000017500000000000011140365041014255 5ustar ivanivanlibloki-0.1.7.orig/doc/flex/flex_string.html0000644000175000017500000000350210515241547017500 0ustar ivanivan

flex_string

This code accompanies the article "Type-Safe Formatting" in C/C++ Users Journal, July 2005. It implements a simple printf emulation framework, which is typesafe at the price of a slightly modified invocation syntax.

flex_string is a drop-in replacement for the standard string (std::basic_string, better known by its typedefed name, std::string. If you think that reimplementing a likely fine-tuned component of your standard library is not a very rewarding endeavor, think again. flex_string has a policy-based design allowing unparalleled control over its behavior and optimizations, and also allows you to define new implementations in only a few dozens of lines of code. If you're looking for controllable performance and predictible behavior with multiple threads, then flex_string might be of interest to you.

To find more about flex_string, you may want to read "A Policy-Based basic_string Implementation," C/C++ Users Journal, June 2001.

The downloadable code consists of the flex_string header and a test suite that compares its behavior against std::string. Though no performance comparison suite is available at this time, Harmut Kaizer reported that simply dropping in flex_string in the Wave Boost Preprocessor improved its speed by 5-10%, depending on input.

Justin Matthews contributed with flex_string_hash.h, an add-on for flex_string that allows using it with hash maps. Justin's code supports (and automatically recognizes) two implementations: STLPort and Microsoft Visual C++ 7.1.

libloki-0.1.7.orig/doc/html/0000755000175000017500000000000011140366263014272 5ustar ivanivanlibloki-0.1.7.orig/doc/html/a00121.html0000755000175000017500000000516211140366261015771 0ustar ivanivan Loki: Loki::SingleThreaded< Host, MutexPolicy >::SingleThreaded::Lock Struct Reference

Loki::SingleThreaded< Host, MutexPolicy >::SingleThreaded::Lock Struct Reference

#include <Threads.h>

List of all members.


Detailed Description

template<class Host, class MutexPolicy = ::Loki::Mutex>
struct Loki::SingleThreaded< Host, MutexPolicy >::Lock

Dummy Lock class
The documentation for this struct was generated from the following file:

Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00309.html0000755000175000017500000000405711140366256016007 0ustar ivanivan Loki: Member List

Loki::Factory< AbstractProduct, IdentifierType, CreatorParmTList, FactoryErrorPolicy > Member List

This is the complete list of members for Loki::Factory< AbstractProduct, IdentifierType, CreatorParmTList, FactoryErrorPolicy >, including all inherited members.


Generated on Thu Jan 29 18:51:42 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00063.html0000755000175000017500000001735511140366261016005 0ustar ivanivan Loki: Loki::FunctionStorage< T > Class Template Reference

Loki::FunctionStorage< T > Class Template Reference
[Storage policies]

Implementation of the StoragePolicy used by SmartPtr. More...

#include <SPCachedFactory.h>

Collaboration diagram for Loki::FunctionStorage< T >:
[legend]

List of all members.

Public Types

typedef T * StoredType
 the type of the pointee_ object
typedef T * InitPointerType
 type used to declare OwnershipPolicy type.
typedef T * PointerType
 type returned by operator->
typedef T & ReferenceType
 type returned by operator*
typedef Functor< void, Seq
< void * > > 
FunctorType
 type of the Functor to set

Public Member Functions

void SetCallBackFunction (const FunctorType &functor)


Detailed Description

template<class T>
class Loki::FunctionStorage< T >

Implementation of the StoragePolicy used by SmartPtr.

This storage policy is used by SmartPointer CachedFactory's encapsulation policy. It's purpose is to call a Functor instead of deleting the underlying pointee object. You have to set the callback functor by calling SetCallBackFunction(const FunctorType &functor).

Unfortunately, the functor argument is not a reference to the SmartPtr but a void *. Making functor argument a reference to the pointer would require the FunctionStorage template to know the full definition of the SmartPtr.


Member Function Documentation

template<class T>
void Loki::FunctionStorage< T >::SetCallBackFunction ( const FunctorType functor  )  [inline]

Sets the callback function to call. You have to specify it or the smartPtr will throw a bad_function_call exception.


The documentation for this class was generated from the following file:

Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00056_49ab7ca3364fe05f2d7d91248ee5d0e3_cgraph.dot0000755000175000017500000000276111140366262023675 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node1 [label="Loki::FixedAllocator::Deallocate",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1 -> Node2 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::FixedAllocator::CountEmptyChunks",height=0.2,width=0.4,color="black",URL="$a00056.html#e74cbab50e78bfa115d7c0fcdce00641"]; Node2 -> Node3 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node3 [label="Loki::Chunk::HasAvailable",height=0.2,width=0.4,color="black",URL="$a00025.html#0874a711145788bd8c5265a9de2a4aac"]; Node1 -> Node4 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node4 [label="Loki::Chunk::HasBlock",height=0.2,width=0.4,color="black",URL="$a00025.html#b4ce346a74a437dabe4748bfb8e8b950",tooltip="Returns true if block at address P is inside this Chunk."]; Node1 -> Node5 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node5 [label="Loki::Chunk::IsBlockAvailable",height=0.2,width=0.4,color="black",URL="$a00025.html#8fe6ac2943df6c2f60123f928f119a73"]; Node1 -> Node6 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node6 [label="Loki::Chunk::IsCorrupt",height=0.2,width=0.4,color="black",URL="$a00025.html#245b6450d855d8ab65e9ca7add3e2071"]; } libloki-0.1.7.orig/doc/html/a00056_49ab7ca3364fe05f2d7d91248ee5d0e3_cgraph.md50000755000175000017500000000004011140366262023560 0ustar ivanivan3266d388fae1319129a0aa9b109156a5libloki-0.1.7.orig/doc/html/a00122.html0000755000175000017500000000523511140366260015772 0ustar ivanivan Loki: Loki::Singleton< T > Class Template Reference

Loki::Singleton< T > Class Template Reference
[Singleton]

#include <Singleton.h>

List of all members.


Detailed Description

template<class T>
class Loki::Singleton< T >

Convenience template to implement a getter function for a singleton object. Often needed in a shared library which hosts singletons.

Usage
see test/SingletonDll
The documentation for this class was generated from the following file:

Generated on Thu Jan 29 18:51:44 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00437.html0000755000175000017500000000420311140366261015776 0ustar ivanivan Loki: Member List

Loki::TwoRefCounts Member List

This is the complete list of members for Loki::TwoRefCounts, including all inherited members.

~TwoRefCounts(void)Loki::TwoRefCounts [inline, protected]


Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/classes.html0000755000175000017500000006047211140366255016632 0ustar ivanivan Loki: Alphabetical List

Class Index

A | B | C | D | E | F | H | I | J | K | L | M | N | O | P | R | S | T | U | V

  A  
LevelMutexInfo (Loki)   
AbstractFactory   LevelMutexInfo::Checker (Loki)   
AllocatorSingleton (Loki)   LevelMutexInfo::MutexUndoer (Loki)   
AllowConversion (Loki)   LockableTwoRefCountInfo   
AllowReset (Loki)   LockableTwoRefCounts   
AlwaysCreate (Loki)   LockedStorage (Loki)   
AmountLimitedCreation (Loki)   LockingPtr (Loki)   
ArrayStorage (Loki)   LokiAllocator (Loki)   
AssertAnyMutexError (Loki)   LokiAllocator::rebind (Loki)   
AssertBadDesignMutexError (Loki)   
  M  
AssertCheck (Loki)   MultiMutexLocker (Loki)   
AssertCheckStrict (Loki)   Mutex (Loki)   
  B  
MutexException (Loki)   
BaseVisitor (Loki)   MutexLocker (Loki)   
BinderFirst (Loki)   MutexSleepWaits (Loki)   
  C  
  N  
CachedFactory (Loki)   NeverCreate (Loki)   
CantResetWithStrong (Loki)   NeverReset (Loki)   
Chainer (Loki)   NoCheck (Loki)   
CheckForEquality (Loki)   NoCopy (Loki)   
CheckForNoChange (Loki)   NoDestroy (Loki)   
CheckForNoChangeOrThrow (Loki)   NoMutexWait (Loki)   
CheckForNothing (Loki)   NoStatisticPolicy (Loki)   
CheckForNoThrow (Loki)   NullPointerException (Loki)   
CheckReturn (Loki)   
  O  
CheckStaticForNothing (Loki)   ObjScopeGuardImpl0 (Loki)   
CheckStaticForNoThrow (Loki)   ObjScopeGuardImpl1 (Loki)   
Chunk (Loki)   ObjScopeGuardImpl2 (Loki)   
CloneFactory (Loki)   ObjScopeGuardImpl3 (Loki)   
COMRefCounted (Loki)   
  P  
ConstPropPtr (Loki)   PhoenixSingleton (Loki)   
ContractChecker (Loki)   Pimpl (Loki)   
CreateStatic (Loki)   PImplOf   
CreateUsing (Loki)   PropagateConst (Loki)   
CreateUsingMalloc (Loki)   
  R  
CreateUsingNew (Loki)   RateLimitedCreation (Loki)   
CyclicVisitor (Loki)   RefCounted (Loki)   
  D  
RefCountedMT   
DeepCopy (Loki)   RefLinked (Loki)   
DefaultFactoryError (Loki)   RefToValue (Loki)   
DefaultLifetime (Loki)   RegisterOnCreateSet (Loki)   
DefaultSPStorage (Loki)   RejectNull (Loki)   
DeletableSingleton (Loki)   RejectNullStatic (Loki)   
DeleteArray (Loki)   RejectNullStrict (Loki)   
DeleteNothing (Loki)   
  S  
DeleteSingle (Loki)   SafeBitConst (Loki)   
DeleteUsingFree (Loki)   ScopeGuardImpl0 (Loki)   
DestructiveCopy (Loki)   ScopeGuardImpl1 (Loki)   
DieAsSmallObjectChild (Loki::LongevityLifetime)   ScopeGuardImpl2 (Loki)   
DieAsSmallObjectParent (Loki::LongevityLifetime)   ScopeGuardImpl3 (Loki)   
DieDirectlyBeforeLast (Loki::LongevityLifetime)   ScopeGuardImpl4 (Loki)   
DieFirst (Loki::LongevityLifetime)   ScopeGuardImpl5 (Loki)   
DieLast (Loki::LongevityLifetime)   ScopeGuardImplBase (Loki)   
DisallowConversion (Loki)   SimplePointer (Loki)   
DontPropagateConst (Loki)   SimpleStatisticPolicy (Loki)   
  E  
SingleThreaded (Loki)   
EvictAging (Loki)   SingleThreaded::Lock (Loki)   
EvictLRU (Loki)   Singleton (Loki)   
EvictRandom (Loki)   SingletonFixedLongevity (Loki::LongevityLifetime)   
  F  
SingletonHolder (Loki)   
Factory (Loki)   SingletonWithLongevity (Loki)   
FixedAllocator (Loki)   SleepLevelMutex (Loki)   
FollowIntoDeath (Loki)   SmallObjAllocator (Loki)   
FollowIntoDeath::AfterMaster (Loki)   SmallObject (Loki)   
FollowIntoDeath::AfterMaster::IsDestroyed (Loki)   SmallObjectBase (Loki)   
FollowIntoDeath::With (Loki)   SmallValueObject (Loki)   
FollowIntoDeath::With::AsMasterLifetime (Loki)   SmartPointer (Loki)   
Function   SmartPtr (Loki)   
FunctionStorage (Loki)   SpinLevelMutex (Loki)   
Functor (Loki)   StaticChecker (Loki)   
  H  
StrongPtr (Loki)   
HeapStorage (Loki)   
  T  
  I  
ThrowOnAnyMutexError (Loki)   
ImplOf   ThrowOnBadDesignMutexError (Loki)   
  J  
TwoRefCountInfo (Loki::Private)   
JustReturnMutexError (Loki)   TwoRefCounts (Loki)   
  K  
TwoRefLinks (Loki)   
Key (Loki)   
  U  
  L  
UnRegisterOnDeleteSet (Loki)   
less< Loki::StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > > (std)   
  V  
LevelMutex (Loki)   Visitor   

A | B | C | D | E | F | H | I | J | K | L | M | N | O | P | R | S | T | U | V


Generated on Thu Jan 29 18:51:41 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00064.html0000755000175000017500000000731511140366256016005 0ustar ivanivan Loki: Loki::Functor< R, TList, ThreadingModel > Class Template Reference

Loki::Functor< R, TList, ThreadingModel > Class Template Reference
[Function objects]

#include <Functor.h>

Inheritance diagram for Loki::Functor< R, TList, ThreadingModel >:
[legend]

List of all members.


Detailed Description

template<typename R = void, class TList = NullType, template< class, class > class ThreadingModel = ::Loki::SingleThreaded>
class Loki::Functor< R, TList, ThreadingModel >

A generalized functor implementation with value semantics

Macro: LOKI_FUNCTOR_IS_NOT_A_SMALLOBJECT
Define
 LOKI_FUNCTOR_IS_NOT_A_SMALLOBJECT 
to avoid static instantiation/delete order problems. It often helps against crashes when using static Functors and multi threading. Defining also removes problems when unloading Dlls which hosts static Functor objects.
Macro: LOKI_FUNCTORS_ARE_COMPARABLE
To enable the operator== define the macro
 LOKI_FUNCTORS_ARE_COMPARABLE 
The macro is disabled by default, because it breaks compiling functor objects which have no operator== implemented, keep in mind when you enable operator==.

The documentation for this class was generated from the following file:

Generated on Thu Jan 29 18:51:42 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/functions_type.html0000755000175000017500000001236111140366255020240 0ustar ivanivan Loki: Class Members - Typedefs
 


Generated on Thu Jan 29 18:51:41 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00379.html0000755000175000017500000000437311140366260016012 0ustar ivanivan Loki: Member List

Loki::ObjScopeGuardImpl3< Obj, MemFun, P1, P2, P3 > Member List

This is the complete list of members for Loki::ObjScopeGuardImpl3< Obj, MemFun, P1, P2, P3 >, including all inherited members.

ScopeGuardImplBase(const ScopeGuardImplBase &other)Loki::ScopeGuardImplBase [inline, protected]


Generated on Thu Jan 29 18:51:44 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00123.html0000755000175000017500000000621311140366262015772 0ustar ivanivan Loki: Loki::LongevityLifetime::SingletonFixedLongevity< Longevity, T > Struct Template Reference

Loki::LongevityLifetime::SingletonFixedLongevity< Longevity, T > Struct Template Reference
[LongevityLifetime]

#include <Singleton.h>

Inheritance diagram for Loki::LongevityLifetime::SingletonFixedLongevity< Longevity, T >:
[legend]

List of all members.


Detailed Description

template<unsigned int Longevity, class T>
struct Loki::LongevityLifetime::SingletonFixedLongevity< Longevity, T >

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> {}


The documentation for this struct was generated from the following file:

Generated on Thu Jan 29 18:51:46 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00192.html0000755000175000017500000015765011140366256016017 0ustar ivanivan Loki: Loki Namespace Reference

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
libloki-0.1.7.orig/doc/html/a00002_033978d127f16d2da0fd79d31ee75713_cgraph.dot0000755000175000017500000000361011140366261023437 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node1 [label="Loki::AllocatorSingleton::IsCorrupted",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1 -> Node2 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::AllocatorSingleton::Instance",height=0.2,width=0.4,color="black",URL="$a00002.html#0de7839b1e888e11ff44bc50b78ca7d7",tooltip="Returns reference to the singleton."]; Node2 -> Node3 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node3 [label="Loki::SingletonHolder::Instance",height=0.2,width=0.4,color="black",URL="$a00124.html#43e4ea5cb6291a8bb14eb7cdc2bcb7bf",tooltip="Returns a reference to singleton object."]; Node1 -> Node4 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node4 [label="Loki::SmallObjAllocator::IsCorrupt",height=0.2,width=0.4,color="black",URL="$a00127.html#2b7fbd5bf5fc56e45754abd2497ad18f"]; Node4 -> Node5 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node5 [label="Loki::SmallObjAllocator::GetAlignment",height=0.2,width=0.4,color="black",URL="$a00127.html#b1c8a2a3d7e9368ab59422ddd082105c",tooltip="Returns # of bytes between allocation boundaries."]; Node4 -> Node6 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node6 [label="Loki::SmallObjAllocator::GetMaxObjectSize",height=0.2,width=0.4,color="black",URL="$a00127.html#e49e9de3fd7b2fd93676cc1d63299b0d",tooltip="Returns max # of bytes which this can allocate."]; Node4 -> Node7 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node7 [label="Loki::GetOffset",height=0.2,width=0.4,color="black",URL="$a00217.html#g2f0821e243f812a3ae2abfaea51895e8"]; } libloki-0.1.7.orig/doc/html/a00002_033978d127f16d2da0fd79d31ee75713_cgraph.md50000755000175000017500000000004011140366261023330 0ustar ivanivanf8dfb5c3e1c321f2e3c1ad90c8d1b952libloki-0.1.7.orig/doc/html/a00071_b917108c3e7c83b8a515d28e91a3a3ca_cgraph.dot0000755000175000017500000000143311140366256023576 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node1 [label="Loki::LevelMutexInfo::IsRecentLock",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1 -> Node2 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::LevelMutexInfo::IsValid",height=0.2,width=0.4,color="black",URL="$a00071.html#36c34ecf5d019f3db9bfb8654cf49176"]; Node2 -> Node3 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node3 [label="Loki::LevelMutexInfo::IsValidList",height=0.2,width=0.4,color="black",URL="$a00071.html#01f6dfba5d2ea5606109b34e5a543cf0"]; } libloki-0.1.7.orig/doc/html/a00071_b917108c3e7c83b8a515d28e91a3a3ca_cgraph.md50000755000175000017500000000004011140366256023466 0ustar ivanivan1ec952100fbd9036268f9242d2fd56a0libloki-0.1.7.orig/doc/html/a00192_ae4c5edaad45b3657f39e8cdbae0f928_cgraph.dot0000755000175000017500000000260211140366255024175 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node1 [label="Loki::CountLocksInCurrentThread",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1 -> Node2 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::LevelMutexInfo::GetCurrentMutex",height=0.2,width=0.4,color="black",URL="$a00071.html#b7fd94847721b118979b72121472d3e2"]; Node2 -> Node3 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node3 [label="Loki::LevelMutexInfo::IsValidList",height=0.2,width=0.4,color="black",URL="$a00071.html#01f6dfba5d2ea5606109b34e5a543cf0"]; Node1 -> Node4 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node4 [label="Loki::LevelMutexInfo::GetLockCount",height=0.2,width=0.4,color="black",URL="$a00071.html#013e7ffd438e4c1f11dcc6943a40802e",tooltip="Returns count of how many times this mutex got locked."]; Node1 -> Node5 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node5 [label="Loki::LevelMutexInfo::GetPrevious",height=0.2,width=0.4,color="black",URL="$a00071.html#b774e94ff72724dd87ff236d99970bb5",tooltip="Returns pointer to mutex previously locked by the thread which locked this."]; } libloki-0.1.7.orig/doc/html/a00192_ae4c5edaad45b3657f39e8cdbae0f928_cgraph.md50000755000175000017500000000004011140366255024066 0ustar ivanivanab1db9ef206e6585d1694a0cf35f7574libloki-0.1.7.orig/doc/html/a00310.html0000755000175000017500000000402511140366256015772 0ustar ivanivan Loki: Member List

Loki::CloneFactory< AbstractProduct, ProductCreator, FactoryErrorPolicy > Member List

This is the complete list of members for Loki::CloneFactory< AbstractProduct, ProductCreator, FactoryErrorPolicy >, including all inherited members.


Generated on Thu Jan 29 18:51:42 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00065.html0000755000175000017500000001124511140366261015777 0ustar ivanivan Loki: Loki::HeapStorage< T > Class Template Reference

Loki::HeapStorage< T > Class Template Reference
[Storage policies]

#include <SmartPtr.h>

List of all members.

Public Types

typedef T * InitPointerType
 the type of the pointee_ object
typedef T * PointerType
 type used to declare OwnershipPolicy type.
typedef T & ReferenceType
 type returned by operator->

Public Member Functions

 HeapStorage ()
 type returned by operator*


Detailed Description

template<class T>
class Loki::HeapStorage< T >

Implementation of the StoragePolicy used by SmartPtr. Uses explicit call to T's destructor followed by call to free.
The documentation for this class was generated from the following file:

Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00218_g7c1d35d961854e812b743b22c89f14f8_cgraph.dot0000755000175000017500000000116311140366254023552 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node1 [label="Loki::operator!=",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1 -> Node2 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::StrongPtr::Equals",height=0.2,width=0.4,color="black",URL="$a00135.html#0c197e9b4f68669529435577357ffa57",tooltip="Helper function which can be called to avoid exposing GetPointer function."]; } libloki-0.1.7.orig/doc/html/a00218_g7c1d35d961854e812b743b22c89f14f8_cgraph.md50000755000175000017500000000004011140366254023442 0ustar ivanivan31451293eec8b49974aef0bdb7cfdbdelibloki-0.1.7.orig/doc/html/a00124.html0000755000175000017500000001140611140366260015771 0ustar ivanivan Loki: Loki::SingletonHolder< T, CreationPolicy, LifetimePolicy, ThreadingModel, MutexPolicy > Class Template Reference

Loki::SingletonHolder< T, CreationPolicy, LifetimePolicy, ThreadingModel, MutexPolicy > Class Template Reference
[Singleton]

#include <Singleton.h>

List of all members.

Public Types

typedef T ObjectType
 Type of the singleton object.

Static Public Member Functions

static T & Instance ()
 Returns a reference to singleton object.


Detailed Description

template<typename T, template< class > class CreationPolicy = CreateUsingNew, template< class > class LifetimePolicy = DefaultLifetime, template< class, class > class ThreadingModel = ::Loki::SingleThreaded, class MutexPolicy = ::Loki::Mutex>
class Loki::SingletonHolder< T, CreationPolicy, LifetimePolicy, ThreadingModel, MutexPolicy >

Provides Singleton amenities for a type T To protect that type from spurious instantiations, you have to protect it yourself.

Parameters:
CreationPolicy Creation policy, default: CreateUsingNew
LifetimePolicy Lifetime policy, default: DefaultLifetime,
ThreadingModel Threading policy, default: LOKI_DEFAULT_THREADING_NO_OBJ_LEVEL

The documentation for this class was generated from the following file:

Generated on Thu Jan 29 18:51:44 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00439.html0000755000175000017500000000420011140366261015775 0ustar ivanivan Loki: Member List

Loki::TwoRefLinks Member List

This is the complete list of members for Loki::TwoRefLinks, including all inherited members.

Merge(TwoRefLinks &rhs)Loki::TwoRefLinks [protected]


Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00071_ebf33c02e3dd8adb0155fd827b5cfccd_cgraph.dot0000755000175000017500000000143311140366256024232 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node1 [label="Loki::LevelMutexInfo::IsRecentLock",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1 -> Node2 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::LevelMutexInfo::IsValid",height=0.2,width=0.4,color="black",URL="$a00071.html#36c34ecf5d019f3db9bfb8654cf49176"]; Node2 -> Node3 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node3 [label="Loki::LevelMutexInfo::IsValidList",height=0.2,width=0.4,color="black",URL="$a00071.html#01f6dfba5d2ea5606109b34e5a543cf0"]; } libloki-0.1.7.orig/doc/html/a00071_ebf33c02e3dd8adb0155fd827b5cfccd_cgraph.md50000755000175000017500000000004011140366256024122 0ustar ivanivan1ec952100fbd9036268f9242d2fd56a0libloki-0.1.7.orig/doc/html/a00066.html0000755000175000017500000000430211140366255015777 0ustar ivanivan Loki: ImplOf Class Reference

ImplOf Class Reference
[Pimpl]

#include <Pimpl.h>


Detailed Description

Convenience template for the implementations which Pimpl points to.
The documentation for this class was generated from the following file:

Generated on Thu Jan 29 18:51:41 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00380.html0000755000175000017500000000366511140366260016005 0ustar ivanivan Loki: Member List

Loki::CreateUsingNew< T > Member List

This is the complete list of members for Loki::CreateUsingNew< T >, including all inherited members.


Generated on Thu Jan 29 18:51:44 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00125.html0000755000175000017500000000540711140366260015776 0ustar ivanivan Loki: Loki::SingletonWithLongevity< T > Struct Template Reference

Loki::SingletonWithLongevity< T > Struct Template Reference
[Lifetime policies]

#include <Singleton.h>

List of all members.


Detailed Description

template<class T>
struct Loki::SingletonWithLongevity< T >

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.
The documentation for this struct was generated from the following file:

Generated on Thu Jan 29 18:51:44 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00312.html0000755000175000017500000000372511140366256016002 0ustar ivanivan Loki: Member List

Loki::Functor< R, TList, ThreadingModel > Member List

This is the complete list of members for Loki::Functor< R, TList, ThreadingModel >, including all inherited members.


Generated on Thu Jan 29 18:51:42 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00067.html0000755000175000017500000000505411140366256016006 0ustar ivanivan Loki: Loki::JustReturnMutexError Class Reference

Loki::JustReturnMutexError Class Reference

#include <LevelMutex.h>

List of all members.


Detailed Description

Implements the ErrorPolicy for LevelMutex and does nothing no matter how bad the error condition. Only recommended use is for automated unit-testing of mutex policies.
The documentation for this class was generated from the following file:

Generated on Thu Jan 29 18:51:42 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00381.html0000755000175000017500000000367311140366260016005 0ustar ivanivan Loki: Member List

Loki::CreateUsingMalloc< T > Member List

This is the complete list of members for Loki::CreateUsingMalloc< T >, including all inherited members.


Generated on Thu Jan 29 18:51:44 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00126.html0000755000175000017500000001510111140366257015775 0ustar ivanivan Loki: Loki::SleepLevelMutex Class Reference

Loki::SleepLevelMutex Class Reference

#include <LevelMutex.h>

Inheritance diagram for Loki::SleepLevelMutex:
[legend]
Collaboration diagram for Loki::SleepLevelMutex:
[legend]

List of all members.

Public Member Functions

 SleepLevelMutex (unsigned int level)
virtual ~SleepLevelMutex (void)
 Destructs the mutex.
virtual MutexErrors::Type Lock (void) volatile


Detailed Description

Implements a sleeping loop to wait for the mutex to unlock.

Purpose
Since this class puts the thread to sleep for short intervals, you can use this class for most of your mutexes. Especially for locking any high level resources where any one operation on the resouce consumes many CPU cycles. The purpose of this mutex is to reduce the number of CPU cycles spent in idle loops. All SleepLevelMutex's should have higher levels than all your SpinLevelMutex's.
Dependence on SpinLevelMutex
This utilizes SpinLevelMutex so it does not have to re-implement the DoTryLock and DoUnlock functions the same way. All it really needs is a DoLock function and the amount of time it should sleep if an attempt to lock a function fails.

Constructor & Destructor Documentation

Loki::SleepLevelMutex::SleepLevelMutex ( unsigned int  level  )  [explicit]

Constructs a levelized mutex that puts threads to sleep while they wait for another thread to unlock the mutex.

Parameters:
level Level of this mutex.


Member Function Documentation

MutexErrors::Type Loki::SleepLevelMutex::Lock ( void   )  volatile [virtual]

Attempts to lock a mutex, and if it fails, then sleeps for a while before attempting again.

Reimplemented from Loki::SpinLevelMutex.


The documentation for this class was generated from the following files:

Generated on Thu Jan 29 18:51:43 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00440.html0000755000175000017500000001477611140366261016010 0ustar ivanivan Loki: Member List

Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy > Member List

This is the complete list of members for Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy >, including all inherited members.

Equals(const T1 *p) const Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy > [inline]
GreaterThan(const T1 *p) const Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy > [inline]
LessThan(const T1 *p) const Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy > [inline]
Lock(void)Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy > [inline]
Merge(StrongPtr< T1, S1, OP1, CP1, KP1, RP1, DP1, CNP1 > &rhs)Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy > [inline]
operator!=(const StrongPtr< T1, S1, OP1, CP1, KP1, RP1, DP1, CNP1 > &rhs) const Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy > [inline]
operator<(const StrongPtr< T1, S1, OP1, CP1, KP1, RP1, DP1, CNP1 > &rhs) const Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy > [inline]
operator<=(const StrongPtr< T1, S1, OP1, CP1, KP1, RP1, DP1, CNP1 > &rhs) const Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy > [inline]
operator==(const StrongPtr< T1, S1, OP1, CP1, KP1, RP1, DP1, CNP1 > &rhs) const Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy > [inline]
operator>(const StrongPtr< T1, S1, OP1, CP1, KP1, RP1, DP1, CNP1 > &rhs) const Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy > [inline]
operator>=(const StrongPtr< T1, S1, OP1, CP1, KP1, RP1, DP1, CNP1 > &rhs) const Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy > [inline]
Unlock(void)Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy > [inline]


Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00218_gd6031d88c8485cea6a6f4a89356e638a_cgraph.dot0000755000175000017500000000116311140366254023720 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node1 [label="Loki::operator!=",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1 -> Node2 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::StrongPtr::Equals",height=0.2,width=0.4,color="black",URL="$a00135.html#0c197e9b4f68669529435577357ffa57",tooltip="Helper function which can be called to avoid exposing GetPointer function."]; } libloki-0.1.7.orig/doc/html/a00218_gd6031d88c8485cea6a6f4a89356e638a_cgraph.md50000755000175000017500000000004011140366254023610 0ustar ivanivan31451293eec8b49974aef0bdb7cfdbdelibloki-0.1.7.orig/doc/html/a00080_a88fcf2068f0c4292e2f25fcd29c3e33_cgraph.dot0000755000175000017500000000764711140366257023710 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node1 [label="Loki::MultiMutexLocker::MultiMutexLocker",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1 -> Node2 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::LevelMutexInfo::MultiLock",height=0.2,width=0.4,color="black",URL="$a00071.html#dde650eae1cad8b4723e68cdb9130283"]; Node2 -> Node3 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node3 [label="Loki::LevelMutexInfo::MutexUndoer::Cancel",height=0.2,width=0.4,color="black",URL="$a00073.html#87e777d849336fe81907e55aaad1edaa"]; Node2 -> Node4 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node4 [label="Loki::LevelMutexInfo::DoErrorCheck",height=0.2,width=0.4,color="black",URL="$a00071.html#14e0d51318b864645bbb3df4f7c9f7ab"]; Node2 -> Node5 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node5 [label="Loki::DoMutexesMatchContainer",height=0.2,width=0.4,color="black",URL="$a00192.html#d633ca81ae0befaf235ae63886368037"]; Node5 -> Node6 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node6 [label="Loki::CountMutexesAtCurrentLevel",height=0.2,width=0.4,color="black",URL="$a00192.html#8cb767d3e7aaf2fe44b8f3b90218b876"]; Node6 -> Node7 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node7 [label="Loki::LevelMutexInfo::GetCurrentMutex",height=0.2,width=0.4,color="black",URL="$a00071.html#b7fd94847721b118979b72121472d3e2"]; Node7 -> Node8 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node8 [label="Loki::LevelMutexInfo::IsValidList",height=0.2,width=0.4,color="black",URL="$a00071.html#01f6dfba5d2ea5606109b34e5a543cf0"]; Node6 -> Node9 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node9 [label="Loki::LevelMutexInfo::GetLevel",height=0.2,width=0.4,color="black",URL="$a00071.html#1cad7c6b6fc50e230401e4cc22761d14",tooltip="Returns the level of this mutex."]; Node6 -> Node10 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node10 [label="Loki::LevelMutexInfo::GetPrevious",height=0.2,width=0.4,color="black",URL="$a00071.html#b774e94ff72724dd87ff236d99970bb5",tooltip="Returns pointer to mutex previously locked by the thread which locked this."]; Node5 -> Node11 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node11 [label="Loki::GetCurrentThreadsLevel",height=0.2,width=0.4,color="black",URL="$a00192.html#9548795d9cda6f227a1e1241ba577ca8"]; Node11 -> Node7 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node11 -> Node9 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node5 -> Node9 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node5 -> Node12 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node12 [label="Loki::LevelMutexInfo::IsRecentLock",height=0.2,width=0.4,color="black",URL="$a00071.html#b917108c3e7c83b8a515d28e91a3a3ca"]; Node12 -> Node13 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node13 [label="Loki::LevelMutexInfo::IsValid",height=0.2,width=0.4,color="black",URL="$a00071.html#36c34ecf5d019f3db9bfb8654cf49176"]; Node13 -> Node8 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 -> Node11 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 -> Node8 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 -> Node14 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node14 [label="Loki::LevelMutexInfo::MutexUndoer::SetPlace",height=0.2,width=0.4,color="black",URL="$a00073.html#65a5d0ff95ed8ab37280350f6a10259c"]; } libloki-0.1.7.orig/doc/html/a00080_a88fcf2068f0c4292e2f25fcd29c3e33_cgraph.md50000755000175000017500000000004011140366257023563 0ustar ivanivan6961e150d14e97a036ff0e3316b80a00libloki-0.1.7.orig/doc/html/a00313.html0000755000175000017500000000371311140366256016000 0ustar ivanivan Loki: Member List

Loki::BinderFirst< OriginalFunctor > Member List

This is the complete list of members for Loki::BinderFirst< OriginalFunctor >, including all inherited members.


Generated on Thu Jan 29 18:51:42 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00068.html0000755000175000017500000000474411140366256016014 0ustar ivanivan Loki: Loki::Key< Factory, IdentifierType > Class Template Reference

Loki::Key< Factory, IdentifierType > Class Template Reference

#include <Key.h>

List of all members.


Detailed Description

template<class Factory, typename IdentifierType>
class Loki::Key< Factory, IdentifierType >

A Key class
The documentation for this class was generated from the following file:

Generated on Thu Jan 29 18:51:42 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00382.html0000755000175000017500000000366111140366260016003 0ustar ivanivan Loki: Member List

Loki::CreateStatic< T > Member List

This is the complete list of members for Loki::CreateStatic< T >, including all inherited members.


Generated on Thu Jan 29 18:51:44 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00127.html0000755000175000017500000004500511140366261015777 0ustar ivanivan Loki: Loki::SmallObjAllocator Class Reference

Loki::SmallObjAllocator Class Reference
[Internals]

#include <SmallObj.h>

Inheritance diagram for Loki::SmallObjAllocator:
[legend]
Collaboration diagram for Loki::SmallObjAllocator:
[legend]

List of all members.

Public Member Functions

void * Allocate (std::size_t size, bool doThrow)
void Deallocate (void *p, std::size_t size)
void Deallocate (void *p)
std::size_t GetMaxObjectSize () const
 Returns max # of bytes which this can allocate.
std::size_t GetAlignment () const
 Returns # of bytes between allocation boundaries.
bool TrimExcessMemory (void)
bool IsCorrupt (void) const

Protected Member Functions

 SmallObjAllocator (std::size_t pageSize, std::size_t maxObjectSize, std::size_t objectAlignSize)
 ~SmallObjAllocator (void)


Detailed Description

Manages pool of fixed-size allocators. Designed to be a non-templated base class of AllocatorSingleton so that implementation details can be safely hidden in the source code file.

Constructor & Destructor Documentation

Loki::SmallObjAllocator::SmallObjAllocator ( std::size_t  pageSize,
std::size_t  maxObjectSize,
std::size_t  objectAlignSize 
) [protected]

The only available constructor needs certain parameters in order to initialize all the FixedAllocator's. This throws only if

Parameters:
pageSize # of bytes in a page of memory.
maxObjectSize Max # of bytes which this may allocate.
objectAlignSize # of bytes between alignment boundaries.

References Loki::GetOffset().

Here is the call graph for this function:

Loki::SmallObjAllocator::~SmallObjAllocator ( void   )  [protected]

Destructor releases all blocks, all Chunks, and FixedAllocator's. Any outstanding blocks are unavailable, and should not be used after this destructor is called. The destructor is deliberately non-virtual because it is protected, not public.


Member Function Documentation

void * Loki::SmallObjAllocator::Allocate ( std::size_t  size,
bool  doThrow 
)

Allocates a block of memory of requested size. Complexity is often constant-time, but might be O(C) where C is the number of Chunks in a FixedAllocator.

Exception Safety Level
Provides either strong-exception safety, or no-throw exception-safety level depending upon doThrow parameter. The reason it provides two levels of exception safety is because it is used by both the nothrow and throwing new operators. The underlying implementation will never throw of its own accord, but this can decide to throw if it does not allocate. The only exception it should emit is std::bad_alloc.
Allocation Failure
If it does not allocate, it will call TrimExcessMemory and attempt to allocate again, before it decides to throw or return NULL. Many allocators loop through several new_handler functions, and terminate if they can not allocate, but not this one. It only makes one attempt using its own implementation of the new_handler, and then returns NULL or throws so that the program can decide what to do at a higher level. (Side note: Even though the C++ Standard allows allocators and new_handlers to terminate if they fail, the Loki allocator does not do that since that policy is not polite to a host program.)
Parameters:
size # of bytes needed for allocation.
doThrow True if this should throw if unable to allocate, false if it should provide no-throw exception safety level.
Returns:
NULL if nothing allocated and doThrow is false. Else the pointer to an available block of memory.

References Loki::FixedAllocator::Allocate(), Loki::FixedAllocator::BlockSize(), Loki::DefaultAllocator(), GetAlignment(), GetMaxObjectSize(), Loki::GetOffset(), and TrimExcessMemory().

Here is the call graph for this function:

void Loki::SmallObjAllocator::Deallocate ( void *  p  ) 

Deallocates a block of memory at a given place but of unknown size size. Complexity is O(F + C) where F is the count of FixedAllocator's in the pool, and C is the number of Chunks in all FixedAllocator's. This does not throw exceptions. This overloaded version of Deallocate is called by the nothow delete operator - which is called when the nothrow new operator is used, but a constructor throws an exception.

References Loki::FixedAllocator::Deallocate(), Loki::DefaultDeallocator(), GetAlignment(), GetMaxObjectSize(), Loki::GetOffset(), and Loki::FixedAllocator::HasBlock().

Here is the call graph for this function:

void Loki::SmallObjAllocator::Deallocate ( void *  p,
std::size_t  size 
)

Deallocates a block of memory at a given place and of a specific size. Complexity is almost always constant-time, and is O(C) only if it has to search for which Chunk deallocates. This never throws.

References Loki::FixedAllocator::BlockSize(), Loki::FixedAllocator::Deallocate(), Loki::DefaultDeallocator(), GetAlignment(), GetMaxObjectSize(), and Loki::GetOffset().

Here is the call graph for this function:

bool Loki::SmallObjAllocator::IsCorrupt ( void   )  const

Returns true if anything in implementation is corrupt. Complexity is O(F + C + B) where F is the count of FixedAllocator's in the pool, C is the number of Chunks in all FixedAllocator's, and B is the number of blocks in all Chunks. If it determines any data is corrupted, this will return true in release version, but assert in debug version at the line where it detects the corrupted data. If it does not detect any corrupted data, it returns false.

References GetAlignment(), GetMaxObjectSize(), and Loki::GetOffset().

Referenced by Loki::AllocatorSingleton< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >::IsCorrupted().

Here is the call graph for this function:

bool Loki::SmallObjAllocator::TrimExcessMemory ( void   ) 

Releases empty Chunks from memory. Complexity is O(F + C) where F is the count of FixedAllocator's in the pool, and C is the number of Chunks in all FixedAllocator's. This will never throw. This is called by AllocatorSingleto::ClearExtraMemory, the new_handler function for Loki's allocator, and is called internally when an allocation fails.

Returns:
True if any memory released, or false if none released.

References GetAlignment(), GetMaxObjectSize(), and Loki::GetOffset().

Referenced by Allocate(), and Loki::AllocatorSingleton< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >::ClearExtraMemory().

Here is the call graph for this function:


The documentation for this class was generated from the following files:

Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/graph_legend.html0000755000175000017500000001137711140366263017613 0ustar ivanivan Loki: Graph Legend

Graph Legend

This page explains how to interpret the graphs that are generated by doxygen.

Consider the following example:

/*! Invisible class because of truncation */
class Invisible { };

/*! Truncated class, inheritance relation is hidden */
class Truncated : public Invisible { };

/* Class not documented with doxygen comments */
class Undocumented { };

/*! Class that is inherited using public inheritance */
class PublicBase : public Truncated { };

/*! A template class */
template<class T> class Templ { };

/*! Class that is inherited using protected inheritance */
class ProtectedBase { };

/*! Class that is inherited using private inheritance */
class PrivateBase { };

/*! Class that is used by the Inherited class */
class Used { };

/*! Super class that inherits a number of other classes */
class Inherited : public PublicBase,
                  protected ProtectedBase,
                  private PrivateBase,
                  public Undocumented,
                  public Templ<int>
{
  private:
    Used *m_usedClass;
};
This will result in the following graph:

graph_legend.png

The boxes in the above graph have the following meaning:

The arrows have the following meaning:

Generated on Thu Jan 29 18:51:47 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00441.html0000755000175000017500000000361511140366261015777 0ustar ivanivan Loki: Member List

Loki::Mutex Member List

This is the complete list of members for Loki::Mutex, including all inherited members.


Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00196.html0000755000175000017500000000410411140366262016001 0ustar ivanivan Loki: LongevityLifetime Namespace Reference

LongevityLifetime Namespace Reference
[LongevityLifetime]

In this namespace are special lifetime policies to manage lifetime dependencies. More...


Detailed Description

In this namespace are special lifetime policies to manage lifetime dependencies.


Generated on Thu Jan 29 18:51:46 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00314.html0000755000175000017500000000367111140366256016004 0ustar ivanivan Loki: Member List

Loki::Chainer< Fun1, Fun2 > Member List

This is the complete list of members for Loki::Chainer< Fun1, Fun2 >, including all inherited members.


Generated on Thu Jan 29 18:51:42 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00069.html0000755000175000017500000000563611140366262016013 0ustar ivanivan Loki: std::less< Loki::StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > > Struct Template Reference

std::less< Loki::StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > > Struct Template Reference
[Smart pointers]

#include <StrongPtr.h>

List of all members.


Detailed Description

template<typename T, bool S, class OP, class CP, template< class > class KP, template< class > class RP, template< class > class DP, template< class > class CNP>
struct std::less< Loki::StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > >

specialization of std::less for StrongPtr
The documentation for this struct was generated from the following file:

Generated on Thu Jan 29 18:51:46 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00383.html0000755000175000017500000000366711140366260016012 0ustar ivanivan Loki: Member List

Loki::DefaultLifetime< T > Member List

This is the complete list of members for Loki::DefaultLifetime< T >, including all inherited members.


Generated on Thu Jan 29 18:51:44 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00128.html0000755000175000017500000001005111140366261015771 0ustar ivanivan Loki: Loki::SmallObject< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > Class Template Reference

Loki::SmallObject< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > Class Template Reference
[Small objects]

#include <SmallObj.h>

Inheritance diagram for Loki::SmallObject< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >:
[legend]
Collaboration diagram for Loki::SmallObject< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >:
[legend]

List of all members.


Detailed Description

template<template< class, class > class ThreadingModel = ::Loki::SingleThreaded, std::size_t chunkSize = 4096, std::size_t maxSmallObjectSize = 256, std::size_t objectAlignSize = 4, template< class > class LifetimePolicy = ::Loki::LongevityLifetime::DieAsSmallObjectParent, class MutexPolicy = ::Loki::Mutex>
class Loki::SmallObject< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >

SmallObject Base class for polymorphic small objects, offers fast allocations & deallocations. Destructor is virtual and public. Default constructor is trivial. Copy-constructor and copy-assignment operator are not implemented since polymorphic classes almost always disable those operations. Class has no data members so compilers can use Empty-Base-Optimization.
The documentation for this class was generated from the following file:

Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00442.html0000755000175000017500000000372511140366261016002 0ustar ivanivan Loki: Member List

Loki::SingleThreaded< Host, MutexPolicy > Member List

This is the complete list of members for Loki::SingleThreaded< Host, MutexPolicy >, including all inherited members.


Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00197.html0000755000175000017500000000424711140366262016012 0ustar ivanivan Loki: std Namespace Reference

std Namespace Reference
[Smart pointers]


Classes

struct  less< Loki::StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > >

Detailed Description

specialization of std::less for SmartPtr


Generated on Thu Jan 29 18:51:46 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00198.dot0000755000175000017500000000231511140366254015630 0ustar ivanivandigraph structs { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node4 [label="Clone Factory",height=0.2,width=0.4,color="black",URL="$a00207.html",tooltip="Creates a copy from a polymorphic object."]; Node2 [label="Cached Factory",height=0.2,width=0.4,color="black",URL="$a00200.html",tooltip="CachedFactory provides an extension of a Factory with caching support."]; Node0 [label="Factories",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1 [label="Abstract Factory",height=0.2,width=0.4,color="black",URL="$a00199.html",tooltip="Implements an abstract object factory."]; Node3 [label="Factory",height=0.2,width=0.4,color="black",URL="$a00205.html",tooltip="Implements a generic object factory."]; Node0->Node1 [shape=plaintext, color="midnightblue", dir="back", style="solid"]; Node0->Node2 [shape=plaintext, color="midnightblue", dir="back", style="solid"]; Node0->Node3 [shape=plaintext, color="midnightblue", dir="back", style="solid"]; Node0->Node4 [shape=plaintext, color="midnightblue", dir="back", style="solid"]; } libloki-0.1.7.orig/doc/html/a00199.dot0000755000175000017500000000075711140366254015641 0ustar ivanivandigraph structs { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node1 [label="Factories",height=0.2,width=0.4,color="black",URL="$a00198.html"]; Node0 [label="Abstract Factory",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1->Node0 [shape=plaintext, color="midnightblue", dir="back", style="solid"]; } libloki-0.1.7.orig/doc/html/a00315.html0000755000175000017500000000371311140366256016002 0ustar ivanivan Loki: Member List

Loki::Key< Factory, IdentifierType > Member List

This is the complete list of members for Loki::Key< Factory, IdentifierType >, including all inherited members.


Generated on Thu Jan 29 18:51:42 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00384.html0000755000175000017500000000367111140366260016006 0ustar ivanivan Loki: Member List

Loki::PhoenixSingleton< T > Member List

This is the complete list of members for Loki::PhoenixSingleton< T >, including all inherited members.


Generated on Thu Jan 29 18:51:44 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00129.html0000755000175000017500000003603611140366261016005 0ustar ivanivan Loki: Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > Class Template Reference

Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > Class Template Reference
[Small objects]

#include <SmallObj.h>

Inheritance diagram for Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >:
[legend]

List of all members.

Public Types

typedef AllocatorSingleton
< ThreadingModel, chunkSize,
maxSmallObjectSize,
objectAlignSize,
LifetimePolicy > 
ObjAllocatorSingleton

Static Public Member Functions

static void * operator new (std::size_t size) throw ( std::bad_alloc )
 Throwing single-object new throws bad_alloc when allocation fails.
static void * operator new (std::size_t size, const std::nothrow_t &) throw ()
 Non-throwing single-object new returns NULL if allocation fails.
static void * operator new (std::size_t size, void *place)
 Placement single-object new merely calls global placement new.
static void operator delete (void *p, std::size_t size) throw ()
 Single-object delete.
static void operator delete (void *p, const std::nothrow_t &) throw ()
static void operator delete (void *p, void *place)
 Placement single-object delete merely calls global placement delete.


Detailed Description

template<template< class, class > class ThreadingModel, std::size_t chunkSize, std::size_t maxSmallObjectSize, std::size_t objectAlignSize, template< class > class LifetimePolicy, class MutexPolicy>
class Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >

Base class for small object allocation classes. The shared implementation of the new and delete operators are here instead of being duplicated in both SmallObject or SmallValueObject, later just called Small-Objects. This class is not meant to be used directly by clients, or derived from by clients. Class has no data members so compilers can use Empty-Base-Optimization.

ThreadingModel
This class doesn't support ObjectLevelLockable policy for ThreadingModel. The allocator is a singleton, so a per-instance mutex is not necessary. Nor is using ObjectLevelLockable recommended with SingletonHolder since the SingletonHolder::MakeInstance function requires a mutex that exists prior to when the object is created - which is not possible if the mutex is inside the object, such as required for ObjectLevelLockable. If you attempt to use ObjectLevelLockable, the compiler will emit errors because it can't use the default constructor in ObjectLevelLockable. If you need a thread-safe allocator, use the ClassLevelLockable policy.
Lifetime Policy
The SmallObjectBase template needs a lifetime policy because it owns a singleton of SmallObjAllocator which does all the low level functions. When using a Small-Object in combination with the SingletonHolder template you have to choose two lifetimes, that of the Small-Object and that of the singleton. The rule is: The Small-Object lifetime must be greater than the lifetime of the singleton hosting the Small-Object. Violating this rule results in a crash on exit, because the hosting singleton tries to delete the Small-Object which is then already destroyed.

The lifetime policies recommended for use with Small-Objects hosted by a SingletonHolder template are

The default lifetime of Small-Objects is LongevityLifetime::DieAsSmallObjectParent to insure that memory is not released before a object with the lifetime LongevityLifetime::DieAsSmallObjectChild using that memory is destroyed. The LongevityLifetime::DieAsSmallObjectParent lifetime has the highest possible value of a SetLongevity lifetime, so you can use it in combination with your own lifetime not having also the highest possible value.

The DefaultLifetime and PhoenixSingleton policies are *not* recommended since they can cause the allocator to be destroyed and release memory for singletons hosting a object which inherit from either SmallObject or SmallValueObject.

Lifetime usage

You should *not* use NoDestroy for the singleton, and then use SingletonWithLongevity for the Small-Object.

Examples:

Member Typedef Documentation

template<template< class, class > class ThreadingModel, std::size_t chunkSize, std::size_t maxSmallObjectSize, std::size_t objectAlignSize, template< class > class LifetimePolicy, class MutexPolicy>
typedef AllocatorSingleton< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy > Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >::ObjAllocatorSingleton

Defines type of allocator singleton, must be public to handle singleton lifetime dependencies.


Member Function Documentation

template<template< class, class > class ThreadingModel, std::size_t chunkSize, std::size_t maxSmallObjectSize, std::size_t objectAlignSize, template< class > class LifetimePolicy, class MutexPolicy>
static void Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >::operator delete ( void *  p,
const std::nothrow_t &   
) throw () [inline, static]

Non-throwing single-object delete is only called when nothrow new operator is used, and the constructor throws an exception.


The documentation for this class was generated from the following file:

Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00029_ac668398deabba5291b9025b4ac4eafd_cgraph.dot0000755000175000017500000000107211140366256024101 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node1 [label="Loki::ContractChecker::~ContractChecker",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1 -> Node2 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::ContractChecker::Check",height=0.2,width=0.4,color="black",URL="$a00029.html#812565f4dccc8d50be8f7b9c91841a51"]; } libloki-0.1.7.orig/doc/html/a00029_ac668398deabba5291b9025b4ac4eafd_cgraph.md50000755000175000017500000000004011140366256023772 0ustar ivanivan0f06a1cf98560f14c3d1862900ac34f3libloki-0.1.7.orig/doc/html/a00443.html0000755000175000017500000000400111140366261015767 0ustar ivanivan Loki: Member List

Loki::SingleThreaded< Host, MutexPolicy >::SingleThreaded::Lock Member List

This is the complete list of members for Loki::SingleThreaded< Host, MutexPolicy >::SingleThreaded::Lock, including all inherited members.


Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00198.html0000755000175000017500000000545011140366254016011 0ustar ivanivan Loki: Factories

Factories

Collaboration diagram for Factories:


Modules

 Abstract Factory
 Implements an abstract object factory.
 Cached Factory
 CachedFactory provides an extension of a Factory with caching support.
 Factory
 Implements a generic object factory.
 Clone Factory
 Creates a copy from a polymorphic object.

Generated on Thu Jan 29 18:51:40 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00001.html0000755000175000017500000000445411140366255015774 0ustar ivanivan Loki: AbstractFactory Class Reference

AbstractFactory Class Reference
[Abstract Factory]

Implements an abstract object factory. More...

#include <AbstractFactory.h>


Detailed Description

Implements an abstract object factory.
The documentation for this class was generated from the following file:

Generated on Thu Jan 29 18:51:41 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00070.html0000755000175000017500000005415411140366257016006 0ustar ivanivan Loki: Loki::LevelMutex< MutexPolicy, DefaultLevel, ErrorPolicy, WaitPolicy > Class Template Reference

Loki::LevelMutex< MutexPolicy, DefaultLevel, ErrorPolicy, WaitPolicy > Class Template Reference

#include <LevelMutex.h>

Inheritance diagram for Loki::LevelMutex< MutexPolicy, DefaultLevel, ErrorPolicy, WaitPolicy >:
[legend]
Collaboration diagram for Loki::LevelMutex< MutexPolicy, DefaultLevel, ErrorPolicy, WaitPolicy >:
[legend]

List of all members.

Public Member Functions

 LevelMutex (unsigned int level=DefaultLevel)
 ~LevelMutex (void)
 The destructor.
const volatile MutexPolicy & GetMutexPolicy (void) const volatile
virtual MutexErrors::Type TryLock (void) volatile
virtual MutexErrors::Type Lock (void) volatile
virtual MutexErrors::Type Lock (unsigned int milliSeconds) volatile
virtual MutexErrors::Type Unlock (void) volatile


Detailed Description

template<class MutexPolicy, unsigned int DefaultLevel, class ErrorPolicy = ::Loki::ThrowOnBadDesignMutexError, class WaitPolicy = ::Loki::NoMutexWait>
class Loki::LevelMutex< MutexPolicy, DefaultLevel, ErrorPolicy, WaitPolicy >

Levelized mutex class prevents deadlocks by requiring programs to lock mutexes in the same order, and unlock them in reverse order. This is accomplished by forcing each mutex to have a level and forcing code to lock mutexes with higher levels before locking mutexes at lower levels. If you want to lock several mutexes, they must be locked in decreasing order by level, or if they are all of the same level, then locked by LevelMutex::MultiLock.

Features
  • Immune: Very unlikely to deadlock since all mutexes are locked in the same order and unlocked in reverse order.
  • Scalable: Can handle any number of mutexes.
  • Efficient: Many operations occur in constant time, and most operations require no more than O(m) steps.
  • Exception safe: All operations provide strong safety or don't throw.
  • Extendable: Can work with existing mutexes through policy-based design.
  • Easily Extended: Derived classes only need to implement 5 functions and a mutex to get all the features of this class.
  • Re-Entrant: Allows for re-entrancy even if mutexes in policy classes don't.
  • Cost-Free: No resource allocations occur in LevelMutex - although user-defined policy classes may allocate resources.
  • Compact: Each LevelMutex object is small.
  • Portable: As long as your compiler and libraries can meet the requirements.
  • Robust: Maintains data integrity even if exceptions occur in policy classes.
  • Affording: Several functions provide information about a mutex which allows client code to easily choose correct actions.
Requirements
  • Your compiler must allow for thread-specific data.
  • You must have a threading or mutex library.
Policy-Based Design
This class hosts 3 policies and a default level. The policy-based design allows users to write their own policies to extend the behaviors of LevelMutex. The paragraphs below say how to design a class for each policy.
  • MutexPolicy The mutex policy class.
  • defaultLevel A level for existing client code that calls a default constructor.
  • ErrorPolicy How the mutex should handle error conditions.
  • WaitPolicy Whether a thread should wait, and how long in some internal loops.
MutexPolicy
A policy class that wraps a low-level mutex. Loki provides two policy classes for the actual mutex (SpinLevelMutex and SleepLevelMutex), both of which wrap either pthreads or the Windows CRITICAL_SECTION. If you want to use a mutex mechanism besides one of those, then all you have to do is provide a class which wraps the mutex and implements these functions. explicit SpinLevelMutex( unsigned int level ); virtual ~SpinLevelMutex( void ); virtual MutexErrors::Type Lock( void ) volatile; virtual MutexErrors::Type TryLock( void ) volatile; virtual MutexErrors::Type Unlock( void ) volatile; Indeed, since the base class does most of the work, and provides all the interace and functionality to client classes, a derived class has very few requirements. It only needs to implement a single constructor, the destructor, some virtual functions, and whatever data members it requires. You don't actually need to declare those functions as virtual if the policy class is not a base or child class. In the parlance of design patterns, LevelMutex is a Template, and the MutexPolicy is a Strategy.
DefaultLevel
The template class requires a default level to use inside the default constructor. Some existing code calls instantiates mutexes with a default constructor, so the mutex must know what level to use there. Please do not use zero or UnlockedLevel as the default level.
ErrorPolicy
This policy specifies how to handle error conditions. The mutexes can return errors, assert, or throw exceptions. I recommend that debug code use asserts, release code use exceptions, and unit-testing code just return errors. The error policy class only needs to implement one function: static MutexErrors::Type CheckError( MutexErrors::Type error, unsigned int level );
WaitPolicy
This states whether the mutex should wait within some tight internal loops, how the waiting is done, and for how long. A wait policy class could sleep, do nothing, check if other objects need attention, or check if the program received events or notices from the operating system. It only needs to implement one function: static void Wait( void );
Per-Function Usage
If you implement a function with a static local mutex, then you have to insure the function is not called from a lower level via call-backs, virtual functions in interface classes. If the function does get called from a lower level, you are setting up a potential deadlock. LevelMutex will detect that by checking the current level and the local mutex's level, so it will refuse to lock the local mutex.
Per-Object Usage
If you use a mutex as a data member of an object to protect that object, then I recommend specifying which functions are volatile and which are not, and then only use the mutex within the volatile functions. You may also want to provide accessor functions so that client code can lock and unlock the mutex either to allow for calling multiple operations without having to lock and unlock before and after each operation, or so they can lock it along with several other objects at the same level.
Per-Class Usage
If you make a static data member within a class, you can use that to lock any resources shared by those objects, or to require threads to act on only one object at a time. You may also want to provide static accessor functions so that client code can lock several other resources at the same level.

Constructor & Destructor Documentation

template<class MutexPolicy , unsigned int DefaultLevel, class ErrorPolicy = ::Loki::ThrowOnBadDesignMutexError, class WaitPolicy = ::Loki::NoMutexWait>
Loki::LevelMutex< MutexPolicy, DefaultLevel, ErrorPolicy, WaitPolicy >::LevelMutex ( unsigned int  level = DefaultLevel  )  [inline, explicit]

This constructor allows callers to replace the default level with another value. It also acts as the default constructor for existing code which uses default construction for mutexes. This is the only time the DefaultLevel template parameter gets used.

References Loki::LevelMutexInfo::IsValid().

Here is the call graph for this function:


Member Function Documentation

template<class MutexPolicy , unsigned int DefaultLevel, class ErrorPolicy = ::Loki::ThrowOnBadDesignMutexError, class WaitPolicy = ::Loki::NoMutexWait>
const volatile MutexPolicy& Loki::LevelMutex< MutexPolicy, DefaultLevel, ErrorPolicy, WaitPolicy >::GetMutexPolicy ( void   )  const volatile [inline]

These functions allow callers to access the mutex in case they need to modify specific values in the MutexPolicy (e.g. - sleep time, functors to call as tasks, etc...) There is one function for every combination of const and volatile qualifiers so callers get a reference to a MutexPolicy with the proper qualifiers.

template<class MutexPolicy , unsigned int DefaultLevel, class ErrorPolicy = ::Loki::ThrowOnBadDesignMutexError, class WaitPolicy = ::Loki::NoMutexWait>
virtual MutexErrors::Type Loki::LevelMutex< MutexPolicy, DefaultLevel, ErrorPolicy, WaitPolicy >::Lock ( unsigned int  milliSeconds  )  volatile [inline, virtual]

Attempts to lock mutex, but only waits for a limited amount of time before it gives up. Will return quickly if an error occurs before any attempt to lock. This may throw an exception if the lock failed or an error occurred - if that is what the error policy specifies.

Parameters:
milliSeconds How long to wait.
Returns:
An error condition if any occurred, else Success.

Implements Loki::LevelMutexInfo.

References Loki::LevelMutexInfo::GetLevel(), Loki::LevelMutexInfo::IsLockedByCurrentThread(), Loki::LevelMutexInfo::IsValid(), and Loki::LevelMutexInfo::PostLock().

Here is the call graph for this function:

template<class MutexPolicy , unsigned int DefaultLevel, class ErrorPolicy = ::Loki::ThrowOnBadDesignMutexError, class WaitPolicy = ::Loki::NoMutexWait>
virtual MutexErrors::Type Loki::LevelMutex< MutexPolicy, DefaultLevel, ErrorPolicy, WaitPolicy >::Lock ( void   )  volatile [inline, virtual]

Blocking call will attempt to lock mutex and wait until it can lock. This may throw an exception if the lock failed or an error occurred - if that is what the error policy specifies.

Returns:
An error condition if any occurred, else Success.

Implements Loki::LevelMutexInfo.

References Loki::LevelMutexInfo::GetLevel(), Loki::LevelMutexInfo::IsLockedByCurrentThread(), Loki::LevelMutexInfo::IsValid(), and Loki::LevelMutexInfo::PostLock().

Here is the call graph for this function:

template<class MutexPolicy , unsigned int DefaultLevel, class ErrorPolicy = ::Loki::ThrowOnBadDesignMutexError, class WaitPolicy = ::Loki::NoMutexWait>
virtual MutexErrors::Type Loki::LevelMutex< MutexPolicy, DefaultLevel, ErrorPolicy, WaitPolicy >::TryLock ( void   )  volatile [inline, virtual]

Tries to lock mutex, and returns immediately if mutex already locked by another thread. It will return immediately with a value of AlreadyLocked if the mutex was locked by a different thread. It may throw an exception or assert when errors occur if the ErrorPolicy class implements that behavior.

Returns:
An error condition if any occurred, else Success.

Implements Loki::LevelMutexInfo.

References Loki::LevelMutexInfo::GetLevel(), Loki::LevelMutexInfo::GetLockCount(), Loki::LevelMutexInfo::IsValid(), and Loki::LevelMutexInfo::PostLock().

Here is the call graph for this function:

template<class MutexPolicy , unsigned int DefaultLevel, class ErrorPolicy = ::Loki::ThrowOnBadDesignMutexError, class WaitPolicy = ::Loki::NoMutexWait>
virtual MutexErrors::Type Loki::LevelMutex< MutexPolicy, DefaultLevel, ErrorPolicy, WaitPolicy >::Unlock ( void   )  volatile [inline, virtual]

Unlocks the mutex, or returns an error condition. This may throw an exception if the lock failed or an error occurred - if that is what the error policy specifies.

Returns:
An error condition if any occurred, else Success.

Implements Loki::LevelMutexInfo.

References Loki::LevelMutexInfo::GetLevel(), Loki::LevelMutexInfo::IsValid(), Loki::LevelMutexInfo::PostLock(), and Loki::LevelMutexInfo::PreUnlock().

Here is the call graph for this function:


The documentation for this class was generated from the following file:

Generated on Thu Jan 29 18:51:43 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00200.dot0000755000175000017500000000265611140366254015620 0ustar ivanivandigraph structs { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node0 [label="Cached Factory",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node4 [label="Eviction policies",height=0.2,width=0.4,color="black",URL="$a00203.html",tooltip="Gathers informations about the stored objects and choose a candidate for eviction..."]; Node2 [label="Encapsulation policies",height=0.2,width=0.4,color="black",URL="$a00201.html",tooltip="Defines how the object is returned to the client."]; Node1 [label="Factories",height=0.2,width=0.4,color="black",URL="$a00198.html"]; Node5 [label="Statistic policies",height=0.2,width=0.4,color="black",URL="$a00204.html",tooltip="Gathers information about the cache."]; Node3 [label="Creation policies",height=0.2,width=0.4,color="black",URL="$a00202.html",tooltip="Defines a way to limit the creation operation."]; Node1->Node0 [shape=plaintext, color="midnightblue", dir="back", style="solid"]; Node0->Node2 [shape=plaintext, color="midnightblue", dir="back", style="solid"]; Node0->Node3 [shape=plaintext, color="midnightblue", dir="back", style="solid"]; Node0->Node4 [shape=plaintext, color="midnightblue", dir="back", style="solid"]; Node0->Node5 [shape=plaintext, color="midnightblue", dir="back", style="solid"]; } libloki-0.1.7.orig/doc/html/a00201.dot0000755000175000017500000000111311140366254015604 0ustar ivanivandigraph structs { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node1 [label="Cached Factory",height=0.2,width=0.4,color="black",URL="$a00200.html",tooltip="CachedFactory provides an extension of a Factory with caching support."]; Node0 [label="Encapsulation policies",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1->Node0 [shape=plaintext, color="midnightblue", dir="back", style="solid"]; } libloki-0.1.7.orig/doc/html/a00385.html0000755000175000017500000000426011140366260016002 0ustar ivanivan Loki: Member List

Loki::DeletableSingleton< T > Member List

This is the complete list of members for Loki::DeletableSingleton< T >, including all inherited members.

GracefulDelete()Loki::DeletableSingleton< T > [inline, static]


Generated on Thu Jan 29 18:51:44 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00202.dot0000755000175000017500000000110611140366254015607 0ustar ivanivandigraph structs { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node1 [label="Cached Factory",height=0.2,width=0.4,color="black",URL="$a00200.html",tooltip="CachedFactory provides an extension of a Factory with caching support."]; Node0 [label="Creation policies",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1->Node0 [shape=plaintext, color="midnightblue", dir="back", style="solid"]; } libloki-0.1.7.orig/doc/html/a00203.dot0000755000175000017500000000110611140366254015610 0ustar ivanivandigraph structs { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node1 [label="Cached Factory",height=0.2,width=0.4,color="black",URL="$a00200.html",tooltip="CachedFactory provides an extension of a Factory with caching support."]; Node0 [label="Eviction policies",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1->Node0 [shape=plaintext, color="midnightblue", dir="back", style="solid"]; } libloki-0.1.7.orig/doc/html/a00204.dot0000755000175000017500000000110711140366254015612 0ustar ivanivandigraph structs { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node1 [label="Cached Factory",height=0.2,width=0.4,color="black",URL="$a00200.html",tooltip="CachedFactory provides an extension of a Factory with caching support."]; Node0 [label="Statistic policies",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1->Node0 [shape=plaintext, color="midnightblue", dir="back", style="solid"]; } libloki-0.1.7.orig/doc/html/a00444.html0000755000175000017500000000363111140366261016000 0ustar ivanivan Loki: Member List

Loki::BaseVisitor Member List

This is the complete list of members for Loki::BaseVisitor, including all inherited members.


Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00199.html0000755000175000017500000000431211140366254016006 0ustar ivanivan Loki: Abstract Factory

Abstract Factory
[Factories]

Implements an abstract object factory. More...

Collaboration diagram for Abstract Factory:

Classes

class  AbstractFactory
 Implements an abstract object factory. More...

Detailed Description

Implements an abstract object factory.

Generated on Thu Jan 29 18:51:40 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00205.dot0000755000175000017500000000134411140366254015616 0ustar ivanivandigraph structs { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node2 [label="Factory Error Policies",height=0.2,width=0.4,color="black",URL="$a00206.html",tooltip="Manages the "Unknown Type" error in an object factory."]; Node1 [label="Factories",height=0.2,width=0.4,color="black",URL="$a00198.html"]; Node0 [label="Factory",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1->Node0 [shape=plaintext, color="midnightblue", dir="back", style="solid"]; Node0->Node2 [shape=plaintext, color="midnightblue", dir="back", style="solid"]; } libloki-0.1.7.orig/doc/html/a00206.dot0000755000175000017500000000104211140366254015612 0ustar ivanivandigraph structs { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node0 [label="Factory Error Policies",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1 [label="Factory",height=0.2,width=0.4,color="black",URL="$a00205.html",tooltip="Implements a generic object factory."]; Node1->Node0 [shape=plaintext, color="midnightblue", dir="back", style="solid"]; } libloki-0.1.7.orig/doc/html/a00207.dot0000755000175000017500000000075411140366254015624 0ustar ivanivandigraph structs { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node0 [label="Clone Factory",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1 [label="Factories",height=0.2,width=0.4,color="black",URL="$a00198.html"]; Node1->Node0 [shape=plaintext, color="midnightblue", dir="back", style="solid"]; } libloki-0.1.7.orig/doc/html/a00002.html0000755000175000017500000003126711140366261015774 0ustar ivanivan Loki: Loki::AllocatorSingleton< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > Class Template Reference

Loki::AllocatorSingleton< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > Class Template Reference
[Internals]

#include <SmallObj.h>

Inheritance diagram for Loki::AllocatorSingleton< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >:
[legend]
Collaboration diagram for Loki::AllocatorSingleton< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >:
[legend]

List of all members.

Public Types

typedef AllocatorSingleton
< ThreadingModel, chunkSize,
maxSmallObjectSize,
objectAlignSize,
LifetimePolicy > 
MyAllocator
 Defines type of allocator.
typedef ThreadingModel
< MyAllocator, MutexPolicy > 
MyThreadingModel
 Defines type for thread-safety locking mechanism.
typedef Loki::SingletonHolder
< MyAllocator,
Loki::CreateStatic,
LifetimePolicy, ThreadingModel > 
MyAllocatorSingleton
 Defines singleton made from allocator.

Public Member Functions

 AllocatorSingleton ()
 The default constructor is not meant to be called directly.
 ~AllocatorSingleton (void)
 The destructor is not meant to be called directly.

Static Public Member Functions

static AllocatorSingletonInstance (void)
 Returns reference to the singleton.
static void ClearExtraMemory (void)
static bool IsCorrupted (void)


Detailed Description

template<template< class, class > class ThreadingModel = ::Loki::SingleThreaded, std::size_t chunkSize = 4096, std::size_t maxSmallObjectSize = 256, std::size_t objectAlignSize = 4, template< class > class LifetimePolicy = ::Loki::LongevityLifetime::DieAsSmallObjectParent, class MutexPolicy = ::Loki::Mutex>
class Loki::AllocatorSingleton< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >

This template class is derived from SmallObjAllocator in order to pass template arguments into it, and still have a default constructor for the singleton. Each instance is a unique combination of all the template parameters, and hence is singleton only with respect to those parameters. The template parameters have default values and the class has typedefs identical to both SmallObject and SmallValueObject so that this class can be used directly instead of going through SmallObject or SmallValueObject. That design feature allows clients to use the new_handler without having the name of the new_handler function show up in classes derived from SmallObject or SmallValueObject. Thus, the only functions in the allocator which show up in SmallObject or SmallValueObject inheritance hierarchies are the new and delete operators.

Member Function Documentation

template<template< class, class > class T, std::size_t C, std::size_t M, std::size_t O, template< class > class L, class X >
void Loki::AllocatorSingleton< T, C, M, O, L, X >::ClearExtraMemory ( void   )  [inline, static]

Clears any excess memory used by the allocator. Complexity is O(F + C) where F is the count of FixedAllocator's in the pool, and C is the number of Chunks in all FixedAllocator's. This never throws.

Note:
This function can be used as a new_handler when Loki and other memory allocators can no longer allocate. Although the C++ Standard allows new_handler functions to terminate the program when they can not release any memory, this will not do so.

References Loki::AllocatorSingleton< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >::Instance(), and Loki::SmallObjAllocator::TrimExcessMemory().

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 >
bool Loki::AllocatorSingleton< T, C, M, O, L, X >::IsCorrupted ( void   )  [inline, static]

Returns true if anything in implementation is corrupt. Complexity is O(F + C + B) where F is the count of FixedAllocator's in the pool, C is the number of Chunks in all FixedAllocator's, and B is the number of blocks in all Chunks. If it determines any data is corrupted, this will return true in release version, but assert in debug version at the line where it detects the corrupted data. If it does not detect any corrupted data, it returns false.

References Loki::AllocatorSingleton< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >::Instance(), and Loki::SmallObjAllocator::IsCorrupt().

Here is the call graph for this function:


The documentation for this class was generated from the following file:

Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/ftv2folderopen.png0000755000175000017500000000040511140366263017741 0ustar ivanivan‰PNG  IHDR_Tq-PLTEภภภ€€€€€’2ŒๅtRNS@ๆุftEXtSoftwaregif2png 2.4.2ฃ^G|IDATxฺ…A‚0E_๕-Sึฦืืา ฑ: !ขo๓‹€ j<*aลำCiมดซ๙pฌƒสป๛ค‹ฎ&FถL่ร๚ณ}จ๋ฅFTFN*โฮ•=บฐd“…› sqƒuื๒ง๒ ๛า๋C๙๒ ค)หฺGฌDIENDฎB`‚libloki-0.1.7.orig/doc/html/a00071.html0000755000175000017500000011541511140366256016004 0ustar ivanivan Loki: Loki::LevelMutexInfo Class Reference

Loki::LevelMutexInfo Class Reference

#include <LevelMutex.h>

Inheritance diagram for Loki::LevelMutexInfo:
[legend]
Collaboration diagram for Loki::LevelMutexInfo:
[legend]

List of all members.

Classes

class  Checker
class  MutexUndoer

Public Types

typedef ::std::vector
< volatile LevelMutexInfo * > 
MutexContainer
 Container for locking multiple mutexes at once.

Public Member Functions

unsigned int GetLevel (void) const volatile
 Returns the level of this mutex.
bool IsLocked (void) const volatile
 Returns true if this mutex was locked at least once.
unsigned int GetLockCount (void) const volatile
 Returns count of how many times this mutex got locked.
const volatile LevelMutexInfoGetPrevious (void) const volatile
 Returns pointer to mutex previously locked by the thread which locked this.
virtual MutexErrors::Type TryLock (void) volatile=0
virtual MutexErrors::Type Lock (void) volatile=0
virtual MutexErrors::Type Lock (unsigned int milliSeconds) volatile=0
virtual MutexErrors::Type Unlock (void) volatile=0
bool IsRecentLock (void) const volatile
bool IsRecentLock (unsigned int count) const volatile
bool IsLockedByCurrentThread (void) const volatile
 Returns true if this was locked by current thread.
bool IsLockedByAnotherThread (void) const volatile
 Returns true if this was locked by another thread.

Static Public Member Functions

static MutexErrors::Type MultiLock (MutexContainer &mutexes)
static MutexErrors::Type MultiLock (MutexContainer &mutexes, unsigned int milliSeconds)
static MutexErrors::Type MultiUnlock (MutexContainer &mutexes)
static const volatile
LevelMutexInfo
GetCurrentMutex (void)

Static Public Attributes

static const unsigned int UnlockedLevel = 0xFFFFFFFF

Protected Member Functions

 LevelMutexInfo (unsigned int level)
virtual ~LevelMutexInfo (void)
 The destructor only gets called by the derived class.
void PostLock (void) volatile
void PreUnlock (void) volatile
 Gets called just before an attempt to unlock a mutex.
void IncrementCount (void) volatile
 Called to relock a mutex already locked by the current thread.
void DecrementCount (void) volatile
 Called to unlock a mutex locked multiple times by the current thread.
bool IsValid (void) const volatile

Static Protected Member Functions

static bool IsValidList (void)


Detailed Description

This monolithic base class stores common info for a template class used to control mutexes. The template class, LevelMutex, is policy-based class.

Implementation
Each thread has a list of mutexes it locked. When a mutex first gets locked, it gets added to the head of the list. If locked again, LevelMutex merely increments a count. When unlocked, the count gets decremented until it reaches zero, and then it gets removed from the list. Each mutex has a pointer to the mutex most recently locked by the current thread. The current level of a thread is always the level of the most recently locked mutex, or UnlockedLevel if the thread does not have any mutexes locked now. A mutex is considered "recently" locked if it is at the head of the list, or the same level as the current mutex and also locked by the current thread.
Class Invariants
This class maintains invariants for each LevelMutexInfo so that no function calls corrupt a mutex. Each function makes a call to IsValid at the start so that LevelMutex knows it acts on valid internal data. Many functions call IsValid again when they return to insure the function did not leave any data in an invalid state. The exit call to IsValid occurs through a tiny helper class called Checker to insure all data remain valid even when exceptions occur. Another helper class, MutexUndoer, unlocks mutexes in a container if an exception occurs during calls to MultiLock.
Error Results
Many functions return an enum value to indicate an error status. Many enum values indicate errors detected within LevelMutex, but some indicate errors found in policy classes, SpinLevelMutex and SleepLevelMutex.

Constructor & Destructor Documentation

Loki::LevelMutexInfo::LevelMutexInfo ( unsigned int  level  )  [explicit, protected]

This is the only available constructor, and it forces any derived class to set a level for each mutex.

References IsValid().

Here is the call graph for this function:


Member Function Documentation

const volatile LevelMutexInfo * Loki::LevelMutexInfo::GetCurrentMutex ( void   )  [static]

Gives pointer to most recently locked mutex, or NULL if nothing locked. The pointer is for a const mutex so the mutex can't be modified inappropriately. The pointer is for a volatile mutex so callers can call volatile member functions to get info about the mutex.

References IsValidList().

Referenced by Loki::CountLocksInCurrentThread(), Loki::CountMutexesAtCurrentLevel(), Loki::CountMutexesInCurrentThread(), and Loki::GetCurrentThreadsLevel().

Here is the call graph for this function:

bool Loki::LevelMutexInfo::IsRecentLock ( unsigned int  count  )  const volatile

Returns true if this mutex was locked within the last count mutexes.

Parameters:
count How many recent mutexes to look through to find this mutex.

References IsValid(), and m_previous.

Here is the call graph for this function:

bool Loki::LevelMutexInfo::IsRecentLock ( void   )  const volatile

Returns true if this mutex was locked by current thread, and level is the same as the current thread's level. Which means this was the most recently locked mutex, or it was locked along with several others of the same level recently.

References IsValid(), m_level, and m_previous.

Referenced by Loki::DoMutexesMatchContainer().

Here is the call graph for this function:

bool Loki::LevelMutexInfo::IsValid ( void   )  const volatile [protected]

bool Loki::LevelMutexInfo::IsValidList ( void   )  [static, protected]

Returns true if linked-list of locked mutexes in this thread is valid. Which means the list has no loops, and each previous mutex on the list has a higher or same level as the current mutex. Called by IsValid.

References m_level, and m_previous.

Referenced by GetCurrentMutex(), IsValid(), MultiLock(), and MultiUnlock().

virtual MutexErrors::Type Loki::LevelMutexInfo::Lock ( unsigned int  milliSeconds  )  volatile [pure virtual]

Attempts to lock mutex, but only waits for a limited amount of time before it gives up. Will return quickly if an error occurs before any attempt to lock. This may throw an exception if the lock failed or an error occurred - if that is what the error policy specifies.

Parameters:
milliSeconds How long to wait.
Returns:
An error condition if any occurred, else Success.

Implemented in Loki::LevelMutex< MutexPolicy, DefaultLevel, ErrorPolicy, WaitPolicy >.

virtual MutexErrors::Type Loki::LevelMutexInfo::Lock ( void   )  volatile [pure virtual]

Blocking call will attempt to lock mutex and wait until it can lock. This may throw an exception if the lock failed or an error occurred - if that is what the error policy specifies.

Returns:
An error condition if any occurred, else Success.

Implemented in Loki::LevelMutex< MutexPolicy, DefaultLevel, ErrorPolicy, WaitPolicy >.

Referenced by Loki::MutexLocker::Lock(), and Loki::MutexLocker::MutexLocker().

MutexErrors::Type Loki::LevelMutexInfo::MultiLock ( MutexContainer mutexes,
unsigned int  milliSeconds 
) [static]

Locks several mutexes at once. Requires O(m + n*n + n*t) actions where m is the number of mutexes currently locked by the thread, n is the number of mutexes in the container, and t is the wait time for each mutex. This provides strong exception safety. If an exception occurs, any mutexes that were locked during this call will ge unlocked.

Parameters:
mutexes Container of pointers to mutexes. Container must have at least 1 mutex, all mutexes must have the same level, no NULL pointers, and all mutexes must not exceed the thread's current level. This sorts the container by address order.
milliSeconds Amount of time to wait for each mutex.
Returns:
Enum value indicating success or error.

References Loki::LevelMutexInfo::LevelMutexInfo::MutexUndoer::Cancel(), DoErrorCheck(), Loki::DoMutexesMatchContainer(), Loki::GetCurrentThreadsLevel(), IsValidList(), MultiLock(), Loki::LevelMutexInfo::LevelMutexInfo::MutexUndoer::SetPlace(), and UnlockedLevel.

Here is the call graph for this function:

MutexErrors::Type Loki::LevelMutexInfo::MultiLock ( MutexContainer mutexes  )  [static]

Locks several mutexes at once. Requires O(m + n*n) actions where m is the number of mutexes currently locked by the thread and n is the number of mutexes in the container. This provides strong exception safety. If an exception occurs, any mutexes that were locked during this call will get unlocked.

Parameters:
mutexes Container of pointers to mutexes. Container must have at least 1 mutex, all mutexes must have the same level, no NULL pointers, and all mutexes must not exceed the thread's current level. This sorts the container by address order.
Returns:
Enum value indicating success or error.

References Loki::LevelMutexInfo::LevelMutexInfo::MutexUndoer::Cancel(), DoErrorCheck(), Loki::DoMutexesMatchContainer(), Loki::GetCurrentThreadsLevel(), IsValidList(), Loki::LevelMutexInfo::LevelMutexInfo::MutexUndoer::SetPlace(), and UnlockedLevel.

Referenced by Loki::MultiMutexLocker::Lock(), MultiLock(), and Loki::MultiMutexLocker::MultiMutexLocker().

Here is the call graph for this function:

MutexErrors::Type Loki::LevelMutexInfo::MultiUnlock ( MutexContainer mutexes  )  [static]

Unlocks several mutexes at once. Requires O(m) actions where m is the number of mutexes in the container. This provides strong exception safety. If an exception occurs when unlocking one mutex, other mutexes in the container get unlocked anyway.

Parameters:
mutexes Container of pointers to mutexes. Container must have at least 1 mutex, all mutexes must have the same level, no NULL pointers, and all mutexes must be locked by the current thread. This sorts the container dby address order.
Returns:
Enum value indicating success or error.

References DoErrorCheck(), Loki::DoMutexesMatchContainer(), IsValidList(), UnlockedLevel, and UnlockThis().

Referenced by Loki::MultiMutexLocker::Unlock(), and Loki::MultiMutexLocker::~MultiMutexLocker().

Here is the call graph for this function:

void Loki::LevelMutexInfo::PostLock ( void   )  volatile [protected]

This gets called after each call to DoLock and DoTryLock to make sure the data members in this object get set correctly.

References IsLockedByCurrentThread(), and IsValid().

Referenced by Loki::LevelMutex< MutexPolicy, DefaultLevel, ErrorPolicy, WaitPolicy >::Lock(), Loki::LevelMutex< MutexPolicy, DefaultLevel, ErrorPolicy, WaitPolicy >::TryLock(), and Loki::LevelMutex< MutexPolicy, DefaultLevel, ErrorPolicy, WaitPolicy >::Unlock().

Here is the call graph for this function:

virtual MutexErrors::Type Loki::LevelMutexInfo::TryLock ( void   )  volatile [pure virtual]

Tries to lock mutex, and returns immediately if mutex already locked by another thread. It will return immediately with a value of AlreadyLocked if the mutex was locked by a different thread. It may throw an exception or assert when errors occur if the ErrorPolicy class implements that behavior.

Returns:
An error condition if any occurred, else Success.

Implemented in Loki::LevelMutex< MutexPolicy, DefaultLevel, ErrorPolicy, WaitPolicy >.

virtual MutexErrors::Type Loki::LevelMutexInfo::Unlock ( void   )  volatile [pure virtual]

Unlocks the mutex, or returns an error condition. This may throw an exception if the lock failed or an error occurred - if that is what the error policy specifies.

Returns:
An error condition if any occurred, else Success.

Implemented in Loki::LevelMutex< MutexPolicy, DefaultLevel, ErrorPolicy, WaitPolicy >.

Referenced by Loki::MutexLocker::Unlock(), and Loki::MutexLocker::~MutexLocker().


Member Data Documentation

const unsigned int Loki::LevelMutexInfo::UnlockedLevel = 0xFFFFFFFF [static]

Level for thread that has not locked any mutex. Maximum possible level for a mutex is UnlockedLevel-1; No mutex may have a level of UnlockedLevel.

Referenced by Loki::DoMutexesMatchContainer(), Loki::GetCurrentThreadsLevel(), IsValid(), MultiLock(), and MultiUnlock().


The documentation for this class was generated from the following files:

Generated on Thu Jan 29 18:51:42 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00386.html0000755000175000017500000000370511140366260016006 0ustar ivanivan Loki: Member List

Loki::SingletonWithLongevity< T > Member List

This is the complete list of members for Loki::SingletonWithLongevity< T >, including all inherited members.


Generated on Thu Jan 29 18:51:44 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00212.dot0000755000175000017500000000123611140366254015614 0ustar ivanivandigraph structs { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node1 [label="Creation policies",height=0.2,width=0.4,color="black",URL="$a00213.html"]; Node2 [label="Lifetime policies",height=0.2,width=0.4,color="black",URL="$a00214.html"]; Node0 [label="Singleton",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node0->Node1 [shape=plaintext, color="midnightblue", dir="back", style="solid"]; Node0->Node2 [shape=plaintext, color="midnightblue", dir="back", style="solid"]; } libloki-0.1.7.orig/doc/html/a00130.html0000755000175000017500000001022511140366261015765 0ustar ivanivan Loki: Loki::SmallValueObject< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > Class Template Reference

Loki::SmallValueObject< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > Class Template Reference
[Small objects]

#include <SmallObj.h>

Inheritance diagram for Loki::SmallValueObject< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >:
[legend]
Collaboration diagram for Loki::SmallValueObject< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >:
[legend]

List of all members.


Detailed Description

template<template< class, class > class ThreadingModel = ::Loki::SingleThreaded, std::size_t chunkSize = 4096, std::size_t maxSmallObjectSize = 256, std::size_t objectAlignSize = 4, template< class > class LifetimePolicy = ::Loki::LongevityLifetime::DieAsSmallObjectParent, class MutexPolicy = ::Loki::Mutex>
class Loki::SmallValueObject< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >

SmallValueObject Base class for small objects with value-type semantics - offers fast allocations & deallocations. Destructor is non-virtual, inline, and protected to prevent unintentional destruction through base class. Default constructor is trivial. Copy-constructor and copy-assignment operator are trivial since value-types almost always need those operations. Class has no data members so compilers can use Empty-Base-Optimization.
The documentation for this class was generated from the following file:

Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00213.dot0000755000175000017500000000076011140366254015616 0ustar ivanivandigraph structs { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node0 [label="Creation policies",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1 [label="Singleton",height=0.2,width=0.4,color="black",URL="$a00212.html"]; Node1->Node0 [shape=plaintext, color="midnightblue", dir="back", style="solid"]; } libloki-0.1.7.orig/doc/html/a00214.dot0000755000175000017500000000123611140366254015616 0ustar ivanivandigraph structs { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node0 [label="Lifetime policies",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1 [label="Singleton",height=0.2,width=0.4,color="black",URL="$a00212.html"]; Node2 [label="LongevityLifetime",height=0.2,width=0.4,color="black",URL="$a00215.html"]; Node1->Node0 [shape=plaintext, color="midnightblue", dir="back", style="solid"]; Node0->Node2 [shape=plaintext, color="midnightblue", dir="back", style="solid"]; } libloki-0.1.7.orig/doc/html/a00215.dot0000755000175000017500000000077011140366254015621 0ustar ivanivandigraph structs { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node1 [label="Lifetime policies",height=0.2,width=0.4,color="black",URL="$a00214.html"]; Node0 [label="LongevityLifetime",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1->Node0 [shape=plaintext, color="midnightblue", dir="back", style="solid"]; } libloki-0.1.7.orig/doc/html/a00216.dot0000755000175000017500000000075411140366254015624 0ustar ivanivandigraph structs { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node0 [label="Small objects",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1 [label="Internals",height=0.2,width=0.4,color="black",URL="$a00217.html"]; Node0->Node1 [shape=plaintext, color="midnightblue", dir="back", style="solid"]; } libloki-0.1.7.orig/doc/html/a00217.dot0000755000175000017500000000075411140366254015625 0ustar ivanivandigraph structs { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node1 [label="Small objects",height=0.2,width=0.4,color="black",URL="$a00216.html"]; Node0 [label="Internals",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1->Node0 [shape=plaintext, color="midnightblue", dir="back", style="solid"]; } libloki-0.1.7.orig/doc/html/a00218.dot0000755000175000017500000000302111140366254015614 0ustar ivanivandigraph structs { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node2 [label="Storage policies",height=0.2,width=0.4,color="black",URL="$a00220.html"]; Node7 [label="Reset policies",height=0.2,width=0.4,color="black",URL="$a00225.html"]; Node4 [label="Checking policies",height=0.2,width=0.4,color="black",URL="$a00222.html"]; Node5 [label="StrongPtr Ownership policies",height=0.2,width=0.4,color="black",URL="$a00223.html"]; Node0 [label="Smart pointers",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1 [label="Ownership policies",height=0.2,width=0.4,color="black",URL="$a00219.html"]; Node6 [label="Delete policies",height=0.2,width=0.4,color="black",URL="$a00224.html"]; Node3 [label="Conversion policies",height=0.2,width=0.4,color="black",URL="$a00221.html"]; Node0->Node1 [shape=plaintext, color="midnightblue", dir="back", style="solid"]; Node0->Node2 [shape=plaintext, color="midnightblue", dir="back", style="solid"]; Node0->Node3 [shape=plaintext, color="midnightblue", dir="back", style="solid"]; Node0->Node4 [shape=plaintext, color="midnightblue", dir="back", style="solid"]; Node0->Node5 [shape=plaintext, color="midnightblue", dir="back", style="solid"]; Node0->Node6 [shape=plaintext, color="midnightblue", dir="back", style="solid"]; Node0->Node7 [shape=plaintext, color="midnightblue", dir="back", style="solid"]; } libloki-0.1.7.orig/doc/html/a00003.html0000755000175000017500000000506411140366261015771 0ustar ivanivan Loki: Loki::AllowConversion Struct Reference

Loki::AllowConversion Struct Reference
[Conversion policies]

#include <SmartPtr.h>

List of all members.


Detailed Description

Implementation of the ConversionPolicy used by SmartPtr Allows implicit conversion from SmartPtr to the pointee type
The documentation for this struct was generated from the following file:

Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00219.dot0000755000175000017500000000076611140366255015633 0ustar ivanivandigraph structs { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node1 [label="Smart pointers",height=0.2,width=0.4,color="black",URL="$a00218.html"]; Node0 [label="Ownership policies",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1->Node0 [shape=plaintext, color="midnightblue", dir="back", style="solid"]; } libloki-0.1.7.orig/doc/html/a00318.html0000755000175000017500000001753111140366256016010 0ustar ivanivan Loki: Member List

Loki::LevelMutexInfo Member List

This is the complete list of members for Loki::LevelMutexInfo, including all inherited members.

DecrementCount(void) volatileLoki::LevelMutexInfo [protected]
GetCurrentMutex(void)Loki::LevelMutexInfo [static]
GetLevel(void) const volatileLoki::LevelMutexInfo [inline]
GetLockCount(void) const volatileLoki::LevelMutexInfo [inline]
GetPrevious(void) const volatileLoki::LevelMutexInfo [inline]
IncrementCount(void) volatileLoki::LevelMutexInfo [protected]
IsLocked(void) const volatileLoki::LevelMutexInfo [inline]
IsLockedByAnotherThread(void) const volatileLoki::LevelMutexInfo
IsLockedByCurrentThread(void) const volatileLoki::LevelMutexInfo
IsRecentLock(void) const volatileLoki::LevelMutexInfo
IsRecentLock(unsigned int count) const volatileLoki::LevelMutexInfo
IsValid(void) const volatileLoki::LevelMutexInfo [protected]
IsValidList(void)Loki::LevelMutexInfo [protected, static]
LevelMutexInfo(unsigned int level)Loki::LevelMutexInfo [explicit, protected]
Lock(void) volatile=0Loki::LevelMutexInfo [pure virtual]
Lock(unsigned int milliSeconds) volatile=0Loki::LevelMutexInfo [pure virtual]
MultiLock(MutexContainer &mutexes)Loki::LevelMutexInfo [static]
MultiLock(MutexContainer &mutexes, unsigned int milliSeconds)Loki::LevelMutexInfo [static]
MultiUnlock(MutexContainer &mutexes)Loki::LevelMutexInfo [static]
MutexContainer typedefLoki::LevelMutexInfo
PostLock(void) volatileLoki::LevelMutexInfo [protected]
PreUnlock(void) volatileLoki::LevelMutexInfo [protected]
TryLock(void) volatile=0Loki::LevelMutexInfo [pure virtual]
Unlock(void) volatile=0Loki::LevelMutexInfo [pure virtual]
UnlockedLevelLoki::LevelMutexInfo [static]
~LevelMutexInfo(void)Loki::LevelMutexInfo [protected, virtual]


Generated on Thu Jan 29 18:51:42 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00072.html0000755000175000017500000000574411140366256016010 0ustar ivanivan Loki: Loki::LevelMutexInfo::LevelMutexInfo::Checker Class Reference

Loki::LevelMutexInfo::LevelMutexInfo::Checker Class Reference

Collaboration diagram for Loki::LevelMutexInfo::LevelMutexInfo::Checker:
[legend]

List of all members.


Detailed Description

check on mutex to insure no class invariants were violated inside any member function. This class only gets used in debug builds, and any instance of it gets optimized away in release builds. A checker is created inside many of member functions so that it's destructor gets called when the function exits. It determines if any class invariants were violated during the function call.
The documentation for this class was generated from the following file:

Generated on Thu Jan 29 18:51:42 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00220.dot0000755000175000017500000000076411140366255015621 0ustar ivanivandigraph structs { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node0 [label="Storage policies",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1 [label="Smart pointers",height=0.2,width=0.4,color="black",URL="$a00218.html"]; Node1->Node0 [shape=plaintext, color="midnightblue", dir="back", style="solid"]; } libloki-0.1.7.orig/doc/html/a00221.dot0000755000175000017500000000076711140366255015625 0ustar ivanivandigraph structs { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node1 [label="Smart pointers",height=0.2,width=0.4,color="black",URL="$a00218.html"]; Node0 [label="Conversion policies",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1->Node0 [shape=plaintext, color="midnightblue", dir="back", style="solid"]; } libloki-0.1.7.orig/doc/html/namespacemembers_func.html0000755000175000017500000001147611140366263021516 0ustar ivanivan Loki: Class Members
 

- b -

- c -

- d -

- g -

- o -

- r -

- s -

- u -


Generated on Thu Jan 29 18:51:47 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00387.html0000755000175000017500000000365311140366260016011 0ustar ivanivan Loki: Member List

Loki::NoDestroy< T > Member List

This is the complete list of members for Loki::NoDestroy< T >, including all inherited members.


Generated on Thu Jan 29 18:51:44 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00222.dot0000755000175000017500000000076511140366255015624 0ustar ivanivandigraph structs { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node0 [label="Checking policies",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1 [label="Smart pointers",height=0.2,width=0.4,color="black",URL="$a00218.html"]; Node1->Node0 [shape=plaintext, color="midnightblue", dir="back", style="solid"]; } libloki-0.1.7.orig/doc/html/a00131.html0000755000175000017500000000772211140366261015776 0ustar ivanivan Loki: Loki::SmartPointer< AbstractProduct, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ConstnessPolicy > Class Template Reference

Loki::SmartPointer< AbstractProduct, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ConstnessPolicy > Class Template Reference
[Encapsulation policies]

Encapsulate the object in a SmartPtr with FunctionStorage policy. More...

#include <SPCachedFactory.h>

List of all members.


Detailed Description

template<class AbstractProduct, template< class > class OwnershipPolicy = RefCounted, class ConversionPolicy = DisallowConversion, template< class > class CheckingPolicy = AssertCheck, template< class > class ConstnessPolicy = LOKI_DEFAULT_CONSTNESS>
class Loki::SmartPointer< AbstractProduct, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ConstnessPolicy >

Encapsulate the object in a SmartPtr with FunctionStorage policy.

The object will come back to the Cache as soon as no more SmartPtr are referencing this object. You can customize the SmartPointer with the standard SmartPtr policies (OwnershipPolicy, ConversionPolicy, CheckingPolicy, ConstnessPolicy) but StoragePolicy is forced to FunctionStorage.


The documentation for this class was generated from the following file:

Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00223.dot0000755000175000017500000000100011140366255015604 0ustar ivanivandigraph structs { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node0 [label="StrongPtr Ownership policies",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1 [label="Smart pointers",height=0.2,width=0.4,color="black",URL="$a00218.html"]; Node1->Node0 [shape=plaintext, color="midnightblue", dir="back", style="solid"]; } libloki-0.1.7.orig/doc/html/a00224.dot0000755000175000017500000000076311140366255015624 0ustar ivanivandigraph structs { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node1 [label="Smart pointers",height=0.2,width=0.4,color="black",URL="$a00218.html"]; Node0 [label="Delete policies",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1->Node0 [shape=plaintext, color="midnightblue", dir="back", style="solid"]; } libloki-0.1.7.orig/doc/html/a00225.dot0000755000175000017500000000076211140366255015624 0ustar ivanivandigraph structs { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node0 [label="Reset policies",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1 [label="Smart pointers",height=0.2,width=0.4,color="black",URL="$a00218.html"]; Node1->Node0 [shape=plaintext, color="midnightblue", dir="back", style="solid"]; } libloki-0.1.7.orig/doc/html/a00083_aeffc60518694479ac9985ee1878ed0f_cgraph.dot0000755000175000017500000000147411140366257023660 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node1 [label="Loki::MutexLocker::MutexLocker",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1 -> Node2 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::LevelMutexInfo::GetLevel",height=0.2,width=0.4,color="black",URL="$a00071.html#1cad7c6b6fc50e230401e4cc22761d14",tooltip="Returns the level of this mutex."]; Node1 -> Node3 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node3 [label="Loki::LevelMutexInfo::Lock",height=0.2,width=0.4,color="black",URL="$a00071.html#c0e21e08ee9974533a4da5008452bd04"]; } libloki-0.1.7.orig/doc/html/a00083_aeffc60518694479ac9985ee1878ed0f_cgraph.md50000755000175000017500000000004011140366257023543 0ustar ivanivan2fed2b030039dd864733cd18f2b9dac5libloki-0.1.7.orig/doc/html/a00071_a76848d3aa8e6c66454bd5357f715583_cgraph.dot0000755000175000017500000001067411140366256023421 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node1 [label="Loki::LevelMutexInfo::MultiLock",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1 -> Node2 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::LevelMutexInfo::MutexUndoer::Cancel",height=0.2,width=0.4,color="black",URL="$a00073.html#87e777d849336fe81907e55aaad1edaa"]; Node1 -> Node3 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node3 [label="Loki::LevelMutexInfo::DoErrorCheck",height=0.2,width=0.4,color="black",URL="$a00071.html#14e0d51318b864645bbb3df4f7c9f7ab"]; Node1 -> Node4 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node4 [label="Loki::DoMutexesMatchContainer",height=0.2,width=0.4,color="black",URL="$a00192.html#d633ca81ae0befaf235ae63886368037"]; Node4 -> Node5 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node5 [label="Loki::CountMutexesAtCurrentLevel",height=0.2,width=0.4,color="black",URL="$a00192.html#8cb767d3e7aaf2fe44b8f3b90218b876"]; Node5 -> Node6 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node6 [label="Loki::LevelMutexInfo::GetCurrentMutex",height=0.2,width=0.4,color="black",URL="$a00071.html#b7fd94847721b118979b72121472d3e2"]; Node6 -> Node7 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node7 [label="Loki::LevelMutexInfo::IsValidList",height=0.2,width=0.4,color="black",URL="$a00071.html#01f6dfba5d2ea5606109b34e5a543cf0"]; Node5 -> Node8 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node8 [label="Loki::LevelMutexInfo::GetLevel",height=0.2,width=0.4,color="black",URL="$a00071.html#1cad7c6b6fc50e230401e4cc22761d14",tooltip="Returns the level of this mutex."]; Node5 -> Node9 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node9 [label="Loki::LevelMutexInfo::GetPrevious",height=0.2,width=0.4,color="black",URL="$a00071.html#b774e94ff72724dd87ff236d99970bb5",tooltip="Returns pointer to mutex previously locked by the thread which locked this."]; Node4 -> Node10 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node10 [label="Loki::GetCurrentThreadsLevel",height=0.2,width=0.4,color="black",URL="$a00192.html#9548795d9cda6f227a1e1241ba577ca8"]; Node10 -> Node6 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node10 -> Node8 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node4 -> Node8 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node4 -> Node11 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node11 [label="Loki::LevelMutexInfo::IsRecentLock",height=0.2,width=0.4,color="black",URL="$a00071.html#b917108c3e7c83b8a515d28e91a3a3ca"]; Node11 -> Node12 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node12 [label="Loki::LevelMutexInfo::IsValid",height=0.2,width=0.4,color="black",URL="$a00071.html#36c34ecf5d019f3db9bfb8654cf49176"]; Node12 -> Node7 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node1 -> Node10 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node1 -> Node7 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node1 -> Node13 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node13 [label="Loki::LevelMutexInfo::MultiLock",height=0.2,width=0.4,color="black",URL="$a00071.html#dde650eae1cad8b4723e68cdb9130283"]; Node13 -> Node2 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node13 -> Node3 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node13 -> Node4 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node13 -> Node10 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node13 -> Node7 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node13 -> Node14 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node14 [label="Loki::LevelMutexInfo::MutexUndoer::SetPlace",height=0.2,width=0.4,color="black",URL="$a00073.html#65a5d0ff95ed8ab37280350f6a10259c"]; Node1 -> Node14 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; } libloki-0.1.7.orig/doc/html/a00071_a76848d3aa8e6c66454bd5357f715583_cgraph.md50000755000175000017500000000004011140366256023302 0ustar ivanivan79053db96755fddfe65417c29583ddfelibloki-0.1.7.orig/doc/html/a00004.html0000755000175000017500000000513211140366261015766 0ustar ivanivan Loki: Loki::AllowReset< P > Class Template Reference

Loki::AllowReset< P > Class Template Reference
[Reset policies]

#include <StrongPtr.h>

List of all members.


Detailed Description

template<class P>
class Loki::AllowReset< P >

Implementation of the ResetPolicy used by StrongPtr. It allows reset and release under any circumstance.
The documentation for this class was generated from the following file:

Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00073.html0000755000175000017500000000537711140366256016013 0ustar ivanivan Loki: Loki::LevelMutexInfo::LevelMutexInfo::MutexUndoer Class Reference

Loki::LevelMutexInfo::LevelMutexInfo::MutexUndoer Class Reference

#include <LevelMutex.h>

List of all members.


Detailed Description

Undoes actions by MultiLock if an exception occurs. It keeps track of which mutexes in a container got locked, and if an exception occurs, then the destructor unlocks them. If MultiLock succeeds, then it cancels the undoer so nothing gets unlocked inadvertently.
The documentation for this class was generated from the following files:

Generated on Thu Jan 29 18:51:42 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00388.html0000755000175000017500000000415111140366260016004 0ustar ivanivan Loki: Member List

Loki::FollowIntoDeath::FollowIntoDeath::AfterMaster< Master >::FollowIntoDeath::AfterMaster::IsDestroyed< F > Member List

This is the complete list of members for Loki::FollowIntoDeath::FollowIntoDeath::AfterMaster< Master >::FollowIntoDeath::AfterMaster::IsDestroyed< F >, including all inherited members.


Generated on Thu Jan 29 18:51:44 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00132.html0000755000175000017500000001006111140366261015765 0ustar ivanivan Loki: Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy > Class Template Reference

Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy > Class Template Reference
[Smart pointers]

#include <SmartPtr.h>

List of all members.


Detailed Description

template<typename T, template< class > class OwnershipPolicy, class ConversionPolicy, template< class > class CheckingPolicy, template< class > class StoragePolicy, template< class > class ConstnessPolicy>
class Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy >

Parameters:
OwnershipPolicy default = RefCounted,
ConversionPolicy default = DisallowConversion,
CheckingPolicy default = AssertCheck,
StoragePolicy default = DefaultSPStorage
ConstnessPolicy default = LOKI_DEFAULT_CONSTNESS
IMPORTANT NOTE
Due to threading issues, the OwnershipPolicy has been changed as follows:

The documentation for this class was generated from the following file:

Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00218_gb5a35f4e3da89fb451c36891a96ab244_cgraph.dot0000755000175000017500000000116311140366254023760 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node1 [label="Loki::operator==",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1 -> Node2 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::StrongPtr::Equals",height=0.2,width=0.4,color="black",URL="$a00135.html#0c197e9b4f68669529435577357ffa57",tooltip="Helper function which can be called to avoid exposing GetPointer function."]; } libloki-0.1.7.orig/doc/html/a00218_gb5a35f4e3da89fb451c36891a96ab244_cgraph.md50000755000175000017500000000004011140366254023650 0ustar ivanivanca45b4417f7d100df8fec30598fc6a49libloki-0.1.7.orig/doc/html/a00447.html0000755000175000017500000000370111140366261016001 0ustar ivanivan Loki: Member List

Loki::CyclicVisitor< R, TList > Member List

This is the complete list of members for Loki::CyclicVisitor< R, TList >, including all inherited members.


Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00005.html0000755000175000017500000000475711140366256016007 0ustar ivanivan Loki: Loki::AlwaysCreate Class Reference

Loki::AlwaysCreate Class Reference
[Creation policies]

Always allows creation. More...

#include <CachedFactory.h>

List of all members.


Detailed Description

Always allows creation.

Doesn't limit the creation in any way


The documentation for this class was generated from the following file:

Generated on Thu Jan 29 18:51:42 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00074.html0000755000175000017500000000576311140366255016012 0ustar ivanivan Loki: LockableTwoRefCountInfo Class Reference

LockableTwoRefCountInfo Class Reference
[StrongPtr Ownership policies]

#include <StrongPtr.h>


Detailed Description

Implementation detail for thread-safe reference counting for strong and weak pointers. It uses TwoRefCountInfo to manage the pointer and counts. All this does is provide a thread safety mechanism. Since it is just a class for managing implementation details, it is not intended to be used directly - which is why it is in a private namespace. Each instance is a shared resource for all copointers, and there should be only one of these for each set of copointers. This class is small, trivial, and inline.

Note:
This class is not designed for use with a single-threaded model. Tests using a single-threaded model will not run properly, but tests in a multi-threaded model with either class-level-locking or object-level-locking do run properly.

The documentation for this class was generated from the following file:

Generated on Thu Jan 29 18:51:41 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00389.html0000755000175000017500000000414511140366260016010 0ustar ivanivan Loki: Member List

Loki::FollowIntoDeath::FollowIntoDeath::With< Lifetime >::FollowIntoDeath::With::AsMasterLifetime< Master > Member List

This is the complete list of members for Loki::FollowIntoDeath::FollowIntoDeath::With< Lifetime >::FollowIntoDeath::With::AsMasterLifetime< Master >, including all inherited members.


Generated on Thu Jan 29 18:51:44 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00133.html0000755000175000017500000001024211140366257015774 0ustar ivanivan Loki: Loki::SpinLevelMutex Class Reference

Loki::SpinLevelMutex Class Reference

#include <LevelMutex.h>

Inheritance diagram for Loki::SpinLevelMutex:
[legend]

List of all members.

Public Member Functions

 SpinLevelMutex (unsigned int level)
 Constructs a spin-level mutex.
virtual ~SpinLevelMutex (void)
 Destructs the mutex.


Detailed Description

Implements a spin-loop to wait for the mutex to unlock. Since this class makes the thread wait in a tight spin-loop, it can cause the thread to remain busy while waiting and thus consume CPU cycles. For that reason, this mutex is best used only for very low-level resources - especially resources which do not require much CPU time to exercise. Rule of thumb: Use this only if all actions on the resource consume a very small number of CPU cycles. Otherwise, use the SleepLevelMutex instead.
The documentation for this class was generated from the following files:

Generated on Thu Jan 29 18:51:43 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00448.html0000755000175000017500000000361511140366261016006 0ustar ivanivan Loki: Member List

Loki::Chunk Member List

This is the complete list of members for Loki::Chunk, including all inherited members.


Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00218_g26dc37f18d3112b69b35514b5e1fd749_cgraph.dot0000755000175000017500000000116311140366254023616 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node1 [label="Loki::operator==",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1 -> Node2 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::StrongPtr::Equals",height=0.2,width=0.4,color="black",URL="$a00135.html#0c197e9b4f68669529435577357ffa57",tooltip="Helper function which can be called to avoid exposing GetPointer function."]; } libloki-0.1.7.orig/doc/html/a00218_g26dc37f18d3112b69b35514b5e1fd749_cgraph.md50000755000175000017500000000004011140366254023506 0ustar ivanivanca45b4417f7d100df8fec30598fc6a49libloki-0.1.7.orig/doc/html/a00006.html0000755000175000017500000000527111140366256016000 0ustar ivanivan Loki: Loki::AmountLimitedCreation Class Reference

Loki::AmountLimitedCreation Class Reference
[Creation policies]

Limit by number of objects. More...

#include <CachedFactory.h>

List of all members.


Detailed Description

Limit by number of objects.

This implementation will prevent from Creating more than maxCreation objects within byTime ms by calling eviction policy. Use the setRate method to set the rate parameters. default is 10 objects.


The documentation for this class was generated from the following file:

Generated on Thu Jan 29 18:51:42 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00320.html0000755000175000017500000000372111140366256015775 0ustar ivanivan Loki: Member List

Loki::LevelMutexInfo::LevelMutexInfo::Checker Member List

This is the complete list of members for Loki::LevelMutexInfo::LevelMutexInfo::Checker, including all inherited members.


Generated on Thu Jan 29 18:51:42 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00075.html0000755000175000017500000000546211140366255016007 0ustar ivanivan Loki: LockableTwoRefCounts Class Reference

LockableTwoRefCounts Class Reference
[StrongPtr Ownership policies]

#include <StrongPtr.h>


Detailed Description

This implementation of StrongPtr's OwnershipPolicy uses a pointer to a shared instance of LockableTwoRefCountInfo. It behaves very similarly to TwoRefCounts, except that it provides thread-safety. Some functions are trivial enough to be inline, while others are implemented elsewhere.

Note:
This class is not designed for use with a single-threaded model. Tests using a single-threaded model will not run properly, but tests in a multi-threaded model with either class-level-locking or object-level-locking do run properly.

The documentation for this class was generated from the following file:

Generated on Thu Jan 29 18:51:41 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00127_2b7fbd5bf5fc56e45754abd2497ad18f_cgraph.dot0000755000175000017500000000216511140366261024040 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node1 [label="Loki::SmallObjAllocator::IsCorrupt",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1 -> Node2 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::SmallObjAllocator::GetAlignment",height=0.2,width=0.4,color="black",URL="$a00127.html#b1c8a2a3d7e9368ab59422ddd082105c",tooltip="Returns # of bytes between allocation boundaries."]; Node1 -> Node3 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node3 [label="Loki::SmallObjAllocator::GetMaxObjectSize",height=0.2,width=0.4,color="black",URL="$a00127.html#e49e9de3fd7b2fd93676cc1d63299b0d",tooltip="Returns max # of bytes which this can allocate."]; Node1 -> Node4 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node4 [label="Loki::GetOffset",height=0.2,width=0.4,color="black",URL="$a00217.html#g2f0821e243f812a3ae2abfaea51895e8"]; } libloki-0.1.7.orig/doc/html/a00127_2b7fbd5bf5fc56e45754abd2497ad18f_cgraph.md50000755000175000017500000000004011140366261023725 0ustar ivanivan73cffa1422867d06cb96929fafcd1b85libloki-0.1.7.orig/doc/html/a00134.html0000755000175000017500000002522611140366256016004 0ustar ivanivan Loki: Loki::StaticChecker< ExceptionPolicy > Class Template Reference

Loki::StaticChecker< ExceptionPolicy > Class Template Reference

#include <Checker.h>

List of all members.

Public Types

typedef bool(* Validator )(void)
 Signature for the validation function.

Public Member Functions

 StaticChecker (Validator validator, Validator pre=0, Validator post=0)
 ~StaticChecker (void)
bool Check (void) const


Detailed Description

template<class ExceptionPolicy>
class Loki::StaticChecker< ExceptionPolicy >

This class checks if a function provides the no-throw exception safety level and if the function violated any invariants. Invariants for stand-alone and static functions act as pre-conditions and post-conditions.

Usage
  1. Implement a function that checks the invariants associated with a function, or with the static data for a class. The function must have the signature similar to the Validator type. Something like: "static bool Host::StaticIsValid( void );" or "bool IsOkay( void );"
    • The function should return true if everything is okay, but false if something is wrong.
    • Or it could assert if anything is wrong.
  2. If the checker is for static functions within a class, declare typedef's inside the class declaration like these. Make one typedef for each policy you use. I typedef'ed the CheckForNothing policy as CheckInvariants because even if a function can't provide the no-throw guarantee, it should still make sure that static data remains in a valid state.
    • typedef Loki::StaticChecker< ::Loki::CheckForNoThrow > CheckStaticForNoThrow;
    • typedef Loki::StaticChecker< ::Loki::CheckForNothing > CheckStaticInvariants;
  3. Construct a checker near the top of each member function - except in the validator member function. Pass the address of your validator function into the checker's constructor.
    • If the function never throws, then use the CheckForNoThrow policy.
    • Otherwise use the CheckInvariants policy.
  4. Recompile a debug version of your program, run it, and see if an assertion fails.

Constructor & Destructor Documentation

template<class ExceptionPolicy >
Loki::StaticChecker< ExceptionPolicy >::StaticChecker ( Validator  validator,
Validator  pre = 0,
Validator  post = 0 
) [inline, explicit]

The constructor makes sure the host is valid at the time the checker was created, thus insuring the host object was not corrupt from the start.

validator Pointer to function that checks class invariants.
pre Optional pointer to function that checks pre-conditions.
post Optional pointer to function that checks post-conditions.

References Loki::StaticChecker< ExceptionPolicy >::Check().

Here is the call graph for this function:

template<class ExceptionPolicy >
Loki::StaticChecker< ExceptionPolicy >::~StaticChecker ( void   )  [inline]

The destructor checks if any Host invariants failed, and then calls the ExceptionPolicy's Check function to determine what to do in case of an exception.

References Loki::StaticChecker< ExceptionPolicy >::Check().

Here is the call graph for this function:


Member Function Documentation

template<class ExceptionPolicy >
bool Loki::StaticChecker< ExceptionPolicy >::Check ( void   )  const [inline]

This first checks its own invariants, and then calls the validator function to make sure no invariants were broken by the function which created this checker. That function can call Check directly to verify the data remains valid at any time. This does not care if the pre- and post- condition validator pointers are null since a host class may pass in NULL pointers for either to indicate the pre-conditions or post-conditions are the same as the overall class invariants.

Referenced by Loki::StaticChecker< ExceptionPolicy >::StaticChecker(), and Loki::StaticChecker< ExceptionPolicy >::~StaticChecker().


The documentation for this class was generated from the following file:

Generated on Thu Jan 29 18:51:42 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/ftv2mnode.png0000755000175000017500000000030211140366263016702 0ustar ivanivan‰PNG  IHDRLƒ1ู$PLTEภภภ€€€Sพ™tRNS@ๆุftEXtSoftwaregif2png 2.4.2ฃ^G*IDATxฺc` .เBtงRT๗n €๑มbLJJศ"05˜ฺัทy'ช๗–IENDฎB`‚libloki-0.1.7.orig/doc/html/a00007.html0000755000175000017500000000620411140366261015772 0ustar ivanivan Loki: Loki::ArrayStorage< T > Class Template Reference

Loki::ArrayStorage< T > Class Template Reference
[Storage policies]

#include <SmartPtr.h>

List of all members.

Public Types

typedef T * PointerType
 type used to declare OwnershipPolicy type.


Detailed Description

template<class T>
class Loki::ArrayStorage< T >

Implementation of the ArrayStorage used by SmartPtr
The documentation for this class was generated from the following file:

Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00321.html0000755000175000017500000000373111140366256015777 0ustar ivanivan Loki: Member List

Loki::LevelMutexInfo::LevelMutexInfo::MutexUndoer Member List

This is the complete list of members for Loki::LevelMutexInfo::LevelMutexInfo::MutexUndoer, including all inherited members.


Generated on Thu Jan 29 18:51:42 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00076.html0000755000175000017500000001311011140366261015772 0ustar ivanivan Loki: Loki::LockedStorage< T > Class Template Reference

Loki::LockedStorage< T > Class Template Reference
[Storage policies]

#include <SmartPtr.h>

List of all members.

Public Types

typedef T * InitPointerType
 the type of the pointee_ object
typedef Locker< T > PointerType
 type used to declare OwnershipPolicy type.
typedef T & ReferenceType
 type returned by operator->

Public Member Functions

 LockedStorage ()
 type returned by operator*


Detailed Description

template<class T>
class Loki::LockedStorage< T >

Implementation of the StoragePolicy used by SmartPtr.

Each call to operator-> locks the object for the duration of a call to a member function of T.

How It Works
LockedStorage has a helper class called Locker, which acts as a smart pointer with limited abilities. LockedStorage::operator-> returns an unnamed temporary of type Locker<T> that exists for the duration of the call to a member function of T. The unnamed temporary locks the object when it is constructed by operator-> and unlocks the object when it is destructed.
Note:
This storage policy requires class T to have member functions Lock and Unlock. If your class does not have Lock or Unlock functions, you may either make a child class which does, or make a policy class similar to LockedStorage which calls other functions to lock the object.

The documentation for this class was generated from the following file:

Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00070_d4ac0c2a33ff3d98ec0a83f70ce145da_cgraph.dot0000755000175000017500000000413011140366257024064 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node1 [label="Loki::LevelMutex::Lock",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1 -> Node2 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::LevelMutexInfo::GetLevel",height=0.2,width=0.4,color="black",URL="$a00071.html#1cad7c6b6fc50e230401e4cc22761d14",tooltip="Returns the level of this mutex."]; Node1 -> Node3 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node3 [label="Loki::LevelMutexInfo::IsLockedByCurrentThread",height=0.2,width=0.4,color="black",URL="$a00071.html#c0a343bcb322ea36495f536504f61f9f",tooltip="Returns true if this was locked by current thread."]; Node3 -> Node4 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node4 [label="Loki::LevelMutexInfo::IsLocked",height=0.2,width=0.4,color="black",URL="$a00071.html#e6aa7465e1bba7f0c9fbf0b06f122a39",tooltip="Returns true if this mutex was locked at least once."]; Node3 -> Node5 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node5 [label="Loki::LevelMutexInfo::IsValid",height=0.2,width=0.4,color="black",URL="$a00071.html#36c34ecf5d019f3db9bfb8654cf49176"]; Node5 -> Node6 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node6 [label="Loki::LevelMutexInfo::IsValidList",height=0.2,width=0.4,color="black",URL="$a00071.html#01f6dfba5d2ea5606109b34e5a543cf0"]; Node1 -> Node5 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node1 -> Node7 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node7 [label="Loki::LevelMutexInfo::PostLock",height=0.2,width=0.4,color="black",URL="$a00071.html#3fe2ecf1bcf2c49eae04c493f023099c"]; Node7 -> Node3 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node7 -> Node5 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; } libloki-0.1.7.orig/doc/html/a00070_d4ac0c2a33ff3d98ec0a83f70ce145da_cgraph.md50000755000175000017500000000004011140366257023757 0ustar ivanivan2de39dbeab7d2e4c526779e8a8a7c830libloki-0.1.7.orig/doc/html/a00390.html0000755000175000017500000000515111140366260015776 0ustar ivanivan Loki: Member List

Loki::SingletonHolder< T, CreationPolicy, LifetimePolicy, ThreadingModel, MutexPolicy > Member List

This is the complete list of members for Loki::SingletonHolder< T, CreationPolicy, LifetimePolicy, ThreadingModel, MutexPolicy >, including all inherited members.

Instance()Loki::SingletonHolder< T, CreationPolicy, LifetimePolicy, ThreadingModel, MutexPolicy > [inline, static]
ObjectType typedefLoki::SingletonHolder< T, CreationPolicy, LifetimePolicy, ThreadingModel, MutexPolicy >


Generated on Thu Jan 29 18:51:44 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00135.html0000755000175000017500000004301011140366261015770 0ustar ivanivan Loki: Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy > Class Template Reference

Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy > Class Template Reference
[Smart pointers]

#include <StrongPtr.h>

List of all members.

Public Member Functions

template<typename T1 , bool S1, class OP1 , class CP1 , template< class > class KP1, template< class > class RP1, template< class > class DP1, template< class > class CNP1>
bool Merge (StrongPtr< T1, S1, OP1, CP1, KP1, RP1, DP1, CNP1 > &rhs)
void Lock (void)
void Unlock (void)
template<class T1 >
bool Equals (const T1 *p) const
 Helper function which can be called to avoid exposing GetPointer function.
template<class T1 >
bool LessThan (const T1 *p) const
 Helper function which can be called to avoid exposing GetPointer function.
template<class T1 >
bool GreaterThan (const T1 *p) const
 Helper function which can be called to avoid exposing GetPointer function.
template<typename T1 , bool S1, class OP1 , class CP1 , template< class > class KP1, template< class > class RP1, template< class > class DP1, template< class > class CNP1>
bool operator== (const StrongPtr< T1, S1, OP1, CP1, KP1, RP1, DP1, CNP1 > &rhs) const
 Equality comparison operator is templated to handle ambiguity.
template<typename T1 , bool S1, class OP1 , class CP1 , template< class > class KP1, template< class > class RP1, template< class > class DP1, template< class > class CNP1>
bool operator!= (const StrongPtr< T1, S1, OP1, CP1, KP1, RP1, DP1, CNP1 > &rhs) const
 Inequality comparison operator is templated to handle ambiguity.
template<typename T1 , bool S1, class OP1 , class CP1 , template< class > class KP1, template< class > class RP1, template< class > class DP1, template< class > class CNP1>
bool operator< (const StrongPtr< T1, S1, OP1, CP1, KP1, RP1, DP1, CNP1 > &rhs) const
 Less-than comparison operator is templated to handle ambiguity.
template<typename T1 , bool S1, class OP1 , class CP1 , template< class > class KP1, template< class > class RP1, template< class > class DP1, template< class > class CNP1>
bool operator> (const StrongPtr< T1, S1, OP1, CP1, KP1, RP1, DP1, CNP1 > &rhs) const
 Greater-than comparison operator is templated to handle ambiguity.
template<typename T1 , bool S1, class OP1 , class CP1 , template< class > class KP1, template< class > class RP1, template< class > class DP1, template< class > class CNP1>
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.
template<typename T1 , bool S1, class OP1 , class CP1 , template< class > class KP1, template< class > class RP1, template< class > class DP1, template< class > class CNP1>
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.


Detailed Description

template<typename T, bool Strong = true, class OwnershipPolicy = Loki::TwoRefCounts, class ConversionPolicy = Loki::DisallowConversion, template< class > class CheckingPolicy = Loki::AssertCheck, template< class > class ResetPolicy = Loki::CantResetWithStrong, template< class > class DeletePolicy = Loki::DeleteSingle, template< class > class ConstnessPolicy = LOKI_DEFAULT_CONSTNESS>
class Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy >

Parameters:
Strong default = true,
OwnershipPolicy default = TwoRefCounts,
ConversionPolicy default = DisallowConversion,
CheckingPolicy default = AssertCheck,
ResetPolicy default = CantResetWithStrong,
DeletePolicy default = DeleteSingle
ConstnessPolicy default = LOKI_DEFAULT_CONSTNESS

Member Function Documentation

template<typename T, bool Strong = true, class OwnershipPolicy = Loki::TwoRefCounts, class ConversionPolicy = Loki::DisallowConversion, template< class > class CheckingPolicy = Loki::AssertCheck, template< class > class ResetPolicy = Loki::CantResetWithStrong, template< class > class DeletePolicy = Loki::DeleteSingle, template< class > class ConstnessPolicy = LOKI_DEFAULT_CONSTNESS>
void Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy >::Lock ( void   )  [inline]

Locks StrongPtr so other threads can't affect pointer. Requires the OwnershipPolicy to have Lock function.

template<typename T, bool Strong = true, class OwnershipPolicy = Loki::TwoRefCounts, class ConversionPolicy = Loki::DisallowConversion, template< class > class CheckingPolicy = Loki::AssertCheck, template< class > class ResetPolicy = Loki::CantResetWithStrong, template< class > class DeletePolicy = Loki::DeleteSingle, template< class > class ConstnessPolicy = LOKI_DEFAULT_CONSTNESS>
template<typename T1 , bool S1, class OP1 , class CP1 , template< class > class KP1, template< class > class RP1, template< class > class DP1, template< class > class CNP1>
bool Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy >::Merge ( StrongPtr< T1, S1, OP1, CP1, KP1, RP1, DP1, CNP1 > &  rhs  )  [inline]

Merges ownership of two StrongPtr's that point to same shared object but are not copointers. Requires Merge function in OwnershipPolicy.

Returns:
True for success, false if not pointer to same object.

template<typename T, bool Strong = true, class OwnershipPolicy = Loki::TwoRefCounts, class ConversionPolicy = Loki::DisallowConversion, template< class > class CheckingPolicy = Loki::AssertCheck, template< class > class ResetPolicy = Loki::CantResetWithStrong, template< class > class DeletePolicy = Loki::DeleteSingle, template< class > class ConstnessPolicy = LOKI_DEFAULT_CONSTNESS>
void Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy >::Unlock ( void   )  [inline]

Unlocks StrongPtr so other threads can affect pointer. Requires the OwnershipPolicy to have Unlock function.


The documentation for this class was generated from the following file:

Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00071_475d734ba0e756935462a5151ea98065_cgraph.dot0000755000175000017500000000667611140366256023251 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node1 [label="Loki::LevelMutexInfo::MultiUnlock",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1 -> Node2 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::LevelMutexInfo::DoErrorCheck",height=0.2,width=0.4,color="black",URL="$a00071.html#14e0d51318b864645bbb3df4f7c9f7ab"]; Node1 -> Node3 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node3 [label="Loki::DoMutexesMatchContainer",height=0.2,width=0.4,color="black",URL="$a00192.html#d633ca81ae0befaf235ae63886368037"]; Node3 -> Node4 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node4 [label="Loki::CountMutexesAtCurrentLevel",height=0.2,width=0.4,color="black",URL="$a00192.html#8cb767d3e7aaf2fe44b8f3b90218b876"]; Node4 -> Node5 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node5 [label="Loki::LevelMutexInfo::GetCurrentMutex",height=0.2,width=0.4,color="black",URL="$a00071.html#b7fd94847721b118979b72121472d3e2"]; Node5 -> Node6 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node6 [label="Loki::LevelMutexInfo::IsValidList",height=0.2,width=0.4,color="black",URL="$a00071.html#01f6dfba5d2ea5606109b34e5a543cf0"]; Node4 -> Node7 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node7 [label="Loki::LevelMutexInfo::GetLevel",height=0.2,width=0.4,color="black",URL="$a00071.html#1cad7c6b6fc50e230401e4cc22761d14",tooltip="Returns the level of this mutex."]; Node4 -> Node8 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node8 [label="Loki::LevelMutexInfo::GetPrevious",height=0.2,width=0.4,color="black",URL="$a00071.html#b774e94ff72724dd87ff236d99970bb5",tooltip="Returns pointer to mutex previously locked by the thread which locked this."]; Node3 -> Node9 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node9 [label="Loki::GetCurrentThreadsLevel",height=0.2,width=0.4,color="black",URL="$a00192.html#9548795d9cda6f227a1e1241ba577ca8"]; Node9 -> Node5 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node9 -> Node7 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node3 -> Node7 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node3 -> Node10 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node10 [label="Loki::LevelMutexInfo::IsRecentLock",height=0.2,width=0.4,color="black",URL="$a00071.html#b917108c3e7c83b8a515d28e91a3a3ca"]; Node10 -> Node11 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node11 [label="Loki::LevelMutexInfo::IsValid",height=0.2,width=0.4,color="black",URL="$a00071.html#36c34ecf5d019f3db9bfb8654cf49176"]; Node11 -> Node6 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node1 -> Node6 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node1 -> Node12 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node12 [label="Loki::LevelMutexInfo::UnlockThis",height=0.2,width=0.4,color="black",URL="$a00071.html#c90cb3e576ae5573381b991894c3b728",tooltip="Called only by MultiUnlock to unlock each particular mutex within a container."]; } libloki-0.1.7.orig/doc/html/a00071_475d734ba0e756935462a5151ea98065_cgraph.md50000755000175000017500000000004011140366256023123 0ustar ivanivan04ca51d1a4a78f1ad720e8bfa716185blibloki-0.1.7.orig/doc/html/globals_defs.html0000755000175000017500000000362411140366263017614 0ustar ivanivan Loki: Class Members
 


Generated on Thu Jan 29 18:51:47 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/functions_rela.html0000755000175000017500000000455511140366255020210 0ustar ivanivan Loki: Class Members - Related Functions
 


Generated on Thu Jan 29 18:51:41 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00008.html0000755000175000017500000000510711140366256016000 0ustar ivanivan Loki: Loki::AssertAnyMutexError Class Reference

Loki::AssertAnyMutexError Class Reference

#include <LevelMutex.h>

List of all members.


Detailed Description

Implements the ErrorPolicy for LevelMutex and asserts for any error condition. Only allows MutexErrors::Success and MutexErrors::NoProblem to get through. Useful for testing mutexes in debug builds.
The documentation for this class was generated from the following file:

Generated on Thu Jan 29 18:51:42 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/functions_vars.html0000755000175000017500000000445411140366255020236 0ustar ivanivan Loki: Class Members - Variables
 


Generated on Thu Jan 29 18:51:41 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00322.html0000755000175000017500000000365311140366256016003 0ustar ivanivan Loki: Member List

Loki::ThrowOnAnyMutexError Member List

This is the complete list of members for Loki::ThrowOnAnyMutexError, including all inherited members.


Generated on Thu Jan 29 18:51:42 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00077.html0000755000175000017500000002001211140366257015777 0ustar ivanivan Loki: Loki::LockingPtr< SharedObject, LockingPolicy, ConstPolicy > Class Template Reference

Loki::LockingPtr< SharedObject, LockingPolicy, ConstPolicy > Class Template Reference

#include <LockingPtr.h>

List of all members.

Public Member Functions

 LockingPtr (volatile ConstOrNotType &object, LockingPolicy &mutex)
 LockingPtr (Pair lockpair)
 ~LockingPtr ()
 Destructor unlocks the mutex.
ConstOrNotType & operator* ()
 Star-operator dereferences pointer.
ConstOrNotType * operator-> ()
 Point-operator returns pointer to object.


Detailed Description

template<typename SharedObject, typename LockingPolicy = LOKI_DEFAULT_MUTEX, template< class > class ConstPolicy = LOKI_DEFAULT_CONSTNESS>
class Loki::LockingPtr< SharedObject, LockingPolicy, ConstPolicy >

Locks a volatile object and casts away volatility so that the object can be safely used in a single-threaded region of code. Original version of LockingPtr had only one template - for the shared object, but not the mutex type. This version allows users to specify a the mutex type as a LockingPolicy class. The only requirements for a LockingPolicy class are to provide Lock and Unlock methods.

Constructor & Destructor Documentation

template<typename SharedObject , typename LockingPolicy = LOKI_DEFAULT_MUTEX, template< class > class ConstPolicy = LOKI_DEFAULT_CONSTNESS>
Loki::LockingPtr< SharedObject, LockingPolicy, ConstPolicy >::LockingPtr ( volatile ConstOrNotType &  object,
LockingPolicy &  mutex 
) [inline]

Constructor locks mutex associated with an object.

Parameters:
object Reference to object.
mutex Mutex used to control thread access to object.

template<typename SharedObject , typename LockingPolicy = LOKI_DEFAULT_MUTEX, template< class > class ConstPolicy = LOKI_DEFAULT_CONSTNESS>
Loki::LockingPtr< SharedObject, LockingPolicy, ConstPolicy >::LockingPtr ( Pair  lockpair  )  [inline]

Constructor locks mutex associated with an object.

Parameters:
lockpair a std::pair of pointers to the object and the mutex


The documentation for this class was generated from the following file:

Generated on Thu Jan 29 18:51:43 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00391.html0000755000175000017500000000365311140366260016004 0ustar ivanivan Loki: Member List

Loki::Singleton< T > Member List

This is the complete list of members for Loki::Singleton< T >, including all inherited members.


Generated on Thu Jan 29 18:51:44 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00136.html0000755000175000017500000000517611140366256016010 0ustar ivanivan Loki: Loki::ThrowOnAnyMutexError Class Reference

Loki::ThrowOnAnyMutexError Class Reference

#include <LevelMutex.h>

List of all members.


Detailed Description

Implements the ErrorPolicy for LevelMutex and throws an exception for any error condition. Only allows MutexErrors::Success and MutexErrors::NoProblem to get through. Useful for release builds.
The documentation for this class was generated from the following files:

Generated on Thu Jan 29 18:51:42 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00450.html0000755000175000017500000001022111140366262015767 0ustar ivanivan Loki: Member List

Loki::FixedAllocator Member List

This is the complete list of members for Loki::FixedAllocator, including all inherited members.

Allocate(void)Loki::FixedAllocator
BlockSize() const Loki::FixedAllocator [inline]
CountEmptyChunks(void) const Loki::FixedAllocator
Deallocate(void *p, Chunk *hint)Loki::FixedAllocator
FixedAllocator()Loki::FixedAllocator
HasBlock(void *p) const Loki::FixedAllocator
Initialize(std::size_t blockSize, std::size_t pageSize)Loki::FixedAllocator
IsCorrupt(void) const Loki::FixedAllocator
TrimChunkList(void)Loki::FixedAllocator
TrimEmptyChunk(void)Loki::FixedAllocator
~FixedAllocator()Loki::FixedAllocator


Generated on Thu Jan 29 18:51:46 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00276.dot0000755000175000017500000000114111140366253015620 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; Node1 [label="Checker.h",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1 -> Node2 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="exception",height=0.2,width=0.4,color="grey75"]; Node1 -> Node3 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node3 [label="assert.h",height=0.2,width=0.4,color="grey75"]; } libloki-0.1.7.orig/doc/html/a00276.md50000755000175000017500000000004011140366253015514 0ustar ivanivan5f735d9d8574d189a89da05604a19742libloki-0.1.7.orig/doc/html/a00277.dot0000755000175000017500000000312311140366253015623 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; Node1 [label="LevelMutex.cpp",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1 -> Node2 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="loki/LevelMutex.h",height=0.2,width=0.4,color="black",URL="$a00158.html",tooltip="Defines classes and functions for LevelMutex facility."]; Node2 -> Node3 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node3 [label="vector",height=0.2,width=0.4,color="grey75"]; Node2 -> Node4 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node4 [label="assert.h",height=0.2,width=0.4,color="grey75"]; Node2 -> Node5 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node5 [label="time.h",height=0.2,width=0.4,color="grey75"]; Node2 -> Node6 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node6 [label="pthread.h",height=0.2,width=0.4,color="grey75"]; Node2 -> Node7 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node7 [label="unistd.h",height=0.2,width=0.4,color="grey75"]; Node1 -> Node8 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node8 [label="algorithm",height=0.2,width=0.4,color="grey75"]; Node1 -> Node9 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node9 [label="cerrno",height=0.2,width=0.4,color="grey75"]; } libloki-0.1.7.orig/doc/html/a00277.md50000755000175000017500000000004011140366253015515 0ustar ivanivanf3686306c96c374b5a17ef9e9d21f6dalibloki-0.1.7.orig/doc/html/a00071_3fe2ecf1bcf2c49eae04c493f023099c_cgraph.dot0000755000175000017500000000267711140366256024034 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node1 [label="Loki::LevelMutexInfo::PostLock",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1 -> Node2 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::LevelMutexInfo::IsLockedByCurrentThread",height=0.2,width=0.4,color="black",URL="$a00071.html#c0a343bcb322ea36495f536504f61f9f",tooltip="Returns true if this was locked by current thread."]; Node2 -> Node3 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node3 [label="Loki::LevelMutexInfo::IsLocked",height=0.2,width=0.4,color="black",URL="$a00071.html#e6aa7465e1bba7f0c9fbf0b06f122a39",tooltip="Returns true if this mutex was locked at least once."]; Node2 -> Node4 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node4 [label="Loki::LevelMutexInfo::IsValid",height=0.2,width=0.4,color="black",URL="$a00071.html#36c34ecf5d019f3db9bfb8654cf49176"]; Node4 -> Node5 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node5 [label="Loki::LevelMutexInfo::IsValidList",height=0.2,width=0.4,color="black",URL="$a00071.html#01f6dfba5d2ea5606109b34e5a543cf0"]; Node1 -> Node4 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; } libloki-0.1.7.orig/doc/html/a00071_3fe2ecf1bcf2c49eae04c493f023099c_cgraph.md50000755000175000017500000000004011140366256023711 0ustar ivanivan72a90097b436dccb03ec206c6e0b8e99libloki-0.1.7.orig/doc/html/a00278.dot0000755000175000017500000000205311140366254015626 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; Node1 [label="LevelMutex.h",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1 -> Node2 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="vector",height=0.2,width=0.4,color="grey75"]; Node1 -> Node3 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node3 [label="assert.h",height=0.2,width=0.4,color="grey75"]; Node1 -> Node4 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node4 [label="time.h",height=0.2,width=0.4,color="grey75"]; Node1 -> Node5 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node5 [label="pthread.h",height=0.2,width=0.4,color="grey75"]; Node1 -> Node6 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node6 [label="unistd.h",height=0.2,width=0.4,color="grey75"]; } libloki-0.1.7.orig/doc/html/a00009.html0000755000175000017500000000515311140366256016002 0ustar ivanivan Loki: Loki::AssertBadDesignMutexError Class Reference

Loki::AssertBadDesignMutexError Class Reference

#include <LevelMutex.h>

List of all members.


Detailed Description

Implements the ErrorPolicy for LevelMutex and asserts if the error indicates the programmer did not levelize the calls to mutexes. Otherwise returns the error result. Useful for testing mutexes in debug builds.
The documentation for this class was generated from the following file:

Generated on Thu Jan 29 18:51:42 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00278.md50000755000175000017500000000004011140366254015517 0ustar ivanivan774c903f4559d555862187d62330b19alibloki-0.1.7.orig/doc/html/a00279.dot0000755000175000017500000000104411140366254015626 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; Node1 [label="LevelMutex.h",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1 -> Node2 [dir=back,color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="LevelMutex.cpp",height=0.2,width=0.4,color="black",URL="$a00157.html",tooltip="Contains functions needed by LevelMutex class."]; } libloki-0.1.7.orig/doc/html/a00279.md50000755000175000017500000000004011140366254015520 0ustar ivanivan125904107a0d9760cce4c483565159f9libloki-0.1.7.orig/doc/html/a00323.html0000755000175000017500000000366711140366256016011 0ustar ivanivan Loki: Member List

Loki::ThrowOnBadDesignMutexError Member List

This is the complete list of members for Loki::ThrowOnBadDesignMutexError, including all inherited members.


Generated on Thu Jan 29 18:51:42 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00078.html0000755000175000017500000002545511140366256016017 0ustar ivanivan Loki: Loki::LokiAllocator< Type, AllocT > Class Template Reference

Loki::LokiAllocator< Type, AllocT > Class Template Reference

#include <Allocator.h>

List of all members.

Classes

struct  rebind
 Convert an allocator<Type> to an allocator <Type1>. More...

Public Member Functions

 LokiAllocator (void) throw ()
 Default constructor does nothing.
 LokiAllocator (const LokiAllocator &) throw ()
 Copy constructor does nothing.
template<typename Type1 >
 LokiAllocator (const LokiAllocator< Type1 > &) throw ()
 Type converting allocator constructor does nothing.
 ~LokiAllocator () throw ()
 Destructor does nothing.
pointer address (reference elem) const
 Return address of reference to mutable element.
const_pointer address (const_reference elem) const
 Return address of reference to const element.
pointer allocate (size_type count, const void *hint=0)
void deallocate (pointer p, size_type size)
 Ask allocator to release memory at pointer with size bytes.
size_type max_size (void) const throw ()
 Calculate max # of elements allocator can handle.
void construct (pointer p, const Type &value)
 Construct an element at the pointer.
void destroy (pointer p)
 Destruct the object at pointer.


Detailed Description

template<typename Type, typename AllocT = Loki::AllocatorSingleton<>>
class Loki::LokiAllocator< Type, AllocT >

Adapts Loki's Small-Object Allocator for STL container classes. This class provides all the functionality required for STL allocators, but uses Loki's Small-Object Allocator to perform actual memory operations. Implementation comes from a post in Loki forums (by Rasmus Ekman?).

Member Function Documentation

template<typename Type, typename AllocT = Loki::AllocatorSingleton<>>
pointer Loki::LokiAllocator< Type, AllocT >::allocate ( size_type  count,
const void *  hint = 0 
) [inline]

Allocate an array of count elements. Warning! The true parameter in the call to Allocate means this function can throw exceptions. This is better than not throwing, and returning a null pointer in case the caller assumes the return value is not null.

Parameters:
count # of elements in array.
hint Place where caller thinks allocation should occur.
Returns:
Pointer to block of memory.


The documentation for this class was generated from the following file:

Generated on Thu Jan 29 18:51:42 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00281.dot0000755000175000017500000000342711140366255015627 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node1 [label="Visitor",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1 -> Node2 [dir=back,color="orange",fontsize="10",style="dashed",label="\",fontname="FreeSans"]; Node2 [label="Visitor\< Tail, R, false \>",height=0.2,width=0.4,color="black",URL="$a00142.html"]; Node1 -> Node3 [dir=back,color="orange",fontsize="10",style="dashed",label="\",fontname="FreeSans"]; Node3 [label="Visitor\< Head, R, false \>",height=0.2,width=0.4,color="black",URL="$a00142.html"]; Node1 -> Node4 [dir=back,color="orange",fontsize="10",style="dashed",label="\",fontname="FreeSans"]; Node4 [label="Visitor\< Head, R, true \>",height=0.2,width=0.4,color="black",URL="$a00142.html"]; Node1 -> Node5 [dir=back,color="orange",fontsize="10",style="dashed",label="\",fontname="FreeSans"]; Node5 [label="Visitor\< Head, R \>",height=0.2,width=0.4,color="black",URL="$a00142.html"]; Node1 -> Node6 [dir=back,color="orange",fontsize="10",style="dashed",label="\",fontname="FreeSans"]; Node6 [label="Visitor\< Tail, R, true \>",height=0.2,width=0.4,color="black",URL="$a00142.html"]; Node1 -> Node7 [dir=back,color="orange",fontsize="10",style="dashed",label="\",fontname="FreeSans"]; Node7 [label="Visitor\< TList, R \>",height=0.2,width=0.4,color="black",URL="$a00142.html"]; Node7 -> Node8 [dir=back,color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node8 [label="Loki::CyclicVisitor\< R, TList \>",height=0.2,width=0.4,color="black",URL="$a00034.html"]; } libloki-0.1.7.orig/doc/html/a00281.md50000755000175000017500000000004011140366255015512 0ustar ivanivana5be15b7e5dbdf700e31f1f689a55427libloki-0.1.7.orig/doc/html/a00282.dot0000755000175000017500000000052011140366255015617 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node1 [label="AbstractFactory",height=0.2,width=0.4,color="black",URL="$a00001.html",tooltip="Implements an abstract object factory."]; } libloki-0.1.7.orig/doc/html/a00282.md50000755000175000017500000000004011140366255015513 0ustar ivanivan108229591ea9a9149aec2085b42b44falibloki-0.1.7.orig/doc/html/a00137.html0000755000175000017500000000524211140366256016003 0ustar ivanivan Loki: Loki::ThrowOnBadDesignMutexError Class Reference

Loki::ThrowOnBadDesignMutexError Class Reference

#include <LevelMutex.h>

List of all members.


Detailed Description

Implements the ErrorPolicy for LevelMutex and throws an exception if the error indicates the programmer did not levelize the calls to mutexes. Otherwise returns the error result. Useful for release builds.
The documentation for this class was generated from the following files:

Generated on Thu Jan 29 18:51:42 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00324.html0000755000175000017500000000365111140366256016003 0ustar ivanivan Loki: Member List

Loki::AssertAnyMutexError Member List

This is the complete list of members for Loki::AssertAnyMutexError, including all inherited members.


Generated on Thu Jan 29 18:51:42 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00079.html0000755000175000017500000000552011140366256016007 0ustar ivanivan Loki: Loki::LokiAllocator< Type, AllocT >::LokiAllocator::rebind< Type1 > Struct Template Reference

Loki::LokiAllocator< Type, AllocT >::LokiAllocator::rebind< Type1 > Struct Template Reference

Convert an allocator<Type> to an allocator <Type1>. More...

#include <Allocator.h>

List of all members.


Detailed Description

template<typename Type, typename AllocT = Loki::AllocatorSingleton<>>
template<typename Type1>
struct Loki::LokiAllocator< Type, AllocT >::rebind< Type1 >

Convert an allocator<Type> to an allocator <Type1>.
The documentation for this struct was generated from the following file:
  • Allocator.h

Generated on Thu Jan 29 18:51:42 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00138.html0000755000175000017500000000553011140366262016001 0ustar ivanivan Loki: Loki::Private::TwoRefCountInfo Class Reference

Loki::Private::TwoRefCountInfo Class Reference
[StrongPtr Ownership policies]

#include <StrongPtr.h>

List of all members.


Detailed Description

Implementation detail for reference counting strong and weak pointers. It maintains a void pointer and 2 reference counts. Since it is just a class for managing implementation details, it is not intended to be used directly - which is why it is in a private namespace. Each instance is a shared resource for all copointers, and there should be only one of these for each set of copointers. This class is small, trivial, and inline.
The documentation for this class was generated from the following file:
  • StrongPtr.h

Generated on Thu Jan 29 18:51:46 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00452.html0000755000175000017500000000400311140366262015772 0ustar ivanivan Loki: Member List

Loki::LongevityLifetime::SingletonFixedLongevity< Longevity, T > Member List

This is the complete list of members for Loki::LongevityLifetime::SingletonFixedLongevity< Longevity, T >, including all inherited members.


Generated on Thu Jan 29 18:51:46 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00010.html0000755000175000017500000000512711140366261015767 0ustar ivanivan Loki: Loki::AssertCheck< P > Struct Template Reference

Loki::AssertCheck< P > Struct Template Reference
[Checking policies]

#include <SmartPtr.h>

List of all members.


Detailed Description

template<class P>
struct Loki::AssertCheck< P >

Implementation of the CheckingPolicy used by SmartPtr Checks the pointer before dereference
The documentation for this struct was generated from the following file:
  • SmartPtr.h

Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00325.html0000755000175000017500000000366511140366256016011 0ustar ivanivan Loki: Member List

Loki::AssertBadDesignMutexError Member List

This is the complete list of members for Loki::AssertBadDesignMutexError, including all inherited members.


Generated on Thu Jan 29 18:51:42 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00394.html0000755000175000017500000000766511140366261016017 0ustar ivanivan Loki: Member List

Loki::SmallObjAllocator Member List

This is the complete list of members for Loki::SmallObjAllocator, including all inherited members.

Allocate(std::size_t size, bool doThrow)Loki::SmallObjAllocator
Deallocate(void *p, std::size_t size)Loki::SmallObjAllocator
Deallocate(void *p)Loki::SmallObjAllocator
GetAlignment() const Loki::SmallObjAllocator [inline]
GetMaxObjectSize() const Loki::SmallObjAllocator [inline]
IsCorrupt(void) const Loki::SmallObjAllocator
SmallObjAllocator(std::size_t pageSize, std::size_t maxObjectSize, std::size_t objectAlignSize)Loki::SmallObjAllocator [protected]
TrimExcessMemory(void)Loki::SmallObjAllocator
~SmallObjAllocator(void)Loki::SmallObjAllocator [protected]


Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00139.html0000755000175000017500000000775311140366261016012 0ustar ivanivan Loki: Loki::TwoRefCounts Class Reference

Loki::TwoRefCounts Class Reference
[StrongPtr Ownership policies]

#include <StrongPtr.h>

Collaboration diagram for Loki::TwoRefCounts:

List of all members.

Protected Member Functions

 ~TwoRefCounts (void)


Detailed Description

This implementation of StrongPtr's OwnershipPolicy uses a pointer to a shared instance of TwoRefCountInfo. This is the default policy for OwnershipPolicy. Some functions are trivial enough to be inline, while others are implemented elsewhere. It is not thread safe, and is intended for single-threaded environments.

Constructor & Destructor Documentation

Loki::TwoRefCounts::~TwoRefCounts ( void   )  [inline, protected]

The destructor does not need to do anything since the call to ZapPointer inside StrongPtr::~StrongPtr will do the cleanup which this dtor would have done.


The documentation for this class was generated from the following files:
  • StrongPtr.h
  • StrongPtr.cpp

Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00011.html0000755000175000017500000000544011140366261015766 0ustar ivanivan Loki: Loki::AssertCheckStrict< P > Struct Template Reference

Loki::AssertCheckStrict< P > Struct Template Reference
[Checking policies]

#include <SmartPtr.h>

List of all members.


Detailed Description

template<class P>
struct Loki::AssertCheckStrict< P >

Implementation of the CheckingPolicy used by SmartPtr Checks the pointer against zero upon initialization and before dereference You can initialize an AssertCheckStrict with an AssertCheck
The documentation for this struct was generated from the following file:
  • SmartPtr.h

Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/functions_func.html0000755000175000017500000005367311140366255020225 0ustar ivanivan Loki: Class Members - Functions
 

- a -

- b -

- c -

- d -

- e -

- f -

- g -

- h -

- i -

- l -

- m -

- o -

- p -

- r -

- s -

- t -

- u -

- w -

- ~ -


Generated on Thu Jan 29 18:51:41 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00326.html0000755000175000017500000000365311140366257016010 0ustar ivanivan Loki: Member List

Loki::JustReturnMutexError Member List

This is the complete list of members for Loki::JustReturnMutexError, including all inherited members.


Generated on Thu Jan 29 18:51:43 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00080.html0000755000175000017500000003031311140366257015776 0ustar ivanivan Loki: Loki::MultiMutexLocker Class Reference

Loki::MultiMutexLocker Class Reference

#include <LevelMutex.h>

List of all members.

Public Member Functions

 MultiMutexLocker (LevelMutexInfo::MutexContainer &mutexes, bool lock=true)
 MultiMutexLocker (LevelMutexInfo::MutexContainer &mutexes, unsigned int milliSeconds, bool lock=true)
 ~MultiMutexLocker (void)
 Destructs the locker, and determines if it needs to unlock the mutexes.
bool Lock (void)
bool Unlock (void)
bool IsLocked (void) const
 Returns true if the mutexes are locked by this object.
const
LevelMutexInfo::MutexContainer
GetMutexes (void) const
 Provides access to the collection of mutexes controlled by this.


Detailed Description

You can place an instance of this as a local variable inside a function to lock a collection of mutexes. It locks them if no error occurs, or throws an exception if one does happen. When the function ends, the destructor determines if it needs to unlock the mutexes. This RAII technique insures the mutexes get unlocked even when exceptions occur. You will also have to construct a MutexContainer as a local object within the same function.

Constructor & Destructor Documentation

Loki::MultiMutexLocker::MultiMutexLocker ( LevelMutexInfo::MutexContainer mutexes,
bool  lock = true 
) [explicit]

Creates an object to lock and unlock a collection of mutexes for a function. This will throw if an attempt to lock any mutex fails. If an exception occurs, it unlocks mutexes it previously locked.

Parameters:
mutex Reference to a collection of mutexes.
lock True if function wants to lock the mutex as this gets constructed.

References Loki::LevelMutexInfo::MultiLock().

Here is the call graph for this function:

Loki::MultiMutexLocker::MultiMutexLocker ( LevelMutexInfo::MutexContainer mutexes,
unsigned int  milliSeconds,
bool  lock = true 
)

Creates an object to lock and unlock a collection of mutexes for a function. This waits a specified amount of time for other threads to unlock each mutex that is locked. This will throw if an attempt to lock any mutex fails. If an exception occurs, it unlocks mutexes it previously locked.

Parameters:
mutexes Reference to a collection of mutexes.
milliSeconds Amount of time to wait for another thread to unlock the mutex.
lock True if function wants to lock the mutexes as this gets constructed.

References Loki::LevelMutexInfo::MultiLock().

Here is the call graph for this function:


Member Function Documentation

bool Loki::MultiMutexLocker::Lock ( void   ) 

You can call this to lock (or relock) the mutexes. In theory, you can lock and unlock mutexes several times within a function in order to give other threads access to resources while this function does not need them.

Returns:
True if mutex is locked by this, else false if not locked.

References Loki::LevelMutexInfo::MultiLock().

Here is the call graph for this function:

bool Loki::MultiMutexLocker::Unlock ( void   ) 

You can call this to unlock the mutexes before the destructor does it. By unlocking the mutexes before returning, the function can do other operations without making other threads wait too long.

Returns:
True if unlocked by this, else false if not unlocked by this. (Which is not the same as whether the mutex itself is locked or not by another thread.)

References Loki::LevelMutexInfo::MultiUnlock().

Here is the call graph for this function:


The documentation for this class was generated from the following files:

Generated on Thu Jan 29 18:51:43 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/hierarchy.html0000755000175000017500000004121011140366255017140 0ustar ivanivan Loki: Hierarchical Index

Class Hierarchy

Go to the graphical class hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:


Generated on Thu Jan 29 18:51:41 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00012.html0000755000175000017500000000463711140366261015776 0ustar ivanivan Loki: Loki::BaseVisitor Class Reference

Loki::BaseVisitor Class Reference
[Visitor]

#include <Visitor.h>

List of all members.


Detailed Description

The base class of any Acyclic Visitor
The documentation for this class was generated from the following file:
  • Visitor.h

Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00327.html0000755000175000017500000000363111140366257016005 0ustar ivanivan Loki: Member List

Loki::NoMutexWait Member List

This is the complete list of members for Loki::NoMutexWait, including all inherited members.


Generated on Thu Jan 29 18:51:43 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00081.html0000755000175000017500000000465411140366261016003 0ustar ivanivan Loki: Loki::Mutex Class Reference

Loki::Mutex Class Reference
[Threading]

#include <Threads.h>

List of all members.


Detailed Description

A simple and portable Mutex. A default policy class for locking objects.
The documentation for this class was generated from the following file:
  • Threads.h

Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00218_g7abc768179c277d50bbb59fdee609668_cgraph.dot0000755000175000017500000000117011140366254024003 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node1 [label="Loki::operator\<",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1 -> Node2 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::StrongPtr::GreaterThan",height=0.2,width=0.4,color="black",URL="$a00135.html#f43b2cde389f926c16e166c418b13040",tooltip="Helper function which can be called to avoid exposing GetPointer function."]; } libloki-0.1.7.orig/doc/html/a00218_g7abc768179c277d50bbb59fdee609668_cgraph.md50000755000175000017500000000004011140366254023675 0ustar ivanivan91e628d1685dc4a8e12b8a0dca5caa2alibloki-0.1.7.orig/doc/html/a00311.dot0000755000175000017500000001240011140366256015611 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node1 [label="Loki::Functor\< R, TList, ThreadingModel \>",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1 -> Node2 [dir=back,color="orange",fontsize="10",style="dashed",label="\ \>",fontname="FreeSans"]; Node2 [label="Loki::Functor\< R, Seq\< P01, P02, P03, P04, P05 \> \>",height=0.2,width=0.4,color="black",URL="$a00064.html"]; Node1 -> Node3 [dir=back,color="orange",fontsize="10",style="dashed",label="\ \>",fontname="FreeSans"]; Node3 [label="Loki::Functor\< R, Seq\< P01 \> \>",height=0.2,width=0.4,color="black",URL="$a00064.html"]; Node1 -> Node4 [dir=back,color="orange",fontsize="10",style="dashed",label="\<\>",fontname="FreeSans"]; Node4 [label="Loki::Functor\<\>",height=0.2,width=0.4,color="black",URL="$a00064.html"]; Node1 -> Node5 [dir=back,color="orange",fontsize="10",style="dashed",label="\ \>",fontname="FreeSans"]; Node5 [label="Loki::Functor\< R, Seq\< P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13 \> \>",height=0.2,width=0.4,color="black",URL="$a00064.html"]; Node1 -> Node6 [dir=back,color="orange",fontsize="10",style="dashed",label="\ \>",fontname="FreeSans"]; Node6 [label="Loki::Functor\< R, Seq\< P01, P02, P03, P04, P05, P06, P07, P08, P09 \> \>",height=0.2,width=0.4,color="black",URL="$a00064.html"]; Node1 -> Node7 [dir=back,color="orange",fontsize="10",style="dashed",label="\",fontname="FreeSans"]; Node7 [label="Loki::Functor\< R \>",height=0.2,width=0.4,color="black",URL="$a00064.html"]; Node1 -> Node8 [dir=back,color="orange",fontsize="10",style="dashed",label="\ \>",fontname="FreeSans"]; Node8 [label="Loki::Functor\< R, Seq\< P01, P02, P03, P04, P05, P06, P07 \> \>",height=0.2,width=0.4,color="black",URL="$a00064.html"]; Node1 -> Node9 [dir=back,color="orange",fontsize="10",style="dashed",label="\ \>",fontname="FreeSans"]; Node9 [label="Loki::Functor\< R, Seq\< P01, P02, P03, P04 \> \>",height=0.2,width=0.4,color="black",URL="$a00064.html"]; Node1 -> Node10 [dir=back,color="orange",fontsize="10",style="dashed",label="\ \>",fontname="FreeSans"]; Node10 [label="Loki::Functor\< R, Seq\< P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14 \> \>",height=0.2,width=0.4,color="black",URL="$a00064.html"]; Node1 -> Node11 [dir=back,color="orange",fontsize="10",style="dashed",label="\ \>",fontname="FreeSans"]; Node11 [label="Loki::Functor\< R, Seq\< P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12 \> \>",height=0.2,width=0.4,color="black",URL="$a00064.html"]; Node1 -> Node12 [dir=back,color="orange",fontsize="10",style="dashed",label="\< void, Seq\< void * \> \>",fontname="FreeSans"]; Node12 [label="Loki::Functor\< void, Seq\< void * \> \>",height=0.2,width=0.4,color="black",URL="$a00064.html"]; Node1 -> Node13 [dir=back,color="orange",fontsize="10",style="dashed",label="\ \>",fontname="FreeSans"]; Node13 [label="Loki::Functor\< R, Seq\< P01, P02, P03, P04, P05, P06 \> \>",height=0.2,width=0.4,color="black",URL="$a00064.html"]; Node1 -> Node14 [dir=back,color="orange",fontsize="10",style="dashed",label="\ \>",fontname="FreeSans"]; Node14 [label="Loki::Functor\< R, Seq\< P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11 \> \>",height=0.2,width=0.4,color="black",URL="$a00064.html"]; Node1 -> Node15 [dir=back,color="orange",fontsize="10",style="dashed",label="\ \>",fontname="FreeSans"]; Node15 [label="Loki::Functor\< R, Seq\< P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15 \> \>",height=0.2,width=0.4,color="black",URL="$a00064.html"]; Node1 -> Node16 [dir=back,color="orange",fontsize="10",style="dashed",label="\ \>",fontname="FreeSans"]; Node16 [label="Loki::Functor\< R, Seq\< P01, P02 \> \>",height=0.2,width=0.4,color="black",URL="$a00064.html"]; Node1 -> Node17 [dir=back,color="orange",fontsize="10",style="dashed",label="\ \>",fontname="FreeSans"]; Node17 [label="Loki::Functor\< R, Seq\< P01, P02, P03, P04, P05, P06, P07, P08 \> \>",height=0.2,width=0.4,color="black",URL="$a00064.html"]; Node1 -> Node18 [dir=back,color="orange",fontsize="10",style="dashed",label="\ \>",fontname="FreeSans"]; Node18 [label="Loki::Functor\< R, Seq\< P01, P02, P03 \> \>",height=0.2,width=0.4,color="black",URL="$a00064.html"]; Node1 -> Node19 [dir=back,color="orange",fontsize="10",style="dashed",label="\ \>",fontname="FreeSans"]; Node19 [label="Loki::Functor\< R, Seq\< P01, P02, P03, P04, P05, P06, P07, P08, P09, P10 \> \>",height=0.2,width=0.4,color="black",URL="$a00064.html"]; } libloki-0.1.7.orig/doc/html/a00311.md50000755000175000017500000000004011140366256015505 0ustar ivanivan24845273fce5d6fa7fd540035e94cecblibloki-0.1.7.orig/doc/html/a00140.html0000755000175000017500000001010711140366261015765 0ustar ivanivan Loki: Loki::TwoRefLinks Class Reference

Loki::TwoRefLinks Class Reference
[StrongPtr Ownership policies]

#include <StrongPtr.h>

Collaboration diagram for Loki::TwoRefLinks:

List of all members.

Protected Member Functions

bool Merge (TwoRefLinks &rhs)


Detailed Description

This implementation of StrongPtr's OwnershipPolicy uses a doubly-linked cycle of copointers to a shared object. Some functions are trivial enough to be inline, while others are implemented in elsewhere. It is not thread safe, and is intended for single-threaded environments.

Member Function Documentation

bool Loki::TwoRefLinks::Merge ( TwoRefLinks rhs  )  [protected]

rhs is in a cycle with 1 node.

this is in a cycle with 1 node.

References m_next, and m_prev.


The documentation for this class was generated from the following files:
  • StrongPtr.h
  • StrongPtr.cpp

Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00455.html0000755000175000017500000000371511140366262016006 0ustar ivanivan Loki: Member List

Loki::LongevityLifetime::DieLast< T > Member List

This is the complete list of members for Loki::LongevityLifetime::DieLast< T >, including all inherited members.


Generated on Thu Jan 29 18:51:46 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00316.dot0000755000175000017500000000105511140366256015622 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; Node1 [label="Loki::LevelMutexInfo",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1 -> Node2 [dir=back,color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::LevelMutex\< MutexPolicy, DefaultLevel, ErrorPolicy, WaitPolicy \>",height=0.2,width=0.4,color="black",URL="$a00070.html"]; } libloki-0.1.7.orig/doc/html/a00316.md50000755000175000017500000000004011140366256015512 0ustar ivanivan617cbdda5d022c059916ceecd7831f8clibloki-0.1.7.orig/doc/html/a00317.dot0000755000175000017500000000067611140366256015633 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; Node1 [label="Loki::LevelMutexInfo",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1 -> Node1 [dir=back,color="darkorchid3",fontsize="10",style="dashed",label="m_previous\ns_currentMutex",fontname="FreeSans"]; } libloki-0.1.7.orig/doc/html/a00317.md50000755000175000017500000000004011140366256015513 0ustar ivanivanee55963c38ece83692b8969638321d7elibloki-0.1.7.orig/doc/html/a00013.html0000755000175000017500000000515611140366256016000 0ustar ivanivan Loki: Loki::BinderFirst< OriginalFunctor > Class Template Reference

Loki::BinderFirst< OriginalFunctor > Class Template Reference
[Function objects]

#include <Functor.h>

List of all members.


Detailed Description

template<class OriginalFunctor>
class Loki::BinderFirst< OriginalFunctor >

Binds the first parameter of a Functor object to a specific value
The documentation for this class was generated from the following file:
  • Functor.h

Generated on Thu Jan 29 18:51:42 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00319.dot0000755000175000017500000000124711140366256015630 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; Node1 [label="Loki::LevelMutexInfo::LevelMutexInfo::Checker",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node2 -> Node1 [dir=back,color="darkorchid3",fontsize="10",style="dashed",label="m_mutex",fontname="FreeSans"]; Node2 [label="Loki::LevelMutexInfo",height=0.2,width=0.4,color="black",URL="$a00071.html"]; Node2 -> Node2 [dir=back,color="darkorchid3",fontsize="10",style="dashed",label="m_previous\ns_currentMutex",fontname="FreeSans"]; } libloki-0.1.7.orig/doc/html/a00319.md50000755000175000017500000000004011140366256015515 0ustar ivanivan41efa5910e3f695b672b483453caf5a6libloki-0.1.7.orig/doc/html/a00328.html0000755000175000017500000000364111140366257016007 0ustar ivanivan Loki: Member List

Loki::MutexSleepWaits Member List

This is the complete list of members for Loki::MutexSleepWaits, including all inherited members.


Generated on Thu Jan 29 18:51:43 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00082.html0000755000175000017500000001713111140366257016003 0ustar ivanivan Loki: Loki::MutexException Class Reference

Loki::MutexException Class Reference

#include <LevelMutex.h>

List of all members.

Public Member Functions

 MutexException (const char *message, unsigned int level, MutexErrors::Type reason)
 MutexException (const MutexException &that) throw ()
 Copy constructor performs a member-by-member copy of an exception.
MutexExceptionoperator= (const MutexException &that) throw ()
 Copy-assignment operator performs a member-by-member copy of an exception.
virtual ~MutexException (void) throw ()
 Destroys the exception.
virtual const char * what (void) const throw ()
 Returns a simple message about which operation failed.
unsigned int GetLevel (void) const
 Returns level of mutex(es) used when problem occurred.
MutexErrors::Type GetReason (void) const
 Returns an error status for why operation failed.


Detailed Description

Exception class used to throw error statuses about LevelMutex's up to code that can respond to mutex problems. This class exists because it conveys more info about the error condition than just std::exception.

Constructor & Destructor Documentation

Loki::MutexException::MutexException ( const char *  message,
unsigned int  level,
MutexErrors::Type  reason 
)

Constructs an exception which stores information about a mutex and the reason an attempt to use a mutex failed.


The documentation for this class was generated from the following files:

Generated on Thu Jan 29 18:51:43 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00071_dde650eae1cad8b4723e68cdb9130283_cgraph.dot0000755000175000017500000000727111140366256023745 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node1 [label="Loki::LevelMutexInfo::MultiLock",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1 -> Node2 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::LevelMutexInfo::MutexUndoer::Cancel",height=0.2,width=0.4,color="black",URL="$a00073.html#87e777d849336fe81907e55aaad1edaa"]; Node1 -> Node3 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node3 [label="Loki::LevelMutexInfo::DoErrorCheck",height=0.2,width=0.4,color="black",URL="$a00071.html#14e0d51318b864645bbb3df4f7c9f7ab"]; Node1 -> Node4 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node4 [label="Loki::DoMutexesMatchContainer",height=0.2,width=0.4,color="black",URL="$a00192.html#d633ca81ae0befaf235ae63886368037"]; Node4 -> Node5 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node5 [label="Loki::CountMutexesAtCurrentLevel",height=0.2,width=0.4,color="black",URL="$a00192.html#8cb767d3e7aaf2fe44b8f3b90218b876"]; Node5 -> Node6 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node6 [label="Loki::LevelMutexInfo::GetCurrentMutex",height=0.2,width=0.4,color="black",URL="$a00071.html#b7fd94847721b118979b72121472d3e2"]; Node6 -> Node7 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node7 [label="Loki::LevelMutexInfo::IsValidList",height=0.2,width=0.4,color="black",URL="$a00071.html#01f6dfba5d2ea5606109b34e5a543cf0"]; Node5 -> Node8 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node8 [label="Loki::LevelMutexInfo::GetLevel",height=0.2,width=0.4,color="black",URL="$a00071.html#1cad7c6b6fc50e230401e4cc22761d14",tooltip="Returns the level of this mutex."]; Node5 -> Node9 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node9 [label="Loki::LevelMutexInfo::GetPrevious",height=0.2,width=0.4,color="black",URL="$a00071.html#b774e94ff72724dd87ff236d99970bb5",tooltip="Returns pointer to mutex previously locked by the thread which locked this."]; Node4 -> Node10 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node10 [label="Loki::GetCurrentThreadsLevel",height=0.2,width=0.4,color="black",URL="$a00192.html#9548795d9cda6f227a1e1241ba577ca8"]; Node10 -> Node6 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node10 -> Node8 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node4 -> Node8 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node4 -> Node11 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node11 [label="Loki::LevelMutexInfo::IsRecentLock",height=0.2,width=0.4,color="black",URL="$a00071.html#b917108c3e7c83b8a515d28e91a3a3ca"]; Node11 -> Node12 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node12 [label="Loki::LevelMutexInfo::IsValid",height=0.2,width=0.4,color="black",URL="$a00071.html#36c34ecf5d019f3db9bfb8654cf49176"]; Node12 -> Node7 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node1 -> Node10 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node1 -> Node7 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node1 -> Node13 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node13 [label="Loki::LevelMutexInfo::MutexUndoer::SetPlace",height=0.2,width=0.4,color="black",URL="$a00073.html#65a5d0ff95ed8ab37280350f6a10259c"]; } libloki-0.1.7.orig/doc/html/a00071_dde650eae1cad8b4723e68cdb9130283_cgraph.md50000755000175000017500000000004011140366256023627 0ustar ivanivan50a284f98c9ab68476fda2676b8f3b81libloki-0.1.7.orig/doc/html/a00397.html0000755000175000017500000001525011140366261016007 0ustar ivanivan Loki: Member List

Loki::AllocatorSingleton< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > Member List

This is the complete list of members for Loki::AllocatorSingleton< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >, including all inherited members.

Allocate(std::size_t size, bool doThrow)Loki::SmallObjAllocator
AllocatorSingleton()Loki::AllocatorSingleton< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > [inline]
ClearExtraMemory(void)Loki::AllocatorSingleton< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > [inline, static]
Deallocate(void *p, std::size_t size)Loki::SmallObjAllocator
Deallocate(void *p)Loki::SmallObjAllocator
GetAlignment() const Loki::SmallObjAllocator [inline]
GetMaxObjectSize() const Loki::SmallObjAllocator [inline]
Instance(void)Loki::AllocatorSingleton< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > [inline, static]
IsCorrupt(void) const Loki::SmallObjAllocator
IsCorrupted(void)Loki::AllocatorSingleton< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > [inline, static]
MyAllocator typedefLoki::AllocatorSingleton< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >
MyAllocatorSingleton typedefLoki::AllocatorSingleton< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >
MyThreadingModel typedefLoki::AllocatorSingleton< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >
SmallObjAllocator(std::size_t pageSize, std::size_t maxObjectSize, std::size_t objectAlignSize)Loki::SmallObjAllocator [protected]
TrimExcessMemory(void)Loki::SmallObjAllocator
~AllocatorSingleton(void)Loki::AllocatorSingleton< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > [inline]
~SmallObjAllocator(void)Loki::SmallObjAllocator [protected]


Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00141.html0000755000175000017500000000553111140366257016000 0ustar ivanivan Loki: Loki::UnRegisterOnDeleteSet< ElementList > Class Template Reference

Loki::UnRegisterOnDeleteSet< ElementList > Class Template Reference
[Register]

#include <Register.h>

Inherits Loki::GenScatterHierarchy<ElementList, Private::UnRegisterOnDeleteElement>.

List of all members.


Detailed Description

template<typename ElementList>
class Loki::UnRegisterOnDeleteSet< ElementList >

Implements a generic register class which unregisters classes of a typelist

Usage
see test/Register

The documentation for this class was generated from the following file:
  • Register.h

Generated on Thu Jan 29 18:51:43 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/doxygen.css0000755000175000017500000001310511140366250016460 0ustar ivanivanbody, table, div, p, dl { font-family: Lucida Grande, Verdana, Geneva, Arial, sans-serif; font-size: 12px; } /* @group Heading Levels */ h1 { text-align: center; font-size: 150%; } h2 { font-size: 120%; } h3 { font-size: 100%; } /* @end */ caption { font-weight: bold; } div.qindex, div.navtab{ background-color: #e8eef2; border: 1px solid #84b0c7; text-align: center; margin: 2px; padding: 2px; } div.qindex, div.navpath { width: 100%; line-height: 140%; } div.navtab { margin-right: 15px; } /* @group Link Styling */ a { color: #153788; font-weight: normal; text-decoration: none; } .contents a:visited { color: #1b77c5; } a:hover { text-decoration: underline; } a.qindex { font-weight: bold; } a.qindexHL { font-weight: bold; background-color: #6666cc; color: #ffffff; border: 1px double #9295C2; } .contents a.qindexHL:visited { color: #ffffff; } a.el { font-weight: bold; } a.elRef { } a.code { } a.codeRef { } /* @end */ dl.el { margin-left: -1cm; } .fragment { font-family: monospace, fixed; font-size: 105%; } pre.fragment { border: 1px solid #CCCCCC; background-color: #f5f5f5; padding: 4px 6px; margin: 4px 8px 4px 2px; } div.ah { background-color: black; font-weight: bold; color: #ffffff; margin-bottom: 3px; margin-top: 3px } div.groupHeader { margin-left: 16px; margin-top: 12px; margin-bottom: 6px; font-weight: bold; } div.groupText { margin-left: 16px; font-style: italic; } body { background: white; color: black; margin-right: 20px; margin-left: 20px; } td.indexkey { background-color: #e8eef2; font-weight: bold; border: 1px solid #CCCCCC; margin: 2px 0px 2px 0; padding: 2px 10px; } td.indexvalue { background-color: #e8eef2; border: 1px solid #CCCCCC; padding: 2px 10px; margin: 2px 0px; } tr.memlist { background-color: #f0f0f0; } p.formulaDsp { text-align: center; } img.formulaDsp { } img.formulaInl { vertical-align: middle; } /* @group Code Colorization */ span.keyword { color: #008000 } span.keywordtype { color: #604020 } span.keywordflow { color: #e08000 } span.comment { color: #800000 } span.preprocessor { color: #806020 } span.stringliteral { color: #002080 } span.charliteral { color: #008080 } span.vhdldigit { color: #ff00ff } span.vhdlchar { color: #000000 } span.vhdlkeyword { color: #700070 } span.vhdllogic { color: #ff0000 } /* @end */ .search { color: #003399; font-weight: bold; } form.search { margin-bottom: 0px; margin-top: 0px; } input.search { font-size: 75%; color: #000080; font-weight: normal; background-color: #e8eef2; } td.tiny { font-size: 75%; } .dirtab { padding: 4px; border-collapse: collapse; border: 1px solid #84b0c7; } th.dirtab { background: #e8eef2; font-weight: bold; } hr { height: 0; border: none; border-top: 1px solid #666; } /* @group Member Descriptions */ .mdescLeft, .mdescRight, .memItemLeft, .memItemRight, .memTemplItemLeft, .memTemplItemRight, .memTemplParams { background-color: #FAFAFA; border: none; margin: 4px; padding: 1px 0 0 8px; } .mdescLeft, .mdescRight { padding: 0px 8px 4px 8px; color: #555; } .memItemLeft, .memItemRight, .memTemplParams { border-top: 1px solid #ccc; } .memTemplParams { color: #606060; } /* @end */ /* @group Member Details */ /* Styles for detailed member documentation */ .memtemplate { font-size: 80%; color: #606060; font-weight: normal; margin-left: 3px; } .memnav { background-color: #e8eef2; border: 1px solid #84b0c7; text-align: center; margin: 2px; margin-right: 15px; padding: 2px; } .memitem { padding: 0; } .memname { white-space: nowrap; font-weight: bold; } .memproto, .memdoc { border: 1px solid #84b0c7; } .memproto { padding: 0; background-color: #d5e1e8; font-weight: bold; -webkit-border-top-left-radius: 8px; -webkit-border-top-right-radius: 8px; -moz-border-radius-topleft: 8px; -moz-border-radius-topright: 8px; } .memdoc { padding: 2px 5px; background-color: #eef3f5; border-top-width: 0; -webkit-border-bottom-left-radius: 8px; -webkit-border-bottom-right-radius: 8px; -moz-border-radius-bottomleft: 8px; -moz-border-radius-bottomright: 8px; } .paramkey { text-align: right; } .paramtype { white-space: nowrap; } .paramname { color: #602020; white-space: nowrap; } .paramname em { font-style: normal; } /* @end */ /* @group Directory (tree) */ /* for the tree view */ .ftvtree { font-family: sans-serif; margin: 0.5em; } /* these are for tree view when used as main index */ .directory { font-size: 9pt; font-weight: bold; } .directory h3 { margin: 0px; margin-top: 1em; font-size: 11pt; } /* The following two styles can be used to replace the root node title with an image of your choice. Simply uncomment the next two styles, specify the name of your image and be sure to set 'height' to the proper pixel height of your image. */ /* .directory h3.swap { height: 61px; background-repeat: no-repeat; background-image: url("yourimage.gif"); } .directory h3.swap span { display: none; } */ .directory > h3 { margin-top: 0; } .directory p { margin: 0px; white-space: nowrap; } .directory div { display: none; margin: 0px; } .directory img { vertical-align: -30%; } /* these are for tree view when not used as main index */ .directory-alt { font-size: 100%; font-weight: bold; } .directory-alt h3 { margin: 0px; margin-top: 1em; font-size: 11pt; } .directory-alt > h3 { margin-top: 0; } .directory-alt p { margin: 0px; white-space: nowrap; } .directory-alt div { display: none; margin: 0px; } .directory-alt img { vertical-align: -30%; } /* @end */ address { font-style: normal; color: #333; } libloki-0.1.7.orig/doc/html/doxygen.png0000755000175000017500000000240111140366250016451 0ustar ivanivan‰PNG  IHDRd-ok>ยgAMAึุิOX2tEXtSoftwareAdobe ImageReadyqษe<]PLTEวพฯ"&ฉศฮ๏ถปึำฺ๚“ข ฌเถย๕‡งีู๊ษสฮแโๆ{Žิก๋ˆ™ื ฒ๘งฌนภภฑฮ๙๙้๕๕็๋๋ๅED9ืึหhg]_X<@:#mhUภ1tRNSอvIDATxฺbCฃ: d#„„………h` @กX",***LKˆ.–], บX@tฑ €่b @ัล€BตD„6–š%""ดฐ € ˜% ˆ™B:Hขˆฒมf@• ˆRPy"K`\PbC(!II!hฉ…๋ƒ(๑„ฤ!๊ˆฌC„ฤ…เl!0[X\J\$TMˆ(’>a$S„ ู@ ะจ@R.$‚ฌLJBRข‰AฬG1 ฌ ย(FศƒิPhhมTภข„%!`€&qฐ%uย P นข ฌ € นCT$Bขเ|‚ยบW„คภl ฃ!B`R$( …ฤˆ‘’ยž@Aล%ฤคฤ%@,(—ส‚ฺฑ%$มโโRPmB U`1IˆYB  99€\1 yCCCf"[N '=TGศ’๘l8˜^K๛5<๊SๆRษค”%๎@@ เ›ส b1 qลAXHˆธ&ุB’R y n˜P„ฬใ–4A €€jน€€> ˜ t!˜+(.ศลWQฑA2MU‚’’‚‚โ `1 %`19€F< 3cZฤ`๓e!\ˆ Dศ+. 83‹ณภไธ!lYYA -6‚EJŠขV €@ฉžXXX 4„ๅ ส@86ะ`RdBด€4I " "–@xrสŒ‚H€Aส`—f ษศฐCŒ"XV0ษฒณC b@2…ฌH ฌศ“ p)!(์‚ 0Ž4ˆ)(%Rมฮ ถ$€Tส€ฅภb‡b,sไะ@7ภ ัฐ‚า๎?fฅึ—\PIx!Iดฆ"”ศˆ’3จ QY˜t^^ุgv- }>WJOAV`$&#”ฆ8๙๘๘8€\FF ›SFJ$ยฦ€ะฦŠะกไˆ‰ภภ 4ช…ศไๅ -มง‡ €Hฒ…—ŸŸŸf ?๐โ5„ €k1ยd‰,Œร ณƒ“€.€"ญF™หห€เ๑‚ฝมIศ€"ฑู4ษH gx|‚fฉm)))9ด. aMDƒ& บX@tฑ €่b @ัล€ข‹%DKˆ.–], บX@tฑ €่b @€d`‚ษฝSตOIENDฎB`‚libloki-0.1.7.orig/doc/html/a00200.html0000755000175000017500000000766711140366254016005 0ustar ivanivan Loki: Cached Factory

Cached Factory
[Factories]

CachedFactory provides an extension of a Factory with caching support. More...

Collaboration diagram for Cached Factory:


Classes

class  Loki::CachedFactory< AbstractProduct, IdentifierType, CreatorParmTList, EncapsulationPolicy, CreationPolicy, EvictionPolicy, StatisticPolicy, FactoryErrorPolicy, ObjVector >
 Factory with caching support. More...

Modules

 Encapsulation policies
 Defines how the object is returned to the client.
 Creation policies
 Defines a way to limit the creation operation.
 Eviction policies
 Gathers informations about the stored objects and choose a candidate for eviction.
 Statistic policies
 Gathers information about the cache.

Detailed Description

CachedFactory provides an extension of a Factory with caching support.

Once used objects are returned to the CachedFactory that manages its destruction. If your code uses lots of "long to construct/destruct objects" using the CachedFactory will surely speedup the execution.


Generated on Thu Jan 29 18:51:40 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00014.html0000755000175000017500000001544611140366256016004 0ustar ivanivan Loki: Loki::CachedFactory< AbstractProduct, IdentifierType, CreatorParmTList, EncapsulationPolicy, CreationPolicy, EvictionPolicy, StatisticPolicy, FactoryErrorPolicy, ObjVector > Class Template Reference

Loki::CachedFactory< AbstractProduct, IdentifierType, CreatorParmTList, EncapsulationPolicy, CreationPolicy, EvictionPolicy, StatisticPolicy, FactoryErrorPolicy, ObjVector > Class Template Reference
[Cached Factory]

Factory with caching support. More...

#include <CachedFactory.h>

List of all members.

Public Member Functions

std::vector< IdentifierType > & RegisteredIds ()
 Return the registered ID in this Factory.
void ReleaseObject (ProductReturn &object)
 Use this function to release the object.
void displayCacheType ()
 display the cache configuration


Detailed Description

template<class AbstractProduct, typename IdentifierType, typename CreatorParmTList = NullType, template< class > class EncapsulationPolicy = SimplePointer, class CreationPolicy = AlwaysCreate, template< typename, typename > class EvictionPolicy = EvictRandom, class StatisticPolicy = NoStatisticPolicy, template< typename, class > class FactoryErrorPolicy = DefaultFactoryError, class ObjVector = std::vector<AbstractProduct*>>
class Loki::CachedFactory< AbstractProduct, IdentifierType, CreatorParmTList, EncapsulationPolicy, CreationPolicy, EvictionPolicy, StatisticPolicy, FactoryErrorPolicy, ObjVector >

Factory with caching support.

This class acts as a Factory (it creates objects) but also keeps the already created objects to prevent long constructions time.

Note this implementation do not retain ownership.


Member Function Documentation

template<class AbstractProduct , typename IdentifierType , typename CreatorParmTList = NullType, template< class > class EncapsulationPolicy = SimplePointer, class CreationPolicy = AlwaysCreate, template< typename, typename > class EvictionPolicy = EvictRandom, class StatisticPolicy = NoStatisticPolicy, template< typename, class > class FactoryErrorPolicy = DefaultFactoryError, class ObjVector = std::vector<AbstractProduct*>>
void Loki::CachedFactory< AbstractProduct, IdentifierType, CreatorParmTList, EncapsulationPolicy, CreationPolicy, EvictionPolicy, StatisticPolicy, FactoryErrorPolicy, ObjVector >::ReleaseObject ( ProductReturn &  object  )  [inline]

Use this function to release the object.

if execution brakes in this function then you tried to release an object that wasn't provided by this Cache ... which is bad :-)


The documentation for this class was generated from the following file:
  • CachedFactory.h

Generated on Thu Jan 29 18:51:42 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00329.dot0000755000175000017500000000077211140366257015634 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; Node1 [label="Loki::SpinLevelMutex",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1 -> Node2 [dir=back,color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::SleepLevelMutex",height=0.2,width=0.4,color="black",URL="$a00126.html"]; } libloki-0.1.7.orig/doc/html/a00329.md50000755000175000017500000000004011140366257015517 0ustar ivanivan408d58b2a1f464ab6b6809d1221354c5libloki-0.1.7.orig/doc/html/a00083.html0000755000175000017500000002771311140366257016013 0ustar ivanivan Loki: Loki::MutexLocker Class Reference

Loki::MutexLocker Class Reference

#include <LevelMutex.h>

Collaboration diagram for Loki::MutexLocker:

List of all members.

Public Member Functions

 MutexLocker (volatile LevelMutexInfo &mutex, bool lock=true)
 MutexLocker (volatile LevelMutexInfo &mutex, unsigned int milliSeconds, bool lock=true)
 ~MutexLocker (void)
 Destructs the locker, and determines if it needs to unlock the mutex.
bool Lock (void)
bool Unlock (void)
bool IsLocked (void) const
 Returns true if the mutex is locked by this object.
const volatile LevelMutexInfoGetMutex (void) const
 Provides access to mutex controlled by this.


Detailed Description

You can place an instance of this as a local variable inside a function to lock a single mutex. It will lock the mutex if no error occurs, or throw if one does happen. When the function ends, the destructor will determine if it needs to unlock the mutex. This RAII technique insures the mutex gets unlocked even when exceptions occur.

Constructor & Destructor Documentation

Loki::MutexLocker::MutexLocker ( volatile LevelMutexInfo mutex,
bool  lock = true 
) [explicit]

Creates an object to lock an unlock a mutex for a function. This will throw if an attempt to lock the mutex fails.

Parameters:
mutex Reference to the mutex.
lock True if function wants to lock the mutex as this gets constructed.

References Loki::LevelMutexInfo::GetLevel(), and Loki::LevelMutexInfo::Lock().

Here is the call graph for this function:

Loki::MutexLocker::MutexLocker ( volatile LevelMutexInfo mutex,
unsigned int  milliSeconds,
bool  lock = true 
)

Creates an object to lock an unlock a mutex for a function. This waits a specified amount of time for another thread to unlock the mutex if it is locked. This will throw if an attempt to lock the mutex fails.

Parameters:
mutex Reference to the mutex.
milliSeconds Amount of time to wait for another thread to unlock the mutex.
lock True if function wants to lock the mutex as this gets constructed.

References Loki::LevelMutexInfo::GetLevel(), and Loki::LevelMutexInfo::Lock().

Here is the call graph for this function:


Member Function Documentation

bool Loki::MutexLocker::Lock ( void   ) 

You can call this to lock (or relock) a mutex. In theory, you can lock and unlock a mutex several times within a function in order to give other threads access to a resource while this function does not need it.

Returns:
True if mutex is locked by this, else false if not locked.

References Loki::LevelMutexInfo::Lock().

Here is the call graph for this function:

bool Loki::MutexLocker::Unlock ( void   ) 

You can call this to unlock a mutex before the destructor does it. By unlocking the mutexes before returning, the function can do other operations without making other threads wait too long.

Returns:
True if unlocked by this, else false if not unlocked by this. (Which is not the same as whether the mutex itself is locked or not by another thread.)

References Loki::LevelMutexInfo::Unlock().

Here is the call graph for this function:


The documentation for this class was generated from the following files:

Generated on Thu Jan 29 18:51:43 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00331.dot0000755000175000017500000000077211140366257015625 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; Node1 [label="Loki::SleepLevelMutex",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node2 -> Node1 [dir=back,color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::SpinLevelMutex",height=0.2,width=0.4,color="black",URL="$a00133.html"]; } libloki-0.1.7.orig/doc/html/a00331.md50000755000175000017500000000004011140366257015510 0ustar ivanivan1da58c0b2d6f34efb1b543134991c81dlibloki-0.1.7.orig/doc/html/a00332.dot0000755000175000017500000000077211140366257015626 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; Node1 [label="Loki::SleepLevelMutex",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node2 -> Node1 [dir=back,color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::SpinLevelMutex",height=0.2,width=0.4,color="black",URL="$a00133.html"]; } libloki-0.1.7.orig/doc/html/a00332.md50000755000175000017500000000004011140366257015511 0ustar ivanivan1da58c0b2d6f34efb1b543134991c81dlibloki-0.1.7.orig/doc/html/a00142.html0000755000175000017500000001371011140366255015775 0ustar ivanivan Loki: Visitor Class Reference

Visitor Class Reference
[Visitor]

#include <Visitor.h>

Inheritance diagram for Visitor:

Detailed Description

The building block of Acyclic Visitor

Usage
Defining the visitable class:

 class RasterBitmap : public BaseVisitable<>
 {
 public:
     LOKI_DEFINE_VISITABLE()
 };

Way 1 to define a visitor:

 class SomeVisitor : 
     public BaseVisitor // required
     public Visitor<RasterBitmap>,
     public Visitor<Paragraph>
 {
 public:
     void Visit(RasterBitmap&); // visit a RasterBitmap
     void Visit(Paragraph &);   // visit a Paragraph
 };

Way 2 to define the visitor:

 class SomeVisitor : 
     public BaseVisitor // required
     public Visitor<LOKI_TYPELIST_2(RasterBitmap, Paragraph)>
 {
 public:
     void Visit(RasterBitmap&); // visit a RasterBitmap
     void Visit(Paragraph &);   // visit a Paragraph
 };

Way 3 to define the visitor:

 class SomeVisitor : 
     public BaseVisitor // required
     public Visitor<Seq<RasterBitmap, Paragraph>::Type>
 {
 public:
     void Visit(RasterBitmap&); // visit a RasterBitmap
     void Visit(Paragraph &);   // visit a Paragraph
 };

Using const visit functions:
Defining the visitable class (true for const):

 class RasterBitmap : public BaseVisitable<void, DefaultCatchAll, true>
 {
 public:
     LOKI_DEFINE_CONST_VISITABLE()
 };

Defining the visitor which only calls const member functions:

 class SomeVisitor : 
     public BaseVisitor // required
     public Visitor<RasterBitmap, void, true>,
 {
 public:
     void Visit(const RasterBitmap&); // visit a RasterBitmap by a const member function
 };

Example:
test/Visitor/main.cpp
The documentation for this class was generated from the following file:
  • Visitor.h

Generated on Thu Jan 29 18:51:41 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00334.dot0000755000175000017500000000105511140366257015623 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; Node1 [label="Loki::LevelMutex\< MutexPolicy, DefaultLevel, ErrorPolicy, WaitPolicy \>",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node2 -> Node1 [dir=back,color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::LevelMutexInfo",height=0.2,width=0.4,color="black",URL="$a00071.html"]; } libloki-0.1.7.orig/doc/html/a00334.md50000755000175000017500000000004011140366257015513 0ustar ivanivan17d7237011354e2b2671e447a13db3aalibloki-0.1.7.orig/doc/html/a00201.html0000755000175000017500000000555511140366254016000 0ustar ivanivan Loki: Encapsulation policies

Encapsulation policies
[Cached Factory]

Defines how the object is returned to the client. More...

Collaboration diagram for Encapsulation policies:

Classes

class  Loki::SimplePointer< AbstractProduct >
 No encaspulation : returns the pointer. More...
class  Loki::SmartPointer< AbstractProduct, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ConstnessPolicy >
 Encapsulate the object in a SmartPtr with FunctionStorage policy. More...

Detailed Description

Defines how the object is returned to the client.

Generated on Thu Jan 29 18:51:40 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00335.dot0000755000175000017500000000126211140366257015624 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; Node1 [label="Loki::LevelMutex\< MutexPolicy, DefaultLevel, ErrorPolicy, WaitPolicy \>",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node2 -> Node1 [dir=back,color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::LevelMutexInfo",height=0.2,width=0.4,color="black",URL="$a00071.html"]; Node2 -> Node2 [dir=back,color="darkorchid3",fontsize="10",style="dashed",label="m_previous\ns_currentMutex",fontname="FreeSans"]; } libloki-0.1.7.orig/doc/html/a00335.md50000755000175000017500000000004011140366257015514 0ustar ivanivanbb391e5958efb944f839d20cfd880442libloki-0.1.7.orig/doc/html/a00338.dot0000755000175000017500000000121311140366257015623 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; Node1 [label="Loki::MutexLocker",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node2 -> Node1 [dir=back,color="darkorchid3",fontsize="10",style="dashed",label="m_mutex",fontname="FreeSans"]; Node2 [label="Loki::LevelMutexInfo",height=0.2,width=0.4,color="black",URL="$a00071.html"]; Node2 -> Node2 [dir=back,color="darkorchid3",fontsize="10",style="dashed",label="m_previous\ns_currentMutex",fontname="FreeSans"]; } libloki-0.1.7.orig/doc/html/a00015.html0000755000175000017500000000534711140366261016000 0ustar ivanivan Loki: Loki::CantResetWithStrong< P > Class Template Reference

Loki::CantResetWithStrong< P > Class Template Reference
[Reset policies]

#include <StrongPtr.h>

List of all members.


Detailed Description

template<class P>
class Loki::CantResetWithStrong< P >

Implementation of the ResetPolicy used by StrongPtr. This is the default ResetPolicy for StrongPtr. It forbids reset and release only if a strong copointer exists.
The documentation for this class was generated from the following file:
  • StrongPtr.h

Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00338.md50000755000175000017500000000004011140366257015517 0ustar ivanivand705a82acd92e9b061b5a3563a3b8467libloki-0.1.7.orig/doc/html/a00084.html0000755000175000017500000000505611140366257016010 0ustar ivanivan Loki: Loki::MutexSleepWaits Class Reference

Loki::MutexSleepWaits Class Reference

#include <LevelMutex.h>

List of all members.


Detailed Description

Implements the WaitPolicy for LevelMutex. Sleeps for a moment so thread won't consume idle CPU cycles. Useful for high-level mutexes.
The documentation for this class was generated from the following files:

Generated on Thu Jan 29 18:51:43 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/functions.html0000755000175000017500000006310611140366255017202 0ustar ivanivan Loki: Class Members
Here is a list of all documented class members with links to the class documentation for each member:

- a -

- b -

- c -

- d -

- e -

- f -

- g -

- h -

- i -

- l -

- m -

- o -

- p -

- r -

- s -

- t -

- u -

- v -

- w -

- ~ -


Generated on Thu Jan 29 18:51:41 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00399.html0000755000175000017500000001100611140366261016004 0ustar ivanivan Loki: Member List

Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > Member List

This is the complete list of members for Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >, including all inherited members.

ObjAllocatorSingleton typedefLoki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >
operator delete(void *p, std::size_t size)Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > [inline, static]
operator delete(void *p, const std::nothrow_t &)Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > [inline, static]
operator delete(void *p, void *place)Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > [inline, static]
operator new(std::size_t size)Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > [inline, static]
operator new(std::size_t size, const std::nothrow_t &)Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > [inline, static]
operator new(std::size_t size, void *place)Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > [inline, static]


Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00458.html0000755000175000017500000000375111140366262016011 0ustar ivanivan Loki: Member List

Loki::LongevityLifetime::DieDirectlyBeforeLast< T > Member List

This is the complete list of members for Loki::LongevityLifetime::DieDirectlyBeforeLast< T >, including all inherited members.


Generated on Thu Jan 29 18:51:46 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00202.html0000755000175000017500000000673211140366254015777 0ustar ivanivan Loki: Creation policies

Creation policies
[Cached Factory]

Defines a way to limit the creation operation. More...

Collaboration diagram for Creation policies:

Classes

class  Loki::NeverCreate
 Never allows creation. Testing purposes only. More...
class  Loki::AlwaysCreate
 Always allows creation. More...
class  Loki::RateLimitedCreation
 Limit in rate. More...
class  Loki::AmountLimitedCreation
 Limit by number of objects. More...

Detailed Description

Defines a way to limit the creation operation.

For instance one may want to be alerted (Exception) when

  • Cache has created a more than X object within the last x seconds
  • Cache creation rate has increased dramatically
which may result from bad caching strategy, or critical overload

Generated on Thu Jan 29 18:51:40 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00083_c929c01961dc1b2a2ee1a39333a79c0b_cgraph.dot0000755000175000017500000000105011140366257023563 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node1 [label="Loki::MutexLocker::Lock",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1 -> Node2 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::LevelMutexInfo::Lock",height=0.2,width=0.4,color="black",URL="$a00071.html#c0e21e08ee9974533a4da5008452bd04"]; } libloki-0.1.7.orig/doc/html/a00083_c929c01961dc1b2a2ee1a39333a79c0b_cgraph.md50000755000175000017500000000004011140366257023460 0ustar ivanivanf16b8eb456f48c3af9e9ff7abb103d3elibloki-0.1.7.orig/doc/html/a00348.dot0000755000175000017500000000464711140366257015642 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node1 [label="Loki::ScopeGuardImplBase",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1 -> Node2 [dir=back,color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::ObjScopeGuardImpl0\< Obj, MemFun \>",height=0.2,width=0.4,color="black",URL="$a00093.html"]; Node1 -> Node3 [dir=back,color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node3 [label="Loki::ObjScopeGuardImpl1\< Obj, MemFun, P1 \>",height=0.2,width=0.4,color="black",URL="$a00094.html"]; Node1 -> Node4 [dir=back,color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node4 [label="Loki::ObjScopeGuardImpl2\< Obj, MemFun, P1, P2 \>",height=0.2,width=0.4,color="black",URL="$a00095.html"]; Node1 -> Node5 [dir=back,color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node5 [label="Loki::ObjScopeGuardImpl3\< Obj, MemFun, P1, P2, P3 \>",height=0.2,width=0.4,color="black",URL="$a00096.html"]; Node1 -> Node6 [dir=back,color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node6 [label="Loki::ScopeGuardImpl0\< F \>",height=0.2,width=0.4,color="black",URL="$a00111.html"]; Node1 -> Node7 [dir=back,color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node7 [label="Loki::ScopeGuardImpl1\< F, P1 \>",height=0.2,width=0.4,color="black",URL="$a00112.html"]; Node1 -> Node8 [dir=back,color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node8 [label="Loki::ScopeGuardImpl2\< F, P1, P2 \>",height=0.2,width=0.4,color="black",URL="$a00113.html"]; Node1 -> Node9 [dir=back,color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node9 [label="Loki::ScopeGuardImpl3\< F, P1, P2, P3 \>",height=0.2,width=0.4,color="black",URL="$a00114.html"]; Node1 -> Node10 [dir=back,color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node10 [label="Loki::ScopeGuardImpl4\< F, P1, P2, P3, P4 \>",height=0.2,width=0.4,color="black",URL="$a00115.html"]; Node1 -> Node11 [dir=back,color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node11 [label="Loki::ScopeGuardImpl5\< F, P1, P2, P3, P4, P5 \>",height=0.2,width=0.4,color="black",URL="$a00116.html"]; } libloki-0.1.7.orig/doc/html/a00016.html0000755000175000017500000000502611140366256015777 0ustar ivanivan Loki: Loki::Chainer< Fun1, Fun2 > Class Template Reference

Loki::Chainer< Fun1, Fun2 > Class Template Reference
[Function objects]

#include <Functor.h>

List of all members.


Detailed Description

template<typename Fun1, typename Fun2>
class Loki::Chainer< Fun1, Fun2 >

Chains two functor calls one after another
The documentation for this class was generated from the following file:
  • Functor.h

Generated on Thu Jan 29 18:51:42 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00348.md50000755000175000017500000000004011140366257015520 0ustar ivanivan3031b21e8b491c7bd11f2c451928675dlibloki-0.1.7.orig/doc/html/a00330.html0000755000175000017500000000456111140366257016002 0ustar ivanivan Loki: Member List

Loki::SpinLevelMutex Member List

This is the complete list of members for Loki::SpinLevelMutex, including all inherited members.

SpinLevelMutex(unsigned int level)Loki::SpinLevelMutex [explicit]
~SpinLevelMutex(void)Loki::SpinLevelMutex [virtual]


Generated on Thu Jan 29 18:51:43 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00085.html0000755000175000017500000000503411140366256016004 0ustar ivanivan Loki: Loki::NeverCreate Class Reference

Loki::NeverCreate Class Reference
[Creation policies]

Never allows creation. Testing purposes only. More...

#include <CachedFactory.h>

List of all members.


Detailed Description

Never allows creation. Testing purposes only.

Using this policy will throw an exception.


The documentation for this class was generated from the following file:
  • CachedFactory.h

Generated on Thu Jan 29 18:51:42 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00350.dot0000755000175000017500000000100511140366257015614 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; Node1 [label="Loki::ScopeGuardImpl0\< F \>",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node2 -> Node1 [dir=back,color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::ScopeGuardImplBase",height=0.2,width=0.4,color="black",URL="$a00117.html"]; } libloki-0.1.7.orig/doc/html/a00350.md50000755000175000017500000000004011140366257015511 0ustar ivanivan75e17e27cfd91f2bb878ae4406984d3dlibloki-0.1.7.orig/doc/html/a00351.dot0000755000175000017500000000100511140366260015607 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; Node1 [label="Loki::ScopeGuardImpl0\< F \>",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node2 -> Node1 [dir=back,color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::ScopeGuardImplBase",height=0.2,width=0.4,color="black",URL="$a00117.html"]; } libloki-0.1.7.orig/doc/html/a00351.md50000755000175000017500000000004011140366260015504 0ustar ivanivan75e17e27cfd91f2bb878ae4406984d3dlibloki-0.1.7.orig/doc/html/a00353.dot0000755000175000017500000000101111140366260015606 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; Node1 [label="Loki::ScopeGuardImpl1\< F, P1 \>",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node2 -> Node1 [dir=back,color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::ScopeGuardImplBase",height=0.2,width=0.4,color="black",URL="$a00117.html"]; } libloki-0.1.7.orig/doc/html/a00353.md50000755000175000017500000000004011140366260015506 0ustar ivanivan50f68d38a2163884985bcd0e9c137144libloki-0.1.7.orig/doc/html/a00080_9ce26d13eb156c9a8b7fa6228bf6724f_cgraph.dot0000755000175000017500000000763311140366257023710 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node1 [label="Loki::MultiMutexLocker::Lock",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1 -> Node2 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::LevelMutexInfo::MultiLock",height=0.2,width=0.4,color="black",URL="$a00071.html#dde650eae1cad8b4723e68cdb9130283"]; Node2 -> Node3 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node3 [label="Loki::LevelMutexInfo::MutexUndoer::Cancel",height=0.2,width=0.4,color="black",URL="$a00073.html#87e777d849336fe81907e55aaad1edaa"]; Node2 -> Node4 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node4 [label="Loki::LevelMutexInfo::DoErrorCheck",height=0.2,width=0.4,color="black",URL="$a00071.html#14e0d51318b864645bbb3df4f7c9f7ab"]; Node2 -> Node5 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node5 [label="Loki::DoMutexesMatchContainer",height=0.2,width=0.4,color="black",URL="$a00192.html#d633ca81ae0befaf235ae63886368037"]; Node5 -> Node6 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node6 [label="Loki::CountMutexesAtCurrentLevel",height=0.2,width=0.4,color="black",URL="$a00192.html#8cb767d3e7aaf2fe44b8f3b90218b876"]; Node6 -> Node7 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node7 [label="Loki::LevelMutexInfo::GetCurrentMutex",height=0.2,width=0.4,color="black",URL="$a00071.html#b7fd94847721b118979b72121472d3e2"]; Node7 -> Node8 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node8 [label="Loki::LevelMutexInfo::IsValidList",height=0.2,width=0.4,color="black",URL="$a00071.html#01f6dfba5d2ea5606109b34e5a543cf0"]; Node6 -> Node9 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node9 [label="Loki::LevelMutexInfo::GetLevel",height=0.2,width=0.4,color="black",URL="$a00071.html#1cad7c6b6fc50e230401e4cc22761d14",tooltip="Returns the level of this mutex."]; Node6 -> Node10 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node10 [label="Loki::LevelMutexInfo::GetPrevious",height=0.2,width=0.4,color="black",URL="$a00071.html#b774e94ff72724dd87ff236d99970bb5",tooltip="Returns pointer to mutex previously locked by the thread which locked this."]; Node5 -> Node11 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node11 [label="Loki::GetCurrentThreadsLevel",height=0.2,width=0.4,color="black",URL="$a00192.html#9548795d9cda6f227a1e1241ba577ca8"]; Node11 -> Node7 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node11 -> Node9 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node5 -> Node9 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node5 -> Node12 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node12 [label="Loki::LevelMutexInfo::IsRecentLock",height=0.2,width=0.4,color="black",URL="$a00071.html#b917108c3e7c83b8a515d28e91a3a3ca"]; Node12 -> Node13 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node13 [label="Loki::LevelMutexInfo::IsValid",height=0.2,width=0.4,color="black",URL="$a00071.html#36c34ecf5d019f3db9bfb8654cf49176"]; Node13 -> Node8 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 -> Node11 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 -> Node8 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 -> Node14 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node14 [label="Loki::LevelMutexInfo::MutexUndoer::SetPlace",height=0.2,width=0.4,color="black",URL="$a00073.html#65a5d0ff95ed8ab37280350f6a10259c"]; } libloki-0.1.7.orig/doc/html/a00354.dot0000755000175000017500000000101111140366260015607 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; Node1 [label="Loki::ScopeGuardImpl1\< F, P1 \>",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node2 -> Node1 [dir=back,color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::ScopeGuardImplBase",height=0.2,width=0.4,color="black",URL="$a00117.html"]; } libloki-0.1.7.orig/doc/html/a00080_9ce26d13eb156c9a8b7fa6228bf6724f_cgraph.md50000755000175000017500000000004011140366257023570 0ustar ivanivane9e56a7b42b5604d31d664a4c28aa76dlibloki-0.1.7.orig/doc/html/a00354.md50000755000175000017500000000004011140366260015507 0ustar ivanivan50f68d38a2163884985bcd0e9c137144libloki-0.1.7.orig/doc/html/a00203.html0000755000175000017500000000576111140366254016001 0ustar ivanivan Loki: Eviction policies

Eviction policies
[Cached Factory]

Gathers informations about the stored objects and choose a candidate for eviction. More...

Collaboration diagram for Eviction policies:

Classes

class  Loki::EvictLRU< DT, ST >
 Evicts least accessed objects first. More...
class  Loki::EvictAging< DT, ST >
 LRU aware of the time span of use. More...
class  Loki::EvictRandom< DT, ST >
 Evicts a random object. More...

Detailed Description

Gathers informations about the stored objects and choose a candidate for eviction.

Generated on Thu Jan 29 18:51:40 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00356.dot0000755000175000017500000000101511140366260015615 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; Node1 [label="Loki::ScopeGuardImpl2\< F, P1, P2 \>",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node2 -> Node1 [dir=back,color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::ScopeGuardImplBase",height=0.2,width=0.4,color="black",URL="$a00117.html"]; } libloki-0.1.7.orig/doc/html/a00356.md50000755000175000017500000000004011140366260015511 0ustar ivanivan7328d5bc1b7db9c206c783b4793bfb69libloki-0.1.7.orig/doc/html/a00357.dot0000755000175000017500000000101511140366260015616 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; Node1 [label="Loki::ScopeGuardImpl2\< F, P1, P2 \>",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node2 -> Node1 [dir=back,color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::ScopeGuardImplBase",height=0.2,width=0.4,color="black",URL="$a00117.html"]; } libloki-0.1.7.orig/doc/html/a00357.md50000755000175000017500000000004011140366260015512 0ustar ivanivan7328d5bc1b7db9c206c783b4793bfb69libloki-0.1.7.orig/doc/html/ftv2node.png0000755000175000017500000000035311140366263016533 0ustar ivanivan‰PNG  IHDRLƒ1ู0PLTE€€€ำ tRNS@ๆุftEXtSoftwaregif2png 2.4.2ฃ^G&tEXtCommentUlead GIF SmartSaver Ver 2.0io?อIDATxฺc`0ภO ˆVŒย.Rโ๚E:แIENDฎB`‚libloki-0.1.7.orig/doc/html/a00017.html0000755000175000017500000000613411140366256016001 0ustar ivanivan Loki: Loki::CheckForEquality< Host > Class Template Reference

Loki::CheckForEquality< Host > Class Template Reference

#include <Checker.h>

List of all members.


Detailed Description

template<class Host>
class Loki::CheckForEquality< Host >

Exception Safety Level:
This exception-checking policy class for ContractChecker asserts if a copy of the host differs from the host object regardless of whether an exception occurs. Host classes can use this policy to show which member functions never change data members, and thereby provide the strong exception safety level by default.
Requirements For Host Class:
This policy requires hosts to provide both the copy-constructor and the equality operator, and is intended for classes with value semantics.

The documentation for this class was generated from the following file:

Generated on Thu Jan 29 18:51:42 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00359.dot0000755000175000017500000000102111140366260015615 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; Node1 [label="Loki::ScopeGuardImpl3\< F, P1, P2, P3 \>",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node2 -> Node1 [dir=back,color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::ScopeGuardImplBase",height=0.2,width=0.4,color="black",URL="$a00117.html"]; } libloki-0.1.7.orig/doc/html/a00359.md50000755000175000017500000000004011140366260015514 0ustar ivanivanb05fc1cc825982248d3174fb34487a55libloki-0.1.7.orig/doc/html/a00086.html0000755000175000017500000000513311140366261016001 0ustar ivanivan Loki: Loki::NeverReset< P > Class Template Reference

Loki::NeverReset< P > Class Template Reference
[Reset policies]

#include <StrongPtr.h>

List of all members.


Detailed Description

template<class P>
class Loki::NeverReset< P >

Implementation of the ResetPolicy used by StrongPtr. It forbids reset and release under any circumstance.
The documentation for this class was generated from the following file:
  • StrongPtr.h

Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00360.dot0000755000175000017500000000102111140366260015605 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; Node1 [label="Loki::ScopeGuardImpl3\< F, P1, P2, P3 \>",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node2 -> Node1 [dir=back,color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::ScopeGuardImplBase",height=0.2,width=0.4,color="black",URL="$a00117.html"]; } libloki-0.1.7.orig/doc/html/a00360.md50000755000175000017500000000004011140366260015504 0ustar ivanivanb05fc1cc825982248d3174fb34487a55libloki-0.1.7.orig/doc/html/a00362.dot0000755000175000017500000000102511140366260015613 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; Node1 [label="Loki::ScopeGuardImpl4\< F, P1, P2, P3, P4 \>",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node2 -> Node1 [dir=back,color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::ScopeGuardImplBase",height=0.2,width=0.4,color="black",URL="$a00117.html"]; } libloki-0.1.7.orig/doc/html/a00362.md50000755000175000017500000000004011140366260015506 0ustar ivanivan4697db1d43149422c059f5a8461220c1libloki-0.1.7.orig/doc/html/a00363.dot0000755000175000017500000000102511140366260015614 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; Node1 [label="Loki::ScopeGuardImpl4\< F, P1, P2, P3, P4 \>",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node2 -> Node1 [dir=back,color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::ScopeGuardImplBase",height=0.2,width=0.4,color="black",URL="$a00117.html"]; } libloki-0.1.7.orig/doc/html/a00363.md50000755000175000017500000000004011140366260015507 0ustar ivanivan4697db1d43149422c059f5a8461220c1libloki-0.1.7.orig/doc/html/a00204.html0000755000175000017500000000533311140366254015775 0ustar ivanivan Loki: Statistic policies

Statistic policies
[Cached Factory]

Gathers information about the cache. More...

Collaboration diagram for Statistic policies:

Classes

class  Loki::NoStatisticPolicy
 Do nothing. More...
class  Loki::SimpleStatisticPolicy
 Simple statistics. More...

Detailed Description

Gathers information about the cache.

For debugging purpose this policy proposes to gather informations about the cache. This could be useful to determine whether the cache is mandatory or if the policies are well suited to the application.


Generated on Thu Jan 29 18:51:40 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00365.dot0000755000175000017500000000103111140366260015613 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; Node1 [label="Loki::ScopeGuardImpl5\< F, P1, P2, P3, P4, P5 \>",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node2 -> Node1 [dir=back,color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::ScopeGuardImplBase",height=0.2,width=0.4,color="black",URL="$a00117.html"]; } libloki-0.1.7.orig/doc/html/a00365.md50000755000175000017500000000004011140366260015511 0ustar ivanivan1916bdc5c03896cd2888da581ed113cdlibloki-0.1.7.orig/doc/html/a00366.dot0000755000175000017500000000103111140366260015614 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; Node1 [label="Loki::ScopeGuardImpl5\< F, P1, P2, P3, P4, P5 \>",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node2 -> Node1 [dir=back,color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::ScopeGuardImplBase",height=0.2,width=0.4,color="black",URL="$a00117.html"]; } libloki-0.1.7.orig/doc/html/a00366.md50000755000175000017500000000004011140366260015512 0ustar ivanivan1916bdc5c03896cd2888da581ed113cdlibloki-0.1.7.orig/doc/html/a00368.dot0000755000175000017500000000102211140366260015616 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; Node1 [label="Loki::ObjScopeGuardImpl0\< Obj, MemFun \>",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node2 -> Node1 [dir=back,color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::ScopeGuardImplBase",height=0.2,width=0.4,color="black",URL="$a00117.html"]; } libloki-0.1.7.orig/doc/html/a00018.html0000755000175000017500000000603711140366256016004 0ustar ivanivan Loki: Loki::CheckForNoChange< Host > Class Template Reference

Loki::CheckForNoChange< Host > Class Template Reference

#include <Checker.h>

List of all members.


Detailed Description

template<class Host>
class Loki::CheckForNoChange< Host >

Exception Safety Level:
This exception-checking policy class for ContractChecker asserts only if a copy of the host differs from the host object when an exception occurs. Host classes can use this policy to show which member functions provide the strong exception guarantee.
Requirements:
This policy requires hosts to provide both the copy-constructor and the equality operator, and is intended for classes with value semantics. equality operator.

The documentation for this class was generated from the following file:

Generated on Thu Jan 29 18:51:42 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00368.md50000755000175000017500000000004011140366260015514 0ustar ivanivanc649ba6f476ee7056843d97e1294cb53libloki-0.1.7.orig/doc/html/a00369.dot0000755000175000017500000000102211140366260015617 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; Node1 [label="Loki::ObjScopeGuardImpl0\< Obj, MemFun \>",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node2 -> Node1 [dir=back,color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::ScopeGuardImplBase",height=0.2,width=0.4,color="black",URL="$a00117.html"]; } libloki-0.1.7.orig/doc/html/a00369.md50000755000175000017500000000004011140366260015515 0ustar ivanivanc649ba6f476ee7056843d97e1294cb53libloki-0.1.7.orig/doc/html/a00087.html0000755000175000017500000000507711140366261016011 0ustar ivanivan Loki: Loki::NoCheck< P > Struct Template Reference

Loki::NoCheck< P > Struct Template Reference
[Checking policies]

#include <SmartPtr.h>

List of all members.


Detailed Description

template<class P>
struct Loki::NoCheck< P >

Implementation of the CheckingPolicy used by SmartPtr Well, it's clear what it does :o)
The documentation for this struct was generated from the following file:
  • SmartPtr.h

Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00371.dot0000755000175000017500000000102611140366260015614 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; Node1 [label="Loki::ObjScopeGuardImpl1\< Obj, MemFun, P1 \>",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node2 -> Node1 [dir=back,color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::ScopeGuardImplBase",height=0.2,width=0.4,color="black",URL="$a00117.html"]; } libloki-0.1.7.orig/doc/html/a00371.md50000755000175000017500000000004011140366260015506 0ustar ivanivan62fcdd9fcbe7755613a44aaa7424aa79libloki-0.1.7.orig/doc/html/a00372.dot0000755000175000017500000000102611140366260015615 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; Node1 [label="Loki::ObjScopeGuardImpl1\< Obj, MemFun, P1 \>",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node2 -> Node1 [dir=back,color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::ScopeGuardImplBase",height=0.2,width=0.4,color="black",URL="$a00117.html"]; } libloki-0.1.7.orig/doc/html/a00372.md50000755000175000017500000000004011140366260015507 0ustar ivanivan62fcdd9fcbe7755613a44aaa7424aa79libloki-0.1.7.orig/doc/html/a00374.dot0000755000175000017500000000103211140366260015614 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; Node1 [label="Loki::ObjScopeGuardImpl2\< Obj, MemFun, P1, P2 \>",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node2 -> Node1 [dir=back,color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::ScopeGuardImplBase",height=0.2,width=0.4,color="black",URL="$a00117.html"]; } libloki-0.1.7.orig/doc/html/a00374.md50000755000175000017500000000004011140366260015511 0ustar ivanivan32105f9fcbaaf75ed54545b14c1ac330libloki-0.1.7.orig/doc/html/a00205.html0000755000175000017500000001021311140366254015767 0ustar ivanivan Loki: Factory

Factory
[Factories]

Implements a generic object factory. More...

Collaboration diagram for Factory:


Classes

class  Loki::Factory< AbstractProduct, IdentifierType, CreatorParmTList, FactoryErrorPolicy >

Modules

 Factory Error Policies
 Manages the "Unknown Type" error in an object factory.

Detailed Description

Implements a generic object factory.

The Factory Method pattern is an object-oriented design pattern. Like other creational patterns, it deals with the problem of creating objects (products) without specifying the exact class of object that will be created. Factory Method, one of the patterns from the Design Patterns book, handles this problem by defining a separate method for creating the objects, which subclasses can then override to specify the derived type of product that will be created.
More generally, the term Factory Method is often used to refer to any method whose main purpose is creation of objects.

Loki proposes a generic version of the Factory. Here is a typical use.

1. Factory< AbstractProduct, int > aFactory;
2. aFactory.Register( 1, createProductNull );
3. aFactory.CreateObject( 1 );


  • 1. The declaration
    You want a Factory that produces AbstractProduct.
    The client will refer to a creation method through an int.
  • 2.The registration
    The code that will contribute to the Factory will now need to declare its ProductCreator by registering them into the Factory.
    A ProductCreator is a just a function that will return the right object. ie
    Product* createProductNull()
    {
    return new Product
    }

  • 3. The use
    Now the client can create object by calling the Factory's CreateObject method with the right identifier. If the ProductCreator were to have arguments (ie :Product* createProductParm( int a, int b ))

Generated on Thu Jan 29 18:51:40 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00375.dot0000755000175000017500000000103211140366260015615 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; Node1 [label="Loki::ObjScopeGuardImpl2\< Obj, MemFun, P1, P2 \>",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node2 -> Node1 [dir=back,color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::ScopeGuardImplBase",height=0.2,width=0.4,color="black",URL="$a00117.html"]; } libloki-0.1.7.orig/doc/html/a00375.md50000755000175000017500000000004011140366260015512 0ustar ivanivan32105f9fcbaaf75ed54545b14c1ac330libloki-0.1.7.orig/doc/html/index.html0000755000175000017500000000062311140366263016273 0ustar ivanivan Loki <a href="main.html">Frames are disabled. Click here to go to the main page.</a> libloki-0.1.7.orig/doc/html/a00377.dot0000755000175000017500000000103611140366260015623 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; Node1 [label="Loki::ObjScopeGuardImpl3\< Obj, MemFun, P1, P2, P3 \>",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node2 -> Node1 [dir=back,color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::ScopeGuardImplBase",height=0.2,width=0.4,color="black",URL="$a00117.html"]; } libloki-0.1.7.orig/doc/html/a00377.md50000755000175000017500000000004011140366260015514 0ustar ivanivanc8364dc3237b69171e26df9cb132e126libloki-0.1.7.orig/doc/html/a00378.dot0000755000175000017500000000103611140366260015624 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; Node1 [label="Loki::ObjScopeGuardImpl3\< Obj, MemFun, P1, P2, P3 \>",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node2 -> Node1 [dir=back,color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::ScopeGuardImplBase",height=0.2,width=0.4,color="black",URL="$a00117.html"]; } libloki-0.1.7.orig/doc/html/a00019.html0000755000175000017500000000616111140366256016003 0ustar ivanivan Loki: Loki::CheckForNoChangeOrThrow< Host > Class Template Reference

Loki::CheckForNoChangeOrThrow< Host > Class Template Reference

#include <Checker.h>

List of all members.


Detailed Description

template<class Host>
class Loki::CheckForNoChangeOrThrow< Host >

Exception Safety Level:
This exception-checking policy class for ContractChecker asserts either if a copy of the host differs from the original host object, or if an exception occurs. Host classes can use this policy to show which member functions provide the no-throw exception guarantee, and would never change data anyway.
Requirements For Host Class:
This policy requires hosts to provide both the copy-constructor and the equality operator, and is intended for classes with value semantics.

The documentation for this class was generated from the following file:

Generated on Thu Jan 29 18:51:42 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00378.md50000755000175000017500000000004011140366260015515 0ustar ivanivanc8364dc3237b69171e26df9cb132e126libloki-0.1.7.orig/doc/html/a00218_g239a9b1c4e557388ba4b9c39051c3f4e_cgraph.dot0000755000175000017500000000117111140366255023702 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node1 [label="Loki::operator\>=",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1 -> Node2 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::StrongPtr::GreaterThan",height=0.2,width=0.4,color="black",URL="$a00135.html#f43b2cde389f926c16e166c418b13040",tooltip="Helper function which can be called to avoid exposing GetPointer function."]; } libloki-0.1.7.orig/doc/html/a00218_g239a9b1c4e557388ba4b9c39051c3f4e_cgraph.md50000755000175000017500000000004011140366255023573 0ustar ivanivan210cf162d506d7d93feb901ed4e5febclibloki-0.1.7.orig/doc/html/a00333.html0000755000175000017500000000605211140366257016002 0ustar ivanivan Loki: Member List

Loki::SleepLevelMutex Member List

This is the complete list of members for Loki::SleepLevelMutex, including all inherited members.

Lock(void) volatileLoki::SleepLevelMutex [virtual]
SleepLevelMutex(unsigned int level)Loki::SleepLevelMutex [explicit]
SpinLevelMutex(unsigned int level)Loki::SpinLevelMutex [explicit]
~SleepLevelMutex(void)Loki::SleepLevelMutex [virtual]
~SpinLevelMutex(void)Loki::SpinLevelMutex [virtual]


Generated on Thu Jan 29 18:51:43 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00088.html0000755000175000017500000000511511140366261016003 0ustar ivanivan Loki: Loki::NoCopy< P > Class Template Reference

Loki::NoCopy< P > Class Template Reference
[Ownership policies]

#include <SmartPtr.h>

List of all members.


Detailed Description

template<class P>
class Loki::NoCopy< P >

Implementation of the OwnershipPolicy used by SmartPtr Implements a policy that doesn't allow copying objects
The documentation for this class was generated from the following file:
  • SmartPtr.h

Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00147.html0000755000175000017500000001022611140366253015777 0ustar ivanivan Loki: Checker.h File Reference

Checker.h File Reference

This file provides Loki's Checker facility. More...

#include <exception>
#include <assert.h>

Include dependency graph for Checker.h:

Classes

class  Loki::CheckForNoThrow< Host >
class  Loki::CheckForNoChange< Host >
class  Loki::CheckForNoChangeOrThrow< Host >
class  Loki::CheckForEquality< Host >
class  Loki::CheckForNothing< Host >
class  Loki::ContractChecker< Host, ExceptionPolicy >
class  Loki::CheckStaticForNoThrow
class  Loki::CheckStaticForNothing
class  Loki::StaticChecker< ExceptionPolicy >

Namespaces

namespace  Loki

Detailed Description

This file provides Loki's Checker facility.


Generated on Thu Jan 29 18:51:39 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00461.html0000755000175000017500000000371711140366262016005 0ustar ivanivan Loki: Member List

Loki::LongevityLifetime::DieFirst< T > Member List

This is the complete list of members for Loki::LongevityLifetime::DieFirst< T >, including all inherited members.


Generated on Thu Jan 29 18:51:46 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/globals.html0000755000175000017500000000373411140366263016615 0ustar ivanivan Loki: Class Members
Here is a list of all documented file members with links to the documentation:


Generated on Thu Jan 29 18:51:47 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00206.html0000755000175000017500000000445711140366254016005 0ustar ivanivan Loki: Factory Error Policies

Factory Error Policies
[Factory]

Manages the "Unknown Type" error in an object factory. More...

Collaboration diagram for Factory Error Policies:

Classes

class  Loki::DefaultFactoryError< IdentifierType, AbstractProduct >
 Default policy that throws an exception. More...

Detailed Description

Manages the "Unknown Type" error in an object factory.

Generated on Thu Jan 29 18:51:40 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/installdox0000755000175000017500000000502511140366255016404 0ustar ivanivan#!/usr/bin/perl %subst = ( ); $quiet = 0; if (open(F,"search.cfg")) { $_= ; s/[ \t\n]*$//g ; $subst{"_doc"} = $_; $_= ; s/[ \t\n]*$//g ; $subst{"_cgi"} = $_; } while ( @ARGV ) { $_ = shift @ARGV; if ( s/^-// ) { if ( /^l(.*)/ ) { $v = ($1 eq "") ? shift @ARGV : $1; ($v =~ /\/$/) || ($v .= "/"); $_ = $v; if ( /(.+)\@(.+)/ ) { if ( exists $subst{$1} ) { $subst{$1} = $2; } else { print STDERR "Unknown tag file $1 given with option -l\n"; &usage(); } } else { print STDERR "Argument $_ is invalid for option -l\n"; &usage(); } } elsif ( /^q/ ) { $quiet = 1; } elsif ( /^\?|^h/ ) { &usage(); } else { print STDERR "Illegal option -$_\n"; &usage(); } } else { push (@files, $_ ); } } foreach $sub (keys %subst) { if ( $subst{$sub} eq "" ) { print STDERR "No substitute given for tag file `$sub'\n"; &usage(); } elsif ( ! $quiet && $sub ne "_doc" && $sub ne "_cgi" ) { print "Substituting $subst{$sub} for each occurence of tag file $sub\n"; } } if ( ! @files ) { if (opendir(D,".")) { foreach $file ( readdir(D) ) { $match = ".html"; next if ( $file =~ /^\.\.?$/ ); ($file =~ /$match/) && (push @files, $file); ($file =~ "tree.js") && (push @files, $file); } closedir(D); } } if ( ! @files ) { print STDERR "Warning: No input files given and none found!\n"; } foreach $f (@files) { if ( ! $quiet ) { print "Editing: $f...\n"; } $oldf = $f; $f .= ".bak"; unless (rename $oldf,$f) { print STDERR "Error: cannot rename file $oldf\n"; exit 1; } if (open(F,"<$f")) { unless (open(G,">$oldf")) { print STDERR "Error: opening file $oldf for writing\n"; exit 1; } if ($oldf ne "tree.js") { while () { s/doxygen\=\"([^ \"\:\t\>\<]*)\:([^ \"\t\>\<]*)\" (href|src)=\"\2/doxygen\=\"$1:$subst{$1}\" \3=\"$subst{$1}/g; print G "$_"; } } else { while () { s/\"([^ \"\:\t\>\<]*)\:([^ \"\t\>\<]*)\", \"\2/\"$1:$subst{$1}\" ,\"$subst{$1}/g; print G "$_"; } } } else { print STDERR "Warning file $f does not exist\n"; } unlink $f; } sub usage { print STDERR "Usage: installdox [options] [html-file [html-file ...]]\n"; print STDERR "Options:\n"; print STDERR " -l tagfile\@linkName tag file + URL or directory \n"; print STDERR " -q Quiet mode\n\n"; exit 1; } libloki-0.1.7.orig/doc/html/inherits.html0000755000175000017500000000363711140366255017022 0ustar ivanivan Loki: Graphical Class Hierarchy

Graphical Class Hierarchy

Go to the textual class hierarchy


Generated on Thu Jan 29 18:51:41 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00089.html0000755000175000017500000000511211140366260016000 0ustar ivanivan Loki: Loki::NoDestroy< T > Struct Template Reference

Loki::NoDestroy< T > Struct Template Reference
[Lifetime policies]

#include <Singleton.h>

List of all members.


Detailed Description

template<class T>
struct Loki::NoDestroy< T >

Implementation of the LifetimePolicy used by SingletonHolder Never destroys the object
The documentation for this struct was generated from the following file:
  • Singleton.h

Generated on Thu Jan 29 18:51:44 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00392.dot0000755000175000017500000000115711140366260015624 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node1 [label="Loki::SmallObjAllocator",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1 -> Node2 [dir=back,color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::AllocatorSingleton\< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy \>",height=0.2,width=0.4,color="black",URL="$a00002.html"]; } libloki-0.1.7.orig/doc/html/a00392.md50000755000175000017500000000004011140366260015511 0ustar ivanivan1db7bd89d940bb01f0d5d3d0b029e910libloki-0.1.7.orig/doc/html/a00393.dot0000755000175000017500000000136111140366260015622 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; Node1 [label="Loki::SmallObjAllocator",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node2 -> Node1 [dir=back,color="darkorchid3",fontsize="10",style="dashed",label="pool_",fontname="FreeSans"]; Node2 [label="Loki::FixedAllocator",height=0.2,width=0.4,color="black",URL="$a00056.html"]; Node3 -> Node2 [dir=back,color="darkorchid3",fontsize="10",style="dashed",label="allocChunk_\nemptyChunk_\ndeallocChunk_",fontname="FreeSans"]; Node3 [label="Loki::Chunk",height=0.2,width=0.4,color="black",URL="$a00025.html"]; } libloki-0.1.7.orig/doc/html/a00393.md50000755000175000017500000000004011140366260015512 0ustar ivanivan0120bf44c40a5e21d26e523a18594e05libloki-0.1.7.orig/doc/html/a00207.html0000755000175000017500000000441211140366254015775 0ustar ivanivan Loki: Clone Factory

Clone Factory
[Factories]

Creates a copy from a polymorphic object. More...

Collaboration diagram for Clone Factory:

Classes

class  Loki::CloneFactory< AbstractProduct, ProductCreator, FactoryErrorPolicy >
 Creates a copy from a polymorphic object. More...

Detailed Description

Creates a copy from a polymorphic object.

Generated on Thu Jan 29 18:51:40 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00395.dot0000755000175000017500000000114111140366261015621 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; Node1 [label="Loki::AllocatorSingleton\< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy \>",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node2 -> Node1 [dir=back,color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::SmallObjAllocator",height=0.2,width=0.4,color="black",URL="$a00127.html"]; } libloki-0.1.7.orig/doc/html/a00395.md50000755000175000017500000000004011140366261015515 0ustar ivanivan7295e99be4cf4720e23f00a3348eda42libloki-0.1.7.orig/doc/html/a00396.dot0000755000175000017500000000202611140366261015625 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; Node1 [label="Loki::AllocatorSingleton\< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy \>",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node2 -> Node1 [dir=back,color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::SmallObjAllocator",height=0.2,width=0.4,color="black",URL="$a00127.html"]; Node3 -> Node2 [dir=back,color="darkorchid3",fontsize="10",style="dashed",label="pool_",fontname="FreeSans"]; Node3 [label="Loki::FixedAllocator",height=0.2,width=0.4,color="black",URL="$a00056.html"]; Node4 -> Node3 [dir=back,color="darkorchid3",fontsize="10",style="dashed",label="allocChunk_\nemptyChunk_\ndeallocChunk_",fontname="FreeSans"]; Node4 [label="Loki::Chunk",height=0.2,width=0.4,color="black",URL="$a00025.html"]; } libloki-0.1.7.orig/doc/html/a00396.md50000755000175000017500000000004011140366261015516 0ustar ivanivand293059b894a7a9446af6bbaa621392flibloki-0.1.7.orig/doc/html/a00398.dot0000755000175000017500000000331211140366261015626 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node1 [label="Loki::SmallObjectBase\< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy \>",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1 -> Node2 [dir=back,color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::SmallObject\< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy \>",height=0.2,width=0.4,color="black",URL="$a00128.html"]; Node1 -> Node3 [dir=back,color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node3 [label="Loki::SmallValueObject\< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy \>",height=0.2,width=0.4,color="black",URL="$a00130.html"]; Node3 -> Node4 [dir=back,color="orange",fontsize="10",style="dashed",label="\",fontname="FreeSans"]; Node4 [label="Loki::SmallValueObject\< ThreadingModel \>",height=0.2,width=0.4,color="black",URL="$a00130.html"]; Node1 -> Node5 [dir=back,color="orange",fontsize="10",style="dashed",label="\< ThreadingModel , 4096 , 256 , 4 , ::Loki::LongevityLifetime::DieAsSmallObjectParent , ::Loki::Mutex \>",fontname="FreeSans"]; Node5 [label="Loki::SmallObjectBase\< ThreadingModel, 4096, 256, 4,::Loki::LongevityLifetime::DieAsSmallObjectParent,::Loki::Mutex \>",height=0.2,width=0.4,color="black",URL="$a00129.html"]; Node5 -> Node4 [dir=back,color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; } libloki-0.1.7.orig/doc/html/a00020.html0000755000175000017500000000573011140366256015774 0ustar ivanivan Loki: Loki::CheckForNothing< Host > Class Template Reference

Loki::CheckForNothing< Host > Class Template Reference

#include <Checker.h>

List of all members.


Detailed Description

template<class Host>
class Loki::CheckForNothing< Host >

Exception Safety Level:
This exception-checking policy class for ContractChecker does nothing when called. Host classes can use this to show which member functions provide neither the strong nor no-throw exception guarantees. The best guarantee such functions can provide is that nothing gets leaked.
Requirements For Host Class:
This policy imposes no requirements on a host class.

The documentation for this class was generated from the following file:

Generated on Thu Jan 29 18:51:42 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00398.md50000755000175000017500000000004011140366261015520 0ustar ivanivan7beb5b4f3557ce8d41df0239ce8f713flibloki-0.1.7.orig/doc/html/a00208.html0000755000175000017500000001245411140366254016003 0ustar ivanivan Loki: Function objects

Function objects


Classes

struct  Function
class  Loki::Functor< R, TList, ThreadingModel >
class  Loki::BinderFirst< OriginalFunctor >
class  Loki::Chainer< Fun1, Fun2 >

Functions

template<class Fctor >
Private::BinderFirstTraits
< Fctor >::BoundFunctorType 
Loki::BindFirst (const Fctor &fun, typename Fctor::Parm1 bound)
template<class Fun1 , class Fun2 >
Fun2 Loki::Chain (const Fun1 &fun1, const Fun2 &fun2)

Function Documentation

template<class Fctor >
Private::BinderFirstTraits<Fctor>::BoundFunctorType Loki::BindFirst ( const Fctor &  fun,
typename Fctor::Parm1  bound 
) [inline]

Binds the first parameter of a Functor object to a specific value

template<class Fun1 , class Fun2 >
Fun2 Loki::Chain ( const Fun1 &  fun1,
const Fun2 &  fun2 
) [inline]

Chains two functor calls one after another


Generated on Thu Jan 29 18:51:40 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00071_b7fd94847721b118979b72121472d3e2_cgraph.dot0000755000175000017500000000107511140366256023241 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node1 [label="Loki::LevelMutexInfo::GetCurrentMutex",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1 -> Node2 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::LevelMutexInfo::IsValidList",height=0.2,width=0.4,color="black",URL="$a00071.html#01f6dfba5d2ea5606109b34e5a543cf0"]; } libloki-0.1.7.orig/doc/html/a00071_b7fd94847721b118979b72121472d3e2_cgraph.md50000755000175000017500000000004011140366256023127 0ustar ivanivan8d53d7a72a9e001babc74066dc63c361libloki-0.1.7.orig/doc/html/a00021.html0000755000175000017500000001272611140366256016000 0ustar ivanivan Loki: Loki::CheckForNoThrow< Host > Class Template Reference

Loki::CheckForNoThrow< Host > Class Template Reference

#include <Checker.h>

List of all members.


Detailed Description

template<class Host>
class Loki::CheckForNoThrow< Host >

ContractChecker and StaticChecker Overview
The ContractChecker and StaticChecker classes have two purposes:
  • provide a mechanism by which programmers can determine which functions violate class/data invariants,
  • and determine which exception safety a function provides.
Class & Data Invariants
The ContractChecker and StaticChecker define invariants as "expressions that are true for particular data". They uses a function which returns true if all data are valid, and returns false if any datum is invalid. This is called the validator function, and the host class or function provides a pointer to it. The validator could also assert for any invariant which fails rather than return false. If the validator is a static member function, you can use it with checkers in any function, but especially standalone functions and class static functions. If the validator is a non-static member function, you can use it only within non-static member functions.
Exception Safety Levels
Years ago, David Abrahams formalized a framework for assessing the exception safety level a function provides. His framework describes three levels of guarantees. Any function which does not provide any of these levels is considered unsafe. ContractChecker and StaticChecker determine a function's safety level through the use of policy classes. Checker's policy classes can show if a function provides any of these three guarantees. Since there is no universal way to detect leaks, this facility provides no mechanism for finding leaks, but users may create their own validators which do. StaticChecker's policy classes only provide direct checking for the no-throw and invariant guarantees. With some finesse, a programmer can write a validator for StaticChecker that checks for the Strong guarantee.
  • No-throw guarantee: A function will not throw any exceptions.
  • Strong guarantee: A function will not change data if an exception occurs. (Which I call the no-change guarantee.)
  • Basic guarantee: A function will not leak resources and data will remain in a valid state if an exception occurs. (Which I call either the no-leak or no-break guarantee depending on context.)

Exception Safety Level:
This exception-checking policy class for ContractChecker asserts if an exception exists. Host classes can use this to show that a member function provides the no-throw exception safety guarantees.
Requirements For Host Class:
This policy imposes no requirements on a host class.

The documentation for this class was generated from the following file:

Generated on Thu Jan 29 18:51:42 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00336.html0000755000175000017500000002204211140366257016002 0ustar ivanivan Loki: Member List

Loki::LevelMutex< MutexPolicy, DefaultLevel, ErrorPolicy, WaitPolicy > Member List

This is the complete list of members for Loki::LevelMutex< MutexPolicy, DefaultLevel, ErrorPolicy, WaitPolicy >, including all inherited members.

DecrementCount(void) volatileLoki::LevelMutexInfo [protected]
GetCurrentMutex(void)Loki::LevelMutexInfo [static]
GetLevel(void) const volatileLoki::LevelMutexInfo [inline]
GetLockCount(void) const volatileLoki::LevelMutexInfo [inline]
GetMutexPolicy(void) const volatileLoki::LevelMutex< MutexPolicy, DefaultLevel, ErrorPolicy, WaitPolicy > [inline]
GetPrevious(void) const volatileLoki::LevelMutexInfo [inline]
IncrementCount(void) volatileLoki::LevelMutexInfo [protected]
IsLocked(void) const volatileLoki::LevelMutexInfo [inline]
IsLockedByAnotherThread(void) const volatileLoki::LevelMutexInfo
IsLockedByCurrentThread(void) const volatileLoki::LevelMutexInfo
IsRecentLock(void) const volatileLoki::LevelMutexInfo
IsRecentLock(unsigned int count) const volatileLoki::LevelMutexInfo
IsValid(void) const volatileLoki::LevelMutexInfo [protected]
IsValidList(void)Loki::LevelMutexInfo [protected, static]
LevelMutex(unsigned int level=DefaultLevel)Loki::LevelMutex< MutexPolicy, DefaultLevel, ErrorPolicy, WaitPolicy > [inline, explicit]
LevelMutexInfo(unsigned int level)Loki::LevelMutexInfo [explicit, protected]
Lock(void) volatileLoki::LevelMutex< MutexPolicy, DefaultLevel, ErrorPolicy, WaitPolicy > [inline, virtual]
Lock(unsigned int milliSeconds) volatileLoki::LevelMutex< MutexPolicy, DefaultLevel, ErrorPolicy, WaitPolicy > [inline, virtual]
MultiLock(MutexContainer &mutexes)Loki::LevelMutexInfo [static]
MultiLock(MutexContainer &mutexes, unsigned int milliSeconds)Loki::LevelMutexInfo [static]
MultiUnlock(MutexContainer &mutexes)Loki::LevelMutexInfo [static]
MutexContainer typedefLoki::LevelMutexInfo
PostLock(void) volatileLoki::LevelMutexInfo [protected]
PreUnlock(void) volatileLoki::LevelMutexInfo [protected]
TryLock(void) volatileLoki::LevelMutex< MutexPolicy, DefaultLevel, ErrorPolicy, WaitPolicy > [inline, virtual]
Unlock(void) volatileLoki::LevelMutex< MutexPolicy, DefaultLevel, ErrorPolicy, WaitPolicy > [inline, virtual]
UnlockedLevelLoki::LevelMutexInfo [static]
~LevelMutex(void)Loki::LevelMutex< MutexPolicy, DefaultLevel, ErrorPolicy, WaitPolicy > [inline]
~LevelMutexInfo(void)Loki::LevelMutexInfo [protected, virtual]


Generated on Thu Jan 29 18:51:43 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00090.html0000755000175000017500000000475011140366257016005 0ustar ivanivan Loki: Loki::NoMutexWait Class Reference

Loki::NoMutexWait Class Reference

#include <LevelMutex.h>

List of all members.


Detailed Description

Implements the WaitPolicy for LevelMutex. Does nothing at all so it turns all wait loops into spin loops. Useful for low-level mutexes.
The documentation for this class was generated from the following file:

Generated on Thu Jan 29 18:51:43 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00400.dot0000755000175000017500000000130711140366261015610 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node1 [label="Loki::SmallObject\< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy \>",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node2 -> Node1 [dir=back,color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::SmallObjectBase\< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy \>",height=0.2,width=0.4,color="black",URL="$a00129.html"]; } libloki-0.1.7.orig/doc/html/a00400.md50000755000175000017500000000004011140366261015500 0ustar ivanivan131790a3f51aac547a15a188d607f4aflibloki-0.1.7.orig/doc/html/a00401.dot0000755000175000017500000000130711140366261015611 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node1 [label="Loki::SmallObject\< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy \>",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node2 -> Node1 [dir=back,color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::SmallObjectBase\< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy \>",height=0.2,width=0.4,color="black",URL="$a00129.html"]; } libloki-0.1.7.orig/doc/html/a00401.md50000755000175000017500000000004011140366261015501 0ustar ivanivan131790a3f51aac547a15a188d607f4aflibloki-0.1.7.orig/doc/html/ftv2link.png0000755000175000017500000000054611140366263016547 0ustar ivanivan‰PNG  IHDR_Tq-0PLTE€€€€€€€ภภภ~›tRNS@ๆุftEXtSoftwaregif2png 2.4.2ฃ^G&tEXtCommentUlead GIF SmartSaver Ver 2.0ู ๅJIDATxฺ}Œฑ ย0Eo3ดc~กSW‹~€nฎZฒพ:d5ธd์/Ÿy!Pะษอแพจ‚เf}ภžQp@ฯญtbโ มฬa;jป;้hบฌQ$์Khํา^~’จm„ฒ((8สาLF-Yฬ8\‹ฬใ+q๚yผgy…Ti/๘ฯq•+กxะIENDฎB`‚libloki-0.1.7.orig/doc/html/a00403.dot0000755000175000017500000000167111140366261015617 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node1 [label="Loki::SmallValueObject\< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy \>",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node2 -> Node1 [dir=back,color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::SmallObjectBase\< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy \>",height=0.2,width=0.4,color="black",URL="$a00129.html"]; Node1 -> Node3 [dir=back,color="orange",fontsize="10",style="dashed",label="\",fontname="FreeSans"]; Node3 [label="Loki::SmallValueObject\< ThreadingModel \>",height=0.2,width=0.4,color="black",URL="$a00130.html"]; } libloki-0.1.7.orig/doc/html/a00403.md50000755000175000017500000000004011140366261015503 0ustar ivanivan2d527b127fa79dd9e80e57eb64aba6a2libloki-0.1.7.orig/doc/html/a00404.dot0000755000175000017500000000131411140366261015612 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node1 [label="Loki::SmallValueObject\< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy \>",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node2 -> Node1 [dir=back,color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::SmallObjectBase\< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy \>",height=0.2,width=0.4,color="black",URL="$a00129.html"]; } libloki-0.1.7.orig/doc/html/a00404.md50000755000175000017500000000004011140366261015504 0ustar ivanivandeaefd8bd6d769b7dab447ed05054821libloki-0.1.7.orig/doc/html/a00464.html0000755000175000017500000000375311140366262016010 0ustar ivanivan Loki: Member List

Loki::LongevityLifetime::DieAsSmallObjectParent< T > Member List

This is the complete list of members for Loki::LongevityLifetime::DieAsSmallObjectParent< T >, including all inherited members.


Generated on Thu Jan 29 18:51:46 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00209.html0000755000175000017500000000435211140366254016002 0ustar ivanivan Loki: Pimpl

Pimpl


Classes

class  Loki::ConstPropPtr< T >
class  Loki::Pimpl< T, Pointer >
class  ImplOf
class  PImplOf

Generated on Thu Jan 29 18:51:40 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00022.html0000755000175000017500000001753511140366256016004 0ustar ivanivan Loki: Loki::CheckReturn< Value, OnError > Class Template Reference

Loki::CheckReturn< Value, OnError > Class Template Reference

#include <CheckReturn.h>

List of all members.

Public Member Functions

 CheckReturn (const Value &value)
 Conversion constructor changes Value type to CheckReturn type.
 CheckReturn (const CheckReturn &that)
 ~CheckReturn (void)
 Destructor checks if return value was used.
 operator Value (void)
 Conversion operator changes CheckReturn back to Value type.


Detailed Description

template<class Value, template< class > class OnError = TriggerAssert>
class Loki::CheckReturn< Value, OnError >

Purpose
C++ provides no mechanism within the language itself to force code to check the return value from a function call. This simple class provides a mechanism by which programmers can force calling functions to check the return value. Or at least make them consciously choose to disregard the return value. If the calling function fails to use or store the return value, the destructor calls the OnError policy.
Template Parameters
CheckReturn has two template parameters, Value and OnError.
  • Value is the return type from the function. CheckReturn stores a copy of it rather than a reference or pointer since return value could be local to a function. CheckReturn works best when the return type is a built-in primitive (bool, int, etc...) a pointer, or an enum (such as an error condition enum). It can work with other types that have cheap copy operations.
  • OnError is a policy class indicating how to handle the situation when a caller does not check or copy the returned value. Loki provides some policy classs and you may also write your own. For example, you can write a policy to create a message box when the function ignores the return value. That would quickly tell you places where code ignores the function call. If your write your own, you only need a templated class or struct with a public function named "run" that accepts a reference to a const value.
Provided Policy Classes
  • IgnoreReturnValue Deliberately ignores when the caller ignores the return value.
  • TriggerAssert Asserts in debug builds if the caller ignores the return value.
  • FprintfStderr Prints out an error message if the caller ignores the return value.
  • ThrowTheValue Throws the ignored value as an exception.
  • ThrowLogicError Throws a logic_error exception to indicate a programming error.

Constructor & Destructor Documentation

template<class Value , template< class > class OnError = TriggerAssert>
Loki::CheckReturn< Value, OnError >::CheckReturn ( const CheckReturn< Value, OnError > &  that  )  [inline]

Copy-constructor allows functions to call another function within the return statement. The other CheckReturn's m_checked flag is set since its duty has been passed to the m_checked flag in this one.

References Loki::CheckReturn< Value, OnError >::m_checked.


The documentation for this class was generated from the following file:
  • CheckReturn.h

Generated on Thu Jan 29 18:51:42 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00337.html0000755000175000017500000000675411140366257016017 0ustar ivanivan Loki: Member List

Loki::MutexException Member List

This is the complete list of members for Loki::MutexException, including all inherited members.

GetLevel(void) const Loki::MutexException [inline]
GetReason(void) const Loki::MutexException [inline]
MutexException(const char *message, unsigned int level, MutexErrors::Type reason)Loki::MutexException
MutexException(const MutexException &that)Loki::MutexException
operator=(const MutexException &that)Loki::MutexException
what(void) const Loki::MutexException [virtual]
~MutexException(void)Loki::MutexException [virtual]


Generated on Thu Jan 29 18:51:43 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00091.html0000755000175000017500000000477511140366256016014 0ustar ivanivan Loki: Loki::NoStatisticPolicy Class Reference

Loki::NoStatisticPolicy Class Reference
[Statistic policies]

Do nothing. More...

#include <CachedFactory.h>

List of all members.


Detailed Description

Do nothing.

Should be used in release code for better performances


The documentation for this class was generated from the following file:
  • CachedFactory.h

Generated on Thu Jan 29 18:51:42 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00083_f5ea31fe3fac046cf646722cc8befa09_cgraph.dot0000755000175000017500000000105411140366257024106 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node1 [label="Loki::MutexLocker::Unlock",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1 -> Node2 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::LevelMutexInfo::Unlock",height=0.2,width=0.4,color="black",URL="$a00071.html#01c9af5cb0f6870585b864b4557e9242"]; } libloki-0.1.7.orig/doc/html/a00083_f5ea31fe3fac046cf646722cc8befa09_cgraph.md50000755000175000017500000000004011140366257023777 0ustar ivanivande6d318a8a01f479f3ad557274fb55b7libloki-0.1.7.orig/doc/html/a00127_50406896d75a2591d4bd7dc53325e3d6_cgraph.dot0000755000175000017500000000602711140366260023374 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node1 [label="Loki::SmallObjAllocator::Deallocate",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1 -> Node2 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::FixedAllocator::Deallocate",height=0.2,width=0.4,color="black",URL="$a00056.html#49ab7ca3364fe05f2d7d91248ee5d0e3"]; Node2 -> Node3 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node3 [label="Loki::FixedAllocator::CountEmptyChunks",height=0.2,width=0.4,color="black",URL="$a00056.html#e74cbab50e78bfa115d7c0fcdce00641"]; Node3 -> Node4 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node4 [label="Loki::Chunk::HasAvailable",height=0.2,width=0.4,color="black",URL="$a00025.html#0874a711145788bd8c5265a9de2a4aac"]; Node2 -> Node5 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node5 [label="Loki::Chunk::HasBlock",height=0.2,width=0.4,color="black",URL="$a00025.html#b4ce346a74a437dabe4748bfb8e8b950",tooltip="Returns true if block at address P is inside this Chunk."]; Node2 -> Node6 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node6 [label="Loki::Chunk::IsBlockAvailable",height=0.2,width=0.4,color="black",URL="$a00025.html#8fe6ac2943df6c2f60123f928f119a73"]; Node2 -> Node7 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node7 [label="Loki::Chunk::IsCorrupt",height=0.2,width=0.4,color="black",URL="$a00025.html#245b6450d855d8ab65e9ca7add3e2071"]; Node1 -> Node8 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node8 [label="Loki::DefaultDeallocator",height=0.2,width=0.4,color="black",URL="$a00217.html#g1d24bf776342ace8f2004e3a173f6cb3"]; Node1 -> Node9 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node9 [label="Loki::SmallObjAllocator::GetAlignment",height=0.2,width=0.4,color="black",URL="$a00127.html#b1c8a2a3d7e9368ab59422ddd082105c",tooltip="Returns # of bytes between allocation boundaries."]; Node1 -> Node10 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node10 [label="Loki::SmallObjAllocator::GetMaxObjectSize",height=0.2,width=0.4,color="black",URL="$a00127.html#e49e9de3fd7b2fd93676cc1d63299b0d",tooltip="Returns max # of bytes which this can allocate."]; Node1 -> Node11 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node11 [label="Loki::GetOffset",height=0.2,width=0.4,color="black",URL="$a00217.html#g2f0821e243f812a3ae2abfaea51895e8"]; Node1 -> Node12 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node12 [label="Loki::FixedAllocator::HasBlock",height=0.2,width=0.4,color="black",URL="$a00056.html#f84b504579cea189ce1c415ee8ed5d2c"]; Node12 -> Node5 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; } libloki-0.1.7.orig/doc/html/a00127_50406896d75a2591d4bd7dc53325e3d6_cgraph.md50000755000175000017500000000004011140366260023260 0ustar ivanivan1752a11ea7ed8083b06a8b42ef63d55clibloki-0.1.7.orig/doc/html/a00023.html0000755000175000017500000000527511140366256016003 0ustar ivanivan Loki: Loki::CheckStaticForNothing Class Reference

Loki::CheckStaticForNothing Class Reference

#include <Checker.h>

List of all members.


Detailed Description

Exception Safety Level:
This exception-checking policy class for StaticChecker does nothing when called. Functions can use this to show they might provide the weak exception guarantee. The best guarantee such functions can provide is that nothing gets leaked.

The documentation for this class was generated from the following file:

Generated on Thu Jan 29 18:51:42 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00092.html0000755000175000017500000000475511140366261016007 0ustar ivanivan Loki: Loki::NullPointerException Struct Reference

Loki::NullPointerException Struct Reference
[Smart pointers]

#include <SmartPtr.h>

List of all members.


Detailed Description

Used by some implementations of the CheckingPolicy used by SmartPtr
The documentation for this struct was generated from the following file:
  • SmartPtr.h

Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00210.html0000755000175000017500000001420611140366254015771 0ustar ivanivan Loki: Register

Register


Classes

class  Loki::RegisterOnCreateSet< ElementList >
class  Loki::UnRegisterOnDeleteSet< ElementList >

Defines

#define LOKI_CHECK_CLASS_IN_LIST(CLASS, LIST)

Functions

template<class t >
bool Loki::RegisterFunction ()
template<class t >
bool Loki::UnRegisterFunction ()

Define Documentation

#define LOKI_CHECK_CLASS_IN_LIST ( CLASS,
LIST   ) 

Value:

\
    struct LOKI_CONCAT(check_,CLASS,_isInList_,LIST)                            \
    {                                                                           \
        typedef int LOKI_CONCAT(ERROR_class_,CLASS,_isNotInList_,LIST);         \
    };                                                                          \
    typedef Loki::Select<Loki::TL::IndexOf<LIST, CLASS>::value == -1,           \
                        CLASS,                                                  \
                        LOKI_CONCAT(check_,CLASS,_isInList_,LIST)>              \
                        ::Result LOKI_CONCAT(CLASS,isInList,LIST,result);       \
    typedef LOKI_CONCAT(CLASS,isInList,LIST,result)::                           \
                        LOKI_CONCAT(ERROR_class_,CLASS,_isNotInList_,LIST)      \
                        LOKI_CONCAT(ERROR_class_,CLASS,_isNotInList__,LIST);
Check if CLASS is in the typelist LIST.

Usage
see test/Register


Function Documentation

template<class t >
bool Loki::RegisterFunction (  )  [inline]

Must be specialized be the user

template<class t >
bool Loki::UnRegisterFunction (  )  [inline]

Must be specialized be the user


Generated on Thu Jan 29 18:51:40 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00426.dot0000755000175000017500000000143411140366261015621 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; Node1 [label="Loki::FunctionStorage\< T \>",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node2 -> Node1 [dir=back,color="darkorchid3",fontsize="10",style="dashed",label="functor_",fontname="FreeSans"]; Node2 [label="Loki::Functor\< void, Seq\< void * \> \>",height=0.2,width=0.4,color="black",URL="$a00064.html"]; Node3 -> Node2 [dir=back,color="orange",fontsize="10",style="dashed",label="\< void, Seq\< void * \> \>",fontname="FreeSans"]; Node3 [label="Loki::Functor\< R, TList, ThreadingModel \>",height=0.2,width=0.4,color="black",URL="$a00064.html"]; } libloki-0.1.7.orig/doc/html/a00426.md50000755000175000017500000000004011140366261015510 0ustar ivanivan27eb2d300fe9598a6712951cfdce92cblibloki-0.1.7.orig/doc/html/a00024.html0000755000175000017500000000517511140366256016003 0ustar ivanivan Loki: Loki::CheckStaticForNoThrow Class Reference

Loki::CheckStaticForNoThrow Class Reference

#include <Checker.h>

List of all members.


Detailed Description

Exception Safety Level:
This exception-checking policy class for StaticChecker asserts if an exception exists. Functions can use this to show they provide the no-throw exception safety guarantee.

The documentation for this class was generated from the following file:

Generated on Thu Jan 29 18:51:42 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00339.html0000755000175000017500000000665511140366257016021 0ustar ivanivan Loki: Member List

Loki::MutexLocker Member List

This is the complete list of members for Loki::MutexLocker, including all inherited members.

GetMutex(void) const Loki::MutexLocker [inline]
IsLocked(void) const Loki::MutexLocker [inline]
Lock(void)Loki::MutexLocker
MutexLocker(volatile LevelMutexInfo &mutex, bool lock=true)Loki::MutexLocker [explicit]
MutexLocker(volatile LevelMutexInfo &mutex, unsigned int milliSeconds, bool lock=true)Loki::MutexLocker
Unlock(void)Loki::MutexLocker
~MutexLocker(void)Loki::MutexLocker


Generated on Thu Jan 29 18:51:43 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00127_a41bb717d552cd0df57a941def7ec607_cgraph.dot0000755000175000017500000000702211140366260023740 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node1 [label="Loki::SmallObjAllocator::Allocate",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1 -> Node2 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::FixedAllocator::Allocate",height=0.2,width=0.4,color="black",URL="$a00056.html#c29973a11534fb1006fd28db97a17bed"]; Node2 -> Node3 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node3 [label="Loki::Chunk::Allocate",height=0.2,width=0.4,color="black",URL="$a00025.html#c3cbcf98897008278a7616c152565810"]; Node2 -> Node4 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node4 [label="Loki::FixedAllocator::CountEmptyChunks",height=0.2,width=0.4,color="black",URL="$a00056.html#e74cbab50e78bfa115d7c0fcdce00641"]; Node4 -> Node5 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node5 [label="Loki::Chunk::HasAvailable",height=0.2,width=0.4,color="black",URL="$a00025.html#0874a711145788bd8c5265a9de2a4aac"]; Node2 -> Node5 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 -> Node6 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node6 [label="Loki::Chunk::IsCorrupt",height=0.2,width=0.4,color="black",URL="$a00025.html#245b6450d855d8ab65e9ca7add3e2071"]; Node2 -> Node7 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node7 [label="Loki::Chunk::IsFilled",height=0.2,width=0.4,color="black",URL="$a00025.html#b70f5bce5a057032bdb5911916e9131d"]; Node1 -> Node8 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node8 [label="Loki::FixedAllocator::BlockSize",height=0.2,width=0.4,color="black",URL="$a00056.html#37df732230913b2dd9126a6b311586f0",tooltip="Returns block size with which the FixedAllocator was initialized."]; Node1 -> Node9 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node9 [label="Loki::DefaultAllocator",height=0.2,width=0.4,color="black",URL="$a00217.html#g2444c5bff0a61b6751fb5f57e0c7e8c7"]; Node1 -> Node10 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node10 [label="Loki::SmallObjAllocator::GetAlignment",height=0.2,width=0.4,color="black",URL="$a00127.html#b1c8a2a3d7e9368ab59422ddd082105c",tooltip="Returns # of bytes between allocation boundaries."]; Node1 -> Node11 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node11 [label="Loki::SmallObjAllocator::GetMaxObjectSize",height=0.2,width=0.4,color="black",URL="$a00127.html#e49e9de3fd7b2fd93676cc1d63299b0d",tooltip="Returns max # of bytes which this can allocate."]; Node1 -> Node12 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node12 [label="Loki::GetOffset",height=0.2,width=0.4,color="black",URL="$a00217.html#g2f0821e243f812a3ae2abfaea51895e8"]; Node1 -> Node13 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node13 [label="Loki::SmallObjAllocator::TrimExcessMemory",height=0.2,width=0.4,color="black",URL="$a00127.html#6b635664b20a6984303dabde86c8ac83"]; Node13 -> Node10 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node13 -> Node11 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node13 -> Node12 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; } libloki-0.1.7.orig/doc/html/a00127_a41bb717d552cd0df57a941def7ec607_cgraph.md50000755000175000017500000000004011140366260023630 0ustar ivanivana3bf3bfa1a80e2ed58a694912d3bd5aflibloki-0.1.7.orig/doc/html/a00093.html0000755000175000017500000000671711140366260016007 0ustar ivanivan Loki: Loki::ObjScopeGuardImpl0< Obj, MemFun > Class Template Reference

Loki::ObjScopeGuardImpl0< Obj, MemFun > Class Template Reference
[Exception-safe code]

#include <ScopeGuard.h>

Inheritance diagram for Loki::ObjScopeGuardImpl0< Obj, MemFun >:
Collaboration diagram for Loki::ObjScopeGuardImpl0< Obj, MemFun >:

List of all members.


Detailed Description

template<class Obj, typename MemFun>
class Loki::ObjScopeGuardImpl0< Obj, MemFun >

Implementation class for a class per-instance member function with no parameters. ScopeGuard ignores any value returned from the call within the Execute function.

This class has 3 standalone helper functions which create a ScopeGuard. One is MakeObjGuard, which is deprecated but provided for older code. The other two are MakeGuard overloads, one which takes a pointer to an object, and the other which takes a reference.


The documentation for this class was generated from the following file:
  • ScopeGuard.h

Generated on Thu Jan 29 18:51:44 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00467.html0000755000175000017500000000375111140366262016011 0ustar ivanivan Loki: Member List

Loki::LongevityLifetime::DieAsSmallObjectChild< T > Member List

This is the complete list of members for Loki::LongevityLifetime::DieAsSmallObjectChild< T >, including all inherited members.


Generated on Thu Jan 29 18:51:46 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00211.html0000755000175000017500000001167411140366254016000 0ustar ivanivan Loki: Exception-safe code
Generated on Thu Jan 29 18:51:40 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00436.dot0000755000175000017500000000102211140366261015613 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; Node1 [label="Loki::TwoRefCounts",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node2 -> Node1 [dir=back,color="darkorchid3",fontsize="10",style="dashed",label="m_counts",fontname="FreeSans"]; Node2 [label="Loki::Private::TwoRefCountInfo",height=0.2,width=0.4,color="black",URL="$a00138.html"]; } libloki-0.1.7.orig/doc/html/a00436.md50000755000175000017500000000004011140366261015511 0ustar ivanivanac71085baf4a431a406951411d35f339libloki-0.1.7.orig/doc/html/a00438.dot0000755000175000017500000000065711140366261015632 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; Node1 [label="Loki::TwoRefLinks",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1 -> Node1 [dir=back,color="darkorchid3",fontsize="10",style="dashed",label="m_prev\nm_next",fontname="FreeSans"]; } libloki-0.1.7.orig/doc/html/a00025.html0000755000175000017500000001050511140366261015771 0ustar ivanivan Loki: Loki::Chunk Struct Reference

Loki::Chunk Struct Reference
[Internals]

List of all members.


Detailed Description

Contains info about each allocated Chunk - which is a collection of contiguous blocks. Each block is the same size, as specified by the FixedAllocator. The number of blocks in a Chunk depends upon page size. This is a POD-style struct with value-semantics. All functions and data are private so that they can not be changed by anything other than the FixedAllocator which owns the Chunk.

Minimal Interface
For the sake of runtime efficiency, no constructor, destructor, or copy-assignment operator is defined. The inline functions made by the compiler should be sufficient, and perhaps faster than hand-crafted functions. The lack of these functions allows vector to create and copy Chunks as needed without overhead. The Init and Release functions do what the default constructor and destructor would do. A Chunk is not in a usable state after it is constructed and before calling Init. Nor is a Chunk usable after Release is called, but before the destructor.
Efficiency
Down near the lowest level of the allocator, runtime efficiencies trump almost all other considerations. Each function does the minimum required of it. All functions should execute in constant time to prevent higher- level code from unwittingly using a version of Shlemiel the Painter's Algorithm.
Stealth Indexes
The first char of each empty block contains the index of the next empty block. These stealth indexes form a singly-linked list within the blocks. A Chunk is corrupt if this singly-linked list has a loop or is shorter than blocksAvailable_. Much of the allocator's time and space efficiency comes from how these stealth indexes are implemented.

The documentation for this struct was generated from the following file:
  • SmallObj.cpp

Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00438.md50000755000175000017500000000004011140366261015513 0ustar ivanivan6d12144e9d1af57d71db1a923534b839libloki-0.1.7.orig/doc/html/a00094.html0000755000175000017500000000711011140366260015774 0ustar ivanivan Loki: Loki::ObjScopeGuardImpl1< Obj, MemFun, P1 > Class Template Reference

Loki::ObjScopeGuardImpl1< Obj, MemFun, P1 > Class Template Reference
[Exception-safe code]

#include <ScopeGuard.h>

Inheritance diagram for Loki::ObjScopeGuardImpl1< Obj, MemFun, P1 >:
Collaboration diagram for Loki::ObjScopeGuardImpl1< Obj, MemFun, P1 >:

List of all members.


Detailed Description

template<class Obj, typename MemFun, typename P1>
class Loki::ObjScopeGuardImpl1< Obj, MemFun, P1 >

Implementation class for a class per-instance member function with one parameter. The parameter is copied by value - use Loki::ByRef if you must use a reference instead. ScopeGuard ignores any value returned from the call within the Execute function.

This class has 3 standalone helper functions which create a ScopeGuard. One is MakeObjGuard, which is deprecated but provided for older code. The other two are MakeGuard overloads, one which takes a pointer to an object, and the other which takes a reference.


The documentation for this class was generated from the following file:
  • ScopeGuard.h

Generated on Thu Jan 29 18:51:44 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/namespaces.html0000755000175000017500000000416611140366255017312 0ustar ivanivan Loki: Namespace Index

Namespace List

Here is a list of all documented namespaces with brief descriptions:
Loki
LongevityLifetimeIn this namespace are special lifetime policies to manage lifetime dependencies
std

Generated on Thu Jan 29 18:51:41 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00468.html0000755000175000017500000000366311140366262016014 0ustar ivanivan Loki: Member List

Loki::Private::TwoRefCountInfo Member List

This is the complete list of members for Loki::Private::TwoRefCountInfo, including all inherited members.


Generated on Thu Jan 29 18:51:46 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00212.html0000755000175000017500000000472111140366254015774 0ustar ivanivan Loki: Singleton
Generated on Thu Jan 29 18:51:40 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00445.dot0000755000175000017500000000131211140366261015615 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; Node1 [label="Loki::CyclicVisitor\< R, TList \>",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node2 -> Node1 [dir=back,color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Visitor\< TList, R \>",height=0.2,width=0.4,color="black",URL="$a00142.html"]; Node3 -> Node2 [dir=back,color="orange",fontsize="10",style="dashed",label="\",fontname="FreeSans"]; Node3 [label="Visitor",height=0.2,width=0.4,color="black",URL="$a00142.html"]; } libloki-0.1.7.orig/doc/html/a00445.md50000755000175000017500000000004011140366261015511 0ustar ivanivan42c8074b2e81c8d7ebb8518704bd51cflibloki-0.1.7.orig/doc/html/a00446.dot0000755000175000017500000000131211140366261015616 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; Node1 [label="Loki::CyclicVisitor\< R, TList \>",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node2 -> Node1 [dir=back,color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Visitor\< TList, R \>",height=0.2,width=0.4,color="black",URL="$a00142.html"]; Node3 -> Node2 [dir=back,color="orange",fontsize="10",style="dashed",label="\",fontname="FreeSans"]; Node3 [label="Visitor",height=0.2,width=0.4,color="black",URL="$a00142.html"]; } libloki-0.1.7.orig/doc/html/a00446.md50000755000175000017500000000004011140366261015512 0ustar ivanivan42c8074b2e81c8d7ebb8518704bd51cflibloki-0.1.7.orig/doc/html/a00026.html0000755000175000017500000000560611140366256016004 0ustar ivanivan Loki: Loki::CloneFactory< AbstractProduct, ProductCreator, FactoryErrorPolicy > Class Template Reference

Loki::CloneFactory< AbstractProduct, ProductCreator, FactoryErrorPolicy > Class Template Reference
[Clone Factory]

Creates a copy from a polymorphic object. More...

#include <Factory.h>

List of all members.


Detailed Description

template<class AbstractProduct, class ProductCreator = AbstractProduct* (*)(const AbstractProduct*), template< typename, class > class FactoryErrorPolicy = DefaultFactoryError>
class Loki::CloneFactory< AbstractProduct, ProductCreator, FactoryErrorPolicy >

Creates a copy from a polymorphic object.
The documentation for this class was generated from the following file:
  • Factory.h

Generated on Thu Jan 29 18:51:42 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00449.dot0000755000175000017500000000104011140366261015617 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; Node1 [label="Loki::FixedAllocator",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node2 -> Node1 [dir=back,color="darkorchid3",fontsize="10",style="dashed",label="allocChunk_\nemptyChunk_\ndeallocChunk_",fontname="FreeSans"]; Node2 [label="Loki::Chunk",height=0.2,width=0.4,color="black",URL="$a00025.html"]; } libloki-0.1.7.orig/doc/html/a00449.md50000755000175000017500000000004011140366261015515 0ustar ivanivan87a46f8db3bcc5b2cb2b1e85895415ddlibloki-0.1.7.orig/doc/html/a00340.html0000755000175000017500000000677511140366257016014 0ustar ivanivan Loki: Member List

Loki::MultiMutexLocker Member List

This is the complete list of members for Loki::MultiMutexLocker, including all inherited members.

GetMutexes(void) const Loki::MultiMutexLocker [inline]
IsLocked(void) const Loki::MultiMutexLocker [inline]
Lock(void)Loki::MultiMutexLocker
MultiMutexLocker(LevelMutexInfo::MutexContainer &mutexes, bool lock=true)Loki::MultiMutexLocker [explicit]
MultiMutexLocker(LevelMutexInfo::MutexContainer &mutexes, unsigned int milliSeconds, bool lock=true)Loki::MultiMutexLocker
Unlock(void)Loki::MultiMutexLocker
~MultiMutexLocker(void)Loki::MultiMutexLocker


Generated on Thu Jan 29 18:51:43 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00095.html0000755000175000017500000000715311140366260016004 0ustar ivanivan Loki: Loki::ObjScopeGuardImpl2< Obj, MemFun, P1, P2 > Class Template Reference

Loki::ObjScopeGuardImpl2< Obj, MemFun, P1, P2 > Class Template Reference
[Exception-safe code]

#include <ScopeGuard.h>

Inheritance diagram for Loki::ObjScopeGuardImpl2< Obj, MemFun, P1, P2 >:
Collaboration diagram for Loki::ObjScopeGuardImpl2< Obj, MemFun, P1, P2 >:

List of all members.


Detailed Description

template<class Obj, typename MemFun, typename P1, typename P2>
class Loki::ObjScopeGuardImpl2< Obj, MemFun, P1, P2 >

Implementation class for a class per-instance member function with two parameters. Each parameter is copied by value - use Loki::ByRef if you must use a reference instead. ScopeGuard ignores any value returned from the call within the Execute function.

This class has 3 standalone helper functions which create a ScopeGuard. One is MakeObjGuard, which is deprecated but provided for older code. The other two are MakeGuard overloads, one which takes a pointer to an object, and the other which takes a reference.


The documentation for this class was generated from the following file:
  • ScopeGuard.h

Generated on Thu Jan 29 18:51:44 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00451.dot0000755000175000017500000000467711140366262015634 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node1 [label="Loki::LongevityLifetime::SingletonFixedLongevity\< Longevity, T \>",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1 -> Node2 [dir=back,color="orange",fontsize="10",style="dashed",label="\<0,T\>",fontname="FreeSans"]; Node2 [label="Loki::LongevityLifetime::SingletonFixedLongevity\< 0, T \>",height=0.2,width=0.4,color="black",URL="$a00123.html"]; Node2 -> Node3 [dir=back,color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node3 [label="Loki::LongevityLifetime::DieFirst\< T \>",height=0.2,width=0.4,color="black",URL="$a00048.html",tooltip="Shortest possible SingletonWithLongevity lifetime: 0."]; Node1 -> Node4 [dir=back,color="orange",fontsize="10",style="dashed",label="\<0xFFFFFFFF ,T\>",fontname="FreeSans"]; Node4 [label="Loki::LongevityLifetime::SingletonFixedLongevity\< 0xFFFFFFFF,T \>",height=0.2,width=0.4,color="black",URL="$a00123.html"]; Node4 -> Node5 [dir=back,color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node5 [label="Loki::LongevityLifetime::DieLast\< T \>",height=0.2,width=0.4,color="black",URL="$a00049.html"]; Node5 -> Node6 [dir=back,color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node6 [label="Loki::LongevityLifetime::DieAsSmallObjectParent\< T \>",height=0.2,width=0.4,color="black",URL="$a00046.html"]; Node4 -> Node5 [dir=back,color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node1 -> Node7 [dir=back,color="orange",fontsize="10",style="dashed",label="\<0xFFFFFFFF-1 ,T\>",fontname="FreeSans"]; Node7 [label="Loki::LongevityLifetime::SingletonFixedLongevity\< 0xFFFFFFFF-1,T \>",height=0.2,width=0.4,color="black",URL="$a00123.html"]; Node7 -> Node8 [dir=back,color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node8 [label="Loki::LongevityLifetime::DieDirectlyBeforeLast\< T \>",height=0.2,width=0.4,color="black",URL="$a00047.html"]; Node8 -> Node9 [dir=back,color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node9 [label="Loki::LongevityLifetime::DieAsSmallObjectChild\< T \>",height=0.2,width=0.4,color="black",URL="$a00045.html"]; Node7 -> Node8 [dir=back,color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; } libloki-0.1.7.orig/doc/html/a00451.md50000755000175000017500000000004011140366262015507 0ustar ivanivan3506e50b2b41bbb99ff00c84287bd3c0libloki-0.1.7.orig/doc/html/tree.html0000755000175000017500000031727611140366263016142 0ustar ivanivan TreeView

Loki

o+Modules

o+Class List

|o*AbstractFactory

|o*Loki::AllocatorSingleton< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >

|o*Loki::AllowConversion

|o*Loki::AllowReset< P >

|o*Loki::AlwaysCreate

|o*Loki::AmountLimitedCreation

|o*Loki::ArrayStorage< T >

|o*Loki::AssertAnyMutexError

|o*Loki::AssertBadDesignMutexError

|o*Loki::AssertCheck< P >

|o*Loki::AssertCheckStrict< P >

|o*Loki::BaseVisitor

|o*Loki::BinderFirst< OriginalFunctor >

|o*Loki::CachedFactory< AbstractProduct, IdentifierType, CreatorParmTList, EncapsulationPolicy, CreationPolicy, EvictionPolicy, StatisticPolicy, FactoryErrorPolicy, ObjVector >

|o*Loki::CantResetWithStrong< P >

|o*Loki::Chainer< Fun1, Fun2 >

|o*Loki::CheckForEquality< Host >

|o*Loki::CheckForNoChange< Host >

|o*Loki::CheckForNoChangeOrThrow< Host >

|o*Loki::CheckForNothing< Host >

|o*Loki::CheckForNoThrow< Host >

|o*Loki::CheckReturn< Value, OnError >

|o*Loki::CheckStaticForNothing

|o*Loki::CheckStaticForNoThrow

|o*Loki::Chunk

|o*Loki::CloneFactory< AbstractProduct, ProductCreator, FactoryErrorPolicy >

|o*Loki::COMRefCounted< P >

|o*Loki::ConstPropPtr< T >

|o*Loki::ContractChecker< Host, ExceptionPolicy >

|o*Loki::CreateStatic< T >

|o*Loki::CreateUsing< Alloc >

|o*Loki::CreateUsingMalloc< T >

|o*Loki::CreateUsingNew< T >

|o*Loki::CyclicVisitor< R, TList >

|o*Loki::DeepCopy< P >

|o*Loki::DefaultFactoryError< IdentifierType, AbstractProduct >

|o*Loki::DefaultLifetime< T >

|o*Loki::DefaultSPStorage< T >

|o*Loki::DeletableSingleton< T >

|o*Loki::DeleteArray< P >

|o*Loki::DeleteNothing< P >

|o*Loki::DeleteSingle< P >

|o*Loki::DeleteUsingFree< P >

|o*Loki::DestructiveCopy< P >

|o*Loki::LongevityLifetime::DieAsSmallObjectChild< T >

|o*Loki::LongevityLifetime::DieAsSmallObjectParent< T >

|o*Loki::LongevityLifetime::DieDirectlyBeforeLast< T >

|o*Loki::LongevityLifetime::DieFirst< T >

|o*Loki::LongevityLifetime::DieLast< T >

|o*Loki::DisallowConversion

|o*Loki::DontPropagateConst< T >

|o*Loki::EvictAging< DT, ST >

|o*Loki::EvictLRU< DT, ST >

|o*Loki::EvictRandom< DT, ST >

|o*Loki::Factory< AbstractProduct, IdentifierType, CreatorParmTList, FactoryErrorPolicy >

|o*Loki::FixedAllocator

|o*Loki::FollowIntoDeath

|o*Loki::FollowIntoDeath::FollowIntoDeath::AfterMaster< Master >

|o*Loki::FollowIntoDeath::FollowIntoDeath::AfterMaster< Master >::FollowIntoDeath::AfterMaster::IsDestroyed< F >

|o*Loki::FollowIntoDeath::FollowIntoDeath::With< Lifetime >

|o*Loki::FollowIntoDeath::FollowIntoDeath::With< Lifetime >::FollowIntoDeath::With::AsMasterLifetime< Master >

|o*Function

|o*Loki::FunctionStorage< T >

|o*Loki::Functor< R, TList, ThreadingModel >

|o*Loki::HeapStorage< T >

|o*ImplOf

|o*Loki::JustReturnMutexError

|o*Loki::Key< Factory, IdentifierType >

|o*std::less< Loki::StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > >

|o*Loki::LevelMutex< MutexPolicy, DefaultLevel, ErrorPolicy, WaitPolicy >

|o*Loki::LevelMutexInfo

|o*Loki::LevelMutexInfo::LevelMutexInfo::Checker

|o*Loki::LevelMutexInfo::LevelMutexInfo::MutexUndoer

|o*LockableTwoRefCountInfo

|o*LockableTwoRefCounts

|o*Loki::LockedStorage< T >

|o*Loki::LockingPtr< SharedObject, LockingPolicy, ConstPolicy >

|o*Loki::LokiAllocator< Type, AllocT >

|o*Loki::LokiAllocator< Type, AllocT >::LokiAllocator::rebind< Type1 >

|o*Loki::MultiMutexLocker

|o*Loki::Mutex

|o*Loki::MutexException

|o*Loki::MutexLocker

|o*Loki::MutexSleepWaits

|o*Loki::NeverCreate

|o*Loki::NeverReset< P >

|o*Loki::NoCheck< P >

|o*Loki::NoCopy< P >

|o*Loki::NoDestroy< T >

|o*Loki::NoMutexWait

|o*Loki::NoStatisticPolicy

|o*Loki::NullPointerException

|o*Loki::ObjScopeGuardImpl0< Obj, MemFun >

|o*Loki::ObjScopeGuardImpl1< Obj, MemFun, P1 >

|o*Loki::ObjScopeGuardImpl2< Obj, MemFun, P1, P2 >

|o*Loki::ObjScopeGuardImpl3< Obj, MemFun, P1, P2, P3 >

|o*Loki::PhoenixSingleton< T >

|o*Loki::Pimpl< T, Pointer >

|o*PImplOf

|o*Loki::PropagateConst< T >

|o*Loki::RateLimitedCreation

|o*Loki::RefCounted< P >

|o*RefCountedMT

|o*Loki::RefLinked< P >

|o*Loki::RefToValue< T >

|o*Loki::RegisterOnCreateSet< ElementList >

|o*Loki::RejectNull< P >

|o*Loki::RejectNullStatic< P >

|o*Loki::RejectNullStrict< P >

|o*Loki::SafeBitConst< unique_index, word_t >

|o*Loki::ScopeGuardImpl0< F >

|o*Loki::ScopeGuardImpl1< F, P1 >

|o*Loki::ScopeGuardImpl2< F, P1, P2 >

|o*Loki::ScopeGuardImpl3< F, P1, P2, P3 >

|o*Loki::ScopeGuardImpl4< F, P1, P2, P3, P4 >

|o*Loki::ScopeGuardImpl5< F, P1, P2, P3, P4, P5 >

|o*Loki::ScopeGuardImplBase

|o*Loki::SimplePointer< AbstractProduct >

|o*Loki::SimpleStatisticPolicy

|o*Loki::SingleThreaded< Host, MutexPolicy >

|o*Loki::SingleThreaded< Host, MutexPolicy >::SingleThreaded::Lock

|o*Loki::Singleton< T >

|o*Loki::LongevityLifetime::SingletonFixedLongevity< Longevity, T >

|o*Loki::SingletonHolder< T, CreationPolicy, LifetimePolicy, ThreadingModel, MutexPolicy >

|o*Loki::SingletonWithLongevity< T >

|o*Loki::SleepLevelMutex

|o*Loki::SmallObjAllocator

|o*Loki::SmallObject< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >

|o*Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >

|o*Loki::SmallValueObject< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >

|o*Loki::SmartPointer< AbstractProduct, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ConstnessPolicy >

|o*Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy >

|o*Loki::SpinLevelMutex

|o*Loki::StaticChecker< ExceptionPolicy >

|o*Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy >

|o*Loki::ThrowOnAnyMutexError

|o*Loki::ThrowOnBadDesignMutexError

|o*Loki::Private::TwoRefCountInfo

|o*Loki::TwoRefCounts

|o*Loki::TwoRefLinks

|o*Loki::UnRegisterOnDeleteSet< ElementList >

|\*Visitor

o+Class Hierarchy

|o*AbstractFactory

|o*Loki::AllowConversion

|o*Loki::AllowReset< P >

|o*Loki::AlwaysCreate

|o*Loki::AmountLimitedCreation

|o*Loki::ArrayStorage< T >

|o*Loki::AssertAnyMutexError

|o*Loki::AssertBadDesignMutexError

|o*Loki::AssertCheck< P >

|o*Loki::AssertCheckStrict< P >

|o*Loki::BaseVisitor

|o*Loki::BinderFirst< OriginalFunctor >

|o*Loki::CachedFactory< AbstractProduct, IdentifierType, CreatorParmTList, EncapsulationPolicy, CreationPolicy, EvictionPolicy, StatisticPolicy, FactoryErrorPolicy, ObjVector >

|o*Loki::CantResetWithStrong< P >

|o*Loki::Chainer< Fun1, Fun2 >

|o*Loki::CheckForEquality< Host >

|o*Loki::CheckForNoChange< Host >

|o*Loki::CheckForNoChangeOrThrow< Host >

|o*Loki::CheckForNothing< Host >

|o*Loki::CheckForNoThrow< Host >

|o*Loki::CheckReturn< Value, OnError >

|o*Loki::CheckStaticForNothing

|o*Loki::CheckStaticForNoThrow

|o*Loki::Chunk

|o*Loki::CloneFactory< AbstractProduct, ProductCreator, FactoryErrorPolicy >

|o*Loki::COMRefCounted< P >

|o*Loki::ConstPropPtr< T >

|o*Loki::ContractChecker< Host, ExceptionPolicy >

|o*Loki::CreateStatic< T >

|o*Loki::CreateUsing< Alloc >

|o*Loki::CreateUsingMalloc< T >

|o*Loki::CreateUsingNew< T >

|o*Loki::DeepCopy< P >

|o*Loki::DefaultFactoryError< IdentifierType, AbstractProduct >

|o*Loki::DefaultLifetime< T >

|o*Loki::DefaultSPStorage< T >

|o*Loki::DeletableSingleton< T >

|o*Loki::DeleteArray< P >

|o*Loki::DeleteNothing< P >

|o*Loki::DeleteSingle< P >

|o*Loki::DeleteUsingFree< P >

|o*Loki::DestructiveCopy< P >

|o*Loki::DisallowConversion

|o*Loki::DontPropagateConst< T >

|o*Loki::EvictAging< DT, ST >

|o*Loki::EvictLRU< DT, ST >

|o*Loki::EvictRandom< DT, ST >

|o*Loki::Factory< AbstractProduct, IdentifierType, CreatorParmTList, FactoryErrorPolicy >

|o*Loki::FixedAllocator

|o*Loki::FollowIntoDeath

|o*Loki::FollowIntoDeath::FollowIntoDeath::AfterMaster< Master >

|o*Loki::FollowIntoDeath::FollowIntoDeath::AfterMaster< Master >::FollowIntoDeath::AfterMaster::IsDestroyed< F >

|o*Loki::FollowIntoDeath::FollowIntoDeath::With< Lifetime >

|o*Loki::FollowIntoDeath::FollowIntoDeath::With< Lifetime >::FollowIntoDeath::With::AsMasterLifetime< Master >

|o*Function

|o*Loki::FunctionStorage< T >

|o*Loki::Functor< R, TList, ThreadingModel >

|o*Loki::Functor< R >

|o*Loki::Functor< R, Seq< P01 > >

|o*Loki::Functor< R, Seq< P01, P02 > >

|o*Loki::Functor< R, Seq< P01, P02, P03 > >

|o*Loki::Functor< R, Seq< P01, P02, P03, P04 > >

|o*Loki::Functor< R, Seq< P01, P02, P03, P04, P05 > >

|o*Loki::Functor< R, Seq< P01, P02, P03, P04, P05, P06 > >

|o*Loki::Functor< R, Seq< P01, P02, P03, P04, P05, P06, P07 > >

|o*Loki::Functor< R, Seq< P01, P02, P03, P04, P05, P06, P07, P08 > >

|o*Loki::Functor< R, Seq< P01, P02, P03, P04, P05, P06, P07, P08, P09 > >

|o*Loki::Functor< R, Seq< P01, P02, P03, P04, P05, P06, P07, P08, P09, P10 > >

|o*Loki::Functor< R, Seq< P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11 > >

|o*Loki::Functor< R, Seq< P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12 > >

|o*Loki::Functor< R, Seq< P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13 > >

|o*Loki::Functor< R, Seq< P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14 > >

|o*Loki::Functor< R, Seq< P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15 > >

|o*Loki::Functor<>

|o*Loki::HeapStorage< T >

|o*ImplOf

|o*Loki::JustReturnMutexError

|o*Loki::Key< Factory, IdentifierType >

|o*std::less< Loki::StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > >

|o+Loki::LevelMutexInfo

|o*Loki::LevelMutexInfo::LevelMutexInfo::Checker

|o*Loki::LevelMutexInfo::LevelMutexInfo::MutexUndoer

|o*LockableTwoRefCountInfo

|o*LockableTwoRefCounts

|o*Loki::LockedStorage< T >

|o*Loki::LockingPtr< SharedObject, LockingPolicy, ConstPolicy >

|o*Loki::LokiAllocator< Type, AllocT >

|o*Loki::LokiAllocator< Type, AllocT >::LokiAllocator::rebind< Type1 >

|o*Loki::MultiMutexLocker

|o*Loki::Mutex

|o*Loki::MutexException

|o*Loki::MutexLocker

|o*Loki::MutexSleepWaits

|o*Loki::NeverCreate

|o*Loki::NeverReset< P >

|o*Loki::NoCheck< P >

|o*Loki::NoCopy< P >

|o*Loki::NoDestroy< T >

|o*Loki::NoMutexWait

|o*Loki::NoStatisticPolicy

|o*Loki::NullPointerException

|o*Loki::PhoenixSingleton< T >

|o*Loki::Pimpl< T, Pointer >

|o*PImplOf

|o*Loki::PropagateConst< T >

|o*Loki::RateLimitedCreation

|o*Loki::RefCounted< P >

|o*RefCountedMT

|o*Loki::RefLinked< P >

|o*Loki::RefToValue< T >

|o*Loki::RegisterOnCreateSet< ElementList >

|o*Loki::RejectNull< P >

|o*Loki::RejectNullStatic< P >

|o*Loki::RejectNullStrict< P >

|o*Loki::SafeBitConst< unique_index, word_t >

|o+Loki::ScopeGuardImplBase

|o*Loki::SimplePointer< AbstractProduct >

|o*Loki::SimpleStatisticPolicy

|o*Loki::SingleThreaded< Host, MutexPolicy >

|o*Loki::SingleThreaded< Host, MutexPolicy >::SingleThreaded::Lock

|o*Loki::Singleton< T >

|o*Loki::LongevityLifetime::SingletonFixedLongevity< Longevity, T >

|o+Loki::LongevityLifetime::SingletonFixedLongevity< 0, T >

|o+Loki::LongevityLifetime::SingletonFixedLongevity< 0xFFFFFFFF,T >

|o+Loki::LongevityLifetime::SingletonFixedLongevity< 0xFFFFFFFF-1,T >

|o*Loki::SingletonHolder< T, CreationPolicy, LifetimePolicy, ThreadingModel, MutexPolicy >

|o*Loki::SingletonWithLongevity< T >

|o+Loki::SmallObjAllocator

|o+Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >

|o+Loki::SmallObjectBase< ThreadingModel, 4096, 256, 4,::Loki::LongevityLifetime::DieAsSmallObjectParent,::Loki::Mutex >

|o*Loki::SmartPointer< AbstractProduct, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ConstnessPolicy >

|o*Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy >

|o+Loki::SpinLevelMutex

|o*Loki::StaticChecker< ExceptionPolicy >

|o*Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy >

|o*Loki::ThrowOnAnyMutexError

|o*Loki::ThrowOnBadDesignMutexError

|o*Loki::Private::TwoRefCountInfo

|o*Loki::TwoRefCounts

|o*Loki::TwoRefLinks

|o*Loki::UnRegisterOnDeleteSet< ElementList >

|o*Visitor

|o*Visitor< Head, R >

|o*Visitor< Head, R, false >

|o*Visitor< Head, R, true >

|o*Visitor< Tail, R, false >

|o*Visitor< Tail, R, true >

|\+Visitor< TList, R >

o*Class Members

o*Graphical Class Hierarchy

o+Namespace List

o*Namespace Members

o+File List

\*File Members

libloki-0.1.7.orig/doc/html/a00453.dot0000755000175000017500000000202311140366262015615 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; Node1 [label="Loki::LongevityLifetime::DieLast\< T \>",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node2 -> Node1 [dir=back,color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::LongevityLifetime::SingletonFixedLongevity\< 0xFFFFFFFF,T \>",height=0.2,width=0.4,color="black",URL="$a00123.html"]; Node3 -> Node2 [dir=back,color="orange",fontsize="10",style="dashed",label="\<0xFFFFFFFF ,T\>",fontname="FreeSans"]; Node3 [label="Loki::LongevityLifetime::SingletonFixedLongevity\< Longevity, T \>",height=0.2,width=0.4,color="black",URL="$a00123.html"]; Node1 -> Node1 [dir=back,color="orange",fontsize="10",style="dashed",label="\",fontname="FreeSans"]; Node1 -> Node1 [dir=back,color="orange",fontsize="10",style="dashed",label="\",fontname="FreeSans"]; } libloki-0.1.7.orig/doc/html/a00453.md50000755000175000017500000000004011140366262015511 0ustar ivanivanb0a6af43867e23100a4dbc431da82a70libloki-0.1.7.orig/doc/html/a00454.dot0000755000175000017500000000147511140366262015630 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; Node1 [label="Loki::LongevityLifetime::DieLast\< T \>",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node2 -> Node1 [dir=back,color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::LongevityLifetime::SingletonFixedLongevity\< 0xFFFFFFFF,T \>",height=0.2,width=0.4,color="black",URL="$a00123.html"]; Node3 -> Node2 [dir=back,color="orange",fontsize="10",style="dashed",label="\<0xFFFFFFFF ,T\>",fontname="FreeSans"]; Node3 [label="Loki::LongevityLifetime::SingletonFixedLongevity\< Longevity, T \>",height=0.2,width=0.4,color="black",URL="$a00123.html"]; } libloki-0.1.7.orig/doc/html/a00454.md50000755000175000017500000000004011140366262015512 0ustar ivanivan2cdbc716623f9fb537b553a60afd2fe6libloki-0.1.7.orig/doc/html/a00469.html0000755000175000017500000000401111140366262016001 0ustar ivanivan Loki: Member List

std::less< Loki::StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > > Member List

This is the complete list of members for std::less< Loki::StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > >, including all inherited members.


Generated on Thu Jan 29 18:51:46 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00213.html0000755000175000017500000000476111140366254016001 0ustar ivanivan Loki: Creation policies

Creation policies
[Singleton]

Collaboration diagram for Creation policies:

Classes

struct  Loki::CreateUsingNew< T >
struct  Loki::CreateUsing< Alloc >
struct  Loki::CreateUsingMalloc< T >
struct  Loki::CreateStatic< T >

Generated on Thu Jan 29 18:51:40 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00456.dot0000755000175000017500000000204511140366262015624 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; Node1 [label="Loki::LongevityLifetime::DieDirectlyBeforeLast\< T \>",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node2 -> Node1 [dir=back,color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::LongevityLifetime::SingletonFixedLongevity\< 0xFFFFFFFF-1,T \>",height=0.2,width=0.4,color="black",URL="$a00123.html"]; Node3 -> Node2 [dir=back,color="orange",fontsize="10",style="dashed",label="\<0xFFFFFFFF-1 ,T\>",fontname="FreeSans"]; Node3 [label="Loki::LongevityLifetime::SingletonFixedLongevity\< Longevity, T \>",height=0.2,width=0.4,color="black",URL="$a00123.html"]; Node1 -> Node1 [dir=back,color="orange",fontsize="10",style="dashed",label="\",fontname="FreeSans"]; Node1 -> Node1 [dir=back,color="orange",fontsize="10",style="dashed",label="\",fontname="FreeSans"]; } libloki-0.1.7.orig/doc/html/a00456.md50000755000175000017500000000004011140366262015514 0ustar ivanivanf7368eae656bc7d3f0d7952da96605c8libloki-0.1.7.orig/doc/html/a00457.dot0000755000175000017500000000151711140366262015630 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; Node1 [label="Loki::LongevityLifetime::DieDirectlyBeforeLast\< T \>",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node2 -> Node1 [dir=back,color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::LongevityLifetime::SingletonFixedLongevity\< 0xFFFFFFFF-1,T \>",height=0.2,width=0.4,color="black",URL="$a00123.html"]; Node3 -> Node2 [dir=back,color="orange",fontsize="10",style="dashed",label="\<0xFFFFFFFF-1 ,T\>",fontname="FreeSans"]; Node3 [label="Loki::LongevityLifetime::SingletonFixedLongevity\< Longevity, T \>",height=0.2,width=0.4,color="black",URL="$a00123.html"]; } libloki-0.1.7.orig/doc/html/a00457.md50000755000175000017500000000004011140366262015515 0ustar ivanivan08d7199fd6450bb1620f802165c449e6libloki-0.1.7.orig/doc/html/a00027.html0000755000175000017500000000520411140366261015773 0ustar ivanivan Loki: Loki::COMRefCounted< P > Class Template Reference

Loki::COMRefCounted< P > Class Template Reference
[Ownership policies]

#include <SmartPtr.h>

List of all members.


Detailed Description

template<class P>
class Loki::COMRefCounted< P >

Implementation of the OwnershipPolicy used by SmartPtr Adapts COM intrusive reference counting to OwnershipPolicy-specific syntax
The documentation for this class was generated from the following file:
  • SmartPtr.h

Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00459.dot0000755000175000017500000000145411140366262015632 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; Node1 [label="Loki::LongevityLifetime::DieFirst\< T \>",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node2 -> Node1 [dir=back,color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::LongevityLifetime::SingletonFixedLongevity\< 0, T \>",height=0.2,width=0.4,color="black",URL="$a00123.html"]; Node3 -> Node2 [dir=back,color="orange",fontsize="10",style="dashed",label="\<0,T\>",fontname="FreeSans"]; Node3 [label="Loki::LongevityLifetime::SingletonFixedLongevity\< Longevity, T \>",height=0.2,width=0.4,color="black",URL="$a00123.html"]; } libloki-0.1.7.orig/doc/html/a00459.md50000755000175000017500000000004011140366262015517 0ustar ivanivan8027387e201546208570c8c24eb139a9libloki-0.1.7.orig/doc/html/files.html0000755000175000017500000000423111140366263016265 0ustar ivanivan Loki: File Index

File List

Here is a list of all documented files with brief descriptions:
Checker.hThis file provides Loki's Checker facility
LevelMutex.cppContains functions needed by LevelMutex class
LevelMutex.hDefines classes and functions for LevelMutex facility

Generated on Thu Jan 29 18:51:47 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00341.html0000755000175000017500000000654611140366257016011 0ustar ivanivan Loki: Member List

Loki::LockingPtr< SharedObject, LockingPolicy, ConstPolicy > Member List

This is the complete list of members for Loki::LockingPtr< SharedObject, LockingPolicy, ConstPolicy >, including all inherited members.

LockingPtr(volatile ConstOrNotType &object, LockingPolicy &mutex)Loki::LockingPtr< SharedObject, LockingPolicy, ConstPolicy > [inline]
LockingPtr(Pair lockpair)Loki::LockingPtr< SharedObject, LockingPolicy, ConstPolicy > [inline]
operator*()Loki::LockingPtr< SharedObject, LockingPolicy, ConstPolicy > [inline]
operator->()Loki::LockingPtr< SharedObject, LockingPolicy, ConstPolicy > [inline]
~LockingPtr()Loki::LockingPtr< SharedObject, LockingPolicy, ConstPolicy > [inline]


Generated on Thu Jan 29 18:51:43 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00096.html0000755000175000017500000000721611140366260016005 0ustar ivanivan Loki: Loki::ObjScopeGuardImpl3< Obj, MemFun, P1, P2, P3 > Class Template Reference

Loki::ObjScopeGuardImpl3< Obj, MemFun, P1, P2, P3 > Class Template Reference
[Exception-safe code]

#include <ScopeGuard.h>

Inheritance diagram for Loki::ObjScopeGuardImpl3< Obj, MemFun, P1, P2, P3 >:
Collaboration diagram for Loki::ObjScopeGuardImpl3< Obj, MemFun, P1, P2, P3 >:

List of all members.


Detailed Description

template<class Obj, typename MemFun, typename P1, typename P2, typename P3>
class Loki::ObjScopeGuardImpl3< Obj, MemFun, P1, P2, P3 >

Implementation class for a class per-instance member function with three parameters. Each parameter is copied by value - use Loki::ByRef if you must use a reference instead. ScopeGuard ignores any value returned from the call within the Execute function.

This class has 3 standalone helper functions which create a ScopeGuard. One is MakeObjGuard, which is deprecated but provided for older code. The other two are MakeGuard overloads, one which takes a pointer to an object, and the other which takes a reference.


The documentation for this class was generated from the following file:
  • ScopeGuard.h

Generated on Thu Jan 29 18:51:44 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00460.dot0000755000175000017500000000145411140366262015622 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; Node1 [label="Loki::LongevityLifetime::DieFirst\< T \>",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node2 -> Node1 [dir=back,color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::LongevityLifetime::SingletonFixedLongevity\< 0, T \>",height=0.2,width=0.4,color="black",URL="$a00123.html"]; Node3 -> Node2 [dir=back,color="orange",fontsize="10",style="dashed",label="\<0,T\>",fontname="FreeSans"]; Node3 [label="Loki::LongevityLifetime::SingletonFixedLongevity\< Longevity, T \>",height=0.2,width=0.4,color="black",URL="$a00123.html"]; } libloki-0.1.7.orig/doc/html/a00460.md50000755000175000017500000000004011140366262015507 0ustar ivanivan8027387e201546208570c8c24eb139a9libloki-0.1.7.orig/doc/html/a00071_0e7b01d7e0aad6710f34de9811a88151_cgraph.dot0000755000175000017500000000143511140366256023511 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node1 [label="Loki::LevelMutexInfo::LevelMutexInfo",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1 -> Node2 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::LevelMutexInfo::IsValid",height=0.2,width=0.4,color="black",URL="$a00071.html#36c34ecf5d019f3db9bfb8654cf49176"]; Node2 -> Node3 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node3 [label="Loki::LevelMutexInfo::IsValidList",height=0.2,width=0.4,color="black",URL="$a00071.html#01f6dfba5d2ea5606109b34e5a543cf0"]; } libloki-0.1.7.orig/doc/html/a00071_0e7b01d7e0aad6710f34de9811a88151_cgraph.md50000755000175000017500000000004011140366256023377 0ustar ivanivanb577b691cd7282727ef16f3999a06708libloki-0.1.7.orig/doc/html/a00462.dot0000755000175000017500000000221211140366262015615 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; Node1 [label="Loki::LongevityLifetime::DieAsSmallObjectParent\< T \>",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node2 -> Node1 [dir=back,color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::LongevityLifetime::DieLast\< T \>",height=0.2,width=0.4,color="black",URL="$a00049.html"]; Node3 -> Node2 [dir=back,color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node3 [label="Loki::LongevityLifetime::SingletonFixedLongevity\< 0xFFFFFFFF,T \>",height=0.2,width=0.4,color="black",URL="$a00123.html"]; Node4 -> Node3 [dir=back,color="orange",fontsize="10",style="dashed",label="\<0xFFFFFFFF ,T\>",fontname="FreeSans"]; Node4 [label="Loki::LongevityLifetime::SingletonFixedLongevity\< Longevity, T \>",height=0.2,width=0.4,color="black",URL="$a00123.html"]; Node2 -> Node2 [dir=back,color="orange",fontsize="10",style="dashed",label="\",fontname="FreeSans"]; } libloki-0.1.7.orig/doc/html/a00462.md50000755000175000017500000000004011140366262015511 0ustar ivanivan7c8c1b63d872307d2bb598d4eaa33c29libloki-0.1.7.orig/doc/html/a00463.dot0000755000175000017500000000221211140366262015616 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; Node1 [label="Loki::LongevityLifetime::DieAsSmallObjectParent\< T \>",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node2 -> Node1 [dir=back,color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::LongevityLifetime::DieLast\< T \>",height=0.2,width=0.4,color="black",URL="$a00049.html"]; Node3 -> Node2 [dir=back,color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node3 [label="Loki::LongevityLifetime::SingletonFixedLongevity\< 0xFFFFFFFF,T \>",height=0.2,width=0.4,color="black",URL="$a00123.html"]; Node4 -> Node3 [dir=back,color="orange",fontsize="10",style="dashed",label="\<0xFFFFFFFF ,T\>",fontname="FreeSans"]; Node4 [label="Loki::LongevityLifetime::SingletonFixedLongevity\< Longevity, T \>",height=0.2,width=0.4,color="black",URL="$a00123.html"]; Node2 -> Node2 [dir=back,color="orange",fontsize="10",style="dashed",label="\",fontname="FreeSans"]; } libloki-0.1.7.orig/doc/html/a00463.md50000755000175000017500000000004011140366262015512 0ustar ivanivan7c8c1b63d872307d2bb598d4eaa33c29libloki-0.1.7.orig/doc/html/a00080_aa646ae058e3273651f89bfbb276cf42_cgraph.dot0000755000175000017500000000764711140366257023627 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node1 [label="Loki::MultiMutexLocker::MultiMutexLocker",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1 -> Node2 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::LevelMutexInfo::MultiLock",height=0.2,width=0.4,color="black",URL="$a00071.html#dde650eae1cad8b4723e68cdb9130283"]; Node2 -> Node3 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node3 [label="Loki::LevelMutexInfo::MutexUndoer::Cancel",height=0.2,width=0.4,color="black",URL="$a00073.html#87e777d849336fe81907e55aaad1edaa"]; Node2 -> Node4 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node4 [label="Loki::LevelMutexInfo::DoErrorCheck",height=0.2,width=0.4,color="black",URL="$a00071.html#14e0d51318b864645bbb3df4f7c9f7ab"]; Node2 -> Node5 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node5 [label="Loki::DoMutexesMatchContainer",height=0.2,width=0.4,color="black",URL="$a00192.html#d633ca81ae0befaf235ae63886368037"]; Node5 -> Node6 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node6 [label="Loki::CountMutexesAtCurrentLevel",height=0.2,width=0.4,color="black",URL="$a00192.html#8cb767d3e7aaf2fe44b8f3b90218b876"]; Node6 -> Node7 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node7 [label="Loki::LevelMutexInfo::GetCurrentMutex",height=0.2,width=0.4,color="black",URL="$a00071.html#b7fd94847721b118979b72121472d3e2"]; Node7 -> Node8 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node8 [label="Loki::LevelMutexInfo::IsValidList",height=0.2,width=0.4,color="black",URL="$a00071.html#01f6dfba5d2ea5606109b34e5a543cf0"]; Node6 -> Node9 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node9 [label="Loki::LevelMutexInfo::GetLevel",height=0.2,width=0.4,color="black",URL="$a00071.html#1cad7c6b6fc50e230401e4cc22761d14",tooltip="Returns the level of this mutex."]; Node6 -> Node10 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node10 [label="Loki::LevelMutexInfo::GetPrevious",height=0.2,width=0.4,color="black",URL="$a00071.html#b774e94ff72724dd87ff236d99970bb5",tooltip="Returns pointer to mutex previously locked by the thread which locked this."]; Node5 -> Node11 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node11 [label="Loki::GetCurrentThreadsLevel",height=0.2,width=0.4,color="black",URL="$a00192.html#9548795d9cda6f227a1e1241ba577ca8"]; Node11 -> Node7 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node11 -> Node9 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node5 -> Node9 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node5 -> Node12 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node12 [label="Loki::LevelMutexInfo::IsRecentLock",height=0.2,width=0.4,color="black",URL="$a00071.html#b917108c3e7c83b8a515d28e91a3a3ca"]; Node12 -> Node13 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node13 [label="Loki::LevelMutexInfo::IsValid",height=0.2,width=0.4,color="black",URL="$a00071.html#36c34ecf5d019f3db9bfb8654cf49176"]; Node13 -> Node8 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 -> Node11 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 -> Node8 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 -> Node14 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node14 [label="Loki::LevelMutexInfo::MutexUndoer::SetPlace",height=0.2,width=0.4,color="black",URL="$a00073.html#65a5d0ff95ed8ab37280350f6a10259c"]; } libloki-0.1.7.orig/doc/html/a00080_aa646ae058e3273651f89bfbb276cf42_cgraph.md50000755000175000017500000000004011140366257023502 0ustar ivanivan6961e150d14e97a036ff0e3316b80a00libloki-0.1.7.orig/doc/html/a00214.html0000755000175000017500000001301311140366254015770 0ustar ivanivan Loki: Lifetime policies

Lifetime policies
[Singleton]

Collaboration diagram for Lifetime policies:

Classes

struct  Loki::DefaultLifetime< T >
struct  Loki::PhoenixSingleton< T >
struct  Loki::DeletableSingleton< T >
struct  Loki::SingletonWithLongevity< T >
struct  Loki::NoDestroy< T >
class  Loki::FollowIntoDeath

Modules

 LongevityLifetime

Functions

template<typename T , typename Destroyer >
void Loki::SetLongevity (T *pDynObject, unsigned int longevity, Destroyer d)

Detailed Description

The lifetimes of the singleton.
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 Be aware of this when you use Loki::Factory, Loki::Functor, or Loki::Function.

Function Documentation

template<typename T , typename Destroyer >
void Loki::SetLongevity ( T *  pDynObject,
unsigned int  longevity,
Destroyer  d 
) [inline]

Assigns an object a longevity; ensures ordered destructions of objects registered thusly during the exit sequence of the application


Generated on Thu Jan 29 18:51:40 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00465.dot0000755000175000017500000000223311140366262015623 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; Node1 [label="Loki::LongevityLifetime::DieAsSmallObjectChild\< T \>",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node2 -> Node1 [dir=back,color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::LongevityLifetime::DieDirectlyBeforeLast\< T \>",height=0.2,width=0.4,color="black",URL="$a00047.html"]; Node3 -> Node2 [dir=back,color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node3 [label="Loki::LongevityLifetime::SingletonFixedLongevity\< 0xFFFFFFFF-1,T \>",height=0.2,width=0.4,color="black",URL="$a00123.html"]; Node4 -> Node3 [dir=back,color="orange",fontsize="10",style="dashed",label="\<0xFFFFFFFF-1 ,T\>",fontname="FreeSans"]; Node4 [label="Loki::LongevityLifetime::SingletonFixedLongevity\< Longevity, T \>",height=0.2,width=0.4,color="black",URL="$a00123.html"]; Node2 -> Node2 [dir=back,color="orange",fontsize="10",style="dashed",label="\",fontname="FreeSans"]; } libloki-0.1.7.orig/doc/html/a00465.md50000755000175000017500000000004011140366262015514 0ustar ivanivanefecc45db4ca7cb3b0e685e04cc2e7e9libloki-0.1.7.orig/doc/html/a00466.dot0000755000175000017500000000223311140366262015624 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; Node1 [label="Loki::LongevityLifetime::DieAsSmallObjectChild\< T \>",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node2 -> Node1 [dir=back,color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::LongevityLifetime::DieDirectlyBeforeLast\< T \>",height=0.2,width=0.4,color="black",URL="$a00047.html"]; Node3 -> Node2 [dir=back,color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node3 [label="Loki::LongevityLifetime::SingletonFixedLongevity\< 0xFFFFFFFF-1,T \>",height=0.2,width=0.4,color="black",URL="$a00123.html"]; Node4 -> Node3 [dir=back,color="orange",fontsize="10",style="dashed",label="\<0xFFFFFFFF-1 ,T\>",fontname="FreeSans"]; Node4 [label="Loki::LongevityLifetime::SingletonFixedLongevity\< Longevity, T \>",height=0.2,width=0.4,color="black",URL="$a00123.html"]; Node2 -> Node2 [dir=back,color="orange",fontsize="10",style="dashed",label="\",fontname="FreeSans"]; } libloki-0.1.7.orig/doc/html/a00466.md50000755000175000017500000000004011140366262015515 0ustar ivanivanefecc45db4ca7cb3b0e685e04cc2e7e9libloki-0.1.7.orig/doc/html/a00283.html0000755000175000017500000001133411140366256016004 0ustar ivanivan Loki: Member List

Loki::LokiAllocator< Type, AllocT > Member List

This is the complete list of members for Loki::LokiAllocator< Type, AllocT >, including all inherited members.

address(reference elem) const Loki::LokiAllocator< Type, AllocT > [inline]
address(const_reference elem) const Loki::LokiAllocator< Type, AllocT > [inline]
allocate(size_type count, const void *hint=0)Loki::LokiAllocator< Type, AllocT > [inline]
construct(pointer p, const Type &value)Loki::LokiAllocator< Type, AllocT > [inline]
deallocate(pointer p, size_type size)Loki::LokiAllocator< Type, AllocT > [inline]
destroy(pointer p)Loki::LokiAllocator< Type, AllocT > [inline]
LokiAllocator(void)Loki::LokiAllocator< Type, AllocT > [inline]
LokiAllocator(const LokiAllocator &)Loki::LokiAllocator< Type, AllocT > [inline]
LokiAllocator(const LokiAllocator< Type1 > &)Loki::LokiAllocator< Type, AllocT > [inline]
max_size(void) const Loki::LokiAllocator< Type, AllocT > [inline]
~LokiAllocator()Loki::LokiAllocator< Type, AllocT > [inline]


Generated on Thu Jan 29 18:51:42 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00028.html0000755000175000017500000000507011140366257016002 0ustar ivanivan Loki: Loki::ConstPropPtr< T > Class Template Reference

Loki::ConstPropPtr< T > Class Template Reference
[Pimpl]

#include <Pimpl.h>

List of all members.


Detailed Description

template<class T>
class Loki::ConstPropPtr< T >

Simple const propagating smart pointer Is the default smart pointer of Pimpl.
The documentation for this class was generated from the following file:
  • Pimpl.h

Generated on Thu Jan 29 18:51:43 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00342.html0000755000175000017500000000366111140366257016005 0ustar ivanivan Loki: Member List

Loki::ConstPropPtr< T > Member List

This is the complete list of members for Loki::ConstPropPtr< T >, including all inherited members.


Generated on Thu Jan 29 18:51:43 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00097.html0000755000175000017500000000533111140366260016002 0ustar ivanivan Loki: Loki::PhoenixSingleton< T > Struct Template Reference

Loki::PhoenixSingleton< T > Struct Template Reference
[Lifetime policies]

#include <Singleton.h>

List of all members.


Detailed Description

template<class T>
struct Loki::PhoenixSingleton< T >

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
The documentation for this struct was generated from the following file:
  • Singleton.h

Generated on Thu Jan 29 18:51:44 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00215.html0000755000175000017500000000724411140366254016002 0ustar ivanivan Loki: LongevityLifetime

LongevityLifetime
[Lifetime policies]

Collaboration diagram for LongevityLifetime:


Classes

struct  Loki::LongevityLifetime::SingletonFixedLongevity< Longevity, T >
struct  Loki::LongevityLifetime::DieLast< T >
 Longest possible SingletonWithLongevity lifetime: 0xFFFFFFFF. More...
struct  Loki::LongevityLifetime::DieDirectlyBeforeLast< T >
 Lifetime is a one less than DieLast: 0xFFFFFFFF-1. More...
struct  Loki::LongevityLifetime::DieFirst< T >
 Shortest possible SingletonWithLongevity lifetime: 0. More...

Namespaces

namespace  LongevityLifetime
 In this namespace are special lifetime policies to manage lifetime dependencies.

Generated on Thu Jan 29 18:51:40 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00284.html0000755000175000017500000000402511140366256016004 0ustar ivanivan Loki: Member List

Loki::LokiAllocator< Type, AllocT >::LokiAllocator::rebind< Type1 > Member List

This is the complete list of members for Loki::LokiAllocator< Type, AllocT >::LokiAllocator::rebind< Type1 >, including all inherited members.


Generated on Thu Jan 29 18:51:42 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00029.html0000755000175000017500000003070111140366256016001 0ustar ivanivan Loki: Loki::ContractChecker< Host, ExceptionPolicy > Class Template Reference

Loki::ContractChecker< Host, ExceptionPolicy > Class Template Reference

#include <Checker.h>

List of all members.

Public Types

typedef bool(Host::* Validator )(void) const
 Signature for the validation function.

Public Member Functions

 ContractChecker (const Host *host, Validator validator, Validator pre=0, Validator post=0)
 ~ContractChecker (void)
bool Check (void) const


Detailed Description

template<class Host, template< class > class ExceptionPolicy>
class Loki::ContractChecker< Host, ExceptionPolicy >

This class determines if a function violated any class invariant, but it also determines if a function fulfills its contract with client code. In the "Design by Contract" paradigm, each function has certain pre-conditions and post-conditions which may differ from the class invariants. This asserts if a check for an invariant fails as well as if any pre- or post-condition fails. It also demonstrate which exception safety level a function provides.

Usage
  1. Implement a function that checks each class invariant. The function must have the signature similar to the Validator type. Something like: "bool Host::IsValid( void ) const;"
    • The function should return true if everything is okay, but false if something is wrong.
    • Or it could assert if anything is wrong.
    • Ideally, it should be private.
  2. Implement similar functions to check for pre-conditions and post-conditions. Functions which verify pre-conditions and post-conditions do not need to check all class invariants, just conditions specific to certain public functions in the host class.
  3. Declare some typedef's inside the class declaration like these. Make one typedef for each exception policy you use. I typedef'ed the CheckForNothing policy as CheckInvariants because even if a function can't provide either the no-throw nor the no-change policies, it should still make sure the object remains in a valid state.
    • typedef Loki::ContractChecker< Host, ::Loki::CheckForNoThrow > CheckForNoThrow;
    • typedef Loki::ContractChecker< Host, ::Loki::CheckForNoChange > CheckForNoChange;
    • typedef Loki::ContractChecker< Host, ::Loki::CheckForEquality > CheckForEquality;
    • typedef Loki::ContractChecker< Host, ::Loki::CheckForNothing > CheckInvariants;
  4. Construct a checker near the top of each member function - except in the validator member function. Pass the this pointer and the address of your validator function into the checker's constructor. You may also pass in pointers to function which check pre- and post-conditions.
    • If the function never throws, then use the CheckForNoThrow policy.
    • If the function never changes any data members, then use CheckForEquality policy.
    • If the function's normal execution flow changes data, but must make sure data remains unchanged when any exceptions occur, then use the CheckForNoChange policy.
    • Otherwise use the CheckInvariants policy.
  5. Recompile a debug version of your program, run the program and all the unit tests, and look for which assertions failed.

Constructor & Destructor Documentation

template<class Host , template< class > class ExceptionPolicy>
Loki::ContractChecker< Host, ExceptionPolicy >::ContractChecker ( const Host *  host,
Validator  validator,
Validator  pre = 0,
Validator  post = 0 
) [inline]

The constructor makes sure the host is valid at the time the checker was created, thus insuring the host object was not corrupt from the start.

host Pointer to host object.
validator Pointer to function that checks class invariants.
pre Optional pointer to function that checks pre-conditions.
post Optional pointer to function that checks post-conditions.

References Loki::ContractChecker< Host, ExceptionPolicy >::Check().

Here is the call graph for this function:

template<class Host , template< class > class ExceptionPolicy>
Loki::ContractChecker< Host, ExceptionPolicy >::~ContractChecker ( void   )  [inline]

The destructor checks if any Host invariants failed, and then calls the ExceptionPolicy's Check function to determine what to do in case of an exception.

References Loki::ContractChecker< Host, ExceptionPolicy >::Check().

Here is the call graph for this function:


Member Function Documentation

template<class Host , template< class > class ExceptionPolicy>
bool Loki::ContractChecker< Host, ExceptionPolicy >::Check ( void   )  const [inline]

This first checks the invariants for ContractChecker, and then calls the validator function for the host to make sure no class invariants were broken by the host within the Host's member function body. The host member function can call Check directly to verify the object remains valid at any time. This does not care if the pre- and post-condition validator pointers are null since a host class may pass in NULL pointers for either to indicate the pre-conditions or post-conditions are the same as the overall class invariants.

Referenced by Loki::ContractChecker< Host, ExceptionPolicy >::ContractChecker(), and Loki::ContractChecker< Host, ExceptionPolicy >::~ContractChecker().


The documentation for this class was generated from the following file:

Generated on Thu Jan 29 18:51:42 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00343.html0000755000175000017500000000366511140366257016012 0ustar ivanivan Loki: Member List

Loki::Pimpl< T, Pointer > Member List

This is the complete list of members for Loki::Pimpl< T, Pointer >, including all inherited members.


Generated on Thu Jan 29 18:51:43 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00098.html0000755000175000017500000000541511140366257016014 0ustar ivanivan Loki: Loki::Pimpl< T, Pointer > Class Template Reference

Loki::Pimpl< T, Pointer > Class Template Reference
[Pimpl]

#include <Pimpl.h>

List of all members.


Detailed Description

template<class T, typename Pointer = ConstPropPtr<T>>
class Loki::Pimpl< T, Pointer >

Implements the Pimpl idiom. It's a wrapper for a smart pointer which automatically creates and deletes the implementation object and adds const propagation to the smart pointer.

Usage
see test/Pimpl

The documentation for this class was generated from the following file:
  • Pimpl.h

Generated on Thu Jan 29 18:51:43 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00402.html0000755000175000017500000001077611140366261016002 0ustar ivanivan Loki: Member List

Loki::SmallObject< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > Member List

This is the complete list of members for Loki::SmallObject< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >, including all inherited members.

ObjAllocatorSingleton typedefLoki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >
operator delete(void *p, std::size_t size)Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > [inline, static]
operator delete(void *p, const std::nothrow_t &)Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > [inline, static]
operator delete(void *p, void *place)Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > [inline, static]
operator new(std::size_t size)Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > [inline, static]
operator new(std::size_t size, const std::nothrow_t &)Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > [inline, static]
operator new(std::size_t size, void *place)Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > [inline, static]


Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00070_042a7938dafd6f149cfd7da46478c0c9_cgraph.dot0000755000175000017500000000445111140366257023706 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node1 [label="Loki::LevelMutex::TryLock",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1 -> Node2 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::LevelMutexInfo::GetLevel",height=0.2,width=0.4,color="black",URL="$a00071.html#1cad7c6b6fc50e230401e4cc22761d14",tooltip="Returns the level of this mutex."]; Node1 -> Node3 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node3 [label="Loki::LevelMutexInfo::GetLockCount",height=0.2,width=0.4,color="black",URL="$a00071.html#013e7ffd438e4c1f11dcc6943a40802e",tooltip="Returns count of how many times this mutex got locked."]; Node1 -> Node4 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node4 [label="Loki::LevelMutexInfo::IsValid",height=0.2,width=0.4,color="black",URL="$a00071.html#36c34ecf5d019f3db9bfb8654cf49176"]; Node4 -> Node5 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node5 [label="Loki::LevelMutexInfo::IsValidList",height=0.2,width=0.4,color="black",URL="$a00071.html#01f6dfba5d2ea5606109b34e5a543cf0"]; Node1 -> Node6 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node6 [label="Loki::LevelMutexInfo::PostLock",height=0.2,width=0.4,color="black",URL="$a00071.html#3fe2ecf1bcf2c49eae04c493f023099c"]; Node6 -> Node7 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node7 [label="Loki::LevelMutexInfo::IsLockedByCurrentThread",height=0.2,width=0.4,color="black",URL="$a00071.html#c0a343bcb322ea36495f536504f61f9f",tooltip="Returns true if this was locked by current thread."]; Node7 -> Node8 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node8 [label="Loki::LevelMutexInfo::IsLocked",height=0.2,width=0.4,color="black",URL="$a00071.html#e6aa7465e1bba7f0c9fbf0b06f122a39",tooltip="Returns true if this mutex was locked at least once."]; Node7 -> Node4 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node6 -> Node4 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; } libloki-0.1.7.orig/doc/html/a00070_042a7938dafd6f149cfd7da46478c0c9_cgraph.md50000755000175000017500000000004011140366257023573 0ustar ivanivancd57e37f458063a660cd73a0eef171e7libloki-0.1.7.orig/doc/html/a00157.html0000755000175000017500000000730211140366254016002 0ustar ivanivan Loki: LevelMutex.cpp File Reference

LevelMutex.cpp File Reference

Contains functions needed by LevelMutex class. More...

#include <loki/LevelMutex.h>
#include <algorithm>
#include <cerrno>

Include dependency graph for LevelMutex.cpp:

Namespaces

namespace  Loki

Functions

unsigned int Loki::GetCurrentThreadsLevel (void)
unsigned int Loki::CountMutexesInCurrentThread (void)
unsigned int Loki::CountLocksInCurrentThread (void)
unsigned int Loki::CountMutexesAtCurrentLevel (void)
MutexErrors::Type Loki::DoMutexesMatchContainer (const LevelMutexInfo::MutexContainer &mutexes)

Detailed Description

Contains functions needed by LevelMutex class.


Generated on Thu Jan 29 18:51:40 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00216.html0000755000175000017500000000620511140366254015777 0ustar ivanivan Loki: Small objects
Generated on Thu Jan 29 18:51:40 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00056_e74cbab50e78bfa115d7c0fcdce00641_cgraph.dot0000755000175000017500000000106611140366261024063 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node1 [label="Loki::FixedAllocator::CountEmptyChunks",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1 -> Node2 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::Chunk::HasAvailable",height=0.2,width=0.4,color="black",URL="$a00025.html#0874a711145788bd8c5265a9de2a4aac"]; } libloki-0.1.7.orig/doc/html/a00056_e74cbab50e78bfa115d7c0fcdce00641_cgraph.md50000755000175000017500000000004011140366261023751 0ustar ivanivand75d11d28e2b921b11362cdaf8598594libloki-0.1.7.orig/doc/html/a00285.html0000755000175000017500000000371711140366256016014 0ustar ivanivan Loki: Member List

Loki::SimplePointer< AbstractProduct > Member List

This is the complete list of members for Loki::SimplePointer< AbstractProduct >, including all inherited members.


Generated on Thu Jan 29 18:51:42 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00344.html0000755000175000017500000000365511140366257016012 0ustar ivanivan Loki: Member List

Loki::RefToValue< T > Member List

This is the complete list of members for Loki::RefToValue< T >, including all inherited members.


Generated on Thu Jan 29 18:51:43 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00099.html0000755000175000017500000000435111140366255016011 0ustar ivanivan Loki: PImplOf Class Reference

PImplOf Class Reference
[Pimpl]

#include <Pimpl.h>


Detailed Description

Convenience template which uses ImplOf as implementation structure
The documentation for this class was generated from the following file:
  • Pimpl.h

Generated on Thu Jan 29 18:51:41 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00158.html0000755000175000017500000002061111140366254016001 0ustar ivanivan Loki: LevelMutex.h File Reference

LevelMutex.h File Reference

Defines classes and functions for LevelMutex facility. More...

#include <vector>
#include <assert.h>
#include <time.h>
#include <pthread.h>
#include <unistd.h>

Include dependency graph for LevelMutex.h:

This graph shows which files directly or indirectly include this file:

Classes

class  Loki::LevelMutexInfo
class  Loki::LevelMutexInfo::LevelMutexInfo::Checker
class  Loki::LevelMutexInfo::LevelMutexInfo::MutexUndoer
class  Loki::ThrowOnAnyMutexError
class  Loki::ThrowOnBadDesignMutexError
class  Loki::AssertAnyMutexError
class  Loki::AssertBadDesignMutexError
class  Loki::JustReturnMutexError
class  Loki::NoMutexWait
class  Loki::MutexSleepWaits
class  Loki::SpinLevelMutex
class  Loki::SleepLevelMutex
class  Loki::LevelMutex< MutexPolicy, DefaultLevel, ErrorPolicy, WaitPolicy >
class  Loki::MutexException
class  Loki::MutexLocker
class  Loki::MultiMutexLocker

Namespaces

namespace  Loki

Defines

#define LOKI_THREAD_LOCAL   thread_local

Functions

unsigned int Loki::GetCurrentThreadsLevel (void)
unsigned int Loki::CountMutexesInCurrentThread (void)
unsigned int Loki::CountLocksInCurrentThread (void)
unsigned int Loki::CountMutexesAtCurrentLevel (void)
MutexErrors::Type Loki::DoMutexesMatchContainer (const LevelMutexInfo::MutexContainer &mutexes)

Detailed Description

Defines classes and functions for LevelMutex facility.


Define Documentation

#define LOKI_THREAD_LOCAL   thread_local

thread_local Keyword
The mutexes require compilers to provide thread local storage - meaning each thread gets its own copy of the data. The next version of C++ will have a new keyword, thread_local for that purpose. Some existing compilers already provide thread local storage using different syntax, so these lines use thread_local to mimic that syntax. If your compiler provides thread local storage but using different syntax besides "thread_local", you may want to modify these lines. If your compiler does not support thread local storage, you can't use LevelMutex.


Generated on Thu Jan 29 18:51:40 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00217.html0000755000175000017500000001715211140366254016003 0ustar ivanivan Loki: Internals

Internals
[Small objects]

Collaboration diagram for Internals:

Classes

class  Loki::SmallObjAllocator
class  Loki::AllocatorSingleton< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >
struct  Loki::Chunk
class  Loki::FixedAllocator

Functions

std::size_t Loki::GetOffset (std::size_t numBytes, std::size_t alignment)
void * Loki::DefaultAllocator (std::size_t numBytes, bool doThrow)
void Loki::DefaultDeallocator (void *p)

Function Documentation

void* Loki::DefaultAllocator ( std::size_t  numBytes,
bool  doThrow 
)

Calls the default allocator when SmallObjAllocator decides not to handle a request. SmallObjAllocator calls this if the number of bytes is bigger than the size which can be handled by any FixedAllocator.

Parameters:
numBytes number of bytes
doThrow True if this function should throw an exception, or false if it should indicate failure by returning a NULL pointer.

Referenced by Loki::SmallObjAllocator::Allocate().

void Loki::DefaultDeallocator ( void *  p  ) 

Calls default deallocator when SmallObjAllocator decides not to handle a request. The default deallocator could be the global delete operator or the free function. The free function is the preferred default deallocator since it matches malloc which is the preferred default allocator. SmallObjAllocator will call this if an address was not found among any of its own blocks.

Referenced by Loki::SmallObjAllocator::Deallocate().

std::size_t Loki::GetOffset ( std::size_t  numBytes,
std::size_t  alignment 
) [inline]


Generated on Thu Jan 29 18:51:40 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/ftv2plastnode.png0000755000175000017500000000024511140366263017577 0ustar ivanivan‰PNG  IHDRรรฤy PLTE€€€<^ป,tRNS@ๆุftEXtSoftwaregif2png 2.4.2ฃ^G(IDATxฺc` 0ach(`2ต BY 1,nมยๅํuงIENDฎB`‚libloki-0.1.7.orig/doc/html/a00286.html0000755000175000017500000000363111140366256016010 0ustar ivanivan Loki: Member List

Loki::NeverCreate Member List

This is the complete list of members for Loki::NeverCreate, including all inherited members.


Generated on Thu Jan 29 18:51:42 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00030.html0000755000175000017500000000545411140366260015773 0ustar ivanivan Loki: Loki::CreateStatic< T > Struct Template Reference

Loki::CreateStatic< T > Struct Template Reference
[Creation policies]

#include <Singleton.h>

List of all members.


Detailed Description

template<class T>
struct Loki::CreateStatic< T >

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.
The documentation for this struct was generated from the following file:
  • Singleton.h

Generated on Thu Jan 29 18:51:44 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00345.html0000755000175000017500000000372311140366257016007 0ustar ivanivan Loki: Member List

Loki::RegisterOnCreateSet< ElementList > Member List

This is the complete list of members for Loki::RegisterOnCreateSet< ElementList >, including all inherited members.


Generated on Thu Jan 29 18:51:43 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/namespacemembers.html0000755000175000017500000001162711140366263020501 0ustar ivanivan Loki: Class Members
Here is a list of all documented namespace members with links to the namespaces they belong to:

- b -

- c -

  • Chain() : Loki
  • CountLocksInCurrentThread() : Loki
  • CountMutexesAtCurrentLevel() : Loki
  • CountMutexesInCurrentThread() : Loki

- d -

  • DefaultAllocator() : Loki
  • DefaultDeallocator() : Loki
  • DoMutexesMatchContainer() : Loki

- g -

  • GetCurrentThreadsLevel() : Loki
  • GetLongevity() : Loki
  • GetOffset() : Loki

- o -

- r -

  • RegisterFunction() : Loki

- s -

  • SetLongevity() : Loki

- u -

  • UnRegisterFunction() : Loki

Generated on Thu Jan 29 18:51:47 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00110_70a37a966ba91fe89ac6f5f661f04279_cgraph.dot0000755000175000017500000000121611140366257023542 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node1 [label="Loki::SafeBitConst::operator\<\<",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1 -> Node2 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::SafeBitConst::SafeBitConst",height=0.2,width=0.4,color="black",URL="$a00110.html#5ca867866c32c41efd30b5912daf48ba",tooltip="Default constructor allows client code to construct bit fields on the stack."]; } libloki-0.1.7.orig/doc/html/a00110_70a37a966ba91fe89ac6f5f661f04279_cgraph.md50000755000175000017500000000004011140366257023433 0ustar ivanivan4240837f9a0466f853a58c380053afeflibloki-0.1.7.orig/doc/html/tabs.css0000755000175000017500000000345611140366250015744 0ustar ivanivan/* tabs styles, based on http://www.alistapart.com/articles/slidingdoors */ DIV.tabs { float : left; width : 100%; background : url("tab_b.gif") repeat-x bottom; margin-bottom : 4px; } DIV.tabs UL { margin : 0px; padding-left : 10px; list-style : none; } DIV.tabs LI, DIV.tabs FORM { display : inline; margin : 0px; padding : 0px; } DIV.tabs FORM { float : right; } DIV.tabs A { float : left; background : url("tab_r.gif") no-repeat right top; border-bottom : 1px solid #84B0C7; font-size : 80%; font-weight : bold; text-decoration : none; } DIV.tabs A:hover { background-position: 100% -150px; } DIV.tabs A:link, DIV.tabs A:visited, DIV.tabs A:active, DIV.tabs A:hover { color: #1A419D; } DIV.tabs SPAN { float : left; display : block; background : url("tab_l.gif") no-repeat left top; padding : 5px 9px; white-space : nowrap; } DIV.tabs INPUT { float : right; display : inline; font-size : 1em; } DIV.tabs TD { font-size : 80%; font-weight : bold; text-decoration : none; } /* Commented Backslash Hack hides rule from IE5-Mac \*/ DIV.tabs SPAN {float : none;} /* End IE5-Mac hack */ DIV.tabs A:hover SPAN { background-position: 0% -150px; } DIV.tabs LI.current A { background-position: 100% -150px; border-width : 0px; } DIV.tabs LI.current SPAN { background-position: 0% -150px; padding-bottom : 6px; } DIV.navpath { background : none; border : none; border-bottom : 1px solid #84B0C7; text-align : center; margin : 2px; padding : 2px; } libloki-0.1.7.orig/doc/html/a00218.html0000755000175000017500000014053611140366255016010 0ustar ivanivan Loki: Smart pointers

Smart pointers

Collaboration diagram for Smart pointers:

Classes

struct  std::less< Loki::StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > >
class  Loki::RefToValue< T >
struct  Loki::NullPointerException
class  Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy >
class  Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy >

Namespaces

namespace  std

Modules

 Ownership policies
 Storage policies
 Conversion policies
 Checking policies
 StrongPtr Ownership policies
 Delete policies
 Reset policies

Functions

template<typename T , template< class > class OP, class CP , template< class > class KP, template< class > class SP, template< class > class CNP1, typename U >
bool Loki::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 Loki::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 Loki::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 Loki::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 Loki::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 Loki::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 Loki::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 Loki::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 Loki::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 Loki::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 Loki::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 Loki::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 Loki::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 Loki::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 Loki::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 Loki::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 Loki::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 Loki::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 Loki::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 Loki::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 Loki::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 Loki::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 Loki::operator>= (U *lhs, const StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > &rhs)

Detailed Description

Policy based implementation of a smart pointer

Function Documentation

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 Loki::operator!= ( U *  lhs,
const StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > &  rhs 
) [inline]

operator!= for lhs = raw pointer, rhs = StrongPtr

References Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy >::Equals().

Here is the call graph for this function:

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 Loki::operator!= ( const StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > &  lhs,
U *  rhs 
) [inline]

operator!= for lhs = StrongPtr, rhs = raw pointer

References Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy >::Equals().

Here is the call graph for this function:

template<typename T , template< class > class OP, class CP , template< class > class KP, template< class > class SP, template< class > class CNP, typename U >
bool Loki::operator!= ( U *  lhs,
const SmartPtr< T, OP, CP, KP, SP, CNP > &  rhs 
) [inline]

operator!= for lhs = raw pointer, rhs = SmartPtr

template<typename T , template< class > class OP, class CP , template< class > class KP, template< class > class SP, template< class > class CNP, typename U >
bool Loki::operator!= ( const SmartPtr< T, OP, CP, KP, SP, CNP > &  lhs,
U *  rhs 
) [inline]

operator!= for lhs = SmartPtr, rhs = raw pointer

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 Loki::operator< ( U *  lhs,
const StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > &  rhs 
) [inline]

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 Loki::operator< ( const StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > &  lhs,
U *  rhs 
) [inline]

operator< for lhs = StrongPtr, rhs = raw pointer

References Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy >::LessThan().

Here is the call graph for this function:

template<typename T , template< class > class OP, class CP , template< class > class KP, template< class > class SP, template< class > class CNP, typename U >
bool Loki::operator< ( U *  lhs,
const SmartPtr< T, OP, CP, KP, SP, CNP > &  rhs 
) [inline]

operator< for lhs = raw pointer, rhs = SmartPtr

template<typename T , template< class > class OP, class CP , template< class > class KP, template< class > class SP, template< class > class CNP, typename U >
bool Loki::operator< ( const SmartPtr< T, OP, CP, KP, SP, CNP > &  lhs,
U *  rhs 
) [inline]

operator< for lhs = SmartPtr, rhs = raw pointer

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 Loki::operator<= ( U *  lhs,
const StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > &  rhs 
) [inline]

operator<= for lhs = raw pointer, rhs = StrongPtr

References Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy >::LessThan().

Here is the call graph for this function:

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 Loki::operator<= ( const StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > &  lhs,
U *  rhs 
) [inline]

template<typename T , template< class > class OP, class CP , template< class > class KP, template< class > class SP, template< class > class CNP, typename U >
bool Loki::operator<= ( U *  lhs,
const SmartPtr< T, OP, CP, KP, SP, CNP > &  rhs 
) [inline]

operator<= for lhs = raw pointer, rhs = SmartPtr

template<typename T , template< class > class OP, class CP , template< class > class KP, template< class > class SP, template< class > class CNP, typename U >
bool Loki::operator<= ( const SmartPtr< T, OP, CP, KP, SP, CNP > &  lhs,
U *  rhs 
) [inline]

operator<= for lhs = SmartPtr, rhs = raw pointer

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 Loki::operator== ( U *  lhs,
const StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > &  rhs 
) [inline]

operator== for lhs = raw pointer, rhs = StrongPtr

References Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy >::Equals().

Here is the call graph for this function:

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 Loki::operator== ( const StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > &  lhs,
U *  rhs 
) [inline]

operator== for lhs = StrongPtr, rhs = raw pointer

References Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy >::Equals().

Here is the call graph for this function:

template<typename T , template< class > class OP, class CP , template< class > class KP, template< class > class SP, template< class > class CNP1, typename U >
bool Loki::operator== ( U *  lhs,
const SmartPtr< T, OP, CP, KP, SP, CNP1 > &  rhs 
) [inline]

operator== for lhs = raw pointer, rhs = SmartPtr

template<typename T , template< class > class OP, class CP , template< class > class KP, template< class > class SP, template< class > class CNP1, typename U >
bool Loki::operator== ( const SmartPtr< T, OP, CP, KP, SP, CNP1 > &  lhs,
U *  rhs 
) [inline]

operator== for lhs = SmartPtr, rhs = raw pointer

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 Loki::operator> ( U *  lhs,
const StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > &  rhs 
) [inline]

operator> for lhs = raw pointer, rhs = StrongPtr

References Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy >::LessThan().

Here is the call graph for this function:

template<typename T , template< class > class OP, class CP , template< class > class KP, template< class > class SP, template< class > class CNP, typename U >
bool Loki::operator> ( U *  lhs,
const SmartPtr< T, OP, CP, KP, SP, CNP > &  rhs 
) [inline]

operator> for lhs = raw pointer, rhs = SmartPtr

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 Loki::operator>= ( U *  lhs,
const StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > &  rhs 
) [inline]

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 Loki::operator>= ( const StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > &  lhs,
U *  rhs 
) [inline]

operator>= for lhs = StrongPtr, rhs = raw pointer

References Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy >::LessThan().

Here is the call graph for this function:

template<typename T , template< class > class OP, class CP , template< class > class KP, template< class > class SP, template< class > class CNP, typename U >
bool Loki::operator>= ( U *  lhs,
const SmartPtr< T, OP, CP, KP, SP, CNP > &  rhs 
) [inline]

operator>= for lhs = raw pointer, rhs = SmartPtr

template<typename T , template< class > class OP, class CP , template< class > class KP, template< class > class SP, template< class > class CNP, typename U >
bool Loki::operator>= ( const SmartPtr< T, OP, CP, KP, SP, CNP > &  lhs,
U *  rhs 
) [inline]

operator>= for lhs = SmartPtr, rhs = raw pointer


Generated on Thu Jan 29 18:51:41 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00056_4df95a9324de31f05d931f2eea25165e_cgraph.dot0000755000175000017500000000220111140366262023600 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node1 [label="Loki::FixedAllocator::TrimEmptyChunk",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1 -> Node2 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::FixedAllocator::CountEmptyChunks",height=0.2,width=0.4,color="black",URL="$a00056.html#e74cbab50e78bfa115d7c0fcdce00641"]; Node2 -> Node3 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node3 [label="Loki::Chunk::HasAvailable",height=0.2,width=0.4,color="black",URL="$a00025.html#0874a711145788bd8c5265a9de2a4aac"]; Node1 -> Node3 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node1 -> Node4 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node4 [label="Loki::Chunk::Release",height=0.2,width=0.4,color="black",URL="$a00025.html#6b011a6b92135a9c5d636b104ffd71bd",tooltip="Releases the allocated block of memory."]; } libloki-0.1.7.orig/doc/html/a00056_4df95a9324de31f05d931f2eea25165e_cgraph.md50000755000175000017500000000004011140366262023476 0ustar ivanivan3172ab250df309f45957a8a89d6346cblibloki-0.1.7.orig/doc/html/a00056_c29973a11534fb1006fd28db97a17bed_cgraph.dot0000755000175000017500000000277511140366261023611 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node1 [label="Loki::FixedAllocator::Allocate",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1 -> Node2 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::Chunk::Allocate",height=0.2,width=0.4,color="black",URL="$a00025.html#c3cbcf98897008278a7616c152565810"]; Node1 -> Node3 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node3 [label="Loki::FixedAllocator::CountEmptyChunks",height=0.2,width=0.4,color="black",URL="$a00056.html#e74cbab50e78bfa115d7c0fcdce00641"]; Node3 -> Node4 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node4 [label="Loki::Chunk::HasAvailable",height=0.2,width=0.4,color="black",URL="$a00025.html#0874a711145788bd8c5265a9de2a4aac"]; Node1 -> Node4 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node1 -> Node5 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node5 [label="Loki::Chunk::IsCorrupt",height=0.2,width=0.4,color="black",URL="$a00025.html#245b6450d855d8ab65e9ca7add3e2071"]; Node1 -> Node6 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node6 [label="Loki::Chunk::IsFilled",height=0.2,width=0.4,color="black",URL="$a00025.html#b70f5bce5a057032bdb5911916e9131d"]; } libloki-0.1.7.orig/doc/html/a00056_c29973a11534fb1006fd28db97a17bed_cgraph.md50000755000175000017500000000004011140366261023467 0ustar ivanivan6f68c999b288d87da017841718fd56d6libloki-0.1.7.orig/doc/html/a00287.html0000755000175000017500000000363311140366256016013 0ustar ivanivan Loki: Member List

Loki::AlwaysCreate Member List

This is the complete list of members for Loki::AlwaysCreate, including all inherited members.


Generated on Thu Jan 29 18:51:42 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00031.html0000755000175000017500000000522211140366260015765 0ustar ivanivan Loki: Loki::CreateUsing< Alloc > Struct Template Reference

Loki::CreateUsing< Alloc > Struct Template Reference
[Creation policies]

#include <Singleton.h>


Detailed Description

template<template< class > class Alloc>
struct Loki::CreateUsing< Alloc >

Implementation of the CreationPolicy used by SingletonHolder Creates objects using a custom allocater. Usage: e.g. CreateUsing<std::allocator>::Allocator
The documentation for this struct was generated from the following file:
  • Singleton.h

Generated on Thu Jan 29 18:51:44 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00346.html0000755000175000017500000000372711140366257016014 0ustar ivanivan Loki: Member List

Loki::UnRegisterOnDeleteSet< ElementList > Member List

This is the complete list of members for Loki::UnRegisterOnDeleteSet< ElementList >, including all inherited members.


Generated on Thu Jan 29 18:51:43 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00405.html0000755000175000017500000001101011140366261015763 0ustar ivanivan Loki: Member List

Loki::SmallValueObject< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > Member List

This is the complete list of members for Loki::SmallValueObject< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >, including all inherited members.

ObjAllocatorSingleton typedefLoki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >
operator delete(void *p, std::size_t size)Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > [inline, static]
operator delete(void *p, const std::nothrow_t &)Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > [inline, static]
operator delete(void *p, void *place)Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > [inline, static]
operator new(std::size_t size)Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > [inline, static]
operator new(std::size_t size, const std::nothrow_t &)Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > [inline, static]
operator new(std::size_t size, void *place)Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > [inline, static]


Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00192_ed0bb857431a808474a4b817d5c37f1c_cgraph.dot0000755000175000017500000000213511140366255023526 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node1 [label="Loki::CountMutexesInCurrentThread",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1 -> Node2 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::LevelMutexInfo::GetCurrentMutex",height=0.2,width=0.4,color="black",URL="$a00071.html#b7fd94847721b118979b72121472d3e2"]; Node2 -> Node3 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node3 [label="Loki::LevelMutexInfo::IsValidList",height=0.2,width=0.4,color="black",URL="$a00071.html#01f6dfba5d2ea5606109b34e5a543cf0"]; Node1 -> Node4 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node4 [label="Loki::LevelMutexInfo::GetPrevious",height=0.2,width=0.4,color="black",URL="$a00071.html#b774e94ff72724dd87ff236d99970bb5",tooltip="Returns pointer to mutex previously locked by the thread which locked this."]; } libloki-0.1.7.orig/doc/html/a00192_ed0bb857431a808474a4b817d5c37f1c_cgraph.md50000755000175000017500000000004011140366255023416 0ustar ivanivan8a83116137986cee70dde1e1e2bcb177libloki-0.1.7.orig/doc/html/a00219.html0000755000175000017500000000604311140366255016003 0ustar ivanivan Loki: Ownership policies

Ownership policies
[Smart pointers]

Collaboration diagram for Ownership policies:

Classes

class  Loki::RefCounted< P >
struct  RefCountedMT
class  Loki::COMRefCounted< P >
struct  Loki::DeepCopy< P >
class  Loki::RefLinked< P >
class  Loki::DestructiveCopy< P >
class  Loki::NoCopy< P >

Generated on Thu Jan 29 18:51:41 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00288.html0000755000175000017500000000365111140366256016014 0ustar ivanivan Loki: Member List

Loki::RateLimitedCreation Member List

This is the complete list of members for Loki::RateLimitedCreation, including all inherited members.


Generated on Thu Jan 29 18:51:42 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00032.html0000755000175000017500000000526611140366260015776 0ustar ivanivan Loki: Loki::CreateUsingMalloc< T > Struct Template Reference

Loki::CreateUsingMalloc< T > Struct Template Reference
[Creation policies]

#include <Singleton.h>

List of all members.


Detailed Description

template<class T>
struct Loki::CreateUsingMalloc< T >

Implementation of the CreationPolicy used by SingletonHolder Creates objects using a call to std::malloc, followed by a call to the placement new operator
The documentation for this struct was generated from the following file:
  • Singleton.h

Generated on Thu Jan 29 18:51:44 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00347.html0000755000175000017500000001141411140366257016005 0ustar ivanivan Loki: Member List

Loki::SafeBitConst< unique_index, word_t > Member List

This is the complete list of members for Loki::SafeBitConst< unique_index, word_t >, including all inherited members.

bit_word_t typedefLoki::SafeBitConst< unique_index, word_t >
field_t typedefLoki::SafeBitConst< unique_index, word_t >
operator<<(unsigned int s) const Loki::SafeBitConst< unique_index, word_t > [inline]
operator==(const SafeBitConst &rhs) const Loki::SafeBitConst< unique_index, word_t > [inline]
operator==(const field_t &rhs) const Loki::SafeBitConst< unique_index, word_t > [inline]
operator|(const SafeBitConst &rhs) const Loki::SafeBitConst< unique_index, word_t > [inline]
operator|(const field_t &rhs) const Loki::SafeBitConst< unique_index, word_t > [inline]
SafeBitConst()Loki::SafeBitConst< unique_index, word_t > [inline]
SafeBitConst(const SafeBitConst &rhs)Loki::SafeBitConst< unique_index, word_t > [inline]
SafeBitField< unique_index, word_t > classLoki::SafeBitConst< unique_index, word_t > [friend]
size()Loki::SafeBitConst< unique_index, word_t > [inline, static]


Generated on Thu Jan 29 18:51:43 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/ftv2lastnode.png0000755000175000017500000000035111140366263017415 0ustar ivanivan‰PNG  IHDRLƒ1ู0PLTE€€€ำ tRNS@ๆุftEXtSoftwaregif2png 2.4.2ฃ^G&tEXtCommentUlead GIF SmartSaver Ver 2.0io?อIDATxฺc`0ภO ศ3$งˆส3=IENDฎB`‚libloki-0.1.7.orig/doc/html/a00406.html0000755000175000017500000000541111140366261015774 0ustar ivanivan Loki: Member List

Loki::HeapStorage< T > Member List

This is the complete list of members for Loki::HeapStorage< T >, including all inherited members.

HeapStorage()Loki::HeapStorage< T > [inline]
InitPointerType typedefLoki::HeapStorage< T >
PointerType typedefLoki::HeapStorage< T >
ReferenceType typedefLoki::HeapStorage< T >


Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00289.html0000755000175000017500000000365511140366256016021 0ustar ivanivan Loki: Member List

Loki::AmountLimitedCreation Member List

This is the complete list of members for Loki::AmountLimitedCreation, including all inherited members.


Generated on Thu Jan 29 18:51:42 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00033.html0000755000175000017500000000520311140366260015766 0ustar ivanivan Loki: Loki::CreateUsingNew< T > Struct Template Reference

Loki::CreateUsingNew< T > Struct Template Reference
[Creation policies]

#include <Singleton.h>

List of all members.


Detailed Description

template<class T>
struct Loki::CreateUsingNew< T >

Implementation of the CreationPolicy used by SingletonHolder Creates objects using a straight call to the new operator
The documentation for this struct was generated from the following file:
  • Singleton.h

Generated on Thu Jan 29 18:51:44 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00407.html0000755000175000017500000000421711140366261016000 0ustar ivanivan Loki: Member List

Loki::DefaultSPStorage< T > Member List

This is the complete list of members for Loki::DefaultSPStorage< T >, including all inherited members.

PointerType typedefLoki::DefaultSPStorage< T >


Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00220.html0000755000175000017500000000560311140366255015774 0ustar ivanivan Loki: Storage policies

Storage policies
[Smart pointers]

Collaboration diagram for Storage policies:

Classes

class  Loki::HeapStorage< T >
class  Loki::DefaultSPStorage< T >
class  Loki::LockedStorage< T >
class  Loki::ArrayStorage< T >
class  Loki::FunctionStorage< T >
 Implementation of the StoragePolicy used by SmartPtr. More...

Generated on Thu Jan 29 18:51:41 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00034.html0000755000175000017500000000611511140366261015773 0ustar ivanivan Loki: Loki::CyclicVisitor< R, TList > Class Template Reference

Loki::CyclicVisitor< R, TList > Class Template Reference
[Visitor]

#include <Visitor.h>

Inheritance diagram for Loki::CyclicVisitor< R, TList >:
Collaboration diagram for Loki::CyclicVisitor< R, TList >:

List of all members.


Detailed Description

template<typename R, class TList>
class Loki::CyclicVisitor< R, TList >

Put it in every class that you want to make visitable (in addition to deriving it from BaseVisitable<R>
The documentation for this class was generated from the following file:
  • Visitor.h

Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00349.html0000755000175000017500000000427111140366257016012 0ustar ivanivan Loki: Member List

Loki::ScopeGuardImplBase Member List

This is the complete list of members for Loki::ScopeGuardImplBase, including all inherited members.

ScopeGuardImplBase(const ScopeGuardImplBase &other)Loki::ScopeGuardImplBase [inline, protected]


Generated on Thu Jan 29 18:51:43 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00408.html0000755000175000017500000000542711140366261016005 0ustar ivanivan Loki: Member List

Loki::LockedStorage< T > Member List

This is the complete list of members for Loki::LockedStorage< T >, including all inherited members.

InitPointerType typedefLoki::LockedStorage< T >
LockedStorage()Loki::LockedStorage< T > [inline]
PointerType typedefLoki::LockedStorage< T >
ReferenceType typedefLoki::LockedStorage< T >


Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00221.html0000755000175000017500000000412711140366255015775 0ustar ivanivan Loki: Conversion policies

Conversion policies
[Smart pointers]

Collaboration diagram for Conversion policies:

Classes

struct  Loki::AllowConversion
struct  Loki::DisallowConversion

Generated on Thu Jan 29 18:51:41 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00290.html0000755000175000017500000000366311140366256016010 0ustar ivanivan Loki: Member List

Loki::EvictLRU< DT, ST > Member List

This is the complete list of members for Loki::EvictLRU< DT, ST >, including all inherited members.


Generated on Thu Jan 29 18:51:42 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00035.html0000755000175000017500000000520711140366261015775 0ustar ivanivan Loki: Loki::DeepCopy< P > Struct Template Reference

Loki::DeepCopy< P > Struct Template Reference
[Ownership policies]

#include <SmartPtr.h>

List of all members.


Detailed Description

template<class P>
struct Loki::DeepCopy< P >

Implementation of the OwnershipPolicy used by SmartPtr Implements deep copy semantics, assumes existence of a Clone() member function of the pointee type
The documentation for this struct was generated from the following file:
  • SmartPtr.h

Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00409.html0000755000175000017500000000420311140366261015775 0ustar ivanivan Loki: Member List

Loki::ArrayStorage< T > Member List

This is the complete list of members for Loki::ArrayStorage< T >, including all inherited members.

PointerType typedefLoki::ArrayStorage< T >


Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00222.html0000755000175000017500000000557711140366255016010 0ustar ivanivan Loki: Checking policies

Checking policies
[Smart pointers]

Collaboration diagram for Checking policies:

Classes

struct  Loki::NoCheck< P >
struct  Loki::AssertCheck< P >
struct  Loki::AssertCheckStrict< P >
struct  Loki::RejectNullStatic< P >
struct  Loki::RejectNull< P >
struct  Loki::RejectNullStrict< P >

Generated on Thu Jan 29 18:51:41 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00291.html0000755000175000017500000000366711140366256016015 0ustar ivanivan Loki: Member List

Loki::EvictAging< DT, ST > Member List

This is the complete list of members for Loki::EvictAging< DT, ST >, including all inherited members.


Generated on Thu Jan 29 18:51:42 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00036.html0000755000175000017500000000536611140366256016010 0ustar ivanivan Loki: Loki::DefaultFactoryError< IdentifierType, AbstractProduct > Class Template Reference

Loki::DefaultFactoryError< IdentifierType, AbstractProduct > Class Template Reference
[Factory Error Policies]

Default policy that throws an exception. More...

#include <Factory.h>

List of all members.


Detailed Description

template<typename IdentifierType, class AbstractProduct>
class Loki::DefaultFactoryError< IdentifierType, AbstractProduct >

Default policy that throws an exception.
The documentation for this class was generated from the following file:
  • Factory.h

Generated on Thu Jan 29 18:51:42 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00127_3d40b34b1a2d08a6bb9d9fa22ab5ce24_cgraph.dot0000755000175000017500000000106111140366260023765 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node1 [label="Loki::SmallObjAllocator::SmallObjAllocator",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1 -> Node2 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::GetOffset",height=0.2,width=0.4,color="black",URL="$a00217.html#g2f0821e243f812a3ae2abfaea51895e8"]; } libloki-0.1.7.orig/doc/html/a00127_3d40b34b1a2d08a6bb9d9fa22ab5ce24_cgraph.md50000755000175000017500000000004011140366260023660 0ustar ivanivan24338cb20476523692ca637f901842fblibloki-0.1.7.orig/doc/html/a00223.html0000755000175000017500000001516111140366255015777 0ustar ivanivan Loki: StrongPtr Ownership policies

StrongPtr Ownership policies
[Smart pointers]

Collaboration diagram for StrongPtr Ownership policies:

Classes

class  Loki::Private::TwoRefCountInfo
class  LockableTwoRefCountInfo
class  Loki::TwoRefCounts
class  LockableTwoRefCounts
class  Loki::TwoRefLinks

Detailed Description

Terminology
These terms are used within this file's comments.
  1. StrongPtr : Class used to implement both strong and weak pointers. The second template parameter determines if a StrongPtr is weak or strong.
  2. Strong pointer : A pointer that claims ownership of a shared object. When the last strong copointer dies, the object is destroyed even if there are weak copointers.
  3. Weak pointer : A pointer that does not own the shared object it points to. It only destroys the shared object if there no strong copointers exist when it dies.
  4. Copointers : All the pointers that refer to the same shared object. The copointers must have the same ownership policy, but the other policies may be different.
  5. Pointee : The shared object.
OwnershipPolicy
The ownership policy has the pointer to the actual object, and it also keeps track of the strong and weak copointers so that it can know if any strong copointers remain. The plain pointer it maintains is stored as a void pointer, which allows the ownership policy classes to be monolithic classes instead of template classes. As monolithic classes, they reduce amount of code-bloat.
Writing Your Own OwnershipPolicy
If you write your own policy, you must implement these 12 functions:
  1. explicit YourPolicy( bool strong )
  2. YourPolicy( void * p, bool strong )
  3. YourPolicy( const YourPolicy & rhs, bool strong )
  4. bool Release( bool strong )
  5. void Increment( bool strong )
  6. bool Decrement( bool strong )
  7. bool HasStrongPointer( void ) const
  8. void Swap( YourPolicy & rhs )
  9. void SetPointer( void * p )
  10. void ZapPointer( void )
  11. void * GetPointer( void ) const
  12. void * & GetPointerRef( void ) const It is strongly recommended that all 12 of these functions be protected instead of public. These two functions are optional for single-threaded policies, but required for multi-threaded policies:
  13. void Lock( void ) const
  14. void Unlock( void ) const This function is entirely optional:
  15. bool Merge( TwoRefLinks & rhs )
DeletePolicy
The delete policy provides a mechanism to destroy an object and a default value for an uninitialized pointer. You can override this policy with your own when using the Singleton, NullObject, or Prototype design patterns.
Writing Your Own DeletePolicy
If you write your own policy, you must implement these 3 functions:
  1. void static Delete( const P * p )
  2. static P * Default( void )
  3. void Swap( YourResetPolicy & )
ResetPolicy
A reset policy tells the ReleaseAll and ResetAll functions whether they should release or reset the StrongPtr copointers. These functions do not affect just one StrongPtr, but all copointers. That is unlike SmartPtr where the Release and Reset functions only affect 1 SmartPtr, and leave all copointers untouched. A useful trick you can do with the ResetPolicy is to not allow reset when a strong pointer exists, and then use the NoCheck policy for all strong pointers. The reset policy guarantees the strong pointers always have a valid pointee, so checking is not required; but weak pointers may still require checking.
Writing Your Own ResetPolicy
If you write your own policy, you must implement these 2 functions:
  1. bool OnReleaseAll( bool ) const
  2. bool OnResetAll( bool ) const The bool parameter means that this was called with a strong pointer or one of its copointers is strong. The return value means the pointer can be reset or released.

Generated on Thu Jan 29 18:51:41 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00292.html0000755000175000017500000000367111140366256016011 0ustar ivanivan Loki: Member List

Loki::EvictRandom< DT, ST > Member List

This is the complete list of members for Loki::EvictRandom< DT, ST >, including all inherited members.


Generated on Thu Jan 29 18:51:42 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00037.html0000755000175000017500000000523111140366260015773 0ustar ivanivan Loki: Loki::DefaultLifetime< T > Struct Template Reference

Loki::DefaultLifetime< T > Struct Template Reference
[Lifetime policies]

#include <Singleton.h>

List of all members.


Detailed Description

template<class T>
struct Loki::DefaultLifetime< T >

Implementation of the LifetimePolicy used by SingletonHolder Schedules an object's destruction as per C++ rules Forwards to std::atexit
The documentation for this struct was generated from the following file:
  • Singleton.h

Generated on Thu Jan 29 18:51:44 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00410.html0000755000175000017500000000365511140366261015777 0ustar ivanivan Loki: Member List

Loki::RefCounted< P > Member List

This is the complete list of members for Loki::RefCounted< P >, including all inherited members.


Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00224.html0000755000175000017500000000474511140366255016006 0ustar ivanivan Loki: Delete policies

Delete policies
[Smart pointers]

Collaboration diagram for Delete policies:

Classes

class  Loki::DeleteUsingFree< P >
class  Loki::DeleteNothing< P >
class  Loki::DeleteSingle< P >
class  Loki::DeleteArray< P >

Generated on Thu Jan 29 18:51:41 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00293.html0000755000175000017500000000364511140366256016013 0ustar ivanivan Loki: Member List

Loki::NoStatisticPolicy Member List

This is the complete list of members for Loki::NoStatisticPolicy, including all inherited members.


Generated on Thu Jan 29 18:51:42 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00038.html0000755000175000017500000000617011140366261016000 0ustar ivanivan Loki: Loki::DefaultSPStorage< T > Class Template Reference

Loki::DefaultSPStorage< T > Class Template Reference
[Storage policies]

#include <SmartPtr.h>

List of all members.

Public Types

typedef T * PointerType
 type used to declare OwnershipPolicy type.


Detailed Description

template<class T>
class Loki::DefaultSPStorage< T >

Implementation of the StoragePolicy used by SmartPtr
The documentation for this class was generated from the following file:
  • SmartPtr.h

Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00352.html0000755000175000017500000000431111140366260015771 0ustar ivanivan Loki: Member List

Loki::ScopeGuardImpl0< F > Member List

This is the complete list of members for Loki::ScopeGuardImpl0< F >, including all inherited members.

ScopeGuardImplBase(const ScopeGuardImplBase &other)Loki::ScopeGuardImplBase [inline, protected]


Generated on Thu Jan 29 18:51:44 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00411.html0000755000175000017500000000366311140366261015777 0ustar ivanivan Loki: Member List

Loki::COMRefCounted< P > Member List

This is the complete list of members for Loki::COMRefCounted< P >, including all inherited members.


Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00225.html0000755000175000017500000000443411140366255016002 0ustar ivanivan Loki: Reset policies

Reset policies
[Smart pointers]

Collaboration diagram for Reset policies:

Classes

class  Loki::CantResetWithStrong< P >
class  Loki::AllowReset< P >
class  Loki::NeverReset< P >

Generated on Thu Jan 29 18:51:41 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00192_d633ca81ae0befaf235ae63886368037_cgraph.dot0000755000175000017500000000512511140366255023611 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node1 [label="Loki::DoMutexesMatchContainer",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1 -> Node2 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::CountMutexesAtCurrentLevel",height=0.2,width=0.4,color="black",URL="$a00192.html#8cb767d3e7aaf2fe44b8f3b90218b876"]; Node2 -> Node3 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node3 [label="Loki::LevelMutexInfo::GetCurrentMutex",height=0.2,width=0.4,color="black",URL="$a00071.html#b7fd94847721b118979b72121472d3e2"]; Node3 -> Node4 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node4 [label="Loki::LevelMutexInfo::IsValidList",height=0.2,width=0.4,color="black",URL="$a00071.html#01f6dfba5d2ea5606109b34e5a543cf0"]; Node2 -> Node5 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node5 [label="Loki::LevelMutexInfo::GetLevel",height=0.2,width=0.4,color="black",URL="$a00071.html#1cad7c6b6fc50e230401e4cc22761d14",tooltip="Returns the level of this mutex."]; Node2 -> Node6 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node6 [label="Loki::LevelMutexInfo::GetPrevious",height=0.2,width=0.4,color="black",URL="$a00071.html#b774e94ff72724dd87ff236d99970bb5",tooltip="Returns pointer to mutex previously locked by the thread which locked this."]; Node1 -> Node7 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node7 [label="Loki::GetCurrentThreadsLevel",height=0.2,width=0.4,color="black",URL="$a00192.html#9548795d9cda6f227a1e1241ba577ca8"]; Node7 -> Node3 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node7 -> Node5 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node1 -> Node5 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node1 -> Node8 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node8 [label="Loki::LevelMutexInfo::IsRecentLock",height=0.2,width=0.4,color="black",URL="$a00071.html#b917108c3e7c83b8a515d28e91a3a3ca"]; Node8 -> Node9 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node9 [label="Loki::LevelMutexInfo::IsValid",height=0.2,width=0.4,color="black",URL="$a00071.html#36c34ecf5d019f3db9bfb8654cf49176"]; Node9 -> Node4 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; } libloki-0.1.7.orig/doc/html/a00192_d633ca81ae0befaf235ae63886368037_cgraph.md50000755000175000017500000000004011140366255023477 0ustar ivanivan6be06a78b45d90480a862c18b4d8bcd8libloki-0.1.7.orig/doc/html/a00294.html0000755000175000017500000000365511140366256016015 0ustar ivanivan Loki: Member List

Loki::SimpleStatisticPolicy Member List

This is the complete list of members for Loki::SimpleStatisticPolicy, including all inherited members.


Generated on Thu Jan 29 18:51:42 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00039.html0000755000175000017500000000716211140366260016002 0ustar ivanivan Loki: Loki::DeletableSingleton< T > Struct Template Reference

Loki::DeletableSingleton< T > Struct Template Reference
[Lifetime policies]

#include <Singleton.h>

List of all members.

Static Public Member Functions

static void GracefulDelete ()
 delete singleton object manually


Detailed Description

template<class T>
struct Loki::DeletableSingleton< T >

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.

Usage:
The singleton can be deleted manually:
DeletableSingleton<MyClass>::GracefulDelete();
The documentation for this struct was generated from the following file:
  • Singleton.h

Generated on Thu Jan 29 18:51:44 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00412.html0000755000175000017500000000365111140366261015775 0ustar ivanivan Loki: Member List

Loki::DeepCopy< P > Member List

This is the complete list of members for Loki::DeepCopy< P >, including all inherited members.


Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00226.html0000755000175000017500000000634611140366255016007 0ustar ivanivan Loki: Threading

Threading


Classes

class  Loki::Mutex
class  Loki::SingleThreaded< Host, MutexPolicy >

Detailed Description

Policies to for the threading model:

  • SingleThreaded
  • ObjectLevelLockable
  • ClassLevelLockable

All classes in Loki have configurable threading model.

The macro LOKI_DEFAULT_THREADING selects the default threading model for certain components of Loki (it affects only default template arguments)

Usage:
To use a specific threading model define

  • nothing, single-theading is default
  • LOKI_OBJECT_LEVEL_THREADING for object-level-threading
  • LOKI_CLASS_LEVEL_THREADING for class-level-threading

Supported platfroms:

Generated on Thu Jan 29 18:51:41 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00295.html0000755000175000017500000000654711140366256016021 0ustar ivanivan Loki: Member List
Generated on Thu Jan 29 18:51:42 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00413.html0000755000175000017500000000365311140366261016000 0ustar ivanivan Loki: Member List

Loki::RefLinked< P > Member List

This is the complete list of members for Loki::RefLinked< P >, including all inherited members.


Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00227.html0000755000175000017500000001333111140366255016000 0ustar ivanivan Loki: Visitor

Visitor


Classes

class  Loki::BaseVisitor
class  Visitor
class  Loki::CyclicVisitor< R, TList >

Defines

#define LOKI_DEFINE_VISITABLE()
#define LOKI_DEFINE_CONST_VISITABLE()
#define LOKI_DEFINE_CYCLIC_VISITABLE(SomeVisitor)

Define Documentation

 
#define LOKI_DEFINE_CONST_VISITABLE (  ) 

Value:

virtual ReturnType Accept(::Loki::BaseVisitor& guest) const \
    { return AcceptImpl(*this, guest); }
Put it in every class that you want to make visitable by const member functions (in addition to deriving it from BaseVisitable<R>)

#define LOKI_DEFINE_CYCLIC_VISITABLE ( SomeVisitor   ) 

Value:

virtual SomeVisitor::ReturnType Accept(SomeVisitor& guest) \
    { return guest.GenericVisit(*this); }
Put it in every class that you want to make visitable by a cyclic visitor

 
#define LOKI_DEFINE_VISITABLE (  ) 

Value:

virtual ReturnType Accept(::Loki::BaseVisitor& guest) \
    { return AcceptImpl(*this, guest); }
Put it in every class that you want to make visitable (in addition to deriving it from BaseVisitable<R>)


Generated on Thu Jan 29 18:51:41 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00296.html0000755000175000017500000000367511140366256016021 0ustar ivanivan Loki: Member List

Loki::CheckForNoThrow< Host > Member List

This is the complete list of members for Loki::CheckForNoThrow< Host >, including all inherited members.


Generated on Thu Jan 29 18:51:42 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00040.html0000755000175000017500000001000411140366261015760 0ustar ivanivan Loki: Loki::DeleteArray< P > Class Template Reference

Loki::DeleteArray< P > Class Template Reference
[Delete policies]

#include <StrongPtr.h>

List of all members.

Static Public Member Functions

static void Delete (const P *p)


Detailed Description

template<class P>
class Loki::DeleteArray< P >

Implementation of the DeletePolicy used by StrongPtr. This deletes an array of shared objects.

Member Function Documentation

template<class P >
static void Loki::DeleteArray< P >::Delete ( const P *  p  )  [inline, static]

Note:
If you see an error message about a negative subscript, that means your are attempting to use Loki to delete an incomplete type. Please don't use this policy with incomplete types; you may want to use DeleteNothing instead.


The documentation for this class was generated from the following file:
  • StrongPtr.h

Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00355.html0000755000175000017500000000432111140366260015775 0ustar ivanivan Loki: Member List

Loki::ScopeGuardImpl1< F, P1 > Member List

This is the complete list of members for Loki::ScopeGuardImpl1< F, P1 >, including all inherited members.

ScopeGuardImplBase(const ScopeGuardImplBase &other)Loki::ScopeGuardImplBase [inline, protected]


Generated on Thu Jan 29 18:51:44 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00414.html0000755000175000017500000000366711140366261016006 0ustar ivanivan Loki: Member List

Loki::DestructiveCopy< P > Member List

This is the complete list of members for Loki::DestructiveCopy< P >, including all inherited members.


Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00297.html0000755000175000017500000000367711140366256016024 0ustar ivanivan Loki: Member List

Loki::CheckForNoChange< Host > Member List

This is the complete list of members for Loki::CheckForNoChange< Host >, including all inherited members.


Generated on Thu Jan 29 18:51:42 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00041.html0000755000175000017500000000531211140366261015767 0ustar ivanivan Loki: Loki::DeleteNothing< P > Class Template Reference

Loki::DeleteNothing< P > Class Template Reference
[Delete policies]

#include <StrongPtr.h>

List of all members.


Detailed Description

template<class P>
class Loki::DeleteNothing< P >

Implementation of the DeletePolicy used by StrongPtr. This will never delete anything. You can use this policy with pointers to an undefined type or a pure interface class with a protected destructor.
The documentation for this class was generated from the following file:
  • StrongPtr.h

Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00100.html0000755000175000017500000000471411140366256015774 0ustar ivanivan Loki: Loki::PropagateConst< T > Class Template Reference

Loki::PropagateConst< T > Class Template Reference

#include <ConstPolicy.h>

List of all members.


Detailed Description

template<class T>
class Loki::PropagateConst< T >

Propagate constness of pointed or referred object.
The documentation for this class was generated from the following file:
  • ConstPolicy.h

Generated on Thu Jan 29 18:51:42 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00415.html0000755000175000017500000000364511140366261016003 0ustar ivanivan Loki: Member List

Loki::NoCopy< P > Member List

This is the complete list of members for Loki::NoCopy< P >, including all inherited members.


Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/search.idx0000755000175000017500000152514011140366263016260 0ustar ivanivanDOXSHZt†ฐ๛+?Sd}ˆ !,=FSฎH“-VPœๅ๖O9‚ฃผะ V ๅ ‚ ศ ( J ‰ ฐ น  !K]bdmีDlu”พศxŠ”ืเ๕$0;lฌ > W ‹ › ค!)"ต#W#…$H$d%ฝ%ะ&&ž&ถ(D(b(n((฿()š)*w*ภ*ส++++M+๛/*/์000?0g0{0ท22%2ูQQQ)RxSIS™TTU‹UูU๊V VถX XTXgY…YจYลYฯYฺZX[น[ไ\\+\’\ํ]ง^?^U^l^ณ` b5b]bœbธcgฒgปgฦgาhhฃi]jjๆlกl๛m้n&oQqอrbrฌrืrเrt˜vzvกvรwwšwโxUxcxrzฦzื{L{Z{๒||Š|ฐ}7}S}ฏ~~2~r~}?Ib‰žๆ€"€’"bool host::isvalid( void ) const;"€จ"bool isokay( void );"€ด"containers"€ภ"design by contract"€ฬ"expressions€ุ"long to construct/destruct objects"€ไ"race condition in refcountedmtadj::release"€๐"run"€"recently""static bool host::staticisvalid( void );""thread_local" "unknown type",'blocksize'8'longevitylifetime'D*not*P/////////////////////////////////////////////////////////////////////////////\0xffffffffp0xffffffff-1|10ˆ12œ1408845จ15ด2.theภ4294967295uฬ7.1ุไabstract๐about‚ abstractproduct‚pabstractfactory‚|abrahams‚ˆabilities‚”actual‚ acting‚ฤacyclic‚ะactions‚ไaccessedƒ0actsƒ‰alwayscreate‰่algorithm‰๔allocatedŠalternativelyŠLalongŠXalreadylockedŠlallocationsŠ€althoughŠœallowedŠฐallocaterŠผalignmentŠศallocatorsingletonŠallocatesŠ๘almost‹allocatorsingleto::clearextramemory‹(allocatorsingleton's‹4allowconversion‹@allowreset‹Tallocator's‹`allocating‹lallocchunk_‹xamong‹„amount‹˜amountlimitedcreation‹ิamenities‹เambiguity‹์andŒ anTany‘ะanother“”anyway”anything”$andrei's”`application”lare”€arguments•ดarray•ะargument-•์article•๘arraystorage–argument–assigns–$as–0ask—tassumes—€assert—œassessing—่asserts—๔assertions˜Passociated˜\assertion˜xassertanymutexerror˜„assertbaddesignmutexerror˜asmasterlifetime˜œassertcheck˜จassertcheckstrict˜ฬat˜เattempt™ฌattemptsšattemptingš4attentionšPatexitš\automatedšhautomaticallyštavoidšˆavailablešดawarešเawayš๔bad›based›$basevisitable›0basically›Lbasic›`back›lbase›€bad_alloc›ิbad_function_call›เbasevisitor›์besides›๘beœ before`behavesไbetween๐beenž becausež(betterž|bestžbehavioržดbehaviorsžศbelowžิbeingžเbindfirstž์bindsŸbiggerŸbinderfirstŸ bit_word_tŸ,bitŸ8bitwiseŸ|bit-fieldŸbit-constŸคbitsŸฐbit-fieldsŸฤbit-constantsŸะblocksŸblock  blocking |blocksavailable_ blocksize œbook จboth ดbool ๘boost/tr1ก boostกbodyก$boxก0boundariesก::allocatorร˜createusingmallocรคcreatestaticรฐcrashรผcurrentรศcurrentlyฤ4cujฤPcustomฤ\customizeฤhcyclicฤtcyclesฤ€cycleฤœcyclicvisitorฤฐdataฤผdata"ลHdatumลTdavidล`dbyลldefinesลxdestructionลฤdebuggingล๘determineฦdesignฦ0dealsฦldefiningฦxderivedฦคdeclarationฦุdeclareฦdefaultวHdestructionsศDdefaultallocatorศPdefaultdeallocatorศddecidesศxdeallocatorศ”deleteศจdeterminesษ$destroyedษxdestroysษœdecrement( bool strong )ษธdeletepolicyษฤdestroyษ๘delete( const p * p )สdefault( void )ส defineส,deadlocksสXderivingสldetailสˆdetailsสœdesignedสธdestructorสิdefinedห dependenciesหดdependหเdependentห์dependsห๘dependencyฬdeallocateฬ destructฬTdetectฬ`describedฬŒdescribesฬจdependingฬดdemonstrateฬศdebugฬิdeliberatelyอ0defaultfactoryerrorอDdecrementcountอPdecrementedอ\detectedอhdestructsอtdependenceอ˜decreasingอคdeadlockอฐdefaultlevelอผdereferencesอะdeletesอdeprecatedอ๘defaultlifetimeฮdeletablesingletonฮ8deletedฮLdeletablesingleton::gracefuldelete()ฮ`deletablesingleton::gracefuldeleteฮldeathฮxdecideฮ„deallocatesฮdetectsฮคdeallocationsฮธdefaultspstorageฮฬdestructedฮเdeepcopyฮ์deepฮ๘destructivecopyฯdestructiveฯdereferenceฯdeletingฯHdefinitionฯTdeleteusingfreeฯ`deletenothingฯldeletesingleฯˆdeletearrayฯœdeallocchunk_ฯจdifferentฯดdiesฯ่directlyะdisplaycachetypeะHdisplayะTdirectะ`differsะldifferะˆdisregardะ”disabledะ didะฌdismissะศdieะิdisableะเdisallowconversionะ์dielastัdiedirectlybeforelastั$diefirstั0dieassmallobjectparentัเfactory'sเfalseเ failureเฌfailsเภfailedแ,failแ˜fastแคfasterแธfetchedแฤfeaturesแุfewแไfeatureแ๐fileแfirstโfixedallocatorโTfile'sโภfixedโฬfixโเfindโ์findingใfinesseใ fieldใfield_tใ4fieldsใ@fiveใdfixed-sizeใpfixedallocator'sใ„fixed-sizedใภflawใฬflowใุflagใไforใ๐found็ไforums่following่formalized่(force่4forces่@forcing่Lfour่Xfollowed่dforwards่€followintodeath่Œfollowers่ follower่ดfollow่ศfollowintodeath::with::asmasterliftime่ิfollowintodeath::aftermaster::isdestroyed่เfollows่์forced่๘forbids้form้fprintfstderr้$from้0free๊คframework๊ศfriendship๊ิfunctions๊เfunction์functor๎8functor.h๎Œfunctionstorage๎˜functionality๎ฤfunction's๎ุfulfills๎์functors๎๘functortype๏full๏ gathers๏,gather๏@getcurrentthreadslevel๏Lgets๏pgeneric๏๔generally๐ getoffset๐,getpointer( void ) const๐@getpointerref( void ) const๐Lgetlongevity๐Xgeneralized๐lgetlevel๐xgetlockcount๐Œgetprevious๐˜getcurrentmutex๐คget๐ฐge๑getmutexpolicy๑getreason๑getmutex๑(getmutexes๑4getlongevity(t*)๑@getter๑Lgetmaxobjectsize๑Xgetalignment๑dgetpointer๑pgives๑Œgive๑จgiven๑ผglobal๑ุgot๑๔going๒gracefuldelete๒greater๒(greaterthan๒4greater-than๒@greater-than-or-equal-to๒Lguarantees๒Xguarantee๒thave๒ฐhas๓ดhandles๔˜handle๔คhandled๕hasstrongpointer( void ) const๕having๕ happen๕ >ะlhslineslimitœlikeภlist์lifetimelifetimes”liveธlinked-listฤlimitedะlibraries์library๘lifetimepolicy line8linkingLlikelyXloki'sdloki::getcurrentthreadslevel€loki::countmutexesincurrentthreadœloki::countlocksincurrentthreadธloki::countmutexesatcurrentlevelิloki::domutexesmatchcontainer๐loki_thread_local locallotsDlokiPloki::bindfirstดloki::chainศloki_check_class_in_listloki::registerfunction่loki::unregisterfunctionloki::byrefloki::setlongevitydloki::factoryxloki::functor„loki::functionlongevityœlongevitylifetimeภloki::getoffsetloki::defaultallocator๐loki::defaultdeallocatorlocatedloki::operator==$loki::operator!=ploki::operator<ผloki::operator>loki::operator<=4loki::operator>=xlock( void ) constผloki_default_threadingศloki_object_level_threadingิloki_class_level_threadingเlock()์loki::mutex๘loki_define_visitableloki_define_const_visitableloki_define_cyclic_visitablelockabletworefcountinfo(lockabletworefcountsเloki::contractchecker< host, ::loki::checkfornochange >์loki::contractchecker< host, ::loki::checkforequality >๘loki::contractchecker< host, ::loki::checkfornothing > look loki::staticchecker::validator $loki::staticchecker::staticchecker 0loki::staticchecker::~staticchecker  Tloki::staticchecker< ::loki::checkfornothing > `loki::checkreturn::checkreturn lloki::checkreturn::~checkreturn €loki::checkreturn::operator value Œlogic_error ˜lockingptr คloki_functor_is_not_a_smallobject ะloki_functors_are_comparable loki::levelmutexinfo::mutexcontainer ่locking ๔loki::levelmutexinfo::getlevel! loki::levelmutexinfo::islocked!,loki::levelmutexinfo::getlockcount!8loki::levelmutexinfo::getprevious!Dloki::levelmutexinfo::trylock!Ploki::levelmutexinfo::lock!\loki::levelmutexinfo::unlock!ploki::levelmutexinfo::isrecentlock!|loki::levelmutexinfo::islockedbycurrentthread!loki::levelmutexinfo::islockedbyanotherthread!œloki::levelmutexinfo::multilock!จloki::levelmutexinfo::multiunlock!ผloki::levelmutexinfo::getcurrentmutex!ศloki::levelmutexinfo::unlockedlevel!ิloki::levelmutexinfo::levelmutexinfo!เloki::levelmutexinfo::~levelmutexinfo!์loki::levelmutexinfo::postlock!๘loki::levelmutexinfo::preunlock"loki::levelmutexinfo::incrementcount"loki::levelmutexinfo::decrementcount"loki::levelmutexinfo::isvalid"(loki::levelmutexinfo::isvalidlist"4loops"@locks"llow-level"ฐloki::spinlevelmutex::spinlevelmutex"ฬloki::spinlevelmutex::~spinlevelmutex"ุloki::sleeplevelmutex::sleeplevelmutex"ไloki::sleeplevelmutex::~sleeplevelmutex"๐loki::sleeplevelmutex::lock"loop#loki::levelmutex::levelmutex#$loki::levelmutex::~levelmutex#0loki::levelmutex::getmutexpolicy#$ฬlockingpolicy$ุlockpair$ไloki::safebitconst::bit_word_t$๐loki::safebitconst::field_t$loki::safebitconst::safebitconst%loki::safebitconst::operator==%loki::safebitconst::operator|%0loki::safebitconst::operator<<%Dloki::safebitconst::size%Ploki::safebitconst::safebitfield< unique_index, word_t >%\loki::scopeguardimplbase::scopeguardimplbase%hloki::deletablesingleton::gracefuldelete%tlongevities%€loki::singletonholder::objecttype%Œloki::singletonholder::instance%˜loki_default_threading_no_obj_level%คloki::smallobjallocator::allocate%ฐloki::smallobjallocator::deallocate%ผloki::smallobjallocator::getmaxobjectsize%ะloki::smallobjallocator::getalignment%loki::smallobjallocator::trimexcessmemory%่loki::smallobjallocator::iscorrupt%๔loki::smallobjallocator::smallobjallocator&loki::smallobjallocator::~smallobjallocator& loki::allocatorsingleton::myallocator&loki::allocatorsingleton::mythreadingmodel&$loki::allocatorsingleton::myallocatorsingleton&0loki::allocatorsingleton::allocatorsingleton&'hlocker'tloki::arraystorage::pointertype'€loki_default_constness'Œloki::functionstorage::storedtype' loki::functionstorage::initpointertype'ฌloki::functionstorage::pointertype'ธloki::functionstorage::referencetype'ฤloki::functionstorage::functortype'ะloki::functionstorage::setcallbackfunction'loki::deleteusingfree::default'่loki::deletesingle::delete'๔loki::deletearray::delete(loki::tworefcounts::~tworefcounts( loki::tworeflinks::merge(loki::strongptr::merge($loki::strongptr::lock(0loki::strongptr::unlock((loki::strongptr::operator<=(œloki::strongptr::operator>=(จlowest(ดloki::fixedallocator::fixedallocator(ภloki::fixedallocator::~fixedallocator(ฬloki::fixedallocator::initialize(ุloki::fixedallocator::allocate(ไloki::fixedallocator::deallocate(๐loki::fixedallocator::blocksize(loki::fixedallocator::trimemptychunk)loki::fixedallocator::trimchunklist)loki::fixedallocator::countemptychunks) loki::fixedallocator::iscorrupt),loki::fixedallocator::hasblock)8longest)Dlru)Pm_checked)dmay)pmanages*,mandatory*Pmain*\matches*hmalloc*|maintains*ˆmacro*ฌmake*ศmanage+4managing+Xmany+tmatch+ธmax_size+ฤmax+ะmaxcreation+์makes,maximum,,matter,@making,Tmarginean's,pmakeguard,|makeobjguard,ะmaxalign,๔manually-master-maxobjectsize-8made-Dmeaning-Xmethod-dmerge( tworeflinks & rhs )-ˆmechanism-”means-ศmember.memory.จmembers/$message/hmerely/Œmeet/จmember-by-member/ดmethods/ศmeant/ิmerge/๐merges0 mimic0miss0$might00mind0Dmilliseconds0Pminimal0|minimum0ˆmodify0”more0ฐmonolithic1model1modified10no-leak>Dno-break>Pnor>\normal>€nomutexwait>Œnotices>˜nonportable>คnodestroy>ฐnon-templated>ฬnon-virtual>ุnothrow>์nothow?none?non-throwing?(nocopy?P€operator<=Pผoperator>=QoptionalQToperatorsQpoperationsQฤoperator valueRoptimizedRoperatingR(operator=R4operator*R@operator->Rdoperator|Rpoperator<<R„operation-assignmentRoperator newRœoperator deleteRธoperator-RิorR๘orderedTิoriginalTเorderTotherUXothersVotherwiseV8outVtoutstandingVˆouterV”overloadV overrideVฌoverallVภoverviewVoverV่overloadsVoverloadedW overheadW,ownW8ownershipWŒownershippolicyWธownsXlownershippolicy-specificXˆownedX”patternXจpatternsXฤparameterXเpayY\parametersYhparticularYparadigmY่passY๔passedZ paragraphsZ,parlanceZ8pagesizeZDpageZPparentZdpainter'sZpperformZ|performanceZˆperformancesZ”per-functionZ per-objectZฌper-classZธperformsZฤpetruZุper-instanceZไper[perhaps[,phoenixsingleton[8pimpl[Lpimplof[xplain[„platfroms[place[œplaces[ศplease[ิplacement[๐policies\ policy\ศpolymorphic^Lpointer^hpointers`|points`่pointeeaposixa8postaDpost-conditionsa`post-conditiona”post-aจpointedaดpostlockaศpolicy-basedaิpossiblea่portableb potentialb(point-operatorb4policyforb@poolbLpoliteb€pointee_bŒpointertypebจpointbิpod-styleb่providesb๔providecฐproposesd$problemd8productsdLproductdXproducesddproductcreatordpproduct*d|preferreddˆprotectedd”prototypedธprogramdฤprivateeproperlye$programse8preventeLprovidedexprogrammerseฌprogrammereภpre-conditionsepre-fpref,primitivef@printsfLprogrammingfXpropagatedfdpropagatefppropagateconstf„problemsfpreviouslyfคpreunlockfศpreviousfิpreventsfเprotectf์propergpropagatinggpropagationg practiceg,priorg8preferedgDpthread.hgPpthreadg\pthreadsghpurposegtpublicgจputgpurposeshputshpureh(quicklyh4qualifiershPrateh\rawh€racei4rasmusi@ratelimitedcreationiLrandomiXratherilraiii€requirei”returnediภresultjdreferj€registrationj”registeringj returnjฌregisterk€registerfunctionkœreftovaluekฐregisteredkฤrequestkเreturningk๔remainlreducel::refcountedmtoreturnso$requirespุrecentlyqTrebindqˆrecentq”removedqจregisteredidsqฤreleaseobjectqะretainqresourcesq่requirementsrregardlessrPremainsr\recompiler€referredr”removesrจrelockrดreachesrะresultsrreasonr๐resouces re-implementsreallys$requirings0reverseswˆsafebitfieldw”safeexecutew sayingwฌsakewธscalablewฤscopeguardimplbasewะscopeguardwไscopeguardimpl0xHscopeguardimpl1xTscopeguardimpl2x`scopeguardimpl3xlscopeguardimpl4xxscopeguardimpl5x„schedulesxsecondsxฌseparatexธseexฬsetlongevityy8sequenceyTsecondy`setpointer( void * p )ytselectsy€setyŒsetrateyุsemanticsy์severalz(settingzlserveszxsearchz„setcallbackfunctionzsetcallbackfunction(const functortype &functor)zœsetszจserviceszดshouldzภshared{Dshow{ฐshort{๔shares|shift| shorter|shlemiel|,shortest|8singleton|Dsize|ศsince}$single-threaded}ศsinglethreaded~single-theading~similarly~$singletonwithlongevity~0simplepointer~\simply~hsimplestatisticpolicy~tsimple~€signature~ฌsimilar~ะsituation~๔singletonholdersinglelsingletonsฐsideฬsingle-objectุsingletonholder::makeinstance€ singly-linked€singletonfixedlongevity€$singletonfixedlongevity< mylifetimenumber ,t>€0sleeplevelmutex€0thisq{ฯ ื๕้เ–?๔LโYuก‚3zސš็Šy์B๊ฅG0+K+K222ZMิeˆoy๗’”๗๗ๆPƒyกิšŒ๓a๙!$rl{ฯฅG[XZer๊“๐ฆ‘8ฮถัฐาู ๆP๚อ`๓–.ƒB๊OMg{ฯ’“๐ ขก!ัฐาื๕ู ฿Gแ#ๆค้ฏ๓a๔-๗Œ 7 0^?๔B๊LโP XจYb#h†i.oyƒyˆ‡‘้’“๐กก.ฅGื๕แ๓a๗8 )$$Ÿ6NM๔Pƒy“๐•ŠฅGฆฯััฐโ๓ฝฌุ$Ÿ2•6NJ"PZIn#{ฯ’กงCแ1๋PTJ‡0์‚๓ฝจP‘้”kฅGัฐู B๊Uฝ{ฯ ัฐ/๛'4N๛b#{ฯ žก…งgา•.+N๛{ฯ“๐gๆ!ๅu4’šŒ/4‰{ฯ‘้’žไ๖XZr๊์‚จัฐำZ‰3แ#b#฿ก;ฮUฝ{ฯ์‚จ’”kา“๐`ธ‡0Ÿ’‘้‘ู้ –#œ%z1K??๔PXจ4ทoูฯ9:Rkส…๔žŠfฮtฯััUัฐาำ2ึ8ืฆื๕ู ูฯ฿Gแโใฦ้ฏ๋์‚๎n๎–๓๓a๗Œ๙!ุ|๓จ > 7 aฦ-ะ,๒%$"…#œ'D-0^00๚1๋2•2ม=,>q?๔AภGJงLLฐLโM๔N๛PV|XXZXจY`Ž`๋cFe[eˆh†i.oyrlr๊txl{ฯ |รˆ‡Šƒz‘ฆ‘้’’ฝ“๐”k”๗•b–ฝก ก.ฅฅGฆ:งฒฉ๏OัUาิ๖ื๕ุุ˜ูฯแ#ใฦ๏7๓๓a๘ซ๙!๛ไุ > ) aะ-๒‘nำ–2"…#œ#๙%z'D'ข*u1K2ม7b9ะ=,>ฝ??๔AภE—LLโM6M๔N๛PV|XXZXจY` `๋bึdณgr๊u4yบ{ฯ<‡0ˆ‡zฏ‘้—›.ฅGฆฆ:8ฯััฐาำ2ึ8ืฆื๕ู ฿G๋๎n๓๓a๗8ุ|; >ะ–2"…#œ%z2•2ม=,??๔J"JงLLโPV|XZXจ_RcFdณoyr๊u๋|ร<‹zŽj•bก.ฅฅGฆ:ูฯ#œ$Ÿ1K>KงMิXZZIeh†r๊๗˜vฅG'DYื๕฿G๘ซz’ก.0^๖ฒฏ&ืฆแโโ5ๆค๊†์‚๎–๓a๔-๖ฒZ|หจ >- "…0^9ะ=,GPQทV|h†oytyบƒR„X†ห‘้’“๐กงฒ2ƒyก)ํN๛` ู 0^nL“ŠSเฏ(ัฐืฆื๕ูฯแโๅ๓a๛ไ| )ะ- %#œ#๙$Ÿ1K1๋>K"KงM๔P`๋h†u4z-‚„†หz’“๐šŒœฅGฆๆP-N๛bึ ื๕฿G๓a๗8XZr๊zก.๓a ื๕๓a › a‘'D2•AภLฐM๔ื๕๏7zz%D?ธ๏ฯcะ๙!z-๋๙!ืฆูฯ฿Gไฃๅ_ๆP้เ|n4๏?๔J"LโM๔Y{ฯ‚„ˆ‡Œ๚”k™†ก.ฅG ะ#œ#๙%z1K2ม?LM6XXจ{ฯ“๐%z?rl9ะrlyบ”๗e[0J"ฯ…๊ัม$ƒyึ8b#{ฯ‘้ฃ„XŽGโฅุe[‘8œฉ็Šyๆค๔-๓aA†ห ฮt์‚จ0^Uฝ_R‘ฆ“๐ฅG`/Rฯ[*ฯ…ัฐื๕ูฯแโใ๚้ฏ๊ั๖ฒZม Š]-–ไ2'ขGIJ"M๔PUฝYaมh†i.oyu4z-{ฯƒR„X‘8’“๐ ขก%๙!%z->?GผKงM6`Žrl{ฯƒy’“๐ƒRูฯ•b#ZIh†z- ื๕แ#ไ๖$K๕h†oy{ฯz“๐ ŠN๛ 74M๔Z๏XZr๊“๐(ๅjU3ค„|&n•ืแ ๎–Zฌ0‰Jฯ•ŠฃZpฌแpฌpฌแ๎–แ แ„฿Gq–oy‘้’ก. /้เ๔๏F:N๛{ฯˆ‡‘้’”kž2มL’82 a'DAภP{ฯ“๐กM๔P6N6N|M๔•b#z-ุืฆ| ›$ื๕฿Gแ#แโ๊†๓a[๓ >"…%z=,?B๊PSเV|i.{ฯƒR†หˆ‡z’“๐ก.ฅGฆูฯ๔๏M๔ุ ›๒2•LฐM๔ฅ 7pฮถฯัะฺัฐาำ2ืฆุูฯ/ฉ%ˆแ#โ5ใฦไ๖็Š้เ๋์๎n๏ุ๓a๕ ๘ซ๙!๛ไR|ž- Rูq์ %ฮ$2uš 5"…%ษ'ข+K+-0^0๚:ฒ:ฺ=,>>q?๔AภBผB๊GผKงLโM๔NอSเTJTiV|XZY` `Ž`๋abึcFeh†n#p<r๊u๋z-zั{ฯ|_|รๆ‚„‡0‡ฐˆ‡‰3’’ฝ“)“Š“๐”๗•b˜vŸ๕ข8ฅGงฒ7(ƒๆP๛'•b#{ฯ'ขNอัฐ๛ไ[M๔{ฯื๕ใ๚[„Xz“๐7‹A้E—Qทh†E—Nง‘8ุ้)๖ฒ4‰u4†ห‘8š2ฉ๏3ฯ…ัฐืฆู /โใ๚ไ๖๊ั์‚๓a ๗ๆ๘ซ๙!๛'|`มจ ) 7 a-‘2'D0๚2ม4>>qAภJ"KงK๕LM๔N๛PUฝXจZ๏z-{ฯ†ห‡0’“๐ก2M๔NอSเƒy’ืฆ๓๔๏|๒–HบLฐMิM๔`๋‡ิ๗ฅGฆ:)ำ2ืฆ/ฉใ๚๎n๓a| >–"…0๚1๋2ม=,>>q?๔JงKงLLโM๔N๛SเV|ZI`/`๋cFeˆp<{ฯ|ร‡ฐ”๗•bข8ฅฅG)ํฯ…ัUา๊ั๓aม ›%%ษ4IM6PZ๏`๋aมeˆeoyˆ‡’“๐ฅฅGh†ู `๓1๋N๛ฆ:M๔N๛ืฆ|ใ๚$Ÿ1๋ใฦ 7“๐โZSเSเ`/ฯc†‡qื๕b#ƒyฯ ืฆื๕ๅ_้™z—™†ฅฅGM๔“๐ฉ๏6xMิ๗ ืฆื๕๓|๙M๔€ูฅฆ:ฆ’๓a6jPูฯ๓a'DAภื๕ๅบz๓aื๕๓azืฆื๕%ๅ_๓๓a๗8๙!|&ธ-Gผ`Žz™†ฆ:ื๕อฟื๕4Eื๕Ndzื๕zื๕)0^A )z' zๅ๒น) AM๔M๔ZI@ฮt`๋‘ฆ“๐Zz-’ฮถัฐา฿G้เ๗8๗Œ๓oy{ฯˆ‡‘้’ก.้เ๗8q…ห‘้’ ”k ฯc%๙!์-Gผ`Žz-†หŸ๕’๓ฯั๋Iฮtำ2ึ8ืฆื๕ู ูฯแโๅ_็Š้ฏ์‚๎n๓a ๔๏๕ ๗8๘ซ|๙จ > 7 › aูฦ‘2u"…%ษ'D0^4=,AภB๊FŽJงK๕M๔PUฝV|XZXจZ๏_R`๋ cFcนf„i.r๊y|ร}7ƒRz‘ฆ‘้“๐”๗•b™†กฅฅGฆฮt์‚๓a  a'D+AภB๊M๔PZ๏cนh†txl}7ƒy‘ฆ“๐กฅGื๕ฌ 2j“E}Pƒy“๐ƒyi.ƒR๓aM๔๒Jˆ/“๐กัฐะฺ-Ÿ๕ู’*˜P']7ฆ\ๆชEธhเ์‚[จ“๐ิ๖ูฯ[- aV'D5@:ฒAภM๔Q—’—[’“๐ื๕โฌ > Š2"…$Ÿ*20^=,K๕M๔QทUฝV|’ ื๕ูฯไ๖๓a๖ฒ–'ขM๔u4z“๐2))IAn#‡0PP’ฝ้ฏ๊†GPi.Pƒyƒy ใ๚็Š๔๏ซ01๋M๔tšPvˆ฿œะฺูฯ้ฏ์i.้ฏi.ืฆูฯุ%z2•2ม?K๕LM๔XZdณe[r๊<›.ูฯ์‚จ a"ฐ'DAภZI ฮถัฐา฿G๑PญN๛u๋‚„ˆ‡Žฺก.ฅG ใฦ?๔B๊LโY Œ๚‘้›.ฅGู แ๓0‰’งฒัUึ8ื๕ๅ_์‚๏7ฌ)จVม$Ÿ5@IOMb#ˆ‡z’“๐—™†กOMื๕ฌ ) ๊nzB๊’g'ขšŒšŒš2ฆ๓a | a'DAภZ๏g3 ๓aฅG๓aื๕ื๕฿Gๅ_๗8’™†ก.ฅGM๔tS$ฅG๏7ฅGeˆ 7—ตใmXeXจ$Ÿ1๋“๐กิ๖์‚จ’K๕R Rะ#œ#๙1K`๋’แR )ะ#œ’ ์K"แยฯ0‰9:RkสJฯแแแแZแ0^ำ2๎n"…=,V|cF|ร•b ฮถัฐา฿G้เ๗8{ฯˆ‡”kก.{ฯ”k฿Gก.“๐J์TJฯcn#z-†ห‡0ฯcz-†ห†ห’’k1 7Xจ—ต ๓ฝ;2^FoูxN„ม‘8งC ืฆๅ_24‰‘8“๐”๗™†ฅฆ‘822'ขNอ2 „ไ๖๓a >2"…=,M๔V|’22ำ2แ#๎nะ#œ#๙01KJงQ—cFp<|ร‰3•bข8ฆE<$coูแ#oูp<‰3ข8|‚‰3•า๔“๐ %?๔LโYeu๋ๆ‚„ŽฺฅG4‰?๔Lโ0^‰3†ห๕  7Xจ—ตG_พk…ืฆื๕฿G์‚๓a๗8[จ 'DAภeˆz’“๐ก.ฅG๓a๓a๓aY แ๚อ6.ƒh†j“xl„ม ข๛ไจQทbึ“๐๖ฒ๓๓a๖ฒ-ฆ:ูฯๆค๔- 2Pก2ไ๖๔๏$2h†ึ82%ษ“๐กำZื๕2z ะื๕๋€2 WHg‡\zฯcฯ๔/์‚ฌจฦ-ซ $ม–u$Ÿ'ขAภINอPoูz- ƒy„X’’ฝ“๐ŸZกฆฏ๖&Oคฒ\`–{ฯ/–ัU๘ซR–9ะ<ฯPS™]gafyบ‡ิˆ‡“๐ก ื๕฿G๗8 )PŠƒ–ฝ›.ก.ฅ4‰J"P“๐๐(P|_Pฯcฉ๘ซuP` ๗Œ'ฮPPP๓a๔๏$tƒyƒy็Šy้ฏi.้ฏUฝi.Uฝi.ƒRูฯฉใฦ์‚๓๘ซจ )-%ษ&ธ>KงM๔aมh.oy}e‡ฐ’ค”ฅฆ:h†’ฮtหh†‘ฆ ขh†ู ู ๓’ู าmุผ/เ>+ˆ‡4๏฿G๓a'ขก.ๅu4šŒ๓a๓a{ฯื๕ ื๕฿G๗8 ›2•LฐM๔zก.ฅM๔oy™$s<ฅGฅG~?\Šƒ–ฝXจ$Ÿ–#u0`  >"…=,V|๎-oู“๐"AJ"J"z-J"”๗าพ{ฯˆ‡”k฿Gก.์‚จz-“ฏ`๋๙L--D:ฒ%๙!-Gผ`ŽSเSเ’้๋B9ะyบฯcaG(‘้แ[PXZr๊•ŠP“๐”๗ืฆ้ฏ|Iaมi.“๐ก๔š2๓a a'DAภื๕M๔$๒LฐฅG0^”๗์‚ฯcz-zN‡08D^ฟR#jไ…$ฌ$้NQุv~$ืฆู ฿G๓a|[ )-ม0๚45@>>qKงM๔OMPXจZ๏`๋e[h.i.{ฯ‡0ˆ‡Žj’“๐Ÿ๕ก.ฅG{ฯัฐื๕๓๓a 7>KงPi.{ฯƒR’›.ฆ:ฆ;TJ“๐f 9ะtyบXจeˆXจeˆXจG’‘8?๔J"LโฏฅฅGZI“๐`๋z-FŽ0^1๋6N‰3”๗ำ2ึ8ื๕แ้ฏ๎n[%#œ=,?๔V|`๋cFeˆi.|รz’•bกฅG4‰’’ ืฆื๕๓a|'D`๋i.{ฯƒR‘้“๐B๊-GƒRn‚3š`N๛ %z0๚2ม>>q?KงLXZdณr๊{ฯ<{ฯ“๐ฮถา้เ‘้’์‚จ“๐‘้Sเ^h†ŽjฏP-GƒR‚ ?๔LโM๔YฅG$ )-แ#z-G๔- aฯ'DAภžฺุ )-๒%z*R2•2ม7b9ะ>ฝ??๔K๕LLฐLโM๔XZYdณe[r๊yบ<›.ฅGXZr๊“๐ฅGุ๒2•LฐXZe[r๊๗8๓a 7Xจ1๋M๔Nอ?ฉ๏ ื๕ )-J"P{ฯzฅG็Š๕ 1๋y[gšŒุtgอšŒงื๕z“๐[$ŸE—ื๕ุQท/ัUิ๖ื๕ุ˜ใฦ๐(๓๓aุ ) aะ๒‘#œ%z'D'ข*22ม4??๔AภK๕LLโM๔XXZYZ๏`/dณr๊{ฯ<ˆ‡z‘8—ฅGฆฆ:2ฏ“๐ฅGPฉP‡ฐ๓a‘J"K๕P`๋’ฝ“๐ื๕ƒRzะฺูฯูฯ-๔๏M๔h†u๋ ื๕๓a )-N๛u๋‚„ˆ‡ŽฺฅGงฒšŒ๓a a‘'D4AภZ๏๓ฆ:?๔Lโฅ 7 ำ2๎n >"…=,JงV|cF|ร’•b{ฯัฐ“๐ฯ…๊ัม้™๓axlรื*ไ๖Gฉำ2L*R*u7b7‹E}E—Nงg‡ฆ22าื๕/฿Gๆค๊†๓a๓0๚>>qKง{ฯzก.{ฯ าื๕๓aะ#œ#๙.+1KM๔Xจrlz ื๕๓ ข%z2ม>ฝ?LXdณ<žฆ:{ฯ์‚จ’4‰u4ก้™Uฝh†ืฆ|3คg„|’ฅG ฯ/„้เ๗8๗Œq)ํF:{ฯ’žYPูฯžูฯู ๑P๓a๓aแย๎–ฃำว๎–ฌJฯ•Š๎nUฝ‘้ัฐา฿Gb#oyˆ‡ก.‘ู้ฯื๕ZI~าาพำ2ึ8ืฆื๕ู ูฯฺ:ฺ€ฉแ โใ๚ไ๖็่!้ฏ๊†์‚ํ๊๎n๓a๔๏๕[๕ก๖ฒุ|่.[จอ > 7 a Šฦ-6ะ๒‘2ณu""…#œ#๙$Ÿ%z'D'ข)i01K1๋2•46ˆ7๓=,>ฝ??๔AภB๊DyGJงJฯK"LฐM๔PvPPพV|XจZœZ๏]ƒ`๋cFee[h†i. isoูrlwxl{ฯ|ร!ƒRƒyƒ•„Xˆ฿‹Œ๚z์‘8‘้’’ฝ“๐”k•b•Š—ตœdกฅGจ๗ฉ<ฉ๏/๓–ฅGB๊4‰๓aM๔ึ8ำ2ฉ‡ฐข8๛ไ‰“๐ํ๊”๗าพ”๗าพ“๐“๐z-†ห๋’ฝ’M๔.าำ2ื๕ไ๖ๅ_็Š๎n๓ > a2"…"ฐ'D'ข.ƒ6N=,AภB๊JงM๔NอQ—V|cFn#oูtu4y|รƒy„X‡0‘8’“๐•b™†กฅGฉ–6N‡ฐ๓aำZ'ัฐื๕ฉใ๚ไ๖็Š๓a๔๏ > aู-‘"…'D0^1๋46N=,AภGM๔PV|XจZIZ๏`๋xl{ฯƒRz’ “๐กฅฅGCฯ…ัฐาำ2ืฆื๕ุู ูฯๅ_๊†๊ั๎n๓๓a๗ๆ|ม- > ) ›ะ- –2"…#œ#๙)#0๚1K1๋=,>>qJงKงM๔N๛PV|XจZIZœ^d`/`๋bึcF|ร!vˆ฿z’“๐”๗•b™†กฅฅGฆ: ไ๖ Ž$3ค6N:MิSเ„|๗h†Sเh†z†ห†๐B๊ื๕๓aื๕ไ๖$1๋,สSเ้)ฉ๏๖ฒiCใ‚„‘\ใฦ[ ›ะ-#œ#๙$Ÿ%ษ1K4M6Z๏eˆฅฅGไ๖ฉ2cน}72่ฆC`PPู“๐$Q˜ุ๑๚ ?๑ง ใ๚ุ )1๋2•LโYeˆ“๐?๔ีJ1žฉ๏ˆbึˆ฿ํ“zฯ…๊ัมใ๚%z?0๚>qˆ‡”k•Š–Hบ‡ิใฦญu๋ก/ณ“๐๘2kสžŠ๓aPZ๏๓a  a‘'D4Z๏z ฮtื๕ไ๖๓a๗8๗ๆ[ )$2?๔LโM๔PSเXจY`/`๋oู‚„ƒy‹z‘ฆ‘้“๐กฅGำ2ื๕์‚๎nจ >%"…=,JงM๔PV|ZI`๋cFz-|ร‹‘8‘้’“๐”k•bกฅG2 `–ฯ9:M๔Rkส…๔žŠ ขP“๐ก )-โ“๐’…2“๐h†u4$ฅGฯ…ำ2๊ั๎nม >"…=,JงV|`๋cF|ร•bฅGกขn‰ฮถู ูฯ%Xจ{ฯN๛4‰๓a—ตXจแ#Uฝก“๐’ ๑Pญ %z?M๔`๋e[j“tu๋Žฺ’„X ืฆื๕ๅ_๓๓a| a'DAภZ๏{ฯ™†ฆ: a$'DAภˆ฿|“๐“๐'ข2ๆค๔-กg‡ื๕Xจ—ต02hาำ2ืฆื๕ุูฯ/฿Gโ5ใฦใ๚ไฃ้เ๊†๎n๏ุ๑P๓๓a๖ฒ๗8|๙[๓ ) 7 › aะ-๒%‘–2"…#œ#๙%z&ธ'D.+0๚1K2ม9ะ=,>>q??๔AภJ"KงLLฐLโM๔PQทV|XZXจY`๋b#cFdณh†rlr๊u4u๋yบz-{ฯ|ร<ๆŠƒz‘้’’ฝ“๐”k”๗•b–ฝ˜všŒ›.žก.ฃฅฅGฆ:งฒ ำ2๎n >"…=,JงM๔ V|cF|ร•bM๔M๔ูฯไ๖ุ- 7ฉ๒ำ 5*u+02•:ฒLฐTJXZXจcนe[r๊}7—ตEฯัะฺำ2ูฯฉ%ˆ฿Gแ#ๅ้ฏ๋์๎n๘ซ๙!๛ไ- >-$u 5"…'ข+-0:ฒ=,B๊GGผJงNอTJUฝV|` `Ž`๋bึcFi.n#p<u4{ฯ|_|รƒR‡0‡ฐ‰3Žj’ฝ“)“Š“๐•bšŒœœฉŸ๕ก.ข8ฅGฆื๕ K"Pˆ฿zD-œ์0^Pv์‚-$GƒR’ูฯ๓aZ๏XZr๊n#‡0z- ้ฏ )--'ขU็i.o)ƒR‘8กฅ‘8๖ฒ4‰ฉ๏้)X2M๔าพื๕2)ํ+KzกQัฐาำZืฆื๕ ุูฯ฿G แ#โใฦๅ็Š้ฏ๊†๎–๓๓a๕ ๗8|;๙ห 7 › Š%$B'ข0^0๚1๋2•7b>q?๔B๊GLฐLโM๔N๛UฝXจYZI_พb#bึeˆg‡h†i.tu4u๋yz{ฯ‚„ƒRƒyˆ‡ˆ฿zŽฺ‘้’“๐ ”๗šŒกก. ฅฅGฆ:งฒ„X“๐ืฆ|M๔ฅG)ํ’ำ2๎n 7"…9ะ=,PSเV|cFpฌyบ|ร“๐•bกPแ้ฏ a-'DAภGi.้ฏจ-Gi.ƒR’h†h†ๆค9:แๆค๔- ืฆื๕ๅ_๓๓a๗8|z‘้™†ฅฅGฆ:๓aฅGื๕๓a › ื๕๎– )-z“๐ฅๅ_™†?๔LโM๔Yาไ๖ไ๖ไ๖ก$Y]ใ๚K๕’ฅGฅGฅG“๐ฅฅGใ๚ใฦ๒LฐXจ๘ซ’แ )-๎–ZF:J"oูฯ๔๙!Kb#‡0ั๙† ฌ์๙!-`Ž9ะyบ’’q‘้xฮถัUัฐา ำ2ำZึ8ื๕ุูฯ/ฉ฿G แ#ใ๚ๅ_ๆค้ฏ ้เ์‚๎n๏ุ๓a ๔-๖ฒ๗8 ๙จ > 7 a-ซ%$–2 ฯu"…#œ$Ÿ%z'D'ข)ํ0๚1K1๋2ม49:=,>>q??๔AภGIKงLLโM๔NอN๛PRSเV|XจYZIZ๏^ฟ_พ`๋aมcFdณe[h†i.j“kสoytu4u๋{ฯ|ร<‚„ƒRƒy„X…๔†หˆ‡ ‹zŽฺ‘้ ’’ฝ“๐”k•b•Š™†šŒžŠกก. ฃฅฅGิaึโŠYฏf4sŽŒŸ%ŒTฅG˜'เ.ๆxบ”z-z- ืฆื๕แ๗Œ[–2PQทZI{ฯOฯัึ8ื๕ ู ูฯ/฿Gแ#แใฦๆค็Š้ฏ๋๓a๔-๕ ๗8 ) 7-ะ- $–2#œ$Ÿ%z1K2ม>>q?GJ"KงK๕LM๔PXZXจ`/`๋h†i.oyoูrlr๊u4y{ฯƒRƒyŠƒzŽj‘้’’ฝ“๐”k–ฝ›.žŸ๕กก.ฅฅG ฆ>KงM๔0SเŸ๕ฅ0^ ื๕ู ้ฏ2uK๕M6Pi.“๐Xะ[ใฦPฆ$Yf„PSเฅGูฯ๑PPz-‘8‘้M๔แ“๐:ฒ’กุ[ู ๒2•Lฐe[xl~ฌ‹€—ตฅGjผPฅGึ8ื๕ู ูฯ๓a a%‘$L$Ÿ'D4?๔AภLโXจYZ๏e{ฯ‚„‹z‘้’“๐ฅGฅปงฒู ๓aXจ{ฯไฃ?๔LโM๔Ygu4๓a๓a4Z๏ ํs้ฅG๒LฐeK๕0^“๐'R…๔^ฟ*็ฺ:ฺ€็่!๕[๕ก่.)i6ˆDyPพ]ƒiswƒ•์œdจ๗ฉ<[;BBผ„มื๕2+K6Nz๙%’ฅGฮtฉไ๖หอ+KF^ฟj7oูx…„X‘ฆ“๐ ”๗ ข+K„X“๐”๗ู %%z?`๋ˆ฿๛ไbึoู|_฿Gก. 5‘้า้™B๊iCใ‘\*˜P']7ฆ\ๆชEธhเ้NQุv~„ๅ[ )-M๔Qท ัฐไ๖x29ะB๊M๔h†yบ{ฯƒy(ๅjU6x่ไo๖k›ฟ ำ2๎n"…7(=,V|cF|รƒ•bwำจB„X„X„Xู bึฏ“๐๗“๐่ฆC`๖&Oคฒ\`)ํ ็'๔ฐาWDQB0›€ ูP9ล•)ฎ6ฮ^i๘จๆ้๔rW(งDฟQw•„๛5ึO้]ษqฉ‚ฺฦ่g†\งhกiนwV๕็s(h5—v?‚ูƒ2Pƒyƒyƒyƒyƒyœ จญู๏]3ƒRvษู"โ5ใฦใ๚ไฃ๏ุ๑Pญะ%ฮ#œ0๚1K>>q?๔KงLโXZYer๊u๋ๆ‚„‹Žฺ˜v›.ฅGงฒ!โ๐‚: )ะ-#œ#๙%z0๚1K2ม3\8>q?@•FŽLLgXZXจ`๋dณrlr๊u๋<†D–sคู ู ัฐู ๆค๔-ฒ6(C6(C\uกސงgุผ๓โ ๊'ฮ'ข[tไ๔%z>?Kงฆt– ™ฆ’ื๕ื๕ื๕ื๕ื๕๑PNfใtE€ูzz๒น D3ศM๔โKEW„cๅt$$€Hฦ6XจŒ๚˜ุึ๑๚ ?&#3\@•MŠYฏf4sŽŒŸึ‘ฅnไT๑ง\ ํ{3@HY]s<ŒT˜'๎–%Xจโ๏7 )?๔Lโ`๋ 7ี˜๐ฦ$๐2@LgXจ{ฯ’‹€—jีJใ&๐‚: ๑“๐~Z‹.คGโำ๒Q1žq๏~Šแ`๋Šƒ–ฝคิฏโŠฉd/q™}ท–sฃถิa๏ˆW„cๅqNŠ:ฃlโ•ืำว๎้ ž#=—V๋cn|๋‰คขณ/ณbึ<€U็oูก…าmเ>ํ“z!ฉ.ๆ<(Isํ@"!M;ฮUbo)ˆ/”๚sั ;}Unี{$“๐“๐“๐ ฌ;1Tภn‰ Q์DH`๋๙†T-„H`๋`๋z„ฯcz-Ÿฆั๘ัš,สGdŸZRS™9Šyv†D’xžฺ'๘2ไ,Fผ_vy-’/’ฯ๊3K4+8R}_k1xบ…FŽGšŒZIืฆื๕แ๓a|[%z2ม9ะ?LM๔PXZ`๋b#dณr๊yบ<‹‘8„7bQทUฝ๖ฒ2–›.–้ฏPฅGไ๖$ƒy ืฆื๕็Š๕ |M๔`๋eˆyzŽjฮtหi.‘ฆฉ้ฏi.๑PญXจh†{ฯฅฅG›.๓โ๛'`b#'ขNอๅ_ 7{ฯ™†ฅG‹•Še[“๐>KงSเ0^ ำ2๎n >"…=,JงV|cF|ร•b >"…=,V|แ#<ฯJ"าพอ"”๗ b#.ƒ’[2'ขNอšŒP๓a6M๔Pi.%9ะN๛Pyบƒyื๕ใ๚็Š๓a๔๏|- > a"…'D6N=,AภV|Z๏`๋zฅัฐา/แ#ๆP๓B๊N๛b#{ฯˆ‡“๐ ”kžื๕์‚๗8จAภeˆ“๐ ข9ะM๔yบHบ‡ิฅGิ๖—โIaม“๐๊†9Šyv๊†[4‰4{ฯ$#œ%z1K??๔’’แ[1๋ 2'ขK๕Nอu4u๋†ห‘8šŒPฅG+i.ƒRƒyใ๚6Nใ๚Xจ‘้ฅGงฒๆค๔-—ต๎–๗8'ขNอ“๐โ5ใฦ๑PR[ )ะ๒%#œ $Ÿ0๚2•>?๔KงLฐLโXจYu๋‚„ŠƒŒ๚Žฺ—ต›.ฅGงฒำ2ื๕ู ูฯไ๖๎n]ไ"…=,?๔LโPV|YcF|ร„Xz“๐•b ขPi.ƒR<ึ8โใmใ๚ ไฃ๏7๏ุ๑P~ญ™ R 7ฦะ-$%ฮ#œ#๙ %z0๚1K1๋2ม>>q??\?๔KงK๕LLโM6XXZXจYdณee[erlr๊u๋}e<ƒy‹“๐–ฝฅฅGฅปงฒูฯJฯ‚3 7’šŒ$ )€HŒ๚ึ‘ใฦฅGฅnไTี๊ฅGุ2•ุ2•‹ส1๋r;~Z‹.$Ld…q๏~Wฮd/q™ํ@"!M+K?๔Lโ?๔้ฏห+Kh†i.M๔กZู{ฯˆ฿’ฃ[’ ัU[2.+Hบh†p<{ฯˆ‡“๐กข8 ื๕ู จ20๚1๋>qM๔h†“๐šŒัฐาื๕๘ซ'DAภu๋{ฯ|_‚„zŽฺ”k”๗งCงฒšฏZ๏“๐ื๕z’ )-Xจb#Šƒ“๐–ฝัฐา{ฯก{ฯ“๐9ะyบn9ัฐำZืฆื๕ู ูฯ/฿Gแโๅ_้ฏ๊†์‚๓aZ|[ 7-๒–0๚>>q?๔GIKงLฐLโM๔N๛PSเXจ`๋aมi.oy{ฯ ƒR‡0ˆ‡‹Žj’“๐”๗™†ก.ฅGฆ2ฅG$ัฐืฆู ูฯแ์‚๓a|๓จ > ) ›-%$+?๔JงLโM๔PYZ๏e[‚ ƒy†ห‹‘้’“๐ฅฅGงฒP“Qใฦใ๚ม45@OMZ๏e[h.{ฯƒy๓‰z-{ฯ“๐ฆ๓aื๕๓a‘'DZ๏{ฯzื๕๓a๓a๓aื๕Z๏’“๐ื๕rผแ#p“๐”๗UฝจoyัU{ฯˆ‡ˆ‡าัU.+Gเ_พ‘้ฮถัฐา฿G้เ๗8 7?๔BผLโXจYu๋{ฯ‚„ˆ‡Žฺ’•Šก.)ํ ืฆใ๚|.+?๔LโN๛Y{ฯ‘้žP๕Yu๋‚„Žฺฮถ้เ๗8{ฯ”kDะGิื๕ุุtู ูฯแ#โโ5ไ๖ๅ_๊†๏7๏ุ|O > ) aฉะำ2u"…#œ#๙'D*u-ิ01K3ค4๏7b<ฯ=,AภGIฬPQ—SเV|`๋b‚bึeˆj“tu4z|_v„X„|†หˆ฿Sฏ‘8“๐ ™†ู ์‚จฦ$2'ข4‰BผNอQทTJ^d` gp<„X‰3ฏ‘้ข8ฆฉภฉ๏2ƒy“๐ ƒyi.ƒR๛ไbึŽj ซ0 JN<€b#๚sื๕ )-N๛XZr๊ฅGใฦ๓a ) aะ-#œ%z'D??๔AภLโYฅG $L%z2ม?LXZdณr๊<ขฮtฮถฯัะGะฺัฐาิ๖ื๕ูฯ„ฉ%ˆ฿Gแ#แโใฦๅๆค้ฏ้เ๊†๋์๓๓a๔-๔๏๗8๘ซ๙!๚อ๛'๛ไRญ`[๓-O ) 7 aq-์•ซะ-%–2 ณu 5#œ$L%z'D)ํ+--ิ1K1๋3ค6N7๓::ฒ??๔AภBผE—GGผIฬLโM๔N๛PQทSเTJUฝXZXจY_R` `Ž`๋ b#bึcนee[h†i.n#p<pฌr๊tu4u๋{ฯ|_}7‚3‚„ƒRƒy„X„|‡0‡ฐˆ‡ ‰3‹SzŽGŽฺฏ‘ฆ‘้’’ฝ“)“Š“๐”k”๗•Š—šŒš›.œฉžŸ๕ ขกก.ข8ฃฅฅG ฅปฆ:งฒ$2{ฯˆ฿‘้์‚จ‘้ื๕z >"…=,V|ไฃ?๔LโQทYu๋Œ๚ื๕ูฯโ้ฏ > )-2u"…1๋=,MิPV|XจYZI^ฟcFi.{ฯz๗‘8‘้ัUึ8แโ้ฏ๓a๔๏ุ 7 › a $Ÿ%z%ษ2•?M๔Pb#e[h†i.{ฯƒy’ฝ”kกฅงCPPู ูฯ๓aฌ๓ 7%XจZ๏h†ƒy“๐ฅฅGM๔ ข>ฝXจ„ม!ัUิ๖ฺ:็์‚๕[่.จ a–ฯ'D)i6ˆ9:AAภDyPพR]ƒkสp<…๔ˆ‡’œdžŠข8จ๗็'๔ฐาไ$W#=—DQBiswƒ•0์›€ูPฺ€่!๕ก9ล•)ฎ,6ฮ^i๘จฉ< ๆ้๔rW(งDฟFผQw•„๛5ึO้]ษ_vqฉ‚ ฺฦ่g†\งhกiนwVy- ๕็s(h5—v?‚ูƒ2’/ๅ_P™† ๆค๎–๔-Z0‰Jฯpฌ{ฯ“๐ก แ ์‚Zจ>B๊KงM๔3ศฅคGšTizัŠ:ฃlV๋cn|๋Zั ;}Unี{$ž:ฺ`๋a;ฮถาำ2ืฆื๕ใ๚้เ๎n๓a๖ฒ๗8๘ซ| )-%–%z'D0๚2ม>>q??๔JงKงLLโM๔ P XZY`/`๋cFdณi.r๊t{ฯ|ร<ƒR„XSz‘8‘้’“๐•bžกฅGงฒฏโ'D0^  $0๚>q?๔LโYb#bึ“๐กัฐู แ๗ๆ >2"…"ฐ#œ0๚=,>>qKงM๔PV|YZI`๋’-GƒRื๕ 7 ›๒Lฐz›.4‰M๔oy‘้‘82Pืฆ|4‰๓a๎–"ฐ >"…=,V|ˆ‡’ ืฆ๓a[–+KM๔P{ฯ“๐๊†nDPPฆฯcะฺะูฯ๊†๋€์๗ๆ-- 5 W:ฒGHgPTJz-ƒR†ห‡\‘้’“๐์/้เๆค๔-22Pำ2แ๎n"…$Ÿ3ค=,N๛PV|cF{ฯ|ร„|•bh†ำ2ไ๖๎n >'ข=,JงM๔NอV|b#|ร•bก๓aื๕ืฆื๕|zกZIb#b#’“๐’B๊šŒ Šิ๖—0^ >"…=,V|“๐๛ไq’“๐ซ#]0Pv-ดPƒy )-N๛ˆ‡”kM๔9ะyบHบ‡ิข8ื๕b๖ฒหn๕)I*R6jDPP]g^F^e[iXj7xNƒy†ห“๐?0ฮtื๕ ุ˜ู ูฯฉํ๊๓a ๖ฒ๘ซอ aฦ-‘"%z'D+2ม49ะ?AภLM๔ NอPSเTJZ๏`๋dณh†oูtyบz{ฯ<z‘ฆ“๐”๗œฉฅGฆ์‚Q—Bฯ๔ิื๕ูฯฺ:ฺ€%ใ๚ๅ_ๆP็่!้ฏ๊†๓a๕[๕ก๗ๆ๙!่. >-ซฮn"…)i-04๏6ˆ=,DyGผM๔N๛PPพSเV|]ƒ`Ž`๋i.iswz-{ฯ‚ ƒRƒ•Žj์–#™†œdœฉžฅGจ๗ฉ< ืฆื๕ฉ้ฏ๘ซ|7 ?๔LโP Yi.PvP‘้-PSเn#t‡0ƒyๅ_B๊™†ืฆื๕ๅ_|z™†ื๕|ืฆtS3ฅGFx…‹“๐แ#ฦิ”๗ัฐา฿GUฝˆ‡ก.{ฯะGO-ิ๘ัT;1z„ Q๊†‘้’ฯ๔ะฺื๕ู แ้™๓a R[ R4‰?๔B๊E—LโM๔PYoู{ฯƒRzื๕โ๓a[ a ‘'D4AภZ๏i.{ฯz๖ฒ22$L22222–๘ซจPoyPัฐื๕6NJ"{ฯzื๕้ฏi.’i.ƒRูฯจ'ขNอ’ฆุ >"…=,M๔V|๓aM๔๓a๒Lฐืฆื๕ๅ_|z™†ืฆื๕|ๅ_™†M๔M๔M๔ttS€š$K๕/ะฮ#œ@H%oูแ#1๋ซ0แ#“๐+Kƒyƒy๖ฒ[2M๔SเXจื๕์‚M๔Poy ข็Š๕ y๓aงCXจe๘ซ%z?M๔1๋B'ขNอ‘8ฺ:ฺ€็่!๕[๕ก่.)i6ˆDyPพ]ƒiswƒ•์œdจ๗ฉ<ูฯB๊ ดุtๅ๓aM๔ )-[ 7PSเำ2ฉ๎nž >š"…:ฺ=,JงM๔QทTiV|acFj“zั|ร•b๒Lฐ‘82P22ื๕ู ฿Gๆค๓a๔-๗82%z&ธ?M๔N๛PXZZIg‡pฌr๊{ฯ‚3zšก.ฅGcน}7ฉฺ่ไo=ใE<g‡ฏ”๗–>KงN๛๓a 7PฅGPXจPPe[“๐B๊P’“๐ฯcฯั๋P’ฝฯั๋P iX’ฝPPฯััฐุูฯ฿GๆP๋๗8๗Œุ Š๒Pz-v’’ฝ“๐ก.ฅา๓P“๐ƒyƒyะฺำ2ูฯ้ฏ์๎n๏7 >ะ 5"…#œ#๙1K1๋=,K"M๔SเV|b‚cFi.{x|ร‚3•bš้ฏ 7>qi.จƒูฯ6ฮถำ2ิู /฿Gโ5ไฃ้เ๎n๏ุ๑P๓a๛'ญ ข ›•๒%ฮ$L.+>ฝF:JงLฐXZ`๋b‚bึcFdณr๊u๋z-{x{ฯ|ร<ๆ‚ ‚„ŽjŽฺ“๐•b˜v›.žก.ฅปงฒ๊†๗ๆ a'D?๔AภLโY`๋u๋‚„Žฺ“๐ใ๚‘้›.ฅGงฒ[ฅ๑Pu4u4z-ฅG[tไฆ๓a 70๚Xจโ๓a a'DAภZ๏Aภืฆื๕|zื๕ztS$0๚>qeฅG“๐ฅG 7X{ฯXจXจXจ$ŸK๕โW6cนแ"ฐJ"”๗า๓oy{ฯ๓กš-„Tภz- ๓:vTz-†หฺ:ฺ€็่!๕[๕ก่.)i6ˆDyPพ]ƒ_พiswƒ•์œdจ๗ฉ<2ื๕i.ƒRzงฒ 7“๐๛ไ’ูฯ-*2Gืฆแ๊†| ) %>?๔KงLโPXจY‚„ƒy’ฅGื๕แ๓a  a‘'D4?๔AภLโYZ๏i.{ฯzแโUฝแ๎้ ž‰๊ขณแ0^z-’ i ำ2๎n >"…"ฐ0^=,JงV|cF|ร•b=WVงpd‰XขcแI๛ไbึ‘82h† ูฯ๗8๙0^06N9ะcนyบ}7ƒyˆ฿zwำ“๐จBฏ'ขPPƒy ึ8้ฏ'ข:NอSเZIeˆi.'ขNอ-จ a$'D:ฒAภ0๚>q?๔LโY{ฯK"”kGdSเ`/‘้ฮtื๕้ฏ ŠN๛PXจi.oy{ฯz‘ฆ’“๐ โ้ฏ๊†-uGP ` i.ƒRˆ฿“๐๓a a‘'D4AภZ๏กXจแ๎–’“๐’x…ไ๖.ƒ<ฯIฬJ"PQb‚oู{x|%„Xˆ฿“๐ ขก „ๆPF:{ฯˆ‡‰ค’”k•Šžืฆๆค้ฏ์‚๓a๔-Z|จ 7–M๔XจZIi.{ฯ‘้“๐โ-+GPi.ƒR€ƒyƒyƒRู FV4x…“๐uUŽj  ขฦซ'tM๔ื๕Zœ!zื๕แ`๋zM๔ แ#ไ๖๛ไ/6bึp<|_‰3“๐”๗ข8ำ2๎n-JงcF|ร•bˆ฿“๐”๗{ฯัU.+Hบaf‡ิ“๐’อ+K 7ภ$๐ฅGrl—ตXจ1๋XจeXจแ#„X„X้ฏ์‚จ 7i.“๐ฉภ/–<(“๐”รกซ07 `๋œฉ(ะฺูฯ%ˆ่!์๕[๕ก๙!่-์ณ 5)i-:ฒGผPPพSเTJ]ƒ`/`Ž`๋m—n#tzƒ•†ห‡0‡ฐ์“)“ŠŸ๕จ๗Sเh†m†หh†ู B๊“๐ฮtฑไ๖์‚‘ฆ“๐กK"๙ุจ“๐ก์ฆ“๐“๐ ื๕๓a[๓-์GM๔ƒR‘้ฅGัฐู /แโใฦใ๚ๆค์‚๔-๗ๆ[จ 1๋PUฝXจz-{ฯ’“๐—ตšŒกฅฅGื๕z?๔LโYUฝ†หQท2โ2`/ื๕1๋3คƒy„|”k]ไห„XŽGี˜XจคๆฅG%z2ม?Ldณ<ใm 7XจXจ#œ1K’oู’๓ณ7๓[๕Sเ`๋h†‘8Pฉ๏bฯัฺ:ฺ€ฉ็๋๗ๆ๘ซ.u6ˆ7๓DPDyP` islw’ฝœdฉ< ฯc้ฏ๓a a?๔AภLโPYZ๏i.’ฝP ำ2แ#๎n๓a $JงPcF|รz•bื๕Pzก๊†-GƒRœูฯ ำ2ู ๎n๓a >"…=,JงV|cF|ร•bB๊'t๓a ‘4Atfใ๓aื๕๓az’ฅGๅ_™†ฅGzแM๔M๔XฅG+KM๔’ZI>ฝฅGK๕K๕–#ฌp<ข8๛ไ{ฯ{ฯัฐ{ฯ†หˆ`๋z-†ห‡ฐ“):ฒŸฆฉ’๔ณ7๓[E—Nงƒy“๐Qท๖ฒ2ƒy“๐ ๊†%z2ม??๔LLโXZYdณr๊<›.ู 4M๔Z๏“๐ืฆื๕ๅ_|eˆz™†ไ๖ใฦ9ะyบ’PPšŒ์[ƒy+ƒyฉ‡ฐ1๋0‰๓ >"…"ฐ=,V|2๙cน}7PPาพแโอ$ŸM๔PvPSเƒyˆ฿“๐œกฅGP6N6Nื๕i.ƒR๔๏2•LฐงCM๔แฯ9:M๔Rkส…๔žŠ )-0J"J"”๗ˆ฿ัฐ{ฯ“๐“๐`๋+K†ฮtฮถัฐาำ2ึ8ืฆื๕ุุ˜ู ูฯ/ฉ฿Gแ#แ โโ5ไฃ้™้ฏ้เ๎n๏ุ๑P๓a ๖ฒ๗8๘ซ๛'Rญ|ห๓ > ) R 7 › a-ะ- %ฮ‘–2u"…#œ#๙$Ÿ%z'D'ข+K0^0๚1K2ม49ะ=,>>q??๔AภB๊GJงKงK๕LLโM๔NอN๛PSเV|XจYZIZ๏_พ` `๋b#cFdณeeˆg‡h†i.oyyบ{ฯ|ร<ๆvƒRƒy„X†หˆ‡zŽj‘ฆ‘้’’ฝ“๐”k•b˜všŒกก.ฅฅGฅปฆงฒ[๋ฮtฮถฯัฯ๔ะGะฺัUัฐ าาพำ2ึ8ืฆื๕2ู ูฯ /ฉ%ˆ฿G แ#แโ โ5ใฦใ๚ไ๖ๅ_ ๅ้)้เ๋์๎n๎–๏ุ๐(๑P๓๓a๔๏ ๖ฒ๗8๗Œ๗ๆ๘ซ๙!๛ไฌR~ุ|;๙[-Oอ > )  7  a ]-์ซะ- P๒ %ฮ$‘n– ไ2(u 5"… #œ#๙$Ÿ%z%ษ'D 'ข+K+--ิ0^00๚1K 1๋2•2ม3ค44‰4๏6N7b::ฒ=,> ??\?๔Aภ B๊F:GผIIฬJ" JงK"Kง K๕LLฐ LโM๔.NอN๛PvP:QทSเTJUฝV|XXZXจY ZIZœZ๏_R` `/`Ž`๋aมb#bึcFdณee[eˆeg‡h†i.j“n#oyp<r๊tu4u๋ zz-{x{ฯ|_|ร}e<!v‚ ‚„ƒy „X „|„ม†ห‡0‡ฐˆ‡ ‰3Šƒz&ŽGŽjŽฺฏ‘8‘ฆ‘้’*’ฝ“)“Š“๐f”๗ •b•Š–ฝ—ต™† š2šŒ›.Ÿ๕กก. ข8ฃค”ฅฅG&ฅปฆ:ฆฉ๏"ูฯ๏7[  7-%ฮ#œ1K>?๔GKงLโXZXจYeei.r๊u๋ๆ‚„ƒy‹Žฺ—ต˜vฅG งฒ6ืฆื๕ุูฯ/โๅ_็Š๊†๓a๕ [ 72 #œ%z2ม49ะ??๔K๕LLโM๔PQทTJUฝXZZ๏`๋bึdณeoูr๊yyบz-{ฯ<ƒR‹z’“๐ ™†กฅฅGฆ ื๕้ฏ๎–๓a[1๋Pi.pฌtz’ู ๓a'ขK๕M๔NอN๛Xจ^ฟu4u๋‘8’“๐šŒืฆื๕ุใฦ๓| 2Prl{ฯ„Xz‘้“๐ฅGฆ: ู ๑P๓aุจ22•{ฯกฅGใฦ๎– )20๚M๔ฏาุ˜๓aะ-#œ#๙%z1K2ม?K๕LN๛XZ`/dณr๊{ฯ<ˆ‡ูฯ้ฏ๓a1๋Pi.‘้ัฐ๓aZ‘1๋4Pe{ฯ’“๐›.ฅG$oูv๚z-ƒyi.“๐6ƒR์‚จh†กัUัฐื๕ุ )๒M๔b#u๋{ฯ‚„ˆ‡zŽฺ”kฆงฒ'ขN๛{ฯN๛๓aV|•b๓abึAภๅ_ 7“๐™†กM๔M๔?๔Lโ๑ ^ 7 ๗ๆ#œ0๚>>qKงeแ#0๚>q+oู“๐{ฯ‘้ืฆๅ_|๓ 7#œ$Ÿ%z1K1๋??๔J"XจŽG’™†ฆงฒญ0๚>qฅG 7ถฮtฯ…ฯ๔ะัฐาพิึ8ืฆื๕ ุู ูฯฉแ#แโใ๚ไ๖ๅ_ๆP็Š้ฏ๊†๊ั๋€์๏7๑P๓๓a๔๏๕ ๖ฒ๗8๗ๆ๘ซ๛ไฌRุ)|[ห๓มจ > ) R 7 a-ะ->๒ฮ$‘–2ฯ W"…#œ#๙$Ÿ%z'D'ข0^00๚1K1๋2•2ม3ค49:9ะ:=,>>q??๔AAภB๊GHgIJ"K"KงK๕LLฐLโM6M๔NอN๛PvPQทRSเ UฝV|XXZXจ YZIZ๏`/`๋ aมb#b‚eeˆegh†i.j“kสn#oูp<rlr๊tyyบz-{x{ฯv‚3ƒRƒy„|„ม…๔†ห‡0‡\‡ฐˆ฿Šƒz‘8‘ฆ‘้’“๐”k–ฝ™†šŒšžžŠ ขกข8ฅฅGฆ:ฆื๕z>Kงฮถ้เ#ฯcาื๕/฿Gโ5ไฃ้เ๊†๏ุ๑P๓a๔-๔๏๗8๓ ›ะ%#œ#๙0๚1K>>qKงN๛{ฯๆz˜vก.ใฦPแ#K"P้ฏ์‚จ-Gi.ƒRูฯXZr๊“๐ุM๔ใ&&#K"!ฉ{ฯ’R}_๊†๓a >"…=,MิM๔PV|{ฯ|ร๗“๐ƒy๔-i.ฯc๘|ƒR,M'ะGะื๕แแยโ๋€๘ซ๚อ)ž-O62š W-ิ9ะ::ฺAHgIฬM๔OMTi`๋an#oูyบzั‡0‡\z•Š ขฃ2๙cน}7ื๕zำZื๕ zื๕zแ#9ะM๔yบแกu4u4๖k›ฟPPPP>KงYƒy\‹ฅGงฒSเu4๓a๓aื๕ื๕$ิฏโ๗ๆ ) ๑ 7ะ-#œ#๙0๚1K>>qKงM6MŠXจ`๋eŠƒ’x–ฝฃถ ใฦ )->?๔KงLโYฅG2มLฅG ใฦ๗ๆะ#œY`๋dณ}e<ฅG‹ใฦใฦe[p}7แแแแกแ#oy๓Sเ{ฯ{ฯˆ‡จ`๋๘ซฯั๋’๓ไ๖%z?K๕ก๙!-`Ž{ฯ’ุ˜๔๏[$PQทi.p<{ฯƒR‰3’“๐ข8+ำ2ื๕ ู ไ๖์‚๎n๓a๘ซ[จ 7 a‘2"…'D'ข49ะ=,AภM๔NอPV|XXจZ๏cFe[i.yบ|รvƒRƒy„XzŽG“๐•bกJฮถฯัะฺะัUัฐูฯฉ%ˆแ#แ โไ๖้ฏ้เ๋๋€์๏7๘ซ๙!๛ไ- 7 Š์2u 5 W$L$Ÿ&ธ+-0^:ฒGผHgK๕PQทSเTJ` `Ž`๋bึh†i.n#oyp<tu4{ฯ|_‡0‡\‡ฐˆ‡‰3’ฝ“)“Š“๐Ÿ๕กข8ฅฅGฉแ#ไ๖๓a-$ŸB๊GQทi.ƒR„X‡ฐœ ฉ๎–๖ฒุ๒2•LฐP—ตื๕ูฯ๔๏๙06NJ"cน}7ƒyˆ฿‰3z“๐”๗]ไ'ขโ๓a’Xจ"ฯ๔ำ2แ๎n) > a$"…$Ÿ&ธ'D0‰3ค=,?๔AAภJงK"LโM๔N๛PV|XZYcFr๊|ร„|“๐•bฅG ืฆื๕ๅ_๓a|%Pz™†ฅG ืฆื๕ๅ_๓a |Nt–z™†๓aZœ!แ๗81๋กฅG )-จจ+’ ื๕฿Gโ[2ˆ‡z’ก. 7ƒRืฆื๕|’็f๔๏ ๕ _Rุ็Š๔๏๕ y๔๏๓a๗8ื๕zฅ์‚bึ“๐้ฏPSเโใ๚1๋โ ็Š๕ [29ะh†yyบ‘8๓a๔๏;Xจ„ม/ไฃๅ_๑P–&ธF:PXZr๊z-ๆ‘้˜v™†ูฯu4N๛ุ#œ%z1K? 7#œ%z1K2ม>??๔KงLXจe—ต 7ะ#œ#๙1Kื๕๖ฒŸ๕ืฆ|2?๔Lโฅ้ฏ4P i.ัUัฐาื๕ไ๖ ) a-$–$L4J"M๔PXZYZ๏`๋r๊„Xˆ‡‘8“๐ฅฅGCฯ…ำ2ืฆื๕ ุู „แใฦไ๖้ฏ๊ั๎n๎–๓a๔๏๛'ม > ข 7 a %ฮ$–2"…$Ÿ'D0‰0=,>AภF:JงKงM๔PvPV|XZ๏`๋b#cFcนi.|ร}7‚„„Xˆ‡ˆ฿‘8‘้’“๐ ”k•bœก๖ฒ>AภKงP2ฮถัฐา฿G้เ๗8)ํ?๔LโM๔N๛PXจYu๋{ฯ‚„ˆ‡Žฺ“๐ก.้ฏ>ฝi.“๐ ูฯ 7-0๚>qGerlƒR ๓๒%z2ม?Ldณ{ฯ<’Ÿ๕ฆ:(ัฐาุ˜฿G๓a๗8๘ซ[ )ะ-–2 #œ#๙%z'ข1K2ม??๔J"LLโNอQทXZ`/i.r๊{ฯƒR†ห‘้“๐”๗ก.8ำ2ื๕/แไ๖ๆP๎n๏7๓a๘ซ๙!๛…๓จ > a $2"…$Ÿ'D+K1๋9ะ=,AภE—F:JงM๔NงPV|XZ_พ`๋cFh†i.r๊yบz|รƒRƒy†ห‡0z’“๐ ”๗•bกำ2้เ๎n๑P๓a| > )"…'ข0๚=,>qJงM๔NอPV|ZIcF|รz‘8‘้’•bฅG2>Kง’ก2ƒyƒy'DM๔Sเh†’M๔`๋M๔—ต•ŠP๓aM๔Pื๕z0๓aื๕[+K9ะM๔PQทXจ`๋yบƒyz“๐,ำ2ื๕ุไ๖็Š๎n๓a๕ ๘ซ๙![ )-$2"…0๚9ะ=,>>qKงM๔PSเV|Xจ`/`๋cFh†oูyyบ|ร„X†ห‡0z“๐•bšŒPPPoูP๙!‘้ฅGUb™D๊3\{—jqNโำŠแ}ทtE๐ฦ2@Isstruct Loki::LongevityLifetime::DieAsSmallObjectChilda00045.htmlMember Loki::FixedAllocator::CountEmptyChunksa00056.html#e74cbab50e78bfa115d7c0fcdce00641Loki::FixedAllocator::FixedAllocatora00056.html#ce7ad725a2f44c427641f4ce629a3aacclass Loki::StrongPtra00135.htmlMember Loki::StrongPtr::Equalsa00135.html#0c197e9b4f68669529435577357ffa57class Loki::AllowReseta00004.htmlMember Loki::DeleteUsingFree::Defaulta00043.html#7b6ba686ce808a9c000067d7722dbd16Member Loki::FunctionStorage::StoredTypea00063.html#52a1fc18d9685e6496bde1078e6949c5Loki::AssertCheck< P > Struct Template Referencea00010.htmlclass Loki::RefCounteda00102.htmlMember Loki::DefaultSPStorage::PointerTypea00038.html#70074a5e2fe5b95668d4e5bb0f0909a8Member Loki::SmallObjectBase::operator deletea00129.html#b835d84fa8bc1ed3a558dc2e7a7e39ecMember Loki::AllocatorSingleton::ClearExtraMemorya00002.html#082b4ba1c6574c5bed916c55ecf46e82Member Loki::SmallObjAllocator::TrimExcessMemorya00127.html#6b635664b20a6984303dabde86c8ac83Loki::SmallObjAllocator::Deallocatea00127.html#2b669733cfa9dd157603d13d979f8c1cstruct Loki::FollowIntoDeath::AfterMastera00058.htmlLoki::CreateStatic< T > Struct Template Referencea00030.htmlclass Loki::ScopeGuardImpl4a00115.htmlMember Loki::SafeBitConst::SafeBitField< unique_index, word_t >a00110.html#14541da61dccc9821659cd1ce5d3dff1Loki::SafeBitConst::field_ta00110.html#fc37803aa81f3704a2cef0ece9e8948cMember Loki::LockingPtr::operator->a00077.html#d717c6fad1cc209cfbd04afb68717824Loki::MultiMutexLocker::IsLockeda00080.html#1bdfd6380329fff07890d2bc0e67427fLoki::MutexLocker::Unlocka00083.html#f5ea31fe3fac046cf646722cc8befa09Member Loki::MutexException::operator=a00082.html#83db7c4cea71a007dd597061833f40eaLoki::LevelMutex::GetMutexPolicya00070.html#9a9abaa6b4148b9b02bd279615872e90Loki::SpinLevelMutex::SpinLevelMutexa00133.html#89f6e3f88dd10a5940d53764cf0f29b5Loki::LevelMutexInfo::LevelMutexInfo::MutexUndoer Class Referencea00073.htmlMember Loki::LevelMutexInfo::LevelMutexInfoa00071.html#0e7b01d7e0aad6710f34de9811a88151Loki::LevelMutexInfo::MultiLocka00071.html#a76848d3aa8e6c66454bd5357f715583Loki::LevelMutexInfo::IsLockeda00071.html#e6aa7465e1bba7f0c9fbf0b06f122a39Loki::Factory< AbstractProduct, IdentifierType, CreatorParmTList, FactoryErrorPolicy > Class Template Referencea00055.htmlMember Loki::StaticChecker::Checka00134.html#d8e80dcf79a603395ecc9d5b2fe91491class Loki::ContractCheckera00029.htmlMember Loki::CachedFactory::ReleaseObjecta00014.html#c307db6556acef8179a260db4d573440class Loki::EvictRandoma00054.htmlclass Loki::NeverCreatea00085.htmlLoki::LokiAllocator::deallocatea00078.html#3713aa29d4ccf61db725f7ba4111eaa9Member Loki::GetLongevitya00192.html#bd6a1e278e749117c26908963320b02eLoki::operator!=a00218.html#gd6031d88c8485cea6a6f4a89356e638aLoki::GetLongevitya00192.html#bd6a1e278e749117c26908963320b02estruct RefCountedMTa00103.htmlLOKI_DEFINE_CYCLIC_VISITABLEa00227.html#gb976a68573455c07def553bdc34203f7Member Loki::operator>=a00218.html#g239a9b1c4e557388ba4b9c39051c3f4eMember Loki::operator!=a00218.html#g7c1d35d961854e812b743b22c89f14f8Loki::operator<=a00218.html#gad6d21d0d77ddc1668f90a115884f8a3Internalsa00217.htmlLOKI_CHECK_CLASS_IN_LISTa00210.html#g33d521dc1c8f768f42b15a34a2574a5cStatistic policiesa00204.htmlLoki::CountMutexesAtCurrentLevela00192.html#8cb767d3e7aaf2fe44b8f3b90218b876Checker.h File Referencea00147.htmlLoki::Private::TwoRefCountInfo Class Referencea00138.htmlMember Loki::FixedAllocator::Deallocatea00056.html#49ab7ca3364fe05f2d7d91248ee5d0e3Member Loki::FixedAllocator::FixedAllocatora00056.html#ce7ad725a2f44c427641f4ce629a3aacMember Loki::StrongPtr::Locka00135.html#70ad60678f72611567acc26fc718fed6Loki::StrongPtr::LessThana00135.html#baea90f6e505a2afc662fe07c9c117faLoki::NeverReset< P > Class Template Referencea00086.htmlclass Loki::DeleteUsingFreea00043.htmlLoki::FunctionStorage::InitPointerTypea00063.html#08681726c77c6a7492a375de7c34a1bestruct Loki::AssertChecka00010.htmlLoki::COMRefCounted< P > Class Template Referencea00027.htmlclass Loki::DefaultSPStoragea00038.htmlLoki::SmallObject< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > Class Template Referencea00128.htmlMember Loki::AllocatorSingleton::IsCorrupteda00002.html#033978d127f16d2da0fd79d31ee75713Loki::AllocatorSingleton< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > Class Template Referencea00002.htmlLoki::SmallObjAllocator::Deallocatea00127.html#50406896d75a2591d4bd7dc53325e3d6Loki::FollowIntoDeath::FollowIntoDeath::AfterMaster< Master >::FollowIntoDeath::AfterMaster::IsDestroyed< F > Struct Template Referencea00059.htmlstruct Loki::CreateStatica00030.htmlLoki::ScopeGuardImpl5< F, P1, P2, P3, P4, P5 > Class Template Referencea00116.htmlclass Loki::SafeBitConsta00110.htmlMember Loki::SafeBitConst::field_ta00110.html#fc37803aa81f3704a2cef0ece9e8948cclass Loki::LockingPtra00077.htmlMember Loki::MultiMutexLocker::IsLockeda00080.html#1bdfd6380329fff07890d2bc0e67427fLoki::MutexLocker::IsLockeda00083.html#231de9c6db22151209ab2537fc45c65eLoki::MutexException::~MutexExceptiona00082.html#da086bdfbb91bb49ef96d6961f39b417Loki::LevelMutex::TryLocka00070.html#042a7938dafd6f149cfd7da46478c0c9Member Loki::SpinLevelMutex::SpinLevelMutexa00133.html#89f6e3f88dd10a5940d53764cf0f29b5class Loki::LevelMutexInfo::MutexUndoera00073.htmlMember Loki::LevelMutexInfo::GetCurrentMutexa00071.html#b7fd94847721b118979b72121472d3e2Loki::LevelMutexInfo::MultiUnlocka00071.html#475d734ba0e756935462a5151ea98065Member Loki::LevelMutexInfo::IsLockeda00071.html#e6aa7465e1bba7f0c9fbf0b06f122a39class Loki::Factorya00055.htmlLoki::CheckReturn< Value, OnError > Class Template Referencea00022.htmlMember Loki::ContractChecker::ContractCheckera00029.html#47a88a788d4099204e3a49593e4ff2a2Loki::CheckForNoThrow< Host > Class Template Referencea00021.htmlclass Loki::EvictRandoma00054.htmlLoki::AlwaysCreate Class Referencea00005.htmlMember Loki::LokiAllocator::deallocatea00078.html#3713aa29d4ccf61db725f7ba4111eaa9Member Loki::operator!=a00192.html#a5a779d50d4d4a37aa3664e5a9f01681Loki::operator<a00218.html#g8408e61306f223b3721f7792c8e172a9Loki::operator==a00218.html#gb3333b9378688690b921def21298d2bfVisitor Class Referencea00142.htmlMember LOKI_DEFINE_CONST_VISITABLEa00227.html#g0d60fea385397a82b9d3b3d231517777Member Loki::operator>=a00218.html#g93341dd134031aede8273376ed13578dMember Loki::operator!=a00218.html#g2c4d3dae616ecca69b25e3af91927b66Loki::operator<=a00218.html#geae99a03480ac6f8882d1799f8f1606cLoki::GetOffseta00217.html#g2f0821e243f812a3ae2abfaea51895e8Loki::RegisterFunctiona00210.html#g14cf89ecf59f8bf3a6d47cdfe5ff389dGroup Statistic policiesa00204.htmlLoki::DoMutexesMatchContainera00192.html#d633ca81ae0befaf235ae63886368037Checker.ha00147.htmlclass Loki::Private::TwoRefCountInfoa00138.htmlMember Loki::FixedAllocator::HasBlocka00056.html#f84b504579cea189ce1c415ee8ed5d2cLoki::FixedAllocator::~FixedAllocatora00056.html#080589e92d310aeb4e432d195bcd7ba5Member Loki::StrongPtr::Mergea00135.html#e493c465f8e0067db7fa98271be5a0c6Member Loki::StrongPtr::LessThana00135.html#baea90f6e505a2afc662fe07c9c117faclass Loki::NeverReseta00086.htmlLoki::DeleteNothing< P > Class Template Referencea00041.htmlMember Loki::FunctionStorage::InitPointerTypea00063.html#08681726c77c6a7492a375de7c34a1beLoki::AssertCheckStrict< P > Struct Template Referencea00011.htmlclass Loki::COMRefCounteda00027.htmlLoki::LockedStorage< T > Class Template Referencea00076.htmlclass Loki::SmallObjecta00128.htmlLoki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > Class Template Referencea00129.htmlLoki::AllocatorSingleton::MyAllocatora00002.html#47fa2a9f8348fc8ce749221f7bfa7245Loki::SmallObjAllocator::GetMaxObjectSizea00127.html#e49e9de3fd7b2fd93676cc1d63299b0dstruct Loki::FollowIntoDeath::AfterMaster::IsDestroyeda00059.htmlLoki::DefaultLifetime< T > Struct Template Referencea00037.htmlclass Loki::ScopeGuardImpl5a00116.htmlMember Loki::SafeBitConst::operator<<a00110.html#70a37a966ba91fe89ac6f5f661f04279Loki::SafeBitConst::SafeBitConsta00110.html#5ca867866c32c41efd30b5912daf48baMember Loki::LockingPtr::LockingPtra00077.html#9d430a6e7f83dfed1ed5f8111b6826caLoki::MultiMutexLocker::GetMutexesa00080.html#1b95c9bfa8ff0737d0afd67d9820f67fMember Loki::MutexLocker::IsLockeda00083.html#231de9c6db22151209ab2537fc45c65eMember Loki::MutexException::~MutexExceptiona00082.html#da086bdfbb91bb49ef96d6961f39b417Loki::LevelMutex::Locka00070.html#95d3742db062548201986f482a9c9b9dLoki::SpinLevelMutex::~SpinLevelMutexa00133.html#7740e7e636a9513d73891aa874a00777Loki::ThrowOnAnyMutexError Class Referencea00136.htmlMember Loki::LevelMutexInfo::IsRecentLocka00071.html#ebf33c02e3dd8adb0155fd827b5cfccdLoki::LevelMutexInfo::GetCurrentMutexa00071.html#b7fd94847721b118979b72121472d3e2Loki::LevelMutexInfo::GetLockCounta00071.html#013e7ffd438e4c1f11dcc6943a40802eLoki::CloneFactory< AbstractProduct, ProductCreator, FactoryErrorPolicy > Class Template Referencea00026.htmlLoki::CheckReturn::CheckReturna00022.html#9e250eb61af69adaee7773a79400a6f7Member Loki::ContractChecker::~ContractCheckera00029.html#ac668398deabba5291b9025b4ac4eafdclass Loki::CheckForNoThrowa00021.htmlLoki::NoStatisticPolicy Class Referencea00091.htmlclass Loki::AlwaysCreatea00005.htmlLoki::LokiAllocator::max_sizea00078.html#78270e4c9b333f80199bc0867b4b9e0aMember Loki::operator==a00192.html#283454c89a3b507c74f05bb038daa173Loki::operator<a00218.html#g7abc768179c277d50bbb59fdee609668Loki::operator==a00218.html#gd6987be67b5ae633a9ca282aa7cbc13bclass Visitora00142.htmlMember LOKI_DEFINE_CYCLIC_VISITABLEa00227.html#gb976a68573455c07def553bdc34203f7Member Loki::operator>=a00218.html#g5a4d9a68820aeaed1974a236b380fb49Member Loki::operator!=a00218.html#gf30cc0b3f416d8703d4a4534c52b56b4Loki::operator>=a00218.html#g54b4de5905940e3780e6e64944f74a11Loki::DefaultAllocatora00217.html#g2444c5bff0a61b6751fb5f57e0c7e8c7Loki::UnRegisterFunctiona00210.html#g8d2c3c45de75a6829be4f21a2575baccGroup Statistic policiesa00204.htmlLevelMutex.ha00158.htmlChecker.ha00147.htmlLongevityLifetime Namespace Referencea00196.htmlMember Loki::FixedAllocator::IsCorrupta00056.html#41a7ad189cba00f504635aade8b3d15cMember Loki::FixedAllocator::~FixedAllocatora00056.html#080589e92d310aeb4e432d195bcd7ba5Member Loki::StrongPtr::Unlocka00135.html#c3afffc8a90f5369c895a220bcc6db34Loki::StrongPtr::GreaterThana00135.html#f43b2cde389f926c16e166c418b13040Loki::TwoRefCounts Class Referencea00139.htmlclass Loki::DeleteNothinga00041.htmlLoki::FunctionStorage::PointerTypea00063.html#0e56f22b839615e3082416ca4025ca69struct Loki::AssertCheckStricta00011.htmlLoki::DeepCopy< P > Struct Template Referencea00035.htmlLoki::LockedStorage::InitPointerTypea00076.html#77b3c2a08c0d43a83b447d9c2c34bbb6Loki::SmallValueObject< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > Class Template Referencea00130.htmlLoki::SmallObjectBase::ObjAllocatorSingletona00129.html#d07df1c9ec9c41580e07e32eddcda82dMember Loki::AllocatorSingleton::MyAllocatora00002.html#47fa2a9f8348fc8ce749221f7bfa7245Member Loki::SmallObjAllocator::GetMaxObjectSizea00127.html#e49e9de3fd7b2fd93676cc1d63299b0dLoki::FollowIntoDeath::FollowIntoDeath::With< Lifetime > Struct Template Referencea00060.htmlstruct Loki::DefaultLifetimea00037.htmlLoki::ObjScopeGuardImpl0< Obj, MemFun > Class Template Referencea00093.htmlMember Loki::SafeBitConst::operator|a00110.html#aefcf0a24311e7cd30a7ab66f5281661Member Loki::SafeBitConst::SafeBitConsta00110.html#5ca867866c32c41efd30b5912daf48baMember Loki::LockingPtr::LockingPtra00077.html#e4ae5d4ed12dbcac9fffd8241dd1cc2bMember Loki::MultiMutexLocker::GetMutexesa00080.html#1b95c9bfa8ff0737d0afd67d9820f67fLoki::MutexLocker::GetMutexa00083.html#2b49f0c689ff6cb8e29f2d8963b041dfLoki::MutexException::whata00082.html#7f27c5ead8129c709c16f1a94a427361Loki::LevelMutex::Locka00070.html#d4ac0c2a33ff3d98ec0a83f70ce145daMember Loki::SpinLevelMutex::~SpinLevelMutexa00133.html#7740e7e636a9513d73891aa874a00777class Loki::ThrowOnAnyMutexErrora00136.htmlMember Loki::LevelMutexInfo::IsRecentLocka00071.html#b917108c3e7c83b8a515d28e91a3a3caLoki::LevelMutexInfo::UnlockedLevela00071.html#1f68bae408eb26856776cf02efed90bcMember Loki::LevelMutexInfo::GetLockCounta00071.html#013e7ffd438e4c1f11dcc6943a40802eclass Loki::CloneFactorya00026.htmlMember Loki::CheckReturn::CheckReturna00022.html#9e250eb61af69adaee7773a79400a6f7Member Loki::ContractChecker::Checka00029.html#812565f4dccc8d50be8f7b9c91841a51Loki::CheckForNoChange< Host > Class Template Referencea00018.htmlclass Loki::NoStatisticPolicya00091.htmlclass Loki::AlwaysCreatea00005.htmlMember Loki::LokiAllocator::max_sizea00078.html#78270e4c9b333f80199bc0867b4b9e0aLoki::LokiAllocator< Type, AllocT > Class Template Referencea00078.htmlLoki::operator>a00218.html#g05304aaf9fabf1dda13ddff6146e2fe2Loki::operator!=a00218.html#gf30cc0b3f416d8703d4a4534c52b56b4Loki Namespace Referencea00192.htmlMember LOKI_DEFINE_VISITABLEa00227.html#g2b6ed280714eca44a2713d3cee5b2093Member Loki::operator>=a00218.html#g54b4de5905940e3780e6e64944f74a11Member Loki::operator<a00218.html#g7abc768179c277d50bbb59fdee609668Loki::operator>=a00218.html#g5a4d9a68820aeaed1974a236b380fb49Loki::DefaultDeallocatora00217.html#g1d24bf776342ace8f2004e3a173f6cb3Member LOKI_CHECK_CLASS_IN_LISTa00210.html#g33d521dc1c8f768f42b15a34a2574a5cFactorya00205.htmlMember LOKI_THREAD_LOCALa00158.html#8235533deec74e2a08322dd48eab5ab2LevelMutex.cpp File Referencea00157.htmlNamespace LongevityLifetimea00196.htmlMember Loki::FixedAllocator::TrimChunkLista00056.html#2b92d73c032c2ae6942ef9aadf6f27fcLoki::FixedAllocator::Initializea00056.html#5fb8edbf26f6ab26a0c332391909fa0cLoki::Mutex Class Referencea00081.htmlMember Loki::StrongPtr::GreaterThana00135.html#f43b2cde389f926c16e166c418b13040Loki::TwoRefCounts::~TwoRefCountsa00139.html#66b5b302258aae61996f43fd4d541440Loki::DeleteSingle< P > Class Template Referencea00042.htmlMember Loki::FunctionStorage::PointerTypea00063.html#0e56f22b839615e3082416ca4025ca69Loki::NullPointerException Struct Referencea00092.htmlstruct Loki::DeepCopya00035.htmlMember Loki::LockedStorage::InitPointerTypea00076.html#77b3c2a08c0d43a83b447d9c2c34bbb6class Loki::SmallValueObjecta00130.htmlLoki::SmallObjectBase::operator newa00129.html#39f9c8d5b17c09bece34c8a400981970Loki::AllocatorSingleton::MyThreadingModela00002.html#c9fde708e2ee0bf990c3eaa34422ca25Loki::SmallObjAllocator::GetAlignmenta00127.html#b1c8a2a3d7e9368ab59422ddd082105cstruct Loki::FollowIntoDeath::Witha00060.htmlLoki::PhoenixSingleton< T > Struct Template Referencea00097.htmlclass Loki::ObjScopeGuardImpl0a00093.htmlLoki::ScopeGuardImplBase Class Referencea00117.htmlLoki::SafeBitConst::SafeBitConsta00110.html#ffc6ec193df68bc5888c3e0249318b09Loki::ConstPropPtr< T > Class Template Referencea00028.htmlclass Loki::MultiMutexLockera00080.htmlMember Loki::MutexLocker::GetMutexa00083.html#2b49f0c689ff6cb8e29f2d8963b041dfMember Loki::MutexException::whata00082.html#7f27c5ead8129c709c16f1a94a427361Loki::LevelMutex::Unlocka00070.html#553a379257af57ceaef9ed48b0dc8b70class Loki::SpinLevelMutexa00133.htmlLoki::ThrowOnBadDesignMutexError Class Referencea00137.htmlMember Loki::LevelMutexInfo::IsValida00071.html#36c34ecf5d019f3db9bfb8654cf49176Loki::LevelMutexInfo::LevelMutexInfoa00071.html#0e7b01d7e0aad6710f34de9811a88151Loki::LevelMutexInfo::GetPreviousa00071.html#b774e94ff72724dd87ff236d99970bb5Loki::Functor< R, TList, ThreadingModel > Class Template Referencea00064.htmlLoki::CheckReturn::CheckReturna00022.html#c25f0d90452244c84dafbb23c5cdb012Loki::CheckStaticForNoThrow Class Referencea00024.htmlclass Loki::CheckForNoChangea00018.htmlclass Loki::NoStatisticPolicya00091.htmlLoki::RateLimitedCreation Class Referencea00101.htmlLoki::LokiAllocator::constructa00078.html#f6f7b3cb7e64ee71a2bda37e78c08654Loki::LokiAllocator::LokiAllocatora00078.html#ca0350e215466300ad6e6998f272aba5Loki::operator<=a00218.html#g272c9c4d6381679daba26c93ac36a70eLoki::operator!=a00218.html#g2c4d3dae616ecca69b25e3af91927b66Loki::operator==a00192.html#283454c89a3b507c74f05bb038daa173AbstractFactory Class Referencea00001.htmlOwnership policiesa00219.htmlMember Loki::operator<a00218.html#g8408e61306f223b3721f7792c8e172a9Loki::operator==a00218.html#gb5a35f4e3da89fb451c36891a96ab244Member Loki::DefaultAllocatora00217.html#g2444c5bff0a61b6751fb5f57e0c7e8c7Member Loki::RegisterFunctiona00210.html#g14cf89ecf59f8bf3a6d47cdfe5ff389dGroup Factorya00205.htmlFactoriesa00198.htmlLevelMutex.cppa00157.htmlstd Namespace Referencea00197.htmlMember Loki::FixedAllocator::TrimEmptyChunka00056.html#4df95a9324de31f05d931f2eea25165eMember Loki::FixedAllocator::Initializea00056.html#5fb8edbf26f6ab26a0c332391909fa0cclass Loki::Mutexa00081.htmlLoki::StrongPtr::operator==a00135.html#a3de2b1fa05e1345761a2227164967ecclass Loki::TwoRefCountsa00139.htmlLoki::DeleteSingle::Deletea00042.html#d6c44662923b94ae70478b91f5034860Loki::FunctionStorage::ReferenceTypea00063.html#9d90fd63b1864a25cda9f1c76a276841struct Loki::NullPointerExceptiona00092.htmlLoki::RefLinked< P > Class Template Referencea00104.htmlLoki::LockedStorage::PointerTypea00076.html#88844c5eb40b576359da4234b76702d8Loki::HeapStorage< T > Class Template Referencea00065.htmlMember Loki::SmallObjectBase::operator newa00129.html#39f9c8d5b17c09bece34c8a400981970Member Loki::AllocatorSingleton::MyThreadingModela00002.html#c9fde708e2ee0bf990c3eaa34422ca25Member Loki::SmallObjAllocator::GetAlignmenta00127.html#b1c8a2a3d7e9368ab59422ddd082105cLoki::FollowIntoDeath::FollowIntoDeath::With< Lifetime >::FollowIntoDeath::With::AsMasterLifetime< Master > Struct Template Referencea00061.htmlstruct Loki::PhoenixSingletona00097.htmlLoki::ObjScopeGuardImpl1< Obj, MemFun, P1 > Class Template Referencea00094.htmlLoki::ScopeGuardImplBase::ScopeGuardImplBasea00117.html#d71436d97ac8d12c1057707c6b5472e5Member Loki::SafeBitConst::SafeBitConsta00110.html#ffc6ec193df68bc5888c3e0249318b09class Loki::ConstPropPtra00028.htmlMember Loki::MultiMutexLocker::MultiMutexLockera00080.html#aa646ae058e3273651f89bfbb276cf42class Loki::MutexLockera00083.htmlLoki::MutexException::GetLevela00082.html#9dacfdcd19078fe4ee9ddca3fe61867dclass Loki::LevelMutexa00070.htmlLoki::SleepLevelMutex Class Referencea00126.htmlclass Loki::ThrowOnBadDesignMutexErrora00137.htmlMember Loki::LevelMutexInfo::IsValidLista00071.html#01f6dfba5d2ea5606109b34e5a543cf0Loki::LevelMutexInfo::~LevelMutexInfoa00071.html#5d6713a7bc49313e970c91cfeb208d0eMember Loki::LevelMutexInfo::GetPreviousa00071.html#b774e94ff72724dd87ff236d99970bb5class Loki::Functora00064.htmlLoki::CheckReturn::~CheckReturna00022.html#9da9337fca355e5dbcadc246159719f7class Loki::CheckStaticForNoThrowa00024.htmlLoki::CheckForNoChangeOrThrow< Host > Class Template Referencea00019.htmlLoki::SimpleStatisticPolicy Class Referencea00119.htmlclass Loki::RateLimitedCreationa00101.htmlMember Loki::LokiAllocator::constructa00078.html#f6f7b3cb7e64ee71a2bda37e78c08654Member Loki::LokiAllocator::LokiAllocatora00078.html#ca0350e215466300ad6e6998f272aba5Loki::operator<=a00218.html#g24773dba1237da071b5df66455393f1dLoki::operator<a00218.html#g19b38e411732f476e3b288ccbd397331Loki::operator!=a00192.html#a5a779d50d4d4a37aa3664e5a9f01681class AbstractFactorya00001.htmlStorage policiesa00220.htmlMember Loki::operator<a00218.html#gf8a4e6ef7065932113a924ee9e9fd63aLoki::operator==a00218.html#g26dc37f18d3112b69b35514b5e1fd749Member Loki::DefaultDeallocatora00217.html#g1d24bf776342ace8f2004e3a173f6cb3Member Loki::UnRegisterFunctiona00210.html#g8d2c3c45de75a6829be4f21a2575baccGroup Factorya00205.htmlAbstract Factorya00199.htmlLoki::GetCurrentThreadsLevela00192.html#9548795d9cda6f227a1e1241ba577ca8Namespace stda00197.htmlLoki::LongevityLifetime::SingletonFixedLongevity< Longevity, T > Struct Template Referencea00123.htmlLoki::FixedAllocator::Allocatea00056.html#c29973a11534fb1006fd28db97a17bedLoki::SingleThreaded< Host, MutexPolicy > Class Template Referencea00120.htmlMember Loki::StrongPtr::operator==a00135.html#a3de2b1fa05e1345761a2227164967ecMember Loki::TwoRefCounts::~TwoRefCountsa00139.html#66b5b302258aae61996f43fd4d541440class Loki::DeleteSinglea00042.htmlMember Loki::FunctionStorage::ReferenceTypea00063.html#9d90fd63b1864a25cda9f1c76a276841Loki::RejectNullStatic< P > Struct Template Referencea00108.htmlclass Loki::RefLinkeda00104.htmlMember Loki::LockedStorage::PointerTypea00076.html#88844c5eb40b576359da4234b76702d8Loki::HeapStorage::InitPointerTypea00065.html#533bd38c232cba5193b2588f868cd3e7Loki::SmallObjectBase::operator newa00129.html#d212efa68b48292bf8fd2dd158b49400Loki::AllocatorSingleton::MyAllocatorSingletona00002.html#74b23f8327ce4f3d795aa20240deb99eLoki::SmallObjAllocator::TrimExcessMemorya00127.html#6b635664b20a6984303dabde86c8ac83struct Loki::FollowIntoDeath::With::AsMasterLifetimea00061.htmlLoki::DeletableSingleton< T > Struct Template Referencea00039.htmlclass Loki::ObjScopeGuardImpl1a00094.htmlMember Loki::ScopeGuardImplBase::ScopeGuardImplBasea00117.html#d71436d97ac8d12c1057707c6b5472e5Loki::SafeBitConst::operator==a00110.html#fa999efd984ef43c0e8c1a637df87412Loki::Pimpl< T, Pointer > Class Template Referencea00098.htmlMember Loki::MultiMutexLocker::MultiMutexLockera00080.html#a88fcf2068f0c4292e2f25fcd29c3e33Member Loki::MutexLocker::MutexLockera00083.html#ae8699ba4423d83aff277149c9008ec8Member Loki::MutexException::GetLevela00082.html#9dacfdcd19078fe4ee9ddca3fe61867dMember Loki::LevelMutex::LevelMutexa00070.html#e770e4e5ec2fa120d016eb23b56d988bLoki::SleepLevelMutex::SleepLevelMutexa00126.html#89785c46dc2bde328e1908e25d6b747bLoki::AssertAnyMutexError Class Referencea00008.htmlMember Loki::LevelMutexInfo::Locka00071.html#5782b9fd9734d95a38ff86ef9532c89bMember Loki::LevelMutexInfo::~LevelMutexInfoa00071.html#5d6713a7bc49313e970c91cfeb208d0eLoki::LevelMutexInfo::TryLocka00071.html#32f89bf087b932de0cdd1151116779b4Loki::BinderFirst< OriginalFunctor > Class Template Referencea00013.htmlMember Loki::CheckReturn::~CheckReturna00022.html#9da9337fca355e5dbcadc246159719f7Loki::CheckStaticForNothing Class Referencea00023.htmlclass Loki::CheckForNoChangeOrThrowa00019.htmlclass Loki::SimpleStatisticPolicya00119.htmlclass Loki::RateLimitedCreationa00101.htmlLoki::LokiAllocator::destroya00078.html#213cb5506ab35d29ad8a626165d2b03aLoki::LokiAllocator::LokiAllocatora00078.html#69aaba440cb8ee0527a04691c9e3b9ebLoki::operator>=a00218.html#g93341dd134031aede8273376ed13578dLoki::operator<a00218.html#gf8a4e6ef7065932113a924ee9e9fd63aLoki::BindFirsta00208.html#g73955e915d2ef0cc231bb6ac5765e812Function Struct Referencea00062.htmlConversion policiesa00221.htmlMember Loki::operator<a00218.html#g19b38e411732f476e3b288ccbd397331Loki::operator!=a00218.html#g7c1d35d961854e812b743b22c89f14f8Member Loki::GetOffseta00217.html#g2f0821e243f812a3ae2abfaea51895e8Exception-safe codea00211.htmlFactory Error Policiesa00206.htmlGroup Abstract Factorya00199.htmlLoki::CountMutexesInCurrentThreada00192.html#ed0bb857431a808474a4b817d5c37f1cstd::less< Loki::StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > > Struct Template Referencea00069.htmlstruct Loki::LongevityLifetime::SingletonFixedLongevitya00123.htmlLoki::FixedAllocator::Deallocatea00056.html#49ab7ca3364fe05f2d7d91248ee5d0e3class Loki::SingleThreadeda00120.htmlLoki::StrongPtr::operator!=a00135.html#08e3d6dd0e6731fc1d304ec30f46c67fLoki::TwoRefLinks Class Referencea00140.htmlMember Loki::DeleteSingle::Deletea00042.html#d6c44662923b94ae70478b91f5034860Loki::FunctionStorage::FunctorTypea00063.html#e72e07ed847e973c97f8ab1e035f827astruct Loki::RejectNullStatica00108.htmlLoki::DestructiveCopy< P > Class Template Referencea00044.htmlLoki::LockedStorage::ReferenceTypea00076.html#5ffd134a01c0a2a7b0450f7969c89a2cMember Loki::HeapStorage::InitPointerTypea00065.html#533bd38c232cba5193b2588f868cd3e7Member Loki::SmallObjectBase::operator newa00129.html#d212efa68b48292bf8fd2dd158b49400Member Loki::AllocatorSingleton::MyAllocatorSingletona00002.html#74b23f8327ce4f3d795aa20240deb99eLoki::SmallObjAllocator::IsCorrupta00127.html#2b7fbd5bf5fc56e45754abd2497ad18fLoki::SingletonHolder< T, CreationPolicy, LifetimePolicy, ThreadingModel, MutexPolicy > Class Template Referencea00124.htmlLoki::DeletableSingleton::GracefulDeletea00039.html#626c2dc57146f1aea6bf911682f8e3e9Loki::ObjScopeGuardImpl2< Obj, MemFun, P1, P2 > Class Template Referencea00095.htmlclass Loki::ScopeGuardImplBasea00117.htmlMember Loki::SafeBitConst::operator==a00110.html#fa999efd984ef43c0e8c1a637df87412class Loki::Pimpla00098.htmlMember Loki::MultiMutexLocker::Locka00080.html#9ce26d13eb156c9a8b7fa6228bf6724fMember Loki::MutexLocker::MutexLockera00083.html#aeffc60518694479ac9985ee1878ed0fLoki::MutexException::GetReasona00082.html#86bcf73eef55b0f64e392f806eb096adMember Loki::LevelMutex::GetMutexPolicya00070.html#9a9abaa6b4148b9b02bd279615872e90Loki::SleepLevelMutex::~SleepLevelMutexa00126.html#4c415349db989e7f2a8f2e02cbf9db88class Loki::AssertAnyMutexErrora00008.htmlMember Loki::LevelMutexInfo::Locka00071.html#c0e21e08ee9974533a4da5008452bd04Loki::LevelMutexInfo::PostLocka00071.html#3fe2ecf1bcf2c49eae04c493f023099cLoki::LevelMutexInfo::Locka00071.html#c0e21e08ee9974533a4da5008452bd04class Loki::BinderFirsta00013.htmlLoki::CheckReturn::operator Valuea00022.html#6a77fab4729207c4c74ac74317ba58d6class Loki::CheckStaticForNothinga00023.htmlLoki::CheckForEquality< Host > Class Template Referencea00017.htmlclass Loki::SimpleStatisticPolicya00119.htmlLoki::AmountLimitedCreation Class Referencea00006.htmlMember Loki::LokiAllocator::destroya00078.html#213cb5506ab35d29ad8a626165d2b03aMember Loki::LokiAllocator::LokiAllocatora00078.html#69aaba440cb8ee0527a04691c9e3b9ebLoki::operator>=a00218.html#g239a9b1c4e557388ba4b9c39051c3f4eLoki::operator>a00218.html#g1e83c8b289a17eaa9341880a8b848c65Loki::Chaina00208.html#g1a74f9db98f84037e15dff40ca82d8ccstruct Functiona00062.htmlChecking policiesa00222.htmlMember Loki::operator<=a00218.html#g24773dba1237da071b5df66455393f1dLoki::operator!=a00218.html#gd6031d88c8485cea6a6f4a89356e638aSmart pointersa00218.htmlLoki::ByRefa00211.html#g613ad438c1e0daeec26304c83f340b76Group Factory Error Policiesa00206.htmlCached Factorya00200.htmlLoki::CountLocksInCurrentThreada00192.html#ae4c5edaad45b3657f39e8cdbae0f928struct std::less< Loki::StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > >a00069.htmlLoki::LongevityLifetime::DieLast< T > Struct Template Referencea00049.htmlLoki::FixedAllocator::BlockSizea00056.html#37df732230913b2dd9126a6b311586f0Loki::SingleThreaded< Host, MutexPolicy >::SingleThreaded::Lock Struct Referencea00121.htmlMember Loki::StrongPtr::operator!=a00135.html#08e3d6dd0e6731fc1d304ec30f46c67fLoki::TwoRefLinks::Mergea00140.html#fa3b914b3e13f0bdefa9304fae430d3fMember Loki::DeleteSingle::Deletea00042.html#d6c44662923b94ae70478b91f5034860Member Loki::FunctionStorage::FunctorTypea00063.html#e72e07ed847e973c97f8ab1e035f827aLoki::RejectNull< P > Struct Template Referencea00107.htmlclass Loki::DestructiveCopya00044.htmlMember Loki::LockedStorage::ReferenceTypea00076.html#5ffd134a01c0a2a7b0450f7969c89a2cLoki::HeapStorage::PointerTypea00065.html#11ad403d98af5c6671f47d433d67201dLoki::SmallObjectBase::operator newa00129.html#dbbe1bde0960a38502af0940004d942fLoki::AllocatorSingleton::AllocatorSingletona00002.html#c1ce92a825643f114d555fea170e2a99Loki::SmallObjAllocator::SmallObjAllocatora00127.html#3d40b34b1a2d08a6bb9d9fa22ab5ce24Loki::SingletonHolder::ObjectTypea00124.html#90400cb32897f9942958bece12165136Member Loki::DeletableSingleton::GracefulDeletea00039.html#626c2dc57146f1aea6bf911682f8e3e9class Loki::ObjScopeGuardImpl2a00095.htmlLoki::ScopeGuardImpl0< F > Class Template Referencea00111.htmlLoki::SafeBitConst::operator==a00110.html#3a78c04cbdd258c1cb54c959ffd3741aLoki::RefToValue< T > Class Template Referencea00105.htmlMember Loki::MultiMutexLocker::Unlocka00080.html#18bfdec10dd2e65e128d64a80e42407fMember Loki::MutexLocker::Locka00083.html#c929c01961dc1b2a2ee1a39333a79c0bMember Loki::MutexException::GetReasona00082.html#86bcf73eef55b0f64e392f806eb096adMember Loki::LevelMutex::Locka00070.html#d4ac0c2a33ff3d98ec0a83f70ce145daMember Loki::SleepLevelMutex::~SleepLevelMutexa00126.html#4c415349db989e7f2a8f2e02cbf9db88Loki::AssertBadDesignMutexError Class Referencea00009.htmlMember Loki::LevelMutexInfo::MultiLocka00071.html#a76848d3aa8e6c66454bd5357f715583Loki::LevelMutexInfo::PreUnlocka00071.html#7d5e2ace54e9423866be7c76116423dfLoki::LevelMutexInfo::Locka00071.html#5782b9fd9734d95a38ff86ef9532c89bLoki::Chainer< Fun1, Fun2 > Class Template Referencea00016.htmlMember Loki::CheckReturn::operator Valuea00022.html#6a77fab4729207c4c74ac74317ba58d6Loki::StaticChecker< ExceptionPolicy > Class Template Referencea00134.htmlclass Loki::CheckForEqualitya00017.htmlLoki::CachedFactory< AbstractProduct, IdentifierType, CreatorParmTList, EncapsulationPolicy, CreationPolicy, EvictionPolicy, StatisticPolicy, FactoryErrorPolicy, ObjVector > Class Template Referencea00014.htmlclass Loki::AmountLimitedCreationa00006.htmlclass Loki::LokiAllocatora00078.htmlLoki::LokiAllocator::LokiAllocatora00078.html#59f6c62294dd2f4ab05e9c42bc9009c0Loki::GetOffseta00217.html#g2f0821e243f812a3ae2abfaea51895e8Member Loki::operator>a00218.html#g1e83c8b289a17eaa9341880a8b848c65Loki::GetCurrentThreadsLevela00192.html#9548795d9cda6f227a1e1241ba577ca8ImplOf Class Referencea00066.htmlStrongPtr Ownership policiesa00223.htmlMember Loki::operator<=a00218.html#g272c9c4d6381679daba26c93ac36a70eLoki::operator<a00218.html#g8408e61306f223b3721f7792c8e172a9Loki::operator==a00218.html#gb3333b9378688690b921def21298d2bfMember Loki::ByRefa00211.html#g613ad438c1e0daeec26304c83f340b76Clone Factorya00207.htmlGroup Cached Factorya00200.htmlLoki::CountMutexesAtCurrentLevela00192.html#8cb767d3e7aaf2fe44b8f3b90218b876struct Loki::LongevityLifetime::DieLasta00049.htmlMember Loki::FixedAllocator::BlockSizea00056.html#37df732230913b2dd9126a6b311586f0struct Loki::SingleThreaded::Locka00121.htmlLoki::StrongPtr::operator<a00135.html#d79a42e24523a741ca408fc06a6b496bclass Loki::TwoRefLinksa00140.htmlLoki::DeleteArray< P > Class Template Referencea00040.htmlLoki::FunctionStorage::SetCallBackFunctiona00063.html#c55c8a149c74a27751204b0215c76041struct Loki::RejectNulla00107.htmlLoki::NoCopy< P > Class Template Referencea00088.htmlLoki::LockedStorage::LockedStoragea00076.html#8a214aaa9bd4d0ed532b9b5a338cb96eMember Loki::HeapStorage::PointerTypea00065.html#11ad403d98af5c6671f47d433d67201dMember Loki::SmallObjectBase::operator newa00129.html#dbbe1bde0960a38502af0940004d942fMember Loki::AllocatorSingleton::AllocatorSingletona00002.html#c1ce92a825643f114d555fea170e2a99Loki::SmallObjAllocator::~SmallObjAllocatora00127.html#0c861c4605844ee30dbe2a4f533fe2aeMember Loki::SingletonHolder::ObjectTypea00124.html#90400cb32897f9942958bece12165136struct Loki::DeletableSingletona00039.htmlLoki::ObjScopeGuardImpl3< Obj, MemFun, P1, P2, P3 > Class Template Referencea00096.htmlclass Loki::ScopeGuardImpl0a00111.htmlMember Loki::SafeBitConst::operator==a00110.html#3a78c04cbdd258c1cb54c959ffd3741aclass Loki::RefToValuea00105.htmlLoki::LockingPtr< SharedObject, LockingPolicy, ConstPolicy > Class Template Referencea00077.htmlMember Loki::MutexLocker::Unlocka00083.html#f5ea31fe3fac046cf646722cc8befa09class Loki::MutexExceptiona00082.htmlMember Loki::LevelMutex::Locka00070.html#95d3742db062548201986f482a9c9b9dLoki::SleepLevelMutex::Locka00126.html#e0f17a3b7641466c7611f5921d0c95e6class Loki::AssertBadDesignMutexErrora00009.htmlMember Loki::LevelMutexInfo::MultiLocka00071.html#dde650eae1cad8b4723e68cdb9130283Member Loki::LevelMutexInfo::PreUnlocka00071.html#7d5e2ace54e9423866be7c76116423dfLoki::LevelMutexInfo::Unlocka00071.html#01c9af5cb0f6870585b864b4557e9242class Loki::Chainera00016.htmlclass Loki::CheckReturna00022.htmlLoki::StaticChecker::Validatora00134.html#8aff7228f0f19f32c9d0efeb36fea643Loki::CheckForNothing< Host > Class Template Referencea00020.htmlclass Loki::CachedFactorya00014.htmlclass Loki::AmountLimitedCreationa00006.htmlMember Loki::LokiAllocator::allocatea00078.html#856c0d1e1f32b786421c02d468020758Member Loki::LokiAllocator::LokiAllocatora00078.html#59f6c62294dd2f4ab05e9c42bc9009c0Loki::DefaultAllocatora00217.html#g2444c5bff0a61b6751fb5f57e0c7e8c7Loki::operator>a00218.html#g46ee0daec0cef9d50136689d771642b6Loki::CountMutexesInCurrentThreada00192.html#ed0bb857431a808474a4b817d5c37f1cclass ImplOfa00066.htmlGroup StrongPtr Ownership policiesa00223.htmlMember Loki::operator<=a00218.html#geae99a03480ac6f8882d1799f8f1606cLoki::operator<a00218.html#g7abc768179c277d50bbb59fdee609668Loki::operator==a00218.html#gd6987be67b5ae633a9ca282aa7cbc13bSingletona00212.htmlGroup Clone Factorya00207.htmlGroup Cached Factorya00200.htmlLoki::DoMutexesMatchContainera00192.html#d633ca81ae0befaf235ae63886368037Loki::LongevityLifetime::DieDirectlyBeforeLast< T > Struct Template Referencea00047.htmlLoki::FixedAllocator::TrimEmptyChunka00056.html#4df95a9324de31f05d931f2eea25165eLoki::BaseVisitor Class Referencea00012.htmlMember Loki::StrongPtr::operator<a00135.html#d79a42e24523a741ca408fc06a6b496bMember Loki::TwoRefLinks::Mergea00140.html#fa3b914b3e13f0bdefa9304fae430d3fLoki::DeleteArray::Deletea00040.html#380d2f3709e399755f52f6da3b2fb8abclass Loki::FunctionStoragea00063.htmlLoki::RejectNullStrict< P > Struct Template Referencea00109.htmlclass Loki::NoCopya00088.htmlMember Loki::LockedStorage::LockedStoragea00076.html#8a214aaa9bd4d0ed532b9b5a338cb96eLoki::HeapStorage::ReferenceTypea00065.html#3fee3ebeb24babac70bd87cbe8006e99Loki::SmallObjectBase::operator deletea00129.html#698e8b9ebac9df8c03e557c842a59bc5Loki::AllocatorSingleton::~AllocatorSingletona00002.html#f4248c104f7c04f4dbef16543083be53class Loki::SmallObjAllocatora00127.htmlLoki::SingletonHolder::Instancea00124.html#43e4ea5cb6291a8bb14eb7cdc2bcb7bfLoki::SingletonWithLongevity< T > Struct Template Referencea00125.htmlclass Loki::ObjScopeGuardImpl3a00096.htmlLoki::ScopeGuardImpl1< F, P1 > Class Template Referencea00112.htmlLoki::SafeBitConst::operator|a00110.html#aefcf0a24311e7cd30a7ab66f5281661Loki::RegisterOnCreateSet< ElementList > Class Template Referencea00106.htmlLoki::LockingPtr::LockingPtra00077.html#9d430a6e7f83dfed1ed5f8111b6826caLoki::MultiMutexLocker Class Referencea00080.htmlMember Loki::MutexException::MutexExceptiona00082.html#0785e768d83f08d5a9f0156827aac238Member Loki::LevelMutex::TryLocka00070.html#042a7938dafd6f149cfd7da46478c0c9class Loki::SleepLevelMutexa00126.htmlLoki::JustReturnMutexError Class Referencea00067.htmlMember Loki::LevelMutexInfo::MultiUnlocka00071.html#475d734ba0e756935462a5151ea98065Loki::LevelMutexInfo::IncrementCounta00071.html#b31292dd7d1a944b8db2ba39a8487f3bLoki::LevelMutexInfo::IsRecentLocka00071.html#b917108c3e7c83b8a515d28e91a3a3caLoki::Key< Factory, IdentifierType > Class Template Referencea00068.htmlMember Loki::CheckReturn::CheckReturna00022.html#c25f0d90452244c84dafbb23c5cdb012Member Loki::StaticChecker::Validatora00134.html#8aff7228f0f19f32c9d0efeb36fea643class Loki::CheckForNothinga00020.htmlLoki::CachedFactory::RegisteredIdsa00014.html#be003d4613debd4079cf26f5c13aabc6Loki::EvictLRU< DT, ST > Class Template Referencea00053.htmlLoki::LokiAllocator< Type, AllocT >::LokiAllocator::rebind< Type1 > Struct Template Referencea00079.htmlLoki::LokiAllocator::~LokiAllocatora00078.html#9ac9082a843ef7c772a74a420d5ffd88Loki::DefaultDeallocatora00217.html#g1d24bf776342ace8f2004e3a173f6cb3Loki::operator<=a00218.html#gad6d21d0d77ddc1668f90a115884f8a3Loki::CountLocksInCurrentThreada00192.html#ae4c5edaad45b3657f39e8cdbae0f928LockableTwoRefCountInfo Class Referencea00074.htmlDelete policiesa00224.htmlMember Loki::operator<=a00218.html#gad6d21d0d77ddc1668f90a115884f8a3Loki::operator>a00218.html#g05304aaf9fabf1dda13ddff6146e2fe2Loki::operator!=a00218.html#gf30cc0b3f416d8703d4a4534c52b56b4Creation policiesa00213.htmlFunction objectsa00208.htmlEncapsulation policiesa00201.htmlLevelMutex.cppa00157.htmlstruct Loki::LongevityLifetime::DieDirectlyBeforeLasta00047.htmlLoki::FixedAllocator::TrimChunkLista00056.html#2b92d73c032c2ae6942ef9aadf6f27fcclass Loki::BaseVisitora00012.htmlLoki::StrongPtr::operator>a00135.html#b2690debb3f60c59954f63328f00fa56Member Loki::TwoRefLinks::Mergea00140.html#fa3b914b3e13f0bdefa9304fae430d3fclass Loki::DeleteArraya00040.htmlMember Loki::FunctionStorage::SetCallBackFunctiona00063.html#c55c8a149c74a27751204b0215c76041struct Loki::RejectNullStricta00109.htmlLoki::AllowConversion Struct Referencea00003.htmlclass Loki::LockedStoragea00076.htmlMember Loki::HeapStorage::ReferenceTypea00065.html#3fee3ebeb24babac70bd87cbe8006e99Member Loki::SmallObjectBase::operator deletea00129.html#698e8b9ebac9df8c03e557c842a59bc5Member Loki::AllocatorSingleton::~AllocatorSingletona00002.html#f4248c104f7c04f4dbef16543083be53Member Loki::SmallObjAllocator::SmallObjAllocatora00127.html#3d40b34b1a2d08a6bb9d9fa22ab5ce24Member Loki::SingletonHolder::Instancea00124.html#43e4ea5cb6291a8bb14eb7cdc2bcb7bfstruct Loki::SingletonWithLongevitya00125.htmlLoki::CreateUsingNew< T > Struct Template Referencea00033.htmlclass Loki::ScopeGuardImpl1a00112.htmlLoki::SafeBitConst::operator|a00110.html#35fc6eef31a04e669ca1846ae9909daeclass Loki::RegisterOnCreateSeta00106.htmlLoki::LockingPtr::LockingPtra00077.html#e4ae5d4ed12dbcac9fffd8241dd1cc2bLoki::MultiMutexLocker::MultiMutexLockera00080.html#aa646ae058e3273651f89bfbb276cf42Loki::MutexLocker Class Referencea00083.htmlMember Loki::LevelMutex::Unlocka00070.html#553a379257af57ceaef9ed48b0dc8b70Member Loki::SleepLevelMutex::SleepLevelMutexa00126.html#89785c46dc2bde328e1908e25d6b747bclass Loki::JustReturnMutexErrora00067.htmlMember Loki::LevelMutexInfo::PostLocka00071.html#3fe2ecf1bcf2c49eae04c493f023099cMember Loki::LevelMutexInfo::IncrementCounta00071.html#b31292dd7d1a944b8db2ba39a8487f3bLoki::LevelMutexInfo::IsRecentLocka00071.html#ebf33c02e3dd8adb0155fd827b5cfccdclass Loki::Keya00068.htmlLoki::DontPropagateConst< T > Class Template Referencea00051.htmlLoki::StaticChecker::StaticCheckera00134.html#03eca9af5c834a019115f519994d84d7Loki::ContractChecker< Host, ExceptionPolicy > Class Template Referencea00029.htmlMember Loki::CachedFactory::RegisteredIdsa00014.html#be003d4613debd4079cf26f5c13aabc6class Loki::EvictLRUa00053.htmlstruct Loki::LokiAllocator::rebinda00079.htmlMember Loki::LokiAllocator::~LokiAllocatora00078.html#9ac9082a843ef7c772a74a420d5ffd88Namespace Lokia00192.htmlLoki::operator<=a00218.html#geae99a03480ac6f8882d1799f8f1606cLoki::CountMutexesAtCurrentLevela00192.html#8cb767d3e7aaf2fe44b8f3b90218b876class LockableTwoRefCountInfoa00074.htmlReset policiesa00225.htmlMember Loki::operator==a00218.html#g26dc37f18d3112b69b35514b5e1fd749Loki::operator<=a00218.html#g272c9c4d6381679daba26c93ac36a70eLoki::operator!=a00218.html#g2c4d3dae616ecca69b25e3af91927b66Lifetime policiesa00214.htmlLoki::BindFirsta00208.html#g73955e915d2ef0cc231bb6ac5765e812Group Encapsulation policiesa00201.htmlLevelMutex.h File Referencea00158.htmlLoki::LongevityLifetime::DieFirst< T > Struct Template Referencea00048.htmlLoki::FixedAllocator::CountEmptyChunksa00056.html#e74cbab50e78bfa115d7c0fcdce00641Loki::CyclicVisitor< R, TList > Class Template Referencea00034.htmlMember Loki::StrongPtr::operator>a00135.html#b2690debb3f60c59954f63328f00fa56Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy > Class Template Referencea00135.htmlMember Loki::DeleteArray::Deletea00040.html#380d2f3709e399755f52f6da3b2fb8abLoki::SmartPointer< AbstractProduct, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ConstnessPolicy > Class Template Referencea00131.htmlLoki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy > Class Template Referencea00132.htmlstruct Loki::AllowConversiona00003.htmlLoki::ArrayStorage< T > Class Template Referencea00007.htmlLoki::HeapStorage::HeapStoragea00065.html#cdfa8becf0edde78add788797126b53cLoki::SmallObjectBase::operator deletea00129.html#b835d84fa8bc1ed3a558dc2e7a7e39ecLoki::AllocatorSingleton::Instancea00002.html#0de7839b1e888e11ff44bc50b78ca7d7Member Loki::SmallObjAllocator::~SmallObjAllocatora00127.html#0c861c4605844ee30dbe2a4f533fe2aeclass Loki::SingletonHoldera00124.htmlLoki::NoDestroy< T > Struct Template Referencea00089.htmlstruct Loki::CreateUsingNewa00033.htmlLoki::ScopeGuardImpl2< F, P1, P2 > Class Template Referencea00113.htmlMember Loki::SafeBitConst::operator|a00110.html#35fc6eef31a04e669ca1846ae9909daeLoki::UnRegisterOnDeleteSet< ElementList > Class Template Referencea00141.htmlLoki::LockingPtr::~LockingPtra00077.html#72ca595078f8f910966752d573267eedLoki::MultiMutexLocker::MultiMutexLockera00080.html#a88fcf2068f0c4292e2f25fcd29c3e33Loki::MutexLocker::MutexLockera00083.html#ae8699ba4423d83aff277149c9008ec8Loki::MutexException Class Referencea00082.htmlMember Loki::SleepLevelMutex::Locka00126.html#e0f17a3b7641466c7611f5921d0c95e6Loki::NoMutexWait Class Referencea00090.htmlMember Loki::LevelMutexInfo::TryLocka00071.html#32f89bf087b932de0cdd1151116779b4Loki::LevelMutexInfo::DecrementCounta00071.html#929c6964d78855d487a4fd72ef8e3332Loki::LevelMutexInfo::IsLockedByCurrentThreada00071.html#c0a343bcb322ea36495f536504f61f9fLoki::LevelMutexInfo Class Referencea00071.htmlclass Loki::DontPropagateConsta00051.htmlLoki::StaticChecker::~StaticCheckera00134.html#c34b548bb197793f0e393e0448b07b6fLoki::ContractChecker::Validatora00029.html#041784de821e2ca4fa00aef169acc18bLoki::CachedFactory::ReleaseObjecta00014.html#c307db6556acef8179a260db4d573440class Loki::EvictLRUa00053.htmlLoki::SimplePointer< AbstractProduct > Class Template Referencea00118.htmlLoki::LokiAllocator::addressa00078.html#c95609b0bb01996e9d7fa94406f787b4Member Loki::CountLocksInCurrentThreada00192.html#ae4c5edaad45b3657f39e8cdbae0f928Loki::operator>=a00218.html#g54b4de5905940e3780e6e64944f74a11Loki::DoMutexesMatchContainera00192.html#d633ca81ae0befaf235ae63886368037LockableTwoRefCounts Class Referencea00075.htmlThreadinga00226.htmlMember Loki::operator==a00218.html#gb5a35f4e3da89fb451c36891a96ab244Loki::operator<=a00218.html#g24773dba1237da071b5df66455393f1dLoki::operator<a00218.html#g19b38e411732f476e3b288ccbd397331Loki::SetLongevitya00214.html#g82d4520d213b3b9ef2090f5e237874cfLoki::Chaina00208.html#g1a74f9db98f84037e15dff40ca82d8ccCreation policiesa00202.htmlLevelMutex.ha00158.htmlstruct Loki::LongevityLifetime::DieFirsta00048.htmlLoki::FixedAllocator::IsCorrupta00056.html#41a7ad189cba00f504635aade8b3d15cclass Loki::CyclicVisitora00034.htmlLoki::StrongPtr::operator<=a00135.html#586e58be1f85d76fbe0b43170ed5da14Loki::StrongPtr::Mergea00135.html#e493c465f8e0067db7fa98271be5a0c6Member Loki::DeleteArray::Deletea00040.html#380d2f3709e399755f52f6da3b2fb8abclass Loki::SmartPointera00131.htmlclass Loki::SmartPtra00132.htmlLoki::DisallowConversion Struct Referencea00050.htmlLoki::ArrayStorage::PointerTypea00007.html#c1c79b615bc1bfffe6b8b8a4c17ff71aMember Loki::HeapStorage::HeapStoragea00065.html#cdfa8becf0edde78add788797126b53cLoki::SmallObjectBase::operator deletea00129.html#e2da17da13c6c6a0d7e33c9df9eb27f2Member Loki::AllocatorSingleton::Instancea00002.html#0de7839b1e888e11ff44bc50b78ca7d7Member Loki::SmallObjAllocator::Allocatea00127.html#a41bb717d552cd0df57a941def7ec607Loki::Singleton< T > Class Template Referencea00122.htmlstruct Loki::NoDestroya00089.htmlLoki::CreateUsing< Alloc > Struct Template Referencea00031.htmlclass Loki::ScopeGuardImpl2a00113.htmlLoki::SafeBitConst::operator<<a00110.html#70a37a966ba91fe89ac6f5f661f04279class Loki::UnRegisterOnDeleteSeta00141.htmlMember Loki::LockingPtr::~LockingPtra00077.html#72ca595078f8f910966752d573267eedLoki::MultiMutexLocker::~MultiMutexLockera00080.html#b3f3fa705ae220da3e5be02e65d6ef10Loki::MutexLocker::MutexLockera00083.html#aeffc60518694479ac9985ee1878ed0fLoki::MutexException::MutexExceptiona00082.html#0785e768d83f08d5a9f0156827aac238Loki::LevelMutex< MutexPolicy, DefaultLevel, ErrorPolicy, WaitPolicy > Class Template Referencea00070.htmlclass Loki::NoMutexWaita00090.htmlMember Loki::LevelMutexInfo::Unlocka00071.html#01c9af5cb0f6870585b864b4557e9242Member Loki::LevelMutexInfo::DecrementCounta00071.html#929c6964d78855d487a4fd72ef8e3332Member Loki::LevelMutexInfo::IsLockedByCurrentThreada00071.html#c0a343bcb322ea36495f536504f61f9fLoki::LevelMutexInfo::MutexContainera00071.html#76a0315d91234f5066c75660a9f27a7fLoki::PropagateConst< T > Class Template Referencea00100.htmlLoki::StaticChecker::Checka00134.html#d8e80dcf79a603395ecc9d5b2fe91491Member Loki::ContractChecker::Validatora00029.html#041784de821e2ca4fa00aef169acc18bMember Loki::CachedFactory::ReleaseObjecta00014.html#c307db6556acef8179a260db4d573440Loki::EvictAging< DT, ST > Class Template Referencea00052.htmlclass Loki::SimplePointera00118.htmlMember Loki::LokiAllocator::addressa00078.html#c95609b0bb01996e9d7fa94406f787b4Member Loki::CountMutexesAtCurrentLevela00192.html#8cb767d3e7aaf2fe44b8f3b90218b876Loki::operator>=a00218.html#g5a4d9a68820aeaed1974a236b380fb49Loki::ByRefa00211.html#g613ad438c1e0daeec26304c83f340b76class LockableTwoRefCountsa00075.htmlGroup Threadinga00226.htmlMember Loki::operator==a00218.html#gd6987be67b5ae633a9ca282aa7cbc13bLoki::operator>=a00218.html#g93341dd134031aede8273376ed13578dLoki::operator<a00218.html#gf8a4e6ef7065932113a924ee9e9fd63aGroup Lifetime policiesa00214.htmlMember Loki::BindFirsta00208.html#g73955e915d2ef0cc231bb6ac5765e812Group Creation policiesa00202.htmlLOKI_THREAD_LOCALa00158.html#8235533deec74e2a08322dd48eab5ab2Loki::LongevityLifetime::DieAsSmallObjectParent< T > Struct Template Referencea00046.htmlLoki::FixedAllocator::HasBlocka00056.html#f84b504579cea189ce1c415ee8ed5d2cLoki::Chunk Struct Referencea00025.htmlMember Loki::StrongPtr::operator<=a00135.html#586e58be1f85d76fbe0b43170ed5da14Loki::StrongPtr::Locka00135.html#70ad60678f72611567acc26fc718fed6Loki::CantResetWithStrong< P > Class Template Referencea00015.htmlclass Loki::SmartPointera00131.htmlLoki::FunctionStorage< T > Class Template Referencea00063.htmlstruct Loki::DisallowConversiona00050.htmlMember Loki::ArrayStorage::PointerTypea00007.html#c1c79b615bc1bfffe6b8b8a4c17ff71aclass Loki::HeapStoragea00065.htmlMember Loki::SmallObjectBase::operator deletea00129.html#e2da17da13c6c6a0d7e33c9df9eb27f2Loki::AllocatorSingleton::ClearExtraMemorya00002.html#082b4ba1c6574c5bed916c55ecf46e82Member Loki::SmallObjAllocator::Deallocatea00127.html#50406896d75a2591d4bd7dc53325e3d6class Loki::Singletona00122.htmlLoki::FollowIntoDeath Class Referencea00057.htmlstruct Loki::CreateUsinga00031.htmlLoki::ScopeGuardImpl3< F, P1, P2, P3 > Class Template Referencea00114.htmlLoki::SafeBitConst::sizea00110.html#dca153e32459cb1bcc34b7406ec7a2fcLoki::SafeBitConst< unique_index, word_t > Class Template Referencea00110.htmlLoki::LockingPtr::operator*a00077.html#1afb02c9b36189cec222bb0fe5d49471Member Loki::MultiMutexLocker::~MultiMutexLockera00080.html#b3f3fa705ae220da3e5be02e65d6ef10Loki::MutexLocker::~MutexLockera00083.html#bab99d9acf93e5add22deb8cf7d04a09Loki::MutexException::MutexExceptiona00082.html#210613fe3eb7005a128fd85f297b85c9Loki::LevelMutex::LevelMutexa00070.html#e770e4e5ec2fa120d016eb23b56d988bLoki::MutexSleepWaits Class Referencea00084.htmlMember Loki::LevelMutexInfo::UnlockedLevela00071.html#1f68bae408eb26856776cf02efed90bcLoki::LevelMutexInfo::IsValida00071.html#36c34ecf5d019f3db9bfb8654cf49176Loki::LevelMutexInfo::IsLockedByAnotherThreada00071.html#7dedf2f4310f08e19c88386b4e9cd415Member Loki::LevelMutexInfo::MutexContainera00071.html#76a0315d91234f5066c75660a9f27a7fclass Loki::PropagateConsta00100.htmlclass Loki::StaticCheckera00134.htmlLoki::ContractChecker::ContractCheckera00029.html#47a88a788d4099204e3a49593e4ff2a2Loki::CachedFactory::displayCacheTypea00014.html#26534687a259fa84dcbb21c388a72134class Loki::EvictAginga00052.htmlclass Loki::SimplePointera00118.htmlLoki::LokiAllocator::addressa00078.html#6f984e7db2d509ad2b49d2229974d87cMember Loki::CountMutexesInCurrentThreada00192.html#ed0bb857431a808474a4b817d5c37f1cLoki::operator==a00218.html#gb5a35f4e3da89fb451c36891a96ab244Loki::RegisterFunctiona00210.html#g14cf89ecf59f8bf3a6d47cdfe5ff389dPImplOf Class Referencea00099.htmlVisitora00227.htmlMember Loki::operator==a00218.html#gb3333b9378688690b921def21298d2bfLoki::operator>=a00218.html#g239a9b1c4e557388ba4b9c39051c3f4eLoki::operator>a00218.html#g1e83c8b289a17eaa9341880a8b848c65Member Loki::SetLongevitya00214.html#g82d4520d213b3b9ef2090f5e237874cfMember Loki::Chaina00208.html#g1a74f9db98f84037e15dff40ca82d8ccGroup Creation policiesa00202.htmlLoki::GetCurrentThreadsLevela00192.html#9548795d9cda6f227a1e1241ba577ca8struct Loki::LongevityLifetime::DieAsSmallObjectParenta00046.htmlclass Loki::FixedAllocatora00056.htmlstruct Loki::Chunka00025.htmlLoki::StrongPtr::operator>=a00135.html#477cf3ea79e8d0f6dff7172372533873Loki::StrongPtr::Unlocka00135.html#c3afffc8a90f5369c895a220bcc6db34class Loki::CantResetWithStronga00015.htmlLoki::DeleteUsingFree< P > Class Template Referencea00043.htmlclass Loki::FunctionStoragea00063.htmlLoki::NoCheck< P > Struct Template Referencea00087.htmlclass Loki::ArrayStoragea00007.htmlLoki::DefaultSPStorage< T > Class Template Referencea00038.htmlclass Loki::SmallObjectBasea00129.htmlLoki::AllocatorSingleton::IsCorrupteda00002.html#033978d127f16d2da0fd79d31ee75713Member Loki::SmallObjAllocator::Deallocatea00127.html#2b669733cfa9dd157603d13d979f8c1cLoki::SmallObjAllocator Class Referencea00127.htmlclass Loki::FollowIntoDeatha00057.htmlLoki::CreateUsingMalloc< T > Struct Template Referencea00032.htmlclass Loki::ScopeGuardImpl3a00114.htmlMember Loki::SafeBitConst::sizea00110.html#dca153e32459cb1bcc34b7406ec7a2fcLoki::SafeBitConst::bit_word_ta00110.html#2b7673100bcc441e25b2a63c1ad8ca79Member Loki::LockingPtr::operator*a00077.html#1afb02c9b36189cec222bb0fe5d49471Loki::MultiMutexLocker::Locka00080.html#9ce26d13eb156c9a8b7fa6228bf6724fMember Loki::MutexLocker::~MutexLockera00083.html#bab99d9acf93e5add22deb8cf7d04a09Member Loki::MutexException::MutexExceptiona00082.html#210613fe3eb7005a128fd85f297b85c9Loki::LevelMutex::~LevelMutexa00070.html#b1670bea535a28e439a991fad4056ec2class Loki::MutexSleepWaitsa00084.htmlLoki::LevelMutexInfo::LevelMutexInfo::Checker Class Referencea00072.htmlLoki::LevelMutexInfo::IsValidLista00071.html#01f6dfba5d2ea5606109b34e5a543cf0Member Loki::LevelMutexInfo::IsLockedByAnotherThreada00071.html#7dedf2f4310f08e19c88386b4e9cd415Loki::LevelMutexInfo::GetLevela00071.html#1cad7c6b6fc50e230401e4cc22761d14Loki::DefaultFactoryError< IdentifierType, AbstractProduct > Class Template Referencea00036.htmlMember Loki::StaticChecker::StaticCheckera00134.html#03eca9af5c834a019115f519994d84d7Loki::ContractChecker::~ContractCheckera00029.html#ac668398deabba5291b9025b4ac4eafdMember Loki::CachedFactory::displayCacheTypea00014.html#26534687a259fa84dcbb21c388a72134class Loki::EvictAginga00052.htmlLoki::NeverCreate Class Referencea00085.htmlMember Loki::LokiAllocator::addressa00078.html#6f984e7db2d509ad2b49d2229974d87cMember Loki::DoMutexesMatchContainera00192.html#d633ca81ae0befaf235ae63886368037Loki::operator==a00218.html#g26dc37f18d3112b69b35514b5e1fd749Loki::UnRegisterFunctiona00210.html#g8d2c3c45de75a6829be4f21a2575baccclass PImplOfa00099.htmlLOKI_DEFINE_VISITABLEa00227.html#g2b6ed280714eca44a2713d3cee5b2093Member Loki::operator>a00218.html#g05304aaf9fabf1dda13ddff6146e2fe2Group Smart pointersa00218.htmlMember Loki::operator>a00218.html#g1e83c8b289a17eaa9341880a8b848c65LongevityLifetimea00215.htmlPimpla00209.htmlEviction policiesa00203.htmlLoki::CountMutexesInCurrentThreada00192.html#ed0bb857431a808474a4b817d5c37f1cLoki::LongevityLifetime::DieAsSmallObjectChild< T > Struct Template Referencea00045.htmlMember Loki::FixedAllocator::Allocatea00056.html#c29973a11534fb1006fd28db97a17bedLoki::FixedAllocator Class Referencea00056.htmlMember Loki::StrongPtr::operator>=a00135.html#477cf3ea79e8d0f6dff7172372533873Loki::StrongPtr::Equalsa00135.html#0c197e9b4f68669529435577357ffa57Loki::AllowReset< P > Class Template Referencea00004.htmlLoki::DeleteUsingFree::Defaulta00043.html#7b6ba686ce808a9c000067d7722dbd16Loki::FunctionStorage::StoredTypea00063.html#52a1fc18d9685e6496bde1078e6949c5struct Loki::NoChecka00087.htmlLoki::RefCounted< P > Class Template Referencea00102.htmlLoki::DefaultSPStorage::PointerTypea00038.html#70074a5e2fe5b95668d4e5bb0f0909a8Member Loki::SmallObjectBase::ObjAllocatorSingletona00129.html#d07df1c9ec9c41580e07e32eddcda82dclass Loki::AllocatorSingletona00002.htmlMember Loki::SmallObjAllocator::IsCorrupta00127.html#2b7fbd5bf5fc56e45754abd2497ad18fLoki::SmallObjAllocator::Allocatea00127.html#a41bb717d552cd0df57a941def7ec607Loki::FollowIntoDeath::FollowIntoDeath::AfterMaster< Master > Struct Template Referencea00058.htmlstruct Loki::CreateUsingMalloca00032.htmlLoki::ScopeGuardImpl4< F, P1, P2, P3, P4 > Class Template Referencea00115.htmlLoki::SafeBitConst::SafeBitField< unique_index, word_t >a00110.html#14541da61dccc9821659cd1ce5d3dff1Member Loki::SafeBitConst::bit_word_ta00110.html#2b7673100bcc441e25b2a63c1ad8ca79Loki::LockingPtr::operator->a00077.html#d717c6fad1cc209cfbd04afb68717824Loki::MultiMutexLocker::Unlocka00080.html#18bfdec10dd2e65e128d64a80e42407fLoki::MutexLocker::Locka00083.html#c929c01961dc1b2a2ee1a39333a79c0bLoki::MutexException::operator=a00082.html#83db7c4cea71a007dd597061833f40eaMember Loki::LevelMutex::~LevelMutexa00070.html#b1670bea535a28e439a991fad4056ec2Loki::SpinLevelMutex Class Referencea00133.htmlclass Loki::LevelMutexInfo::Checkera00072.htmlclass Loki::LevelMutexInfoa00071.htmlLoki::LevelMutexInfo::MultiLocka00071.html#dde650eae1cad8b4723e68cdb9130283Member Loki::LevelMutexInfo::GetLevela00071.html#1cad7c6b6fc50e230401e4cc22761d14class Loki::DefaultFactoryErrora00036.htmlMember Loki::StaticChecker::~StaticCheckera00134.html#c34b548bb197793f0e393e0448b07b6fLoki::ContractChecker::Checka00029.html#812565f4dccc8d50be8f7b9c91841a51class Loki::CachedFactorya00014.htmlLoki::EvictRandom< DT, ST > Class Template Referencea00054.htmlclass Loki::NeverCreatea00085.htmlLoki::LokiAllocator::allocatea00078.html#856c0d1e1f32b786421c02d468020758Member Loki::GetCurrentThreadsLevela00192.html#9548795d9cda6f227a1e1241ba577ca8Loki::operator!=a00218.html#g7c1d35d961854e812b743b22c89f14f8Loki::SetLongevitya00214.html#g82d4520d213b3b9ef2090f5e237874cfRefCountedMT Struct Referencea00103.htmlLOKI_DEFINE_CONST_VISITABLEa00227.html#g0d60fea385397a82b9d3b3d231517777Member Loki::operator>a00218.html#g46ee0daec0cef9d50136689d771642b6Member Loki::operator!=a00218.html#gd6031d88c8485cea6a6f4a89356e638aLoki::operator>a00218.html#g46ee0daec0cef9d50136689d771642b6Small objectsa00216.htmlRegistera00210.htmlGroup Eviction policiesa00203.htmlLoki::CountLocksInCurrentThreada00192.html#ae4c5edaad45b3657f39e8cdbae0f928libloki-0.1.7.orig/doc/html/search.php0000755000175000017500000002365511140366263016266 0ustar ivanivan Search
  • Main Page
  • Modules
  • Namespaces
  • Classes
  • Files
  • 1 document matching your query."; } else // $num>1 { return "Found $num documents matching your query. Showing best matches first."; } } function report_matches() { return "Matches: "; } function end_form($value) { echo " \n \n
    \n
    \n
  • \n
\n
\n"; } function readInt($file) { $b1 = ord(fgetc($file)); $b2 = ord(fgetc($file)); $b3 = ord(fgetc($file)); $b4 = ord(fgetc($file)); return ($b1<<24)|($b2<<16)|($b3<<8)|$b4; } function readString($file) { $result=""; while (ord($c=fgetc($file))) $result.=$c; return $result; } function readHeader($file) { $header =fgetc($file); $header.=fgetc($file); $header.=fgetc($file); $header.=fgetc($file); return $header; } function computeIndex($word) { // Fast string hashing //$lword = strtolower($word); //$l = strlen($lword); //for ($i=0;$i<$l;$i++) //{ // $c = ord($lword{$i}); // $v = (($v & 0xfc00) ^ ($v << 6) ^ $c) & 0xffff; //} //return $v; // Simple hashing that allows for substring search if (strlen($word)<2) return -1; // high char of the index $hi = ord($word{0}); if ($hi==0) return -1; // low char of the index $lo = ord($word{1}); if ($lo==0) return -1; // return index return $hi*256+$lo; } function search($file,$word,&$statsList) { $index = computeIndex($word); if ($index!=-1) // found a valid index { fseek($file,$index*4+4); // 4 bytes per entry, skip header $index = readInt($file); if ($index) // found words matching the hash key { $start=sizeof($statsList); $count=$start; fseek($file,$index); $w = readString($file); while ($w) { $statIdx = readInt($file); if ($word==substr($w,0,strlen($word))) { // found word that matches (as substring) $statsList[$count++]=array( "word"=>$word, "match"=>$w, "index"=>$statIdx, "full"=>strlen($w)==strlen($word), "docs"=>array() ); } $w = readString($file); } $totalHi=0; $totalFreqHi=0; $totalFreqLo=0; for ($count=$start;$count $idx, "freq" => $freq>>1, "rank" => 0.0, "hi" => $freq&1 ); if ($freq&1) // word occurs in high priority doc { $totalHi++; $totalFreqHi+=$freq*$multiplier; } else // word occurs in low priority doc { $totalFreqLo+=$freq*$multiplier; } } // read name and url info for the doc for ($i=0;$i<$numDocs;$i++) { fseek($file,$docInfo[$i]["idx"]); $docInfo[$i]["name"]=readString($file); $docInfo[$i]["url"]=readString($file); } $statInfo["docs"]=$docInfo; } $totalFreq=($totalHi+1)*$totalFreqLo + $totalFreqHi; for ($count=$start;$count$key, "name"=>$di["name"], "rank"=>$rank ); } $docs[$key]["words"][] = array( "word"=>$wordInfo["word"], "match"=>$wordInfo["match"], "freq"=>$di["freq"] ); } } return $docs; } function filter_results($docs,&$requiredWords,&$forbiddenWords) { $filteredDocs=array(); while (list ($key, $val) = each ($docs)) { $words = &$docs[$key]["words"]; $copy=1; // copy entry by default if (sizeof($requiredWords)>0) { foreach ($requiredWords as $reqWord) { $found=0; foreach ($words as $wordInfo) { $found = $wordInfo["word"]==$reqWord; if ($found) break; } if (!$found) { $copy=0; // document contains none of the required words break; } } } if (sizeof($forbiddenWords)>0) { foreach ($words as $wordInfo) { if (in_array($wordInfo["word"],$forbiddenWords)) { $copy=0; // document contains a forbidden word break; } } } if ($copy) $filteredDocs[$key]=$docs[$key]; } return $filteredDocs; } function compare_rank($a,$b) { if ($a["rank"] == $b["rank"]) { return 0; } return ($a["rank"]>$b["rank"]) ? -1 : 1; } function sort_results($docs,&$sorted) { $sorted = $docs; usort($sorted,"compare_rank"); return $sorted; } function report_results(&$docs) { echo "\n"; echo " \n"; echo " \n"; echo " \n"; $numDocs = sizeof($docs); if ($numDocs==0) { echo " \n"; echo " \n"; echo " \n"; } else { echo " \n"; echo " \n"; echo " \n"; $num=1; foreach ($docs as $doc) { echo " \n"; echo " "; echo "\n"; echo " \n"; echo " \n"; echo " \n"; $num++; } } echo "

".search_results()."

".matches_text(0)."
".matches_text($numDocs); echo "\n"; echo "
$num.".$doc["name"]."
".report_matches()." "; foreach ($doc["words"] as $wordInfo) { $word = $wordInfo["word"]; $matchRight = substr($wordInfo["match"],strlen($word)); echo "$word$matchRight(".$wordInfo["freq"].") "; } echo "
\n"; } function main() { if(strcmp('4.1.0', phpversion()) > 0) { die("Error: PHP version 4.1.0 or above required!"); } if (!($file=fopen("search.idx","rb"))) { die("Error: Search index file could NOT be opened!"); } if (readHeader($file)!="DOXS") { die("Error: Header of index file is invalid!"); } $query=""; if (array_key_exists("query", $_GET)) { $query=$_GET["query"]; } end_form(ereg_replace("[^[:alnum:]:\\.\\t ]", " ", $query )); echo " \n
\n"; $results = array(); $requiredWords = array(); $forbiddenWords = array(); $foundWords = array(); $word=strtok($query," "); while ($word) // for each word in the search query { if (($word{0}=='+')) { $word=substr($word,1); $requiredWords[]=$word; } if (($word{0}=='-')) { $word=substr($word,1); $forbiddenWords[]=$word; } if (!in_array($word,$foundWords)) { $foundWords[]=$word; search($file,strtolower($word),$results); } $word=strtok(" "); } $docs = array(); combine_results($results,$docs); // filter out documents with forbidden word or that do not contain // required words $filteredDocs = filter_results($docs,$requiredWords,$forbiddenWords); // sort the results based on rank $sorted = array(); sort_results($filteredDocs,$sorted); // report results to the user report_results($sorted); echo "
\n"; fclose($file); } main(); ?>
Generated on Thu Jan 29 18:51:47 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00298.html0000755000175000017500000000371511140366256016016 0ustar ivanivan Loki: Member List

Loki::CheckForNoChangeOrThrow< Host > Member List

This is the complete list of members for Loki::CheckForNoChangeOrThrow< Host >, including all inherited members.


Generated on Thu Jan 29 18:51:42 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00042.html0000755000175000017500000001006711140366261015773 0ustar ivanivan Loki: Loki::DeleteSingle< P > Class Template Reference

Loki::DeleteSingle< P > Class Template Reference
[Delete policies]

#include <StrongPtr.h>

List of all members.

Static Public Member Functions

static void Delete (const P *p)


Detailed Description

template<class P>
class Loki::DeleteSingle< P >

Implementation of the DeletePolicy used by StrongPtr. This deletes just one shared object. This is the default class for the DeletePolicy.

Member Function Documentation

template<class P >
static void Loki::DeleteSingle< P >::Delete ( const P *  p  )  [inline, static]

Note:
If you see an error message about a negative subscript, that means your are attempting to use Loki to delete an incomplete type. Please don't use this policy with incomplete types; you may want to use DeleteNothing instead.


The documentation for this class was generated from the following file:
  • StrongPtr.h

Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00101.html0000755000175000017500000000535211140366256015774 0ustar ivanivan Loki: Loki::RateLimitedCreation Class Reference

Loki::RateLimitedCreation Class Reference
[Creation policies]

Limit in rate. More...

#include <CachedFactory.h>

List of all members.


Detailed Description

Limit in rate.

This implementation will prevent from Creating more than maxCreation objects within byTime ms by throwing an exception. Could be usefull to detect prevent loads (http connection for instance). Use the setRate method to set the rate parameters. default is 10 objects in a second.


The documentation for this class was generated from the following file:
  • CachedFactory.h

Generated on Thu Jan 29 18:51:42 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00416.html0000755000175000017500000000364111140366261016000 0ustar ivanivan Loki: Member List

Loki::AllowConversion Member List

This is the complete list of members for Loki::AllowConversion, including all inherited members.


Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00299.html0000755000175000017500000000367711140366256016026 0ustar ivanivan Loki: Member List

Loki::CheckForEquality< Host > Member List

This is the complete list of members for Loki::CheckForEquality< Host >, including all inherited members.


Generated on Thu Jan 29 18:51:42 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00043.html0000755000175000017500000000646011140366261015776 0ustar ivanivan Loki: Loki::DeleteUsingFree< P > Class Template Reference

Loki::DeleteUsingFree< P > Class Template Reference
[Delete policies]

#include <StrongPtr.h>

List of all members.

Static Public Member Functions

static P * Default (void)
 Provides default value to initialize the pointer.


Detailed Description

template<class P>
class Loki::DeleteUsingFree< P >

Implementation of the DeletePolicy used by StrongPtr. Uses explicit call to T's destructor followed by call to free. This policy is useful for managing the lifetime of pointers to structs returned by C functions.
The documentation for this class was generated from the following file:
  • StrongPtr.h

Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00358.html0000755000175000017500000000433111140366260016001 0ustar ivanivan Loki: Member List

Loki::ScopeGuardImpl2< F, P1, P2 > Member List

This is the complete list of members for Loki::ScopeGuardImpl2< F, P1, P2 >, including all inherited members.

ScopeGuardImplBase(const ScopeGuardImplBase &other)Loki::ScopeGuardImplBase [inline, protected]


Generated on Thu Jan 29 18:51:44 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00102.html0000755000175000017500000000515011140366261015765 0ustar ivanivan Loki: Loki::RefCounted< P > Class Template Reference

Loki::RefCounted< P > Class Template Reference
[Ownership policies]

#include <SmartPtr.h>

List of all members.


Detailed Description

template<class P>
class Loki::RefCounted< P >

Implementation of the OwnershipPolicy used by SmartPtr Provides a classic external reference counting implementation
The documentation for this class was generated from the following file:
  • SmartPtr.h

Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00417.html0000755000175000017500000000364711140366261016007 0ustar ivanivan Loki: Member List

Loki::DisallowConversion Member List

This is the complete list of members for Loki::DisallowConversion, including all inherited members.


Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00044.html0000755000175000017500000000517611140366261016002 0ustar ivanivan Loki: Loki::DestructiveCopy< P > Class Template Reference

Loki::DestructiveCopy< P > Class Template Reference
[Ownership policies]

#include <SmartPtr.h>

List of all members.


Detailed Description

template<class P>
class Loki::DestructiveCopy< P >

Implementation of the OwnershipPolicy used by SmartPtr Implements destructive copy semantics (a la std::auto_ptr)
The documentation for this class was generated from the following file:
  • SmartPtr.h

Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00110_aefcf0a24311e7cd30a7ab66f5281661_cgraph.dot0000755000175000017500000000121411140366257023634 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node1 [label="Loki::SafeBitConst::operator\|",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1 -> Node2 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::SafeBitConst::SafeBitConst",height=0.2,width=0.4,color="black",URL="$a00110.html#5ca867866c32c41efd30b5912daf48ba",tooltip="Default constructor allows client code to construct bit fields on the stack."]; } libloki-0.1.7.orig/doc/html/a00110_aefcf0a24311e7cd30a7ab66f5281661_cgraph.md50000755000175000017500000000004011140366257023527 0ustar ivanivan7abc14632f6e5b761cedd1c6bbdfdecalibloki-0.1.7.orig/doc/html/a00103.html0000755000175000017500000000617611140366255016002 0ustar ivanivan Loki: RefCountedMT Struct Reference

RefCountedMT Struct Reference
[Ownership policies]

#include <SmartPtr.h>


Detailed Description

Implementation of the OwnershipPolicy used by SmartPtr Implements external reference counting for multithreaded programs Policy Usage: RefCountedMTAdj<ThreadingModel>::RefCountedMT

Warning
There could be a race condition, see bug "Race condition in RefCountedMTAdj::Release" http://sourceforge.net/tracker/index.php?func=detail&aid=1408845&group_id=29557&atid=396644 As stated in bug 1408845, the Release function is not thread safe if a SmartPtr copy-constructor tries to copy the last pointer to an object in one thread, while the destructor is acting on the last pointer in another thread. The existence of a race between a copy-constructor and destructor implies a design flaw at a higher level. That race condition must be fixed at a higher design level, and no change to this class could fix it.

The documentation for this struct was generated from the following file:
  • SmartPtr.h

Generated on Thu Jan 29 18:51:41 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00134_c34b548bb197793f0e393e0448b07b6f_cgraph.dot0000755000175000017500000000106411140366256023456 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node1 [label="Loki::StaticChecker::~StaticChecker",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1 -> Node2 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::StaticChecker::Check",height=0.2,width=0.4,color="black",URL="$a00134.html#d8e80dcf79a603395ecc9d5b2fe91491"]; } libloki-0.1.7.orig/doc/html/a00134_c34b548bb197793f0e393e0448b07b6f_cgraph.md50000755000175000017500000000004011140366256023346 0ustar ivanivana1c9814f560c63eff20bd46f85aa6492libloki-0.1.7.orig/doc/html/a00192_9548795d9cda6f227a1e1241ba577ca8_cgraph.dot0000755000175000017500000000205211140366256023541 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node1 [label="Loki::GetCurrentThreadsLevel",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1 -> Node2 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::LevelMutexInfo::GetCurrentMutex",height=0.2,width=0.4,color="black",URL="$a00071.html#b7fd94847721b118979b72121472d3e2"]; Node2 -> Node3 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node3 [label="Loki::LevelMutexInfo::IsValidList",height=0.2,width=0.4,color="black",URL="$a00071.html#01f6dfba5d2ea5606109b34e5a543cf0"]; Node1 -> Node4 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node4 [label="Loki::LevelMutexInfo::GetLevel",height=0.2,width=0.4,color="black",URL="$a00071.html#1cad7c6b6fc50e230401e4cc22761d14",tooltip="Returns the level of this mutex."]; } libloki-0.1.7.orig/doc/html/a00192_9548795d9cda6f227a1e1241ba577ca8_cgraph.md50000755000175000017500000000004011140366256023433 0ustar ivanivan2bf7f4ff8b42b29840469b763caed9bclibloki-0.1.7.orig/doc/html/a00418.html0000755000175000017500000000364711140366261016010 0ustar ivanivan Loki: Member List

Loki::NoCheck< P > Member List

This is the complete list of members for Loki::NoCheck< P >, including all inherited members.


Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00056_41a7ad189cba00f504635aade8b3d15c_cgraph.dot0000755000175000017500000000211411140366262023714 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node1 [label="Loki::FixedAllocator::IsCorrupt",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1 -> Node2 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::FixedAllocator::CountEmptyChunks",height=0.2,width=0.4,color="black",URL="$a00056.html#e74cbab50e78bfa115d7c0fcdce00641"]; Node2 -> Node3 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node3 [label="Loki::Chunk::HasAvailable",height=0.2,width=0.4,color="black",URL="$a00025.html#0874a711145788bd8c5265a9de2a4aac"]; Node1 -> Node3 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node1 -> Node4 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node4 [label="Loki::Chunk::IsCorrupt",height=0.2,width=0.4,color="black",URL="$a00025.html#245b6450d855d8ab65e9ca7add3e2071"]; } libloki-0.1.7.orig/doc/html/a00056_41a7ad189cba00f504635aade8b3d15c_cgraph.md50000755000175000017500000000004011140366262023607 0ustar ivanivane0f859556d4d8f85d6f4a3f0249fa89clibloki-0.1.7.orig/doc/html/a00045.html0000755000175000017500000000645111140366262016001 0ustar ivanivan Loki: Loki::LongevityLifetime::DieAsSmallObjectChild< T > Struct Template Reference

Loki::LongevityLifetime::DieAsSmallObjectChild< T > Struct Template Reference
[Small objects]

#include <SmallObj.h>

Inheritance diagram for Loki::LongevityLifetime::DieAsSmallObjectChild< T >:
Collaboration diagram for Loki::LongevityLifetime::DieAsSmallObjectChild< T >:

List of all members.


Detailed Description

template<class T>
struct Loki::LongevityLifetime::DieAsSmallObjectChild< T >

Lifetime policy to manage lifetime dependencies of SmallObject base and child classes. The Child class should have this lifetime
The documentation for this struct was generated from the following file:
  • SmallObj.h

Generated on Thu Jan 29 18:51:46 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00104.html0000755000175000017500000000524611140366261015775 0ustar ivanivan Loki: Loki::RefLinked< P > Class Template Reference

Loki::RefLinked< P > Class Template Reference
[Ownership policies]

#include <SmartPtr.h>

Inherits Loki::Private::RefLinkedBase.

List of all members.


Detailed Description

template<class P>
class Loki::RefLinked< P >

Implementation of the OwnershipPolicy used by SmartPtr Implements reference linking
The documentation for this class was generated from the following file:
  • SmartPtr.h

Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00419.html0000755000175000017500000000365711140366261016012 0ustar ivanivan Loki: Member List

Loki::AssertCheck< P > Member List

This is the complete list of members for Loki::AssertCheck< P >, including all inherited members.


Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00070_95d3742db062548201986f482a9c9b9d_cgraph.dot0000755000175000017500000000413011140366257023324 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node1 [label="Loki::LevelMutex::Lock",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1 -> Node2 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::LevelMutexInfo::GetLevel",height=0.2,width=0.4,color="black",URL="$a00071.html#1cad7c6b6fc50e230401e4cc22761d14",tooltip="Returns the level of this mutex."]; Node1 -> Node3 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node3 [label="Loki::LevelMutexInfo::IsLockedByCurrentThread",height=0.2,width=0.4,color="black",URL="$a00071.html#c0a343bcb322ea36495f536504f61f9f",tooltip="Returns true if this was locked by current thread."]; Node3 -> Node4 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node4 [label="Loki::LevelMutexInfo::IsLocked",height=0.2,width=0.4,color="black",URL="$a00071.html#e6aa7465e1bba7f0c9fbf0b06f122a39",tooltip="Returns true if this mutex was locked at least once."]; Node3 -> Node5 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node5 [label="Loki::LevelMutexInfo::IsValid",height=0.2,width=0.4,color="black",URL="$a00071.html#36c34ecf5d019f3db9bfb8654cf49176"]; Node5 -> Node6 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node6 [label="Loki::LevelMutexInfo::IsValidList",height=0.2,width=0.4,color="black",URL="$a00071.html#01f6dfba5d2ea5606109b34e5a543cf0"]; Node1 -> Node5 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node1 -> Node7 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node7 [label="Loki::LevelMutexInfo::PostLock",height=0.2,width=0.4,color="black",URL="$a00071.html#3fe2ecf1bcf2c49eae04c493f023099c"]; Node7 -> Node3 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node7 -> Node5 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; } libloki-0.1.7.orig/doc/html/a00070_95d3742db062548201986f482a9c9b9d_cgraph.md50000755000175000017500000000004011140366257023217 0ustar ivanivan2de39dbeab7d2e4c526779e8a8a7c830libloki-0.1.7.orig/doc/html/a00046.html0000755000175000017500000000644111140366262016001 0ustar ivanivan Loki: Loki::LongevityLifetime::DieAsSmallObjectParent< T > Struct Template Reference

Loki::LongevityLifetime::DieAsSmallObjectParent< T > Struct Template Reference
[Small objects]

#include <SmallObj.h>

Inheritance diagram for Loki::LongevityLifetime::DieAsSmallObjectParent< T >:
Collaboration diagram for Loki::LongevityLifetime::DieAsSmallObjectParent< T >:

List of all members.


Detailed Description

template<class T>
struct Loki::LongevityLifetime::DieAsSmallObjectParent< T >

Lifetime policy to manage lifetime dependencies of SmallObject base and child classes. The Base class should have this lifetime
The documentation for this struct was generated from the following file:
  • SmallObj.h

Generated on Thu Jan 29 18:51:46 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00105.html0000755000175000017500000000506511140366257016002 0ustar ivanivan Loki: Loki::RefToValue< T > Class Template Reference

Loki::RefToValue< T > Class Template Reference
[Smart pointers]

#include <RefToValue.h>

List of all members.


Detailed Description

template<class T>
class Loki::RefToValue< T >

Transports a reference as a value Serves to implement the Colvin/Gibbons trick for SmartPtr/ScopeGuard
The documentation for this class was generated from the following file:
  • RefToValue.h

Generated on Thu Jan 29 18:51:43 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/tab_b.gif0000755000175000017500000000004311140366250016024 0ustar ivanivanGIF89a€„ฐว,D;libloki-0.1.7.orig/doc/html/a00047.html0000755000175000017500000000677211140366262016011 0ustar ivanivan Loki: Loki::LongevityLifetime::DieDirectlyBeforeLast< T > Struct Template Reference

Loki::LongevityLifetime::DieDirectlyBeforeLast< T > Struct Template Reference
[LongevityLifetime]

Lifetime is a one less than DieLast: 0xFFFFFFFF-1. More...

#include <Singleton.h>

Inheritance diagram for Loki::LongevityLifetime::DieDirectlyBeforeLast< T >:
Collaboration diagram for Loki::LongevityLifetime::DieDirectlyBeforeLast< T >:

List of all members.


Detailed Description

template<class T>
struct Loki::LongevityLifetime::DieDirectlyBeforeLast< T >

Lifetime is a one less than DieLast: 0xFFFFFFFF-1.
The documentation for this struct was generated from the following file:
  • Singleton.h

Generated on Thu Jan 29 18:51:46 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00361.html0000755000175000017500000000434111140366260015774 0ustar ivanivan Loki: Member List

Loki::ScopeGuardImpl3< F, P1, P2, P3 > Member List

This is the complete list of members for Loki::ScopeGuardImpl3< F, P1, P2, P3 >, including all inherited members.

ScopeGuardImplBase(const ScopeGuardImplBase &other)Loki::ScopeGuardImplBase [inline, protected]


Generated on Thu Jan 29 18:51:44 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00106.html0000755000175000017500000000551311140366257016001 0ustar ivanivan Loki: Loki::RegisterOnCreateSet< ElementList > Class Template Reference

Loki::RegisterOnCreateSet< ElementList > Class Template Reference
[Register]

#include <Register.h>

Inherits Loki::GenScatterHierarchy<ElementList, Private::RegisterOnCreateElement>.

List of all members.


Detailed Description

template<typename ElementList>
class Loki::RegisterOnCreateSet< ElementList >

Implements a generic register class which registers classes of a typelist

Usage
see test/Register

The documentation for this class was generated from the following file:
  • Register.h

Generated on Thu Jan 29 18:51:43 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/tab_l.gif0000755000175000017500000000130211140366250016035 0ustar ivanivanGIF89a ,ี๖๗๙๑๔๗๖๘๚๚๛๙๚๛๘๙๚๊๏๓๏๓๖ฦี฿าๆุโ้็ํๆ์ๅ์๑่๎๒๔๗๙๓๖๘ณศีมาหูโฯไึแ่–ดลนษฏยอปฮูริยำศืเฬฺโีแู่ไ๊ืโ่ๅ์๐๋๐๓„ฐวัๅๆ๋ใ๋๏๋๑๔๎๓๕๗๚๛๛, ,@–Pฑษ`H$!%CqVe2XญŠฬJ(“ฤ +€˜3 2$ภฦ ผkvŠไ-ห็๕u*…"}ใ|}|~q(" $f„ 'Žl(Œ&&$r‘™ › & ! )ขค›{จฃฅrญชฐฉฏ„ฑฏฌดฆทปบณฎซงพถรยภฟฒนวฤหฦฒฬษฮตาฝอผ„ิศำืะธูีฯูสโ฿ใ็ๆ๊พไล๋วํแ๎ึ์้๏๘๑๗๕ั๐ๅ๙คP฿?‚ƒœวBm ๅAœฮแภ†%Vˆ๎!วk๗ุ/แฤ;^คจฒ$ฦ–#Mf)fอ‡(WฮL‰“ๆK็า„ฐ ’I)L:eD กCตดx*4 Uจh  %Aซฃ^มNKbฌูeงXฑ‚ดkปx!มึํ—2tึ !ฏš5tๆ้—ภ]$ฌด%ƒXํโ.i[ฌ]Yญ•สfžE๋๕kg`ต††:z๋็าž;ฃ}บตjืaa‹–Mšถ้ืธc็žฝปv๏บƒ๓๎›8๐แศ‹'?ฎผ9๓็ฉG_>yu่ฌ_฿ž]zw๊฿ญ‡วพบผm๎ๆตG~ฝ๛๔แƒ—/ž>๙๖๖ูซฯฟลเ|ึWเ}v;libloki-0.1.7.orig/doc/html/a00420.html0000755000175000017500000000367311140366261016000 0ustar ivanivan Loki: Member List

Loki::AssertCheckStrict< P > Member List

This is the complete list of members for Loki::AssertCheckStrict< P >, including all inherited members.


Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00192_8cb767d3e7aaf2fe44b8f3b90218b876_cgraph.dot0000755000175000017500000000255111140366255023711 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node1 [label="Loki::CountMutexesAtCurrentLevel",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1 -> Node2 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::LevelMutexInfo::GetCurrentMutex",height=0.2,width=0.4,color="black",URL="$a00071.html#b7fd94847721b118979b72121472d3e2"]; Node2 -> Node3 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node3 [label="Loki::LevelMutexInfo::IsValidList",height=0.2,width=0.4,color="black",URL="$a00071.html#01f6dfba5d2ea5606109b34e5a543cf0"]; Node1 -> Node4 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node4 [label="Loki::LevelMutexInfo::GetLevel",height=0.2,width=0.4,color="black",URL="$a00071.html#1cad7c6b6fc50e230401e4cc22761d14",tooltip="Returns the level of this mutex."]; Node1 -> Node5 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node5 [label="Loki::LevelMutexInfo::GetPrevious",height=0.2,width=0.4,color="black",URL="$a00071.html#b774e94ff72724dd87ff236d99970bb5",tooltip="Returns pointer to mutex previously locked by the thread which locked this."]; } libloki-0.1.7.orig/doc/html/a00192_8cb767d3e7aaf2fe44b8f3b90218b876_cgraph.md50000755000175000017500000000004011140366255023577 0ustar ivanivan5eaaab04beb8c820deeaf0a3ccc0d75flibloki-0.1.7.orig/doc/html/tab_r.gif0000755000175000017500000000503111140366250016046 0ustar ivanivanGIF89a,ี๖๗๙๑๔๗๖๘๚๚๛๙๚๛๘๙๚๊๏๓๏๓๖ฦี฿าๆุโ้็ํๆ์ๅ์๑่๎๒๔๗๙๓๖๘ณศีมาหูโฯไึแ่–ดลนษฏยอปฮูริยำศืเฬฺโีแู่ไ๊ืโ่ๅ์๐๋๐๓„ฐวัๅๆ๋ใ๋๏๋๑๔๎๓๕๗๚๛๛,,@’pH,ศคrษl:ŸะจtJญZฏุฌv •h<ฌpkL.›ฯ่ดzอnป฿๐ธ|Nฏ๏๘ผ~ฯwVa+‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ “*)^,*ชซฌญฎฏฐฑฒณดตถทธนบปผฝพฟภมยรถ)'ฦฮฯะัาำิีึืฺุู฿เแโใไๅๆฺฅ(" ๐๑๒๓๔๕๖๗๘๙๚๛ Hฐ มƒ๒K"ƒRHœHฑขล‹3jศฑฃว CŠIฒคษ“(Sช\้ลu&@€ มฒฆอ›8s๊ษณงO–(ยฑ€DะฃH“*]สดฉำงPฃJJตชีซXณjสตซืฏS84ฑ ‰hำช]หถญทpใสKทฎปx๓๊หทฏ฿ฟ€ำ} โDฬf(^ฬธฑใว#KžLนฒๅห˜3kฬนณ็ฯ C‹mน๐CฤHœXอบต๋ืฐcหžMปถํธs๋อปท๏฿ภƒ N๗รJ” มฎน๓็ะฃKŸNฝบ๕ุ๋ณk฿ฮฝป๗๏เร‹Oพ๚๑€ dว@€‚‚Lค"ษศF:๒‘Œค$9† (8…&ษษNz๒“  ฅ(GฉFB^ฒ!หจ)WษสVบ๒•ฐlค)1™ wฤ๒–ธฬฅ.wสYบไƒเฅ0‡Iฬb๓พ|ษHpฬf:๓™ะ์e pJฑˆ€}ศฆ6ทษอnz๓›เ ง8๛0ย%"ธๆ8ืษฮvบ๓๐Œง<ษPฮQ`๒%ื$€>๗ษฯ~๚๓Ÿ จ@Jะ‚๔ MจBสะ†:๔กจD'ZPKF ึผ&16สัŽz๔ฃ ฉHGJRb ๗L็5ฯมา–บ๔ฅ0ฉLgJำšš#(e>ฏ‰ำž๚๔ง@ ชP‡Jิข๕จHMชR—สิฆ:๕ฉPชTงJีช&5;%Uทสีฎz๕ซ` ซXวJVซยCง‹ัjYืสึถบ๕ญpซ\ŠUดภฆxอซ^๗สืพ๚๕ฏะภi)$‚”๔ฐˆMฌbหุฦ:vˆ, เฒ˜อฌf7หูฮz๖ณ  ญhGKฺาš๖ดจMญjWหฺึบ๖ตฐญ*$SP๔ถธอญnwห๚๖ทภลm +„โธศMฎr—หๆ:๗นะEฎ?ฑ9ฯ๊Z๗บุอฎvฟ9€๎"‚บ ฏxวK๒b—™ัLฏzืห^Aขทฝ๐ฏ|็†๗า๗พ๘อฏ0ํซ฿๚๗ฟกไ/€LเปืภNฐ‚๏(เ;๘ม n0„'LaJธยฮ0{/ฌแ{ุ˜ฐˆG|ห“๘ฤ(ฅ‰SฬโCrล.ŽฑŒ ใ๘ฦvฌ1Žwฬc6๊ธว@๑ƒLdนศHN๑‘“ฬd/นษPฮ๐“ฃLeOนสXŽp–ท|โ+s๙ห๕2˜วL_1“๙ฬํ53šืM5ณ๙อวt3œ็ผ_:ูยwฮs™๕ฬg๘สนฯ€p ฬ?๚ะ/Fดข๋ผ่FใาะŽŽt!-้Jใ‘า–ฮ๔1ญ้Nป‘ำžuA-๊P“บิ>5ช3ญ๊UWบีฎŽ4ฌc่YำZัถพ๕กsญ๋A๓บื€5ฐ๙,์a็นุฦถ3ฒ“=็e3๛อฮ~๖šฃ-ํ3Sปฺcพ6ถฟฌํmoนฦ2ธรMๅq“สๆ>7“ำญn$ณปD~7ผ,๏y๓ธ๖ฦ1พ๓mใ}๓ศvตฟโ\ษ/ตมNโ…3ษ๗ดร#แ‰S\สguฦ-m๑Oธใ0ศCพเ‘“\ห'_ดษS^เ•ณ|ภ.๙c.๓0ืœะ4ฟ9~sฎ๓=๗ผฯ๕ญ3ฺ๋d๎:ุu)๖ฑ?ฺ์ูF;˜หฎ๖Wฒฝํญ|;W)๗นฒ๎vtหฝwพ๗|เื=xยA;libloki-0.1.7.orig/doc/html/a00218_g93341dd134031aede8273376ed13578d_cgraph.dot0000755000175000017500000000116611140366255023537 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node1 [label="Loki::operator\>=",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1 -> Node2 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::StrongPtr::LessThan",height=0.2,width=0.4,color="black",URL="$a00135.html#baea90f6e505a2afc662fe07c9c117fa",tooltip="Helper function which can be called to avoid exposing GetPointer function."]; } libloki-0.1.7.orig/doc/html/a00218_g93341dd134031aede8273376ed13578d_cgraph.md50000755000175000017500000000004011140366255023424 0ustar ivanivan5b3eb939aae65fab7d4b76e77c1d5388libloki-0.1.7.orig/doc/html/a00048.html0000755000175000017500000000641711140366262016006 0ustar ivanivan Loki: Loki::LongevityLifetime::DieFirst< T > Struct Template Reference

Loki::LongevityLifetime::DieFirst< T > Struct Template Reference
[LongevityLifetime]

Shortest possible SingletonWithLongevity lifetime: 0. More...

#include <Singleton.h>

Inheritance diagram for Loki::LongevityLifetime::DieFirst< T >:
Collaboration diagram for Loki::LongevityLifetime::DieFirst< T >:

List of all members.


Detailed Description

template<class T>
struct Loki::LongevityLifetime::DieFirst< T >

Shortest possible SingletonWithLongevity lifetime: 0.
The documentation for this struct was generated from the following file:
  • Singleton.h

Generated on Thu Jan 29 18:51:46 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00029_47a88a788d4099204e3a49593e4ff2a2_cgraph.dot0000755000175000017500000000107111140366256023411 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node1 [label="Loki::ContractChecker::ContractChecker",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1 -> Node2 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::ContractChecker::Check",height=0.2,width=0.4,color="black",URL="$a00029.html#812565f4dccc8d50be8f7b9c91841a51"]; } libloki-0.1.7.orig/doc/html/a00029_47a88a788d4099204e3a49593e4ff2a2_cgraph.md50000755000175000017500000000004011140366256023303 0ustar ivanivan0e9539d68c3d7607c51f97b197135983libloki-0.1.7.orig/doc/html/a00218_g8408e61306f223b3721f7792c8e172a9_cgraph.dot0000755000175000017500000000116511140366254023405 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node1 [label="Loki::operator\<",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1 -> Node2 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::StrongPtr::LessThan",height=0.2,width=0.4,color="black",URL="$a00135.html#baea90f6e505a2afc662fe07c9c117fa",tooltip="Helper function which can be called to avoid exposing GetPointer function."]; } libloki-0.1.7.orig/doc/html/a00218_g8408e61306f223b3721f7792c8e172a9_cgraph.md50000755000175000017500000000004011140366254023273 0ustar ivanivanb31255ffbc3f1f29bee5e22ba9bca8f4libloki-0.1.7.orig/doc/html/a00107.html0000755000175000017500000000512211140366261015771 0ustar ivanivan Loki: Loki::RejectNull< P > Struct Template Reference

Loki::RejectNull< P > Struct Template Reference
[Checking policies]

#include <SmartPtr.h>

List of all members.


Detailed Description

template<class P>
struct Loki::RejectNull< P >

Implementation of the CheckingPolicy used by SmartPtr Checks the pointer before dereference
The documentation for this struct was generated from the following file:
  • SmartPtr.h

Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00421.html0000755000175000017500000000365311140366261015777 0ustar ivanivan Loki: Member List

Loki::NullPointerException Member List

This is the complete list of members for Loki::NullPointerException, including all inherited members.


Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00049.html0000755000175000017500000000644011140366262016003 0ustar ivanivan Loki: Loki::LongevityLifetime::DieLast< T > Struct Template Reference

Loki::LongevityLifetime::DieLast< T > Struct Template Reference
[LongevityLifetime]

Longest possible SingletonWithLongevity lifetime: 0xFFFFFFFF. More...

#include <Singleton.h>

Inheritance diagram for Loki::LongevityLifetime::DieLast< T >:
Collaboration diagram for Loki::LongevityLifetime::DieLast< T >:

List of all members.


Detailed Description

template<class T>
struct Loki::LongevityLifetime::DieLast< T >

Longest possible SingletonWithLongevity lifetime: 0xFFFFFFFF.
The documentation for this struct was generated from the following file:
  • Singleton.h

Generated on Thu Jan 29 18:51:46 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00108.html0000755000175000017500000000521011140366261015770 0ustar ivanivan Loki: Loki::RejectNullStatic< P > Struct Template Reference

Loki::RejectNullStatic< P > Struct Template Reference
[Checking policies]

#include <SmartPtr.h>

List of all members.


Detailed Description

template<class P>
struct Loki::RejectNullStatic< P >

Implementation of the CheckingPolicy used by SmartPtr Checks the pointer upon initialization and before dereference
The documentation for this struct was generated from the following file:
  • SmartPtr.h

Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00422.html0000755000175000017500000000367111140366261016000 0ustar ivanivan Loki: Member List

Loki::RejectNullStatic< P > Member List

This is the complete list of members for Loki::RejectNullStatic< P >, including all inherited members.


Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00080_18bfdec10dd2e65e128d64a80e42407f_cgraph.dot0000755000175000017500000000724411140366257023665 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node1 [label="Loki::MultiMutexLocker::Unlock",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1 -> Node2 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::LevelMutexInfo::MultiUnlock",height=0.2,width=0.4,color="black",URL="$a00071.html#475d734ba0e756935462a5151ea98065"]; Node2 -> Node3 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node3 [label="Loki::LevelMutexInfo::DoErrorCheck",height=0.2,width=0.4,color="black",URL="$a00071.html#14e0d51318b864645bbb3df4f7c9f7ab"]; Node2 -> Node4 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node4 [label="Loki::DoMutexesMatchContainer",height=0.2,width=0.4,color="black",URL="$a00192.html#d633ca81ae0befaf235ae63886368037"]; Node4 -> Node5 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node5 [label="Loki::CountMutexesAtCurrentLevel",height=0.2,width=0.4,color="black",URL="$a00192.html#8cb767d3e7aaf2fe44b8f3b90218b876"]; Node5 -> Node6 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node6 [label="Loki::LevelMutexInfo::GetCurrentMutex",height=0.2,width=0.4,color="black",URL="$a00071.html#b7fd94847721b118979b72121472d3e2"]; Node6 -> Node7 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node7 [label="Loki::LevelMutexInfo::IsValidList",height=0.2,width=0.4,color="black",URL="$a00071.html#01f6dfba5d2ea5606109b34e5a543cf0"]; Node5 -> Node8 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node8 [label="Loki::LevelMutexInfo::GetLevel",height=0.2,width=0.4,color="black",URL="$a00071.html#1cad7c6b6fc50e230401e4cc22761d14",tooltip="Returns the level of this mutex."]; Node5 -> Node9 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node9 [label="Loki::LevelMutexInfo::GetPrevious",height=0.2,width=0.4,color="black",URL="$a00071.html#b774e94ff72724dd87ff236d99970bb5",tooltip="Returns pointer to mutex previously locked by the thread which locked this."]; Node4 -> Node10 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node10 [label="Loki::GetCurrentThreadsLevel",height=0.2,width=0.4,color="black",URL="$a00192.html#9548795d9cda6f227a1e1241ba577ca8"]; Node10 -> Node6 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node10 -> Node8 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node4 -> Node8 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node4 -> Node11 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node11 [label="Loki::LevelMutexInfo::IsRecentLock",height=0.2,width=0.4,color="black",URL="$a00071.html#b917108c3e7c83b8a515d28e91a3a3ca"]; Node11 -> Node12 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node12 [label="Loki::LevelMutexInfo::IsValid",height=0.2,width=0.4,color="black",URL="$a00071.html#36c34ecf5d019f3db9bfb8654cf49176"]; Node12 -> Node7 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 -> Node7 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 -> Node13 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node13 [label="Loki::LevelMutexInfo::UnlockThis",height=0.2,width=0.4,color="black",URL="$a00071.html#c90cb3e576ae5573381b991894c3b728",tooltip="Called only by MultiUnlock to unlock each particular mutex within a container."]; } libloki-0.1.7.orig/doc/html/a00080_18bfdec10dd2e65e128d64a80e42407f_cgraph.md50000755000175000017500000000004011140366257023547 0ustar ivanivan0ef34e0bee8ffc48e9c0ccdf7dd19448libloki-0.1.7.orig/doc/html/ftv2folderclosed.png0000755000175000017500000000040311140366263020247 0ustar ivanivan‰PNG  IHDR_Tq-PLTEภภภ€€€€€B๎@แtRNS@ๆุftEXtSoftwaregif2png 2.4.2ฃ^G}IDATxฺŽม „0C#Œw๛Bฝ+๘em๏ขอŠ3ญ๎Z๖ฐฺ๐†ฆˆ@S‚šืQB%ฎzv ํ๊yyIsแ๒2_Iนํ#` อ6fไ@Kดๅ๎x ๙–mย‹ขn๙PdฆpถP ำx†˜ฆ]%อ฿ฦ ˜`ฝ IENDฎB`‚libloki-0.1.7.orig/doc/html/a00364.html0000755000175000017500000000435111140366260016000 0ustar ivanivan Loki: Member List

Loki::ScopeGuardImpl4< F, P1, P2, P3, P4 > Member List

This is the complete list of members for Loki::ScopeGuardImpl4< F, P1, P2, P3, P4 >, including all inherited members.

ScopeGuardImplBase(const ScopeGuardImplBase &other)Loki::ScopeGuardImplBase [inline, protected]


Generated on Thu Jan 29 18:51:44 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00109.html0000755000175000017500000000521011140366261015771 0ustar ivanivan Loki: Loki::RejectNullStrict< P > Struct Template Reference

Loki::RejectNullStrict< P > Struct Template Reference
[Checking policies]

#include <SmartPtr.h>

List of all members.


Detailed Description

template<class P>
struct Loki::RejectNullStrict< P >

Implementation of the CheckingPolicy used by SmartPtr Checks the pointer upon initialization and before dereference
The documentation for this struct was generated from the following file:
  • SmartPtr.h

Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00423.html0000755000175000017500000000365511140366261016003 0ustar ivanivan Loki: Member List

Loki::RejectNull< P > Member List

This is the complete list of members for Loki::RejectNull< P >, including all inherited members.


Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00070_e770e4e5ec2fa120d016eb23b56d988b_cgraph.dot0000755000175000017500000000142511140366257023661 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node1 [label="Loki::LevelMutex::LevelMutex",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1 -> Node2 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::LevelMutexInfo::IsValid",height=0.2,width=0.4,color="black",URL="$a00071.html#36c34ecf5d019f3db9bfb8654cf49176"]; Node2 -> Node3 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node3 [label="Loki::LevelMutexInfo::IsValidList",height=0.2,width=0.4,color="black",URL="$a00071.html#01f6dfba5d2ea5606109b34e5a543cf0"]; } libloki-0.1.7.orig/doc/html/a00070_e770e4e5ec2fa120d016eb23b56d988b_cgraph.md50000755000175000017500000000004011140366257023550 0ustar ivanivan3587332f360703b0bf4c956475a7e4b5libloki-0.1.7.orig/doc/html/a00050.html0000755000175000017500000000532211140366261015770 0ustar ivanivan Loki: Loki::DisallowConversion Struct Reference

Loki::DisallowConversion Struct Reference
[Conversion policies]

#include <SmartPtr.h>

List of all members.


Detailed Description

Implementation of the ConversionPolicy used by SmartPtr Does not allow implicit conversion from SmartPtr to the pointee type You can initialize a DisallowConversion with an AllowConversion
The documentation for this struct was generated from the following file:
  • SmartPtr.h

Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00424.html0000755000175000017500000000367111140366261016002 0ustar ivanivan Loki: Member List

Loki::RejectNullStrict< P > Member List

This is the complete list of members for Loki::RejectNullStrict< P >, including all inherited members.


Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00051.html0000755000175000017500000000533111140366256015775 0ustar ivanivan Loki: Loki::DontPropagateConst< T > Class Template Reference

Loki::DontPropagateConst< T > Class Template Reference

#include <ConstPolicy.h>

List of all members.


Detailed Description

template<class T>
class Loki::DontPropagateConst< T >

Note:
These policy classes are used in LockingPtr and SmartPtr to define how const is propagated from the pointee.
Don't propagate constness of pointed or referred object.
The documentation for this class was generated from the following file:
  • ConstPolicy.h

Generated on Thu Jan 29 18:51:42 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00110.html0000755000175000017500000003122211140366257015770 0ustar ivanivan Loki: Loki::SafeBitConst< unique_index, word_t > Class Template Reference

Loki::SafeBitConst< unique_index, word_t > Class Template Reference

List of all members.

Public Types

typedef word_t bit_word_t
 Type of the bit field is available if needed.
typedef SafeBitField
< unique_index, word_t > 
field_t
 Corresponding field type.

Public Member Functions

 SafeBitConst ()
 Default constructor allows client code to construct bit fields on the stack.
 SafeBitConst (const SafeBitConst &rhs)
 Copy constructor.
bool operator== (const SafeBitConst &rhs) const
 Comparison operators which take a constant bit value.
bool operator== (const field_t &rhs) const
 Comparision operators for mutable bit fields.
const SafeBitConst operator| (const SafeBitConst &rhs) const
field_t operator| (const field_t &rhs) const
 These bitwise operators return a bit-field instead of a bit-const.
const SafeBitConst operator<< (unsigned int s) const

Static Public Member Functions

static size_t size ()
 Word size is also the maximum number of different bit fields for a given word type.

Friends

class SafeBitField< unique_index, word_t >
 Typedef is not allowed in friendship declaration.


Detailed Description

template<unsigned int unique_index, typename word_t = unsigned long>
class Loki::SafeBitConst< unique_index, word_t >

This class defines a bit-field constant - a collection of unchanging bits used to compare to bit-fields. Instances of this class are intended to act as labels for bit-fields.

Safety
  • This class provides operations used for comparisons and conversions, but no operations which may modify the value.
  • As a templated class, it provides type-safety so bit values and constants used for different reasons may not be unknowingly compared to each other.
  • The unique_index template parameter insures the unique type of each bit bit-field. It shares the unique_index with a similar SafeBitField.
  • Its operations only allow comparisons to other bit-constants and bit-fields of the same type.
This class defines a bit-field constant - a collection of unchanging bits used to compare to bit-fields. Instances of this class are intended to store bit values.

Safety
  • This class provides operations used for comparisons and conversions, and also operations which may safely modify the value.
  • As a templated class, it provides type-safety so bit values and constants used for different reasons may not be unknowingly compared to each other.
  • The unique_index template parameter insures the unique type of each bit bit-field. It shares the unique_index with a similar SafeBitConst.
  • Its operations only allow comparisons to other bit-constants and bit-fields of the same type.

Member Function Documentation

template<unsigned int unique_index, typename word_t = unsigned long>
const SafeBitConst Loki::SafeBitConst< unique_index, word_t >::operator<< ( unsigned int  s  )  const [inline]

The shift operators move bits inside the bit field. These are useful in loops which act over bit fields and increment them.

References Loki::SafeBitConst< unique_index, word_t >::SafeBitConst().

Here is the call graph for this function:

template<unsigned int unique_index, typename word_t = unsigned long>
const SafeBitConst Loki::SafeBitConst< unique_index, word_t >::operator| ( const SafeBitConst< unique_index, word_t > &  rhs  )  const [inline]

Bitwise operations. Operation-assignment operators are not needed, since bit constants cannot be changed after they are initialized.

References Loki::SafeBitConst< unique_index, word_t >::SafeBitConst(), and Loki::SafeBitConst< unique_index, word_t >::word.

Here is the call graph for this function:


The documentation for this class was generated from the following file:
  • SafeBits.h

Generated on Thu Jan 29 18:51:43 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/ftv2doc.png0000755000175000017500000000037711140366263016361 0ustar ivanivan‰PNG  IHDR_Tq-PLTEภภภ€€€ณฝ๛ศtRNS@ๆุftEXtSoftwaregif2png 2.4.2ฃ^GvIDATxฺc````c``d'0bqโ$8`qส'3001ฃ2 pT2Si`q'ส€\\ภ”ขˆRKRSiศ”„RRลi 6เคคคh‚ฤQ‚kqMaNU๒`'E$pgc 0ลo#๕ะเUƒGฝIENDฎB`‚libloki-0.1.7.orig/doc/html/a00425.html0000755000175000017500000000411711140366261015777 0ustar ivanivan Loki: Member List

Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy > Member List

This is the complete list of members for Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy >, including all inherited members.


Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/main.html0000755000175000017500000000267711140366250016117 0ustar ivanivan Loki: Main Page

Loki Documentation

0.1.7


Generated on Thu Jan 29 18:51:36 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/ftv2blank.png0000755000175000017500000000025611140366263016677 0ustar ivanivan‰PNG  IHDR–ึGtRNS”ฎtEXtSoftwaregif2png 2.4.2ฃ^G%tEXtCommentUlead GIF SmartSaver Ver 2.0!๘ื^SIDATxฺc8ภ€€0เBx<2หr|IENDฎB`‚libloki-0.1.7.orig/doc/html/a00052.html0000755000175000017500000000612511140366256016000 0ustar ivanivan Loki: Loki::EvictAging< DT, ST > Class Template Reference

Loki::EvictAging< DT, ST > Class Template Reference
[Eviction policies]

LRU aware of the time span of use. More...

#include <CachedFactory.h>

Inherits Loki::EvictionHelper< ST, DT >.

List of all members.


Detailed Description

template<typename DT, typename ST = unsigned>
class Loki::EvictAging< DT, ST >

LRU aware of the time span of use.

Implementation of the Aging algorithm as described in http://en.wikipedia.org/wiki/Page_replacement_algorithms .

This method is much more costly than evict LRU so if you need extreme performance consider switching to EvictLRU


The documentation for this class was generated from the following file:
  • CachedFactory.h

Generated on Thu Jan 29 18:51:42 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00367.html0000755000175000017500000000436111140366260016004 0ustar ivanivan Loki: Member List

Loki::ScopeGuardImpl5< F, P1, P2, P3, P4, P5 > Member List

This is the complete list of members for Loki::ScopeGuardImpl5< F, P1, P2, P3, P4, P5 >, including all inherited members.

ScopeGuardImplBase(const ScopeGuardImplBase &other)Loki::ScopeGuardImplBase [inline, protected]


Generated on Thu Jan 29 18:51:44 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00111.html0000755000175000017500000000634411140366260015772 0ustar ivanivan Loki: Loki::ScopeGuardImpl0< F > Class Template Reference

Loki::ScopeGuardImpl0< F > Class Template Reference
[Exception-safe code]

#include <ScopeGuard.h>

Inheritance diagram for Loki::ScopeGuardImpl0< F >:
Collaboration diagram for Loki::ScopeGuardImpl0< F >:

List of all members.


Detailed Description

template<typename F>
class Loki::ScopeGuardImpl0< F >

Implementation class for a standalone function or class static function with no parameters. ScopeGuard ignores any value returned from the call within the Execute function.

This class has a single standalone helper function, MakeGuard which creates and returns a ScopeGuard.


The documentation for this class was generated from the following file:
  • ScopeGuard.h

Generated on Thu Jan 29 18:51:44 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/annotated.html0000755000175000017500000005576211140366255017160 0ustar ivanivan Loki: Class List

Class List

Here are the classes, structs, unions and interfaces with brief descriptions:
AbstractFactoryImplements an abstract object factory
Loki::AllocatorSingleton< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >
Loki::AllowConversion
Loki::AllowReset< P >
Loki::AlwaysCreateAlways allows creation
Loki::AmountLimitedCreationLimit by number of objects
Loki::ArrayStorage< T >
Loki::AssertAnyMutexError
Loki::AssertBadDesignMutexError
Loki::AssertCheck< P >
Loki::AssertCheckStrict< P >
Loki::BaseVisitor
Loki::BinderFirst< OriginalFunctor >
Loki::CachedFactory< AbstractProduct, IdentifierType, CreatorParmTList, EncapsulationPolicy, CreationPolicy, EvictionPolicy, StatisticPolicy, FactoryErrorPolicy, ObjVector >Factory with caching support
Loki::CantResetWithStrong< P >
Loki::Chainer< Fun1, Fun2 >
Loki::CheckForEquality< Host >
Loki::CheckForNoChange< Host >
Loki::CheckForNoChangeOrThrow< Host >
Loki::CheckForNothing< Host >
Loki::CheckForNoThrow< Host >
Loki::CheckReturn< Value, OnError >
Loki::CheckStaticForNothing
Loki::CheckStaticForNoThrow
Loki::Chunk
Loki::CloneFactory< AbstractProduct, ProductCreator, FactoryErrorPolicy >Creates a copy from a polymorphic object
Loki::COMRefCounted< P >
Loki::ConstPropPtr< T >
Loki::ContractChecker< Host, ExceptionPolicy >
Loki::CreateStatic< T >
Loki::CreateUsing< Alloc >
Loki::CreateUsingMalloc< T >
Loki::CreateUsingNew< T >
Loki::CyclicVisitor< R, TList >
Loki::DeepCopy< P >
Loki::DefaultFactoryError< IdentifierType, AbstractProduct >Default policy that throws an exception
Loki::DefaultLifetime< T >
Loki::DefaultSPStorage< T >
Loki::DeletableSingleton< T >
Loki::DeleteArray< P >
Loki::DeleteNothing< P >
Loki::DeleteSingle< P >
Loki::DeleteUsingFree< P >
Loki::DestructiveCopy< P >
Loki::LongevityLifetime::DieAsSmallObjectChild< T >
Loki::LongevityLifetime::DieAsSmallObjectParent< T >
Loki::LongevityLifetime::DieDirectlyBeforeLast< T >Lifetime is a one less than DieLast: 0xFFFFFFFF-1
Loki::LongevityLifetime::DieFirst< T >Shortest possible SingletonWithLongevity lifetime: 0
Loki::LongevityLifetime::DieLast< T >Longest possible SingletonWithLongevity lifetime: 0xFFFFFFFF
Loki::DisallowConversion
Loki::DontPropagateConst< T >
Loki::EvictAging< DT, ST >LRU aware of the time span of use
Loki::EvictLRU< DT, ST >Evicts least accessed objects first
Loki::EvictRandom< DT, ST >Evicts a random object
Loki::Factory< AbstractProduct, IdentifierType, CreatorParmTList, FactoryErrorPolicy >
Loki::FixedAllocator
Loki::FollowIntoDeath
Loki::FollowIntoDeath::FollowIntoDeath::AfterMaster< Master >
Loki::FollowIntoDeath::FollowIntoDeath::AfterMaster< Master >::FollowIntoDeath::AfterMaster::IsDestroyed< F >
Loki::FollowIntoDeath::FollowIntoDeath::With< Lifetime >
Loki::FollowIntoDeath::FollowIntoDeath::With< Lifetime >::FollowIntoDeath::With::AsMasterLifetime< Master >
Function
Loki::FunctionStorage< T >Implementation of the StoragePolicy used by SmartPtr
Loki::Functor< R, TList, ThreadingModel >
Loki::HeapStorage< T >
ImplOf
Loki::JustReturnMutexError
Loki::Key< Factory, IdentifierType >
std::less< Loki::StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > >
Loki::LevelMutex< MutexPolicy, DefaultLevel, ErrorPolicy, WaitPolicy >
Loki::LevelMutexInfo
Loki::LevelMutexInfo::LevelMutexInfo::Checker
Loki::LevelMutexInfo::LevelMutexInfo::MutexUndoer
LockableTwoRefCountInfo
LockableTwoRefCounts
Loki::LockedStorage< T >
Loki::LockingPtr< SharedObject, LockingPolicy, ConstPolicy >
Loki::LokiAllocator< Type, AllocT >
Loki::LokiAllocator< Type, AllocT >::LokiAllocator::rebind< Type1 >Convert an allocator<Type> to an allocator <Type1>
Loki::MultiMutexLocker
Loki::Mutex
Loki::MutexException
Loki::MutexLocker
Loki::MutexSleepWaits
Loki::NeverCreateNever allows creation. Testing purposes only
Loki::NeverReset< P >
Loki::NoCheck< P >
Loki::NoCopy< P >
Loki::NoDestroy< T >
Loki::NoMutexWait
Loki::NoStatisticPolicyDo nothing
Loki::NullPointerException
Loki::ObjScopeGuardImpl0< Obj, MemFun >
Loki::ObjScopeGuardImpl1< Obj, MemFun, P1 >
Loki::ObjScopeGuardImpl2< Obj, MemFun, P1, P2 >
Loki::ObjScopeGuardImpl3< Obj, MemFun, P1, P2, P3 >
Loki::PhoenixSingleton< T >
Loki::Pimpl< T, Pointer >
PImplOf
Loki::PropagateConst< T >
Loki::RateLimitedCreationLimit in rate
Loki::RefCounted< P >
RefCountedMT
Loki::RefLinked< P >
Loki::RefToValue< T >
Loki::RegisterOnCreateSet< ElementList >
Loki::RejectNull< P >
Loki::RejectNullStatic< P >
Loki::RejectNullStrict< P >
Loki::SafeBitConst< unique_index, word_t >
Loki::ScopeGuardImpl0< F >
Loki::ScopeGuardImpl1< F, P1 >
Loki::ScopeGuardImpl2< F, P1, P2 >
Loki::ScopeGuardImpl3< F, P1, P2, P3 >
Loki::ScopeGuardImpl4< F, P1, P2, P3, P4 >
Loki::ScopeGuardImpl5< F, P1, P2, P3, P4, P5 >
Loki::ScopeGuardImplBase
Loki::SimplePointer< AbstractProduct >No encaspulation : returns the pointer
Loki::SimpleStatisticPolicySimple statistics
Loki::SingleThreaded< Host, MutexPolicy >
Loki::SingleThreaded< Host, MutexPolicy >::SingleThreaded::Lock
Loki::Singleton< T >
Loki::LongevityLifetime::SingletonFixedLongevity< Longevity, T >
Loki::SingletonHolder< T, CreationPolicy, LifetimePolicy, ThreadingModel, MutexPolicy >
Loki::SingletonWithLongevity< T >
Loki::SleepLevelMutex
Loki::SmallObjAllocator
Loki::SmallObject< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >
Loki::SmallObjectBase< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >
Loki::SmallValueObject< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >
Loki::SmartPointer< AbstractProduct, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ConstnessPolicy >Encapsulate the object in a SmartPtr with FunctionStorage policy
Loki::SmartPtr< T, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy >
Loki::SpinLevelMutex
Loki::StaticChecker< ExceptionPolicy >
Loki::StrongPtr< T, Strong, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ResetPolicy, DeletePolicy, ConstnessPolicy >
Loki::ThrowOnAnyMutexError
Loki::ThrowOnBadDesignMutexError
Loki::Private::TwoRefCountInfo
Loki::TwoRefCounts
Loki::TwoRefLinks
Loki::UnRegisterOnDeleteSet< ElementList >
Visitor

Generated on Thu Jan 29 18:51:41 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00070_553a379257af57ceaef9ed48b0dc8b70_cgraph.dot0000755000175000017500000000472611140366257023771 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node1 [label="Loki::LevelMutex::Unlock",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1 -> Node2 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::LevelMutexInfo::GetLevel",height=0.2,width=0.4,color="black",URL="$a00071.html#1cad7c6b6fc50e230401e4cc22761d14",tooltip="Returns the level of this mutex."]; Node1 -> Node3 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node3 [label="Loki::LevelMutexInfo::IsValid",height=0.2,width=0.4,color="black",URL="$a00071.html#36c34ecf5d019f3db9bfb8654cf49176"]; Node3 -> Node4 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node4 [label="Loki::LevelMutexInfo::IsValidList",height=0.2,width=0.4,color="black",URL="$a00071.html#01f6dfba5d2ea5606109b34e5a543cf0"]; Node1 -> Node5 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node5 [label="Loki::LevelMutexInfo::PostLock",height=0.2,width=0.4,color="black",URL="$a00071.html#3fe2ecf1bcf2c49eae04c493f023099c"]; Node5 -> Node6 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node6 [label="Loki::LevelMutexInfo::IsLockedByCurrentThread",height=0.2,width=0.4,color="black",URL="$a00071.html#c0a343bcb322ea36495f536504f61f9f",tooltip="Returns true if this was locked by current thread."]; Node6 -> Node7 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node7 [label="Loki::LevelMutexInfo::IsLocked",height=0.2,width=0.4,color="black",URL="$a00071.html#e6aa7465e1bba7f0c9fbf0b06f122a39",tooltip="Returns true if this mutex was locked at least once."]; Node6 -> Node3 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node5 -> Node3 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node1 -> Node8 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node8 [label="Loki::LevelMutexInfo::PreUnlock",height=0.2,width=0.4,color="black",URL="$a00071.html#7d5e2ace54e9423866be7c76116423df",tooltip="Gets called just before an attempt to unlock a mutex."]; Node8 -> Node6 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node8 -> Node3 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; } libloki-0.1.7.orig/doc/html/a00070_553a379257af57ceaef9ed48b0dc8b70_cgraph.md50000755000175000017500000000004011140366257023651 0ustar ivanivan0c30bc50f41d303be25cb665604b518alibloki-0.1.7.orig/doc/html/a00056_f84b504579cea189ce1c415ee8ed5d2c_cgraph.dot0000755000175000017500000000115511140366262023760 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node1 [label="Loki::FixedAllocator::HasBlock",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1 -> Node2 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::Chunk::HasBlock",height=0.2,width=0.4,color="black",URL="$a00025.html#b4ce346a74a437dabe4748bfb8e8b950",tooltip="Returns true if block at address P is inside this Chunk."]; } libloki-0.1.7.orig/doc/html/a00056_f84b504579cea189ce1c415ee8ed5d2c_cgraph.md50000755000175000017500000000004011140366262023647 0ustar ivanivan6f4e07fe9ed18f1cd1e8c5df420984a3libloki-0.1.7.orig/doc/html/a00053.html0000755000175000017500000000604411140366256016001 0ustar ivanivan Loki: Loki::EvictLRU< DT, ST > Class Template Reference

Loki::EvictLRU< DT, ST > Class Template Reference
[Eviction policies]

Evicts least accessed objects first. More...

#include <CachedFactory.h>

Inherits Loki::EvictionHelper< ST , DT >.

List of all members.


Detailed Description

template<typename DT, typename ST = unsigned>
class Loki::EvictLRU< DT, ST >

Evicts least accessed objects first.

Implementation of the Least recent used algorithm as described in http://en.wikipedia.org/wiki/Page_replacement_algorithms .

WARNING : If an object is heavily fetched (more than ULONG_MAX = UINT_MAX = 4294967295U) it could unfortunately be removed from the cache.


The documentation for this class was generated from the following file:
  • CachedFactory.h

Generated on Thu Jan 29 18:51:42 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00218_g05304aaf9fabf1dda13ddff6146e2fe2_cgraph.dot0000755000175000017500000000116511140366255024321 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node1 [label="Loki::operator\>",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1 -> Node2 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::StrongPtr::LessThan",height=0.2,width=0.4,color="black",URL="$a00135.html#baea90f6e505a2afc662fe07c9c117fa",tooltip="Helper function which can be called to avoid exposing GetPointer function."]; } libloki-0.1.7.orig/doc/html/a00218_g05304aaf9fabf1dda13ddff6146e2fe2_cgraph.md50000755000175000017500000000004011140366255024207 0ustar ivanivan04351aa857b16a7464ab308af19106f9libloki-0.1.7.orig/doc/html/a00112.html0000755000175000017500000000653611140366260015776 0ustar ivanivan Loki: Loki::ScopeGuardImpl1< F, P1 > Class Template Reference

Loki::ScopeGuardImpl1< F, P1 > Class Template Reference
[Exception-safe code]

#include <ScopeGuard.h>

Inheritance diagram for Loki::ScopeGuardImpl1< F, P1 >:
Collaboration diagram for Loki::ScopeGuardImpl1< F, P1 >:

List of all members.


Detailed Description

template<typename F, typename P1>
class Loki::ScopeGuardImpl1< F, P1 >

Implementation class for a standalone function or class static function with one parameter. Each parameter is copied by value - use Loki::ByRef if you must use a reference instead. ScopeGuard ignores any value returned from the call within the Execute function.

This class has a single standalone helper function, MakeGuard which creates and returns a ScopeGuard.


The documentation for this class was generated from the following file:
  • ScopeGuard.h

Generated on Thu Jan 29 18:51:44 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00427.html0000755000175000017500000000636011140366261016003 0ustar ivanivan Loki: Member List

Loki::FunctionStorage< T > Member List

This is the complete list of members for Loki::FunctionStorage< T >, including all inherited members.

FunctorType typedefLoki::FunctionStorage< T >
InitPointerType typedefLoki::FunctionStorage< T >
PointerType typedefLoki::FunctionStorage< T >
ReferenceType typedefLoki::FunctionStorage< T >
SetCallBackFunction(const FunctorType &functor)Loki::FunctionStorage< T > [inline]
StoredType typedefLoki::FunctionStorage< T >


Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00054.html0000755000175000017500000000542711140366256016006 0ustar ivanivan Loki: Loki::EvictRandom< DT, ST > Class Template Reference

Loki::EvictRandom< DT, ST > Class Template Reference
[Eviction policies]

Evicts a random object. More...

#include <CachedFactory.h>

List of all members.


Detailed Description

template<typename DT, typename ST = void>
class Loki::EvictRandom< DT, ST >

Evicts a random object.

Implementation of the Random algorithm as described in http://en.wikipedia.org/wiki/Page_replacement_algorithms .


The documentation for this class was generated from the following file:
  • CachedFactory.h

Generated on Thu Jan 29 18:51:42 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00113.html0000755000175000017500000000660011140366260015767 0ustar ivanivan Loki: Loki::ScopeGuardImpl2< F, P1, P2 > Class Template Reference

Loki::ScopeGuardImpl2< F, P1, P2 > Class Template Reference
[Exception-safe code]

#include <ScopeGuard.h>

Inheritance diagram for Loki::ScopeGuardImpl2< F, P1, P2 >:
Collaboration diagram for Loki::ScopeGuardImpl2< F, P1, P2 >:

List of all members.


Detailed Description

template<typename F, typename P1, typename P2>
class Loki::ScopeGuardImpl2< F, P1, P2 >

Implementation class for a standalone function or class static function with two parameters. Each parameter is copied by value - use Loki::ByRef if you must use a reference instead. ScopeGuard ignores any value returned from the call within the Execute function.

This class has a single standalone helper function, MakeGuard which creates and returns a ScopeGuard.


The documentation for this class was generated from the following file:
  • ScopeGuard.h

Generated on Thu Jan 29 18:51:44 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00428.html0000755000175000017500000000412511140366261016001 0ustar ivanivan Loki: Member List

Loki::SmartPointer< AbstractProduct, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ConstnessPolicy > Member List

This is the complete list of members for Loki::SmartPointer< AbstractProduct, OwnershipPolicy, ConversionPolicy, CheckingPolicy, ConstnessPolicy >, including all inherited members.


Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00218_g24773dba1237da071b5df66455393f1d_cgraph.dot0000755000175000017500000000116611140366254023613 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node1 [label="Loki::operator\<=",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1 -> Node2 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::StrongPtr::LessThan",height=0.2,width=0.4,color="black",URL="$a00135.html#baea90f6e505a2afc662fe07c9c117fa",tooltip="Helper function which can be called to avoid exposing GetPointer function."]; } libloki-0.1.7.orig/doc/html/a00218_g24773dba1237da071b5df66455393f1d_cgraph.md50000755000175000017500000000004011140366254023500 0ustar ivanivan7bd94d4505b8f3671ca52895b56e3729libloki-0.1.7.orig/doc/html/a00071_36c34ecf5d019f3db9bfb8654cf49176_cgraph.dot0000755000175000017500000000106511140366256023705 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node1 [label="Loki::LevelMutexInfo::IsValid",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1 -> Node2 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::LevelMutexInfo::IsValidList",height=0.2,width=0.4,color="black",URL="$a00071.html#01f6dfba5d2ea5606109b34e5a543cf0"]; } libloki-0.1.7.orig/doc/html/a00071_36c34ecf5d019f3db9bfb8654cf49176_cgraph.md50000755000175000017500000000004011140366256023574 0ustar ivanivandb891ff4b6f115bbe0d2b6fdc0eb47a1libloki-0.1.7.orig/doc/html/a00300.html0000755000175000017500000000367511140366256016003 0ustar ivanivan Loki: Member List

Loki::CheckForNothing< Host > Member List

This is the complete list of members for Loki::CheckForNothing< Host >, including all inherited members.


Generated on Thu Jan 29 18:51:42 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00055.html0000755000175000017500000000707211140366256016005 0ustar ivanivan Loki: Loki::Factory< AbstractProduct, IdentifierType, CreatorParmTList, FactoryErrorPolicy > Class Template Reference

Loki::Factory< AbstractProduct, IdentifierType, CreatorParmTList, FactoryErrorPolicy > Class Template Reference
[Factory]

#include <Factory.h>

List of all members.


Detailed Description

template<class AbstractProduct, typename IdentifierType, typename CreatorParmTList = NullType, template< typename, class > class FactoryErrorPolicy = DefaultFactoryError>
class Loki::Factory< AbstractProduct, IdentifierType, CreatorParmTList, FactoryErrorPolicy >

Implements a generic object factory.

Create functions can have up to 15 parameters.

Singleton lifetime when used with Loki::SingletonHolder
Because Factory uses internally Functors which inherits from SmallObject you must use the singleton lifetime Alternatively you could suppress for Functor the inheritance from SmallObject by defining the macro:
 LOKI_FUNCTOR_IS_NOT_A_SMALLOBJECT 

The documentation for this class was generated from the following file:
  • Factory.h

Generated on Thu Jan 29 18:51:42 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00114.html0000755000175000017500000000664311140366260015777 0ustar ivanivan Loki: Loki::ScopeGuardImpl3< F, P1, P2, P3 > Class Template Reference

Loki::ScopeGuardImpl3< F, P1, P2, P3 > Class Template Reference
[Exception-safe code]

#include <ScopeGuard.h>

Inheritance diagram for Loki::ScopeGuardImpl3< F, P1, P2, P3 >:
Collaboration diagram for Loki::ScopeGuardImpl3< F, P1, P2, P3 >:

List of all members.


Detailed Description

template<typename F, typename P1, typename P2, typename P3>
class Loki::ScopeGuardImpl3< F, P1, P2, P3 >

Implementation class for a standalone function or class static function with three parameters. Each parameter is copied by value - use Loki::ByRef if you must use a reference instead. ScopeGuard ignores any value returned from the call within the Execute function.

This class has a single standalone helper function, MakeGuard which creates and returns a ScopeGuard.


The documentation for this class was generated from the following file:
  • ScopeGuard.h

Generated on Thu Jan 29 18:51:44 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/ftv2mlastnode.png0000755000175000017500000000024011140366263017567 0ustar ivanivan‰PNG  IHDRรรฤy PLTE€€€<^ป,tRNS@ๆุftEXtSoftwaregif2png 2.4.2ฃ^G#IDATxฺc`   `„Œกก ษจตPส‰amบภiศIENDฎB`‚libloki-0.1.7.orig/doc/html/a00429.html0000755000175000017500000000424411140366261016004 0ustar ivanivan Loki: Member List

Loki::DeleteUsingFree< P > Member List

This is the complete list of members for Loki::DeleteUsingFree< P >, including all inherited members.

Default(void)Loki::DeleteUsingFree< P > [inline, static]


Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00002_082b4ba1c6574c5bed916c55ecf46e82_cgraph.dot0000755000175000017500000000362411140366261023661 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node1 [label="Loki::AllocatorSingleton::ClearExtraMemory",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1 -> Node2 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::AllocatorSingleton::Instance",height=0.2,width=0.4,color="black",URL="$a00002.html#0de7839b1e888e11ff44bc50b78ca7d7",tooltip="Returns reference to the singleton."]; Node2 -> Node3 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node3 [label="Loki::SingletonHolder::Instance",height=0.2,width=0.4,color="black",URL="$a00124.html#43e4ea5cb6291a8bb14eb7cdc2bcb7bf",tooltip="Returns a reference to singleton object."]; Node1 -> Node4 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node4 [label="Loki::SmallObjAllocator::TrimExcessMemory",height=0.2,width=0.4,color="black",URL="$a00127.html#6b635664b20a6984303dabde86c8ac83"]; Node4 -> Node5 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node5 [label="Loki::SmallObjAllocator::GetAlignment",height=0.2,width=0.4,color="black",URL="$a00127.html#b1c8a2a3d7e9368ab59422ddd082105c",tooltip="Returns # of bytes between allocation boundaries."]; Node4 -> Node6 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node6 [label="Loki::SmallObjAllocator::GetMaxObjectSize",height=0.2,width=0.4,color="black",URL="$a00127.html#e49e9de3fd7b2fd93676cc1d63299b0d",tooltip="Returns max # of bytes which this can allocate."]; Node4 -> Node7 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node7 [label="Loki::GetOffset",height=0.2,width=0.4,color="black",URL="$a00217.html#g2f0821e243f812a3ae2abfaea51895e8"]; } libloki-0.1.7.orig/doc/html/a00002_082b4ba1c6574c5bed916c55ecf46e82_cgraph.md50000755000175000017500000000004011140366261023545 0ustar ivanivan84911e21e65ec1647dcc0d78cff36d3blibloki-0.1.7.orig/doc/html/a00127_2b669733cfa9dd157603d13d979f8c1c_cgraph.dot0000755000175000017500000000601211140366260023537 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node1 [label="Loki::SmallObjAllocator::Deallocate",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1 -> Node2 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::FixedAllocator::BlockSize",height=0.2,width=0.4,color="black",URL="$a00056.html#37df732230913b2dd9126a6b311586f0",tooltip="Returns block size with which the FixedAllocator was initialized."]; Node1 -> Node3 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node3 [label="Loki::FixedAllocator::Deallocate",height=0.2,width=0.4,color="black",URL="$a00056.html#49ab7ca3364fe05f2d7d91248ee5d0e3"]; Node3 -> Node4 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node4 [label="Loki::FixedAllocator::CountEmptyChunks",height=0.2,width=0.4,color="black",URL="$a00056.html#e74cbab50e78bfa115d7c0fcdce00641"]; Node4 -> Node5 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node5 [label="Loki::Chunk::HasAvailable",height=0.2,width=0.4,color="black",URL="$a00025.html#0874a711145788bd8c5265a9de2a4aac"]; Node3 -> Node6 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node6 [label="Loki::Chunk::HasBlock",height=0.2,width=0.4,color="black",URL="$a00025.html#b4ce346a74a437dabe4748bfb8e8b950",tooltip="Returns true if block at address P is inside this Chunk."]; Node3 -> Node7 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node7 [label="Loki::Chunk::IsBlockAvailable",height=0.2,width=0.4,color="black",URL="$a00025.html#8fe6ac2943df6c2f60123f928f119a73"]; Node3 -> Node8 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node8 [label="Loki::Chunk::IsCorrupt",height=0.2,width=0.4,color="black",URL="$a00025.html#245b6450d855d8ab65e9ca7add3e2071"]; Node1 -> Node9 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node9 [label="Loki::DefaultDeallocator",height=0.2,width=0.4,color="black",URL="$a00217.html#g1d24bf776342ace8f2004e3a173f6cb3"]; Node1 -> Node10 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node10 [label="Loki::SmallObjAllocator::GetAlignment",height=0.2,width=0.4,color="black",URL="$a00127.html#b1c8a2a3d7e9368ab59422ddd082105c",tooltip="Returns # of bytes between allocation boundaries."]; Node1 -> Node11 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node11 [label="Loki::SmallObjAllocator::GetMaxObjectSize",height=0.2,width=0.4,color="black",URL="$a00127.html#e49e9de3fd7b2fd93676cc1d63299b0d",tooltip="Returns max # of bytes which this can allocate."]; Node1 -> Node12 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node12 [label="Loki::GetOffset",height=0.2,width=0.4,color="black",URL="$a00217.html#g2f0821e243f812a3ae2abfaea51895e8"]; } libloki-0.1.7.orig/doc/html/a00127_2b669733cfa9dd157603d13d979f8c1c_cgraph.md50000755000175000017500000000004011140366260023431 0ustar ivanivan7d4e667431931cc55dff4da5cc3fe883libloki-0.1.7.orig/doc/html/a00301.html0000755000175000017500000000601311140366256015771 0ustar ivanivan Loki: Member List

Loki::ContractChecker< Host, ExceptionPolicy > Member List

This is the complete list of members for Loki::ContractChecker< Host, ExceptionPolicy >, including all inherited members.

Check(void) const Loki::ContractChecker< Host, ExceptionPolicy > [inline]
ContractChecker(const Host *host, Validator validator, Validator pre=0, Validator post=0)Loki::ContractChecker< Host, ExceptionPolicy > [inline]
Validator typedefLoki::ContractChecker< Host, ExceptionPolicy >
~ContractChecker(void)Loki::ContractChecker< Host, ExceptionPolicy > [inline]


Generated on Thu Jan 29 18:51:42 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00056.html0000755000175000017500000004072011140366262016000 0ustar ivanivan Loki: Loki::FixedAllocator Class Reference

Loki::FixedAllocator Class Reference
[Internals]

Collaboration diagram for Loki::FixedAllocator:

List of all members.

Public Member Functions

 FixedAllocator ()
 Create a FixedAllocator which manages blocks of 'blockSize' size.
 ~FixedAllocator ()
 Destroy the FixedAllocator and release all its Chunks.
void Initialize (std::size_t blockSize, std::size_t pageSize)
 Initializes a FixedAllocator by calculating # of blocks per Chunk.
void * Allocate (void)
bool Deallocate (void *p, Chunk *hint)
std::size_t BlockSize () const
 Returns block size with which the FixedAllocator was initialized.
bool TrimEmptyChunk (void)
bool TrimChunkList (void)
std::size_t CountEmptyChunks (void) const
bool IsCorrupt (void) const
const ChunkHasBlock (void *p) const


Detailed Description

Offers services for allocating fixed-sized objects. It has a container of "containers" of fixed-size blocks. The outer container has all the Chunks. The inner container is a Chunk which owns some blocks.

Class Level Invariants
  • There is always either zero or one Chunk which is empty.
  • If this has no empty Chunk, then emptyChunk_ is NULL.
  • If this has an empty Chunk, then emptyChunk_ points to it.
  • If the Chunk container is empty, then deallocChunk_ and allocChunk_ are NULL.
  • If the Chunk container is not-empty, then deallocChunk_ and allocChunk_ are either NULL or point to Chunks within the container.
  • allocChunk_ will often point to the last Chunk in the container since it was likely allocated most recently, and therefore likely to have an available block.

Member Function Documentation

void * Loki::FixedAllocator::Allocate ( void   ) 

Returns pointer to allocated memory block of fixed size - or NULL if it failed to allocate.

References Loki::Chunk::Allocate(), CountEmptyChunks(), Loki::Chunk::HasAvailable(), Loki::Chunk::IsCorrupt(), and Loki::Chunk::IsFilled().

Referenced by Loki::SmallObjAllocator::Allocate().

Here is the call graph for this function:

std::size_t Loki::FixedAllocator::CountEmptyChunks ( void   )  const

Returns count of empty Chunks held by this allocator. Complexity is O(C) where C is the total number of Chunks - empty or used.

References Loki::Chunk::HasAvailable().

Referenced by Allocate(), Deallocate(), IsCorrupt(), and TrimEmptyChunk().

Here is the call graph for this function:

bool Loki::FixedAllocator::Deallocate ( void *  p,
Chunk hint 
)

Deallocate a memory block previously allocated with Allocate. If the block is not owned by this FixedAllocator, it returns false so that SmallObjAllocator can call the default deallocator. If the block was found, this returns true.

References CountEmptyChunks(), Loki::Chunk::HasBlock(), Loki::Chunk::IsBlockAvailable(), and Loki::Chunk::IsCorrupt().

Referenced by Loki::SmallObjAllocator::Deallocate().

Here is the call graph for this function:

const Chunk * Loki::FixedAllocator::HasBlock ( void *  p  )  const

Returns true if the block at address p is within a Chunk owned by this FixedAllocator. Complexity is O(C) where C is the total number of Chunks - empty or used.

References Loki::Chunk::HasBlock().

Referenced by Loki::SmallObjAllocator::Deallocate().

Here is the call graph for this function:

bool Loki::FixedAllocator::IsCorrupt ( void   )  const

Determines if FixedAllocator is corrupt. Checks data members to see if any have erroneous values, or violate class invariants. It also checks if any Chunk is corrupt. Complexity is O(C) where C is the number of Chunks. If any data is corrupt, this will return true in release mode, or assert in debug mode.

References CountEmptyChunks(), Loki::Chunk::HasAvailable(), and Loki::Chunk::IsCorrupt().

Here is the call graph for this function:

bool Loki::FixedAllocator::TrimChunkList ( void   ) 

Releases unused spots from ChunkList. This takes constant time with respect to # of Chunks, but actual time depends on underlying memory allocator.

Returns:
False if no unused spots, true if some found and released.

bool Loki::FixedAllocator::TrimEmptyChunk ( void   ) 

Releases the memory used by the empty Chunk. This will take constant time under any situation.

Returns:
True if empty chunk found and released, false if none empty.

References Loki::Chunk::blocksAvailable_, CountEmptyChunks(), Loki::Chunk::HasAvailable(), and Loki::Chunk::Release().

Referenced by ~FixedAllocator().

Here is the call graph for this function:


The documentation for this class was generated from the following file:
  • SmallObj.cpp

Generated on Thu Jan 29 18:51:46 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00370.html0000755000175000017500000000434311140366260015776 0ustar ivanivan Loki: Member List

Loki::ObjScopeGuardImpl0< Obj, MemFun > Member List

This is the complete list of members for Loki::ObjScopeGuardImpl0< Obj, MemFun >, including all inherited members.

ScopeGuardImplBase(const ScopeGuardImplBase &other)Loki::ScopeGuardImplBase [inline, protected]


Generated on Thu Jan 29 18:51:44 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00115.html0000755000175000017500000000670311140366260015775 0ustar ivanivan Loki: Loki::ScopeGuardImpl4< F, P1, P2, P3, P4 > Class Template Reference

Loki::ScopeGuardImpl4< F, P1, P2, P3, P4 > Class Template Reference
[Exception-safe code]

#include <ScopeGuard.h>

Inheritance diagram for Loki::ScopeGuardImpl4< F, P1, P2, P3, P4 >:
Collaboration diagram for Loki::ScopeGuardImpl4< F, P1, P2, P3, P4 >:

List of all members.


Detailed Description

template<typename F, typename P1, typename P2, typename P3, typename P4>
class Loki::ScopeGuardImpl4< F, P1, P2, P3, P4 >

Implementation class for a standalone function or class static function with four parameters. Each parameter is copied by value - use Loki::ByRef if you must use a reference instead. ScopeGuard ignores any value returned from the call within the Execute function.

This class has a single standalone helper function, MakeGuard which creates and returns a ScopeGuard.


The documentation for this class was generated from the following file:
  • ScopeGuard.h

Generated on Thu Jan 29 18:51:44 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/ftv2vertline.png0000755000175000017500000000034511140366263017437 0ustar ivanivan‰PNG  IHDRLƒ1ู0PLTE€€€ำ tRNS@ๆุftEXtSoftwaregif2png 2.4.2ฃ^G&tEXtCommentUlead GIF SmartSaver Ver 2.0io?อIDATxฺc`0ภO[!ฆๅ<่:IENDฎB`‚libloki-0.1.7.orig/doc/html/graph_legend.dot0000755000175000017500000000426711140366263017435 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; Node9 [shape="box",label="Inherited",fontsize="10",height=0.2,width=0.4,fontname="FreeSans",fillcolor="grey75",style="filled" fontcolor="black"]; Node10 -> Node9 [dir=back,color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node10 [shape="box",label="PublicBase",fontsize="10",height=0.2,width=0.4,fontname="FreeSans",color="black",URL="$classPublicBase.html"]; Node11 -> Node10 [dir=back,color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node11 [shape="box",label="Truncated",fontsize="10",height=0.2,width=0.4,fontname="FreeSans",color="red",URL="$classTruncated.html"]; Node13 -> Node9 [dir=back,color="darkgreen",fontsize="10",style="solid",fontname="FreeSans"]; Node13 [shape="box",label="ProtectedBase",fontsize="10",height=0.2,width=0.4,fontname="FreeSans",color="black",URL="$classProtectedBase.html"]; Node14 -> Node9 [dir=back,color="firebrick4",fontsize="10",style="solid",fontname="FreeSans"]; Node14 [shape="box",label="PrivateBase",fontsize="10",height=0.2,width=0.4,fontname="FreeSans",color="black",URL="$classPrivateBase.html"]; Node15 -> Node9 [dir=back,color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node15 [shape="box",label="Undocumented",fontsize="10",height=0.2,width=0.4,fontname="FreeSans",color="grey75"]; Node16 -> Node9 [dir=back,color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node16 [shape="box",label="Templ< int >",fontsize="10",height=0.2,width=0.4,fontname="FreeSans",color="black",URL="$classTempl.html"]; Node17 -> Node16 [dir=back,color="orange",fontsize="10",style="dashed",label="< int >",fontname="FreeSans"]; Node17 [shape="box",label="Templ< T >",fontsize="10",height=0.2,width=0.4,fontname="FreeSans",color="black",URL="$classTempl.html"]; Node18 -> Node9 [dir=back,color="darkorchid3",fontsize="10",style="dashed",label="m_usedClass",fontname="FreeSans"]; Node18 [shape="box",label="Used",fontsize="10",height=0.2,width=0.4,fontname="FreeSans",color="black",URL="$classUsed.html"]; } libloki-0.1.7.orig/doc/html/a00083_ae8699ba4423d83aff277149c9008ec8_cgraph.dot0000755000175000017500000000147411140366257023560 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node1 [label="Loki::MutexLocker::MutexLocker",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1 -> Node2 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::LevelMutexInfo::GetLevel",height=0.2,width=0.4,color="black",URL="$a00071.html#1cad7c6b6fc50e230401e4cc22761d14",tooltip="Returns the level of this mutex."]; Node1 -> Node3 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node3 [label="Loki::LevelMutexInfo::Lock",height=0.2,width=0.4,color="black",URL="$a00071.html#c0e21e08ee9974533a4da5008452bd04"]; } libloki-0.1.7.orig/doc/html/a00083_ae8699ba4423d83aff277149c9008ec8_cgraph.md50000755000175000017500000000004011140366257023443 0ustar ivanivan2fed2b030039dd864733cd18f2b9dac5libloki-0.1.7.orig/doc/html/a00302.html0000755000175000017500000000365511140366256016003 0ustar ivanivan Loki: Member List

Loki::CheckStaticForNoThrow Member List

This is the complete list of members for Loki::CheckStaticForNoThrow, including all inherited members.


Generated on Thu Jan 29 18:51:42 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00057.html0000755000175000017500000000737111140366260016004 0ustar ivanivan Loki: Loki::FollowIntoDeath Class Reference

Loki::FollowIntoDeath Class Reference
[Lifetime policies]

#include <Singleton.h>


Classes

struct  AfterMaster
struct  With


Detailed Description

Lifetime policyfor the SingletonHolder tempalte. Followers will die after the master dies Followers will not die, if

Usage:
Lifetimes of the master and the follower singletons, e.g. with a M and a F class:
 SingletonHolder< M , FollowIntoDeath::With<DefaultLifetime>::AsMasterLifetime > MasterSingleton; 
 SingletonHolder< F , CreateUsingNew, FollowIntoDeath::AfterMaster< MasterSingleton >::IsDestroyed > FollowerSingleton 

The documentation for this class was generated from the following file:
  • Singleton.h

Generated on Thu Jan 29 18:51:44 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00116.html0000755000175000017500000000674411140366260016003 0ustar ivanivan Loki: Loki::ScopeGuardImpl5< F, P1, P2, P3, P4, P5 > Class Template Reference

Loki::ScopeGuardImpl5< F, P1, P2, P3, P4, P5 > Class Template Reference
[Exception-safe code]

#include <ScopeGuard.h>

Inheritance diagram for Loki::ScopeGuardImpl5< F, P1, P2, P3, P4, P5 >:
Collaboration diagram for Loki::ScopeGuardImpl5< F, P1, P2, P3, P4, P5 >:

List of all members.


Detailed Description

template<typename F, typename P1, typename P2, typename P3, typename P4, typename P5>
class Loki::ScopeGuardImpl5< F, P1, P2, P3, P4, P5 >

Implementation class for a standalone function or class static function with five parameters. Each parameter is copied by value - use Loki::ByRef if you must use a reference instead. ScopeGuard ignores any value returned from the call within the Execute function.

This class has a single standalone helper function, MakeGuard which creates and returns a ScopeGuard.


The documentation for this class was generated from the following file:
  • ScopeGuard.h

Generated on Thu Jan 29 18:51:44 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00430.html0000755000175000017500000000366311140366261016000 0ustar ivanivan Loki: Member List

Loki::DeleteNothing< P > Member List

This is the complete list of members for Loki::DeleteNothing< P >, including all inherited members.


Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00303.html0000755000175000017500000000365511140366256016004 0ustar ivanivan Loki: Member List

Loki::CheckStaticForNothing Member List

This is the complete list of members for Loki::CheckStaticForNothing, including all inherited members.


Generated on Thu Jan 29 18:51:42 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00058.html0000755000175000017500000000575711140366260016013 0ustar ivanivan Loki: Loki::FollowIntoDeath::FollowIntoDeath::AfterMaster< Master > Struct Template Reference

Loki::FollowIntoDeath::FollowIntoDeath::AfterMaster< Master > Struct Template Reference

#include <Singleton.h>


Classes

struct  IsDestroyed


Detailed Description

template<class Master>
struct Loki::FollowIntoDeath::AfterMaster< Master >

Template for the follower
Parameters:
Master Master to follow into death

The documentation for this struct was generated from the following file:
  • Singleton.h

Generated on Thu Jan 29 18:51:44 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00117.html0000755000175000017500000000741311140366257016004 0ustar ivanivan Loki: Loki::ScopeGuardImplBase Class Reference

Loki::ScopeGuardImplBase Class Reference
[Exception-safe code]

#include <ScopeGuard.h>

Inheritance diagram for Loki::ScopeGuardImplBase:

List of all members.

Protected Member Functions

 ScopeGuardImplBase (const ScopeGuardImplBase &other) throw ()
 Copy-constructor takes over responsibility from other ScopeGuard.


Detailed Description

Base class used by all ScopeGuard implementations. All commonly used functions are in this class (e.g. - Dismiss and SafeExecute).

See Andrei's and Petru Marginean's CUJ article http://www.cuj.com/documents/s=8000/cujcexp1812alexandr/alexandr.htm

Changes to the original code by Joshua Lehrer: http://www.lehrerfamily.com/scopeguard.html


The documentation for this class was generated from the following file:
  • ScopeGuard.h

Generated on Thu Jan 29 18:51:43 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00431.html0000755000175000017500000000424011140366261015771 0ustar ivanivan Loki: Member List

Loki::DeleteSingle< P > Member List

This is the complete list of members for Loki::DeleteSingle< P >, including all inherited members.

Delete(const P *p)Loki::DeleteSingle< P > [inline, static]


Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00304.html0000755000175000017500000000571711140366256016006 0ustar ivanivan Loki: Member List

Loki::StaticChecker< ExceptionPolicy > Member List

This is the complete list of members for Loki::StaticChecker< ExceptionPolicy >, including all inherited members.

Check(void) const Loki::StaticChecker< ExceptionPolicy > [inline]
StaticChecker(Validator validator, Validator pre=0, Validator post=0)Loki::StaticChecker< ExceptionPolicy > [inline, explicit]
Validator typedefLoki::StaticChecker< ExceptionPolicy >
~StaticChecker(void)Loki::StaticChecker< ExceptionPolicy > [inline]


Generated on Thu Jan 29 18:51:42 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00059.html0000755000175000017500000000545611140366260016010 0ustar ivanivan Loki: Loki::FollowIntoDeath::FollowIntoDeath::AfterMaster< Master >::FollowIntoDeath::AfterMaster::IsDestroyed< F > Struct Template Reference

Loki::FollowIntoDeath::FollowIntoDeath::AfterMaster< Master >::FollowIntoDeath::AfterMaster::IsDestroyed< F > Struct Template Reference

#include <Singleton.h>

List of all members.


Detailed Description

template<class Master>
template<class F>
struct Loki::FollowIntoDeath::AfterMaster< Master >::IsDestroyed< F >

Policy for followers
The documentation for this struct was generated from the following file:
  • Singleton.h

Generated on Thu Jan 29 18:51:44 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00373.html0000755000175000017500000000435311140366260016002 0ustar ivanivan Loki: Member List

Loki::ObjScopeGuardImpl1< Obj, MemFun, P1 > Member List

This is the complete list of members for Loki::ObjScopeGuardImpl1< Obj, MemFun, P1 >, including all inherited members.

ScopeGuardImplBase(const ScopeGuardImplBase &other)Loki::ScopeGuardImplBase [inline, protected]


Generated on Thu Jan 29 18:51:44 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00118.html0000755000175000017500000000537311140366256016007 0ustar ivanivan Loki: Loki::SimplePointer< AbstractProduct > Class Template Reference

Loki::SimplePointer< AbstractProduct > Class Template Reference
[Encapsulation policies]

No encaspulation : returns the pointer. More...

#include <CachedFactory.h>

List of all members.


Detailed Description

template<class AbstractProduct>
class Loki::SimplePointer< AbstractProduct >

No encaspulation : returns the pointer.

This implementation does not make any encapsulation. It simply returns the object's pointer.


The documentation for this class was generated from the following file:
  • CachedFactory.h

Generated on Thu Jan 29 18:51:42 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00432.html0000755000175000017500000000423511140366261015776 0ustar ivanivan Loki: Member List

Loki::DeleteArray< P > Member List

This is the complete list of members for Loki::DeleteArray< P >, including all inherited members.

Delete(const P *p)Loki::DeleteArray< P > [inline, static]


Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00305.html0000755000175000017500000000567611140366256016013 0ustar ivanivan Loki: Member List

Loki::CheckReturn< Value, OnError > Member List

This is the complete list of members for Loki::CheckReturn< Value, OnError >, including all inherited members.

CheckReturn(const Value &value)Loki::CheckReturn< Value, OnError > [inline]
CheckReturn(const CheckReturn &that)Loki::CheckReturn< Value, OnError > [inline]
operator Value(void)Loki::CheckReturn< Value, OnError > [inline]
~CheckReturn(void)Loki::CheckReturn< Value, OnError > [inline]


Generated on Thu Jan 29 18:51:42 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00218_g272c9c4d6381679daba26c93ac36a70e_cgraph.dot0000755000175000017500000000117111140366254023755 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node1 [label="Loki::operator\<=",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1 -> Node2 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::StrongPtr::GreaterThan",height=0.2,width=0.4,color="black",URL="$a00135.html#f43b2cde389f926c16e166c418b13040",tooltip="Helper function which can be called to avoid exposing GetPointer function."]; } libloki-0.1.7.orig/doc/html/a00218_g272c9c4d6381679daba26c93ac36a70e_cgraph.md50000755000175000017500000000004011140366254023646 0ustar ivanivanb08462dbcf7d639ab4db076b7630806flibloki-0.1.7.orig/doc/html/a00119.html0000755000175000017500000000534711140366256016011 0ustar ivanivan Loki: Loki::SimpleStatisticPolicy Class Reference

Loki::SimpleStatisticPolicy Class Reference
[Statistic policies]

Simple statistics. More...

#include <CachedFactory.h>

List of all members.


Detailed Description

Simple statistics.

Provides the following informations about the cache :

  • Created objects
  • Fetched objects
  • Destroyed objects
  • Cache hit
  • Cache miss
  • Currently allocated
  • Currently out
  • Cache overall efficiency

The documentation for this class was generated from the following file:
  • CachedFactory.h

Generated on Thu Jan 29 18:51:42 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00134_03eca9af5c834a019115f519994d84d7_cgraph.dot0000755000175000017500000000106311140366256023455 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node1 [label="Loki::StaticChecker::StaticChecker",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1 -> Node2 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::StaticChecker::Check",height=0.2,width=0.4,color="black",URL="$a00134.html#d8e80dcf79a603395ecc9d5b2fe91491"]; } libloki-0.1.7.orig/doc/html/a00134_03eca9af5c834a019115f519994d84d7_cgraph.md50000755000175000017500000000004011140366256023346 0ustar ivanivan5548a554d8da47828a10beca642f915dlibloki-0.1.7.orig/doc/html/a00433.html0000755000175000017500000000367711140366261016010 0ustar ivanivan Loki: Member List

Loki::CantResetWithStrong< P > Member List

This is the complete list of members for Loki::CantResetWithStrong< P >, including all inherited members.


Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00306.html0000755000175000017500000000367511140366256016011 0ustar ivanivan Loki: Member List

Loki::DontPropagateConst< T > Member List

This is the complete list of members for Loki::DontPropagateConst< T >, including all inherited members.


Generated on Thu Jan 29 18:51:42 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00060.html0000755000175000017500000000576411140366260016002 0ustar ivanivan Loki: Loki::FollowIntoDeath::FollowIntoDeath::With< Lifetime > Struct Template Reference

Loki::FollowIntoDeath::FollowIntoDeath::With< Lifetime > Struct Template Reference

#include <Singleton.h>


Classes

struct  AsMasterLifetime


Detailed Description

template<template< class > class Lifetime>
struct Loki::FollowIntoDeath::With< Lifetime >

Template for the master
Parameters:
Lifetime Lifetime policy for the master

The documentation for this struct was generated from the following file:
  • Singleton.h

Generated on Thu Jan 29 18:51:44 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/modules.html0000755000175000017500000000626011140366255016640 0ustar ivanivan Loki: Module Index
Generated on Thu Jan 29 18:51:41 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00434.html0000755000175000017500000000365511140366261016005 0ustar ivanivan Loki: Member List

Loki::AllowReset< P > Member List

This is the complete list of members for Loki::AllowReset< P >, including all inherited members.


Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00127_6b635664b20a6984303dabde86c8ac83_cgraph.dot0000755000175000017500000000217411140366261023530 0ustar ivanivandigraph G { bgcolor="transparent"; edge [fontname="FreeSans",fontsize="10",labelfontname="FreeSans",labelfontsize="10"]; node [fontname="FreeSans",fontsize="10",shape=record]; rankdir=LR; Node1 [label="Loki::SmallObjAllocator::TrimExcessMemory",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled" fontcolor="black"]; Node1 -> Node2 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node2 [label="Loki::SmallObjAllocator::GetAlignment",height=0.2,width=0.4,color="black",URL="$a00127.html#b1c8a2a3d7e9368ab59422ddd082105c",tooltip="Returns # of bytes between allocation boundaries."]; Node1 -> Node3 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node3 [label="Loki::SmallObjAllocator::GetMaxObjectSize",height=0.2,width=0.4,color="black",URL="$a00127.html#e49e9de3fd7b2fd93676cc1d63299b0d",tooltip="Returns max # of bytes which this can allocate."]; Node1 -> Node4 [color="midnightblue",fontsize="10",style="solid",fontname="FreeSans"]; Node4 [label="Loki::GetOffset",height=0.2,width=0.4,color="black",URL="$a00217.html#g2f0821e243f812a3ae2abfaea51895e8"]; } libloki-0.1.7.orig/doc/html/a00127_6b635664b20a6984303dabde86c8ac83_cgraph.md50000755000175000017500000000004011140366261023415 0ustar ivanivanedd50eb12b7912fe7c3be4d53bd3d27elibloki-0.1.7.orig/doc/html/a00307.html0000755000175000017500000000366511140366256016011 0ustar ivanivan Loki: Member List

Loki::PropagateConst< T > Member List

This is the complete list of members for Loki::PropagateConst< T >, including all inherited members.


Generated on Thu Jan 29 18:51:42 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00061.html0000755000175000017500000000550711140366260015776 0ustar ivanivan Loki: Loki::FollowIntoDeath::FollowIntoDeath::With< Lifetime >::FollowIntoDeath::With::AsMasterLifetime< Master > Struct Template Reference

Loki::FollowIntoDeath::FollowIntoDeath::With< Lifetime >::FollowIntoDeath::With::AsMasterLifetime< Master > Struct Template Reference

#include <Singleton.h>

List of all members.


Detailed Description

template<template< class > class Lifetime>
template<class Master>
struct Loki::FollowIntoDeath::With< Lifetime >::AsMasterLifetime< Master >

Policy for master
The documentation for this struct was generated from the following file:
  • Singleton.h

Generated on Thu Jan 29 18:51:44 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00376.html0000755000175000017500000000436311140366260016006 0ustar ivanivan Loki: Member List

Loki::ObjScopeGuardImpl2< Obj, MemFun, P1, P2 > Member List

This is the complete list of members for Loki::ObjScopeGuardImpl2< Obj, MemFun, P1, P2 >, including all inherited members.

ScopeGuardImplBase(const ScopeGuardImplBase &other)Loki::ScopeGuardImplBase [inline, protected]


Generated on Thu Jan 29 18:51:44 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00120.html0000755000175000017500000000561111140366261015767 0ustar ivanivan Loki: Loki::SingleThreaded< Host, MutexPolicy > Class Template Reference

Loki::SingleThreaded< Host, MutexPolicy > Class Template Reference
[Threading]

#include <Threads.h>

List of all members.

Classes

struct  Lock


Detailed Description

template<class Host, class MutexPolicy = ::Loki::Mutex>
class Loki::SingleThreaded< Host, MutexPolicy >

Implementation of the ThreadingModel policy used by various classes Implements a single-threaded model; no synchronization
The documentation for this class was generated from the following file:
  • Threads.h

Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00435.html0000755000175000017500000000365511140366261016006 0ustar ivanivan Loki: Member List

Loki::NeverReset< P > Member List

This is the complete list of members for Loki::NeverReset< P >, including all inherited members.


Generated on Thu Jan 29 18:51:45 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/ftv2pnode.png0000755000175000017500000000031011140366263016704 0ustar ivanivan‰PNG  IHDRLƒ1ู$PLTEภภภ€€€Sพ™tRNS@ๆุftEXtSoftwaregif2png 2.4.2ฃ^G0IDATxฺc` .เBn&8โโTŠสเ >DŒ›II‰››YฆS;:บk/ชหoIENDฎB`‚libloki-0.1.7.orig/doc/html/a00308.html0000755000175000017500000000377311140366256016012 0ustar ivanivan Loki: Member List

Loki::DefaultFactoryError< IdentifierType, AbstractProduct > Member List

This is the complete list of members for Loki::DefaultFactoryError< IdentifierType, AbstractProduct >, including all inherited members.


Generated on Thu Jan 29 18:51:42 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/html/a00062.html0000755000175000017500000000537011140366255016001 0ustar ivanivan Loki: Function Struct Reference

Function Struct Reference
[Function objects]

#include <Function.h>


Detailed Description

Allows a boost/TR1 like usage of Functor.

Usage

see also test/Function/FunctionTest.cpp (the modified test program from boost)


The documentation for this struct was generated from the following file:
  • Function.h

Generated on Thu Jan 29 18:51:41 2009 for Loki by  doxygen 1.5.8
libloki-0.1.7.orig/doc/yasli/0000755000175000017500000000000011140365041014440 5ustar ivanivanlibloki-0.1.7.orig/doc/yasli/yasli.html0000644000175000017500000000312210515241547016456 0ustar ivanivan

YASLI

The legendary YASLI stands for "Yet Another Standard Library Implementation", and is meant to be an STL implementation that exploits type introspection and guarded platform assumptions at its best to yield lean and mean code.

By definition, YASLI is the best implementation all around; however, it is also a non-existent one, because it was created in Yasland and we don't have full access to Yaslander technology yet. YASLI is often dreamed of by Andrei, but seldom worked on because Andrei's current main interest (and time sink) is his research. <\p>

This first component of the legendary YASLI is now available together with a simple test suite that compares yasli::vector's behavior against std::vector. (Many thanks to Casper Edward Aethelric Cody Clemence, who submitted a largely fixed version on January 13th, 2005.)

As of now, the implementation illustrates the definition and use of a moving protocol, and has a number of known inefficiencies and a yet-unknown number of bugs. You are welcome to improve the former and report the latter.

Some bugs in MSVC 7.1 prevent the data moving protocol to function properly for certain data types, such as std::complex. That code has been commented out as of now.

Unfortunately, the article that describes yasli::vector's design and implementation ("yasli::vector Is On The Move") is not available online; it is published in C/C++ Users Journal, June 2004. It will be available on this site 3 months after publication.

libloki-0.1.7.orig/doc/yasli/Notes.txt0000644000175000017500000000307010515241547016302 0ustar ivanivan This carries an "aint nuffin clever in 'ere" warning: So far All I have done is get yasvec compiling again, remove a few bugs and extend reallocate for some cases where msize and expand are availible. enable_if removed, its function replaced with type_selector in the case of namespace level functions and the use of dummy Int2Type arguments in member functions. I don't like dummy arguments but they seemed better than the other options (namely external, explicitly templated functions 'hidden' in an implementation namespace). I should have kept a log of all of the bugs I pulled out and other modifications, Indeed, I almost did but somehow it didn't quite happen - sorry. uninitialised_copy I have defined for InputItr = const T* and InputItr = T* seperately, this is less than desireable but previously with only the const-data version defined any non const pointers were being eaten up by the default templated function. This is fairly minor but I mentions because you may disagree with me. To do: Cut vector back vector to a buffer then decide whether it is sensible to re-implement vector using this buffer. Implement valarray and related classes using yasli_nstd::buffer and other yasli components. The structure of these classes will follow that found in Mingw32 - expressions are to be evaluated during assignment. Add yasli_nstd::reference_valarray, a class which behaves like valarray and can be used in conjuction with it but which consists of an array of pointers.libloki-0.1.7.orig/doc/Doxyfile0000644000175000017500000002260211140366203015030 0ustar ivanivan# Doxyfile 1.4.4 #--------------------------------------------------------------------------- # Project related configuration options #--------------------------------------------------------------------------- PROJECT_NAME = Loki PROJECT_NUMBER = 0.1.7 OUTPUT_DIRECTORY = . CREATE_SUBDIRS = NO OUTPUT_LANGUAGE = English USE_WINDOWS_ENCODING = YES BRIEF_MEMBER_DESC = YES REPEAT_BRIEF = YES ABBREVIATE_BRIEF = "The $name class" \ "The $name widget" \ "The $name file" \ is \ provides \ specifies \ contains \ represents \ a \ an \ the ALWAYS_DETAILED_SEC = NO INLINE_INHERITED_MEMB = NO FULL_PATH_NAMES = NO STRIP_FROM_PATH = C:/Programme/doxygen/bin/ STRIP_FROM_INC_PATH = SHORT_NAMES = YES JAVADOC_AUTOBRIEF = NO MULTILINE_CPP_IS_BRIEF = NO DETAILS_AT_TOP = NO INHERIT_DOCS = YES DISTRIBUTE_GROUP_DOC = NO SEPARATE_MEMBER_PAGES = NO TAB_SIZE = 5 ALIASES = OPTIMIZE_OUTPUT_FOR_C = NO OPTIMIZE_OUTPUT_JAVA = NO SUBGROUPING = YES #--------------------------------------------------------------------------- # Build related configuration options #--------------------------------------------------------------------------- EXTRACT_ALL = NO EXTRACT_PRIVATE = NO EXTRACT_STATIC = YES EXTRACT_LOCAL_CLASSES = YES EXTRACT_LOCAL_METHODS = YES HIDE_UNDOC_MEMBERS = YES HIDE_UNDOC_CLASSES = YES HIDE_FRIEND_COMPOUNDS = NO HIDE_IN_BODY_DOCS = NO INTERNAL_DOCS = NO CASE_SENSE_NAMES = NO HIDE_SCOPE_NAMES = NO SHOW_INCLUDE_FILES = YES INLINE_INFO = YES SORT_MEMBER_DOCS = YES SORT_BRIEF_DOCS = NO SORT_BY_SCOPE_NAME = NO GENERATE_TODOLIST = YES GENERATE_TESTLIST = YES GENERATE_BUGLIST = YES GENERATE_DEPRECATEDLIST= YES ENABLED_SECTIONS = MAX_INITIALIZER_LINES = 30 SHOW_USED_FILES = YES SHOW_DIRECTORIES = NO FILE_VERSION_FILTER = #--------------------------------------------------------------------------- # configuration options related to warning and progress messages #--------------------------------------------------------------------------- QUIET = NO WARNINGS = YES WARN_IF_UNDOCUMENTED = YES WARN_IF_DOC_ERROR = YES WARN_NO_PARAMDOC = NO WARN_FORMAT = "$file:$line: $text" WARN_LOGFILE = #--------------------------------------------------------------------------- # configuration options related to the input files #--------------------------------------------------------------------------- INPUT = ../include/loki \ ../src FILE_PATTERNS = *.c \ *.cc \ *.cxx \ *.cpp \ *.c++ \ *.d \ *.java \ *.ii \ *.ixx \ *.ipp \ *.i++ \ *.inl \ *.h \ *.hh \ *.hxx \ *.hpp \ *.h++ \ *.idl \ *.odl \ *.cs \ *.php \ *.php3 \ *.inc \ *.m \ *.mm \ *.dox RECURSIVE = NO EXCLUDE = EXCLUDE_SYMLINKS = NO EXCLUDE_PATTERNS = EXAMPLE_PATH = EXAMPLE_PATTERNS = * EXAMPLE_RECURSIVE = NO IMAGE_PATH = INPUT_FILTER = FILTER_PATTERNS = FILTER_SOURCE_FILES = NO #--------------------------------------------------------------------------- # configuration options related to source browsing #--------------------------------------------------------------------------- SOURCE_BROWSER = NO INLINE_SOURCES = NO STRIP_CODE_COMMENTS = YES REFERENCED_BY_RELATION = YES REFERENCES_RELATION = YES USE_HTAGS = NO VERBATIM_HEADERS = NO #--------------------------------------------------------------------------- # configuration options related to the alphabetical class index #--------------------------------------------------------------------------- ALPHABETICAL_INDEX = YES COLS_IN_ALPHA_INDEX = 2 IGNORE_PREFIX = #--------------------------------------------------------------------------- # configuration options related to the HTML output #--------------------------------------------------------------------------- GENERATE_HTML = YES HTML_OUTPUT = html HTML_FILE_EXTENSION = .html HTML_HEADER = HTML_FOOTER = HTML_STYLESHEET = HTML_ALIGN_MEMBERS = YES GENERATE_HTMLHELP = NO CHM_FILE = HHC_LOCATION = GENERATE_CHI = NO BINARY_TOC = NO TOC_EXPAND = NO DISABLE_INDEX = NO ENUM_VALUES_PER_LINE = 4 GENERATE_TREEVIEW = YES TREEVIEW_WIDTH = 250 #--------------------------------------------------------------------------- # configuration options related to the LaTeX output #--------------------------------------------------------------------------- GENERATE_LATEX = NO LATEX_OUTPUT = latex LATEX_CMD_NAME = latex MAKEINDEX_CMD_NAME = makeindex COMPACT_LATEX = NO PAPER_TYPE = a4wide EXTRA_PACKAGES = LATEX_HEADER = PDF_HYPERLINKS = NO USE_PDFLATEX = NO LATEX_BATCHMODE = NO LATEX_HIDE_INDICES = NO #--------------------------------------------------------------------------- # configuration options related to the RTF output #--------------------------------------------------------------------------- GENERATE_RTF = NO RTF_OUTPUT = rtf COMPACT_RTF = NO RTF_HYPERLINKS = NO RTF_STYLESHEET_FILE = RTF_EXTENSIONS_FILE = #--------------------------------------------------------------------------- # configuration options related to the man page output #--------------------------------------------------------------------------- GENERATE_MAN = NO MAN_OUTPUT = man MAN_EXTENSION = .3 MAN_LINKS = NO #--------------------------------------------------------------------------- # configuration options related to the XML output #--------------------------------------------------------------------------- GENERATE_XML = NO XML_OUTPUT = xml XML_SCHEMA = XML_DTD = XML_PROGRAMLISTING = YES #--------------------------------------------------------------------------- # configuration options for the AutoGen Definitions output #--------------------------------------------------------------------------- GENERATE_AUTOGEN_DEF = NO #--------------------------------------------------------------------------- # configuration options related to the Perl module output #--------------------------------------------------------------------------- GENERATE_PERLMOD = NO PERLMOD_LATEX = NO PERLMOD_PRETTY = YES PERLMOD_MAKEVAR_PREFIX = #--------------------------------------------------------------------------- # Configuration options related to the preprocessor #--------------------------------------------------------------------------- ENABLE_PREPROCESSING = YES MACRO_EXPANSION = YES EXPAND_ONLY_PREDEF = NO SEARCH_INCLUDES = YES INCLUDE_PATH = INCLUDE_FILE_PATTERNS = PREDEFINED = _WINDOWS_H EXPAND_AS_DEFINED = SKIP_FUNCTION_MACROS = YES #--------------------------------------------------------------------------- # Configuration::additions related to external references #--------------------------------------------------------------------------- TAGFILES = GENERATE_TAGFILE = ALLEXTERNALS = NO EXTERNAL_GROUPS = YES PERL_PATH = /usr/bin/perl #--------------------------------------------------------------------------- # Configuration options related to the dot tool #--------------------------------------------------------------------------- CLASS_DIAGRAMS = YES HIDE_UNDOC_RELATIONS = YES HAVE_DOT = YES CLASS_GRAPH = YES COLLABORATION_GRAPH = YES GROUP_GRAPHS = YES UML_LOOK = NO TEMPLATE_RELATIONS = YES INCLUDE_GRAPH = YES INCLUDED_BY_GRAPH = YES CALL_GRAPH = YES GRAPHICAL_HIERARCHY = YES DIRECTORY_GRAPH = YES DOT_IMAGE_FORMAT = png DOT_PATH = DOTFILE_DIRS = MAX_DOT_GRAPH_WIDTH = 1024 MAX_DOT_GRAPH_HEIGHT = 1024 MAX_DOT_GRAPH_DEPTH = 1000 DOT_TRANSPARENT = YES DOT_MULTI_TARGETS = NO GENERATE_LEGEND = YES DOT_CLEANUP = YES #--------------------------------------------------------------------------- # Configuration::additions related to the search engine #--------------------------------------------------------------------------- SEARCHENGINE = YES libloki-0.1.7.orig/lib/0000755000175000017500000000000011140365041013320 5ustar ivanivanlibloki-0.1.7.orig/lib/README0000644000175000017500000000010110515241547014201 0ustar ivanivanThere is no library (*.lib) when using the ms vc++ toolkit 2003. libloki-0.1.7.orig/src/0000755000175000017500000000000011140365041013341 5ustar ivanivanlibloki-0.1.7.orig/src/Makefile0000644000175000017500000000476511137411362015021 0ustar ivanivaninclude ../Makefile.common SRC := $(wildcard *.cpp) STATIC_OBJ := $(SRC:.cpp=.o) SHARED_OBJ := $(SRC:.cpp=.lo) override CPPFLAGS += -I../include -DNDEBUG STATIC_LIB := libloki.a ifeq ($(OS), Darwin) SHARED_LIB_BASE := libloki.dylib SHARED_LIB_VERSIONED := libloki.$(VERSION).dylib override LDFLAGS += -dynamiclib -single_module -install_name $(SHARED_LIB_VERSIONED) -fPIC LDLIBS := -lpthread else ifeq ($(OS), Linux) SHARED_LIB_BASE := libloki.so SHARED_LIB_VERSIONED := libloki.so.$(VERSION) override LDFLAGS += --shared -Wl,-soname=$(SHARED_LIB_VERSIONED) -fPIC LDLIBS := -lpthread else ifeq ($(OS), GNU/kFreeBSD) SHARED_LIB_BASE := libloki.so SHARED_LIB_VERSIONED := libloki.so.$(VERSION) override LDFLAGS += --shared -Wl,-soname=$(SHARED_LIB_VERSIONED) -fPIC LDLIBS := -lpthread else ifeq ($(OS), GNU) SHARED_LIB_BASE := libloki.so SHARED_LIB_VERSIONED := libloki.so.$(VERSION) override LDFLAGS += --shared -Wl,-soname=$(SHARED_LIB_VERSIONED) -fPIC LDLIBS := -lpthread else ifeq ($(OS), HP-UX) SHARED_LIB_BASE := libloki.so SHARED_LIB_VERSIONED := libloki.so.$(VERSION) override LDFLAGS += --shared -fPIC -mlp64 override CXXFLAGS += -mlp64 LDLIBS := -lpthread RESULT_DIR := ../lib/ else SHARED_LIB_VERSIONED := libloki.dll override LDFLAGS += --shared LDLIBS := endif endif endif endif endif RESULT_DIR := ../lib/ .PHONY: all build-static build-shared clean distclean all: build-static build-shared build-static: $(RESULT_DIR)$(STATIC_LIB) build-shared: $(RESULT_DIR)$(SHARED_LIB_VERSIONED) clean: $(RM) $(STATIC_OBJ) ifneq ($(OS), Windows) $(RM) $(SHARED_OBJ) endif distclean: clean cleandeps $(RM) $(RESULT_DIR)$(STATIC_LIB) $(RM) $(RESULT_DIR)$(SHARED_LIB_VERSIONED) ifneq ($(OS),Windows) INSTALL := install INSTALL_DATA := $(INSTALL) -m 644 .PHONY: install install-static install-shared install: install-static install-shared install-static: $(RESULT_DIR)$(STATIC_LIB) mkdir -p $(prefix)/lib $(INSTALL_DATA) $(RESULT_DIR)$(STATIC_LIB) $(prefix)/lib install-shared: $(RESULT_DIR)$(SHARED_LIB_VERSIONED) mkdir -p $(prefix)/lib $(INSTALL_DATA) $(RESULT_DIR)$(SHARED_LIB_VERSIONED) $(prefix)/lib cd $(prefix)/lib; ln -s $(SHARED_LIB_VERSIONED) $(SHARED_LIB_BASE) %.lo : %.cpp $(CXX) -c $(CXXFLAGS) -fPIC $(CPPFLAGS) -o $@ $< $(RESULT_DIR)$(SHARED_LIB_VERSIONED): $(SHARED_OBJ) else $(RESULT_DIR)$(SHARED_LIB_VERSIONED): $(STATIC_OBJ) endif $(CXX) $(LDFLAGS) -o $@ $^ $(LDLIBS) $(RESULT_DIR)$(STATIC_LIB): $(STATIC_OBJ) $(AR) $(ARFLAGS) $@ $^ include ../Makefile.deps libloki-0.1.7.orig/src/StrongPtr.cpp0000644000175000017500000003251110573403624016022 0ustar ivanivan//////////////////////////////////////////////////////////////////////////////// // The Loki Library // Copyright (c) 2006 Rich Sposato // 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 makes no representations about the // suitability of this software for any purpose. It is provided "as is" // without express or implied warranty. //////////////////////////////////////////////////////////////////////////////// // $Id: StrongPtr.cpp 819 2007-03-07 00:30:12Z rich_sposato $ #include #include #ifdef DO_EXTRA_LOKI_TESTS #include #endif #include // ---------------------------------------------------------------------------- namespace Loki { // ---------------------------------------------------------------------------- TwoRefCounts::TwoRefCounts( bool strong ) : m_counts( NULL ) { void * temp = SmallObject<>::operator new( sizeof(Loki::Private::TwoRefCountInfo) ); #ifdef DO_EXTRA_LOKI_TESTS assert( temp != 0 ); #endif m_counts = new ( temp ) Loki::Private::TwoRefCountInfo( strong ); } // ---------------------------------------------------------------------------- TwoRefCounts::TwoRefCounts( const void * p, bool strong ) : m_counts( NULL ) { void * temp = SmallObject<>::operator new( sizeof(Loki::Private::TwoRefCountInfo) ); #ifdef DO_EXTRA_LOKI_TESTS assert( temp != 0 ); #endif void * p2 = const_cast< void * >( p ); m_counts = new ( temp ) Loki::Private::TwoRefCountInfo( p2, strong ); } // ---------------------------------------------------------------------------- void TwoRefCounts::Increment( bool strong ) { if ( strong ) { m_counts->IncStrongCount(); } else { m_counts->IncWeakCount(); } } // ---------------------------------------------------------------------------- bool TwoRefCounts::Decrement( bool strong ) { if ( strong ) { m_counts->DecStrongCount(); } else { m_counts->DecWeakCount(); } return !m_counts->HasStrongPointer(); } // ---------------------------------------------------------------------------- void TwoRefCounts::Swap( TwoRefCounts & rhs ) { std::swap( m_counts, rhs.m_counts ); } // ---------------------------------------------------------------------------- void TwoRefCounts::ZapPointer( void ) { #ifdef DO_EXTRA_LOKI_TESTS assert( !m_counts->HasStrongPointer() ); #endif if ( m_counts->HasWeakPointer() ) { m_counts->ZapPointer(); } else { SmallObject<>::operator delete ( m_counts, sizeof(Loki::Private::TwoRefCountInfo) ); m_counts = NULL; } } // ---------------------------------------------------------------------------- TwoRefLinks::TwoRefLinks( const void * p, bool strong ) : m_pointer( const_cast< void * >( p ) ) , m_strong( strong ) { m_prev = m_next = this; #ifdef DO_EXTRA_LOKI_TESTS assert( CountPrevCycle( this ) == CountNextCycle( this ) ); #endif } // ---------------------------------------------------------------------------- TwoRefLinks::TwoRefLinks( const TwoRefLinks & rhs, bool strong ) : m_pointer( rhs.m_pointer ) , m_prev( const_cast< TwoRefLinks * >( &rhs ) ) , m_next( rhs.m_next ) , m_strong( strong ) { m_prev->m_next = this; m_next->m_prev = this; #ifdef DO_EXTRA_LOKI_TESTS assert( m_prev->HasPrevNode( this ) ); assert( m_next->HasNextNode( this ) ); assert( rhs.m_next->HasNextNode( this ) ); assert( rhs.m_prev->HasPrevNode( this ) ); assert( CountPrevCycle( this ) == CountNextCycle( this ) ); assert( CountPrevCycle( this ) == CountNextCycle( &rhs ) ); assert( AllNodesHaveSamePointer() ); #endif } // ---------------------------------------------------------------------------- void TwoRefLinks::SetPointer( void * p ) { TwoRefLinks * node = m_prev; if ( ( this == node ) || ( 0 == node ) ) return; #ifdef DO_EXTRA_LOKI_TESTS assert( m_prev->HasPrevNode( this ) ); assert( m_next->HasNextNode( this ) ); assert( CountPrevCycle( this ) == CountNextCycle( this ) ); assert( AllNodesHaveSamePointer() ); #endif while ( node != this ) { node->m_pointer = p; node = node->m_next; } m_pointer = node; #ifdef DO_EXTRA_LOKI_TESTS assert( m_prev->HasPrevNode( this ) ); assert( m_next->HasNextNode( this ) ); assert( CountPrevCycle( this ) == CountNextCycle( this ) ); assert( AllNodesHaveSamePointer() ); #endif } // ---------------------------------------------------------------------------- bool TwoRefLinks::Release( bool strong ) { (void)strong; #ifdef DO_EXTRA_LOKI_TESTS assert( strong == m_strong ); assert( m_prev->HasPrevNode( this ) ); assert( m_next->HasNextNode( this ) ); assert( CountPrevCycle( this ) == CountNextCycle( this ) ); assert( AllNodesHaveSamePointer() ); #endif if ( NULL == m_next ) { #ifdef DO_EXTRA_LOKI_TESTS assert( NULL == m_prev ); #endif // Return false so it does not try to destroy shared object // more than once. return false; } else if (m_next == this) { #ifdef DO_EXTRA_LOKI_TESTS assert(m_prev == this); #endif // Set these to NULL to prevent re-entrancy. m_prev = NULL; m_next = NULL; // Last one in the cycle has to release the pointer. return true; } #ifdef DO_EXTRA_LOKI_TESTS assert( this != m_prev ); assert( NULL != m_prev ); assert( m_prev->HasPrevNode( this ) ); assert( m_next->HasNextNode( this ) ); #endif // If a single node is strong, then return false so it won't release. if ( HasStrongPointer() ) { // A cyclic chain of pointers is only as strong as the strongest link. m_prev->m_next = m_next; m_next->m_prev = m_prev; return false; } return true; } // ---------------------------------------------------------------------------- void TwoRefLinks::ZapAllNodes( void ) { TwoRefLinks * p = m_prev; if ( ( this == p ) || ( 0 == p ) ) return; #ifdef DO_EXTRA_LOKI_TESTS assert( AllNodesHaveSamePointer() ); #endif while ( p != this ) { TwoRefLinks * p1 = p->m_prev; p->m_pointer = 0; p->m_next = p; p->m_prev = p; p = p1; } m_pointer = 0; } // ---------------------------------------------------------------------------- void TwoRefLinks::Swap( TwoRefLinks & rhs ) { #ifdef DO_EXTRA_LOKI_TESTS assert( m_prev->HasPrevNode( this ) ); assert( m_next->HasNextNode( this ) ); assert( CountPrevCycle( this ) == CountNextCycle( this ) ); assert( AllNodesHaveSamePointer() ); assert( rhs.AllNodesHaveSamePointer() ); #endif std::swap( rhs.m_pointer, m_pointer ); if (m_next == this) { #ifdef DO_EXTRA_LOKI_TESTS // This is in a cycle by itself. assert(m_prev == this); #endif if (rhs.m_next == &rhs) { #ifdef DO_EXTRA_LOKI_TESTS assert(rhs.m_prev == &rhs); #endif // both are in 1-node cycles - thus there is nothing to do. return; } m_prev = rhs.m_prev; m_next = rhs.m_next; m_prev->m_next = m_next->m_prev = this; rhs.m_next = rhs.m_prev = &rhs; return; } if (rhs.m_next == &rhs) { #ifdef DO_EXTRA_LOKI_TESTS // rhs is in a cycle by itself. assert( rhs.m_prev == &rhs ); #endif rhs.m_prev = m_prev; rhs.m_next = m_next; m_prev->m_next = m_next->m_prev = &rhs; m_next = m_prev = this; return; } if (m_next == &rhs ) // rhs is next neighbour { if ( m_prev == &rhs ) return; // cycle of 2 pointers - no need to swap. std::swap(m_prev, m_next); std::swap(rhs.m_prev, rhs.m_next); std::swap(rhs.m_prev, m_next); std::swap(rhs.m_prev->m_next,m_next->m_prev); } else if ( m_prev == &rhs ) // rhs is prev neighbor { if ( m_next == &rhs ) return; // cycle of 2 pointers - no need to swap. std::swap( m_prev, m_next ); std::swap( rhs.m_next, rhs.m_prev ); std::swap( rhs.m_next, m_prev ); std::swap( rhs.m_next->m_prev, m_prev->m_next ); } else // not neighhbors { std::swap(m_prev, rhs.m_prev); std::swap(m_next, rhs.m_next); std::swap(m_prev->m_next, rhs.m_prev->m_next); std::swap(m_next->m_prev, rhs.m_next->m_prev); } #ifdef DO_EXTRA_LOKI_TESTS assert( m_next == this ? m_prev == this : m_prev != this); assert( m_prev == this ? m_next == this : m_next != this); assert( m_prev->HasPrevNode( this ) ); assert( m_next->HasNextNode( this ) ); assert( CountPrevCycle( this ) == CountNextCycle( this ) ); assert( rhs.m_prev->HasPrevNode( &rhs ) ); assert( rhs.m_next->HasNextNode( &rhs ) ); assert( CountPrevCycle( &rhs ) == CountNextCycle( &rhs ) ); assert( AllNodesHaveSamePointer() ); assert( rhs.AllNodesHaveSamePointer() ); #endif } // ---------------------------------------------------------------------------- bool TwoRefLinks::AllNodesHaveSamePointer( void ) const { const TwoRefLinks * next = m_next; if ( NULL == next ) return true; do { if ( next->m_pointer != m_pointer ) return false; next = next->m_next; } while ( next != this ); return true; } // ---------------------------------------------------------------------------- unsigned int TwoRefLinks::CountPrevCycle( const TwoRefLinks * pThis ) { if ( NULL == pThis ) return 0; const TwoRefLinks * p = pThis->m_prev; if ( NULL == p ) return 0; if ( pThis == p ) return 1; unsigned int count = 1; do { p = p->m_prev; ++count; } while ( p != pThis ); return count; } // ---------------------------------------------------------------------------- unsigned int TwoRefLinks::CountNextCycle( const TwoRefLinks * pThis ) { if ( NULL == pThis ) return 0; const TwoRefLinks * p = pThis->m_next; if ( NULL == p ) return 0; if ( pThis == p ) return 1; unsigned int count = 1; while ( p != pThis ) { p = p->m_next; ++count; } return count; } // ---------------------------------------------------------------------------- bool TwoRefLinks::HasPrevNode( const TwoRefLinks * p ) const { if ( this == p ) return true; const TwoRefLinks * prev = m_prev; if ( NULL == prev ) return false; while ( prev != this ) { if ( p == prev ) return true; prev = prev->m_prev; } return false; } // ---------------------------------------------------------------------------- bool TwoRefLinks::HasNextNode( const TwoRefLinks * p ) const { if ( this == p ) return true; const TwoRefLinks * next = m_next; if ( NULL == next ) return false; while ( next != this ) { if ( p == next ) return true; next = next->m_next; } return false; } // ---------------------------------------------------------------------------- bool TwoRefLinks::HasStrongPointer( void ) const { const TwoRefLinks * next = m_next; if ( NULL == next ) return false; while ( next != this ) { if ( next->m_strong ) return true; next = next->m_next; } return false; } // ---------------------------------------------------------------------------- bool TwoRefLinks::Merge( TwoRefLinks & rhs ) { if ( NULL == m_next ) { #ifdef DO_EXTRA_LOKI_TESTS assert( NULL == m_prev ); #endif return false; } TwoRefLinks * prhs = &rhs; if ( prhs == this ) return true; if ( NULL == prhs->m_next ) { #ifdef DO_EXTRA_LOKI_TESTS assert( NULL == prhs->m_prev ); #endif return true; } #ifdef DO_EXTRA_LOKI_TESTS assert( CountPrevCycle( this ) == CountNextCycle( this ) ); assert( CountPrevCycle( prhs ) == CountNextCycle( prhs ) ); #endif // If rhs node is already in this cycle, then no need to merge. if ( HasPrevNode( &rhs ) ) { #ifdef DO_EXTRA_LOKI_TESTS assert( HasNextNode( &rhs ) ); #endif return true; } if ( prhs == prhs->m_next ) { /// rhs is in a cycle with 1 node. #ifdef DO_EXTRA_LOKI_TESTS assert( prhs->m_prev == prhs ); #endif prhs->m_prev = m_prev; prhs->m_next = this; m_prev->m_next = prhs; m_prev = prhs; } else if ( this == m_next ) { /// this is in a cycle with 1 node. #ifdef DO_EXTRA_LOKI_TESTS assert( m_prev == this ); #endif m_prev = prhs->m_prev; m_next = prhs; prhs->m_prev->m_next = this; prhs->m_prev = this; } else { m_next->m_prev = prhs->m_prev; prhs->m_prev->m_next = m_prev; m_next = prhs; prhs->m_prev = this; } #ifdef DO_EXTRA_LOKI_TESTS assert( CountPrevCycle( this ) == CountNextCycle( this ) ); #endif return true; } // ---------------------------------------------------------------------------- } // end namespace Loki libloki-0.1.7.orig/src/make.msvc.bat0000644000175000017500000000044610515233307015725 0ustar ivanivan cl -c -Zm200 -O2 -DNDEBUG -MT -EHsc -GR -W4 -I"." -I"..\include" OrderedStatic.cpp SafeFormat.cpp SmallObj.cpp SmartPtr.cpp Singleton.cpp StrongPtr.cpp link /lib /NOLOGO /OUT:"..\lib\loki.lib" OrderedStatic.obj SafeFormat.obj SmallObj.obj SmartPtr.obj Singleton.obj StrongPtr.obj del *.obj libloki-0.1.7.orig/src/Library.vcproj0000644000175000017500000001524511042206311016174 0ustar ivanivan libloki-0.1.7.orig/src/OrderedStatic.cpp0000644000175000017500000000460410515233626016615 0ustar ivanivan//////////////////////////////////////////////////////////////////////////////// // The Loki Library // Copyright (c) 2005 Peter Kmmel // 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 makes no representations about the // suitability of this software for any purpose. It is provided "as is" // without express or implied warranty. //////////////////////////////////////////////////////////////////////////////// // $Id: OrderedStatic.cpp 756 2006-10-17 20:05:42Z syntheticpp $ #include #include #ifdef min #undef min #endif #ifdef max #undef max #endif namespace Loki { namespace Private { OrderedStaticCreatorFunc::OrderedStaticCreatorFunc() { } OrderedStaticCreatorFunc::~OrderedStaticCreatorFunc() { } OrderedStaticManagerClass::OrderedStaticManagerClass() : staticObjects_(), max_longevity_(std::numeric_limits::min()), min_longevity_(std::numeric_limits::max()) { } OrderedStaticManagerClass::~OrderedStaticManagerClass() { } void OrderedStaticManagerClass::createObjects() { for(unsigned int longevity=max_longevity_; longevity>=min_longevity_; longevity--) { for(unsigned int i=0; imax_longevity_) max_longevity_=l; if(l namespace Loki { // Crude writing method: writes straight to the file, unbuffered // Must be combined with a buffer to work properly (and efficiently) void write(std::FILE* f, const char* from, const char* to) { assert(from <= to); ::std::fwrite(from, 1, to - from, f); } // Write to a string void write(std::string& s, const char* from, const char* to) { assert(from <= to); s.append(from, to); } // Write to a stream void write(std::ostream& f, const char* from, const char* to) { assert(from <= to); f.write(from, std::streamsize(to - from)); } //////////////////////////////////////////////////////////////////////////////// // PrintfState class template // Holds the formatting state, and implements operator() to format stuff // Todo: make sure errors are handled properly //////////////////////////////////////////////////////////////////////////////// PrintfState Printf(const char* format) { return PrintfState(stdout, format); } PrintfState Printf(const std::string& format) { return PrintfState(stdout, format.c_str()); } PrintfState FPrintf(std::FILE* f, const char* format) { return PrintfState(f, format); } PrintfState FPrintf(std::FILE* f, const std::string& format) { return PrintfState(f, format.c_str()); } PrintfState FPrintf(std::ostream& f, const char* format) { return PrintfState(f, format); } PrintfState FPrintf(std::ostream& f, const std::string& format) { return PrintfState(f, format.c_str()); } PrintfState SPrintf(std::string& s, const char* format) { return PrintfState(s, format); } PrintfState SPrintf(std::string& s, const std::string& format) { return PrintfState(s, format.c_str()); } } // end namespace Loki libloki-0.1.7.orig/src/Library_MSVC_8.vcproj0000644000175000017500000001477411047143225017272 0ustar ivanivan libloki-0.1.7.orig/src/Singleton.cpp0000644000175000017500000000503710515233626016024 0ustar ivanivan//////////////////////////////////////////////////////////////////////////////// // 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. //////////////////////////////////////////////////////////////////////////////// // $Id: Singleton.cpp 756 2006-10-17 20:05:42Z syntheticpp $ #include #ifdef LOKI_ENABLE_NEW_SETLONGLIVITY_HELPER_DATA_IMPL Loki::Private::TrackerArray* Loki::Private::pTrackerArray = 0; #else Loki::Private::TrackerArray Loki::Private::pTrackerArray = 0; unsigned int Loki::Private::elements = 0; #endif //////////////////////////////////////////////////////////////////////////////// // function AtExitFn // Ensures proper destruction of objects with longevity //////////////////////////////////////////////////////////////////////////////// #ifdef LOKI_ENABLE_NEW_SETLONGLIVITY_HELPER_DATA_IMPL void LOKI_C_CALLING_CONVENTION_QUALIFIER Loki::Private::AtExitFn() { assert(pTrackerArray!=0 && !pTrackerArray->empty()); // Pick the element at the top of the stack LifetimeTracker* pTop = pTrackerArray->back(); // Remove that object off the stack _before_ deleting pTop pTrackerArray->pop_back(); // Destroy the element delete pTop; // Destroy stack when it's empty _after_ deleting pTop if(pTrackerArray->empty()) { delete pTrackerArray; pTrackerArray = 0; } } #else void LOKI_C_CALLING_CONVENTION_QUALIFIER Loki::Private::AtExitFn() { assert(elements > 0 && pTrackerArray != 0); // Pick the element at the top of the stack LifetimeTracker* pTop = pTrackerArray[elements - 1]; // Remove that object off the stack // Don't check errors - realloc with less memory // can't fail pTrackerArray = static_cast(std::realloc( pTrackerArray, sizeof(*pTrackerArray) * --elements)); // Destroy the element delete pTop; } #endif libloki-0.1.7.orig/src/SmartPtr.cpp0000644000175000017500000001766510515233626015650 0ustar ivanivan//////////////////////////////////////////////////////////////////////////////// // The Loki Library // Copyright (c) 2001 by Andrei Alexandrescu // Copyright (c) 2006 Richard Sposato // 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. //////////////////////////////////////////////////////////////////////////////// // $Id: SmartPtr.cpp 756 2006-10-17 20:05:42Z syntheticpp $ #include #include //#define DO_EXTRA_LOKI_TESTS #ifdef DO_EXTRA_LOKI_TESTS #include #endif // ---------------------------------------------------------------------------- namespace Loki { namespace Private { // ---------------------------------------------------------------------------- RefLinkedBase::RefLinkedBase(const RefLinkedBase& rhs) { prev_ = &rhs; next_ = rhs.next_; prev_->next_ = this; next_->prev_ = this; #ifdef DO_EXTRA_LOKI_TESTS assert( prev_->HasPrevNode( this ) ); assert( next_->HasNextNode( this ) ); assert( CountPrevCycle( this ) == CountNextCycle( this ) ); #endif } // ---------------------------------------------------------------------------- bool RefLinkedBase::Release() { #ifdef DO_EXTRA_LOKI_TESTS assert( prev_->HasPrevNode( this ) ); assert( next_->HasNextNode( this ) ); assert( CountPrevCycle( this ) == CountNextCycle( this ) ); #endif if ( NULL == next_ ) { assert( NULL == prev_ ); // Return false so it does not try to destroy shared object // more than once. return false; } else if (next_ == this) { assert(prev_ == this); // Set these to NULL to prevent re-entrancy. prev_ = NULL; next_ = NULL; return true; } #ifdef DO_EXTRA_LOKI_TESTS assert( this != prev_ ); assert( NULL != prev_ ); assert( prev_->HasPrevNode( this ) ); assert( next_->HasNextNode( this ) ); #endif prev_->next_ = next_; next_->prev_ = prev_; #ifdef DO_EXTRA_LOKI_TESTS next_ = this; prev_ = this; assert( 1 == CountNextCycle( this ) ); assert( 1 == CountPrevCycle( this ) ); #endif return false; } // ---------------------------------------------------------------------------- void RefLinkedBase::Swap(RefLinkedBase& rhs) { #ifdef DO_EXTRA_LOKI_TESTS assert( prev_->HasPrevNode( this ) ); assert( next_->HasNextNode( this ) ); assert( CountPrevCycle( this ) == CountNextCycle( this ) ); #endif if (next_ == this) { assert(prev_ == this); if (rhs.next_ == &rhs) { assert(rhs.prev_ == &rhs); // both lists are empty, nothing 2 do return; } prev_ = rhs.prev_; next_ = rhs.next_; prev_->next_ = next_->prev_ = this; rhs.next_ = rhs.prev_ = &rhs; return; } if (rhs.next_ == &rhs) { rhs.Swap(*this); return; } if (next_ == &rhs ) // rhs is next neighbour { if ( prev_ == &rhs ) return; // cycle of 2 pointers - no need to swap. std::swap(prev_, next_); std::swap(rhs.prev_, rhs.next_); std::swap(rhs.prev_, next_); std::swap(rhs.prev_->next_,next_->prev_); } else if ( prev_ == &rhs ) // rhs is prev neighbor { if ( next_ == &rhs ) return; // cycle of 2 pointers - no need to swap. std::swap( prev_, next_ ); std::swap( rhs.next_, rhs.prev_ ); std::swap( rhs.next_, prev_ ); std::swap( rhs.next_->prev_, prev_->next_ ); } else // not neighhbors { std::swap(prev_, rhs.prev_); std::swap(next_, rhs.next_); std::swap(prev_->next_, rhs.prev_->next_); std::swap(next_->prev_, rhs.next_->prev_); } #ifdef DO_EXTRA_LOKI_TESTS assert( next_ == this ? prev_ == this : prev_ != this); assert( prev_ == this ? next_ == this : next_ != this); assert( prev_->HasPrevNode( this ) ); assert( next_->HasNextNode( this ) ); assert( CountPrevCycle( this ) == CountNextCycle( this ) ); assert( rhs.prev_->HasPrevNode( &rhs ) ); assert( rhs.next_->HasNextNode( &rhs ) ); assert( CountPrevCycle( &rhs ) == CountNextCycle( &rhs ) ); #endif } // ---------------------------------------------------------------------------- unsigned int RefLinkedBase::CountPrevCycle( const RefLinkedBase * pThis ) { if ( NULL == pThis ) return 0; const RefLinkedBase * p = pThis->prev_; if ( NULL == p ) return 0; if ( pThis == p ) return 1; unsigned int count = 1; do { p = p->prev_; ++count; } while ( p != pThis ); return count; } // ---------------------------------------------------------------------------- unsigned int RefLinkedBase::CountNextCycle( const RefLinkedBase * pThis ) { if ( NULL == pThis ) return 0; const RefLinkedBase * p = pThis->next_; if ( NULL == p ) return 0; if ( pThis == p ) return 1; unsigned int count = 1; while ( p != pThis ) { p = p->next_; ++count; } return count; } // ---------------------------------------------------------------------------- bool RefLinkedBase::HasPrevNode( const RefLinkedBase * p ) const { if ( this == p ) return true; const RefLinkedBase * prev = prev_; if ( NULL == prev ) return false; while ( prev != this ) { if ( p == prev ) return true; prev = prev->prev_; } return false; } // ---------------------------------------------------------------------------- bool RefLinkedBase::HasNextNode( const RefLinkedBase * p ) const { if ( this == p ) return true; const RefLinkedBase * next = next_; if ( NULL == next ) return false; while ( next != this ) { if ( p == next ) return true; next = next->next_; } return false; } // ---------------------------------------------------------------------------- bool RefLinkedBase::Merge( RefLinkedBase & rhs ) { if ( NULL == next_ ) { assert( NULL == prev_ ); return false; } RefLinkedBase * prhs = &rhs; if ( prhs == this ) return true; if ( NULL == prhs->next_ ) { assert( NULL == prhs->prev_ ); return true; } assert( CountPrevCycle( this ) == CountNextCycle( this ) ); assert( CountPrevCycle( prhs ) == CountNextCycle( prhs ) ); // If rhs node is already in this cycle, then no need to merge. if ( HasPrevNode( &rhs ) ) { assert( HasNextNode( &rhs ) ); return true; } if ( prhs == prhs->next_ ) { /// rhs is in a cycle with 1 node. assert( prhs->prev_ == prhs ); prhs->prev_ = prev_; prhs->next_ = this; prev_->next_ = prhs; prev_ = prhs; } else if ( this == next_ ) { /// this is in a cycle with 1 node. assert( prev_ == this ); prev_ = prhs->prev_; next_ = prhs; prhs->prev_->next_ = this; prhs->prev_ = this; } else { next_->prev_ = prhs->prev_; prhs->prev_->next_ = prev_; next_ = prhs; prhs->prev_ = this; } assert( CountPrevCycle( this ) == CountNextCycle( this ) ); return true; } // ---------------------------------------------------------------------------- } // end namespace Private } // end namespace Loki libloki-0.1.7.orig/src/Library_MSVC9.vcproj0000644000175000017500000002000211140364657017121 0ustar ivanivan libloki-0.1.7.orig/src/LevelMutex.cpp0000644000175000017500000010336411137412714016154 0ustar ivanivan//////////////////////////////////////////////////////////////////////////////// // // LevelMutex facility for the Loki Library // Copyright (c) 2008 Richard Sposato // The copyright on this file is protected under the terms of the MIT license. // // 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 makes no representations about the suitability of this software // for any purpose. It is provided "as is" without express or implied warranty. // //////////////////////////////////////////////////////////////////////////////// // $Id$ /// @file LevelMutex.cpp Contains functions needed by LevelMutex class. // ---------------------------------------------------------------------------- #if (!defined(__CYGWIN__) || (defined(__CYGWIN__) && __GNUC__ > 3)) && !defined(__APPLE__) #include #include #include using namespace ::std; // define nullptr even though new compilers will have this keyword just so we // have a consistent and easy way of identifying which uses of 0 mean null. #define nullptr 0 LOKI_THREAD_LOCAL volatile ::Loki::LevelMutexInfo * ::Loki::LevelMutexInfo::s_currentMutex = nullptr; unsigned int ::Loki::MutexSleepWaits::sleepTime = 1; /// Anonymous namespace hides some functions which are implementation details. namespace { // ---------------------------------------------------------------------------- /** Determines if the mutex at specific iterator location is unique within the container of mutexes. It only checks mutexes at later locations in the container instead of the entire container partly for efficiency sake. (Any prior duplications would have gotten caught during earlier calls to this function.) This should not throw exceptions. It requires O(m) operations where m is the number of elements in the container after the iterator. @param mutexes Container to check. @param cit Location of mutex used for comparing. @return True for uniqueness, false if a duplicate exists. */ bool IsUniqueMutex( const ::Loki::LevelMutexInfo::MutexContainer & mutexes, ::Loki::LevelMutexInfo::LevelMutexContainerCIter cit ) { assert( mutexes.end() != cit ); const ::Loki::LevelMutexInfo::LevelMutexContainerCIter end = mutexes.end(); const volatile ::Loki::LevelMutexInfo * mutex = *cit; for ( ++cit; cit != end; ++cit ) { const volatile ::Loki::LevelMutexInfo * check = *cit; if ( check == mutex ) return false; } return true; } // ---------------------------------------------------------------------------- /** Returns pointer to first mutex it finds in the container. This should not throw, and takes O(1) most of the time. At worse, it takes O(m) operations where m is the size of the container. @param mutexes Container of mutexes. @return Pointer to first mutex it finds, or nullptr if container is empty or each element is a nullptr. */ const volatile ::Loki::LevelMutexInfo * GetFirstMutex( const ::Loki::LevelMutexInfo::MutexContainer & mutexes ) { if ( mutexes.size() == 0 ) return nullptr; ::Loki::LevelMutexInfo::LevelMutexContainerCIter it( mutexes.begin() ); const volatile ::Loki::LevelMutexInfo * mutex = *it; if ( nullptr != mutex ) return mutex; const ::Loki::LevelMutexInfo::LevelMutexContainerCIter end( mutexes.end() ); while ( it != end ) { mutex = *it; if ( nullptr != mutex ) return mutex; ++it; } return nullptr; } // ---------------------------------------------------------------------------- /** Gets the level number associated with the first mutex found in a container. Usually takes O(1) operations, but take up to O(m) where m is the size of the container. @return Level number of first mutex in container, or UnlockedLevel if no mutexes were found in the container. */ unsigned int GetLevel( const ::Loki::LevelMutexInfo::MutexContainer & mutexes ) { const volatile ::Loki::LevelMutexInfo * mutex = GetFirstMutex( mutexes ); return ( nullptr == mutex ) ? ::Loki::LevelMutexInfo::UnlockedLevel : mutex->GetLevel(); } // ---------------------------------------------------------------------------- } // end anonymous namespace namespace Loki { // ---------------------------------------------------------------------------- unsigned int GetCurrentThreadsLevel( void ) { const volatile LevelMutexInfo * mutex = LevelMutexInfo::GetCurrentMutex(); return ( nullptr == mutex ) ? LevelMutexInfo::UnlockedLevel : mutex->GetLevel(); } // ---------------------------------------------------------------------------- unsigned int CountMutexesInCurrentThread( void ) { const volatile LevelMutexInfo * mutex = LevelMutexInfo::GetCurrentMutex(); unsigned int count = 0; while ( nullptr != mutex ) { count++; mutex = mutex->GetPrevious(); } return count; } // ---------------------------------------------------------------------------- unsigned int CountLocksInCurrentThread( void ) { const volatile LevelMutexInfo * mutex = LevelMutexInfo::GetCurrentMutex(); unsigned int count = 0; while ( nullptr != mutex ) { count += mutex->GetLockCount(); mutex = mutex->GetPrevious(); } return count; } // ---------------------------------------------------------------------------- unsigned int CountMutexesAtCurrentLevel( void ) { const volatile LevelMutexInfo * mutex = LevelMutexInfo::GetCurrentMutex(); if ( nullptr == mutex ) return 0; unsigned int count = 0; unsigned int level = mutex->GetLevel(); while ( nullptr != mutex ) { if ( level != mutex->GetLevel() ) break; mutex = mutex->GetPrevious(); count++; } return count; } // ---------------------------------------------------------------------------- MutexErrors::Type DoMutexesMatchContainer( const LevelMutexInfo::MutexContainer & mutexes ) { const unsigned int count = mutexes.size(); if ( 0 == count ) return MutexErrors::EmptyContainer; unsigned int currentLevel = GetCurrentThreadsLevel(); const LevelMutexInfo::LevelMutexContainerCIter endSpot = mutexes.end(); for ( LevelMutexInfo::LevelMutexContainerCIter cit = mutexes.begin(); cit != endSpot; ++cit ) { const volatile LevelMutexInfo * mutex = *cit; if ( nullptr == mutex ) return MutexErrors::NullMutexPointer; if ( currentLevel != mutex->GetLevel() ) { return ( LevelMutexInfo::UnlockedLevel == currentLevel ) ? MutexErrors::NotRecentLock : MutexErrors::WrongLevel; } if ( !mutex->IsRecentLock( count ) ) return MutexErrors::NotRecentLock; if ( !IsUniqueMutex( mutexes, cit ) ) return MutexErrors::DuplicateMutex; } if ( count != CountMutexesAtCurrentLevel() ) return MutexErrors::LevelTooHigh; return MutexErrors::Success; } // ---------------------------------------------------------------------------- LevelMutexInfo::MutexUndoer::MutexUndoer( MutexContainer & mutexes ) : m_mutexes( mutexes ), m_here( mutexes.end() ) { assert( this != nullptr ); } // ---------------------------------------------------------------------------- LevelMutexInfo::MutexUndoer::~MutexUndoer( void ) { assert( this != nullptr ); try { if ( m_here == m_mutexes.end() ) return; LevelMutexContainerRIter rend( m_mutexes.rend() ); LevelMutexContainerRIter rit( m_here ); --rit; for ( ; rit != rend; ++rit ) { volatile ::Loki::LevelMutexInfo * mutex = *rit; assert( nullptr != mutex ); mutex->UnlockThis(); } } catch ( ... ) { } } // ---------------------------------------------------------------------------- void LevelMutexInfo::MutexUndoer::SetPlace( LevelMutexContainerIter & here ) { assert( this != nullptr ); m_here = here; } // ---------------------------------------------------------------------------- void LevelMutexInfo::MutexUndoer::Cancel( void ) { assert( this != nullptr ); m_here = m_mutexes.end(); } // ---------------------------------------------------------------------------- const volatile LevelMutexInfo * LevelMutexInfo::GetCurrentMutex( void ) { assert( IsValidList() ); return s_currentMutex; } // ---------------------------------------------------------------------------- bool LevelMutexInfo::IsValidList( void ) { const volatile LevelMutexInfo * mutex1 = s_currentMutex; const volatile LevelMutexInfo * mutex2 = s_currentMutex; if ( nullptr == mutex1 ) return true; while ( nullptr != mutex2 ) { if ( nullptr == mutex2 ) break; mutex2 = mutex2->m_previous; if ( mutex1 == mutex2 ) return false; if ( nullptr == mutex2 ) break; mutex2 = mutex2->m_previous; if ( mutex1 == mutex2 ) return false; if ( nullptr == mutex2 ) break; mutex1 = mutex1->m_previous; if ( nullptr == mutex1 ) break; } mutex1 = s_currentMutex; unsigned int level = mutex1->m_level; while ( nullptr != mutex1 ) { if ( level > mutex1->m_level ) return false; level = mutex1->m_level; mutex1 = mutex1->m_previous; } return true; } // ---------------------------------------------------------------------------- MutexErrors::Type LevelMutexInfo::MultiLock( MutexContainer & mutexes ) { assert( IsValidList() ); const unsigned int count = mutexes.size(); if ( count == 0 ) return MutexErrors::EmptyContainer; LevelMutexContainerIter it( mutexes.begin() ); volatile LevelMutexInfo * mutex = *it; if ( nullptr == mutex ) return MutexErrors::NullMutexPointer; // Since the pointer to the first mutex is not NULL, save it so we use it // to call the derived class and check for errors. const volatile LevelMutexInfo * const first = mutex; if ( !IsUniqueMutex( mutexes, it ) ) return MutexErrors::DuplicateMutex; const unsigned int checkLevel = mutex->GetLevel(); const unsigned int currentLevel = GetCurrentThreadsLevel(); if ( currentLevel < checkLevel ) { return first->DoErrorCheck( MutexErrors::LevelTooHigh ); } const LevelMutexContainerIter end( mutexes.end() ); if ( currentLevel == checkLevel ) { MutexErrors::Type result = DoMutexesMatchContainer( mutexes ); if ( MutexErrors::Success != result ) { if ( LevelMutexInfo::UnlockedLevel == currentLevel ) { return first->DoErrorCheck( result ); } return first->DoErrorCheck( MutexErrors::LevelTooHigh ); } for ( it = mutexes.begin(); it != end; ++it ) { mutex = *it; mutex->IncrementCount(); } return MutexErrors::Success; } assert( !mutex->IsRecentLock( count ) ); if ( 1 < count ) { for ( ++it; it != end; ++it ) { mutex = *it; if ( nullptr == mutex ) return first->DoErrorCheck( MutexErrors::NullMutexPointer ); const unsigned int level = mutex->GetLevel(); if ( checkLevel != level ) return first->DoErrorCheck( MutexErrors::WrongLevel ); if ( !IsUniqueMutex( mutexes, it ) ) return first->DoErrorCheck( MutexErrors::DuplicateMutex ); assert( !mutex->IsRecentLock( count ) ); } it = mutexes.begin(); ::std::sort( it, end ); } MutexUndoer undoer( mutexes ); for ( ; it != end; ++it ) { mutex = *it; const MutexErrors::Type result = mutex->LockThis(); if ( MutexErrors::Success != result ) return first->DoErrorCheck( result ); undoer.SetPlace( it ); } undoer.Cancel(); return MutexErrors::Success; } // ---------------------------------------------------------------------------- MutexErrors::Type LevelMutexInfo::MultiLock( MutexContainer & mutexes, unsigned int milliSeconds ) { assert( IsValidList() ); if ( 0 == milliSeconds ) return MultiLock( mutexes ); const unsigned int count = mutexes.size(); if ( 0 == count ) return MutexErrors::EmptyContainer; LevelMutexContainerIter it( mutexes.begin() ); volatile LevelMutexInfo * mutex = *it; if ( nullptr == mutex ) return MutexErrors::NullMutexPointer; // Since the pointer to the first mutex is not NULL, save it so we use it // to call the derived class and check for errors. const volatile LevelMutexInfo * const first = mutex; if ( !IsUniqueMutex( mutexes, it ) ) return first->DoErrorCheck( MutexErrors::DuplicateMutex ); const unsigned int checkLevel = mutex->GetLevel(); const unsigned int currentLevel = GetCurrentThreadsLevel(); if ( currentLevel < checkLevel ) { return first->DoErrorCheck( MutexErrors::LevelTooHigh ); } const LevelMutexContainerIter end( mutexes.end() ); if ( currentLevel == checkLevel ) { MutexErrors::Type result = DoMutexesMatchContainer( mutexes ); if ( MutexErrors::Success != result ) { if ( LevelMutexInfo::UnlockedLevel == currentLevel ) { return first->DoErrorCheck( result ); } return first->DoErrorCheck( MutexErrors::LevelTooHigh ); } for ( it = mutexes.begin(); it != end; ++it ) { mutex = *it; mutex->IncrementCount(); } return MutexErrors::Success; } assert( !mutex->IsRecentLock( count ) ); if ( 1 < count ) { for ( ++it; it != end; ++it ) { mutex = *it; if ( nullptr == mutex ) return first->DoErrorCheck( MutexErrors::NullMutexPointer ); const unsigned int level = mutex->GetLevel(); if ( checkLevel != level ) return first->DoErrorCheck( MutexErrors::WrongLevel ); if ( !IsUniqueMutex( mutexes, it ) ) return first->DoErrorCheck( MutexErrors::DuplicateMutex ); assert( !mutex->IsRecentLock( count ) ); } it = mutexes.begin(); ::std::sort( it, end ); } MutexUndoer undoer( mutexes ); for ( ; it != end; ++it ) { mutex = *it; const MutexErrors::Type result = mutex->LockThis( milliSeconds ); if ( MutexErrors::Success != result ) return first->DoErrorCheck( result ); undoer.SetPlace( it ); } undoer.Cancel(); return MutexErrors::Success; } // ---------------------------------------------------------------------------- MutexErrors::Type LevelMutexInfo::MultiUnlock( MutexContainer & mutexes ) { assert( IsValidList() ); MutexErrors::Type result = DoMutexesMatchContainer( mutexes ); if ( result != MutexErrors::Success ) { const volatile LevelMutexInfo * const mutex = GetFirstMutex( mutexes ); if ( nullptr != mutex ) return mutex->DoErrorCheck( result ); throw MutexException( "Unable to unlock mutexes in container.", LevelMutexInfo::UnlockedLevel, result ); } const unsigned int count = mutexes.size(); if ( 1 < count ) { ::std::sort( mutexes.begin(), mutexes.end() ); } bool failed = false; LevelMutexContainerRIter rit( mutexes.rbegin() ); const LevelMutexContainerRIter rend( mutexes.rend() ); for ( ; rit != rend; ++rit ) { try { volatile LevelMutexInfo * mutex = *rit; result = mutex->UnlockThis(); if ( MutexErrors::Success != result ) failed = true; } catch ( ... ) { failed = true; // If one fails to unlock, keep trying to unlock the others. // So don't just exit the for loop. This keeps going instead // of trying to relock the mutex and exit since it is not // safe to leave some locked, but not others. } } return ( failed ) ? MutexErrors::MultiUnlockFailed : MutexErrors::Success; } // ---------------------------------------------------------------------------- LevelMutexInfo::LevelMutexInfo( unsigned int level ) : m_level( level ), m_count( 0 ), m_previous( nullptr ) { assert( IsValid() ); } // ---------------------------------------------------------------------------- LevelMutexInfo::~LevelMutexInfo( void ) { assert( IsValid() ); assert( 0 == m_count ); assert( nullptr == m_previous ); } // ---------------------------------------------------------------------------- bool LevelMutexInfo::IsValid( void ) const volatile { assert( nullptr != this ); assert( LevelMutexInfo::UnlockedLevel != m_level ); assert( m_previous != this ); assert( ( nullptr == m_previous ) || ( 0 < m_count ) ); assert( IsValidList() ); return true; } // ---------------------------------------------------------------------------- void LevelMutexInfo::IncrementCount( void ) volatile { assert( IsValid() ); assert( 0 < m_count ); ++m_count; } // ---------------------------------------------------------------------------- void LevelMutexInfo::DecrementCount( void ) volatile { assert( IsValid() ); assert( 0 < m_count ); --m_count; } // ---------------------------------------------------------------------------- bool LevelMutexInfo::IsLockedByCurrentThread( void ) const volatile { assert( IsValid() ); LOKI_MUTEX_DEBUG_CODE( Checker checker( this ); (void)checker; ) if ( !IsLocked() ) return false; const volatile LevelMutexInfo * mutex = s_currentMutex; while ( nullptr != mutex ) { if ( this == mutex ) return true; mutex = mutex->m_previous; } return false; } // ---------------------------------------------------------------------------- bool LevelMutexInfo::IsRecentLock( void ) const volatile { assert( IsValid() ); LOKI_MUTEX_DEBUG_CODE( Checker checker( this ); (void)checker; ) if ( 0 == m_count ) return false; const volatile LevelMutexInfo * mutex = s_currentMutex; while ( nullptr != mutex ) { assert( m_level <= mutex->m_level ); if ( this == mutex ) return true; if ( m_level != mutex->m_level ) return false; mutex = mutex->m_previous; } return false; } // ---------------------------------------------------------------------------- bool LevelMutexInfo::IsRecentLock( unsigned int count ) const volatile { assert( IsValid() ); LOKI_MUTEX_DEBUG_CODE( Checker checker( this ); (void)checker; ) if ( 0 == count ) return false; const volatile LevelMutexInfo * mutex = s_currentMutex; for ( ; count > 0; count-- ) { if ( nullptr == mutex ) return false; if ( this == mutex ) return true; mutex = mutex->m_previous; } return false; } // ---------------------------------------------------------------------------- bool LevelMutexInfo::IsLockedByAnotherThread( void ) const volatile { assert( IsValid() ); LOKI_MUTEX_DEBUG_CODE( Checker checker( this ); (void)checker; ) if ( !IsLocked() ) return false; if ( IsLockedByCurrentThread() ) return false; if ( !IsLocked() ) return false; return true; } // ---------------------------------------------------------------------------- void LevelMutexInfo::PostLock( void ) volatile { assert( IsValid() ); assert( 0 == m_count ); assert( nullptr == m_previous ); assert( this != s_currentMutex ); assert( !IsLockedByCurrentThread() ); LOKI_MUTEX_DEBUG_CODE( Checker checker( this ); (void)checker; ) m_count = 1; m_previous = s_currentMutex; s_currentMutex = this; } // ---------------------------------------------------------------------------- void LevelMutexInfo::PreUnlock( void ) volatile { assert( IsValid() ); assert( 1 == m_count ); assert( nullptr != s_currentMutex ); assert( this == s_currentMutex ); assert( IsLockedByCurrentThread() ); LOKI_MUTEX_DEBUG_CODE( Checker checker( this ); (void)checker; ) s_currentMutex = m_previous; m_previous = nullptr; m_count = 0; } // ---------------------------------------------------------------------------- MutexErrors::Type LevelMutexInfo::PreLockCheck( bool forTryLock ) volatile { assert( IsValid() ); LOKI_MUTEX_DEBUG_CODE( Checker checker( this ); (void)checker; ) const unsigned int currentLevel = GetCurrentThreadsLevel(); if ( currentLevel < LevelMutexInfo::GetLevel() ) return MutexErrors::LevelTooHigh; const bool lockedByThisThread = IsLockedByCurrentThread(); if ( !lockedByThisThread && forTryLock && IsLocked() ) return MutexErrors::AlreadyLocked; if ( currentLevel == LevelMutexInfo::GetLevel() ) { // If this mutex has the same level as the current level, // and was locked by the current thread, then assume it // was locked with the MultiLock function. Which means it // is safe to relock this. If this checked if it equals // s_currentMutex that would defeat re-entrancy for all // multi-locked mutexes. if ( lockedByThisThread ) { m_count++; return MutexErrors::Success; } else { return MutexErrors::LevelTooHigh; } } return MutexErrors::NoProblem; } // ---------------------------------------------------------------------------- MutexErrors::Type LevelMutexInfo::PreUnlockCheck( void ) volatile { assert( IsValid() ); LOKI_MUTEX_DEBUG_CODE( Checker checker( this ); (void)checker; ) if ( 0 == m_count ) return MutexErrors::WasntLocked; const unsigned int currentLevel = GetCurrentThreadsLevel(); if ( currentLevel > m_level ) return MutexErrors::LevelTooLow; if ( currentLevel < m_level ) return MutexErrors::LevelTooHigh; const bool lockedByThisThread = IsLockedByCurrentThread(); if ( !lockedByThisThread ) return MutexErrors::NotLockedByThread; if ( 1 < m_count ) { m_count--; return MutexErrors::Success; } return MutexErrors::NoProblem; } // ---------------------------------------------------------------------------- MutexErrors::Type ThrowOnAnyMutexError::CheckError( MutexErrors::Type error, unsigned int level ) { if ( ( error != MutexErrors::Success ) && ( error != MutexErrors::NoProblem ) ) { throw MutexException( "Error occurred using mutex.", level, error ); } return error; } // ---------------------------------------------------------------------------- MutexErrors::Type ThrowOnBadDesignMutexError::CheckError( MutexErrors::Type error, unsigned int level ) { if ( ( error == MutexErrors::LevelTooHigh ) && ( error == MutexErrors::LevelTooLow ) ) { throw MutexException( "Error occurred using mutex.", level, error ); } return error; } // ---------------------------------------------------------------------------- void MutexSleepWaits::Wait( void ) { #if defined( _MSC_VER ) ::SleepEx( sleepTime, true ); #else ::sleep( sleepTime ); #endif } // ---------------------------------------------------------------------------- SpinLevelMutex::SpinLevelMutex( unsigned int level ) : m_mutex(), m_level( level ) { #if defined( _MSC_VER ) ::InitializeCriticalSection( &m_mutex ); #else const int result = ::pthread_mutex_init( &m_mutex, 0 ); switch ( result ) { case 0: return; case EBUSY: throw MutexException( "pthread mutex already initialized!", level, MutexErrors::AlreadyInitialized ); default: case EINVAL: throw MutexException( "pthread mutex has an invalid attribute!", level, MutexErrors::InvalidAttribute ); case EFAULT: throw MutexException( "pthread mutex has an invalid address!", level, MutexErrors::InvalidAddress ); } #endif } // ---------------------------------------------------------------------------- SpinLevelMutex::~SpinLevelMutex( void ) { try { #if defined( _MSC_VER ) ::DeleteCriticalSection( &m_mutex ); #else ::pthread_mutex_destroy( &m_mutex ); #endif } catch ( ... ) { // Not much we can do after catching an exception inside a destructor! } } // ---------------------------------------------------------------------------- MutexErrors::Type SpinLevelMutex::Lock( void ) volatile { // Have to cast away volatile since Windows CriticalSection class does not // use volatile qualifier. SpinLevelMutex * pThis = const_cast< SpinLevelMutex * >( this ); #if defined( _MSC_VER ) ::EnterCriticalSection( &pThis->m_mutex ); #else const int result = ::pthread_mutex_lock( &pThis->m_mutex ); switch ( result ) { case 0: break; default: case EINVAL: throw MutexException( "pthread mutex not initialized properly!", GetLevel(), MutexErrors::NotInitialized ); case EFAULT : throw MutexException( "pthread mutex is not valid!", GetLevel(), MutexErrors::InvalidAddress ); case EDEADLK: throw MutexException( "locking this pthread mutex may cause a deadlock!", GetLevel(), MutexErrors::MayDeadlock ); } #endif return MutexErrors::Success; } // ---------------------------------------------------------------------------- MutexErrors::Type SpinLevelMutex::TryLock( void ) volatile { // Have to cast away volatile since Windows CriticalSection class does not // use volatile qualifier. SpinLevelMutex * pThis = const_cast< SpinLevelMutex * >( this ); #if defined( _MSC_VER ) const bool locked = ( 0 != ::TryEnterCriticalSection( &pThis->m_mutex ) ); return ( locked ) ? MutexErrors::Success : MutexErrors::TryFailed; #else const int result = ::pthread_mutex_trylock( &pThis->m_mutex ); switch ( result ) { case 0: return MutexErrors::Success; default: case EBUSY: break; case EAGAIN: throw MutexException( "pthread mutex reached recursion limit!", GetLevel(), MutexErrors::TooMuchRecursion ); } return MutexErrors::TryFailed; #endif } // ---------------------------------------------------------------------------- MutexErrors::Type SpinLevelMutex::Unlock( void ) volatile { // Have to cast away volatile since Windows CriticalSection class does not // use volatile qualifier. SpinLevelMutex * pThis = const_cast< SpinLevelMutex * >( this ); #if defined( _MSC_VER ) ::LeaveCriticalSection( &pThis->m_mutex ); #else const int result = ::pthread_mutex_unlock( &pThis->m_mutex ); if ( EPERM == result ) throw MutexException( "current thread did not lock this pthread mutex!", GetLevel(), MutexErrors::NotLockedByThread ); #endif return MutexErrors::Success; } // ---------------------------------------------------------------------------- #if defined( _MSC_VER ) SleepLevelMutex::SleepLevelMutex( unsigned int level ) : SpinLevelMutex( level ), m_sleepTime( 1 ), m_wakable( true ) { } // ---------------------------------------------------------------------------- #else SleepLevelMutex::SleepLevelMutex( unsigned int level, unsigned int sleepTime ) : SpinLevelMutex( level ), m_sleepTime( sleepTime / 1000 ) { if ( 0 == m_sleepTime ) m_sleepTime = 1; // Can't have a resolution less than 1 second. } #endif // ---------------------------------------------------------------------------- SleepLevelMutex::~SleepLevelMutex( void ) { } // ---------------------------------------------------------------------------- MutexErrors::Type SleepLevelMutex::Lock( void ) volatile { bool locked = false; while ( !locked ) { locked = ( MutexErrors::Success == TryLock() ); if ( locked ) break; #if defined( _MSC_VER ) ::SleepEx( m_sleepTime, m_wakable ); #else ::sleep( m_sleepTime ); #endif } return MutexErrors::Success; } // ---------------------------------------------------------------------------- MutexException::MutexException( const char * message, unsigned int level, MutexErrors::Type reason ) : m_message( message ), m_level( level ), m_reason( reason ) { } // ---------------------------------------------------------------------------- MutexException::MutexException( const MutexException & that ) throw () : ::std::exception( that ), m_message( that.m_message ), m_level( that.m_level ), m_reason( that.m_reason ) { } // ---------------------------------------------------------------------------- MutexException & MutexException::operator = ( const MutexException & that ) throw () { m_message = that.m_message; m_level = that.m_level; m_reason = that.m_reason; return *this; } // ---------------------------------------------------------------------------- MutexException::~MutexException( void ) throw () { } // ---------------------------------------------------------------------------- const char * MutexException::what( void ) const throw () { return m_message; } // ---------------------------------------------------------------------------- MutexLocker::MutexLocker( volatile LevelMutexInfo & mutex, bool lock ) : m_locked( false ), m_mutex( mutex ) { assert( nullptr != this ); if ( !lock ) return; const MutexErrors::Type result = mutex.Lock(); m_locked = ( MutexErrors::Success == result ); if ( !m_locked ) throw MutexException( "Unable to lock mutex.", mutex.GetLevel(), result ); } // ---------------------------------------------------------------------------- MutexLocker::MutexLocker( volatile LevelMutexInfo & mutex, unsigned int milliSeconds, bool lock ) : m_locked( false ), m_mutex( mutex ) { assert( nullptr != this ); if ( !lock ) return; const MutexErrors::Type result = mutex.Lock( milliSeconds ); m_locked = ( MutexErrors::Success == result ); if ( !m_locked ) throw MutexException( "Unable to lock mutex.", mutex.GetLevel(), result ); } // ---------------------------------------------------------------------------- MutexLocker::~MutexLocker( void ) { assert( nullptr != this ); if ( !m_locked ) return; try { m_mutex.Unlock(); } catch ( ... ) { // Not much we can do when catching an exception inside a destructor. } } // ---------------------------------------------------------------------------- bool MutexLocker::Lock( void ) { assert( nullptr != this ); if ( m_locked ) return true; const MutexErrors::Type result = m_mutex.Lock(); if ( MutexErrors::Success != result ) return false; m_locked = true; return true; } // ---------------------------------------------------------------------------- bool MutexLocker::Unlock( void ) { assert( nullptr != this ); if ( !m_locked ) return true; const MutexErrors::Type result = m_mutex.Unlock(); if ( MutexErrors::Success != result ) return false; m_locked = false; return true; } // ---------------------------------------------------------------------------- MultiMutexLocker::MultiMutexLocker( LevelMutexInfo::MutexContainer & mutexes, bool lock ) : m_locked( false ), m_mutexes( mutexes ) { assert( nullptr != this ); if ( !lock ) return; const MutexErrors::Type result = LevelMutexInfo::MultiLock( mutexes ); m_locked = ( MutexErrors::Success == result ); if ( !m_locked ) throw MutexException( "Unable to lock multiple mutexes.", GetLevel( mutexes ), result ); } // ---------------------------------------------------------------------------- MultiMutexLocker::MultiMutexLocker( LevelMutexInfo::MutexContainer & mutexes, unsigned int milliSeconds, bool lock ) : m_locked( false ), m_mutexes( mutexes ) { assert( nullptr != this ); if ( !lock ) return; const MutexErrors::Type result = LevelMutexInfo::MultiLock( mutexes, milliSeconds ); m_locked = ( MutexErrors::Success == result ); if ( !m_locked ) throw MutexException( "Unable to lock multiple mutexes.", GetLevel( mutexes ), result ); } // ---------------------------------------------------------------------------- MultiMutexLocker::~MultiMutexLocker( void ) { assert( nullptr != this ); if ( !m_locked ) return; try { LevelMutexInfo::MultiUnlock( m_mutexes ); } catch ( ... ) { // Not much we can do when catching an exception inside a destructor. } } // ---------------------------------------------------------------------------- bool MultiMutexLocker::Lock( void ) { assert( nullptr != this ); if ( m_locked ) return true; const MutexErrors::Type result = LevelMutexInfo::MultiLock( m_mutexes ); if ( MutexErrors::Success != result ) return false; m_locked = true; return true; } // ---------------------------------------------------------------------------- bool MultiMutexLocker::Unlock( void ) { assert( nullptr != this ); if ( !m_locked ) return true; const MutexErrors::Type result = LevelMutexInfo::MultiUnlock( m_mutexes ); if ( MutexErrors::Success != result ) return false; m_locked = false; return true; } // ---------------------------------------------------------------------------- } // end namespace Loki #endif libloki-0.1.7.orig/src/SmallObj.cpp0000644000175000017500000012077310620052610015557 0ustar ivanivan//////////////////////////////////////////////////////////////////////////////// // 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. //////////////////////////////////////////////////////////////////////////////// // $Id: SmallObj.cpp 823 2007-05-08 10:48:40Z lfittl $ #include #include #include #include #include //#define DO_EXTRA_LOKI_TESTS //#define USE_NEW_TO_ALLOCATE //#define LOKI_CHECK_FOR_CORRUPTION #ifdef DO_EXTRA_LOKI_TESTS #include #endif namespace Loki { /** @struct Chunk @ingroup SmallObjectGroupInternal Contains info about each allocated Chunk - which is a collection of contiguous blocks. Each block is the same size, as specified by the FixedAllocator. The number of blocks in a Chunk depends upon page size. This is a POD-style struct with value-semantics. All functions and data are private so that they can not be changed by anything other than the FixedAllocator which owns the Chunk. @par Minimal Interface For the sake of runtime efficiency, no constructor, destructor, or copy-assignment operator is defined. The inline functions made by the compiler should be sufficient, and perhaps faster than hand-crafted functions. The lack of these functions allows vector to create and copy Chunks as needed without overhead. The Init and Release functions do what the default constructor and destructor would do. A Chunk is not in a usable state after it is constructed and before calling Init. Nor is a Chunk usable after Release is called, but before the destructor. @par Efficiency Down near the lowest level of the allocator, runtime efficiencies trump almost all other considerations. Each function does the minimum required of it. All functions should execute in constant time to prevent higher- level code from unwittingly using a version of Shlemiel the Painter's Algorithm. @par Stealth Indexes The first char of each empty block contains the index of the next empty block. These stealth indexes form a singly-linked list within the blocks. A Chunk is corrupt if this singly-linked list has a loop or is shorter than blocksAvailable_. Much of the allocator's time and space efficiency comes from how these stealth indexes are implemented. */ class Chunk { private: friend class FixedAllocator; /** Initializes a just-constructed Chunk. @param blockSize Number of bytes per block. @param blocks Number of blocks per Chunk. @return True for success, false for failure. */ bool Init( std::size_t blockSize, unsigned char blocks ); /** Allocate a block within the Chunk. Complexity is always O(1), and this will never throw. Does not actually "allocate" by calling malloc, new, or any other function, but merely adjusts some internal indexes to indicate an already allocated block is no longer available. @return Pointer to block within Chunk. */ void * Allocate( std::size_t blockSize ); /** Deallocate a block within the Chunk. Complexity is always O(1), and this will never throw. For efficiency, this assumes the address is within the block and aligned along the correct byte boundary. An assertion checks the alignment, and a call to HasBlock is done from within VicinityFind. Does not actually "deallocate" by calling free, delete, or other function, but merely adjusts some internal indexes to indicate a block is now available. */ void Deallocate( void * p, std::size_t blockSize ); /** Resets the Chunk back to pristine values. The available count is set back to zero, and the first available index is set to the zeroth block. The stealth indexes inside each block are set to point to the next block. This assumes the Chunk's data was already using Init. */ void Reset( std::size_t blockSize, unsigned char blocks ); /// Releases the allocated block of memory. void Release(); /** Determines if the Chunk has been corrupted. @param numBlocks Total # of blocks in the Chunk. @param blockSize # of bytes in each block. @param checkIndexes True if caller wants to check indexes of available blocks for corruption. If false, then caller wants to skip some tests tests just to run faster. (Debug version does more checks, but release version runs faster.) @return True if Chunk is corrupt. */ bool IsCorrupt( unsigned char numBlocks, std::size_t blockSize, bool checkIndexes ) const; /** Determines if block is available. @param p Address of block managed by Chunk. @param numBlocks Total # of blocks in the Chunk. @param blockSize # of bytes in each block. @return True if block is available, else false if allocated. */ bool IsBlockAvailable( void * p, unsigned char numBlocks, std::size_t blockSize ) const; /// Returns true if block at address P is inside this Chunk. inline bool HasBlock( void * p, std::size_t chunkLength ) const { unsigned char * pc = static_cast< unsigned char * >( p ); return ( pData_ <= pc ) && ( pc < pData_ + chunkLength ); } inline bool HasAvailable( unsigned char numBlocks ) const { return ( blocksAvailable_ == numBlocks ); } inline bool IsFilled( void ) const { return ( 0 == blocksAvailable_ ); } /// Pointer to array of allocated blocks. unsigned char * pData_; /// Index of first empty block. unsigned char firstAvailableBlock_; /// Count of empty blocks. unsigned char blocksAvailable_; }; /** @class FixedAllocator @ingroup SmallObjectGroupInternal Offers services for allocating fixed-sized objects. It has a container of "containers" of fixed-size blocks. The outer container has all the Chunks. The inner container is a Chunk which owns some blocks. @par Class Level Invariants - There is always either zero or one Chunk which is empty. - If this has no empty Chunk, then emptyChunk_ is NULL. - If this has an empty Chunk, then emptyChunk_ points to it. - If the Chunk container is empty, then deallocChunk_ and allocChunk_ are NULL. - If the Chunk container is not-empty, then deallocChunk_ and allocChunk_ are either NULL or point to Chunks within the container. - allocChunk_ will often point to the last Chunk in the container since it was likely allocated most recently, and therefore likely to have an available block. */ class FixedAllocator { private: /** Deallocates the block at address p, and then handles the internal bookkeeping needed to maintain class invariants. This assumes that deallocChunk_ points to the correct chunk. */ void DoDeallocate( void * p ); /** Creates an empty Chunk and adds it to the end of the ChunkList. All calls to the lower-level memory allocation functions occur inside this function, and so the only try-catch block is inside here. @return true for success, false for failure. */ bool MakeNewChunk( void ); /** Finds the Chunk which owns the block at address p. It starts at deallocChunk_ and searches in both forwards and backwards directions from there until it finds the Chunk which owns p. This algorithm should find the Chunk quickly if it is deallocChunk_ or is close to it in the Chunks container. This goes both forwards and backwards since that works well for both same-order and opposite-order deallocations. (Same-order = objects are deallocated in the same order in which they were allocated. Opposite order = objects are deallocated in a last to first order. Complexity is O(C) where C is count of all Chunks. This never throws. @return Pointer to Chunk that owns p, or NULL if no owner found. */ Chunk * VicinityFind( void * p ) const; /// Not implemented. FixedAllocator(const FixedAllocator&); /// Not implemented. FixedAllocator& operator=(const FixedAllocator&); /// Type of container used to hold Chunks. typedef std::vector< Chunk > Chunks; /// Iterator through container of Chunks. typedef Chunks::iterator ChunkIter; /// Iterator through const container of Chunks. typedef Chunks::const_iterator ChunkCIter; /// Fewest # of objects managed by a Chunk. static unsigned char MinObjectsPerChunk_; /// Most # of objects managed by a Chunk - never exceeds UCHAR_MAX. static unsigned char MaxObjectsPerChunk_; /// Number of bytes in a single block within a Chunk. std::size_t blockSize_; /// Number of blocks managed by each Chunk. unsigned char numBlocks_; /// Container of Chunks. Chunks chunks_; /// Pointer to Chunk used for last or next allocation. Chunk * allocChunk_; /// Pointer to Chunk used for last or next deallocation. Chunk * deallocChunk_; /// Pointer to the only empty Chunk if there is one, else NULL. Chunk * emptyChunk_; public: /// Create a FixedAllocator which manages blocks of 'blockSize' size. FixedAllocator(); /// Destroy the FixedAllocator and release all its Chunks. ~FixedAllocator(); /// Initializes a FixedAllocator by calculating # of blocks per Chunk. void Initialize( std::size_t blockSize, std::size_t pageSize ); /** Returns pointer to allocated memory block of fixed size - or NULL if it failed to allocate. */ void * Allocate( void ); /** Deallocate a memory block previously allocated with Allocate. If the block is not owned by this FixedAllocator, it returns false so that SmallObjAllocator can call the default deallocator. If the block was found, this returns true. */ bool Deallocate( void * p, Chunk * hint ); /// Returns block size with which the FixedAllocator was initialized. inline std::size_t BlockSize() const { return blockSize_; } /** Releases the memory used by the empty Chunk. This will take constant time under any situation. @return True if empty chunk found and released, false if none empty. */ bool TrimEmptyChunk( void ); /** Releases unused spots from ChunkList. This takes constant time with respect to # of Chunks, but actual time depends on underlying memory allocator. @return False if no unused spots, true if some found and released. */ bool TrimChunkList( void ); /** Returns count of empty Chunks held by this allocator. Complexity is O(C) where C is the total number of Chunks - empty or used. */ std::size_t CountEmptyChunks( void ) const; /** Determines if FixedAllocator is corrupt. Checks data members to see if any have erroneous values, or violate class invariants. It also checks if any Chunk is corrupt. Complexity is O(C) where C is the number of Chunks. If any data is corrupt, this will return true in release mode, or assert in debug mode. */ bool IsCorrupt( void ) const; /** Returns true if the block at address p is within a Chunk owned by this FixedAllocator. Complexity is O(C) where C is the total number of Chunks - empty or used. */ const Chunk * HasBlock( void * p ) const; inline Chunk * HasBlock( void * p ) { return const_cast< Chunk * >( const_cast< const FixedAllocator * >( this )->HasBlock( p ) ); } }; unsigned char FixedAllocator::MinObjectsPerChunk_ = 8; unsigned char FixedAllocator::MaxObjectsPerChunk_ = UCHAR_MAX; // Chunk::Init ---------------------------------------------------------------- bool Chunk::Init( std::size_t blockSize, unsigned char blocks ) { assert(blockSize > 0); assert(blocks > 0); // Overflow check const std::size_t allocSize = blockSize * blocks; assert( allocSize / blockSize == blocks); #ifdef USE_NEW_TO_ALLOCATE // If this new operator fails, it will throw, and the exception will get // caught one layer up. pData_ = static_cast< unsigned char * >( ::operator new ( allocSize ) ); #else // malloc can't throw, so its only way to indicate an error is to return // a NULL pointer, so we have to check for that. pData_ = static_cast< unsigned char * >( ::std::malloc( allocSize ) ); if ( NULL == pData_ ) return false; #endif Reset( blockSize, blocks ); return true; } // Chunk::Reset --------------------------------------------------------------- void Chunk::Reset(std::size_t blockSize, unsigned char blocks) { assert(blockSize > 0); assert(blocks > 0); // Overflow check assert((blockSize * blocks) / blockSize == blocks); firstAvailableBlock_ = 0; blocksAvailable_ = blocks; unsigned char i = 0; for ( unsigned char * p = pData_; i != blocks; p += blockSize ) { *p = ++i; } } // Chunk::Release ------------------------------------------------------------- void Chunk::Release() { assert( NULL != pData_ ); #ifdef USE_NEW_TO_ALLOCATE ::operator delete ( pData_ ); #else ::std::free( static_cast< void * >( pData_ ) ); #endif } // Chunk::Allocate ------------------------------------------------------------ void* Chunk::Allocate(std::size_t blockSize) { if ( IsFilled() ) return NULL; assert((firstAvailableBlock_ * blockSize) / blockSize == firstAvailableBlock_); unsigned char * pResult = pData_ + (firstAvailableBlock_ * blockSize); firstAvailableBlock_ = *pResult; --blocksAvailable_; return pResult; } // Chunk::Deallocate ---------------------------------------------------------- void Chunk::Deallocate(void* p, std::size_t blockSize) { assert(p >= pData_); unsigned char* toRelease = static_cast(p); // Alignment check assert((toRelease - pData_) % blockSize == 0); unsigned char index = static_cast< unsigned char >( ( toRelease - pData_ ) / blockSize); #if defined(DEBUG) || defined(_DEBUG) // Check if block was already deleted. Attempting to delete the same // block more than once causes Chunk's linked-list of stealth indexes to // become corrupt. And causes count of blocksAvailable_ to be wrong. if ( 0 < blocksAvailable_ ) assert( firstAvailableBlock_ != index ); #endif *toRelease = firstAvailableBlock_; firstAvailableBlock_ = index; // Truncation check assert(firstAvailableBlock_ == (toRelease - pData_) / blockSize); ++blocksAvailable_; } // Chunk::IsCorrupt ----------------------------------------------------------- bool Chunk::IsCorrupt( unsigned char numBlocks, std::size_t blockSize, bool checkIndexes ) const { if ( numBlocks < blocksAvailable_ ) { // Contents at this Chunk corrupted. This might mean something has // overwritten memory owned by the Chunks container. assert( false ); return true; } if ( IsFilled() ) // Useless to do further corruption checks if all blocks allocated. return false; unsigned char index = firstAvailableBlock_; if ( numBlocks <= index ) { // Contents at this Chunk corrupted. This might mean something has // overwritten memory owned by the Chunks container. assert( false ); return true; } if ( !checkIndexes ) // Caller chose to skip more complex corruption tests. return false; /* If the bit at index was set in foundBlocks, then the stealth index was found on the linked-list. */ std::bitset< UCHAR_MAX > foundBlocks; unsigned char * nextBlock = NULL; /* The loop goes along singly linked-list of stealth indexes and makes sure that each index is within bounds (0 <= index < numBlocks) and that the index was not already found while traversing the linked-list. The linked- list should have exactly blocksAvailable_ nodes, so the for loop will not check more than blocksAvailable_. This loop can't check inside allocated blocks for corruption since such blocks are not within the linked-list. Contents of allocated blocks are not changed by Chunk. Here are the types of corrupted link-lists which can be verified. The corrupt index is shown with asterisks in each example. Type 1: Index is too big. numBlocks == 64 blocksAvailable_ == 7 firstAvailableBlock_ -> 17 -> 29 -> *101* There should be no indexes which are equal to or larger than the total number of blocks. Such an index would refer to a block beyond the Chunk's allocated domain. Type 2: Index is repeated. numBlocks == 64 blocksAvailable_ == 5 firstAvailableBlock_ -> 17 -> 29 -> 53 -> *17* -> 29 -> 53 ... No index should be repeated within the linked-list since that would indicate the presence of a loop in the linked-list. */ for ( unsigned char cc = 0; ; ) { nextBlock = pData_ + ( index * blockSize ); foundBlocks.set( index, true ); ++cc; if ( cc >= blocksAvailable_ ) // Successfully counted off number of nodes in linked-list. break; index = *nextBlock; if ( numBlocks <= index ) { /* This catches Type 1 corruptions as shown in above comments. This implies that a block was corrupted due to a stray pointer or an operation on a nearby block overran the size of the block. */ assert( false ); return true; } if ( foundBlocks.test( index ) ) { /* This catches Type 2 corruptions as shown in above comments. This implies that a block was corrupted due to a stray pointer or an operation on a nearby block overran the size of the block. Or perhaps the program tried to delete a block more than once. */ assert( false ); return true; } } if ( foundBlocks.count() != blocksAvailable_ ) { /* This implies that the singly-linked-list of stealth indexes was corrupted. Ideally, this should have been detected within the loop. */ assert( false ); return true; } return false; } // Chunk::IsBlockAvailable ---------------------------------------------------- bool Chunk::IsBlockAvailable( void * p, unsigned char numBlocks, std::size_t blockSize ) const { (void) numBlocks; if ( IsFilled() ) return false; unsigned char * place = static_cast< unsigned char * >( p ); // Alignment check assert( ( place - pData_ ) % blockSize == 0 ); unsigned char blockIndex = static_cast< unsigned char >( ( place - pData_ ) / blockSize ); unsigned char index = firstAvailableBlock_; assert( numBlocks > index ); if ( index == blockIndex ) return true; /* If the bit at index was set in foundBlocks, then the stealth index was found on the linked-list. */ std::bitset< UCHAR_MAX > foundBlocks; unsigned char * nextBlock = NULL; for ( unsigned char cc = 0; ; ) { nextBlock = pData_ + ( index * blockSize ); foundBlocks.set( index, true ); ++cc; if ( cc >= blocksAvailable_ ) // Successfully counted off number of nodes in linked-list. break; index = *nextBlock; if ( index == blockIndex ) return true; assert( numBlocks > index ); assert( !foundBlocks.test( index ) ); } return false; } // FixedAllocator::FixedAllocator --------------------------------------------- FixedAllocator::FixedAllocator() : blockSize_( 0 ) , numBlocks_( 0 ) , chunks_( 0 ) , allocChunk_( NULL ) , deallocChunk_( NULL ) , emptyChunk_( NULL ) { } // FixedAllocator::~FixedAllocator -------------------------------------------- FixedAllocator::~FixedAllocator() { #ifdef DO_EXTRA_LOKI_TESTS TrimEmptyChunk(); assert( chunks_.empty() && "Memory leak detected!" ); #endif for ( ChunkIter i( chunks_.begin() ); i != chunks_.end(); ++i ) i->Release(); } // FixedAllocator::Initialize ------------------------------------------------- void FixedAllocator::Initialize( std::size_t blockSize, std::size_t pageSize ) { assert( blockSize > 0 ); assert( pageSize >= blockSize ); blockSize_ = blockSize; std::size_t numBlocks = pageSize / blockSize; if ( numBlocks > MaxObjectsPerChunk_ ) numBlocks = MaxObjectsPerChunk_; else if ( numBlocks < MinObjectsPerChunk_ ) numBlocks = MinObjectsPerChunk_; numBlocks_ = static_cast(numBlocks); assert(numBlocks_ == numBlocks); } // FixedAllocator::CountEmptyChunks ------------------------------------------- std::size_t FixedAllocator::CountEmptyChunks( void ) const { #ifdef DO_EXTRA_LOKI_TESTS // This code is only used for specialized tests of the allocator. // It is #ifdef-ed so that its O(C) complexity does not overwhelm the // functions which call it. std::size_t count = 0; for ( ChunkCIter it( chunks_.begin() ); it != chunks_.end(); ++it ) { const Chunk & chunk = *it; if ( chunk.HasAvailable( numBlocks_ ) ) ++count; } return count; #else return ( NULL == emptyChunk_ ) ? 0 : 1; #endif } // FixedAllocator::IsCorrupt -------------------------------------------------- bool FixedAllocator::IsCorrupt( void ) const { const bool isEmpty = chunks_.empty(); ChunkCIter start( chunks_.begin() ); ChunkCIter last( chunks_.end() ); const size_t emptyChunkCount = CountEmptyChunks(); if ( isEmpty ) { if ( start != last ) { assert( false ); return true; } if ( 0 < emptyChunkCount ) { assert( false ); return true; } if ( NULL != deallocChunk_ ) { assert( false ); return true; } if ( NULL != allocChunk_ ) { assert( false ); return true; } if ( NULL != emptyChunk_ ) { assert( false ); return true; } } else { const Chunk * front = &chunks_.front(); const Chunk * back = &chunks_.back(); if ( start >= last ) { assert( false ); return true; } if ( back < deallocChunk_ ) { assert( false ); return true; } if ( back < allocChunk_ ) { assert( false ); return true; } if ( front > deallocChunk_ ) { assert( false ); return true; } if ( front > allocChunk_ ) { assert( false ); return true; } switch ( emptyChunkCount ) { case 0: if ( emptyChunk_ != NULL ) { assert( false ); return true; } break; case 1: if ( emptyChunk_ == NULL ) { assert( false ); return true; } if ( back < emptyChunk_ ) { assert( false ); return true; } if ( front > emptyChunk_ ) { assert( false ); return true; } if ( !emptyChunk_->HasAvailable( numBlocks_ ) ) { // This may imply somebody tried to delete a block twice. assert( false ); return true; } break; default: assert( false ); return true; } for ( ChunkCIter it( start ); it != last; ++it ) { const Chunk & chunk = *it; if ( chunk.IsCorrupt( numBlocks_, blockSize_, true ) ) return true; } } return false; } // FixedAllocator::HasBlock --------------------------------------------------- const Chunk * FixedAllocator::HasBlock( void * p ) const { const std::size_t chunkLength = numBlocks_ * blockSize_; for ( ChunkCIter it( chunks_.begin() ); it != chunks_.end(); ++it ) { const Chunk & chunk = *it; if ( chunk.HasBlock( p, chunkLength ) ) return &chunk; } return NULL; } // FixedAllocator::TrimEmptyChunk --------------------------------------------- bool FixedAllocator::TrimEmptyChunk( void ) { // prove either emptyChunk_ points nowhere, or points to a truly empty Chunk. assert( ( NULL == emptyChunk_ ) || ( emptyChunk_->HasAvailable( numBlocks_ ) ) ); if ( NULL == emptyChunk_ ) return false; // If emptyChunk_ points to valid Chunk, then chunk list is not empty. assert( !chunks_.empty() ); // And there should be exactly 1 empty Chunk. assert( 1 == CountEmptyChunks() ); Chunk * lastChunk = &chunks_.back(); if ( lastChunk != emptyChunk_ ) std::swap( *emptyChunk_, *lastChunk ); assert( lastChunk->HasAvailable( numBlocks_ ) ); lastChunk->Release(); chunks_.pop_back(); if ( chunks_.empty() ) { allocChunk_ = NULL; deallocChunk_ = NULL; } else { if ( deallocChunk_ == emptyChunk_ ) { deallocChunk_ = &chunks_.front(); assert( deallocChunk_->blocksAvailable_ < numBlocks_ ); } if ( allocChunk_ == emptyChunk_ ) { allocChunk_ = &chunks_.back(); assert( allocChunk_->blocksAvailable_ < numBlocks_ ); } } emptyChunk_ = NULL; assert( 0 == CountEmptyChunks() ); return true; } // FixedAllocator::TrimChunkList ---------------------------------------------- bool FixedAllocator::TrimChunkList( void ) { if ( chunks_.empty() ) { assert( NULL == allocChunk_ ); assert( NULL == deallocChunk_ ); } if ( chunks_.size() == chunks_.capacity() ) return false; // Use the "make-a-temp-and-swap" trick to remove excess capacity. Chunks( chunks_ ).swap( chunks_ ); return true; } // FixedAllocator::MakeNewChunk ----------------------------------------------- bool FixedAllocator::MakeNewChunk( void ) { bool allocated = false; try { std::size_t size = chunks_.size(); // Calling chunks_.reserve *before* creating and initializing the new // Chunk means that nothing is leaked by this function in case an // exception is thrown from reserve. if ( chunks_.capacity() == size ) { if ( 0 == size ) size = 4; chunks_.reserve( size * 2 ); } Chunk newChunk; allocated = newChunk.Init( blockSize_, numBlocks_ ); if ( allocated ) chunks_.push_back( newChunk ); } catch ( ... ) { allocated = false; } if ( !allocated ) return false; allocChunk_ = &chunks_.back(); deallocChunk_ = &chunks_.front(); return true; } // FixedAllocator::Allocate --------------------------------------------------- void * FixedAllocator::Allocate( void ) { // prove either emptyChunk_ points nowhere, or points to a truly empty Chunk. assert( ( NULL == emptyChunk_ ) || ( emptyChunk_->HasAvailable( numBlocks_ ) ) ); assert( CountEmptyChunks() < 2 ); if ( ( NULL == allocChunk_ ) || allocChunk_->IsFilled() ) { if ( NULL != emptyChunk_ ) { allocChunk_ = emptyChunk_; emptyChunk_ = NULL; } else { for ( ChunkIter i( chunks_.begin() ); ; ++i ) { if ( chunks_.end() == i ) { if ( !MakeNewChunk() ) return NULL; break; } if ( !i->IsFilled() ) { allocChunk_ = &*i; break; } } } } else if ( allocChunk_ == emptyChunk_) // detach emptyChunk_ from allocChunk_, because after // calling allocChunk_->Allocate(blockSize_); the chunk // is no longer empty. emptyChunk_ = NULL; assert( allocChunk_ != NULL ); assert( !allocChunk_->IsFilled() ); void * place = allocChunk_->Allocate( blockSize_ ); // prove either emptyChunk_ points nowhere, or points to a truly empty Chunk. assert( ( NULL == emptyChunk_ ) || ( emptyChunk_->HasAvailable( numBlocks_ ) ) ); assert( CountEmptyChunks() < 2 ); #ifdef LOKI_CHECK_FOR_CORRUPTION if ( allocChunk_->IsCorrupt( numBlocks_, blockSize_, true ) ) { assert( false ); return NULL; } #endif return place; } // FixedAllocator::Deallocate ------------------------------------------------- bool FixedAllocator::Deallocate( void * p, Chunk * hint ) { assert(!chunks_.empty()); assert(&chunks_.front() <= deallocChunk_); assert(&chunks_.back() >= deallocChunk_); assert( &chunks_.front() <= allocChunk_ ); assert( &chunks_.back() >= allocChunk_ ); assert( CountEmptyChunks() < 2 ); Chunk * foundChunk = ( NULL == hint ) ? VicinityFind( p ) : hint; if ( NULL == foundChunk ) return false; assert( foundChunk->HasBlock( p, numBlocks_ * blockSize_ ) ); #ifdef LOKI_CHECK_FOR_CORRUPTION if ( foundChunk->IsCorrupt( numBlocks_, blockSize_, true ) ) { assert( false ); return false; } if ( foundChunk->IsBlockAvailable( p, numBlocks_, blockSize_ ) ) { assert( false ); return false; } #endif deallocChunk_ = foundChunk; DoDeallocate(p); assert( CountEmptyChunks() < 2 ); return true; } // FixedAllocator::VicinityFind ----------------------------------------------- Chunk * FixedAllocator::VicinityFind( void * p ) const { if ( chunks_.empty() ) return NULL; assert(deallocChunk_); const std::size_t chunkLength = numBlocks_ * blockSize_; Chunk * lo = deallocChunk_; Chunk * hi = deallocChunk_ + 1; const Chunk * loBound = &chunks_.front(); const Chunk * hiBound = &chunks_.back() + 1; // Special case: deallocChunk_ is the last in the array if (hi == hiBound) hi = NULL; for (;;) { if (lo) { if ( lo->HasBlock( p, chunkLength ) ) return lo; if ( lo == loBound ) { lo = NULL; if ( NULL == hi ) break; } else --lo; } if (hi) { if ( hi->HasBlock( p, chunkLength ) ) return hi; if ( ++hi == hiBound ) { hi = NULL; if ( NULL == lo ) break; } } } return NULL; } // FixedAllocator::DoDeallocate ----------------------------------------------- void FixedAllocator::DoDeallocate(void* p) { // Show that deallocChunk_ really owns the block at address p. assert( deallocChunk_->HasBlock( p, numBlocks_ * blockSize_ ) ); // Either of the next two assertions may fail if somebody tries to // delete the same block twice. assert( emptyChunk_ != deallocChunk_ ); assert( !deallocChunk_->HasAvailable( numBlocks_ ) ); // prove either emptyChunk_ points nowhere, or points to a truly empty Chunk. assert( ( NULL == emptyChunk_ ) || ( emptyChunk_->HasAvailable( numBlocks_ ) ) ); // call into the chunk, will adjust the inner list but won't release memory deallocChunk_->Deallocate(p, blockSize_); if ( deallocChunk_->HasAvailable( numBlocks_ ) ) { assert( emptyChunk_ != deallocChunk_ ); // deallocChunk_ is empty, but a Chunk is only released if there are 2 // empty chunks. Since emptyChunk_ may only point to a previously // cleared Chunk, if it points to something else besides deallocChunk_, // then FixedAllocator currently has 2 empty Chunks. if ( NULL != emptyChunk_ ) { // If last Chunk is empty, just change what deallocChunk_ // points to, and release the last. Otherwise, swap an empty // Chunk with the last, and then release it. Chunk * lastChunk = &chunks_.back(); if ( lastChunk == deallocChunk_ ) deallocChunk_ = emptyChunk_; else if ( lastChunk != emptyChunk_ ) std::swap( *emptyChunk_, *lastChunk ); assert( lastChunk->HasAvailable( numBlocks_ ) ); lastChunk->Release(); chunks_.pop_back(); if ( ( allocChunk_ == lastChunk ) || allocChunk_->IsFilled() ) allocChunk_ = deallocChunk_; } emptyChunk_ = deallocChunk_; } // prove either emptyChunk_ points nowhere, or points to a truly empty Chunk. assert( ( NULL == emptyChunk_ ) || ( emptyChunk_->HasAvailable( numBlocks_ ) ) ); } // GetOffset ------------------------------------------------------------------ /// @ingroup SmallObjectGroupInternal /// Calculates index into array where a FixedAllocator of numBytes is located. inline std::size_t GetOffset( std::size_t numBytes, std::size_t alignment ) { const std::size_t alignExtra = alignment-1; return ( numBytes + alignExtra ) / alignment; } // DefaultAllocator ----------------------------------------------------------- /** @ingroup SmallObjectGroupInternal Calls the default allocator when SmallObjAllocator decides not to handle a request. SmallObjAllocator calls this if the number of bytes is bigger than the size which can be handled by any FixedAllocator. @param numBytes number of bytes @param doThrow True if this function should throw an exception, or false if it should indicate failure by returning a NULL pointer. */ void * DefaultAllocator( std::size_t numBytes, bool doThrow ) { #ifdef USE_NEW_TO_ALLOCATE return doThrow ? ::operator new( numBytes ) : ::operator new( numBytes, std::nothrow_t() ); #else void * p = ::std::malloc( numBytes ); if ( doThrow && ( NULL == p ) ) throw std::bad_alloc(); return p; #endif } // DefaultDeallocator --------------------------------------------------------- /** @ingroup SmallObjectGroupInternal Calls default deallocator when SmallObjAllocator decides not to handle a request. The default deallocator could be the global delete operator or the free function. The free function is the preferred default deallocator since it matches malloc which is the preferred default allocator. SmallObjAllocator will call this if an address was not found among any of its own blocks. */ void DefaultDeallocator( void * p ) { #ifdef USE_NEW_TO_ALLOCATE ::operator delete( p ); #else ::std::free( p ); #endif } // SmallObjAllocator::SmallObjAllocator --------------------------------------- SmallObjAllocator::SmallObjAllocator( std::size_t pageSize, std::size_t maxObjectSize, std::size_t objectAlignSize ) : pool_( NULL ), maxSmallObjectSize_( maxObjectSize ), objectAlignSize_( objectAlignSize ) { #ifdef DO_EXTRA_LOKI_TESTS std::cout << "SmallObjAllocator " << this << std::endl; #endif assert( 0 != objectAlignSize ); const std::size_t allocCount = GetOffset( maxObjectSize, objectAlignSize ); pool_ = new FixedAllocator[ allocCount ]; for ( std::size_t i = 0; i < allocCount; ++i ) pool_[ i ].Initialize( ( i+1 ) * objectAlignSize, pageSize ); } // SmallObjAllocator::~SmallObjAllocator -------------------------------------- SmallObjAllocator::~SmallObjAllocator( void ) { #ifdef DO_EXTRA_LOKI_TESTS std::cout << "~SmallObjAllocator " << this << std::endl; #endif delete [] pool_; } // SmallObjAllocator::TrimExcessMemory ---------------------------------------- bool SmallObjAllocator::TrimExcessMemory( void ) { bool found = false; const std::size_t allocCount = GetOffset( GetMaxObjectSize(), GetAlignment() ); std::size_t i = 0; for ( ; i < allocCount; ++i ) { if ( pool_[ i ].TrimEmptyChunk() ) found = true; } for ( i = 0; i < allocCount; ++i ) { if ( pool_[ i ].TrimChunkList() ) found = true; } return found; } // SmallObjAllocator::Allocate ------------------------------------------------ void * SmallObjAllocator::Allocate( std::size_t numBytes, bool doThrow ) { if ( numBytes > GetMaxObjectSize() ) return DefaultAllocator( numBytes, doThrow ); assert( NULL != pool_ ); if ( 0 == numBytes ) numBytes = 1; const std::size_t index = GetOffset( numBytes, GetAlignment() ) - 1; const std::size_t allocCount = GetOffset( GetMaxObjectSize(), GetAlignment() ); (void) allocCount; assert( index < allocCount ); FixedAllocator & allocator = pool_[ index ]; assert( allocator.BlockSize() >= numBytes ); assert( allocator.BlockSize() < numBytes + GetAlignment() ); void * place = allocator.Allocate(); if ( ( NULL == place ) && TrimExcessMemory() ) place = allocator.Allocate(); if ( ( NULL == place ) && doThrow ) { #ifdef _MSC_VER throw std::bad_alloc( "could not allocate small object" ); #else // GCC did not like a literal string passed to std::bad_alloc. // so just throw the default-constructed exception. throw std::bad_alloc(); #endif } return place; } // SmallObjAllocator::Deallocate ---------------------------------------------- void SmallObjAllocator::Deallocate( void * p, std::size_t numBytes ) { if ( NULL == p ) return; if ( numBytes > GetMaxObjectSize() ) { DefaultDeallocator( p ); return; } assert( NULL != pool_ ); if ( 0 == numBytes ) numBytes = 1; const std::size_t index = GetOffset( numBytes, GetAlignment() ) - 1; const std::size_t allocCount = GetOffset( GetMaxObjectSize(), GetAlignment() ); (void) allocCount; assert( index < allocCount ); FixedAllocator & allocator = pool_[ index ]; assert( allocator.BlockSize() >= numBytes ); assert( allocator.BlockSize() < numBytes + GetAlignment() ); const bool found = allocator.Deallocate( p, NULL ); (void) found; assert( found ); } // SmallObjAllocator::Deallocate ---------------------------------------------- void SmallObjAllocator::Deallocate( void * p ) { if ( NULL == p ) return; assert( NULL != pool_ ); FixedAllocator * pAllocator = NULL; const std::size_t allocCount = GetOffset( GetMaxObjectSize(), GetAlignment() ); Chunk * chunk = NULL; for ( std::size_t ii = 0; ii < allocCount; ++ii ) { chunk = pool_[ ii ].HasBlock( p ); if ( NULL != chunk ) { pAllocator = &pool_[ ii ]; break; } } if ( NULL == pAllocator ) { DefaultDeallocator( p ); return; } assert( NULL != chunk ); const bool found = pAllocator->Deallocate( p, chunk ); (void) found; assert( found ); } // SmallObjAllocator::IsCorrupt ----------------------------------------------- bool SmallObjAllocator::IsCorrupt( void ) const { if ( NULL == pool_ ) { assert( false ); return true; } if ( 0 == GetAlignment() ) { assert( false ); return true; } if ( 0 == GetMaxObjectSize() ) { assert( false ); return true; } const std::size_t allocCount = GetOffset( GetMaxObjectSize(), GetAlignment() ); for ( std::size_t ii = 0; ii < allocCount; ++ii ) { if ( pool_[ ii ].IsCorrupt() ) return true; } return false; } } // end namespace Loki libloki-0.1.7.orig/src/make.msvc.dll.bat0000644000175000017500000000051310515233307016472 0ustar ivanivan cl -c -Zm200 -O2 -DNDEBUG -MT -D_WINDLL -DLOKI_MAKE_DLL -EHsc -GR -W4 -wd4251 -I"." -I"..\include" OrderedStatic.cpp SafeFormat.cpp SmallObj.cpp SmartPtr.cpp Singleton.cpp StrongPtr.cpp link /NOLOGO /DLL /OUT:"..\lib\loki015.dll" OrderedStatic.obj SafeFormat.obj SmallObj.obj SmartPtr.obj Singleton.obj StrongPtr.obj del *.obj libloki-0.1.7.orig/test/0000755000175000017500000000000011140365040013530 5ustar ivanivanlibloki-0.1.7.orig/test/OrderedStatic/0000755000175000017500000000000011140365037016272 5ustar ivanivanlibloki-0.1.7.orig/test/OrderedStatic/Makefile0000644000175000017500000000037210515234750017736 0ustar ivanivaninclude ../Makefile.common BIN := main$(BIN_SUFFIX) SRC := main.cpp OBJ := $(SRC:.cpp=.o) .PHONY: all clean all: $(BIN) clean: cleandeps $(RM) $(BIN) $(RM) $(OBJ) $(BIN): $(OBJ) $(CXX) $(LDFLAGS) -o $@ $^ $(LDLIBS) include ../../Makefile.deps libloki-0.1.7.orig/test/OrderedStatic/make.msvc.bat0000644000175000017500000000030510515234750020646 0ustar ivanivan cl -c -Zm200 -O2 -DNDEBUG -MT -EHsc -GR -W4 -wd4710 -I"." -I"..\..\include" main.cpp link /NOLOGO /SUBSYSTEM:CONSOLE /incremental:no /OUT:"main-msvc.exe" ..\..\lib\loki.lib main.obj del *.obj libloki-0.1.7.orig/test/OrderedStatic/main.cpp0000644000175000017500000000566311047334460017736 0ustar ivanivan//////////////////////////////////////////////////////////////////////////////// // The Loki Library // Copyright (c) 2005 Peter Kmmel // 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 makes no representations about the // suitability of this software for any purpose. It is provided "as is" // without express or implied warranty. //////////////////////////////////////////////////////////////////////////////// // $Id: main.cpp 898 2008-08-09 15:35:12Z syntheticpp $ // define to test the OrderedStatic template #define TEST_ORDERED_STATIC // define to see a runtime crash when not using OrderedStatic //#define LOKI_CLASS_LEVEL_THREADING #include #include #ifdef TEST_ORDERED_STATIC #include #endif struct L1 { L1(){std::cout << "create L1: " << this << "\n";} ~L1(){std::cout << "delete L1: " << this <<" \n";} }; struct L2 { L2(){std::cout << "create L2 \n";} ~L2(){std::cout << "delete L2 \n";} }; struct M1 { M1(){std::cout << "create M1 \n";} ~M1(){std::cout << "delete M1 \n";} }; struct M2 { M2(){std::cout << "create M2 \n";} ~M2(){std::cout << "delete M2 \n";} }; int f() { std::cout << "f called \n"; return 0; } std::string func(); #ifdef TEST_ORDERED_STATIC struct MemberTest { static Loki::OrderedStatic<1,M1> m1; static Loki::OrderedStatic<2,M2> m2; }; Loki::OrderedStatic<1,M1> MemberTest::m1; Loki::OrderedStatic<2,M2> MemberTest::m2; Loki::OrderedStatic<1,L1> l1; Loki::OrderedStatic<2,L2> l2; Loki::OrderedStatic<1, std::string, std::string(*)() > s1( &func ); Loki::OrderedStatic<2, std::string, Loki::Seq > s2( "s2" ); Loki::OrderedStatic<1, Loki::Functor, Loki::Seq > f1(f); #else struct MemberTest { static M1 m1; static M2 m2; }; M1 MemberTest::m1; M2 MemberTest::m2; L1 l1; L2 l2; std::string s1( func() ); std::string s2("s2"); Loki::Functor f1(f); #endif std::string func() { #ifdef TEST_ORDERED_STATIC return *s2; #else return s2; #endif } int main() { #ifdef TEST_ORDERED_STATIC Loki::OrderedStaticManager::Instance().createObjects(); std::cout << "\n"; (*f1)(); std::cout << "value of s1: " << (*s1).c_str() << "\n"; std::cout << "value of s2: " << (*s2).c_str() << "\n"; std::string s("text11"); *s1=s; std::cout << "value of s1: " << s1->c_str() << "\n"; #else std::cout << "\n"; f1(); std::cout << "s1 = " << s1.c_str() << "\n"; std::cout << "s2 = " << s2.c_str() << "\n"; #endif std::cout << "\n"; #if defined(__BORLANDC__) || defined(_MSC_VER) system("PAUSE"); #endif return 0; } libloki-0.1.7.orig/test/OrderedStatic/OrderedStatic.cbp0000644000175000017500000000252011047143225021512 0ustar ivanivan libloki-0.1.7.orig/test/OrderedStatic/OrderedStatic_MSVC_8.vcproj0000644000175000017500000000650011047143225023332 0ustar ivanivan libloki-0.1.7.orig/test/OrderedStatic/OrderedStatic.vcproj0000644000175000017500000000660111041557515022262 0ustar ivanivan libloki-0.1.7.orig/test/OrderedStatic/OrderedStatic_MSVC9.vcproj0000644000175000017500000001141711140364657023207 0ustar ivanivan libloki-0.1.7.orig/test/SafeFormat/0000755000175000017500000000000011140365037015565 5ustar ivanivanlibloki-0.1.7.orig/test/SafeFormat/Makefile0000644000175000017500000000046710515234750017236 0ustar ivanivaninclude ../Makefile.common BIN := main$(BIN_SUFFIX) SRC := main.cpp OBJ := $(SRC:.cpp=.o) CXXFLAGS := $(CXXWARNFLAGS) -g -fexpensive-optimizations -O3 .PHONY: all clean all: $(BIN) clean: cleandeps $(RM) $(BIN) $(RM) $(OBJ) $(BIN): $(OBJ) $(CXX) $(LDFLAGS) -o $@ $^ $(LDLIBS) include ../../Makefile.deps libloki-0.1.7.orig/test/SafeFormat/SafeFormat_MSVC9.vcproj0000644000175000017500000001140311140364657021770 0ustar ivanivan libloki-0.1.7.orig/test/SafeFormat/make.msvc.bat0000644000175000017500000000030710515234750020143 0ustar ivanivancl -c -Zm200 -O2 -DNDEBUG -MT -EHsc -GR -W4 -wd4710 -I"." -I"..\..\include" main.cpp link /NOLOGO /SUBSYSTEM:CONSOLE /incremental:no /OUT:"main-msvc.exe" ..\..\lib\loki.lib main.obj del main.obj libloki-0.1.7.orig/test/SafeFormat/main.cpp0000644000175000017500000001605610515237275017234 0ustar ivanivan//////////////////////////////////////////////////////////////////////////////// // Copyright (c) 2005 by Andrei Alexandrescu // 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 makes no representations about the suitability of this software // for any purpose. It is provided "as is" without express or implied // warranty. //////////////////////////////////////////////////////////////////////////////// // $Id: main.cpp 760 2006-10-17 20:36:13Z syntheticpp $ #include #include #include #include #include "../SmallObj/timer.h" #if defined(_MSC_VER) #if _MSC_VER >= 1400 #define sprintf sprintf_s #define _snprintf _snprintf_s #else #define sprintf sprintf #define _snprintf _snprintf #endif #endif using namespace std; using namespace Loki; template Integral2 RandomInt(Integral1 low, Integral2 up) { // From ``Accelerated C++'', page 135: // random integer in the range [0, n) // We adjust to generate in the range [0, n] const Integral2 low2 = low, n = up - low; assert(n > 0); const size_t bucket_size = RAND_MAX / n; assert(bucket_size > 0); Integral2 r; do r = Integral2(rand() / bucket_size); while (r > n); r = r + low2; assert(r >= low2 && r <= up); return r; } string RandomString(unsigned int maxSize) { string result(RandomInt(0, maxSize), '\0'); unsigned int i = 0; for (; i != result.size(); ++i) { result[i] = RandomInt('a', 'z'); } return result; } template void TestCase(const string& fmt, T value) { char buf[4096]; std::string s; const int i1 = SPrintf(s, fmt.c_str())(value); #ifdef _MSC_VER const int i2 = _snprintf(buf, sizeof(buf), fmt.c_str(), value); #else const int i2 = snprintf(buf, sizeof(buf), fmt.c_str(), value); #endif if (i1 != i2 || s != buf) { cout << endl << "Reference: " << i2 << "; Actual: " << i1 << ", Difference = " << i2-i1 << endl << "V: [" << value << "]" << endl << "F: [" << fmt << "]" << endl << "R: [" << buf << "]" << endl << "A: [" << s.c_str() << "]" << endl; assert(false); } } template void TestCase2(const string& fmt, T value, U value2) { char buf[4096]; std::string s; const int i1 = SPrintf(s, fmt.c_str())(value)(value2); const int i2 = snprintf(buf, sizeof(buf), fmt.c_str(), value, value2); assert(i1 == i2); assert(s == buf); } int main(int argc, char** argv) { if (argc == 2) { // test speed Timer t; int loop = atoi(argv[1]); if(loop < 100) loop = 100; t.start(); for (int i=loop; i > 0; --i) printf("Hey, %u frobnicators and %u twiddlicators\n",i, i); t.stop(); t.t100 = t.t(); int t_printf = t.t(); t.start(); for (int i=loop; i > 0; --i) Printf("Hey, %u frobnicators and %u twiddlicators\n")(i)(i); t.stop(); int t_Printf = t.t(); t.start(); for (int i=loop; i > 0; --i) cout << "Hey, " << i << " frobnicators and " << i <<" twiddlicators\n"; t.stop(); int t_cout = t.t(); Printf("\n\nElapsed time for %i outputs\n\n")(loop); t.print(t_printf,"printf : "); t.print(t_Printf,"Printf : "); t.print(t_cout, "std::cout: "); } else { //srand(time(0)); srand(0); printf("\nNumber of tests:\n"); for (unsigned i = 0; ; ++i) { printf("%u\r", i); // Generate a random string for the head string lead = RandomString(100); // This string will hold a random format specification string formatSpec(lead + "|%"); // Generate a random set of flags static const string flags("-+0 #"); size_t maxFlags = RandomInt(0u, flags.length() - 1); for (size_t i = 0; i != maxFlags; ++i) { formatSpec += flags[RandomInt(0u, flags.length() - 1)]; } // Generate an optional random width if (RandomInt(0, 1)) { const unsigned int width = RandomInt(0, 100); char buf[4]; sprintf(buf, "%u", width); formatSpec += buf; } // Generate an optional random precision if (RandomInt(0, 1)) { const unsigned int prec = RandomInt(0, 100); char buf[4]; sprintf(buf, "%u", prec); formatSpec += '.'; formatSpec += buf; } // Generate a random type character static const string type("cdeEfgGinopsuxX"); const char typeSpec = type[RandomInt(0u, type.size() - 1)]; // Generate an optional type prefix static const string prefix("hl"); if (typeSpec != 's' && RandomInt(0, 1)) { formatSpec += prefix[RandomInt(0u, prefix.size() - 1)]; } formatSpec += typeSpec; formatSpec += '|'; formatSpec += RandomString(100); switch (typeSpec) { case 'c': TestCase(formatSpec, RandomInt(1, 127)); break; case 'd': case 'i': case 'o': case 'u': case 'x': case 'X': //TestCase(formatSpec, RandomInt(-10000, 10000)); // don't test negative values on 64bit systems, because // snprintf does not support 64 Bit values TestCase(formatSpec, RandomInt( -10000 * (sizeof(size_t)>4 ? 0 : 1) , 10000)); break; case 'e': case 'E': case 'f': case 'g': case 'G': TestCase(formatSpec, RandomInt(-10000, 10000) / double(RandomInt(1, 100))); break; case 'n': break; case 'p': { void * p = malloc(RandomInt(1, 1000)); TestCase(formatSpec, p); free(p); } break; case 's': TestCase(formatSpec, RandomString(100).c_str()); break; default: assert(false); break; } } } } void test_dword() { typedef signed int Int; typedef unsigned int UInt; typedef signed long Long; typedef unsigned long ULong; Int i(0); UInt ui(0); Long l(0); ULong ul(0); Printf("%d")(i); Printf("%d")(ui); Printf("%d")(l); Printf("%d")(ul); } libloki-0.1.7.orig/test/SafeFormat/SafeFormat.cbp0000644000175000017500000000250711047143225020305 0ustar ivanivan libloki-0.1.7.orig/test/SafeFormat/SafeFormat.vcproj0000644000175000017500000000656511041560156021054 0ustar ivanivan libloki-0.1.7.orig/test/SafeFormat/SafeFormat_MSVC_8.vcproj0000644000175000017500000000646411047143225022131 0ustar ivanivan libloki-0.1.7.orig/test/Makefile0000644000175000017500000000063610515234750015205 0ustar ivanivanSUBTARGETS_ORIG := $(patsubst %/,%,$(dir $(wildcard */Makefile))) SUBTARGETS_FILTER_OUT := flex_string SUBTARGETS := $(filter-out $(SUBTARGETS_FILTER_OUT),$(SUBTARGETS_ORIG)) SUBTARGETS_CLEAN := $(addsuffix -clean,$(SUBTARGETS)) .PHONY: all clean $(SUBTARGETS) $(SUBTARGETS_CLEAN) all: $(SUBTARGETS) clean: $(SUBTARGETS_CLEAN) $(SUBTARGETS): $(MAKE) -C $@ $(SUBTARGETS_CLEAN): $(MAKE) -C $(@:-clean=) clean libloki-0.1.7.orig/test/Visitor/0000755000175000017500000000000011140365037015175 5ustar ivanivanlibloki-0.1.7.orig/test/Visitor/Makefile0000644000175000017500000000037210515234750016641 0ustar ivanivaninclude ../Makefile.common BIN := main$(BIN_SUFFIX) SRC := main.cpp OBJ := $(SRC:.cpp=.o) .PHONY: all clean all: $(BIN) clean: cleandeps $(RM) $(BIN) $(RM) $(OBJ) $(BIN): $(OBJ) $(CXX) $(LDFLAGS) -o $@ $^ $(LDLIBS) include ../../Makefile.deps libloki-0.1.7.orig/test/Visitor/Visitor.cbp0000644000175000017500000000226611047143225017327 0ustar ivanivan libloki-0.1.7.orig/test/Visitor/Visitor_MSVC_8.vcproj0000644000175000017500000000635111047143225021144 0ustar ivanivan libloki-0.1.7.orig/test/Visitor/Visitor.vcproj0000644000175000017500000000645211041561465020073 0ustar ivanivan libloki-0.1.7.orig/test/Visitor/make.msvc.bat0000644000175000017500000000030510515234750017551 0ustar ivanivan cl -c -Zm200 -O2 -DNDEBUG -MT -EHsc -GR -W4 -wd4710 -I"." -I"..\..\include" main.cpp link /NOLOGO /SUBSYSTEM:CONSOLE /incremental:no /OUT:"main-msvc.exe" ..\..\lib\loki.lib main.obj del *.obj libloki-0.1.7.orig/test/Visitor/main.cpp0000644000175000017500000000445310515236261016634 0ustar ivanivan//////////////////////////////////////////////////////////////////////////////// // The Loki Library // Copyright (c) 2006 Peter Kmmel // 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 makes no representations about the // suitability of this software for any purpose. It is provided "as is" // without express or implied warranty. //////////////////////////////////////////////////////////////////////////////// // $Id: main.cpp 759 2006-10-17 20:27:29Z syntheticpp $ #include #include class Base : public Loki::BaseVisitable<> { public: LOKI_DEFINE_VISITABLE() }; class Type1 : public Base { public: LOKI_DEFINE_VISITABLE() }; class VariableVisitor : public Loki::BaseVisitor, //public Loki::Visitor, //public Loki::Visitor #ifndef LOKI_DISABLE_TYPELIST_MACROS public Loki::Visitor #else public Loki::Visitor::Type> #endif { public: void Visit(Base&){std::cout << "void Visit(Base&)\n";} void Visit(Type1&){std::cout << "void Visit(Type1&)\n";} }; class CBase : public Loki::BaseVisitable { public: LOKI_DEFINE_CONST_VISITABLE() }; class CType1 : public CBase { public: LOKI_DEFINE_CONST_VISITABLE() }; class CVariableVisitor : public Loki::BaseVisitor, //public Loki::Visitor, //public Loki::Visitor #ifndef LOKI_DISABLE_TYPELIST_MACROS public Loki::Visitor #else public Loki::Visitor::Type,void,true> #endif { public: void Visit(const CBase&){std::cout << "void Visit(CBase&)\n";} void Visit(const CType1&){std::cout << "void Visit(CType1&)\n";} }; int main() { VariableVisitor visitor; Type1 type1; Base* dyn = &type1; dyn->Accept(visitor); CVariableVisitor cvisitor; CType1 ctype1; CBase* cdyn = &ctype1; cdyn->Accept(cvisitor); #if defined(__BORLANDC__) || defined(_MSC_VER) system("PAUSE"); #endif } libloki-0.1.7.orig/test/Visitor/Visitor_MSVC9.vcproj0000644000175000017500000001127011140364657021012 0ustar ivanivan libloki-0.1.7.orig/test/Pimpl/0000755000175000017500000000000011140365036014616 5ustar ivanivanlibloki-0.1.7.orig/test/Pimpl/Makefile0000644000175000017500000000037210515234750016263 0ustar ivanivaninclude ../Makefile.common BIN := main$(BIN_SUFFIX) SRC := main.cpp OBJ := $(SRC:.cpp=.o) .PHONY: all clean all: $(BIN) clean: cleandeps $(RM) $(BIN) $(RM) $(OBJ) $(BIN): $(OBJ) $(CXX) $(LDFLAGS) -o $@ $^ $(LDLIBS) include ../../Makefile.deps libloki-0.1.7.orig/test/Pimpl/Pimpl_MSVC9.vcproj0000644000175000017500000001166511140364657020066 0ustar ivanivan libloki-0.1.7.orig/test/Pimpl/Pimpl.vcproj0000644000175000017500000000676711041557602017146 0ustar ivanivan libloki-0.1.7.orig/test/Pimpl/make.msvc.bat0000644000175000017500000000030510515234750017173 0ustar ivanivan cl -c -Zm200 -O2 -DNDEBUG -MT -EHsc -GR -W4 -wd4710 -I"." -I"..\..\include" main.cpp link /NOLOGO /SUBSYSTEM:CONSOLE /incremental:no /OUT:"main-msvc.exe" ..\..\lib\loki.lib main.obj del *.obj libloki-0.1.7.orig/test/Pimpl/main.cpp0000644000175000017500000001737110515237275016267 0ustar ivanivan//////////////////////////////////////////////////////////////////////////////// // The Loki Library // Copyright (c) 2006 Peter Kmmel // 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 makes no representations about the // suitability of this software for any purpose. It is provided "as is" // without express or implied warranty. //////////////////////////////////////////////////////////////////////////////// // $Id: main.cpp 760 2006-10-17 20:36:13Z syntheticpp $ #ifdef _MSC_VER #pragma warning (disable: 4512) #endif #define LOKI_INHERITED_PIMPL_NAME d #define LOKI_INHERITED_RIMPL_NAME d #include "type.h" #include "type2.h" #include ///////////////////////////////////////// // Definition of ImplOf ///////////////////////////////////////// namespace Loki // gcc!! { template<> struct ImplOf : public SmallObject<> // inherit SmallObj for speed up { ImplOf() : data(0) {Printf("A created\n");} ~ImplOf(){Printf("A destroyed, data=%d\n")(data);} int data; }; } ///////////////////////////////////////// // class A definition ///////////////////////////////////////// A::A() {} void A::foo() { (*d).data = 1; d->data = 111; } ///////////////////////////////////////// // Definition of ImplOf ///////////////////////////////////////// namespace Loki // gcc!! { template<> struct ImplOf : public SmallObject<> // inherit SmallObj for speed up { ImplOf() : data(0) {Printf("B created\n");} ~ImplOf(){Printf("B destroyed, data=%d\n")(data);} int data; }; } ///////////////////////////////////////// // class B definition ///////////////////////////////////////// B::B() : Loki::PimplOf::Owner() {} void B::foo() { (*d).data = 2; d->data = 222; } ///////////////////////////////////////// // Definition of ImplOf ///////////////////////////////////////// namespace Loki // gcc!! { template<> struct ImplOf : public SmallObject<> // inherit SmallObj for speed up { ImplOf(): data(0) {Printf("C created\n");} ~ImplOf(){Printf("C destroyed, data=%d\n")(data);} int data; }; } ///////////////////////////////////////// // class C definition ///////////////////////////////////////// C::C() : p(), d(*p) {} void C::foo() { d.data = 333; } ///////////////////////////////////////// // Definition of ImplOf ///////////////////////////////////////// namespace Loki // gcc!! { template<> struct ImplOf : public SmallObject<> // inherit SmallObj for speed up { ImplOf(): data(0) {Printf("D created\n");} ~ImplOf(){Printf("D destroyed, data=%d\n")(data);} int data; }; } ///////////////////////////////////////// // class D definition ///////////////////////////////////////// D::D() : Loki::RimplOf::Owner() {} void D::foo() { d.data = 444; } ///////////////////////////////////////// // main ///////////////////////////////////////// void test_more(); int main() { A* a = new A; B* b = new B; C* c = new C; D* d = new D; a->foo(); b->foo(); c->foo(); d->foo(); delete a; delete b; delete c; delete d; test_more(); #if defined(__BORLANDC__) || defined(_MSC_VER) system("PAUSE"); #endif return 0; } //////////////////// // more test code //////////////////// // incomplete type test // this must give errors //Incomplete1 ii; // compiler error //Incomplete2 i2; // linker error //Incomplete4 i4; // compiler error ///////////////////////////////////////// // Definition of ImplOf ///////////////////////////////////////// namespace Loki // gcc!! { template<> struct ImplOf : public SmallObject<> // inherit SmallObj for speed up { ImplOf() : data(0) {Printf("E created\n");} ~ImplOf(){Printf("E destroyed, data=%d\n")(data);} int data; void foo() {Printf("E foo() \n");} void foo() const {Printf("E foo() const \n");} }; } P1::P1(){d->data = 1;} P2::P2(){d->data = 2;} P3::P3(){d->data = 3;} P4::P4(){d->data = 4;} P5::P5(){d->data = 5;} PO1::PO1(){d->data = 6;} PO2::PO2(){d->data = 7;} PO3::PO3(){d->data = 8;} PO4::PO4(){d->data = 9;} PO5::PO5(){d->data = 10;} void P1::f(){d->foo();} void P2::f(){d->foo();} void P3::f(){d->foo();} void P4::f(){d->foo();} void P5::f(){d->foo();} void PO1::f(){d->foo();} void PO2::f(){d->foo();} void PO3::f(){d->foo();} void PO4::f(){d->foo();} void PO5::f(){d->foo();} void P1::f()const{d->foo();} void P2::f()const{d->foo();} void P3::f()const{d->foo();} void P4::f()const{d->foo();} void P5::f()const{d->foo();} void PO1::f()const{d->foo();} void PO2::f()const{d->foo();} void PO3::f()const{d->foo();} void PO4::f()const{d->foo();} void PO5::f()const{d->foo();} R1::R1():d(*p){d.data = 11;} R2::R2():d(*p){d.data = 22;} R3::R3():d(*p){d.data = 33;} R4::R4():d(*p){d.data = 44;} R5::R5():d(*p){d.data = 55;} void R1::f(){d.foo();} void R2::f(){d.foo();} void R3::f(){d.foo();} void R4::f(){d.foo();} void R5::f(){d.foo();} void R1::f()const{d.foo();} void R2::f()const{d.foo();} void R3::f()const{d.foo();} void R4::f()const{d.foo();} void R5::f()const{d.foo();} RO1::RO1(){d.data = 66;} RO2::RO2(){d.data = 77;} RO3::RO3(){d.data = 88;} RO4::RO4(){d.data = 99;} RO5::RO5(){d.data = 1010;} void RO1::f(){d.foo();} void RO2::f(){d.foo();} void RO3::f(){d.foo();} void RO4::f(){d.foo();} void RO5::f(){d.foo();} void RO1::f()const{d.foo();} void RO2::f()const{d.foo();} void RO3::f()const{d.foo();} void RO4::f()const{d.foo();} void RO5::f()const{d.foo();} void test_more() { Loki::Printf("\n\nMore tests:\n"); Loki::Printf("\nCreating Pimpls\n"); P1* p1 = new P1; P2* p2 = new P2; P3* p3 = new P3; P4* p4 = new P4; P5* p5 = new P5; PO1* p6 = new PO1; PO2* p7 = new PO2; PO3* p8 = new PO3; PO4* p9 = new PO4; PO5* p10 = new PO5; Loki::Printf("\nConst check\n"); p1->f(); p2->f(); p3->f(); p4->f(); p5->f(); p6->f(); p7->f(); p8->f(); p9->f(); p10->f(); Loki::Printf("\nDeleting Pimpls\n"); delete p1; delete p2; delete p3; delete p4; delete p5; delete p6; delete p7; delete p8; delete p9; delete p10; Loki::Printf("\nCreating Rimpls\n"); R1* r1 = new R1; R2* r2 = new R2; R3* r3 = new R3; R4* r4 = new R4; R5* r5 = new R5; RO1* r6 = new RO1; RO2* r7 = new RO2; RO3* r8 = new RO3; RO4* r9 = new RO4; RO5* r10 = new RO5; r1->f(); r2->f(); r3->f(); r4->f(); r5->f(); r6->f(); r7->f(); r8->f(); r9->f(); r10->f(); Loki::Printf("\nDeleting Rimpls\n"); delete r1; delete r2; delete r3; delete r4; delete r5; delete r6; delete r7; delete r8; delete r9; delete r10; Loki::Printf("\nCreating const Pimpls\n"); const P1* cp1 = new P1; const P2* cp2 = new P2; const P3* cp3 = new P3; const P4* cp4 = new P4; const P5* cp5 = new P5; const PO1* cp6 = new PO1; const PO2* cp7 = new PO2; const PO3* cp8 = new PO3; const PO4* cp9 = new PO4; const PO5* cp10 = new PO5; Loki::Printf("\nConst check\n"); cp1->f(); cp2->f(); cp3->f(); cp4->f(); cp5->f(); cp6->f(); cp7->f(); cp8->f(); cp9->f(); cp10->f(); Loki::Printf("\nDeleting const Pimpls\n"); delete cp1; delete cp2; delete cp3; delete cp4; delete cp5; delete cp6; delete cp7; delete cp8; delete cp9; delete cp10; } libloki-0.1.7.orig/test/Pimpl/Pimpl_MSVC_8.vcproj0000644000175000017500000000666611047143225020221 0ustar ivanivan libloki-0.1.7.orig/test/Pimpl/type2.h0000644000175000017500000000460210515240622016032 0ustar ivanivan//////////////////////////////////////////////////////////////////////////////// // The Loki Library // Copyright (c) 2006 Peter Kmmel // 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 makes no representations about the // suitability of this software for any purpose. It is provided "as is" // without express or implied warranty. //////////////////////////////////////////////////////////////////////////////// // $Id: type2.h 761 2006-10-17 20:48:18Z syntheticpp $ #include ///////////////////////////////////////// // class A2 declaration ///////////////////////////////////////// template< class T> class Impl; class A2 { public: A2(); ~A2(); void foo(); private: PimplOf::Type d; }; ///////////////////////////////////////// // class B2 declaration ///////////////////////////////////////// class B2 : private PimplOf::Owner { public: B2(); ~B2(); void foo(); }; ///////////////////////////////////////// // class C2 declaration ///////////////////////////////////////// class C2 { public: C2(); ~C2(); void foo(); private: PimplOf::Type rint; RimplOf::Type d; }; ///////////////////////////////////////// // class D2 declaration ///////////////////////////////////////// class D2 : private RimplOf::Owner { public: D2(); ~D2(); void foo(); }; ///////////////////////////////////////// // incomplete type test ///////////////////////////////////////// class Incomplete1 { public: Incomplete1(); void foo(); private: PimplOf::Type d; }; class Incomplete2 { public: Incomplete2(); ~Incomplete2(); void foo(); private: PimplOf::Type d; }; // Test: don't compile with inline destructor #if 0 class Incomplete3 { public: Incomplete3(); ~Incomplete3() { // inline destructor } void foo(); private: PimplOf::Type d; }; #endif // Test: don't compile with incomplete type and auto_ptr #include class Impl4; class Incomplete4 { public: Incomplete4(); void foo(); private: Pimpl > d; }; libloki-0.1.7.orig/test/Pimpl/type.h0000644000175000017500000001025310515237275015761 0ustar ivanivan//////////////////////////////////////////////////////////////////////////////// // The Loki Library // Copyright (c) 2006 Peter Kmmel // 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 makes no representations about the // suitability of this software for any purpose. It is provided "as is" // without express or implied warranty. //////////////////////////////////////////////////////////////////////////////// // $Id: type.h 760 2006-10-17 20:36:13Z syntheticpp $ #include //#define TEST_WITH_BOOST #ifdef TEST_WITH_BOOST #include #endif #include #include using namespace Loki; ///////////////////////////////////////// // class A declaration ///////////////////////////////////////// class A { public: A(); void foo(); private: PimplOf::Type d; }; ///////////////////////////////////////// // class B declaration ///////////////////////////////////////// class B : private PimplOf::Owner { public: B(); void foo(); }; ///////////////////////////////////////// // class C declaration ///////////////////////////////////////// class C { public: C(); void foo(); private: PimplOf::Type p; RimplOf::Type d; }; ///////////////////////////////////////// // class D declaration ///////////////////////////////////////// class D : private RimplOf::Owner { public: D(); void foo(); }; //////////////////// // more test code //////////////////// struct E; typedef SmartPtr > LokiPtr; typedef ConstPropPtr > CPropPtr; typedef std::auto_ptr > StdAutoPtr; #ifdef TEST_WITH_BOOST typedef boost::shared_ptr > BoostPtr; #else typedef LokiPtr BoostPtr; #endif // Pimpl typedef Pimpl > Pimpl1; typedef Pimpl, CPropPtr> Pimpl2; typedef Pimpl, LokiPtr> Pimpl3; typedef Pimpl, BoostPtr> Pimpl4; typedef Pimpl, StdAutoPtr> Pimpl5; struct P1 {Pimpl1 d; P1();void f();void f()const;}; struct P2 {Pimpl2 d; P2();void f();void f()const;}; struct P3 {Pimpl3 d; P3();void f();void f()const;}; struct P4 {Pimpl4 d; P4();void f();void f()const;}; struct P5 {Pimpl5 d; P5();void f();void f()const;}; // PimplOwner typedef PimplOwner > PimplOwner1; typedef PimplOwner, CPropPtr> PimplOwner2; typedef PimplOwner, LokiPtr> PimplOwner3; typedef PimplOwner, BoostPtr> PimplOwner4; typedef PimplOwner, StdAutoPtr> PimplOwner5; struct PO1 : private PimplOwner1 {PO1();void f();void f()const;}; struct PO2 : private PimplOwner2 {PO2();void f();void f()const;}; struct PO3 : private PimplOwner3 {PO3();void f();void f()const;}; struct PO4 : private PimplOwner4 {PO4();void f();void f()const;}; struct PO5 : private PimplOwner5 {PO5();void f();void f()const;}; // Rimpl typedef RimplOf Rimpl1; typedef RimplOf Rimpl2; typedef RimplOf Rimpl3; typedef RimplOf Rimpl4; typedef RimplOf Rimpl5; struct R1 {Pimpl1 p; Rimpl1::Type d; R1();void f();void f()const;}; struct R2 {Pimpl2 p; Rimpl2::Type d; R2();void f();void f()const;}; struct R3 {Pimpl3 p; Rimpl3::Type d; R3();void f();void f()const;}; struct R4 {Pimpl4 p; Rimpl4::Type d; R4();void f();void f()const;}; struct R5 {Pimpl5 p; Rimpl5::Type d; R5();void f();void f()const;}; // RimplOwner typedef RimplOf::Owner RimplO1; typedef RimplOf::Owner RimplO2; typedef RimplOf::Owner RimplO3; typedef RimplOf::Owner RimplO4; typedef RimplOf::Owner RimplO5; struct RO1 : private RimplO1 {RO1();void f();void f()const;}; struct RO2 : private RimplO2 {RO2();void f();void f()const;}; struct RO3 : private RimplO3 {RO3();void f();void f()const;}; struct RO4 : private RimplO4 {RO4();void f();void f()const;}; struct RO5 : private RimplO5 {RO5();void f();void f()const;}; libloki-0.1.7.orig/test/Pimpl/Pimpl.cbp0000644000175000017500000000256311047143225016373 0ustar ivanivan libloki-0.1.7.orig/test/Makefile.common0000644000175000017500000000025510515234750016471 0ustar ivanivaninclude ../../Makefile.common override CPPFLAGS += -I../../include -DNDEBUG LDLIBS := ../../lib/libloki.a ifeq ($(OS),Windows) BIN_SUFFIX := .exe else BIN_SUFFIX := endif libloki-0.1.7.orig/test/Checker/0000755000175000017500000000000011140365040015074 5ustar ivanivanlibloki-0.1.7.orig/test/Checker/Checker_MSVC_9.vcproj0000644000175000017500000000701111047143225020751 0ustar ivanivan libloki-0.1.7.orig/test/Checker/main.cpp0000644000175000017500000003267711072564652016561 0ustar ivanivan//////////////////////////////////////////////////////////////////////////////// // // Test program for The Loki Library // Copyright (c) 2008 Richard Sposato // The copyright on this file is protected under the terms of the MIT license. // // 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 makes no representations about the suitability of this software // for any purpose. It is provided "as is" without express or implied warranty. // //////////////////////////////////////////////////////////////////////////////// // $Id$ /// @file main.cpp This provides examples on how to use Loki's Checker facility. // ---------------------------------------------------------------------------- #include "../../include/loki/Checker.h" #include #include #include #if !defined( nullptr ) #define nullptr NULL #endif #if !defined( NULL ) #define NULL 0 #endif using namespace std; // ---------------------------------------------------------------------------- /* This class has 2 invariants. The this pointer may never equal NULL, and the value may not equal zero. */ class Thingy { public: static void ChangeThat( void ); static unsigned int GetThat( void ); explicit Thingy( unsigned int value ); Thingy( const Thingy & that ); Thingy & operator = ( const Thingy & that ); ~Thingy( void ); void Swap( Thingy & that ); bool operator == ( const Thingy & that ) const; void DoSomethingEvil( void ); unsigned int GetValue( void ) const; unsigned int DoSomething( bool doThrow ) const; void DoSomethingElse( void ) const; void AddCount( unsigned int count ); unsigned int GetCount( unsigned int index ) const; void ClearCounts( void ); private: /// This is a static validator. static bool StaticIsValid( void ); /// This is a per-instance validator. bool IsValid( void ) const; /// This can be used to validate pre-conditions and post-conditions. bool IsValidEmpty( void ) const; /// This can be used to validate pre-conditions and post-conditions. bool IsValidFull( void ) const; // These lines show how to declare checkers for non-static functions in a host class. typedef ::Loki::ContractChecker< Thingy, ::Loki::CheckForNoThrow > CheckForNoThrow; typedef ::Loki::ContractChecker< Thingy, ::Loki::CheckForNoChangeOrThrow > CheckForNoChangeOrThrow; typedef ::Loki::ContractChecker< Thingy, ::Loki::CheckForNoChange > CheckForNoChange; typedef ::Loki::ContractChecker< Thingy, ::Loki::CheckForEquality > CheckForEquality; typedef ::Loki::ContractChecker< Thingy, ::Loki::CheckForNothing > CheckInvariants; // These lines show how to declare checkers for static functions of a host class. typedef ::Loki::StaticChecker< ::Loki::CheckStaticForNoThrow > CheckStaticForNoThrow; typedef ::Loki::StaticChecker< ::Loki::CheckStaticForNothing > CheckStaticInvariants; typedef ::std::vector< unsigned int > IntBlock; static unsigned int s_value; unsigned int m_value; IntBlock m_counts; }; unsigned int Thingy::s_value = 10; // ---------------------------------------------------------------------------- // This example shows how static functions can use a no-throw checkers. void Thingy::ChangeThat( void ) { CheckStaticForNoThrow checker( &Thingy::StaticIsValid ); (void)checker; s_value--; } // ---------------------------------------------------------------------------- // This example shows how static functions can use an invariant checker. unsigned int Thingy::GetThat( void ) { CheckStaticInvariants checker( &Thingy::StaticIsValid ); (void)checker; return s_value; } // ---------------------------------------------------------------------------- // This example shows how ctors can use an invariant checker. Thingy::Thingy( unsigned int value ) : m_value( value ), m_counts() { CheckInvariants checker( this, &Thingy::IsValid ); (void)checker; } // ---------------------------------------------------------------------------- Thingy::Thingy( const Thingy & that ) : m_value( that.m_value ), m_counts( that.m_counts ) { CheckInvariants checker( this, &Thingy::IsValid ); (void)checker; } // ---------------------------------------------------------------------------- Thingy & Thingy::operator = ( const Thingy & that ) { CheckInvariants checker( this, &Thingy::IsValid ); (void)checker; if ( &that != this ) { Thingy temp( that ); temp.Swap( *this ); } return *this; } // ---------------------------------------------------------------------------- // A destructor really doesn't need a checker, but does need to confirm // the object is valid at the start of the destructor. Thingy::~Thingy( void ) { assert( IsValid() ); } // ---------------------------------------------------------------------------- // A swap function gets 2 checkers - one for this, and another for that. void Thingy::Swap( Thingy & that ) { CheckInvariants checker1( this, &Thingy::IsValid ); (void)checker1; CheckInvariants checker2( &that, &Thingy::IsValid ); (void)checker2; const IntBlock counts( m_counts ); m_counts = that.m_counts; that.m_counts = counts; const unsigned int value = m_value; m_value = that.m_value; that.m_value = value; } // ---------------------------------------------------------------------------- bool Thingy::operator == ( const Thingy & that ) const { return ( m_value == that.m_value ); } // ---------------------------------------------------------------------------- void Thingy::DoSomethingEvil( void ) { m_value = 0; } // ---------------------------------------------------------------------------- // This example shows how to use the no-throw checker. unsigned int Thingy::GetValue( void ) const { CheckForNoThrow checker( this, &Thingy::IsValid ); (void)checker; return m_value; } // ---------------------------------------------------------------------------- // This example shows how to use the equality checker. unsigned int Thingy::DoSomething( bool doThrow ) const { CheckForEquality checker( this, &Thingy::IsValid ); (void)checker; if ( doThrow ) throw ::std::logic_error( "Test Exception." ); return m_value; } // ---------------------------------------------------------------------------- // This example shows how to use the no-change checker. void Thingy::DoSomethingElse( void ) const { CheckForNoChange checker( this, &Thingy::IsValid ); (void)checker; } // ---------------------------------------------------------------------------- void Thingy::AddCount( unsigned int count ) { // This function's checker cares about class invariants and post-conditions, // but does not need to check pre-conditions, so it passes in a nullptr for // the pre-condition validator. Ths post-condition validator just makes sure // the container has at least 1 element. CheckInvariants checker( this, &Thingy::IsValid, nullptr, &Thingy::IsValidFull ); m_counts.push_back( count ); } // ---------------------------------------------------------------------------- unsigned int Thingy::GetCount( unsigned int index ) const { // This function's checker cares about class invariants and both the pre- and // post-conditions, so it passes in pointers for all 3 validators. The pre- // and post-conditions are both about making sure the container is not empty. CheckForNoChangeOrThrow checker( this, &Thingy::IsValid, &Thingy::IsValidFull, &Thingy::IsValidFull ); if ( m_counts.size() <= index ) return 0; const unsigned int count = m_counts[ index ]; return count; } // ---------------------------------------------------------------------------- void Thingy::ClearCounts( void ) { // This function's checker cares about class invariants and post-conditions, // but does not need to check pre-conditions, so it passes in a nullptr for // the pre-condition validator. Ths post-condition validator just makes sure // the container has no elements. CheckForNoThrow checker( this, &Thingy::IsValid, nullptr, &Thingy::IsValidEmpty ); m_counts.clear(); } // ---------------------------------------------------------------------------- // This is a static validator. bool Thingy::StaticIsValid( void ) { assert( s_value != 0 ); return true; } // ---------------------------------------------------------------------------- // This is a per-instance validator. bool Thingy::IsValid( void ) const { assert( nullptr != this ); assert( m_value != 0 ); return true; } // ---------------------------------------------------------------------------- bool Thingy::IsValidEmpty( void ) const { assert( nullptr != this ); assert( m_counts.size() == 0 ); return true; } // ---------------------------------------------------------------------------- bool Thingy::IsValidFull( void ) const { assert( nullptr != this ); assert( m_counts.size() != 0 ); return true; } // ---------------------------------------------------------------------------- // This is a validator function called by checkers inside standalone functions. bool AllIsValid( void ) { assert( Thingy::GetThat() != 0 ); return true; } // ---------------------------------------------------------------------------- // These lines show how to declare checkers for standalone functions. typedef ::Loki::StaticChecker< ::Loki::CheckStaticForNoThrow > CheckStaticForNoThrow; typedef ::Loki::StaticChecker< ::Loki::CheckStaticForNothing > CheckStaticInvariants; // ---------------------------------------------------------------------------- void DoSomething( void ) { // This example shows how to use a checker in a stand-alone function. CheckStaticForNoThrow checker( &AllIsValid ); (void)checker; Thingy::ChangeThat(); } // ---------------------------------------------------------------------------- void ThrowTest( void ) { Thingy thingy( 10 ); throw ::std::logic_error( "Will Thingy assert during an exception?" ); } // ---------------------------------------------------------------------------- int main( unsigned int argc, const char * const argv[] ) { try { cout << "Just before call to ThrowTest." << endl; ThrowTest(); cout << "Just after call to ThrowTest." << endl; } catch ( const ::std::logic_error & ex ) { cout << "Caught an exception! " << ex.what() << endl; } catch ( const ::std::exception & ex ) { cout << "Caught an exception! " << ex.what() << endl; } catch ( ... ) { cout << "Caught an exception!" << endl; } unsigned int count = 0; try { cout << "Running basic tests with Thingy." << endl; // First do some tests on class member functions. Thingy t1( 1 ); t1.DoSomething( false ); Thingy t2( 2 ); t2.DoSomething( true ); cout << "Done with basic tests with Thingy." << endl; } catch ( const ::std::logic_error & ex ) { cout << "Caught an exception! " << ex.what() << endl; } catch ( const ::std::exception & ex ) { cout << "Caught an exception! " << ex.what() << endl; } catch ( ... ) { cout << "Caught an exception!" << endl; } try { Thingy t1( 1 ); cout << "Now running tests with Thingy counts." << endl; // These lines will exercise the functions with pre- and post-conditions. t1.AddCount( 11 ); t1.AddCount( 13 ); t1.AddCount( 17 ); t1.AddCount( 19 ); count = t1.GetCount( 3 ); assert( count == 19 ); count = t1.GetCount( 0 ); assert( count == 11 ); t1.ClearCounts(); cout << "Done with tests with Thingy counts." << endl; } catch ( const ::std::logic_error & ex ) { cout << "Caught an exception! " << ex.what() << endl; } catch ( const ::std::exception & ex ) { cout << "Caught an exception! " << ex.what() << endl; } catch ( ... ) { cout << "Caught an exception!" << endl; } try { cout << "Now run tests on static member functions" << endl; // Next do some tests with static member functions. Thingy::ChangeThat(); const unsigned int value = Thingy::GetThat(); assert( value != 0 ); cout << "Done with tests on static member functions" << endl; } catch ( const ::std::logic_error & ex ) { cout << "Caught an exception! " << ex.what() << endl; } catch ( const ::std::exception & ex ) { cout << "Caught an exception! " << ex.what() << endl; } catch ( ... ) { cout << "Caught an exception!" << endl; } try { cout << "Now run test on a standalone function." << endl; // Then do a test with a standalone function. DoSomething(); cout << "Done with test on a standalone function." << endl; } catch ( const ::std::exception & ex ) { cout << "Caught an exception! " << ex.what() << endl; } catch ( ... ) { cout << "Caught an exception!" << endl; } cout << "All done!" << endl; return 0; } // ---------------------------------------------------------------------------- libloki-0.1.7.orig/test/Checker/Checker.vcproj0000644000175000017500000000610111140364657017700 0ustar ivanivan libloki-0.1.7.orig/test/Checker/Checker.cbp0000644000175000017500000000226611047143225017141 0ustar ivanivan libloki-0.1.7.orig/test/make.msvc.bat0000644000175000017500000000131710515234750016116 0ustar ivanivan cd CachedFactory call make.msvc.bat cd .. cd DeletableSingleton call make.msvc.bat cd .. cd Factory call make.msvc.bat cd .. cd Function call make.msvc.bat cd .. cd LockingPtr call make.msvc.bat cd .. cd Longevity call make.msvc.bat cd .. cd OrderedStatic call make.msvc.bat cd .. cd Pimpl call make.msvc.bat cd .. cd Register call make.msvc.bat cd .. cd RegressionTest call make.msvc.bat cd .. cd SafeFormat call make.msvc.bat cd .. cd ScopeGuard call make.msvc.bat cd .. cd Singleton call make.msvc.bat cd .. cd SingletonDll call make.msvc.bat cd .. cd SmallObj call make.msvc.bat cd .. cd SmartPtr call make.msvc.bat cd .. cd Visitor call make.msvc.bat cd .. cd flex_string call make.msvc.bat cd ..libloki-0.1.7.orig/test/CachedFactory/0000755000175000017500000000000011140365037016235 5ustar ivanivanlibloki-0.1.7.orig/test/CachedFactory/CachedFactoryTest.cpp0000644000175000017500000004032611047147137022312 0ustar ivanivan//////////////////////////////////////////////////////////////////////////////// // The Loki Library // Copyright (c) 2006 by Guillaume Chatelet // // Code covered by the MIT License // // 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 authors make no representations about the suitability of this software // for any purpose. It is provided "as is" without express or implied warranty. // // This code DOES NOT accompany the book: // Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design // Patterns Applied". Copyright (c) 2001. Addison-Wesley. // //////////////////////////////////////////////////////////////////////////////// // $Id: CachedFactoryTest.cpp 897 2008-08-08 22:53:19Z syntheticpp $ #define USE_SEQUENCE #include #include #include #include #ifdef LOKI_DISABLE_TYPELIST_MACROS #define USE_WQUENCE #endif #ifdef USE_SEQUENCE #include #endif #include typedef long milliSec; #if defined(_WIN32) && !defined(__CYGWIN__) #include milliSec getmilliSeconds() { return clock()*1000/CLOCKS_PER_SEC; } #else #include void Sleep(unsigned int t) { usleep( 1000 * static_cast(t));} /** * Returns the number of milliseconds elapsed from the epoch. * This counter might overrun and come back to 0. * This might give a false result in the following tests. */ #include milliSec getmilliSeconds() { struct timeval time; time.tv_usec = 0; time.tv_sec = 0; gettimeofday(&time, NULL); return milliSec(time.tv_usec/1000+time.tv_sec*1000); } #endif using std::cout; using std::cerr; using std::endl; using std::vector; using namespace Loki; class AbstractProduct{ public: virtual ~AbstractProduct(){} }; class Product : public AbstractProduct { public: Product(){} Product( int, int ){} }; class CostlyProduct : public AbstractProduct { public: CostlyProduct(){Sleep(100);} CostlyProduct( int, int ){Sleep(100);} }; class DebugProduct : public AbstractProduct { public: DebugProduct() { cout << "Product Ctor()" << endl; } DebugProduct( int, int ) { cout << "Product Ctor(int, int)" << endl; } ~DebugProduct() { cout << "Product Dtor()" << endl; } }; CostlyProduct* createCostlyProductNull() { return new CostlyProduct; } DebugProduct* createDebugProductNull() { return new DebugProduct; } Product* createProductNull() { return new Product; } Product* createProductInt(int a, int b) { return new Product(a,b); } const int nullID(0); const int intID(1); bool dispResult(const char* message, bool result) { cout << "## " << message << (result?" ...OK":" ...Failed !") << endl; return result; } template bool unitTestCacheOverhead(int loop){ milliSec start(0), elapsedNoCache(0), elapsedCache(0); start = getmilliSeconds(); for(int i=0;i(elapsedCache-elapsedNoCache)) / CLOCKS_PER_SEC * 1000 / loop) << " ms" << endl; return true; } void testCacheOverhead(){ const int loop(1000000); cout << "Starting cache overhead test with " << loop << " loops" << endl; typedef CachedFactory< AbstractProduct, int, NullType, SimplePointer, AmountLimitedCreation, EvictRandom > CRandomEvict; typedef CachedFactory< AbstractProduct, int, NullType, SimplePointer, AmountLimitedCreation, EvictLRU > CLRUEvict; typedef CachedFactory< AbstractProduct, int, NullType, SimplePointer, AmountLimitedCreation, EvictAging > CAgingEvict; bool test1 = dispResult("Random policy", unitTestCacheOverhead< CRandomEvict >(loop));(void)test1; bool test2 = dispResult("LRU policy", unitTestCacheOverhead< CLRUEvict >(loop));(void)test2; bool test3 = dispResult("Aging policy", unitTestCacheOverhead< CAgingEvict >(loop));(void)test3; } void unitTestCachePerformance(int loop){ typedef CachedFactory< AbstractProduct, int > CCache; milliSec start(0), elapsedNoCache(0), elapsedCache(0); start = getmilliSeconds(); for(int i=0;i " << i << " iterations" << endl; unitTestCachePerformance(i); } } template< class Cache > milliSec typicalUse( Cache &CC, unsigned objectKind, unsigned maxObjectCount, unsigned maxIteration) { assert(objectKind>0); assert(maxIteration>0); assert(maxObjectCount>0); vector< AbstractProduct* > fetched; fetched.reserve(maxObjectCount); srand(0); // initialise the pseudo random operator milliSec start(0); milliSec end(0); try{ // Registering objects for(size_t i=0;i::iterator itr = fetched.begin(); itr!=fetched.end(); itr++) CC.ReleaseObject(*itr); fetched.clear(); return end-start; } template< class Cache > void displayTypicalUse(Cache &CC, unsigned objectKind, unsigned maxObjectCount, unsigned maxIteration) { CC.displayCacheType(); cout << "====> " << typicalUse(CC, objectKind, maxObjectCount, maxIteration) << " ms" << endl; } void testTypicalUse() { const unsigned objectKind(10); const unsigned maxObjectCount(300); const unsigned maxIteration(1000000); cout << "# " << objectKind << " objects registered in the Factory" << endl; cout << "# Cache contains max " << maxObjectCount << " objects" << endl; cout << "# Test performs "<< maxIteration <<" iterations" << endl; { typedef CachedFactory< AbstractProduct, int, NullType, SimplePointer, AlwaysCreate, EvictRandom, SimpleStatisticPolicy > CRandomEvict; CRandomEvict cache; displayTypicalUse( cache, objectKind, maxObjectCount, maxIteration); } { typedef CachedFactory< AbstractProduct, int, NullType, SimplePointer, AlwaysCreate, EvictLRU, SimpleStatisticPolicy > CLRUEvict; CLRUEvict cache; displayTypicalUse( cache, objectKind, maxObjectCount, maxIteration); } { typedef CachedFactory< AbstractProduct, int, NullType, SimplePointer, AlwaysCreate, EvictAging, SimpleStatisticPolicy > CAgingEvict; CAgingEvict cache; displayTypicalUse( cache, objectKind, maxObjectCount, maxIteration); } } template< class Cache > bool testEvictionError() { bool testPassed = false; Cache CC; CC.Register(nullID, createProductNull); CC.setMaxCreation(1); AbstractProduct *pProduct1 = NULL, *pProduct2 = NULL; try{ pProduct1 = CC.CreateObject(nullID); // should be OK pProduct2 = CC.CreateObject(nullID); // should cast an exception } catch(std::exception &e){ if(strcmp(e.what(), EvictionException().what())==0) testPassed = true; } if(pProduct1!=NULL) CC.ReleaseObject(pProduct1); if(pProduct2!=NULL) CC.ReleaseObject(pProduct2); return testPassed; } bool testAllEvictionError() { typedef CachedFactory< AbstractProduct, int, NullType, SimplePointer, AmountLimitedCreation, EvictRandom > CRandomEvict; typedef CachedFactory< AbstractProduct, int, NullType, SimplePointer, AmountLimitedCreation, EvictLRU > CLRUEvict; typedef CachedFactory< AbstractProduct, int, NullType, SimplePointer, AmountLimitedCreation, EvictAging > CAgingEvict; bool test1 = dispResult("Random policy", testEvictionError< CRandomEvict >()); bool test2 = dispResult("LRU policy", testEvictionError< CLRUEvict >()); bool test3 = dispResult("Aging policy", testEvictionError< CAgingEvict >()); return test1 && test2 && test3; } bool testAmountLimitedCreation() { typedef CachedFactory< AbstractProduct, int, NullType, SimplePointer, AmountLimitedCreation, EvictRandom, SimpleStatisticPolicy > CCache; CCache CC; CC.Register(nullID, createDebugProductNull); CC.Register(intID, createDebugProductNull); // CC.setMaxCreation(0); <== would break on assert, such a cache is useless CC.setMaxCreation(1); AbstractProduct *pProduct1 = NULL, *pProduct2 = NULL; pProduct1 = CC.CreateObject(nullID); // should be OK CC.ReleaseObject(pProduct1); pProduct2 = CC.CreateObject(intID); // should call the evict method if(pProduct1!=NULL) CC.ReleaseObject(pProduct1); if(pProduct2!=NULL) CC.ReleaseObject(pProduct2); return (CC.getDestroyed()==1); } bool testRateLimitedFetchPolicy(bool waitBetweenFetch) { typedef CachedFactory< AbstractProduct, int, NullType, SimplePointer, RateLimitedCreation > CCache; CCache CC; CC.Register(nullID, createProductNull); CC.setRate(2/*max two fetchs*/,100/*within 100 ms*/); bool exceptionOccured = false; const int number(5); const int sleepTime(70); AbstractProduct *products[number]; for(int i=0;i Setting rate limit to 2 fetch within 100 ms." << endl; cout << " || => generating 5 objects " << endl; bool test1 = dispResult("Fast creation", testRateLimitedFetchPolicy(false)==true); cout << " || => generating 5 objects with 70ms between each Fetch" << endl; bool test2 = dispResult("Slow creation", testRateLimitedFetchPolicy(true)==false); return test1 && test2; } bool testRelease(){ typedef CachedFactory< AbstractProduct, int > CCache; CCache CC; CC.Register(nullID, createProductNull); AbstractProduct *pProduct = NULL; CC.ReleaseObject(pProduct); cout << "Caching failed" << endl; return false; } bool testCache() { typedef CachedFactory< AbstractProduct, int, Seq< int, int > > CCache2Parm; CCache2Parm CC2; CC2.Register(intID, createProductInt); AbstractProduct * pProduct = CC2.CreateObject(intID,5,3); AbstractProduct * pSave(pProduct); CC2.ReleaseObject(pProduct); pProduct = CC2.CreateObject(intID,5,3); if(pSave != pProduct) { cout << "Caching failed" << endl; return false; } else { CC2.ReleaseObject(pProduct); return true; } } #include template class SmartPointer_OneTArg : public SmartPointer { }; bool testSmartPointer() { typedef CachedFactory< AbstractProduct, int, NullType, SmartPointer_OneTArg, AlwaysCreate, EvictRandom, SimpleStatisticPolicy > CFactory; CFactory factory; factory.Register(0, createProductNull); for(int i=0;i<500;++i) { CFactory::ProductReturn ptr(factory.CreateObject(0)); CFactory::ProductReturn ptr2(ptr); // check that copying the SP won't release the object twice } // all object should have been returned to the factory bool outOk = factory.getOut()==0; // one object allocater bool allocOk = factory.getAllocated()==1; // one missed, the first one bool missedOk = factory.getMissed()==1; // 500 fetched bool fetchedOk = factory.getFetched()==500; // 499 hit bool hitOk = factory.getHit()==499; return outOk && allocOk && missedOk && fetchedOk && hitOk; } void dispText(const char* text) { cout << endl; cout << "##========================================"<< endl; cout << "## " << text << endl; cout << "##========================================"<< endl; } void dispText(const char* text, const char* comment) { cout << endl; cout << "##========================================"<< endl; cout << "## " << text << endl; cout << "## " << comment << endl; cout << "##========================================"<< endl; } void separator() { cout << endl << endl; } void performanceTests() { dispText(" ==> Performance tests <=="); separator(); dispText("Test typical use", "tries different Cache strategies in a typical use configuration"); testTypicalUse(); separator(); dispText("Test efficiency","Comparison between generating costly objects (100ms) and using Cache"); testCachePerformance(); separator(); dispText("Test overhead","Intensive use of Cache to determine the cache time overhead"); testCacheOverhead(); separator(); } void reliabilityTests() { dispText(" ==> Reliability tests <=="); separator(); dispText("Test caching", "Trying to Create, Release, Create and see if Cache gives the same object"); bool cacheResult= dispResult("caching result", testCache()); separator(); dispText("Test RateLimitedFetch policy", "Trying to quickly create objects, then same scenario with pause in between"); bool rateLimitedResult= dispResult("RateLimitedFetch policy result",fullTestRateLimitedFetchPolicy()); separator(); dispText("Test AmountLimitedCreation policy","Trying to create 2 objects with a limit of 1 creation max, you should see a destroyed object (eviction)"); bool amountLimitedResult = dispResult("AmountLimitedCreation policy result", testAmountLimitedCreation()); separator(); dispText("Test eviction error", "An eviction should occur (Creation Policy), but all object are in use"); bool evictionTest = dispResult("eviction error test result", testAllEvictionError()); separator(); dispText("Smart pointer", "The factory provides smart pointers, when pointers go out of scope, the object returns to Cache"); bool spTest = dispResult("Smart Pointer test result", testSmartPointer()); separator(); if(cacheResult&&rateLimitedResult&&amountLimitedResult&&evictionTest&&spTest) dispText("All tests passed successfully"); else dispText("One or more test have failed"); } int main(int , char **) { try{ performanceTests(); reliabilityTests(); }catch(std::exception &e){ cerr << e.what() << endl; cerr << "Error while performing tests" << endl; } } // TODO provide : // +Efficiency tests // +Overhead tests // +Fiability tests libloki-0.1.7.orig/test/CachedFactory/Makefile0000644000175000017500000000042410515234750017677 0ustar ivanivaninclude ../Makefile.common BIN := CachedFactoryTest$(BIN_SUFFIX) SRC := CachedFactoryTest.cpp OBJ := $(SRC:.cpp=.o) .PHONY: all clean all: $(BIN) clean: cleandeps $(RM) $(BIN) $(RM) $(OBJ) $(BIN): $(OBJ) $(CXX) $(LDFLAGS) -o $@ $^ $(LDLIBS) include ../../Makefile.deps libloki-0.1.7.orig/test/CachedFactory/CachedFactory.cbp0000644000175000017500000000253511047143225021426 0ustar ivanivan libloki-0.1.7.orig/test/CachedFactory/CachedFactory.dev0000644000175000017500000000264710515234750021447 0ustar ivanivan[Project] FileName=CachedFactory.dev Name=Factory UnitCount=5 Type=1 Ver=1 ObjFiles= Includes=..\..\include Libs= PrivateResource= ResourceIncludes= MakeIncludes= Compiler= CppCompiler=-D DEBUG_@@_-D _DEBUG_@@_-Wall -pedantic_@@_ Linker= IsCpp=1 Icon= ExeOutput= ObjectOutput= OverrideOutput=0 OverrideOutputName=CachedFactoryTest.exe HostApplication= Folders= CommandLine= UseCustomMakefile=0 CustomMakefile=Makefile.loki IncludeVersionInfo=0 SupportXPThemes=0 CompilerSet=0 CompilerSettings=0000000000000001000000 [VersionInfo] Major=0 Minor=1 Release=1 Build=1 LanguageID=1033 CharsetID=1252 CompanyName= FileVersion= FileDescription=Developed using the Dev-C++ IDE InternalName= LegalCopyright= LegalTrademarks= OriginalFilename= ProductName= ProductVersion= AutoIncBuildNr=0 [Unit1] FileName=CachedFactoryTest.cpp CompileCpp=1 Folder=CachedFactory Compile=1 Link=1 Priority=1000 OverrideBuildCmd=0 BuildCmd= [Unit2] FileName=..\..\src\SmallObj.cpp CompileCpp=1 Folder=Factory Compile=1 Link=1 Priority=1000 OverrideBuildCmd=0 BuildCmd= [Unit3] FileName=..\..\src\Singleton.cpp CompileCpp=1 Folder=Factory Compile=1 Link=1 Priority=1000 OverrideBuildCmd=0 BuildCmd= [Unit4] FileName=..\..\include\loki\Key.h CompileCpp=1 Folder=Factory Compile=1 Link=1 Priority=1000 OverrideBuildCmd=0 BuildCmd= [Unit5] FileName=..\..\include\loki\CachedFactory.h CompileCpp=1 Folder=Factory Compile=1 Link=1 Priority=1000 OverrideBuildCmd=0 BuildCmd= libloki-0.1.7.orig/test/CachedFactory/make.msvc.bat0000644000175000017500000000033610515234750020615 0ustar ivanivan cl -c -Zm200 -O2 -DNDEBUG -MT -EHsc -GR -W4 -wd4710 -I"." -I"..\..\include" CachedFactoryTest.cpp link /NOLOGO /SUBSYSTEM:CONSOLE /incremental:no /OUT:"main-msvc.exe" ..\..\lib\loki.lib CachedFactoryTest.obj del *.obj libloki-0.1.7.orig/test/CachedFactory/CachedFactory.vcproj0000644000175000017500000000701411041554660022165 0ustar ivanivan libloki-0.1.7.orig/test/CachedFactory/CachedFactory_MSVC_8.vcproj0000644000175000017500000000671311047143225023246 0ustar ivanivan libloki-0.1.7.orig/test/CachedFactory/CachedFactory_MSVC9.vcproj0000644000175000017500000001163211140364657023114 0ustar ivanivan libloki-0.1.7.orig/test/SmallObj/0000755000175000017500000000000011140365037015241 5ustar ivanivanlibloki-0.1.7.orig/test/SmallObj/Makefile0000644000175000017500000000101510515234750016700 0ustar ivanivaninclude ../Makefile.common BIN1 := SmallObjBench$(BIN_SUFFIX) SRC1 := SmallObjBench.cpp OBJ1 := $(SRC1:.cpp=.o) BIN2 := SmallObjSingleton$(BIN_SUFFIX) SRC2 := SmallObjSingleton.cpp OBJ2 := $(SRC2:.cpp=.o) CXXFLAGS := $(CXXWARNFLAGS) -g -fexpensive-optimizations -O3 .PHONY: all clean all: $(BIN1) $(BIN2) clean: cleandeps $(RM) $(BIN1) $(RM) $(OBJ1) $(RM) $(BIN2) $(RM) $(OBJ2) $(BIN1): $(OBJ1) $(CXX) $(LDFLAGS) -o $@ $^ $(LDLIBS) $(BIN2): $(OBJ2) $(CXX) $(LDFLAGS) -o $@ $^ $(LDLIBS) include ../../Makefile.deps libloki-0.1.7.orig/test/SmallObj/SmallObjSingleton.vcproj0000644000175000017500000001203311041561027022050 0ustar ivanivan libloki-0.1.7.orig/test/SmallObj/DefaultAlloc_MSVC_8.vcproj0000644000175000017500000000701611047143225022107 0ustar ivanivan libloki-0.1.7.orig/test/SmallObj/make.msvc.bat0000644000175000017500000000170110515234750017616 0ustar ivanivan@ECHO OFF echo - echo - Use make.msvc.bat dll to link with dynamic runtile library echo - if "%1"=="dll" ( set MTMD=MD set OUT_EXE=main-dll-msvc.exe echo - using dynamic library: /MD echo - ) else ( set MTMD=MT set OUT_EXE=main-msvc.exe echo - using static library: /MT echo - ) @ECHO ON :: SmallObjBench.cpp cl -c -DNDEBUG -Zm200 -O2 -%MTMD% -EHsc -GR -W4 -wd4710 -wd4100 -I"." -I"..\..\include" -I"..\..\include\loki" SmallObjBench.cpp :: ..\..\src\SmallObj.cpp ..\..\src\Singleton.cpp link /NOLOGO /SUBSYSTEM:CONSOLE /incremental:no /OUT:%OUT_EXE% SmallObjBench.obj ..\..\lib\loki.lib ::SmallObj.obj tmp\Singleton.obj :: SmallSingleton.cpp cl -c -DNDEBUG -Zm200 -O2 -%MTMD% -EHsc -GR -W4 -wd4710 -I"." -I"..\..\include" -I"..\..\include\loki" SmallObjSingleton.cpp link /NOLOGO /SUBSYSTEM:CONSOLE /incremental:no /OUT:SmallObjSingleton-msvc.exe ..\..\lib\loki.lib SmallObjSingleton.obj del *.obj @ECHO OFF set MTMD= set OUT_EXE= libloki-0.1.7.orig/test/SmallObj/SmallSingleton.dev0000644000175000017500000000324510515234750020702 0ustar ivanivan[Project] FileName=SmallSingleton.dev Name=SmallSingleton UnitCount=7 Type=1 Ver=1 ObjFiles= Includes=C:\Projects\loki\include\loki Libs= PrivateResource= ResourceIncludes= MakeIncludes= Compiler= CppCompiler= Linker= IsCpp=1 Icon= ExeOutput= ObjectOutput= OverrideOutput=0 OverrideOutputName=SmallSingleton.exe HostApplication= Folders= CommandLine= UseCustomMakefile=0 CustomMakefile= IncludeVersionInfo=0 SupportXPThemes=0 CompilerSet=0 CompilerSettings=0000001001001000000000 [Unit1] FileName=timer.h CompileCpp=1 Folder=SmallSingleton Compile=1 Link=1 Priority=1000 OverrideBuildCmd=0 BuildCmd= [Unit2] FileName=SmallSingleton.cpp CompileCpp=1 Folder=SmallSingleton Compile=1 Link=1 Priority=1000 OverrideBuildCmd=0 BuildCmd= [VersionInfo] Major=0 Minor=1 Release=1 Build=1 LanguageID=1033 CharsetID=1252 CompanyName= FileVersion= FileDescription=Developed using the Dev-C++ IDE InternalName= LegalCopyright= LegalTrademarks= OriginalFilename= ProductName= ProductVersion= AutoIncBuildNr=0 [Unit3] FileName=..\..\src\SmallObj.cpp CompileCpp=1 Folder=SmallSingleton Compile=1 Link=1 Priority=1000 OverrideBuildCmd=0 BuildCmd= [Unit4] FileName=..\..\src\Singleton.cpp CompileCpp=1 Folder=SmallSingleton Compile=1 Link=1 Priority=1000 OverrideBuildCmd=0 BuildCmd= [Unit5] FileName=..\..\include\loki\Threads.h CompileCpp=1 Folder=SmallSingleton Compile=1 Link=1 Priority=1000 OverrideBuildCmd=0 BuildCmd= [Unit6] FileName=..\..\include\loki\Singleton.h CompileCpp=1 Folder=SmallSingleton Compile=1 Link=1 Priority=1000 OverrideBuildCmd=0 BuildCmd= [Unit7] FileName=..\..\include\loki\SmallObj.h CompileCpp=1 Folder=SmallSingleton Compile=1 Link=1 Priority=1000 OverrideBuildCmd=0 BuildCmd= libloki-0.1.7.orig/test/SmallObj/timer.h0000644000175000017500000000323410620052610016524 0ustar ivanivan//////////////////////////////////////////////////////////////////////////////// // The Loki Library // Copyright (c) 2005 Peter Kmmel // 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 authors make no representations about the // suitability of this software for any purpose. It is provided "as is" // without express or implied warranty. //////////////////////////////////////////////////////////////////////////////// #ifndef LOKI_TEST_TIMER_H #define LOKI_TEST_TIMER_H // $Id: timer.h 823 2007-05-08 10:48:40Z lfittl $ #include #include #include #include class Timer { public: Timer() { t100 = 0; } void start() { t0 = clock(); } void stop() { t1 = clock(); } int t() { return t1-t0; } double sec(int t) { return floor(100.0*double(t)/1000.0 )/100.0; } int rel(int t) { return ( t100==0 ? 100 : static_cast(floor(100.0*t/t100+0.5)) ); } double speedup(int t) { double tup=t; return (tup!=0 ? floor(100.0*(t100!=0?t100:tup)/tup+0.5)/100 : 1); } double t100; void print(int t, const char* s) { std::cout << s << "\tseconds: " << sec(t) << "\trelative time: " << rel(t) << "%\tspeed-up factor: " << speedup(t) << "" << std::endl; } private: int t0; int t1; }; #endif libloki-0.1.7.orig/test/SmallObj/SmallObjSingleton.cpp0000644000175000017500000002465210515240622021341 0ustar ivanivan//////////////////////////////////////////////////////////////////////////////// // The Loki Library // Copyright (c) 2005 Richard Sposato // Copyright (c) 2005 Peter Kmmel // 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 authors make no representations about the // suitability of this software for any purpose. It is provided "as is" // without express or implied warranty. //////////////////////////////////////////////////////////////////////////////// // $Id: SmallObjSingleton.cpp 761 2006-10-17 20:48:18Z syntheticpp $ #include #include #include // define DO_EXTRA_LOKI_TESTS in src/SmallObj.cpp to get // a message when a SmallObject is created/deleted. using namespace std; // ---------------------------------------------------------------------------- // // LongevityLifetime Parent/Child policies // // ---------------------------------------------------------------------------- typedef Loki::SmallValueObject< LOKI_DEFAULT_THREADING_NO_OBJ_LEVEL, 512, 32, 4, Loki::LongevityLifetime::DieAsSmallObjectParent > SmallObjectParent; class SmallObjectChild : public SmallObjectParent { public: typedef Loki::SingletonHolder< SmallObjectChild, Loki::CreateUsingNew, Loki::LongevityLifetime::DieAsSmallObjectChild> MySmallSingleton; /// Returns reference to the singleton. inline static SmallObjectChild & Instance( void ) { return MySmallSingleton::Instance(); } SmallObjectChild( void ) { cout << "SmallObjectChild created" << endl; } ~SmallObjectChild( void ) { cout << "~SmallObjectChild" << endl; } void DoThat( void ) { cout << "SmallObjectChild::DoThat" << endl << endl; } private: char m_stuff[ 16 ]; }; // ---------------------------------------------------------------------------- // // SingletonWithLongevity policy // // ---------------------------------------------------------------------------- typedef Loki::SmallValueObject< LOKI_DEFAULT_THREADING_NO_OBJ_LEVEL, LOKI_DEFAULT_CHUNK_SIZE, LOKI_MAX_SMALL_OBJECT_SIZE, LOKI_DEFAULT_OBJECT_ALIGNMENT, Loki::SingletonWithLongevity > LongLivedObject; class LongLivedSingleton : public LongLivedObject { public: typedef Loki::SingletonHolder< LongLivedSingleton, Loki::CreateUsingNew, Loki::SingletonWithLongevity> MySmallSingleton; /// Returns reference to the singleton. inline static LongLivedSingleton & Instance( void ) { return MySmallSingleton::Instance(); } LongLivedSingleton( void ) { cout << "LongLivedSingleton created" << endl; } ~LongLivedSingleton( void ) { cout << "~LongLivedSingleton" << endl; } void DoThat( void ) { cout << "LongLivedSingleton::DoThat" << endl << endl; } private: char m_stuff[ 16 ]; }; inline unsigned int GetLongevity( LongLivedSingleton * ) { /// @note Must return a longevity level lower than the one in SmallObj.h. return 1; } #if !defined(_MSC_VER) || (_MSC_VER>=1400) // ---------------------------------------------------------------------------- // // FollowIntoDeath policy // // ---------------------------------------------------------------------------- typedef Loki::SmallValueObject< LOKI_DEFAULT_THREADING_NO_OBJ_LEVEL, LOKI_DEFAULT_CHUNK_SIZE, LOKI_MAX_SMALL_OBJECT_SIZE, LOKI_DEFAULT_OBJECT_ALIGNMENT, Loki::FollowIntoDeath::With::AsMasterLifetime > MasterObject; class FollowerSingleton : public MasterObject { public: typedef Loki::SingletonHolder< FollowerSingleton, Loki::CreateUsingNew, Loki::FollowIntoDeath::AfterMaster::IsDestroyed> MySmallSingleton; /// Returns reference to the singleton. inline static FollowerSingleton & Instance( void ) { return MySmallSingleton::Instance(); } FollowerSingleton( void ) { cout << "FollowerSingleton created" << endl; } ~FollowerSingleton( void ) { cout << "~FollowerSingleton" << endl; } void DoThat( void ) { cout << "FollowerSingleton::DoThat" << endl << endl; } private: char m_stuff[ 16 ]; }; #endif // ---------------------------------------------------------------------------- // // NoDestroy policy // // ---------------------------------------------------------------------------- typedef Loki::SmallValueObject< LOKI_DEFAULT_THREADING_NO_OBJ_LEVEL, LOKI_DEFAULT_CHUNK_SIZE, LOKI_MAX_SMALL_OBJECT_SIZE, LOKI_DEFAULT_OBJECT_ALIGNMENT, Loki::NoDestroy > ImmortalObject; class ImmortalSingleton : public ImmortalObject { public: typedef Loki::SingletonHolder< ImmortalSingleton, Loki::CreateUsingNew, Loki::NoDestroy> MySmallSingleton; /// Returns reference to the singleton. inline static ImmortalSingleton & Instance( void ) { return MySmallSingleton::Instance(); } ImmortalSingleton( void ) { cout << "ImmortalSingleton created" << endl; } ~ImmortalSingleton( void ) { cout << "~ImmortalSingleton destructor should never get called!" << endl; } void DoThat( void ) { cout << "ImmortalSingleton::DoThat" << endl << endl; } private: char m_stuff[ 16 ]; }; // ---------------------------------------------------------------------------- // // NoDestroy and SingletonWithLongevity policy combination // // ---------------------------------------------------------------------------- class MortalSingleton : public ImmortalObject { public: typedef Loki::SingletonHolder< MortalSingleton, Loki::CreateUsingNew, Loki::SingletonWithLongevity> MySmallSingleton; /// Returns reference to the singleton. inline static MortalSingleton & Instance( void ) { return MySmallSingleton::Instance(); } MortalSingleton( void ) { cout << "MortalSingleton created" << endl; } ~MortalSingleton( void ) { cout << "~MortalSingleton" << endl; } void DoThat( void ) { cout << "MortalSingleton::DoThat" << endl << endl; } private: char m_stuff[ 16 ]; }; inline unsigned int GetLongevity( MortalSingleton * ) { /// @note Must return a longevity level lower than the one in SmallObj.h. return 1; } // ---------------------------------------------------------------------------- // // detect memory leaks on MSVC Ide // // ---------------------------------------------------------------------------- //#define LOKI_MSVC_CHECK_FOR_MEMORY_LEAKS #ifdef LOKI_MSVC_CHECK_FOR_MEMORY_LEAKS #include #include void heap_debug() { int tmpFlag = _CrtSetDbgFlag( _CRTDBG_REPORT_FLAG ); // Turn on leak-checking bit tmpFlag |= _CRTDBG_LEAK_CHECK_DF; //tmpFlag |= _CRTDBG_CHECK_MasterLWMasterYS_DF; // Turn off CRT block checking bit tmpFlag &= ~_CRTDBG_CHECK_CRT_DF; // Set flag to the new value _CrtSetDbgFlag( tmpFlag ); } #else void heap_debug() {} #endif // ---------------------------------------------------------------------------- // // main // // ---------------------------------------------------------------------------- int main() { heap_debug(); cout << endl << "This program tests the lifetime policies for Loki's " << endl << "Small-Object Allocator and singleton objects that are derived " << endl << "from SmallObject or SmallValueObject." << endl << endl << "Use one of the following lifetime policies" << endl << "to manage the lifetime dependency:" << endl << endl << "- LongevityLifetime Parent/Child: SmallObject has" << endl << " LongevityLifetime::DieAsSmallObjectParent" << endl << " policy and the derived Singleton has " << endl << " LongevityLifetime::DieAsSmallObjectChild" << endl << " This is tested by the SmallObjectChild class." << endl << endl << "- Both SmallObject and derived Singleton use" << endl << " SingletonWithLongevity" << endl << " policy. This is tested by the LongLivedSingleton class." << endl << endl #if !defined(_MSC_VER) || (_MSC_VER>=1400) << "- FollowIntoDeath: SmallObject has" << endl << " FollowIntoDeath::With::AsMasterLiftime" << endl << " policy and the derived Singleton has " << endl << " FollowIntoDeath::AfterMaster::IsDestroyed" << endl << " policy. This is tested by the FollowerSingleton class." << endl << endl #endif << "- Both SmallObject and derived Singleton use" << endl << " NoDestroy" << endl << " policy. This is tested by the ImmortalSingleton class." << endl << " Note: yow will get memory leaks" << endl << endl << "- SmallObject has"<< endl << " NoDestroy" << endl << " policy but the derived Singleton has" << endl << " SingletonWithLongevity" << endl << " policy. This is tested by the MortalSingleton class." << endl << " Note: yow will get memory leaks" << endl << endl << endl << endl << "If this program executes without crashing or asserting" << endl << "at exit time, then all policies work." << endl << endl; SmallObjectChild::Instance().DoThat(); LongLivedSingleton::Instance().DoThat(); #if !defined(_MSC_VER) || (_MSC_VER>=1400) FollowerSingleton::Instance().DoThat(); #endif #define ENABLE_MEMORY_LEAK #ifdef ENABLE_MEMORY_LEAK ImmortalSingleton::Instance().DoThat(); MortalSingleton::Instance().DoThat(); #else cout << endl; cout << "ImmortalSingleton and MortalSingleton" << endl; cout << "are disabled due to the test on memory leaks."; cout << endl << endl; #endif #if defined(__BORLANDC__) || defined(_MSC_VER) system("PAUSE"); #endif cout << endl<< endl << "now leaving main" << endl; cout << "________________________________" << endl << endl; return 0; } // ---------------------------------------------------------------------------- libloki-0.1.7.orig/test/SmallObj/SmallObjBench.cpp0000644000175000017500000004160110620216142020404 0ustar ivanivan//////////////////////////////////////////////////////////////////////////////// // The Loki Library // Copyright (c) 2005 Peter Kmmel // Copyright (c) 2005 Richard Sposato // 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 authors make no representations about the // suitability of this software for any purpose. It is provided "as is" // without express or implied warranty. //////////////////////////////////////////////////////////////////////////////// // $Id: SmallObjBench.cpp 824 2007-05-09 00:57:06Z rich_sposato $ // ---------------------------------------------------------------------------- #define LOKI_SMALL_OBJECT_USE_NEW_ARRAY #ifndef LOKI_CLASS_LEVEL_THREADING #define LOKI_CLASS_LEVEL_THREADING #endif #include #include "timer.h" #include #include //#define COMPARE_BOOST_POOL #ifdef COMPARE_BOOST_POOL #include #endif using namespace std; // ---------------------------------------------------------------------------- template class ThisIsASmallObject { char data[N]; }; template struct Base : public ThisIsASmallObject, public T {}; template struct Base : public ThisIsASmallObject {}; // ---------------------------------------------------------------------------- #ifdef COMPARE_BOOST_POOL template class BoostPoolNew : public Base { private: static boost::object_pool< BoostPoolNew > BoostPool; public: /// Throwing single-object new throws bad_alloc when allocation fails. #ifdef _MSC_VER /// @note MSVC complains about non-empty exception specification lists. static void * operator new ( std::size_t ) #else static void * operator new ( std::size_t ) throw ( std::bad_alloc ) #endif { return BoostPool.malloc(); } /// Non-throwing single-object new returns NULL if allocation fails. static void * operator new ( std::size_t, const std::nothrow_t & ) throw () { return BoostPool.malloc(); } /// Placement single-object new merely calls global placement new. inline static void * operator new ( std::size_t size, void * place ) { return ::operator new( size, place ); } /// Single-object delete. static void operator delete ( void * p ) throw () { BoostPool.free( reinterpret_cast< BoostPoolNew * >( p ) ); } /** Non-throwing single-object delete is only called when nothrow new operator is used, and the constructor throws an exception. */ static void operator delete ( void * p, const std::nothrow_t & ) throw() { BoostPool.free( reinterpret_cast< BoostPoolNew * >( p ) ); } /// Placement single-object delete merely calls global placement delete. inline static void operator delete ( void * p, void * place ) { ::operator delete ( p, place ); } /** @note This class does not provide new [] and delete [] operators since the Boost.Pool allocator only works for memory requests of the same size. */ }; template boost::object_pool< BoostPoolNew > BoostPoolNew::BoostPool; #endif // ---------------------------------------------------------------------------- int array_test_nr = 0; double t100_new = 0; double t100_delete = 0; #define LOKI_SMALLOBJ_BENCH(FUNC, CODE_LOOP) \ template \ int FUNC(void**, const int N, int loop, Timer& t, const char* s) \ { \ t.start(); \ /****************************************************************/ \ for (int i=0; i \ int FUNC(void** arrv, const int N, int loop, Timer& t, const char* s) \ { \ \ CODE_DECL; \ T** arr = reinterpret_cast(arrv); \ t.start(); \ /****************************************************************/ \ for (int i=0; i st;st.deallocate(st.allocate(1), 1);) LOKI_SMALLOBJ_BENCH(delete_new_array ,delete[] new T[N];) LOKI_SMALLOBJ_BENCH(delete_new_array_mal,std::free(std::malloc(sizeof(T[TN])));) LOKI_SMALLOBJ_BENCH(delete_new_array_all,std::allocator st;st.deallocate(st.allocate(1), 1);) LOKI_SMALLOBJ_BENCH_ARRAY(new_del_on_arr , , arr[i] = new T; , delete arr[i];) LOKI_SMALLOBJ_BENCH_ARRAY(new_del_on_arr_mal, , arr[i] = static_cast(std::malloc(sizeof(T))); , std::free(arr[i]);) LOKI_SMALLOBJ_BENCH_ARRAY(new_del_on_arr_all, std::allocator st , arr[i]=st.allocate(1); , st.deallocate(arr[i], 1);) LOKI_SMALLOBJ_BENCH_ARRAY(new_del_a_on_a , , arr[i] = new T[TN]; , delete[] arr[i];) LOKI_SMALLOBJ_BENCH_ARRAY(new_del_a_on_a_mal, , arr[i] = static_cast(std::malloc(sizeof(T[TN]))); , std::free(arr[i]);) LOKI_SMALLOBJ_BENCH_ARRAY(new_del_a_on_a_all,std::allocator st , arr[i]=reinterpret_cast(st.allocate(1)); , st.deallocate(reinterpret_cast(arr[i]), 1);) // ---------------------------------------------------------------------------- #ifndef COMPARE_BOOST_POOL #define LOKI_SMALL_OBJECT_BENCH_ABCD(FUNC,N,LOOP,TIMER,MESSAGE) \ array_test_nr = 0; \ cout << MESSAGE << endl; \ FUNC(a,N,LOOP,TIMER,"new :"); \ FUNC(a,N,LOOP,TIMER,"SmallObj :"); \ FUNC(a,N,LOOP,TIMER,"ValueObj :"); \ FUNC##_all(a,N,LOOP,TIMER,"allocator:"); \ FUNC##_mal(a,N,LOOP,TIMER,"malloc :"); \ cout << endl << endl; #else #define LOKI_SMALL_OBJECT_BENCH_ABCD(FUNC,N,LOOP,TIMER,MESSAGE) \ array_test_nr = 0; \ cout << MESSAGE << endl; \ FUNC(a,N,LOOP,TIMER,"new :"); \ FUNC(a,N,LOOP,TIMER,"SmallObj :"); \ FUNC(a,N,LOOP,TIMER,"ValueObj :"); \ FUNC(a,N,LOOP,TIMER,"boost :"); \ FUNC##_all(a,N,LOOP,TIMER,"allocator:"); \ FUNC##_mal(a,N,LOOP,TIMER,"malloc :"); \ cout << endl << endl; #endif // ---------------------------------------------------------------------------- template< unsigned int Size, int loop, template class ThreadingModel, std::size_t chunkSize, std::size_t maxSmallObjectSize, std::size_t objectAlignSize, template class LifetimePolicy, class MutexPolicy > void testSize() { typedef Base A; typedef Base > B; typedef Base > C; typedef Loki::AllocatorSingleton< ThreadingModel, chunkSize, maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > AllocatorSingleton; #ifdef COMPARE_BOOST_POOL typedef BoostPoolNew D; #endif assert( (!AllocatorSingleton::IsCorrupted()) ); cout << endl << endl; cout << "Allocator Benchmark Tests with " << Size << " bytes big objects " << endl; cout << endl; cout << "new = global new/delete \tsizeof(A) = " << sizeof(A) << endl; cout << "SmallObj = Loki::SmallObject \tsizeof(B) = " << sizeof(B) << endl; cout << "ValueObj = Loki::SmallValueObject\tsizeof(C) = " << sizeof(C) << endl; #ifdef COMPARE_BOOST_POOL cout << "boost = boost::object_pool \tsizeof(D) = " << sizeof(D) << endl; #endif cout << "allocator= std::allocator \tsizeof(A) = " << sizeof(A) << endl; cout << "malloc = std::malloc/free \tsizeof(A) = " << sizeof(A) << endl; cout << endl << endl; Timer t; const int N = 3; int Narr = 1000*1000; void** a= new void*[Narr]; cout << loop << " times "; LOKI_SMALL_OBJECT_BENCH_ABCD(delete_new ,0,loop,t,"'delete new T'"); assert( (!AllocatorSingleton::IsCorrupted()) ); cout << "N=" << N <<" : " << loop << " times "; LOKI_SMALL_OBJECT_BENCH_ABCD(delete_new_array ,N,loop,t,"'delete[] new T[N]'"); assert( (!AllocatorSingleton::IsCorrupted()) ); cout << "i=0..." << Narr << " : "; LOKI_SMALL_OBJECT_BENCH_ABCD(new_del_on_arr ,0,Narr,t,"1. 'arr[i] = new T' 2. 'delete arr[i]'"); assert( (!AllocatorSingleton::IsCorrupted()) ); cout << "i=0..." << Narr << ", N=" << N <<" : "; LOKI_SMALL_OBJECT_BENCH_ABCD(new_del_a_on_a ,N,Narr,t,"1. 'arr[i] = new T[N]' 2. 'delete[] arr[i]'"); assert( (!AllocatorSingleton::IsCorrupted()) ); delete [] a; cout << "_________________________________________________________________" << endl; assert( (!AllocatorSingleton::IsCorrupted()) ); AllocatorSingleton::ClearExtraMemory(); } // ---------------------------------------------------------------------------- void DoSingleThreadTest (void) { const int loop = 1000*1000; cout << endl; testSize< 2, loop, ::Loki::SingleThreaded, 4096, 128, 4, ::Loki::NoDestroy, ::Loki::Mutex >(); testSize< 3, loop, ::Loki::SingleThreaded, 4096, 128, 4, ::Loki::NoDestroy, ::Loki::Mutex >(); testSize< 8, loop, ::Loki::SingleThreaded, 4096, 128, 4, ::Loki::NoDestroy, ::Loki::Mutex >(); testSize< 9, loop, ::Loki::SingleThreaded, 4096, 128, 4, ::Loki::NoDestroy, ::Loki::Mutex >(); testSize< 16, loop, ::Loki::SingleThreaded, 4096, 128, 4, ::Loki::NoDestroy, ::Loki::Mutex >(); testSize< 17, loop, ::Loki::SingleThreaded, 4096, 128, 4, ::Loki::NoDestroy, ::Loki::Mutex >(); #if defined(__BORLANDC__) || defined(_MSC_VER) system("PAUSE"); #endif } // ---------------------------------------------------------------------------- #if defined(LOKI_CLASS_LEVEL_THREADING) void DoClassLockTest (void) { const int loop = 1000*1000; cout << endl; testSize< 2, loop, ::Loki::ClassLevelLockable, 4096, 128, 4, ::Loki::NoDestroy, ::Loki::Mutex >(); testSize< 3, loop, ::Loki::ClassLevelLockable, 4096, 128, 4, ::Loki::NoDestroy, ::Loki::Mutex >(); testSize< 8, loop, ::Loki::ClassLevelLockable, 4096, 128, 4, ::Loki::NoDestroy, ::Loki::Mutex >(); testSize< 9, loop, ::Loki::ClassLevelLockable, 4096, 128, 4, ::Loki::NoDestroy, ::Loki::Mutex >(); testSize< 16, loop, ::Loki::ClassLevelLockable, 4096, 128, 4, ::Loki::NoDestroy, ::Loki::Mutex >(); testSize< 17, loop, ::Loki::ClassLevelLockable, 4096, 128, 4, ::Loki::NoDestroy, ::Loki::Mutex >(); #if defined(__BORLANDC__) || defined(_MSC_VER) system("PAUSE"); #endif } #endif // ---------------------------------------------------------------------------- int main() { DoSingleThreadTest(); #if defined(LOKI_CLASS_LEVEL_THREADING) DoClassLockTest(); #endif return 0; } // ---------------------------------------------------------------------------- libloki-0.1.7.orig/test/SmallObj/SmallObjSingleton_MSVC9.vcproj0000644000175000017500000001626011140364657023011 0ustar ivanivan libloki-0.1.7.orig/test/SmallObj/SmallObjCompare_MSVC9.vcproj0000644000175000017500000001646711140364657022446 0ustar ivanivan libloki-0.1.7.orig/test/SmallObj/SmallObjSingleton_MSVC_8.vcproj0000644000175000017500000001173211047143225023136 0ustar ivanivan libloki-0.1.7.orig/test/SmallObj/SmallObjCompare.vcproj0000644000175000017500000001220411041560610021471 0ustar ivanivan libloki-0.1.7.orig/test/SmallObj/CompareSmallObj.dev0000644000175000017500000000333510515234750020761 0ustar ivanivan[Project] FileName=CompareSmallObj.dev Name=CompareSmallObj UnitCount=7 Type=1 Ver=1 ObjFiles= Includes=C:\Projects\loki\include\loki;C:\Projects\boost_1_33_0 Libs= PrivateResource= ResourceIncludes= MakeIncludes= Compiler= CppCompiler=-D LOKI_SMALL_OBJECT_USE_NEW_ARRAY_@@_-D COMPARE_BOOST_POOL_@@_ Linker= IsCpp=1 Icon= ExeOutput= ObjectOutput= OverrideOutput=0 OverrideOutputName=CompareSmallObj.exe HostApplication= Folders=Headers,Sources CommandLine= UseCustomMakefile=0 CustomMakefile= IncludeVersionInfo=0 SupportXPThemes=0 CompilerSet=0 CompilerSettings=0000001001001000000000 [Unit1] FileName=timer.h CompileCpp=1 Folder=Headers Compile=1 Link=1 Priority=1000 OverrideBuildCmd=0 BuildCmd= [Unit2] FileName=SmallObjBench.cpp CompileCpp=1 Folder=Sources Compile=1 Link=1 Priority=1000 OverrideBuildCmd=0 BuildCmd= [Unit3] FileName=..\..\include\loki\Threads.h CompileCpp=1 Folder=Headers Compile=1 Link=1 Priority=1000 OverrideBuildCmd=0 BuildCmd= [Unit4] FileName=..\..\include\loki\Singleton.h CompileCpp=1 Folder=Headers Compile=1 Link=1 Priority=1000 OverrideBuildCmd=0 BuildCmd= [Unit5] FileName=..\..\include\loki\SmallObj.h CompileCpp=1 Folder=Headers Compile=1 Link=1 Priority=1000 OverrideBuildCmd=0 BuildCmd= [Unit6] FileName=..\..\src\Singleton.cpp CompileCpp=1 Folder=Sources Compile=1 Link=1 Priority=1000 OverrideBuildCmd=0 BuildCmd= [Unit7] FileName=..\..\src\SmallObj.cpp CompileCpp=1 Folder=Sources Compile=1 Link=1 Priority=1000 OverrideBuildCmd=0 BuildCmd= [VersionInfo] Major=0 Minor=1 Release=1 Build=1 LanguageID=1033 CharsetID=1252 CompanyName= FileVersion= FileDescription=Developed using the Dev-C++ IDE InternalName= LegalCopyright= LegalTrademarks= OriginalFilename= ProductName= ProductVersion= AutoIncBuildNr=0 libloki-0.1.7.orig/test/SmallObj/SmallObj.cbp0000644000175000017500000000251211047143225017431 0ustar ivanivan libloki-0.1.7.orig/test/SmallObj/DefaultAlloc.cbp0000644000175000017500000000231511047143225020266 0ustar ivanivan libloki-0.1.7.orig/test/SmallObj/DefaultAlloc.cpp0000644000175000017500000005664110515240622020315 0ustar ivanivan/** @file DefaultAlloc.cpp Tests compiler compliance when using the new and delete operators. @author Rich Sposato (original author) @par Purpose of Program This program tests how well C++ compilers comply with the ISO C++ Standard in implementing new, new [], delete, and delete [] operators. The program should identify each known way in which a C++ compiler can fail to comply. It provides versions of each new, new[], delete, and delete [] operators that classes typically overload. These functions have the same signatures as those in the Loki project, and the same as those enumerated in section 18 of the ISO C++ Standard. @par Running the Program If the programs fails to compile, or crashes when executed, the compiler does not comply with the ISO C++ Standard. As the program runs, it should: - identify your compiler, - execute each version of the new, new[], delete, and delete [] operators, - determine if compiler provides correct behavior when exceptions are thrown, - determine if correct operators were called for each appropriate situation, - and determine if the correct parameters were provided to each function. @par License This file is released under the MIT License - like the rest of Loki. You may use it and modify it as you wish - except that the entire set of documentation commentary at the top of this file shall remain intact. @par Connection to Loki This file is provided as part of the Loki project - but does not depend upon any other files in Loki. It was made for Loki by Rich Sposato to determine which compilers can safely use Loki's Small-Object Allocator. During his work on Loki, Rich noticed that some compilers did not provide the correct values to the allocation / deallocation operators, or worse, called the wrong operator. Rather than make several variations of allocator functions to work around areas of non-compliance, Rich decided to write a program that exposes which compilers do not comply with the ISO C++ Standard. It is recommended that you execute this program before incorporating Loki's Small-Object Allocator from your source code. Hence, this program is a "crash test dummy" for how well your compiler can handle Loki. */ // $Id: DefaultAlloc.cpp 761 2006-10-17 20:48:18Z syntheticpp $ // ---------------------------------------------------------------------------- #include #include // ---------------------------------------------------------------------------- using namespace std; /** @par Array Overhead Most compilers require a few extra bytes when allocating arrays via the new [] operators. The overhead is needed to keep track of how many objects are in the array and how many bytes were allocated. The overhead often exists as 4 extra bytes at the start of the array. */ static const unsigned int ArrayOverhead = 4; static const unsigned int ArrayCount = 1000; static bool s_verbose = false; // ---------------------------------------------------------------------------- class EmptyThing { }; class BadBee : public std::exception { public: BadBee( void ) : m_message( "Unknown exception." ) {} BadBee( const char * m ) : m_message( m ) {} virtual ~BadBee( void ) throw() {} virtual const char* what() const throw() { return m_message; } private: const char * m_message; }; class Bee { public: /// Enumerates all the new and delete operators. enum OperatorName { Unknown, NewScalarThrow, NewScalarNoThrow, NewScalarPlacement, DeleteScalarWithSize, DeleteScalarNoThrow, DeleteScalarPlacement, NewArrayThrow, NewArrayNoThrow, NewArrayPlacement, DeleteArrayWithSize, DeleteArrayNoThrow, DeleteArrayPlacement, }; /// Provides textual name for all new and delete operators. static const char * Name( OperatorName type ) { switch ( type ) { case NewScalarThrow: return "scalar throwing new operator"; case NewScalarNoThrow: return "scalar nothrow new operator"; case NewScalarPlacement: return "scalar placement new operator"; case DeleteScalarWithSize: return "scalar delete operator with size"; case DeleteScalarNoThrow: return "scalar nothrow delete operator"; case DeleteScalarPlacement: return "scalar placement delete operator"; case NewArrayThrow: return "array throwing new operator"; case NewArrayNoThrow: return "array nothrow new operator"; case NewArrayPlacement: return "array placement new operator"; case DeleteArrayWithSize: return "array delete operator with size"; case DeleteArrayNoThrow: return "array nothrow delete operator"; case DeleteArrayPlacement: return "array placement delete operator"; } return "Unknown"; } #ifdef _MSC_VER /// @note MSVC complains about non-empty exception specification lists. static void * operator new ( std::size_t size ) #else static void * operator new ( std::size_t size ) throw ( std::bad_alloc ) #endif { CheckCallType( NewScalarThrow, "new" ); void * place = ::operator new( size ); if ( s_verbose ) cout << "static void * operator new ( std::size_t size ) throw ( std::bad_alloc )" << endl << "\tsize = " << size << endl; cout << endl; return place; } static void * operator new ( std::size_t size, const std::nothrow_t & nt ) throw () { s_triedNoThrowNew = true; CheckCallType( NewScalarNoThrow, "new" ); void * place = ::operator new( size, nt ); if ( s_verbose ) cout << "static void * operator new ( std::size_t size," << endl << "\tconst std::nothrow_t & nt ) throw ()" << endl << "\tsize = " << size << endl; cout << endl; return place; } static void * operator new ( std::size_t size, void * place ) { void * place2 = ::operator new( size, place ); CheckCallType( NewScalarPlacement, "new" ); if ( s_verbose ) cout << "static void * operator new ( std::size_t size, void * place )" << endl << "\tsize = " << size << endl << "\tplace = " << place << endl << "\treturn = " << place2 << endl; cout << endl; return place2; } /** @note This version of delete [] is commented out since the C++ Standard requires compilers to use the version of delete [] with the size parameter if that one is available and this one is not. */ // static void operator delete ( void * place ) throw () // { // CheckCallType( DeleteScalarNoSize, "delete" ); // cout << "scalar delete operator" << endl; // if ( s_verbose ) // cout << "static void operator delete ( void * place ) throw ()" << endl // << "\tplace = " << place << endl; // cout << endl; // ::operator delete( place ); // } static void operator delete ( void * place, std::size_t size ) throw () { CheckCallType( DeleteScalarWithSize, "delete" ); if ( s_verbose ) cout << "static void operator delete ( void * place, std::size_t size ) throw ()" << endl << "\tplace = " << place << endl << "\tsize = " << size << endl; cout << endl; ::operator delete( place ); } static void operator delete ( void * place, const std::nothrow_t & nt ) throw() { CheckCallType( DeleteScalarNoThrow, "delete" ); if ( s_verbose ) cout << "static void operator delete ( void * place," << endl << "\tconst std::nothrow_t & nt ) throw()" << endl << "\tplace = " << place << endl; cout << endl; ::operator delete( place, nt ); } static void operator delete ( void * place1, void * place2 ) { CheckCallType( DeleteScalarPlacement, "delete" ); if ( s_verbose ) cout << "static void operator delete ( void * place1, void * place2 )" << endl << "\tplace1 = " << place1 << endl << "\tplace2 = " << place2 << endl; cout << endl; ::operator delete( place1, place2 ); } #ifdef _MSC_VER /// @note MSVC complains about non-empty exception specification lists. static void * operator new [] ( std::size_t size ) #else static void * operator new [] ( std::size_t size ) throw ( std::bad_alloc ) #endif { s_newArraySize = size; CheckCallType( NewArrayThrow, "new []" ); void * place = ::operator new [] ( size ); if ( s_verbose ) cout << "static void * operator new [] ( std::size_t size ) throw ( std::bad_alloc )" << endl << "\tsize = " << size << endl; cout << endl; return place; } static void * operator new [] ( std::size_t size, const std::nothrow_t & nt ) throw () { s_triedNoThrowNew = true; s_newArraySize = size; CheckCallType( NewArrayNoThrow, "new []" ); void * place = ::operator new [] ( size, nt ); if ( s_verbose ) cout << "static void * operator new [] ( std::size_t size," << endl << "\tconst std::nothrow_t & nt ) throw ()" << endl << "\tsize = " << size << endl; cout << endl; return place; } static void * operator new [] ( std::size_t size, void * place ) { CheckCallType( NewArrayPlacement, "new []" ); void * place2 = ::operator new [] ( size, place ); if ( s_verbose ) cout << "static void * operator new [] ( std::size_t size, void * place )" << endl << "\tsize = " << size << endl << "\tplace = " << place << endl << "\treturn = " << place2 << endl; cout << endl; return place2; } /** @note This version of delete [] is commented out since the C++ Standard requires compilers to use the version of delete [] with the size parameter if that one is available and this one is not. */ // static void operator delete [] ( void * place ) throw () // { // CheckCallType( DeleteArrayNoSize, "delete []" ); // if ( s_verbose ) // cout << "static void operator delete [] ( void * place ) throw ()" << endl // << "\tplace = " << place << endl; // cout << endl; // ::operator delete [] ( place ); // } static void operator delete [] ( void * place, std::size_t size ) throw () { s_deleteArraySize = size; CheckCallType( DeleteArrayWithSize, "delete []" ); if ( s_verbose ) cout << "static void operator delete [] ( void * place, std::size_t size ) throw ()" << endl << "\tplace = " << place << endl << "\tsize = " << size << endl; if ( s_newArraySize != size ) { cout << "\tERROR: The size parameter should be: " << s_newArraySize << '!' << endl; s_errorCount++; } cout << endl; ::operator delete [] ( place ); } static void operator delete [] ( void * place, const std::nothrow_t & nt ) throw() { CheckCallType( DeleteArrayNoThrow, "delete []" ); if ( s_verbose ) cout << "static void operator delete [] ( void * place," << endl << "\tconst std::nothrow_t & nt ) throw()" << endl << "\tplace = " << place << endl; cout << endl; ::operator delete [] ( place, nt ); } static void operator delete [] ( void * place1, void * place2 ) { CheckCallType( DeleteArrayPlacement, "delete []" ); if ( s_verbose ) cout << "static void operator delete [] ( void * place1, void * place2 )" << endl << "\tplace1 = " << place1 << endl << "\tplace2 = " << place2 << endl; cout << endl; ::operator delete [] ( place1, place2 ); } static void OutputArraySizeInfo( void ); inline static void Clear( void ) { s_newArraySize = 0; s_deleteArraySize = 0; } inline static void SetConstructorToThrow( bool b ) { s_throw = b; } inline static bool WillConstructorThrow( void ) { return s_throw; } Bee( void ) : m_legs( 6 ) { if ( s_throw ) { s_expectedCall = ( NewArrayNoThrow == s_expectedCall ) ? DeleteArrayNoThrow : DeleteScalarNoThrow; throw BadBee( "Bee died before it hatched." ); } } ~Bee( void ) {} inline static unsigned int GetErrorCount( void ) { return s_errorCount; } inline static void IncrementErrorCount( void ) { ++s_errorCount; } static OperatorName s_expectedCall; private: static std::size_t s_newArraySize; static std::size_t s_deleteArraySize; static unsigned int s_errorCount; static bool s_triedNoThrowNew; static bool s_throw; static void CheckCallType( OperatorName actual, const char * name ) { cout << Name( actual ) << endl; if ( s_expectedCall != actual ) { s_errorCount++; cout << "\tERROR! The wrong " << name << " operator was called!" << endl << "\tExpected " << Name( s_expectedCall ) << " instead!" << endl; } } unsigned int m_legs; }; // ---------------------------------------------------------------------------- Bee::OperatorName Bee::s_expectedCall = Bee::Unknown; std::size_t Bee::s_newArraySize = 0; std::size_t Bee::s_deleteArraySize = 0; unsigned int Bee::s_errorCount = 0; bool Bee::s_triedNoThrowNew = false; bool Bee::s_throw = false; // ---------------------------------------------------------------------------- void Bee::OutputArraySizeInfo( void ) { cout << endl; if ( ( 0 == s_newArraySize ) || ( 0 == s_deleteArraySize ) ) cout << "I do not have sufficient information to know if your compiler complies" << endl << "with Section 12.5/5 of the C++ Standard. You should not use Loki to" << endl << "allocate arrays. Please do not #define LOKI_SMALL_OBJECT_USE_NEW_ARRAY." << endl; else if ( s_newArraySize == s_deleteArraySize ) cout << "Your compiler provides correct value for delete [] operator. You may use" << endl << "Loki to allocate arrays via #define LOKI_SMALL_OBJECT_USE_NEW_ARRAY. If" << endl << "you do, please run the SmallObjBench tests to see if Loki is faster or" << endl << "slower at allocating arrays than the default allocator." << endl << endl; else cout << "Your compiler does NOT provide correct size value for delete [] operator." << endl << "It should provide the same size value to delete [] as it did to new []." << endl << "Please ask your compiler vendor to comply with Section 12.5/5 of the C++" << endl << "Standard. You should NOT use Loki to allocate arrays. Please do *not*" << endl << "#define LOKI_SMALL_OBJECT_USE_NEW_ARRAY." << endl << endl; cout << endl; } // ---------------------------------------------------------------------------- const char * GetCompilerName( void ) { /** @note This list of predefined compiler version macros comes from http://predef.sourceforge.net/precomp.html Feel free to update this function to add specific version numbers or add other compilers. */ #if (__INTEL_COMPILER) return "Intel"; #elif (__ICC) return "Intel"; #elif (__KCC) return "Intel's KAI C++"; #elif (__MINGW32__) return "MinGW"; #elif (__COMO__) return "Comeau C++"; #elif (__DECC) return "Compaq C/C++"; #elif (VAXC) return "Compaq C/C++"; #elif (__VAXC) return "Compaq C/C++"; #elif (_CRAYC) return "Cray C/C++"; #elif (__CYGWIN__) return "Cygwin"; #elif (__DCC__) return "Diab C/C++"; #elif (__DMC__) return "Digital Mars"; #elif (__SC__) return "Digital Mars"; #elif (__ZTC__) return "Digital Mars"; #elif (__EDG__) return "EDG C++ Front End"; #elif (__GNUC__) return "Gnu C/C++"; #elif (__HP_cc) return "HP ANSI C/aC++"; #elif (__HP_aCC) return "HP ANSI C/aC++"; #elif (__xlC__) return "IBM XL C/C++"; #elif (__IBMC__) return "IBM XL C/C++"; #elif (__IBMCPP__) return "IBM XL C/C++"; #elif (LCC) return "LCC"; #elif (__HIGHC__) return "MetaWare High C/C++"; #elif (sgi) return "MIPSpro"; #elif (__sgi) return "MIPSpro"; #elif (__MRC__) return "MPW C++"; #elif (MPW_C) return "MPW C++"; #elif (MPW_CPLUS) return "MPW C++"; #elif (__CC_NORCROFT) return "Norcroft C"; #elif (__POCC__) return "Pelles C"; #elif (SASC) return "SAS/C"; #elif (__SASC) return "SAS/C"; #elif (__SASC__) return "SAS/C"; #elif (_SCO_DS) return "SCO"; #elif (__SUNPRO_C) return "Sun Workshop C/C++"; #elif (__SUNPRO_CC) return "Sun Workshop C/C++"; #elif (__TenDRA__) return "TenDRA C/C++"; #elif (__TINYC__) return "Tiny C"; #elif (__USLC__) return "USL C"; #elif (__WATCOMC__) return "Watcom C++"; #elif (__MWERKS__) return "MetroWerks CodeWarrior"; #elif (__TURBOC__) return "Borland Turbo C"; #elif (__BORLANDC__) return "Borland C++"; #elif (_MSC_VER >= 1400) return "Microsoft 8.0 or higher"; #elif (_MSC_VER >= 1300) return "Microsoft 7"; #elif (_MSC_VER >= 1200) return "Microsoft 6"; #elif (_MSC_VER) return "Microsoft, but a version lower than 6"; #else return "an Unknown type"; #endif } // ---------------------------------------------------------------------------- void OutputCompilerType( void ) { cout << "Your compiler is " << GetCompilerName() << '.' << endl << endl; const bool zeroSize = ( 0 == sizeof(EmptyThing) ); if ( zeroSize ) { cout << "Your compiler allows datatypes to be zero bytes, which is contrary to" << endl; cout << "the ISO C++ Standard." << endl; } else { cout << "Your compiler correctly sets the sizeof empty data types to " << sizeof(EmptyThing) << " byte(s) instead of zero bytes." << endl; } cout << "( sizeof(EmptyThing) == " << sizeof(EmptyThing) << " )" << endl << endl; } // ---------------------------------------------------------------------------- void RunTests( void ) { char localQueen[ sizeof(Bee) ]; char localHive[ sizeof(Bee) * ArrayCount + ArrayOverhead ]; void * here = localQueen; // test throwing new if ( s_verbose ) cout << "Bee * queen = new Bee;" << endl; Bee::s_expectedCall = Bee::NewScalarThrow; Bee * queen = new Bee; if ( s_verbose ) cout << "delete queen;" << endl; // test normal delete Bee::s_expectedCall = Bee::DeleteScalarWithSize; delete queen; // test throwing new [] if ( s_verbose ) cout << "Bee * hive = new Bee [ ArrayCount ];" << endl; Bee::s_expectedCall = Bee::NewArrayThrow; Bee * hive = new Bee [ ArrayCount ]; if ( s_verbose ) cout << "delete [] hive;" << endl; // test normal delete [] Bee::s_expectedCall = Bee::DeleteArrayWithSize; delete [] hive; Bee::OutputArraySizeInfo(); // test nothrow new if ( s_verbose ) cout << "Bee * queen = new nothrow Bee;" << endl; Bee::s_expectedCall = Bee::NewScalarNoThrow; queen = new (nothrow) Bee; if ( s_verbose ) cout << "delete queen;" << endl; // test normal delete Bee::s_expectedCall = Bee::DeleteScalarWithSize; delete queen; // test nothrow new [] if ( s_verbose ) cout << "Bee * hive = new (nothrow) Bee [ 1000 ];" << endl; Bee::s_expectedCall = Bee::NewArrayNoThrow; hive = new (nothrow) Bee [ ArrayCount ]; if ( s_verbose ) cout << "delete [] hive;" << endl; // test normal delete [] Bee::s_expectedCall = Bee::DeleteArrayWithSize; delete [] hive; Bee::Clear(); Bee::SetConstructorToThrow( true ); std::nothrow_t nothrow; try { // test nothrow new when constructor throws. if ( s_verbose ) cout << "Bee * queen = new nothrow Bee;" << endl; Bee::s_expectedCall = Bee::NewScalarNoThrow; queen = new (nothrow) Bee; if ( s_verbose ) cout << "delete queen;" << endl; // test normal delete delete queen; } catch ( const std::exception & ex0 ) { // nothrow delete should be called before catch block starts if ( s_verbose ) cout << "catch ( const std::exception & ex0 )" << endl << "\t" << ex0.what() << endl; } try { // test nothrow new [] when constructor throws. if ( s_verbose ) cout << "Bee * hive = new (nothrow) Bee [ 1000 ];" << endl; Bee::s_expectedCall = Bee::NewArrayNoThrow; hive = new (nothrow) Bee [ ArrayCount ]; if ( s_verbose ) cout << "delete queen;" << endl; // test normal delete delete [] hive; } catch ( const std::exception & ex1 ) { // nothrow delete should be called before catch block starts if ( s_verbose ) cout << "catch ( const std::exception & ex0 )" << endl << "\t" << ex1.what() << endl; } Bee::SetConstructorToThrow( false ); // test placement new if ( s_verbose ) cout << "Bee * queen = new (here) Bee;" << endl; Bee::s_expectedCall = Bee::NewScalarPlacement; queen = new (here) Bee; if ( s_verbose ) cout << "delete (here, queen);" << endl; // test placement delete; Bee::s_expectedCall = Bee::DeleteScalarPlacement; delete (here, queen); // test placement new [] here = localHive; if ( s_verbose ) cout << "Bee * hive = new (here) Bee [ ArrayCount ];" << endl; Bee::s_expectedCall = Bee::NewArrayPlacement; hive = new (here) Bee [ ArrayCount ]; if ( s_verbose ) cout << "delete [] (here, hive);" << endl; // test placement delete []; Bee::s_expectedCall = Bee::DeleteArrayPlacement; delete [] (here, hive); } // ---------------------------------------------------------------------------- int main( unsigned int argc, const char * const argv[] ) { bool caught = false; for ( unsigned int aa = 1; aa < argc; ++aa ) { if ( ::strcmp( argv[aa], "-v" ) == 0 ) s_verbose = true; } OutputCompilerType(); try { RunTests(); } catch ( const std::bad_alloc & ex1 ) { caught = true; if ( s_verbose ) cout << "catch ( const std::bad_alloc & ex1 )" << endl << "\t" << ex1.what() << endl; } catch ( const std::exception & ex2 ) { caught = true; if ( s_verbose ) cout << "catch ( const std::exception & ex2 )" << endl << "\t" << ex2.what() << endl; } catch ( ... ) { caught = true; if ( s_verbose ) cout << "catch ( ... )" << endl; } if ( caught ) { Bee::IncrementErrorCount(); cout << "Tests of default new and delete operators aborted because of exception!" << endl; } cout << "Done running tests of default allocators." << endl; cout << "Total errors detected: " << Bee::GetErrorCount() << endl; return 0; } // ---------------------------------------------------------------------------- libloki-0.1.7.orig/test/SmallObj/DefaultAlloc.dev0000644000175000017500000000144110515234750020302 0ustar ivanivan[Project] FileName=DefaultAlloc.dev Name=DefaultAlloc UnitCount=1 Type=1 Ver=1 ObjFiles= Includes= Libs= PrivateResource= ResourceIncludes= MakeIncludes= Compiler= CppCompiler= Linker= IsCpp=1 Icon= ExeOutput= ObjectOutput= OverrideOutput=0 OverrideOutputName= HostApplication= Folders= CommandLine= UseCustomMakefile=0 CustomMakefile= IncludeVersionInfo=0 SupportXPThemes=0 CompilerSet=0 CompilerSettings= [Unit1] FileName=DefaultAlloc.cpp CompileCpp=1 Folder=DefaultAlloc Compile=1 Link=1 Priority=1000 OverrideBuildCmd=0 BuildCmd= [VersionInfo] Major=0 Minor=1 Release=1 Build=1 LanguageID=1033 CharsetID=1252 CompanyName= FileVersion= FileDescription=Developed using the Dev-C++ IDE InternalName= LegalCopyright= LegalTrademarks= OriginalFilename= ProductName= ProductVersion= AutoIncBuildNr=0 libloki-0.1.7.orig/test/SmallObj/DefaultAlloc.vcproj0000644000175000017500000000711711041561027021030 0ustar ivanivan libloki-0.1.7.orig/test/SmallObj/SmallObjCompare_MSVC_8.vcproj0000644000175000017500000001210311047143225022553 0ustar ivanivan libloki-0.1.7.orig/test/SmallObj/DefaultAlloc_MSVC9.vcproj0000644000175000017500000001215611140364657021762 0ustar ivanivan libloki-0.1.7.orig/test/SmartPtr/0000755000175000017500000000000011140365040015304 5ustar ivanivanlibloki-0.1.7.orig/test/SmartPtr/Makefile0000644000175000017500000000044610515234750016760 0ustar ivanivaninclude ../Makefile.common BIN := main$(BIN_SUFFIX) SRC := main.cpp strong.cpp LockTest.cpp OBJ := $(SRC:.cpp=.o) LDLIBS += -lpthread .PHONY: all clean all: $(BIN) clean: cleandeps $(RM) $(BIN) $(RM) $(OBJ) $(BIN): $(OBJ) $(CXX) $(LDFLAGS) -o $@ $^ $(LDLIBS) include ../../Makefile.deps libloki-0.1.7.orig/test/SmartPtr/strong.cpp0000644000175000017500000011240511122716347017341 0ustar ivanivan//////////////////////////////////////////////////////////////////////////////// // Test program for The Loki Library // Copyright (c) 2006 Richard Sposato // 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 authors make no representations about the // suitability of this software for any purpose. It is provided "as is" // without express or implied warranty. //////////////////////////////////////////////////////////////////////////////// // $Id: strong.cpp 916 2008-12-19 13:08:55Z syntheticpp $ // ---------------------------------------------------------------------------- #ifndef LOKI_CLASS_LEVEL_THREADING #define LOKI_CLASS_LEVEL_THREADING #endif #include #include #include #include "base.h" // ---------------------------------------------------------------------------- using namespace std; using namespace Loki; // ---------------------------------------------------------------------------- /// Used to check if SmartPtr can be used with a forward-reference. class Thingy; typedef Loki::StrongPtr< Thingy, true, TwoRefCounts, DisallowConversion, AssertCheck, CantResetWithStrong, DeleteSingle, DontPropagateConst > Thingy_DeleteSingle_ptr; typedef Loki::StrongPtr< Thingy, true, TwoRefCounts, DisallowConversion, AssertCheck, CantResetWithStrong, DeleteUsingFree, DontPropagateConst > Thingy_DeleteUsingFree_ptr; typedef Loki::StrongPtr< Thingy, true, TwoRefCounts, DisallowConversion, AssertCheck, CantResetWithStrong, DeleteNothing, DontPropagateConst > Thingy_DeleteNothing_ptr; // ---------------------------------------------------------------------------- class Counted { public: Counted( void ) : m_size( 0 ) { s_constructions++; } ~Counted( void ) { s_destructions++; } static inline bool AllDestroyed( void ) { return ( s_constructions == s_destructions ); } static inline bool ExtraConstructions( void ) { return ( s_constructions > s_destructions ); } static inline bool ExtraDestructions( void ) { return ( s_constructions < s_destructions ); } static inline unsigned int GetCtorCount( void ) { return s_constructions; } static inline unsigned int GetDtorCount( void ) { return s_destructions; } private: /// Not implemented. Counted( const Counted & ); /// Not implemented. Counted & operator = ( const Counted & ); static unsigned int s_constructions; static unsigned int s_destructions; int m_size; }; unsigned int Counted::s_constructions = 0; unsigned int Counted::s_destructions = 0; typedef ::Loki::StrongPtr< Counted, false > Counted_WeakPtr; typedef ::Loki::StrongPtr< Counted, true > Counted_StrongPtr; typedef ::Loki::StrongPtr< Counted, false, ::Loki::TwoRefLinks > Linked_WeakPtr; typedef ::Loki::StrongPtr< Counted, true, ::Loki::TwoRefLinks > Linked_StrongPtr; typedef ::Loki::StrongPtr< Counted, false, ::Loki::LockableTwoRefCounts > Lockable_WeakPtr; typedef ::Loki::StrongPtr< Counted, true, ::Loki::LockableTwoRefCounts > Lockable_StrongPtr; // ---------------------------------------------------------------------------- class Earth; class Moon; typedef Loki::StrongPtr< Earth, false, TwoRefCounts, DisallowConversion, AssertCheck, CantResetWithStrong, DeleteSingle, DontPropagateConst > Earth_WeakPtr; typedef Loki::StrongPtr< Earth, true, TwoRefCounts, DisallowConversion, AssertCheck, AllowReset, DeleteSingle, DontPropagateConst > Earth_StrongPtr; typedef Loki::StrongPtr< Moon, false, TwoRefCounts, DisallowConversion, AssertCheck, CantResetWithStrong, DeleteSingle, DontPropagateConst > Moon_WeakPtr; typedef Loki::StrongPtr< Moon, true, TwoRefCounts, DisallowConversion, AssertCheck, AllowReset, DeleteSingle, DontPropagateConst > Moon_StrongPtr; // ---------------------------------------------------------------------------- class Earth { public: Earth( void ) : m_moon() { s_constructions++; } ~Earth( void ) { s_destructions++; } void SetMoon( const Moon_StrongPtr & p ); void SetMoon( const Moon_WeakPtr & p ); static inline bool AllDestroyed( void ) { return ( s_constructions == s_destructions ); } static inline bool ExtraConstructions( void ) { return ( s_constructions > s_destructions ); } static inline bool ExtraDestructions( void ) { return ( s_constructions < s_destructions ); } static inline unsigned int GetCtorCount( void ) { return s_constructions; } static inline unsigned int GetDtorCount( void ) { return s_destructions; } private: /// Not implemented. Earth( const Earth & ); /// Not implemented. Earth & operator = ( const Earth & ); static unsigned int s_constructions; static unsigned int s_destructions; Moon_WeakPtr m_moon; }; unsigned int Earth::s_constructions = 0; unsigned int Earth::s_destructions = 0; // ---------------------------------------------------------------------------- class Moon { public: Moon( void ) : m_earth() { s_constructions++; } ~Moon( void ) { s_destructions++; } void SetEarth( const Earth_WeakPtr & p ); void SetEarth( const Earth_StrongPtr & p ); static inline bool AllDestroyed( void ) { return ( s_constructions == s_destructions ); } static inline bool ExtraConstructions( void ) { return ( s_constructions > s_destructions ); } static inline bool ExtraDestructions( void ) { return ( s_constructions < s_destructions ); } static inline unsigned int GetCtorCount( void ) { return s_constructions; } static inline unsigned int GetDtorCount( void ) { return s_destructions; } private: /// Not implemented. Moon( const Moon & ); /// Not implemented. Moon & operator = ( const Moon & ); static unsigned int s_constructions; static unsigned int s_destructions; Earth_WeakPtr m_earth; }; unsigned int Moon::s_constructions = 0; unsigned int Moon::s_destructions = 0; // ---------------------------------------------------------------------------- void Moon::SetEarth( const Earth_WeakPtr & p ) { m_earth = p; } // ---------------------------------------------------------------------------- void Moon::SetEarth( const Earth_StrongPtr & p ) { m_earth = p; } // ---------------------------------------------------------------------------- void Earth::SetMoon( const Moon_WeakPtr & p ) { m_moon = p; } // ---------------------------------------------------------------------------- void Earth::SetMoon( const Moon_StrongPtr & p ) { m_moon = p; } // ---------------------------------------------------------------------------- typedef Loki::StrongPtr< BaseClass, false, TwoRefCounts, DisallowConversion, AssertCheck, CantResetWithStrong, DeleteSingle, DontPropagateConst > NonConstBase_WeakCount_NoConvert_Assert_NoPropagate_ptr; typedef Loki::StrongPtr< BaseClass, true, TwoRefCounts, DisallowConversion, NoCheck, CantResetWithStrong, DeleteSingle, DontPropagateConst > NonConstBase_StrongCount_NoConvert_NoCheck_NoPropagate_ptr; typedef Loki::StrongPtr< BaseClass, false, TwoRefLinks, DisallowConversion, AssertCheck, CantResetWithStrong, DeleteSingle, DontPropagateConst > NonConstBase_WeakLink_NoConvert_Assert_NoPropagate_ptr; typedef Loki::StrongPtr< BaseClass, true, TwoRefLinks, DisallowConversion, NoCheck, CantResetWithStrong, DeleteSingle, DontPropagateConst > NonConstBase_StrongLink_NoConvert_NoCheck_NoPropagate_ptr; typedef Loki::StrongPtr< BaseClass, false, TwoRefCounts, DisallowConversion, AssertCheck, AllowReset, DeleteSingle, DontPropagateConst > NonConstBase_WeakCount_NoConvert_Assert_Reset_NoPropagate_ptr; typedef Loki::StrongPtr< BaseClass, true, TwoRefCounts, DisallowConversion, NoCheck, AllowReset, DeleteSingle, DontPropagateConst > NonConstBase_StrongCount_NoConvert_NoCheck_Reset_NoPropagate_ptr; /// @note Used for const propagation tests. typedef Loki::StrongPtr< const BaseClass, true, TwoRefCounts, DisallowConversion, NoCheck, CantResetWithStrong, DeleteSingle, PropagateConst > ConstBase_StrongCount_NoConvert_NoCheck_Propagate_ptr; typedef Loki::StrongPtr< const BaseClass, false, TwoRefCounts, DisallowConversion, AssertCheck, CantResetWithStrong, DeleteSingle, PropagateConst > ConstBase_WeakCount_NoConvert_Assert_Propagate_ptr; // ---------------------------------------------------------------------------- void DoWeakLeakTest( void ) { const unsigned int ctorCount = Counted::GetCtorCount(); const unsigned int dtorCount = Counted::GetDtorCount(); assert( Counted::AllDestroyed() ); { Counted_WeakPtr pWeakInt; { Counted_StrongPtr pStrongInt( new Counted ); pWeakInt = pStrongInt; assert( Counted::ExtraConstructions() ); assert( Counted::GetCtorCount() == ctorCount + 1 ); assert( Counted::GetDtorCount() == dtorCount ); } assert( Counted::AllDestroyed() ); assert( Counted::GetCtorCount() == ctorCount + 1 ); assert( Counted::GetDtorCount() == dtorCount + 1 ); } { Lockable_WeakPtr pWeakInt; { Lockable_StrongPtr pStrongInt( new Counted ); pWeakInt = pStrongInt; assert( Counted::ExtraConstructions() ); assert( Counted::GetCtorCount() == ctorCount + 2 ); assert( Counted::GetDtorCount() == dtorCount + 1 ); } assert( Counted::AllDestroyed() ); assert( Counted::GetCtorCount() == ctorCount + 2 ); assert( Counted::GetDtorCount() == dtorCount + 2 ); } { Linked_WeakPtr pWeakInt; { Linked_StrongPtr pStrongInt( new Counted ); pWeakInt = pStrongInt; assert( Counted::ExtraConstructions() ); assert( Counted::GetCtorCount() == ctorCount + 3 ); assert( Counted::GetDtorCount() == dtorCount + 2 ); } assert( Counted::AllDestroyed() ); assert( Counted::GetCtorCount() == ctorCount + 3 ); assert( Counted::GetDtorCount() == dtorCount + 3 ); } } // ---------------------------------------------------------------------------- void DoStrongRefCountTests( void ) { BaseClass * pNull = NULL; (void)pNull; const unsigned int ctorCount = BaseClass::GetCtorCount(); (void)ctorCount; const unsigned int dtorCount = BaseClass::GetDtorCount(); (void)dtorCount; assert( BaseClass::GetCtorCount() == BaseClass::GetDtorCount() ); { NonConstBase_WeakCount_NoConvert_Assert_NoPropagate_ptr w0; NonConstBase_StrongCount_NoConvert_NoCheck_NoPropagate_ptr s0; NonConstBase_WeakCount_NoConvert_Assert_NoPropagate_ptr w1( w0 ); // Copy from weak to strong is available. NonConstBase_StrongCount_NoConvert_NoCheck_NoPropagate_ptr s1( w0 ); // Assignment from weak to strong is available. s1 = w1; // Converting from strong to weak is available. NonConstBase_WeakCount_NoConvert_Assert_NoPropagate_ptr w2( s0 ); // Assignment from strong to weak is available. w1 = s1; assert( !s0 ); assert( !s1 ); assert( !w0 ); assert( !w1 ); assert( s1 == pNull ); assert( s0 == pNull ); assert( w1 == pNull ); assert( w1 == pNull ); assert( pNull == s0 ); assert( pNull == s1 ); assert( pNull == w0 ); assert( pNull == w1 ); assert( s0 == s0 ); assert( s1 == s1 ); assert( w0 == w0 ); assert( w1 == w1 ); assert( s1 == s0 ); assert( s0 == s1 ); assert( w0 == s0 ); assert( s0 == w0 ); assert( w0 == w1 ); assert( w1 == w0 ); assert( w0 == w1 ); assert( w1 == s1 ); assert( s1 == w1 ); assert( s1 <= s0 ); assert( s1 >= s0 ); assert( s0 <= s1 ); assert( s0 >= s1 ); assert( w0 <= s0 ); assert( w0 >= s0 ); assert( s0 <= w0 ); assert( s0 >= w0 ); assert( w1 <= w0 ); assert( w1 >= w0 ); assert( w0 <= w1 ); assert( w0 >= w1 ); assert( !( s1 < s0 ) ); assert( !( s1 > s0 ) ); assert( !( s0 < s1 ) ); assert( !( s0 > s1 ) ); assert( !( w0 < s0 ) ); assert( !( w0 > s0 ) ); assert( !( s0 < w0 ) ); assert( !( s0 > w0 ) ); assert( !( w1 < w0 ) ); assert( !( w1 > w0 ) ); assert( !( w0 < w1 ) ); assert( !( w0 > w1 ) ); assert( !( w0 < pNull ) ); assert( !( w0 > pNull ) ); assert( !( pNull < w0 ) ); assert( !( pNull > w0 ) ); } assert( ctorCount == BaseClass::GetCtorCount() ); assert( dtorCount == BaseClass::GetDtorCount() ); { NonConstBase_WeakCount_NoConvert_Assert_NoPropagate_ptr w1( new BaseClass ); NonConstBase_WeakCount_NoConvert_Assert_NoPropagate_ptr w2( new BaseClass ); assert( w1 != w2 ); assert( w1 ); assert( w2 ); w1 = w2; assert( w1 == w2 ); assert( w1 ); assert( w2 ); assert( dtorCount + 1 == BaseClass::GetDtorCount() ); } assert( ctorCount + 2 == BaseClass::GetCtorCount() ); assert( dtorCount + 2 == BaseClass::GetDtorCount() ); { NonConstBase_StrongCount_NoConvert_NoCheck_NoPropagate_ptr s1( new BaseClass ); NonConstBase_StrongCount_NoConvert_NoCheck_NoPropagate_ptr s2( new BaseClass ); assert( s1 != s2 ); assert( s1 ); assert( s2 ); s1 = s2; assert( s1 == s2 ); assert( s1 ); assert( s2 ); assert( dtorCount + 3 == BaseClass::GetDtorCount() ); } assert( ctorCount + 4 == BaseClass::GetCtorCount() ); assert( dtorCount + 4 == BaseClass::GetDtorCount() ); assert( BaseClass::GetCtorCount() == BaseClass::GetDtorCount() ); { NonConstBase_WeakCount_NoConvert_Assert_NoPropagate_ptr w1( new BaseClass ); NonConstBase_WeakCount_NoConvert_Assert_NoPropagate_ptr w2( new BaseClass ); NonConstBase_StrongCount_NoConvert_NoCheck_NoPropagate_ptr s1( w1 ); NonConstBase_StrongCount_NoConvert_NoCheck_NoPropagate_ptr s2( w2 ); // prove basic stuff. assert( w1 != w2 ); assert( s1 != s2 ); assert( s1 == w1 ); assert( s2 == w2 ); assert( s1 ); assert( s2 ); assert( w1 ); assert( w2 ); // prove a weak pointer can be re-assigned to another without affecting // any strong co-pointers. and that no objects were released. w1 = w2; // w1 == w2 == s2 s1 assert( w1 == w2 ); assert( s1 != s2 ); assert( s1 != w1 ); assert( s1 != w2 ); assert( s2 == w1 ); assert( w1 ); assert( w2 ); assert( s1 ); assert( s2 ); assert( dtorCount + 4 == BaseClass::GetDtorCount() ); // Prove they all point to same thing. s1 = s2; // w1 == w2 == s2 == s1 // and prove that one of them released the object. assert( dtorCount + 5 == BaseClass::GetDtorCount() ); assert( w1 == w2 ); assert( s1 == s2 ); assert( s1 == w1 ); assert( s1 == w2 ); assert( s2 == w1 ); assert( w1 ); assert( w2 ); assert( s1 ); assert( s2 ); } assert( ctorCount + 6 == BaseClass::GetCtorCount() ); assert( dtorCount + 6 == BaseClass::GetDtorCount() ); { NonConstBase_WeakCount_NoConvert_Assert_NoPropagate_ptr w1( new BaseClass ); NonConstBase_WeakCount_NoConvert_Assert_NoPropagate_ptr w2( new BaseClass ); NonConstBase_StrongCount_NoConvert_NoCheck_NoPropagate_ptr s1( w1 ); NonConstBase_StrongCount_NoConvert_NoCheck_NoPropagate_ptr s2( w2 ); // prove basic stuff. w1 == s1 w2 == s2 assert( w1 != w2 ); assert( s1 != s2 ); assert( s1 == w1 ); assert( s2 == w2 ); assert( s1 ); assert( s2 ); assert( w1 ); assert( w2 ); // prove a strong pointer can be re-assigned to another weak pointer, // and that any weak co-pointers released the object. s1 = w2; // s1 == w2 == s2 w1 assert( w1 != w2 ); assert( s1 == s2 ); assert( s1 != w1 ); assert( s1 == w2 ); assert( s2 != w1 ); assert( !w1 ); assert( w2 ); assert( s1 ); assert( s2 ); assert( dtorCount + 7 == BaseClass::GetDtorCount() ); // Prove that when strong pointer is re-assigned, object // is not destroyed if another strong co-pointer exists. s1 = w1; // w1 == s1 w2 == s2 // and prove that none of them released an object. assert( dtorCount + 7 == BaseClass::GetDtorCount() ); assert( w1 != w2 ); assert( s1 != s2 ); assert( s1 == w1 ); assert( s2 == w2 ); assert( !s1 ); assert( s2 ); assert( !w1 ); assert( w2 ); } assert( ctorCount + 8 == BaseClass::GetCtorCount() ); assert( dtorCount + 8 == BaseClass::GetDtorCount() ); } // ---------------------------------------------------------------------------- void DoStrongConstTests( void ) { const unsigned int ctorCount = BaseClass::GetCtorCount(); (void)ctorCount; const unsigned int dtorCount = BaseClass::GetDtorCount(); (void)dtorCount; assert( BaseClass::GetCtorCount() == BaseClass::GetDtorCount() ); { NonConstBase_WeakCount_NoConvert_Assert_NoPropagate_ptr w1( new BaseClass ); const NonConstBase_WeakCount_NoConvert_Assert_NoPropagate_ptr w2( w1 ); NonConstBase_StrongCount_NoConvert_NoCheck_NoPropagate_ptr s1( w1 ); const NonConstBase_StrongCount_NoConvert_NoCheck_NoPropagate_ptr s2( w2 ); const BaseClass & cbw1 = *w1; cbw1.DoThat(); const BaseClass & cbw2 = *w2; cbw2.DoThat(); const BaseClass & cbs1 = *s1; cbs1.DoThat(); const BaseClass & cbs2 = *s2; cbs2.DoThat(); BaseClass & bw1 = *w1; bw1.DoThat(); BaseClass & bw2 = *w2; bw2.DoThat(); BaseClass & bs1 = *s1; bs1.DoThat(); BaseClass & bs2 = *s2; bs2.DoThat(); } assert( ctorCount + 1 == BaseClass::GetCtorCount() ); assert( dtorCount + 1 == BaseClass::GetDtorCount() ); { ConstBase_WeakCount_NoConvert_Assert_Propagate_ptr w1( new BaseClass ); const ConstBase_WeakCount_NoConvert_Assert_Propagate_ptr w2( w1 ); ConstBase_StrongCount_NoConvert_NoCheck_Propagate_ptr s1( w1 ); const ConstBase_StrongCount_NoConvert_NoCheck_Propagate_ptr s2( w2 ); const BaseClass & cbw1 = *w1; cbw1.DoThat(); const BaseClass & cbw2 = *w2; cbw2.DoThat(); const BaseClass & cbs1 = *s1; cbs1.DoThat(); const BaseClass & cbs2 = *s2; cbs2.DoThat(); /** @note These are illegal because constness is propagated by the StrongPtr's policy. Your compiler should produce error messages if you attempt to compile these lines. */ //BaseClass & bw1 = *w1; //bw1.DoThat(); //BaseClass & bw2 = *w2; //bw2.DoThat(); //BaseClass & bs1 = *s1; //bs1.DoThat(); //BaseClass & bs2 = *s2; //bs2.DoThat(); } assert( ctorCount + 2 == BaseClass::GetCtorCount() ); assert( dtorCount + 2 == BaseClass::GetDtorCount() ); } // ---------------------------------------------------------------------------- void DoStrongReleaseTests( void ) { BaseClass * pNull = NULL; (void)pNull; const unsigned int ctorCount = BaseClass::GetCtorCount(); (void)ctorCount; const unsigned int dtorCount = BaseClass::GetDtorCount(); (void)dtorCount; assert( BaseClass::GetCtorCount() == BaseClass::GetDtorCount() ); { // These are tests of pointers that don't allow reset or release if // there is at least 1 strong pointer. Ironically, this means that // if only 1 strong pointer holds onto an object, and you call Release // using that strong pointer, it can't release itself. NonConstBase_WeakCount_NoConvert_Assert_NoPropagate_ptr w1( new BaseClass ); NonConstBase_WeakCount_NoConvert_Assert_NoPropagate_ptr w2( new BaseClass ); NonConstBase_StrongCount_NoConvert_NoCheck_NoPropagate_ptr s1( w1 ); NonConstBase_StrongCount_NoConvert_NoCheck_NoPropagate_ptr s2( w2 ); // Prove that neither weak nor strong pointers can be // released if any co-pointer is strong. bool released = ReleaseAll( w2, pNull ); assert( !released ); released = ReleaseAll( w1, pNull ); assert( !released ); released = ReleaseAll( s1, pNull ); assert( !released ); released = ReleaseAll( s2, pNull ); assert( !released ); // Prove that weak and strong pointers can be reset only // if stored pointer matches parameter pointer - or there // are no strong co-pointers. bool reset = ResetAll( w2, pNull ); assert( !reset ); reset = ResetAll( w1, pNull ); assert( !reset ); reset = ResetAll( s1, pNull ); assert( !reset ); reset = ResetAll( s2, pNull ); assert( !reset ); s2 = pNull; assert( dtorCount + 1 == BaseClass::GetDtorCount() ); reset = ResetAll( w2, pNull ); assert( reset ); reset = ResetAll( w1, pNull ); assert( !reset ); reset = ResetAll( s1, pNull ); assert( !reset ); reset = ResetAll( s2, pNull ); assert( reset ); } assert( ctorCount + 2 == BaseClass::GetCtorCount() ); assert( dtorCount + 2 == BaseClass::GetDtorCount() ); { // These are tests of pointers that do allow reset and release even // if a strong pointer exists. NonConstBase_WeakCount_NoConvert_Assert_Reset_NoPropagate_ptr w1( new BaseClass ); NonConstBase_StrongCount_NoConvert_NoCheck_Reset_NoPropagate_ptr w2( new BaseClass ); NonConstBase_WeakCount_NoConvert_Assert_Reset_NoPropagate_ptr s1( w1 ); NonConstBase_StrongCount_NoConvert_NoCheck_Reset_NoPropagate_ptr s2( w2 ); BaseClass * thing = NULL; bool released = ReleaseAll( w2, thing ); assert( released ); assert( NULL != thing ); delete thing; assert( dtorCount + 3 == BaseClass::GetDtorCount() ); released = ReleaseAll( s1, thing ); assert( released ); assert( NULL != thing ); delete thing; assert( dtorCount + 4 == BaseClass::GetDtorCount() ); released = ReleaseAll( w1, thing ); assert( released ); assert( NULL == thing ); released = ReleaseAll( s2, thing ); assert( released ); assert( NULL == thing ); // Prove that weak and strong pointers can be reset // only if stored pointer matches parameter pointer // - even if there are strong co-pointers. bool reset = ResetAll( w2, pNull ); assert( reset ); reset = ResetAll( w1, pNull ); assert( reset ); reset = ResetAll( s1, pNull ); assert( reset ); reset = ResetAll( s2, pNull ); assert( reset ); assert( ctorCount + 4 == BaseClass::GetCtorCount() ); assert( dtorCount + 4 == BaseClass::GetDtorCount() ); s2 = new BaseClass; s1 = new BaseClass; reset = ResetAll( w2, pNull ); assert( reset ); reset = ResetAll( w1, pNull ); assert( reset ); } assert( ctorCount + 6 == BaseClass::GetCtorCount() ); assert( dtorCount + 6 == BaseClass::GetDtorCount() ); } // ---------------------------------------------------------------------------- void DoStrongRefLinkTests( void ) { BaseClass * pNull = NULL; (void)pNull; const unsigned int ctorCount = BaseClass::GetCtorCount(); (void)ctorCount; const unsigned int dtorCount = BaseClass::GetDtorCount(); (void)dtorCount; assert( BaseClass::GetCtorCount() == BaseClass::GetDtorCount() ); { NonConstBase_WeakLink_NoConvert_Assert_NoPropagate_ptr w0; NonConstBase_WeakLink_NoConvert_Assert_NoPropagate_ptr w1; NonConstBase_StrongLink_NoConvert_NoCheck_NoPropagate_ptr s0; NonConstBase_StrongLink_NoConvert_NoCheck_NoPropagate_ptr s1; assert( !s0 ); assert( !s1 ); assert( s0 == s1 ); assert( s1 == pNull ); assert( s0 == pNull ); assert( pNull == s0 ); assert( pNull == s1 ); assert( s1 == s0 ); assert( s1 == s1 ); assert( s0 == s0 ); assert( s0 == s1 ); assert( s1 <= s0 ); assert( s1 >= s0 ); assert( s0 <= s1 ); assert( s0 >= s1 ); assert( !( s1 < s0 ) ); assert( !( s1 > s0 ) ); assert( !( s0 < s1 ) ); assert( !( s0 > s1 ) ); assert( !w0 ); assert( !w1 ); assert( w0 == pNull ); assert( s0 == pNull ); assert( pNull == s0 ); assert( pNull == w0 ); assert( w0 == s0 ); assert( w0 == w0 ); assert( s0 == s0 ); assert( s0 == w0 ); assert( w0 <= s0 ); assert( w0 >= s0 ); assert( s0 <= w0 ); assert( s0 >= w0 ); assert( !( w0 < s0 ) ); assert( !( w0 > s0 ) ); assert( !( s0 < w0 ) ); assert( !( s0 > w0 ) ); assert( w0 == w1 ); assert( w1 == pNull ); assert( w0 == pNull ); assert( pNull == w0 ); assert( pNull == w1 ); assert( w1 == w0 ); assert( w1 == w1 ); assert( w0 == w0 ); assert( w0 == w1 ); assert( w1 <= w0 ); assert( w1 >= w0 ); assert( w0 <= w1 ); assert( w0 >= w1 ); assert( !( w1 < w0 ) ); assert( !( w1 > w0 ) ); assert( !( w0 < w1 ) ); assert( !( w0 > w1 ) ); } assert( ctorCount == BaseClass::GetCtorCount() ); assert( dtorCount == BaseClass::GetDtorCount() ); { NonConstBase_WeakLink_NoConvert_Assert_NoPropagate_ptr w3( new BaseClass ); NonConstBase_WeakLink_NoConvert_Assert_NoPropagate_ptr w4( new BaseClass ); assert( w3 != w4 ); assert( w3 ); assert( w4 ); w3 = w4; assert( w3 == w4 ); assert( w3 ); assert( w4 ); assert( dtorCount + 1 == BaseClass::GetDtorCount() ); } assert( ctorCount + 2 == BaseClass::GetCtorCount() ); assert( dtorCount + 2 == BaseClass::GetDtorCount() ); { NonConstBase_StrongLink_NoConvert_NoCheck_NoPropagate_ptr s3( new BaseClass ); NonConstBase_StrongLink_NoConvert_NoCheck_NoPropagate_ptr s4( new BaseClass ); assert( s3 != s4 ); assert( s3 ); assert( s4 ); s3 = s4; assert( s3 == s4 ); assert( s3 ); assert( s4 ); assert( dtorCount + 3 == BaseClass::GetDtorCount() ); } assert( ctorCount + 4 == BaseClass::GetCtorCount() ); assert( dtorCount + 4 == BaseClass::GetDtorCount() ); assert( BaseClass::GetCtorCount() == BaseClass::GetDtorCount() ); } // ---------------------------------------------------------------------------- void DoWeakCycleTests( void ) { const unsigned int ctorCountMoon = Moon::GetCtorCount(); (void)ctorCountMoon; const unsigned int dtorCountMoon = Moon::GetDtorCount(); (void)dtorCountMoon; assert( Moon::AllDestroyed() ); const unsigned int ctorCountEarth = Earth::GetCtorCount(); (void)ctorCountEarth; const unsigned int dtorCountEarth = Earth::GetDtorCount(); (void)dtorCountEarth; assert( Earth::AllDestroyed() ); { Earth_WeakPtr ew0; Moon_WeakPtr mw0; } assert( Moon::AllDestroyed() ); assert( Moon::GetCtorCount() == ctorCountMoon ); assert( Moon::GetDtorCount() == dtorCountMoon ); assert( Earth::AllDestroyed() ); assert( Earth::GetCtorCount() == ctorCountEarth ); assert( Earth::GetDtorCount() == dtorCountEarth ); { Earth_WeakPtr ew1( new Earth ); } assert( Earth::AllDestroyed() ); assert( Earth::GetCtorCount() == ctorCountEarth+1 ); assert( Earth::GetDtorCount() == dtorCountEarth+1 ); { Moon_WeakPtr mw1( new Moon ); } assert( Moon::AllDestroyed() ); assert( Moon::GetCtorCount() == ctorCountMoon+1 ); assert( Moon::GetDtorCount() == dtorCountMoon+1 ); { Earth_WeakPtr ew1( new Earth ); Moon_WeakPtr mw1( new Moon ); ew1->SetMoon( mw1 ); } assert( Moon::AllDestroyed() ); assert( Moon::GetCtorCount() == ctorCountMoon+2 ); assert( Moon::GetDtorCount() == dtorCountMoon+2 ); assert( Earth::AllDestroyed() ); assert( Earth::GetCtorCount() == ctorCountEarth+2 ); assert( Earth::GetDtorCount() == dtorCountEarth+2 ); { Earth_WeakPtr ew1( new Earth ); Moon_WeakPtr mw1( new Moon ); mw1->SetEarth( ew1 ); } assert( Moon::AllDestroyed() ); assert( Moon::GetCtorCount() == ctorCountMoon+3 ); assert( Moon::GetDtorCount() == dtorCountMoon+3 ); assert( Earth::AllDestroyed() ); assert( Earth::GetCtorCount() == ctorCountEarth+3 ); assert( Earth::GetDtorCount() == dtorCountEarth+3 ); { Earth_WeakPtr ew1( new Earth ); Moon_WeakPtr mw1( new Moon ); ew1->SetMoon( mw1 ); mw1->SetEarth( ew1 ); } assert( Moon::AllDestroyed() ); assert( Moon::GetCtorCount() == ctorCountMoon+4 ); assert( Moon::GetDtorCount() == dtorCountMoon+4 ); assert( Earth::AllDestroyed() ); assert( Earth::GetCtorCount() == ctorCountEarth+4 ); assert( Earth::GetDtorCount() == dtorCountEarth+4 ); { Earth_StrongPtr es1( new Earth ); Moon_StrongPtr ms1( new Moon ); } assert( Moon::AllDestroyed() ); assert( Moon::GetCtorCount() == ctorCountMoon+5 ); assert( Moon::GetDtorCount() == dtorCountMoon+5 ); assert( Earth::AllDestroyed() ); assert( Earth::GetCtorCount() == ctorCountEarth+5 ); assert( Earth::GetDtorCount() == dtorCountEarth+5 ); { Earth_StrongPtr es1( new Earth ); Moon_StrongPtr ms1( new Moon ); es1->SetMoon( ms1 ); ms1->SetEarth( es1 ); } assert( Moon::AllDestroyed() ); assert( Moon::GetCtorCount() == ctorCountMoon+6 ); assert( Moon::GetDtorCount() == dtorCountMoon+6 ); assert( Earth::AllDestroyed() ); assert( Earth::GetCtorCount() == ctorCountEarth+6 ); assert( Earth::GetDtorCount() == dtorCountEarth+6 ); { Earth_StrongPtr es1( new Earth ); Moon_StrongPtr ms1( new Moon ); { Earth_WeakPtr ew1( es1 ); Moon_WeakPtr mw1( ms1 ); ew1->SetMoon( mw1 ); mw1->SetEarth( ew1 ); } // Note that dtor counts have not changed from previous test. assert( Moon::GetCtorCount() == ctorCountMoon+7 ); assert( Moon::GetDtorCount() == dtorCountMoon+6 ); assert( Earth::GetCtorCount() == ctorCountEarth+7 ); assert( Earth::GetDtorCount() == dtorCountEarth+6 ); } assert( Moon::AllDestroyed() ); assert( Moon::GetCtorCount() == ctorCountMoon+7 ); assert( Moon::GetDtorCount() == dtorCountMoon+7 ); assert( Earth::AllDestroyed() ); assert( Earth::GetCtorCount() == ctorCountEarth+7 ); assert( Earth::GetDtorCount() == dtorCountEarth+7 ); { Earth_StrongPtr es1; Moon_StrongPtr ms1; { Earth_WeakPtr ew1( new Earth ); Moon_WeakPtr mw1( new Moon ); ew1->SetMoon( mw1 ); mw1->SetEarth( ew1 ); es1 = ew1; ms1 = mw1; } // Note that dtor counts have not changed from previous test. assert( Moon::GetCtorCount() == ctorCountMoon+8 ); assert( Moon::GetDtorCount() == dtorCountMoon+7 ); assert( Earth::GetCtorCount() == ctorCountEarth+8 ); assert( Earth::GetDtorCount() == dtorCountEarth+7 ); } assert( Moon::AllDestroyed() ); assert( Moon::GetCtorCount() == ctorCountMoon+8 ); assert( Moon::GetDtorCount() == dtorCountMoon+8 ); assert( Earth::AllDestroyed() ); assert( Earth::GetCtorCount() == ctorCountEarth+8 ); assert( Earth::GetDtorCount() == dtorCountEarth+8 ); } // ---------------------------------------------------------------------------- void DoStrongForwardReferenceTest( void ) { /** @note These lines should cause the compiler to make a warning message about attempting to delete an undefined type. They should also cause an error message about a negative subscript since */ //Thingy_DeleteSingle_ptr p1; //Thingy_DeleteSingle_ptr p2( p1 ); //Thingy_DeleteSingle_ptr p3; //p3 = p1; /** @note These lines should cause the compiler to make an error message about attempting to call the destructor for an undefined type. */ //Thingy_DeleteUsingFree_ptr p4; //Thingy_DeleteUsingFree_ptr p5( p4 ); //Thingy_DeleteUsingFree_ptr p6; //p6 = p4; /** @note These lines should cause the compiler to make neither a warning nor an error message even though the type is undefined. */ Thingy_DeleteNothing_ptr p7; Thingy_DeleteNothing_ptr p8( p7 ); Thingy_DeleteNothing_ptr p9; p9 = p7; } // ---------------------------------------------------------------------------- #include struct Foo { }; typedef Loki::StrongPtr < BaseClass, false, TwoRefCounts, DisallowConversion, AssertCheck, CantResetWithStrong, DeleteSingle, DontPropagateConst > Ptr; bool Compare( const Ptr&, const Ptr&) { return true; } void friend_handling2() { // http://sourceforge.net/tracker/index.php?func=detail&aid=1570582&group_id=29557&atid=396644 // friend injection // see http://gcc.gnu.org/bugzilla/show_bug.cgi?id=28597 std::vector vec; std::sort( vec.begin(), vec.end(), Compare ); std::nth_element( vec.begin(), vec.begin(), vec.end(), Compare ); std::search( vec.begin(), vec.end(), vec.begin(), vec.end(), Compare ); Ptr a, b; Compare( a, b ); // http://gcc.gnu.org/bugzilla/show_bug.cgi?id=29486 BaseClass * pNull ; Ptr w1( new BaseClass ); ReleaseAll( w1, pNull ); } // ---------------------------------------------------------------------------- void DoStrongCompareTests( void ) { Earth * p1 = new Earth; Earth * p2 = new Earth; Earth_StrongPtr sp1( p1 ); Earth_StrongPtr sp2( p2 ); const bool isOneLess = ( p1 < p2 ); if ( isOneLess ) { assert( sp1 < p2 ); assert( sp1 < sp2 ); assert( sp1 <= p2 ); assert( sp1 <= sp2 ); assert( sp1 <= p1 ); assert( sp1 == p1 ); assert( sp1 == sp1 ); assert( sp1 != p2 ); assert( sp1 != sp2 ); assert( sp2 > p1 ); assert( sp2 > sp1 ); assert( sp2 >= p1 ); assert( sp2 >= sp1 ); assert( sp2 >= p2 ); assert( sp2 == p2 ); assert( sp2 == sp2 ); assert( sp2 != p1 ); assert( sp2 != sp1 ); assert( p1 < p2 ); assert( p1 < sp2 ); assert( p1 <= p2 ); assert( p1 <= sp2 ); assert( p1 <= sp1 ); assert( p1 == p1 ); assert( p1 == sp1 ); assert( p1 != p2 ); assert( p1 != sp2 ); assert( p2 > p1 ); assert( p2 > sp1 ); assert( p2 >= p1 ); assert( p2 >= sp1 ); assert( p2 >= sp2 ); assert( p2 == p2 ); assert( p2 == sp2 ); assert( p2 != p1 ); assert( p2 != sp1 ); } else { assert( sp2 < p1 ); assert( sp2 < sp1 ); assert( sp2 <= p1 ); assert( sp2 <= p2 ); assert( sp2 <= sp1 ); assert( sp2 == p2 ); assert( sp2 == sp2 ); assert( sp2 != p1 ); assert( sp2 != sp1 ); assert( sp1 > p2 ); assert( sp1 > sp2 ); assert( sp1 >= p2 ); assert( sp1 >= p1 ); assert( sp1 >= sp2 ); assert( sp1 == p1 ); assert( sp1 == sp1 ); assert( sp1 != p2 ); assert( sp1 != sp2 ); assert( p2 < p1 ); assert( p2 < sp1 ); assert( p2 <= p1 ); assert( p2 <= sp1 ); assert( p2 <= sp2 ); assert( p2 == p2 ); assert( p2 == sp2 ); assert( p2 != p1 ); assert( p2 != sp1 ); assert( p1 > p2 ); assert( p1 > sp2 ); assert( p1 >= p2 ); assert( p1 >= sp2 ); assert( p1 >= sp1 ); assert( p1 == p1 ); assert( p1 == sp1 ); assert( p1 != p2 ); assert( p1 != sp2 ); } } // ---------------------------------------------------------------------------- // GCC bug // http://gcc.gnu.org/bugzilla/show_bug.cgi?id=38579 struct Policy { protected: Policy() {} Policy(const Policy&) {} int i; }; template struct BugGcc : //protected P public P { BugGcc() {} template BugGcc(const BugGcc& t) : P(t) {} }; void foo() { BugGcc<0, Policy> f1; BugGcc<1, Policy> f2(f1); // Policy members are still not public, // this will not compile: //int i = f1.i; } libloki-0.1.7.orig/test/SmartPtr/colvin_gibbons_trick.cpp0000644000175000017500000001102311121554153022202 0ustar ivanivan//////////////////////////////////////////////////////////////////////////////// // Test program for The Loki Library // Copyright (c) 2008 Richard Sposato // 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 authors make no representations about the // suitability of this software for any purpose. It is provided "as is" // without express or implied warranty. //////////////////////////////////////////////////////////////////////////////// // $Id$ // ---------------------------------------------------------------------------- // loki_smart_auto_ptr.cpp Test program for Loki::SmartPtr configured as // auto_ptr using Colvin-Gibbons trick #ifdef HAVE_CONFIG_H #include #endif #include #include #include #include using namespace Loki; using namespace std; // ---------------------------------------------------------------------------- class Base { public: virtual ~Base() {} virtual void Hello() { cout << "Base Hello, world!" << endl; } }; // ---------------------------------------------------------------------------- class Derived: public Base { public: virtual void Hello() { cout << "Derived Hello, world!" << endl; } }; // ---------------------------------------------------------------------------- typedef auto_ptr< Base > AutoPtrBase; typedef auto_ptr< Derived > AutoPtrDerived; typedef SmartPtr< Base, DestructiveCopy > SmartAutoPtrBase; typedef SmartPtr< Derived, DestructiveCopy > SmartAutoPtrDerived; // ---------------------------------------------------------------------------- template TPtrBase CreateBase() { return TPtrBase( new Base ); } // ---------------------------------------------------------------------------- template TPtrDerived CreateDerived() { return TPtrDerived( new Derived ); } // ---------------------------------------------------------------------------- template < class TPtrBase > void UseBase( TPtrBase ptr ) { ptr->Hello(); } // ---------------------------------------------------------------------------- template < class TPtrBase, class TPtrDerived > void DoTest() { TPtrBase spb0 = CreateBase< TPtrBase >(); TPtrBase spb1( spb0 ); UseBase< TPtrBase >( CreateBase< TPtrBase >() ); TPtrDerived spd1 = CreateDerived< TPtrDerived >(); TPtrBase spb2( spd1 ); // NOTE: this does not compile with gcc 4.3.1 also for std::auto_ptr; // it should work (Copy-initialization, base-from-derived) // according to http://www.open-std.org/jtc1/sc22/wg21/docs/papers/1997/N1128.pdf // It does compile with Visual C++ 8 (need to test with 9) // UseBase(CreateDerived()); // Quick fix UseBase< TPtrBase >( TPtrBase( CreateDerived< TPtrDerived >() ) ); } // ---------------------------------------------------------------------------- void TryColvinGibbonsTrick( void ) { DoTest(); // OK DoTest(); // FIXME: eror: // assignment of read-only reference 'val' } // ---------------------------------------------------------------------------- #if 0 https://sourceforge.net/tracker/index.php?func=detail&aid=2080889&group_id=29557&atid=396644 To fix the compile bug we have to disable the (const T&) ctor and use RefToValue, the way how it is done in auto_prt. But I'm not sure about the consequences of such a change. Index: loki/SmartPtr.h =================================================================== --- loki/SmartPtr.h (revision 910) +++ loki/SmartPtr.h (working copy) @@ -1175,6 +1175,7 @@ GetImplRef(*this) = OP::Clone(GetImplRef(rhs)); } + /* template < typename T1, @@ -1187,6 +1188,7 @@ SmartPtr(const SmartPtr& rhs) : SP(rhs), OP(rhs), KP(rhs), CP(rhs) { GetImplRef(*this) = OP::Clone(GetImplRef(rhs)); } + */ template < @@ -1205,7 +1207,10 @@ SmartPtr(RefToValue rhs) : SP(rhs), OP(rhs), KP(rhs), CP(rhs) - {} + { + SmartPtr& ref = rhs; + GetImplRef(*this) = OP::Clone(GetImplRef(ref)); + } operator RefToValue() { return RefToValue(*this); } #endif libloki-0.1.7.orig/test/SmartPtr/make.msvc.bat0000644000175000017500000000036410515234750017673 0ustar ivanivan cl -c -Zm200 -O2 -DNDEBUG -MT -EHsc -GR -W4 -wd4710 -I"." -I"..\..\include" main.cpp strong.cpp LockTest.cpp link /NOLOGO /SUBSYSTEM:CONSOLE /incremental:no /OUT:"main-msvc.exe" ..\..\lib\loki.lib main.obj strong.obj LockTest.obj del *.obj libloki-0.1.7.orig/test/SmartPtr/main.cpp0000644000175000017500000010576711047147137016767 0ustar ivanivan//////////////////////////////////////////////////////////////////////////////// // Test program for The Loki Library // Copyright (c) 2006 Richard Sposato // 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 authors make no representations about the // suitability of this software for any purpose. It is provided "as is" // without express or implied warranty. //////////////////////////////////////////////////////////////////////////////// // $Id: main.cpp 897 2008-08-08 22:53:19Z syntheticpp $ // ---------------------------------------------------------------------------- #include #include #include #include "base.h" // ---------------------------------------------------------------------------- using namespace std; using namespace Loki; extern void DoWeakLeakTest( void ); extern void DoStrongRefCountTests( void ); extern void DoStrongRefLinkTests( void ); extern void DoStrongReleaseTests( void ); extern void DoWeakCycleTests( void ); extern void DoStrongConstTests( void ); extern void DoStrongForwardReferenceTest( void ); extern void DoStrongCompareTests( void ); extern void DoLockedPtrTest( void ); extern void DoLockedStorageTest( void ); unsigned int BaseClass::s_constructions = 0; unsigned int BaseClass::s_destructions = 0; unsigned int MimicCOM::s_constructions = 0; unsigned int MimicCOM::s_destructions = 0; // ---------------------------------------------------------------------------- /// Used to check if SmartPtr can be used with a forward-reference. /// GCC gives out warnings because of it, you can ignore them. class Thingy; typedef Loki::SmartPtr< Thingy, RefCounted, DisallowConversion, AssertCheck, DefaultSPStorage, PropagateConst > Thingy_DefaultStorage_ptr; typedef Loki::SmartPtr< Thingy, RefCounted, DisallowConversion, AssertCheck, HeapStorage, PropagateConst > Thingy_HeapStorage_ptr; // ---------------------------------------------------------------------------- /// @note Used for testing most policies. typedef Loki::SmartPtr< BaseClass, RefCounted, DisallowConversion, AssertCheck, DefaultSPStorage, DontPropagateConst > NonConstBase_RefCount_NoConvert_Assert_DontPropagate_ptr; /// @note These 3 are used for testing const policies. typedef Loki::SmartPtr< const BaseClass, RefCounted, DisallowConversion, AssertCheck, DefaultSPStorage, DontPropagateConst > ConstBase_RefCount_NoConvert_Assert_DontPropagate_ptr; typedef Loki::SmartPtr< const BaseClass, RefCounted, DisallowConversion, AssertCheck, DefaultSPStorage, PropagateConst > ConstBase_RefCount_NoConvert_Assert_Propagate_ptr; typedef Loki::SmartPtr< BaseClass, RefCounted, DisallowConversion, AssertCheck, DefaultSPStorage, PropagateConst > NonConstBase_RefCount_NoConvert_Assert_Propagate_ptr; // ---------------------------------------------------------------------------- /// @note These 5 are used for testing ownership policies. typedef Loki::SmartPtr< BaseClass, COMRefCounted, DisallowConversion, AssertCheck, DefaultSPStorage, DontPropagateConst > NonConstBase_ComRef_NoConvert_Assert_DontPropagate_ptr; typedef Loki::SmartPtr< BaseClass, RefLinked, DisallowConversion, AssertCheck, DefaultSPStorage, DontPropagateConst > NonConstBase_RefLink_NoConvert_Assert_DontPropagate_ptr; typedef Loki::SmartPtr< BaseClass, DeepCopy, DisallowConversion, AssertCheck, DefaultSPStorage, DontPropagateConst > NonConstBase_DeepCopy_NoConvert_Assert_DontPropagate_ptr; typedef Loki::SmartPtr< BaseClass, DestructiveCopy, DisallowConversion, AssertCheck, DefaultSPStorage, DontPropagateConst > NonConstBase_KillCopy_NoConvert_Assert_DontPropagate_ptr; typedef Loki::SmartPtr< BaseClass, NoCopy, DisallowConversion, AssertCheck, DefaultSPStorage, DontPropagateConst > NonConstBase_NoCopy_NoConvert_Assert_DontPropagate_ptr; // ---------------------------------------------------------------------------- /// @note These 2 are used for testing inheritance. typedef Loki::SmartPtr< PublicSubClass, RefCounted, DisallowConversion, AssertCheck, DefaultSPStorage, DontPropagateConst > PublicSub_RefCount_NoConvert_Assert_DontPropagate_ptr; typedef Loki::SmartPtr< PrivateSubClass, RefCounted, DisallowConversion, AssertCheck, DefaultSPStorage, DontPropagateConst > PrivateSub_RefCount_NoConvert_Assert_DontPropagate_ptr; // ---------------------------------------------------------------------------- /// @note Used for testing how well SmartPtr works with COM objects. typedef Loki::SmartPtr< MimicCOM, COMRefCounted, DisallowConversion, AssertCheck, DefaultSPStorage, DontPropagateConst > MimicCOM_ptr; // ---------------------------------------------------------------------------- void DoConstConversionTests( void ) { NonConstBase_RefCount_NoConvert_Assert_DontPropagate_ptr p1; ConstBase_RefCount_NoConvert_Assert_DontPropagate_ptr p2( p1 ); ConstBase_RefCount_NoConvert_Assert_Propagate_ptr p3( p1 ); NonConstBase_RefCount_NoConvert_Assert_Propagate_ptr p4( p1 ); // p1 = p2; // illegal! converts const to non-const. // p1 = p3; // illegal! converts const to non-const. p1 = p4; // legal, but dubious. Changes const-propagation policy. p2 = p1; // legal. natural const conversion. p2 = p3; // legal, but dubious. Changes const-propagation policy. p2 = p4; // legal, but dubious. Changes const-propagation policy. p3 = p1; // legal, but dubious. Changes const-propagation policy. p3 = p2; // legal, but dubious. Changes const-propagation policy. p3 = p4; // legal. natural const conversion. p4 = p1; // legal, but dubious. Changes const-propagation policy. // p4 = p2; // illegal! converts const to non-const. // p4 = p3; // illegal! converts const to non-const. } // ---------------------------------------------------------------------------- void DoOwnershipConversionTests( void ) { NonConstBase_RefCount_NoConvert_Assert_DontPropagate_ptr p1; NonConstBase_ComRef_NoConvert_Assert_DontPropagate_ptr p2; NonConstBase_RefLink_NoConvert_Assert_DontPropagate_ptr p3; NonConstBase_DeepCopy_NoConvert_Assert_DontPropagate_ptr p4( new BaseClass ); NonConstBase_KillCopy_NoConvert_Assert_DontPropagate_ptr p5; NonConstBase_NoCopy_NoConvert_Assert_DontPropagate_ptr p6; // legal constructions. Each should allow copy with same policies. NonConstBase_RefCount_NoConvert_Assert_DontPropagate_ptr p7( p1 ); NonConstBase_ComRef_NoConvert_Assert_DontPropagate_ptr p8( p2 ); NonConstBase_RefLink_NoConvert_Assert_DontPropagate_ptr p9( p3 ); NonConstBase_DeepCopy_NoConvert_Assert_DontPropagate_ptr p10( p4 ); NonConstBase_KillCopy_NoConvert_Assert_DontPropagate_ptr p11( p5 ); // illegal construction! Can't copy anything with NoCopy policy. // NonConstBase_NoCopy_NoConvert_Assert_DontPropagate_ptr p12( p6 ); // illegal constructions! Can't convert from one ownership policy to another. // NonConstBase_RefCount_NoConvert_Assert_DontPropagate_ptr p13( p2 ); // NonConstBase_RefCount_NoConvert_Assert_DontPropagate_ptr p14( p3 ); // NonConstBase_RefCount_NoConvert_Assert_DontPropagate_ptr p15( p4 ); // NonConstBase_RefCount_NoConvert_Assert_DontPropagate_ptr p16( p5 ); // NonConstBase_RefCount_NoConvert_Assert_DontPropagate_ptr p17( p6 ); // illegal constructions! Can't convert from one ownership policy to another. // NonConstBase_ComRef_NoConvert_Assert_DontPropagate_ptr p18( p1 ); // NonConstBase_ComRef_NoConvert_Assert_DontPropagate_ptr p19( p3 ); // NonConstBase_ComRef_NoConvert_Assert_DontPropagate_ptr p20( p4 ); // NonConstBase_ComRef_NoConvert_Assert_DontPropagate_ptr p21( p5 ); // NonConstBase_ComRef_NoConvert_Assert_DontPropagate_ptr p22( p6 ); // illegal constructions! Can't convert from one ownership policy to another. // NonConstBase_RefLink_NoConvert_Assert_DontPropagate_ptr p23( p1 ); // NonConstBase_RefLink_NoConvert_Assert_DontPropagate_ptr p24( p2 ); // NonConstBase_RefLink_NoConvert_Assert_DontPropagate_ptr p25( p4 ); // NonConstBase_RefLink_NoConvert_Assert_DontPropagate_ptr p26( p5 ); // NonConstBase_RefLink_NoConvert_Assert_DontPropagate_ptr p27( p6 ); // illegal constructions! Can't convert from one ownership policy to another. // NonConstBase_DeepCopy_NoConvert_Assert_DontPropagate_ptr p28( p1 ); // NonConstBase_DeepCopy_NoConvert_Assert_DontPropagate_ptr p29( p2 ); // NonConstBase_DeepCopy_NoConvert_Assert_DontPropagate_ptr p30( p3 ); // NonConstBase_DeepCopy_NoConvert_Assert_DontPropagate_ptr p31( p5 ); // NonConstBase_DeepCopy_NoConvert_Assert_DontPropagate_ptr p32( p6 ); // illegal constructions! Can't convert from one ownership policy to another. // NonConstBase_KillCopy_NoConvert_Assert_DontPropagate_ptr p33( p1 ); // NonConstBase_KillCopy_NoConvert_Assert_DontPropagate_ptr p34( p2 ); // NonConstBase_KillCopy_NoConvert_Assert_DontPropagate_ptr p35( p3 ); // NonConstBase_KillCopy_NoConvert_Assert_DontPropagate_ptr p36( p4 ); // NonConstBase_KillCopy_NoConvert_Assert_DontPropagate_ptr p37( p6 ); // illegal constructions! Can't convert from one ownership policy to another. // NonConstBase_NoCopy_NoConvert_Assert_DontPropagate_ptr p38( p1 ); // NonConstBase_NoCopy_NoConvert_Assert_DontPropagate_ptr p39( p2 ); // NonConstBase_NoCopy_NoConvert_Assert_DontPropagate_ptr p40( p3 ); // NonConstBase_NoCopy_NoConvert_Assert_DontPropagate_ptr p41( p4 ); // NonConstBase_NoCopy_NoConvert_Assert_DontPropagate_ptr p42( p5 ); // illegal assignements! Can't convert from one ownership policy to another. // p1 = p2; // p1 = p3; // p1 = p4; // p1 = p5; // p1 = p6; // p2 = p1; // p2 = p3; // p2 = p4; // p2 = p5; // p2 = p6; // p3 = p1; // p3 = p2; // p3 = p4; // p3 = p5; // p3 = p6; // p4 = p1; // p4 = p2; // p4 = p3; // p4 = p5; // p4 = p6; // p5 = p1; // p5 = p2; // p5 = p3; // p5 = p4; // p5 = p6; // p6 = p1; // p6 = p2; // p6 = p3; // p6 = p4; // p6 = p5; } // ---------------------------------------------------------------------------- void DoInheritanceConversionTests( void ) { NonConstBase_RefCount_NoConvert_Assert_DontPropagate_ptr p1; PublicSub_RefCount_NoConvert_Assert_DontPropagate_ptr p2; PrivateSub_RefCount_NoConvert_Assert_DontPropagate_ptr p3; p1 = p2; // legal. Cast to public base class allowed. assert( p1 == p2 ); // p1 = p3; // illegal! Can't assign pointer since base class is private. // p2 = p1; // illegal! Can't do cast to derived class in pointer assignment. // p2 = p3; // illegal! Can't assign when types are unrelated. // p3 = p1; // illegal! Can't do cast to derived class in pointer assignment. // p3 = p2; // illegal! Can't assign when types are unrelated. NonConstBase_RefCount_NoConvert_Assert_DontPropagate_ptr p4( p2 ); assert( p4 == p1 ); assert( p4 == p2 ); // These copy-constructions are illegal for reasons shown above. // NonConstBase_RefCount_NoConvert_Assert_DontPropagate_ptr p5( p3 ); // PublicSub_RefCount_NoConvert_Assert_DontPropagate_ptr p6( p1 ); // PublicSub_RefCount_NoConvert_Assert_DontPropagate_ptr p7( p3 ); // PrivateSub_RefCount_NoConvert_Assert_DontPropagate_ptr p8( p1 ); // PrivateSub_RefCount_NoConvert_Assert_DontPropagate_ptr p9( p2 ); } // ---------------------------------------------------------------------------- void DoRefCountSwapTests( void ) { NonConstBase_RefCount_NoConvert_Assert_DontPropagate_ptr p1( new BaseClass ); NonConstBase_RefCount_NoConvert_Assert_DontPropagate_ptr p2( new BaseClass ); NonConstBase_RefCount_NoConvert_Assert_DontPropagate_ptr p3( p1 ); NonConstBase_RefCount_NoConvert_Assert_DontPropagate_ptr p4( p2 ); // p1 == p3 and p2 == p4 assert( p1 == p3 ); assert( p1 != p2 ); assert( p1 != p4 ); assert( p2 == p4 ); assert( p2 != p3 ); assert( p2 != p1 ); // p1 == p4 and p2 == p3 p3.Swap( p4 ); assert( p1 == p4 ); assert( p1 != p2 ); assert( p1 != p3 ); assert( p2 == p3 ); assert( p2 != p4 ); assert( p2 != p1 ); // p1 == p3 and p2 == p4 p3.Swap( p4 ); assert( p1 == p3 ); assert( p1 != p2 ); assert( p1 != p4 ); assert( p2 == p4 ); assert( p2 != p3 ); assert( p2 != p1 ); // p2 == p3 and p1 == p4 p1.Swap( p2 ); assert( p1 == p4 ); assert( p1 != p2 ); assert( p1 != p3 ); assert( p2 == p3 ); assert( p2 != p4 ); assert( p2 != p1 ); // p2 == p3 and p1 == p4 p1.Swap( p1 ); assert( p1 == p4 ); assert( p1 != p2 ); assert( p1 != p3 ); assert( p2 == p3 ); assert( p2 != p4 ); assert( p2 != p1 ); // p2 == p3 and p4 == p1 p1.Swap( p4 ); assert( p1 == p4 ); assert( p1 != p2 ); assert( p1 != p3 ); assert( p2 == p3 ); assert( p2 != p4 ); assert( p2 != p1 ); } // ---------------------------------------------------------------------------- void DoRefLinkSwapTests( void ) { BaseClass * pBaseClass = new BaseClass; NonConstBase_RefLink_NoConvert_Assert_DontPropagate_ptr p1( pBaseClass ); NonConstBase_RefLink_NoConvert_Assert_DontPropagate_ptr p2( new BaseClass ); p1->DoThat(); p2->DoThat(); NonConstBase_RefLink_NoConvert_Assert_DontPropagate_ptr p3( p1 ); NonConstBase_RefLink_NoConvert_Assert_DontPropagate_ptr p4( p2 ); NonConstBase_RefLink_NoConvert_Assert_DontPropagate_ptr p5; NonConstBase_RefLink_NoConvert_Assert_DontPropagate_ptr p6( new BaseClass ); // p1 <---> p3 and p2 <---> p4 and p5 and p6 assert( p1 == p3 ); assert( p1 != p2 ); assert( p1 != p4 ); assert( p2 == p4 ); assert( p2 != p3 ); assert( p2 != p1 ); assert( p1 != p5 ); assert( p2 != p5 ); assert( p3 != p5 ); assert( p4 != p5 ); assert( p1 == p1 ); assert( p2 == p2 ); assert( p3 == p3 ); assert( p4 == p4 ); assert( p5 == p5 ); p3.Swap( p4 ); // p1 <---> p4 and p2 <---> p3 and p5 and p6 assert( p1 == p4 ); assert( p1 != p2 ); assert( p1 != p3 ); assert( p2 == p3 ); assert( p2 != p4 ); assert( p2 != p1 ); assert( p1 != p5 ); assert( p2 != p5 ); assert( p3 != p5 ); assert( p4 != p5 ); assert( p1 == p1 ); assert( p2 == p2 ); assert( p3 == p3 ); assert( p4 == p4 ); assert( p5 == p5 ); p3.Swap( p4 ); // p1 <---> p3 and p2 <---> p4 and p5 and p6 assert( p1 == p3 ); assert( p1 != p2 ); assert( p1 != p4 ); assert( p2 == p4 ); assert( p2 != p3 ); assert( p2 != p1 ); assert( p1 != p5 ); assert( p2 != p5 ); assert( p3 != p5 ); assert( p4 != p5 ); assert( p1 == p1 ); assert( p2 == p2 ); assert( p3 == p3 ); assert( p4 == p4 ); assert( p5 == p5 ); p1.Swap( p2 ); // p2 <---> p3 and p1 <---> p4 and p5 and p6 assert( p1 != pBaseClass ); assert( p2 == pBaseClass ); assert( p1 == p4 ); assert( p1 != p2 ); assert( p1 != p3 ); assert( p2 == p3 ); assert( p2 != p4 ); assert( p2 != p1 ); assert( p1 != p5 ); assert( p2 != p5 ); assert( p3 != p5 ); assert( p4 != p5 ); assert( p1 == p1 ); assert( p2 == p2 ); assert( p3 == p3 ); assert( p4 == p4 ); assert( p5 == p5 ); p1.Swap( p1 ); // p2 <---> p3 and p1 <---> p4 and p5 and p6 assert( p1 == p4 ); assert( p1 != p2 ); assert( p1 != p3 ); assert( p2 == p3 ); assert( p2 != p4 ); assert( p2 != p1 ); assert( p1 != p5 ); assert( p2 != p5 ); assert( p3 != p5 ); assert( p4 != p5 ); assert( p1 == p1 ); assert( p2 == p2 ); assert( p3 == p3 ); assert( p4 == p4 ); assert( p5 == p5 ); p1.Swap( p4 ); // p2 <---> p3 and p4 <---> p1 and p5 and p6 assert( p1 == p4 ); assert( p1 != p2 ); assert( p1 != p3 ); assert( p2 == p3 ); assert( p2 != p4 ); assert( p2 != p1 ); assert( p1 != p5 ); assert( p2 != p5 ); assert( p3 != p5 ); assert( p4 != p5 ); assert( p1 == p1 ); assert( p2 == p2 ); assert( p3 == p3 ); assert( p4 == p4 ); assert( p5 == p5 ); p4.Swap( p1 ); // p2 <---> p3 and p4 <---> p1 and p5 and p6 assert( p1 == p4 ); assert( p1 != p2 ); assert( p1 != p3 ); assert( p2 == p3 ); assert( p2 != p4 ); assert( p2 != p1 ); assert( p1 != p5 ); assert( p2 != p5 ); assert( p3 != p5 ); assert( p4 != p5 ); assert( p1 == p1 ); assert( p2 == p2 ); assert( p3 == p3 ); assert( p4 == p4 ); assert( p5 == p5 ); p5.Swap( p5 ); // p2 <---> p3 and p4 <---> p1 and p5 and p6 assert( p1 == p1 ); assert( p2 == p2 ); assert( p3 == p3 ); assert( p4 == p4 ); assert( p1 != p5 ); assert( p2 != p5 ); assert( p3 != p5 ); assert( p4 != p5 ); p5.Swap( p1 ); // p2 <---> p3 and p4 <---> p5 and p1 and p6 assert( p5 == p4 ); assert( p5 != p2 ); assert( p5 != p3 ); assert( p2 == p3 ); assert( p2 != p4 ); assert( p2 != p5 ); assert( p1 != p5 ); assert( p2 != p1 ); assert( p3 != p1 ); assert( p4 != p1 ); assert( p1 == p1 ); assert( p2 == p2 ); assert( p3 == p3 ); assert( p4 == p4 ); assert( p5 == p5 ); p6.Swap( p1 ); // p2 <---> p3 and p4 <---> p5 and p1 and p6 assert( p5 == p4 ); assert( p5 != p2 ); assert( p5 != p3 ); assert( p2 == p3 ); assert( p2 != p4 ); assert( p2 != p5 ); assert( p1 != p5 ); assert( p2 != p1 ); assert( p3 != p1 ); assert( p4 != p1 ); assert( p1 == p1 ); assert( p2 == p2 ); assert( p3 == p3 ); assert( p4 == p4 ); assert( p5 == p5 ); assert( p6 == p6 ); p5.Swap( p1 ); // p2 <---> p3 and p4 <---> p1 and p5 and p6 assert( p1 == p4 ); assert( p1 != p2 ); assert( p1 != p3 ); assert( p2 == p3 ); assert( p2 != p4 ); assert( p2 != p1 ); assert( p1 != p5 ); assert( p2 != p5 ); assert( p3 != p5 ); assert( p4 != p5 ); assert( p1 == p1 ); assert( p2 == p2 ); assert( p3 == p3 ); assert( p4 == p4 ); assert( p5 == p5 ); p6 = p2; // p6 <---> p2 <---> p3 and p4 <---> p1 and p5 assert( p6 == p2 ); assert( p6 == p3 ); assert( p2 == p3 ); assert( p1 == p4 ); assert( p5 != p3 ); assert( p2 != p4 ); assert( p2 != p5 ); assert( p1 != p5 ); assert( p2 != p1 ); assert( p3 != p1 ); assert( p1 == p1 ); assert( p2 == p2 ); assert( p3 == p3 ); assert( p4 == p4 ); assert( p5 == p5 ); assert( p6 == p6 ); p5 = p3; // p6 <---> p2 <---> p3 <---> p5 and p4 <---> p1 assert( p6 == p5 ); assert( p6 == p2 ); assert( p6 == p3 ); assert( p5 == p3 ); assert( p2 == p3 ); assert( p1 == p4 ); assert( p2 != p4 ); assert( p1 != p5 ); assert( p2 != p1 ); assert( p3 != p1 ); assert( p1 == p1 ); assert( p2 == p2 ); assert( p3 == p3 ); assert( p4 == p4 ); assert( p5 == p5 ); assert( p6 == p6 ); p5.Swap( p3 ); // p6 <---> p2 <---> p5 <---> p3 and p4 <---> p1 assert( p6 == p5 ); assert( p6 == p2 ); assert( p6 == p3 ); assert( p5 == p3 ); assert( p2 == p3 ); assert( p1 == p4 ); assert( p2 != p4 ); assert( p1 != p5 ); assert( p2 != p1 ); assert( p3 != p1 ); assert( p1 == p1 ); assert( p2 == p2 ); assert( p3 == p3 ); assert( p4 == p4 ); assert( p5 == p5 ); assert( p6 == p6 ); p2.Swap( p3 ); // p6 <---> p3 <---> p5 <---> p2 and p4 <---> p1 assert( p6 == p5 ); assert( p6 == p2 ); assert( p6 == p3 ); assert( p5 == p3 ); assert( p2 == p3 ); assert( p1 == p4 ); assert( p2 != p4 ); assert( p1 != p5 ); assert( p2 != p1 ); assert( p3 != p1 ); assert( p1 == p1 ); assert( p2 == p2 ); assert( p3 == p3 ); assert( p4 == p4 ); assert( p5 == p5 ); assert( p6 == p6 ); bool merged = false; NonConstBase_RefLink_NoConvert_Assert_DontPropagate_ptr p7( pBaseClass ); assert( p7 == p7 ); assert( p6 == p7 ); assert( p1 != p7 ); merged = p7.Merge( p6 ); // p7 <---> p6 <---> p3 <---> p5 <---> p2 and p4 <---> p1 assert( merged ); assert( p6 == p7 ); assert( p1 != p7 ); assert( p6 == p5 ); assert( p6 == p2 ); assert( p6 == p3 ); assert( p5 == p3 ); assert( p2 == p3 ); assert( p1 == p4 ); assert( p2 != p4 ); assert( p1 != p5 ); assert( p2 != p1 ); assert( p3 != p1 ); assert( p1 == p1 ); assert( p2 == p2 ); assert( p3 == p3 ); assert( p4 == p4 ); assert( p5 == p5 ); assert( p6 == p6 ); assert( p7 == p7 ); NonConstBase_RefLink_NoConvert_Assert_DontPropagate_ptr p8( pBaseClass ); assert( p6 == p8 ); assert( p1 != p8 ); merged = p6.Merge( p8 ); // p7 <---> p6 <---> p8 <---> p3 <---> p5 <---> p2 and p4 <---> p1 assert( merged ); assert( p6 == p8 ); assert( p6 == p7 ); assert( p1 != p7 ); assert( p6 == p5 ); assert( p6 == p2 ); assert( p6 == p3 ); assert( p5 == p3 ); assert( p2 == p3 ); assert( p1 == p4 ); assert( p2 != p4 ); assert( p1 != p5 ); assert( p2 != p1 ); assert( p3 != p1 ); assert( p1 == p1 ); assert( p2 == p2 ); assert( p3 == p3 ); assert( p4 == p4 ); assert( p5 == p5 ); assert( p6 == p6 ); assert( p7 == p7 ); assert( p8 == p8 ); merged = p6.Merge( p6 ); // p7 <---> p6 <---> p8 <---> p3 <---> p5 <---> p2 and p4 <---> p1 assert( merged ); assert( p6 == p8 ); assert( p6 == p7 ); assert( p1 != p7 ); assert( p6 == p5 ); assert( p6 == p2 ); assert( p6 == p3 ); assert( p5 == p3 ); assert( p2 == p3 ); assert( p1 == p4 ); assert( p2 != p4 ); assert( p1 != p5 ); assert( p2 != p1 ); assert( p3 != p1 ); assert( p1 == p1 ); assert( p2 == p2 ); assert( p3 == p3 ); assert( p4 == p4 ); assert( p5 == p5 ); assert( p6 == p6 ); assert( p7 == p7 ); assert( p8 == p8 ); merged = p6.Merge( p3 ); // p7 <---> p6 <---> p8 <---> p3 <---> p5 <---> p2 and p4 <---> p1 assert( merged ); assert( p6 == p8 ); assert( p6 == p7 ); assert( p1 != p7 ); assert( p6 == p5 ); assert( p6 == p2 ); assert( p6 == p3 ); assert( p5 == p3 ); assert( p2 == p3 ); assert( p1 == p4 ); assert( p2 != p4 ); assert( p1 != p5 ); assert( p2 != p1 ); assert( p3 != p1 ); assert( p1 == p1 ); assert( p2 == p2 ); assert( p3 == p3 ); assert( p4 == p4 ); assert( p5 == p5 ); assert( p6 == p6 ); assert( p7 == p7 ); assert( p8 == p8 ); merged = p5.Merge( p1 ); // p7 <---> p6 <---> p8 <---> p3 <---> p5 <---> p2 and p4 <---> p1 assert( !merged ); assert( p6 == p8 ); assert( p6 == p7 ); assert( p1 != p7 ); assert( p6 == p5 ); assert( p6 == p2 ); assert( p6 == p3 ); assert( p5 == p3 ); assert( p2 == p3 ); assert( p1 == p4 ); assert( p2 != p4 ); assert( p1 != p5 ); assert( p2 != p1 ); assert( p3 != p1 ); assert( p1 == p1 ); assert( p2 == p2 ); assert( p3 == p3 ); assert( p4 == p4 ); assert( p5 == p5 ); assert( p6 == p6 ); assert( p7 == p7 ); assert( p8 == p8 ); NonConstBase_RefLink_NoConvert_Assert_DontPropagate_ptr p9( pBaseClass ); NonConstBase_RefLink_NoConvert_Assert_DontPropagate_ptr pA( p9 ); assert( p9 == pA ); assert( p9 == p8 ); assert( p1 != p8 ); merged = p9.Merge( p1 ); // p7 <---> p6 <---> p8 <---> p3 <---> p5 <---> p2 // and p4 <---> p1 and p9 <---> pA assert( !merged ); assert( p6 == p8 ); assert( p6 == p7 ); assert( p1 != p7 ); assert( p6 == p5 ); assert( p6 == p2 ); assert( p6 == p3 ); assert( p5 == p3 ); assert( p2 == p3 ); assert( p1 == p4 ); assert( p2 != p4 ); assert( p1 != p5 ); assert( p2 != p1 ); assert( p3 != p1 ); assert( p1 == p1 ); assert( p2 == p2 ); assert( p3 == p3 ); assert( p4 == p4 ); assert( p5 == p5 ); assert( p6 == p6 ); assert( p7 == p7 ); assert( p8 == p8 ); assert( p9 == p9 ); assert( pA == pA ); merged = p9.Merge( p2 ); // p7 <---> p6 <---> p8 <---> p3 <---> p5 <---> p2 <---> p9 <---> pA // and p4 <---> p1 assert( merged ); assert( p6 == p8 ); assert( p6 == p7 ); assert( p1 != p7 ); assert( p6 == p5 ); assert( p6 == p2 ); assert( p6 == p3 ); assert( p5 == p3 ); assert( p2 == p3 ); assert( p1 == p4 ); assert( p2 != p4 ); assert( p1 != p5 ); assert( p2 != p1 ); assert( p3 != p1 ); assert( p1 == p1 ); assert( p2 == p2 ); assert( p3 == p3 ); assert( p4 == p4 ); assert( p5 == p5 ); assert( p6 == p6 ); assert( p7 == p7 ); assert( p8 == p8 ); assert( p9 == p9 ); assert( pA == pA ); } // ---------------------------------------------------------------------------- void DoRefLinkTests( void ) { const unsigned int ctorCount = BaseClass::GetCtorCount(); (void) ctorCount; const unsigned int dtorCount = BaseClass::GetDtorCount(); (void) dtorCount; assert( BaseClass::GetCtorCount() == BaseClass::GetDtorCount() ); { NonConstBase_RefLink_NoConvert_Assert_DontPropagate_ptr w0; NonConstBase_RefLink_NoConvert_Assert_DontPropagate_ptr w1; } assert( ctorCount == BaseClass::GetCtorCount() ); assert( dtorCount == BaseClass::GetDtorCount() ); { NonConstBase_RefLink_NoConvert_Assert_DontPropagate_ptr w3( new BaseClass ); NonConstBase_RefLink_NoConvert_Assert_DontPropagate_ptr w4( new BaseClass ); assert( w3 != w4 ); assert( w3 ); assert( w4 ); w3 = w4; assert( w3 == w4 ); assert( w3 ); assert( w4 ); assert( dtorCount + 1 == BaseClass::GetDtorCount() ); w3->DoThat(); } assert( ctorCount + 2 == BaseClass::GetCtorCount() ); assert( dtorCount + 2 == BaseClass::GetDtorCount() ); assert( BaseClass::GetCtorCount() == BaseClass::GetDtorCount() ); } // ---------------------------------------------------------------------------- void DoRefCountNullPointerTests( void ) { BaseClass * pNull = NULL; (void) pNull; const unsigned int ctorCount = BaseClass::GetCtorCount(); (void) ctorCount; const unsigned int dtorCount = BaseClass::GetDtorCount(); (void) dtorCount; assert( BaseClass::GetCtorCount() == BaseClass::GetDtorCount() ); { NonConstBase_RefCount_NoConvert_Assert_DontPropagate_ptr p0; NonConstBase_RefCount_NoConvert_Assert_DontPropagate_ptr p1; NonConstBase_RefCount_NoConvert_Assert_DontPropagate_ptr p2( p0 ); assert( !p0 ); assert( !p1 ); assert( !p2 ); assert( p1 == pNull ); assert( p0 == pNull ); assert( pNull == p0 ); assert( pNull == p1 ); assert( pNull == p2 ); assert( p0 == p0 ); assert( p1 == p1 ); assert( p2 == p2 ); assert( p1 == p0 ); assert( p0 == p1 ); assert( p2 == p0 ); assert( p0 == p2 ); assert( p1 <= p0 ); assert( p1 >= p0 ); assert( p0 <= p1 ); assert( p0 >= p1 ); assert( p2 <= p0 ); assert( p2 >= p0 ); assert( p0 <= p2 ); assert( p0 >= p2 ); assert( !( p1 < p0 ) ); assert( !( p1 > p0 ) ); assert( !( p0 < p1 ) ); assert( !( p0 > p1 ) ); assert( !( p2 < p0 ) ); assert( !( p2 > p0 ) ); assert( !( p0 < p2 ) ); assert( !( p0 > p2 ) ); assert( !( p0 < pNull ) ); assert( !( p0 > pNull ) ); assert( !( pNull < p0 ) ); assert( !( pNull > p0 ) ); } assert( ctorCount == BaseClass::GetCtorCount() ); assert( dtorCount == BaseClass::GetDtorCount() ); } // ---------------------------------------------------------------------------- void DoRefLinkNullPointerTests( void ) { BaseClass * pNull = NULL; (void) pNull; const unsigned int ctorCount = BaseClass::GetCtorCount(); (void) ctorCount; const unsigned int dtorCount = BaseClass::GetDtorCount(); (void) dtorCount; assert( BaseClass::GetCtorCount() == BaseClass::GetDtorCount() ); { NonConstBase_RefLink_NoConvert_Assert_DontPropagate_ptr p0; NonConstBase_RefLink_NoConvert_Assert_DontPropagate_ptr p1; NonConstBase_RefLink_NoConvert_Assert_DontPropagate_ptr p2( p0 ); assert( !p0 ); assert( !p1 ); assert( !p2 ); assert( p1 == pNull ); assert( p0 == pNull ); assert( pNull == p0 ); assert( pNull == p1 ); assert( pNull == p2 ); assert( p0 == p0 ); assert( p1 == p1 ); assert( p2 == p2 ); assert( p1 == p0 ); assert( p0 == p1 ); assert( p2 == p0 ); assert( p0 == p2 ); assert( p1 <= p0 ); assert( p1 >= p0 ); assert( p0 <= p1 ); assert( p0 >= p1 ); assert( p2 <= p0 ); assert( p2 >= p0 ); assert( p0 <= p2 ); assert( p0 >= p2 ); assert( !( p1 < p0 ) ); assert( !( p1 > p0 ) ); assert( !( p0 < p1 ) ); assert( !( p0 > p1 ) ); assert( !( p2 < p0 ) ); assert( !( p2 > p0 ) ); assert( !( p0 < p2 ) ); assert( !( p0 > p2 ) ); assert( !( p0 < pNull ) ); assert( !( p0 > pNull ) ); assert( !( pNull < p0 ) ); assert( !( pNull > p0 ) ); } assert( ctorCount == BaseClass::GetCtorCount() ); assert( dtorCount == BaseClass::GetDtorCount() ); } // ---------------------------------------------------------------------------- void DoComRefTest( void ) { const unsigned int ctorCount = MimicCOM::GetCtorCount(); (void) ctorCount; const unsigned int dtorCount = MimicCOM::GetDtorCount(); (void) dtorCount; assert( MimicCOM::AllDestroyed() ); { MimicCOM_ptr p1; } assert( MimicCOM::AllDestroyed() ); assert( ctorCount == MimicCOM::GetCtorCount() ); assert( dtorCount == MimicCOM::GetDtorCount() ); { MimicCOM_ptr p1( MimicCOM::QueryInterface() ); } assert( ctorCount+1 == MimicCOM::GetCtorCount() ); assert( dtorCount+1 == MimicCOM::GetDtorCount() ); { MimicCOM_ptr p2( MimicCOM::QueryInterface() ); MimicCOM_ptr p3( p2 ); MimicCOM_ptr p4; p4 = p2; } assert( ctorCount+2 == MimicCOM::GetCtorCount() ); assert( dtorCount+2 == MimicCOM::GetDtorCount() ); } // ---------------------------------------------------------------------------- void DoForwardReferenceTest( void ) { /** @note These lines should cause the compiler to make a warning message about attempting to delete an undefined type. But it should not produce any error messages. */ Thingy_DefaultStorage_ptr p1; Thingy_DefaultStorage_ptr p2( p1 ); Thingy_DefaultStorage_ptr p3; p3 = p2; /** @note These lines should cause the compiler to make an error message about attempting to call the destructor for an undefined type. */ //Thingy_HeapStorage_ptr p4; //Thingy_HeapStorage_ptr p5( p4 ); //Thingy_HeapStorage_ptr p6; //p6 = p5; } int main( int argc, const char * argv[] ) { bool doThreadTest = false; for ( int ii = 1; ii < argc; ++ii ) { if ( ::strcmp( argv[ii], "-t" ) == 0 ) doThreadTest = true; } DoRefLinkTests(); DoWeakLeakTest(); DoStrongRefCountTests(); DoStrongReleaseTests(); DoStrongReleaseTests(); DoWeakCycleTests(); DoStrongCompareTests(); DoForwardReferenceTest(); DoStrongForwardReferenceTest(); DoRefCountNullPointerTests(); DoRefLinkNullPointerTests(); DoRefCountSwapTests(); DoRefLinkSwapTests(); DoComRefTest(); DoStrongConstTests(); DoConstConversionTests(); DoOwnershipConversionTests(); DoInheritanceConversionTests(); #if defined (LOKI_OBJECT_LEVEL_THREADING) || defined (LOKI_CLASS_LEVEL_THREADING) if ( doThreadTest ) { DoLockedStorageTest(); DoLockedPtrTest(); } #endif // Check that nothing was leaked. assert( BaseClass::AllDestroyed() ); assert( !BaseClass::ExtraConstructions() ); // Check that no destructor called too often. assert( !BaseClass::ExtraDestructions() ); cout << "All SmartPtr tests passed!" << endl; return 0; } // ---------------------------------------------------------------------------- #include struct Foo { }; typedef Loki::SmartPtr < BaseClass, RefCounted, DisallowConversion, AssertCheck, DefaultSPStorage, DontPropagateConst > Ptr; bool Compare( const Ptr&, const Ptr&) { return true; } void friend_handling() { // http://sourceforge.net/tracker/index.php?func=detail&aid=1570582&group_id=29557&atid=396644 // friend injection // see http://gcc.gnu.org/bugzilla/show_bug.cgi?id=28597 std::vector vec; std::sort( vec.begin(), vec.end(), Compare ); std::nth_element( vec.begin(), vec.begin(), vec.end(), Compare ); std::search( vec.begin(), vec.end(), vec.begin(), vec.end(), Compare ); Ptr a, b; Compare( a, b ); // http://gcc.gnu.org/bugzilla/show_bug.cgi?id=29486 BaseClass * pNull ; Ptr w1( new BaseClass ); Release( w1, pNull ); } // ---------------------------------------------------------------------------- // $Log$ // Revision 1.14 2006/10/17 10:36:08 syntheticpp // change line ending // // Revision 1.13 2006/10/17 10:09:37 syntheticpp // add test code for template friends with template template parameters // // Revision 1.12 2006/10/16 11:48:13 syntheticpp // by default Loki is compiled without thread support, so we must disable the dependency on thread classes (StrongPtr) to avaoid linker errors when compiling with the default build process. Should we change the default threading of Loki? // // Revision 1.11 2006/10/13 23:59:42 rich_sposato // Added check for -t command line parameter to do lock-thread test. // Changed ending chars of some lines from LF to CR-LF to be consistent. // // Revision 1.10 2006/10/11 11:17:53 syntheticpp // test injected friends. Thanks to Sigoure Benoit // // Revision 1.9 2006/05/30 14:17:05 syntheticpp // don't confuse with warnings // // Revision 1.8 2006/05/18 05:05:21 rich_sposato // Added QueryInterface function to MimicCOM class. // // Revision 1.7 2006/04/28 00:34:21 rich_sposato // Added test for thread-safe StrongPtr policy. // // Revision 1.6 2006/04/16 14:05:39 syntheticpp // remove warnings // // Revision 1.5 2006/04/05 22:53:12 rich_sposato // Added StrongPtr class to Loki along with tests for StrongPtr. // // Revision 1.4 2006/03/21 20:50:22 syntheticpp // fix include error // // Revision 1.3 2006/03/17 22:52:56 rich_sposato // Fixed bugs 1452805 and 1451835. Added Merge ability for RefLink policy. // Added more tests for SmartPtr. // // Revision 1.2 2006/03/01 02:08:11 rich_sposato // Fixed bug 1440694 by adding check if rhs is previous neighbor. // // Revision 1.1 2006/02/25 01:53:20 rich_sposato // Added test project for Loki::SmartPtr class. // libloki-0.1.7.orig/test/SmartPtr/base.h0000644000175000017500000001075410515240622016401 0ustar ivanivan//////////////////////////////////////////////////////////////////////////////// // Test program for The Loki Library // Copyright (c) 2006 Richard Sposato // 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 authors make no representations about the // suitability of this software for any purpose. It is provided "as is" // without express or implied warranty. //////////////////////////////////////////////////////////////////////////////// // $Id: base.h 761 2006-10-17 20:48:18Z syntheticpp $ #include // ---------------------------------------------------------------------------- class BaseClass { public: BaseClass( void ) { s_constructions++; } virtual ~BaseClass( void ) { s_destructions++; } // These 2 functions are so we can pretend we have a COM object. void AddRef( void ) {} void Release( void ) {} // This function is used only for the DeepCopy policy. virtual BaseClass * Clone( void ) const { return new BaseClass(); } void DoThat( void ) const {} static inline bool AllDestroyed( void ) { return ( s_constructions == s_destructions ); } static inline bool ExtraConstructions( void ) { return ( s_constructions > s_destructions ); } static inline bool ExtraDestructions( void ) { return ( s_constructions < s_destructions ); } static inline unsigned int GetCtorCount( void ) { return s_constructions; } static inline unsigned int GetDtorCount( void ) { return s_destructions; } private: /// Not implemented. BaseClass( const BaseClass & ); /// Not implemented. BaseClass & operator = ( const BaseClass & ); static unsigned int s_constructions; static unsigned int s_destructions; }; // ---------------------------------------------------------------------------- class PublicSubClass : public BaseClass { public: // This function is used only for the DeepCopy policy. virtual BaseClass * Clone( void ) const { return new PublicSubClass; } }; // ---------------------------------------------------------------------------- class PrivateSubClass : private BaseClass { public: // This function is used only for the DeepCopy policy. virtual BaseClass * Clone( void ) const { return new PrivateSubClass; } }; // ---------------------------------------------------------------------------- /** @class MimicCOM Acts like a COM object by having an intrusive ref count. */ class MimicCOM { public: static MimicCOM * QueryInterface( void ) { MimicCOM * p = new MimicCOM; p->AddRef(); return p; } virtual ~MimicCOM( void ) { s_destructions++; } void AddRef( void ) { m_count++; m_AddRefCount++; } void Release( void ) { m_ReleaseCount++; assert( 0 < m_count ); m_count--; if ( 0 == m_count ) { /** @note I consider "delete this;" to be very unsafe! I'm only using it here for the purpose of testing. */ delete this; } } void DoThat( void ) {} static inline bool AllDestroyed( void ) { return ( s_constructions == s_destructions ); } static inline bool ExtraConstructions( void ) { return ( s_constructions > s_destructions ); } static inline bool ExtraDestructions( void ) { return ( s_constructions < s_destructions ); } static inline unsigned int GetCtorCount( void ) { return s_constructions; } static inline unsigned int GetDtorCount( void ) { return s_destructions; } private: /// Not implemented. MimicCOM( const MimicCOM & ); /// Not implemented. MimicCOM & operator = ( const MimicCOM & ); MimicCOM( void ) : m_count( 0 ) , m_AddRefCount( 0 ) , m_ReleaseCount( 0 ) { s_constructions++; } static unsigned int s_constructions; static unsigned int s_destructions; unsigned int m_count; unsigned int m_AddRefCount; unsigned int m_ReleaseCount; }; // ---------------------------------------------------------------------------- libloki-0.1.7.orig/test/SmartPtr/SmartPtr_MSVC_8.vcproj0000644000175000017500000001007311047143225021372 0ustar ivanivan libloki-0.1.7.orig/test/SmartPtr/SmartPtr.cbp0000644000175000017500000000272211047143225017556 0ustar ivanivan libloki-0.1.7.orig/test/SmartPtr/SmartPtr.dev0000644000175000017500000000515010515234750017571 0ustar ivanivan[Project] FileName=SmartPtr.dev Name=SmartPtr UnitCount=15 Type=1 Ver=1 ObjFiles= Includes=..\..\include Libs= PrivateResource= ResourceIncludes= MakeIncludes= Compiler= CppCompiler= Linker= IsCpp=1 Icon= ExeOutput= ObjectOutput= OverrideOutput=0 OverrideOutputName=SmartPtr.exe HostApplication= Folders=Headers,Sources,Tests CommandLine= UseCustomMakefile=0 CustomMakefile= IncludeVersionInfo=0 SupportXPThemes=0 CompilerSet=0 CompilerSettings=0000001001001001000000 [Unit1] FileName=main.cpp CompileCpp=1 Folder=Tests Compile=1 Link=1 Priority=1000 OverrideBuildCmd=0 BuildCmd= [Unit2] FileName=..\..\src\Singleton.cpp CompileCpp=1 Folder=Sources Compile=1 Link=1 Priority=1000 OverrideBuildCmd=0 BuildCmd= [Unit3] FileName=..\..\src\SmallObj.cpp CompileCpp=1 Folder=Sources Compile=1 Link=1 Priority=1000 OverrideBuildCmd=0 BuildCmd= [Unit4] FileName=..\..\include\loki\Threads.h CompileCpp=1 Folder=Headers Compile=1 Link=1 Priority=1000 OverrideBuildCmd=0 BuildCmd= [Unit5] FileName=..\..\include\loki\Singleton.h CompileCpp=1 Folder=Headers Compile=1 Link=1 Priority=1000 OverrideBuildCmd=0 BuildCmd= [Unit6] FileName=..\..\include\loki\SmallObj.h CompileCpp=1 Folder=Headers Compile=1 Link=1 Priority=1000 OverrideBuildCmd=0 BuildCmd= [Unit7] FileName=..\..\include\loki\SmartPtr.h CompileCpp=1 Folder=Headers Compile=1 Link=1 Priority=1000 OverrideBuildCmd=0 BuildCmd= [VersionInfo] Major=0 Minor=1 Release=1 Build=1 LanguageID=1033 CharsetID=1252 CompanyName= FileVersion= FileDescription=Developed using the Dev-C++ IDE InternalName= LegalCopyright= LegalTrademarks= OriginalFilename= ProductName= ProductVersion= AutoIncBuildNr=0 [Unit8] FileName=strong.cpp CompileCpp=1 Folder=Tests Compile=1 Link=1 Priority=1000 OverrideBuildCmd=0 BuildCmd= [Unit9] FileName=..\..\src\StrongPtr.cpp CompileCpp=1 Folder=Sources Compile=1 Link=1 Priority=1000 OverrideBuildCmd=0 BuildCmd= [Unit10] FileName=..\..\include\loki\StrongPtr.h CompileCpp=1 Folder=Headers Compile=1 Link=1 Priority=1000 OverrideBuildCmd=0 BuildCmd= [Unit11] FileName=..\..\src\SmartPtr.cpp CompileCpp=1 Folder=Sources Compile=1 Link=1 Priority=1000 OverrideBuildCmd=0 BuildCmd= [Unit12] FileName=base.h CompileCpp=1 Folder=Tests Compile=1 Link=1 Priority=1000 OverrideBuildCmd=0 BuildCmd= [Unit13] FileName=LockTest.cpp CompileCpp=1 Folder=Tests Compile=1 Link=1 Priority=1000 OverrideBuildCmd=0 BuildCmd= [Unit14] FileName=..\..\src\SafeFormat.cpp CompileCpp=1 Folder=Sources Compile=1 Link=1 Priority=1000 OverrideBuildCmd=0 BuildCmd= [Unit15] FileName=..\..\include\loki\SafeFormat.h CompileCpp=1 Folder=Headers Compile=1 Link=1 Priority=1000 OverrideBuildCmd=0 BuildCmd= libloki-0.1.7.orig/test/SmartPtr/SmartPtr.vcproj0000644000175000017500000001030011121554360020303 0ustar ivanivan libloki-0.1.7.orig/test/SmartPtr/LockTest.cpp0000644000175000017500000003071110571431117017550 0ustar ivanivan//////////////////////////////////////////////////////////////////////////////// // Test program for The Loki Library // Copyright (c) 2006 Richard Sposato // 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 authors make no representations about the // suitability of this software for any purpose. It is provided "as is" // without express or implied warranty. //////////////////////////////////////////////////////////////////////////////// // $Id: LockTest.cpp 817 2007-03-01 01:54:23Z rich_sposato $ // ---------------------------------------------------------------------------- #define LOKI_CLASS_LEVEL_THREADING //#define DO_EXTRA_LOKI_TESTS #if defined (LOKI_OBJECT_LEVEL_THREADING) || defined (LOKI_CLASS_LEVEL_THREADING) /// @note This test uses LOKI_OBJECT_LEVEL_THREADING because StrongPtr's /// LockableTwoRefCounts policy can't be used with a single-threaded model. /// It requires either object-level-locking or class-level-locking. #if defined(_WIN32) #include #include #define LOKI_WINDOWS_H #endif #include #include #include #include #include #include #include #include #include // ---------------------------------------------------------------------------- #if defined(_WIN32) typedef unsigned int ( WINAPI * ThreadFunction_ )( void * ); #define LOKI_pthread_t HANDLE #define LOKI_pthread_create(handle,attr,func,arg) \ (int)((*handle=(HANDLE) _beginthreadex (NULL,0,(ThreadFunction_)func,arg,0,NULL))==NULL) #define LOKI_pthread_join(thread) \ ((::WaitForSingleObject((thread),INFINITE)!=WAIT_OBJECT_0) || !CloseHandle(thread)) #else #define LOKI_pthread_t \ pthread_t #define LOKI_pthread_create(handle,attr,func,arg) \ pthread_create(handle,attr,func,arg) #define LOKI_pthread_join(thread) \ pthread_join(thread, NULL) #endif using namespace std; using namespace Loki; // ---------------------------------------------------------------------------- class Thread { public: typedef void * ( * CallFunction )( void * ); Thread( CallFunction func, void * parm ) : pthread_() , func_( func ) , parm_( parm ) { } void AssignTask( CallFunction func, void * parm ) { func_ = func; parm_ = parm; } int Start( void ) { return LOKI_pthread_create( &pthread_, NULL, func_, parm_ ); } int WaitForThread( void ) const { return LOKI_pthread_join( pthread_ ); } private: LOKI_pthread_t pthread_; CallFunction func_; void * parm_; }; // ---------------------------------------------------------------------------- class ThreadPool { public: ThreadPool( void ) : m_threads() { } void Create( size_t threadCount, Thread::CallFunction function ) { for( size_t ii = 0; ii < threadCount; ii++ ) { string buffer; SPrintf( buffer, "Creating thread %d\n" )( ii ); cout << buffer; Thread * thread = new Thread( function, reinterpret_cast< void * >( ii ) ); m_threads.push_back( thread ); } } void Start( void ) { for ( size_t ii = 0; ii < m_threads.size(); ii++ ) { string buffer; SPrintf( buffer, "Starting thread %d\n" )( ii ); cout << buffer; m_threads.at( ii )->Start(); } } void Join( void ) const { for ( size_t ii = 0; ii < m_threads.size(); ii++ ) m_threads.at( ii )->WaitForThread(); } ~ThreadPool( void ) { for ( size_t ii = 0; ii < m_threads.size(); ii++ ) { delete m_threads.at(ii); } } private: typedef std::vector< Thread * > Threads; Threads m_threads; }; // ---------------------------------------------------------------------------- static const unsigned int loop = 5; class A { public: A( void ) {} #define BIG_FOR_LOOP for( unsigned int i = 0; i < 5000000; i++ ) g++; void Print( int id ) const { BIG_FOR_LOOP;Printf("%d: ----------------\n")(id); BIG_FOR_LOOP;Printf("%d: ---------------\n")(id); BIG_FOR_LOOP;Printf("%d: --------------\n")(id); BIG_FOR_LOOP;Printf("%d: -------------\n")(id); BIG_FOR_LOOP;Printf("%d: ------------\n")(id); BIG_FOR_LOOP;Printf("%d: -----------\n")(id); BIG_FOR_LOOP;Printf("%d: ----------\n")(id); BIG_FOR_LOOP;Printf("%d: ---------\n")(id); BIG_FOR_LOOP;Printf("%d: --------\n")(id); BIG_FOR_LOOP;Printf("%d: -------\n")(id); BIG_FOR_LOOP;Printf("%d: ------\n")(id); BIG_FOR_LOOP;Printf("%d: -----\n")(id); BIG_FOR_LOOP;Printf("%d: ----\n")(id); BIG_FOR_LOOP;Printf("%d: ---\n")(id); BIG_FOR_LOOP;Printf("%d: --\n")(id); BIG_FOR_LOOP;Printf("%d: -\n")(id); BIG_FOR_LOOP;Printf("%d: \n")(id); } void Print( int id, int j ) const { BIG_FOR_LOOP;Printf("%d: %d: ----------------\n")(id)(j); BIG_FOR_LOOP;Printf("%d: %d: ---------------\n")(id)(j); BIG_FOR_LOOP;Printf("%d: %d: --------------\n")(id)(j); BIG_FOR_LOOP;Printf("%d: %d: -------------\n")(id)(j); BIG_FOR_LOOP;Printf("%d: %d: ------------\n")(id)(j); BIG_FOR_LOOP;Printf("%d: %d: -----------\n")(id)(j); BIG_FOR_LOOP;Printf("%d: %d: ----------\n")(id)(j); BIG_FOR_LOOP;Printf("%d: %d: ---------\n")(id)(j); BIG_FOR_LOOP;Printf("%d: %d: --------\n")(id)(j); BIG_FOR_LOOP;Printf("%d: %d: -------\n")(id)(j); BIG_FOR_LOOP;Printf("%d: %d: ------\n")(id)(j); BIG_FOR_LOOP;Printf("%d: %d: -----\n")(id)(j); BIG_FOR_LOOP;Printf("%d: %d: ----\n")(id)(j); BIG_FOR_LOOP;Printf("%d: %d: ---\n")(id)(j); BIG_FOR_LOOP;Printf("%d: %d: --\n")(id)(j); BIG_FOR_LOOP;Printf("%d: %d: -\n")(id)(j); BIG_FOR_LOOP;Printf("%d: %d: \n")(id)(j); } private: static unsigned int g; }; unsigned int A::g = 0; // ---------------------------------------------------------------------------- class LockedA : public A { public: LockedA( void ) : A(), m_mutex() {} ~LockedA( void ) {} void Lock( void ) const { m_mutex.Lock(); } void Unlock( void ) const { m_mutex.Unlock(); } private: mutable ::Loki::Mutex m_mutex; }; // ---------------------------------------------------------------------------- typedef ::Loki::StrongPtr< A, true, TwoRefCounts, DisallowConversion, NoCheck, NeverReset, DeleteSingle, DontPropagateConst > A_ptr; typedef ::Loki::StrongPtr< A, true, LockableTwoRefCounts, DisallowConversion, NoCheck, NeverReset, DeleteSingle, DontPropagateConst > A_Lockable_ptr; typedef ::Loki::SmartPtr< LockedA, RefCounted, DisallowConversion, ::Loki::AssertCheck, ::Loki::LockedStorage, DontPropagateConst > A_Locked_ptr; // ---------------------------------------------------------------------------- class SafeA { public: static SafeA & GetIt( void ) { if ( NULL == s_instance ) s_instance = new SafeA; return *s_instance; } static void Destroy( void ) { if ( NULL != s_instance ) { delete s_instance; s_instance = NULL; } } A_Lockable_ptr GetA (void) { return m_ptr; } private: static SafeA * s_instance; SafeA( void ) : m_ptr( new A ) {} ~SafeA( void ) {} A_Lockable_ptr m_ptr; }; SafeA * SafeA::s_instance = NULL; // ---------------------------------------------------------------------------- class UnsafeA { public: static UnsafeA & GetIt( void ) { if ( NULL == s_instance ) s_instance = new UnsafeA; return *s_instance; } static void Destroy( void ) { if ( NULL != s_instance ) { delete s_instance; s_instance = NULL; } } A_ptr GetA (void) { return m_ptr; } private: static UnsafeA * s_instance; UnsafeA( void ) : m_ptr( new A ) {} ~UnsafeA( void ) {} A_ptr m_ptr; }; UnsafeA * UnsafeA::s_instance = NULL; // ---------------------------------------------------------------------------- class SelfLockedA { public: static SelfLockedA & GetIt( void ) { if ( NULL == s_instance ) s_instance = new SelfLockedA; return *s_instance; } static void Destroy( void ) { if ( NULL != s_instance ) { delete s_instance; s_instance = NULL; } } A_Locked_ptr GetA (void) { return m_ptr; } private: static SelfLockedA * s_instance; SelfLockedA( void ) : m_ptr( new LockedA ) {} ~SelfLockedA( void ) {} A_Locked_ptr m_ptr; }; SelfLockedA * SelfLockedA::s_instance = NULL; // ---------------------------------------------------------------------------- void * RunLocked( void * id ) { A_Lockable_ptr ap( SafeA::GetIt().GetA() ); const ptrdiff_t threadIndex = reinterpret_cast< ptrdiff_t >( id ); const int index = static_cast< int >( threadIndex ); for( unsigned int i = 0; i < loop; i++ ) { ap.Lock(); Loki::ScopeGuard unlockGuard = MakeGuard( &A_Lockable_ptr::Unlock, ap ); (void)unlockGuard; ap->Print( index ); } return 0; } // ---------------------------------------------------------------------------- void * RunLockedStorage( void * id ) { A_Locked_ptr ap( SelfLockedA::GetIt().GetA() ); const ptrdiff_t threadIndex = reinterpret_cast< ptrdiff_t >( id ); const int index = static_cast< int >( threadIndex ); int j = 0; for( unsigned int i = 0; i < loop; i++ ) { ap->Print( index, j ); j++; #ifdef DO_EXTRA_LOKI_TESTS ap->Print( index, j ); j++; A_Locked_ptr ap1( ap ); ap1->Print( index, j ); j++; #endif } return 0; } // ---------------------------------------------------------------------------- void * Run( void * id ) { A_ptr ap( UnsafeA::GetIt().GetA() ); const ptrdiff_t threadIndex = reinterpret_cast< ptrdiff_t >( id ); const int index = static_cast< int >( threadIndex ); for( unsigned int i = 0; i < loop; i++ ) { ap->Print( index ); } return 0; } // ---------------------------------------------------------------------------- void DoLockedPtrTest( void ) { cout << "Doing thread-locked pointer tests." << endl; SafeA::GetIt(); UnsafeA::GetIt(); ::system( "pause" ); { ThreadPool pool; pool.Create( 5, RunLocked ); pool.Start(); pool.Join(); } cout << "Doing thread-unsafe pointer tests." << endl; ::system( "pause" ); { ThreadPool pool; pool.Create( 5, Run ); pool.Start(); pool.Join(); } SafeA::Destroy(); UnsafeA::Destroy(); } // ---------------------------------------------------------------------------- void DoLockedStorageTest( void ) { cout << "Doing LockedStorage tests." << endl; SelfLockedA::GetIt(); ::system( "pause" ); { ThreadPool pool; pool.Create( 5, RunLockedStorage ); pool.Start(); pool.Join(); } ::system( "pause" ); SelfLockedA::Destroy(); } // ---------------------------------------------------------------------------- #endif //#ifdef using multi-threaded model // ---------------------------------------------------------------------------- // $Log$ // Revision 1.4 2006/10/16 11:48:13 syntheticpp // by default Loki is compiled without thread support, so we must disable the dependency on thread classes (StrongPtr) to avaoid linker errors when compiling with the default build process. Should we change the default threading of Loki? // // Revision 1.3 2006/10/14 00:06:15 rich_sposato // Fixed a couple of bugs. Added lines to send test info to output. Added // use of ScopeGuard. Removed superfluous code. // // Revision 1.2 2006/06/08 19:15:27 lfittl // - Simplify some threading code by not saving the return status // (also fixes 2 gcc warnings) // // Revision 1.1 2006/04/28 00:34:21 rich_sposato // Added test for thread-safe StrongPtr policy. // libloki-0.1.7.orig/test/SmartPtr/SmartPtr_MSVC9.vcproj0000644000175000017500000001255711140364657021255 0ustar ivanivan libloki-0.1.7.orig/test/Singleton/0000755000175000017500000000000011140365037015500 5ustar ivanivanlibloki-0.1.7.orig/test/Singleton/Makefile0000644000175000017500000000067210515234750017147 0ustar ivanivaninclude ../Makefile.common BIN1 := Dependencies$(BIN_SUFFIX) SRC1 := Dependencies.cpp OBJ1 := $(SRC1:.cpp=.o) BIN2 := Phoenix$(BIN_SUFFIX) SRC2 := Phoenix.cpp OBJ2 := $(SRC2:.cpp=.o) .PHONY: all clean all: $(BIN1) $(BIN2) clean: cleandeps $(RM) $(BIN1) $(RM) $(OBJ1) $(RM) $(BIN2) $(RM) $(OBJ2) $(BIN1): $(OBJ1) $(CXX) $(LDFLAGS) -o $@ $^ $(LDLIBS) $(BIN2): $(OBJ2) $(CXX) $(LDFLAGS) -o $@ $^ $(LDLIBS) include ../../Makefile.deps libloki-0.1.7.orig/test/Singleton/Singleton_MSVC_8.vcproj0000644000175000017500000000713511047143225021753 0ustar ivanivan libloki-0.1.7.orig/test/Singleton/Singleton_MSVC9.vcproj0000644000175000017500000001232211140364657021617 0ustar ivanivan libloki-0.1.7.orig/test/Singleton/make.msvc.bat0000644000175000017500000000071110515234750020055 0ustar ivanivan :: Phoenix.cpp cl -c -Zm200 -O2 -DNDEBUG -MT -EHsc -GR -W4 -wd4710 -I"." -I"..\..\include" Phoenix.cpp link /NOLOGO /SUBSYSTEM:CONSOLE /incremental:no /OUT:"Phoenix-msvc.exe" ..\..\lib\loki.lib Phoenix.obj :: Dependencies.cpp cl -c -Zm200 -O2 -DNDEBUG -MT -EHsc -GR -W4 -wd4710 -I"." -I"..\..\include" Dependencies.cpp link /NOLOGO /SUBSYSTEM:CONSOLE /incremental:no /OUT:"Dependencies-msvc.exe" ..\..\lib\loki.lib Dependencies.obj del *.obj libloki-0.1.7.orig/test/Singleton/Singleton.cbp0000644000175000017500000000251411047143225020131 0ustar ivanivan libloki-0.1.7.orig/test/Singleton/Singleton.vcproj0000644000175000017500000000723611041560445020677 0ustar ivanivan libloki-0.1.7.orig/test/Singleton/Phoenix.cpp0000644000175000017500000000445410515237275017634 0ustar ivanivan//////////////////////////////////////////////////////////////////////////////// // The Loki Library // Copyright (c) 2005 by Curtis Krauskopf // Copyright (c) 2005 by Peter Kuemmel // // Code covered by the MIT License // The authors make no representations about the suitability of this software // for any purpose. It is provided "as is" without express or implied warranty. //////////////////////////////////////////////////////////////////////////////// // $Id: Phoenix.cpp 760 2006-10-17 20:36:13Z syntheticpp $ // A singleton LogClass object that resurrects itself after // it has been automatically destroyed during program // termination. When a dead-reference to the LogClass // singleton is detected, it is resurrected automatically. // // Expected output: // Example c'tor // LogClass c'tor // LogClass now instantiated. // LogClass d'tor // Example d'tor starting // LogClass c'tor // LogClass: inside Example d'tor // Example d'tor finished // // The last line of the output only appears when this // program is compiled with the ATEXIT_FIXED symbol // defined (see the Loki library and the CUJ article). // #include #include // for Loki::SingletonHolder using namespace std; // okay for small programs using namespace Loki; // okay for small programs class LogClass { public: LogClass() { echo("LogClass c'tor"); } ~LogClass() { echo("LogClass d'tor"); } void echo(const char *s) { cout << s << endl; } }; typedef SingletonHolder LogBook; // A generic example class that stores and echoes a const char. // class Example { public: Example() { echo("Example c'tor"); } ~Example() { echo("Example d'tor starting"); LogBook::Instance().echo("LogClass: inside Example d'tor"); echo("Example d'tor finished"); } void echo(const char *s) { cout << s << endl; } }; int main(int argc, char* argv[]) { Example *example = new Example(); SetLongevity(example, 1, &Loki::Private::Deleter::Delete); LogBook::Instance().echo("LogClass now instantiated."); #if defined(__BORLANDC__) || defined(_MSC_VER) system("PAUSE"); #endif return 0; } libloki-0.1.7.orig/test/Singleton/Dependencies.cpp0000644000175000017500000003223610620052610020570 0ustar ivanivan//////////////////////////////////////////////////////////////////////////////// // The Loki Library // Copyright (c) 2005 Peter Kmmel // 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 authors make no representations about the // suitability of this software for any purpose. It is provided "as is" // without express or implied warranty. //////////////////////////////////////////////////////////////////////////////// // $Id: Dependencies.cpp 823 2007-05-08 10:48:40Z lfittl $ #include #include #include using namespace Loki; //////////////////////////////////////////////////////////////////////////////////// // // Data object for all singletons // //////////////////////////////////////////////////////////////////////////////////// template