Loki Namespace Reference


Classes

class  AbstractFactoryUnit
class  AbstractFactory
class  OpNewFactoryUnit
class  PrototypeFactoryUnit
class  ConcreteFactory
class  AssocVector
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  EvictionException
class  EvictionHelper
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  CacheException
class  CachedFactory
 Factory with caching support. More...
class  DontPropagateConst
class  PropagateConst
class  EmptyType
class  DefaultFactoryError
 Default policy that throws an exception. More...
struct  FactoryImplBase
struct  FactoryImpl< AP, Id, NullType >
struct  FactoryImpl< AP, Id, Seq< P1 > >
struct  FactoryImpl< AP, Id, Seq< P1, P2 > >
struct  FactoryImpl< AP, Id, Seq< P1, P2, P3 > >
struct  FactoryImpl< AP, Id, Seq< P1, P2, P3, P4 > >
struct  FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5 > >
struct  FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6 > >
struct  FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7 > >
struct  FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8 > >
struct  FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9 > >
struct  FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 > >
struct  FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 > >
struct  FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 > >
struct  FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 > >
struct  FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 > >
struct  FactoryImpl< AP, Id, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 > >
class  Factory
class  CloneFactory
 Creates a copy from a polymorphic object. More...
struct  Function< R()>
struct  Function<>
struct  Function< R(P01)>
struct  Function< R(P01, P02)>
struct  Function< R(P01, P02, P03)>
struct  Function< R(P01, P02, P03, P04)>
struct  Function< R(P01, P02, P03, P04, P05)>
struct  Function< R(P01, P02, P03, P04, P05, P06)>
struct  Function< R(P01, P02, P03, P04, P05, P06, P07)>
struct  Function< R(P01, P02, P03, P04, P05, P06, P07, P08)>
struct  Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09)>
struct  Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10)>
struct  Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11)>
struct  Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12)>
struct  Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13)>
struct  Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14)>
struct  Function< R(P01, P02, P03, P04, P05, P06, P07, P08, P09, P10, P11, P12, P13, P14, P15)>
class  FunctorImpl< R, NullType, ThreadingModel >
class  FunctorImpl< R, Seq< P1 >, ThreadingModel >
class  FunctorImpl< R, Seq< P1, P2 >, ThreadingModel >
class  FunctorImpl< R, Seq< P1, P2, P3 >, ThreadingModel >
class  FunctorImpl< R, Seq< P1, P2, P3, P4 >, ThreadingModel >
class  FunctorImpl< R, Seq< P1, P2, P3, P4, P5 >, ThreadingModel >
class  FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6 >, ThreadingModel >
class  FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7 >, ThreadingModel >
class  FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8 >, ThreadingModel >
class  FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9 >, ThreadingModel >
class  FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 >, ThreadingModel >
class  FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 >, ThreadingModel >
class  FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 >, ThreadingModel >
class  FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 >, ThreadingModel >
class  FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 >, ThreadingModel >
class  FunctorImpl< R, Seq< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 >, ThreadingModel >
class  FunctorHandler
class  MemFunHandler
class  Functor
class  BinderFirst
class  Chainer
class  GenScatterHierarchy< Typelist< T1, T2 >, Unit >
class  GenScatterHierarchy
class  GenScatterHierarchy< NullType, Unit >
struct  TupleUnit
struct  Tuple
struct  FieldHelper< H, 0 >
struct  FieldHelper
class  GenLinearHierarchy< Typelist< T1, T2 >, Unit, Root >
class  GenLinearHierarchy< Typelist< T, NullType >, Unit, Root >
class  GenLinearHierarchy< NullType, Unit, Root >
class  Key
class  LockingPtr
class  TypeInfo
class  StaticDispatcher
class  BasicDispatcher
struct  StaticCaster
struct  DynamicCaster
class  FnDispatcher
class  FunctorDispatcher
class  NullType
class  OrderedStatic< L, T, P1(*)() >
class  ConstPropPtr
class  Pimpl
struct  PimplOwner
struct  PimplOf
struct  RimplOf
class  RefToValue
class  RegisterOnCreateSet
class  UnRegisterOnDeleteSet
struct  PrintfState
class  ScopeGuardImplBase
class  ScopeGuardImpl0
class  ScopeGuardImpl1
class  ScopeGuardImpl2
class  ScopeGuardImpl3
class  ScopeGuardImpl4
class  ScopeGuardImpl5
class  ObjScopeGuardImpl0
class  ObjScopeGuardImpl1
class  ObjScopeGuardImpl2
class  ObjScopeGuardImpl3
struct  Seq
struct  Seq<>
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  Locker
class  LockedStorage
class  ArrayStorage
class  RefCounted
struct  RefCountedMTAdj
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
struct  SmartPtrDef
class  SmartPtr
class  FunctionStorage
 Implementation of the StoragePolicy used by SmartPtr. More...
class  SmartPointer
 Encapsulate the object in a SmartPtr with FunctionStorage policy. More...
struct  CompileTimeError< true >
class  DeleteUsingFree
class  DeleteNothing
class  DeleteSingle
class  DeleteArray
class  CantResetWithStrong
class  AllowReset
class  NeverReset
class  TwoRefCounts
class  TwoRefLinks
class  StrongPtr
class  Mutex
class  SingleThreaded
struct  Typelist
struct  Int2Type
struct  Type2Type
struct  Select
struct  Select< false, T, U >
struct  IsSameType
struct  IsSameType< T, T >
struct  Conversion
struct  Conversion< T, T >
struct  Conversion< void, T >
struct  Conversion< T, void >
struct  Conversion< void, void >
struct  SuperSubclass
struct  SuperSubclass< void, void >
struct  SuperSubclass< void, U >
struct  SuperSubclass< T, void >
struct  SuperSubclassStrict
struct  SuperSubclassStrict< void, void >
struct  SuperSubclassStrict< void, U >
struct  SuperSubclassStrict< T, void >
struct  IsCustomUnsignedInt
struct  IsCustomSignedInt
struct  IsCustomFloat
class  TypeTraits
class  BaseVisitor
class  Visitor< T, R, false >
class  Visitor< T, R, true >
class  Visitor< Typelist< Head, Tail >, R, false >
class  Visitor< Typelist< Head, NullType >, R, false >
class  Visitor< Typelist< Head, Tail >, R, true >
class  Visitor< Typelist< Head, NullType >, R, true >
class  BaseVisitorImpl< Typelist< Head, Tail >, R >
class  BaseVisitorImpl< Typelist< Head, NullType >, R >
struct  DefaultCatchAll
class  BaseVisitable< R, CatchAll, false >
class  BaseVisitable< R, CatchAll, true >
class  CyclicVisitor
struct  Chunk
class  FixedAllocator
class  GenScatterHierarchy< Private::ScatterHierarchyTag< T1, T2 >, Unit >
class  OrderedStatic< L, T, Loki::NullType >
class  OrderedStatic< L, T, Loki::Seq< P1 > >
struct  FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::NullType >>
class  FunctorImpl< R,::Loki::Typelist< P1,::Loki::NullType >, ThreadingModel >
struct  FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::NullType > >>
class  FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::NullType > >, ThreadingModel >
struct  FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::NullType > > >>
class  FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::NullType > > >, ThreadingModel >
struct  FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::NullType > > > >>
class  FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::NullType > > > >, ThreadingModel >
struct  FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::NullType > > > > >>
class  FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::NullType > > > > >, ThreadingModel >
struct  FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::Typelist< P6,::Loki::NullType > > > > > >>
class  FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::Typelist< P6,::Loki::NullType > > > > > >, ThreadingModel >
struct  FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::Typelist< P6,::Loki::Typelist< P7,::Loki::NullType > > > > > > >>
class  FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::Typelist< P6,::Loki::Typelist< P7,::Loki::NullType > > > > > > >, ThreadingModel >
struct  FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::Typelist< P6,::Loki::Typelist< P7,::Loki::Typelist< P8,::Loki::NullType > > > > > > > >>
class  FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::Typelist< P6,::Loki::Typelist< P7,::Loki::Typelist< P8,::Loki::NullType > > > > > > > >, ThreadingModel >
struct  FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::Typelist< P6,::Loki::Typelist< P7,::Loki::Typelist< P8,::Loki::Typelist< P9,::Loki::NullType > > > > > > > > >>
class  FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::Typelist< P6,::Loki::Typelist< P7,::Loki::Typelist< P8,::Loki::Typelist< P9,::Loki::NullType > > > > > > > > >, ThreadingModel >
struct  FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::Typelist< P6,::Loki::Typelist< P7,::Loki::Typelist< P8,::Loki::Typelist< P9,::Loki::Typelist< P10,::Loki::NullType > > > > > > > > > >>
class  FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::Typelist< P6,::Loki::Typelist< P7,::Loki::Typelist< P8,::Loki::Typelist< P9,::Loki::Typelist< P10,::Loki::NullType > > > > > > > > > >, ThreadingModel >
struct  FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::Typelist< P6,::Loki::Typelist< P7,::Loki::Typelist< P8,::Loki::Typelist< P9,::Loki::Typelist< P10,::Loki::Typelist< P11,::Loki::NullType > > > > > > > > > > >>
class  FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::Typelist< P6,::Loki::Typelist< P7,::Loki::Typelist< P8,::Loki::Typelist< P9,::Loki::Typelist< P10,::Loki::Typelist< P11,::Loki::NullType > > > > > > > > > > >, ThreadingModel >
struct  FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::Typelist< P6,::Loki::Typelist< P7,::Loki::Typelist< P8,::Loki::Typelist< P9,::Loki::Typelist< P10,::Loki::Typelist< P11,::Loki::Typelist< P12,::Loki::NullType > > > > > > > > > > > >>
class  FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::Typelist< P6,::Loki::Typelist< P7,::Loki::Typelist< P8,::Loki::Typelist< P9,::Loki::Typelist< P10,::Loki::Typelist< P11,::Loki::Typelist< P12,::Loki::NullType > > > > > > > > > > > >, ThreadingModel >
struct  FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::Typelist< P6,::Loki::Typelist< P7,::Loki::Typelist< P8,::Loki::Typelist< P9,::Loki::Typelist< P10,::Loki::Typelist< P11,::Loki::Typelist< P12,::Loki::Typelist< P13,::Loki::NullType > > > > > > > > > > > > >>
class  FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::Typelist< P6,::Loki::Typelist< P7,::Loki::Typelist< P8,::Loki::Typelist< P9,::Loki::Typelist< P10,::Loki::Typelist< P11,::Loki::Typelist< P12,::Loki::Typelist< P13,::Loki::NullType > > > > > > > > > > > > >, ThreadingModel >
struct  FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::Typelist< P6,::Loki::Typelist< P7,::Loki::Typelist< P8,::Loki::Typelist< P9,::Loki::Typelist< P10,::Loki::Typelist< P11,::Loki::Typelist< P12,::Loki::Typelist< P13,::Loki::Typelist< P14,::Loki::NullType > > > > > > > > > > > > > >>
class  FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::Typelist< P6,::Loki::Typelist< P7,::Loki::Typelist< P8,::Loki::Typelist< P9,::Loki::Typelist< P10,::Loki::Typelist< P11,::Loki::Typelist< P12,::Loki::Typelist< P13,::Loki::Typelist< P14,::Loki::NullType > > > > > > > > > > > > > >, ThreadingModel >
struct  FactoryImpl< AP, Id,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::Typelist< P6,::Loki::Typelist< P7,::Loki::Typelist< P8,::Loki::Typelist< P9,::Loki::Typelist< P10,::Loki::Typelist< P11,::Loki::Typelist< P12,::Loki::Typelist< P13,::Loki::Typelist< P14,::Loki::Typelist< P15,::Loki::NullType > > > > > > > > > > > > > > >>
class  FunctorImpl< R,::Loki::Typelist< P1,::Loki::Typelist< P2,::Loki::Typelist< P3,::Loki::Typelist< P4,::Loki::Typelist< P5,::Loki::Typelist< P6,::Loki::Typelist< P7,::Loki::Typelist< P8,::Loki::Typelist< P9,::Loki::Typelist< P10,::Loki::Typelist< P11,::Loki::Typelist< P12,::Loki::Typelist< P13,::Loki::Typelist< P14,::Loki::Typelist< P15,::Loki::NullType > > > > > > > > > > > > > > >, ThreadingModel >

Namespaces

namespace  LongevityLifetime
namespace  Private
namespace  TL

Typedefs

typedef Loki::SingletonHolder<
Loki::Private::OrderedStaticManagerClass,
Loki::CreateUsingNew, Loki::NoDestroy,
Loki::SingleThreaded
OrderedStaticManager
typedef const ScopeGuardImplBaseScopeGuard
typedef void(*) atexit_pfn_t ()

Functions

template<class CP, class Base>
void DoGetPrototype (const PrototypeFactoryUnit< CP, Base > &me, typename Base::ProductList::Head *&pPrototype)
template<class CP, class Base>
void DoSetPrototype (PrototypeFactoryUnit< CP, Base > &me, typename Base::ProductList::Head *pObj)
template<class K, class V, class C, class A>
bool operator== (const AssocVector< K, V, C, A > &lhs, const AssocVector< K, V, C, A > &rhs)
template<class K, class V, class C, class A>
bool operator!= (const AssocVector< K, V, C, A > &lhs, const AssocVector< K, V, C, A > &rhs)
template<class K, class V, class C, class A>
bool operator> (const AssocVector< K, V, C, A > &lhs, const AssocVector< K, V, C, A > &rhs)
template<class K, class V, class C, class A>
bool operator>= (const AssocVector< K, V, C, A > &lhs, const AssocVector< K, V, C, A > &rhs)
template<class K, class V, class C, class A>
bool operator<= (const AssocVector< K, V, C, A > &lhs, const AssocVector< K, V, C, A > &rhs)
template<class K, class V, class C, class A>
void swap (AssocVector< K, V, C, A > &lhs, AssocVector< K, V, C, A > &rhs)
bool operator== (const EmptyType &, const EmptyType &)
bool operator< (const EmptyType &, const EmptyType &)
bool operator> (const EmptyType &, const EmptyType &)
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)
template<class T, class H>
H::template Rebind< T >::Result & Field (H &obj)
template<class T, class H>
const H::template Rebind<
T >::Result & 
Field (const H &obj)
template<class F, typename I>
bool operator== (const Key< F, I > &k1, const Key< F, I > &k2)
template<class F, typename I>
bool operator< (const Key< F, I > &k1, const Key< F, I > &k2)
bool operator== (const TypeInfo &lhs, const TypeInfo &rhs)
bool operator< (const TypeInfo &lhs, const TypeInfo &rhs)
bool operator!= (const TypeInfo &lhs, const TypeInfo &rhs)
bool operator> (const TypeInfo &lhs, const TypeInfo &rhs)
bool operator<= (const TypeInfo &lhs, const TypeInfo &rhs)
bool operator>= (const TypeInfo &lhs, const TypeInfo &rhs)
template<class T>
RefToValue< T > ByRef (T &t)
template<class t>
bool RegisterFunction ()
template<class t>
bool UnRegisterFunction ()
LOKI_EXPORT void write (std::FILE *f, const char *from, const char *to)
LOKI_EXPORT void write (std::ostream &f, const char *from, const char *to)
LOKI_EXPORT void write (std::string &s, const char *from, const char *to)
template<class Char>
void write (std::pair< Char *, std::size_t > &s, const Char *from, const Char *to)
LOKI_EXPORT PrintfState< std::FILE *,
char > 
Printf (const char *format)
LOKI_EXPORT PrintfState< std::FILE *,
char > 
Printf (const std::string &format)
LOKI_EXPORT PrintfState< std::FILE *,
char > 
FPrintf (std::FILE *f, const char *format)
LOKI_EXPORT PrintfState< std::FILE *,
char > 
FPrintf (std::FILE *f, const std::string &format)
LOKI_EXPORT PrintfState< std::ostream &,
char > 
FPrintf (std::ostream &f, const char *format)
LOKI_EXPORT PrintfState< std::ostream &,
char > 
FPrintf (std::ostream &f, const std::string &format)
LOKI_EXPORT PrintfState< std::string &,
char > 
SPrintf (std::string &s, const char *format)
LOKI_EXPORT PrintfState< std::string &,
char > 
SPrintf (std::string &s, const std::string &format)
template<class T, class Char>
PrintfState< T &, Char > XPrintf (T &device, const Char *format)
template<class T>
PrintfState< T &, char > XPrintf (T &device, const std::string &format)
template<class Char, std::size_t N>
PrintfState< std::pair< Char *,
std::size_t >, Char > 
BufPrintf (Char(&buf)[N], const Char *format)
template<typename F>
ScopeGuardImpl0< F > MakeGuard (F fun)
template<typename F, typename P1>
ScopeGuardImpl1< F, P1 > MakeGuard (F fun, P1 p1)
template<typename F, typename P1, typename P2>
ScopeGuardImpl2< F, P1, P2 > MakeGuard (F fun, P1 p1, P2 p2)
template<typename F, typename P1, typename P2, typename P3>
ScopeGuardImpl3< F, P1, P2,
P3 > 
MakeGuard (F fun, P1 p1, P2 p2, P3 p3)
template<typename F, typename P1, typename P2, typename P3, typename P4>
ScopeGuardImpl4< F, P1, P2,
P3, P4 > 
MakeGuard (F fun, P1 p1, P2 p2, P3 p3, P4 p4)
template<typename F, typename P1, typename P2, typename P3, typename P4, typename P5>
ScopeGuardImpl5< F, P1, P2,
P3, P4, P5 > 
MakeGuard (F fun, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
template<class Obj, typename MemFun>
ObjScopeGuardImpl0< Obj, MemFun > MakeObjGuard (Obj &obj, MemFun memFun)
template<typename Ret, class Obj1, class Obj2>
ObjScopeGuardImpl0< Obj1,
Ret(Obj2::*)()> 
MakeGuard (Ret(Obj2::*memFun)(), Obj1 &obj)
template<typename Ret, class Obj1, class Obj2>
ObjScopeGuardImpl0< Obj1,
Ret(Obj2::*)()> 
MakeGuard (Ret(Obj2::*memFun)(), Obj1 *obj)
template<class Obj, typename MemFun, typename P1>
ObjScopeGuardImpl1< Obj, MemFun,
P1 > 
MakeObjGuard (Obj &obj, MemFun memFun, P1 p1)
template<typename Ret, class Obj1, class Obj2, typename P1a, typename P1b>
ObjScopeGuardImpl1< Obj1,
Ret(Obj2::*)(P1a), P1b > 
MakeGuard (Ret(Obj2::*memFun)(P1a), Obj1 &obj, P1b p1)
template<typename Ret, class Obj1, class Obj2, typename P1a, typename P1b>
ObjScopeGuardImpl1< Obj1,
Ret(Obj2::*)(P1a), P1b > 
MakeGuard (Ret(Obj2::*memFun)(P1a), Obj1 *obj, P1b p1)
template<class Obj, typename MemFun, typename P1, typename P2>
ObjScopeGuardImpl2< Obj, MemFun,
P1, P2 > 
MakeObjGuard (Obj &obj, MemFun memFun, P1 p1, P2 p2)
template<typename Ret, class Obj1, class Obj2, typename P1a, typename P1b, typename P2a, typename P2b>
ObjScopeGuardImpl2< Obj1,
Ret(Obj2::*)(P1a, P2a), P1b,
P2b > 
MakeGuard (Ret(Obj2::*memFun)(P1a, P2a), Obj1 &obj, P1b p1, P2b p2)
template<typename Ret, class Obj1, class Obj2, typename P1a, typename P1b, typename P2a, typename P2b>
ObjScopeGuardImpl2< Obj1,
Ret(Obj2::*)(P1a, P2a), P1b,
P2b > 
MakeGuard (Ret(Obj2::*memFun)(P1a, P2a), Obj1 *obj, P1b p1, P2b p2)
template<class Obj, typename MemFun, typename P1, typename P2, typename P3>
ObjScopeGuardImpl3< Obj, MemFun,
P1, P2, P3 > 
MakeObjGuard (Obj &obj, MemFun memFun, P1 p1, P2 p2, P3 p3)
template<typename Ret, class Obj1, class Obj2, typename P1a, typename P1b, typename P2a, typename P2b, typename P3a, typename P3b>
ObjScopeGuardImpl3< Obj1,
Ret(Obj2::*)(P1a, P2a, P3a),
P1b, P2b, P3b > 
MakeGuard (Ret(Obj2::*memFun)(P1a, P2a, P3a), Obj1 &obj, P1b p1, P2b p2, P3b p3)
template<typename Ret, class Obj1, class Obj2, typename P1a, typename P1b, typename P2a, typename P2b, typename P3a, typename P3b>
ObjScopeGuardImpl3< Obj1,
Ret(Obj2::*)(P1a, P2a, P3a),
P1b, P2b, P3b > 
MakeGuard (Ret(Obj2::*memFun)(P1a, P2a, P3a), Obj1 *obj, P1b p1, P2b p2, P3b p3)
template<typename T, typename Destroyer>
void SetLongevity (T *pDynObject, unsigned int longevity, Destroyer d)
template<typename T>
void SetLongevity (T *pDynObject, unsigned int longevity, typename Private::Deleter< T >::Type d=Private::Deleter< T >::Delete)
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<class T>
HeapStorage< T >::PointerType GetImpl (const HeapStorage< T > &sp)
template<class T>
const HeapStorage< T >::StoredType & GetImplRef (const HeapStorage< T > &sp)
template<class T>
HeapStorage< T >::StoredType & GetImplRef (HeapStorage< T > &sp)
template<class T>
DefaultSPStorage< T >::PointerType GetImpl (const DefaultSPStorage< T > &sp)
template<class T>
const DefaultSPStorage< T
>::StoredType & 
GetImplRef (const DefaultSPStorage< T > &sp)
template<class T>
DefaultSPStorage< T >::StoredType & GetImplRef (DefaultSPStorage< T > &sp)
template<class T>
LockedStorage< T >::InitPointerType GetImpl (const LockedStorage< T > &sp)
template<class T>
const LockedStorage< T
>::StoredType & 
GetImplRef (const LockedStorage< T > &sp)
template<class T>
LockedStorage< T >::StoredType & GetImplRef (LockedStorage< T > &sp)
template<class T>
ArrayStorage< T >::PointerType GetImpl (const ArrayStorage< T > &sp)
template<class T>
const ArrayStorage< T >::StoredType & GetImplRef (const ArrayStorage< T > &sp)
template<class T>
ArrayStorage< T >::StoredType & GetImplRef (ArrayStorage< T > &sp)
template<typename T, template< class > class OP, class CP, template< class > class KP, template< class > class SP, template< class > class CNP>
void Release (SmartPtr< T, OP, CP, KP, SP, CNP > &sp, typename SP< T >::StoredType &p)
template<typename T, template< class > class OP, class CP, template< class > class KP, template< class > class SP, template< class > class CNP>
void Reset (SmartPtr< T, OP, CP, KP, SP, CNP > &sp, typename SP< T >::StoredType p)
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<class T>
FunctionStorage< T >::PointerType GetImpl (const FunctionStorage< T > &sp)
template<class T>
const FunctionStorage< T
>::StoredType & 
GetImplRef (const FunctionStorage< T > &sp)
template<class T>
FunctionStorage< T >::StoredType & GetImplRef (FunctionStorage< T > &sp)
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 ReleaseAll (StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > &sp, typename StrongPtr< T, S, OP, CP, KP, RP, DP, CNP >::StoredType &p)
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 ResetAll (StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > &sp, typename StrongPtr< T, S, OP, CP, KP, RP, DP, CNP >::StoredType p)
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> (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)
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


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>
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.

Definition at line 331 of file SmallObj.h.

Referenced by Loki::SingletonWithLongevity< T >::ScheduleDestruction().


Generated on Sun Feb 25 16:52:33 2007 for Loki by  doxygen 1.5.1-p1